大模型应用：拆解大模型算力需求：算力是什么？怎么衡量？如何匹配？.64

import torch
import GPUtil
import time
import matplotlib.pyplot as plt
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

# 实时监控显卡状态
def monitor_gpu(interval=0.5, duration=10):
    """
    监控GPU算力利用率与显存占用
    interval: 采样间隔（秒）
    duration: 监控时长（秒）
    """
    gpu = GPUtil.getGPUs()[0]
    times = []
    gpu_utils = []
    gpu_mems = []
    
    start_time = time.time()
    while time.time() - start_time < duration:
        times.append(time.time() - start_time)
        gpu_utils.append(gpu.load * 100)  # 算力利用率（%）
        gpu_mems.append(gpu.memoryUsed / gpu.memoryTotal * 100)  # 显存占用率（%）
        time.sleep(interval)
    
    return times, gpu_utils, gpu_mems

# 加载模型并监控（以RTX 4090运行13B INT8模型为例）
bnb_config = BitsAndBytesConfig(
    load_in_8bit=True,
    bnb_8bit_compute_dtype=torch.float16
)

model = AutoModelForCausalLM.from_pretrained(
    "Qwen-13B-Chat",
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True
)
tokenizer = AutoTokenizer.from_pretrained("Qwen-13B-Chat", trust_remote_code=True)

# 开始监控并运行模型
print("开始监控GPU状态...")
times, gpu_utils, gpu_mems = monitor_gpu(duration=15)

# 运行模型生成任务
inputs = tokenizer("用Python实现大模型算力监控脚本", return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens=200)
print("生成完成：", tokenizer.decode(outputs[0], skip_special_tokens=True))

# 生成监控趋势图
plt.rcParams['font.sans-serif'] = ['SimHei', 'Arial Unicode MS']
plt.figure(figsize=(12, 7))
ax1 = plt.gca()
ax2 = ax1.twinx()

ax1.plot(times, gpu_utils, 'r-', label='算力利用率（%）')
ax2.plot(times, gpu_mems, 'b-', label='显存占用率（%）')

ax1.set_xlabel('时间（秒）', fontsize=12)
ax1.set_ylabel('算力利用率（%）', fontsize=12, color='r')
ax2.set_ylabel('显存占用率（%）', fontsize=12, color='b')
ax1.tick_params(axis='y', labelcolor='r')
ax2.tick_params(axis='y', labelcolor='b')

plt.title('RTX 4090运行13B INT8模型时算力与显存监控', fontsize=14, fontweight='bold')
ax1.legend(loc='upper left')
ax2.legend(loc='upper right')
ax1.grid(alpha=0.3)
plt.tight_layout()

plt.close()

# 输出监控结果
print(f"\n平均算力利用率：{np.mean(gpu_utils):.2f}%")
print(f"平均显存占用率：{np.mean(gpu_mems):.2f}%")

import torch
import time
import matplotlib.pyplot as plt
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

# 测试不同量化精度的优化效果
def test_quantization_effect(model_path):
    tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
    inputs = tokenizer("分析大模型量化对算力和速度的影响", return_tensors="pt")
    results = []
    
    # 1. FP16精度（基准）
    print("测试FP16精度...")
    model_fp16 = AutoModelForCausalLM.from_pretrained(
        model_path,
        torch_dtype=torch.float16,
        device_map="auto",
        trust_remote_code=True
    )
    start_time = time.time()
    outputs = model_fp16.generate(**inputs.to("cuda"), max_new_tokens=150)
    fp16_time = time.time() - start_time
    fp16_speed = 150 / fp16_time  # 字/秒
    results.append(("FP16", fp16_speed, fp16_time))
    del model_fp16
    torch.cuda.empty_cache()
    
    # 2. INT8量化
    print("测试INT8量化...")
    bnb_config_int8 = BitsAndBytesConfig(load_in_8bit=True)
    model_int8 = AutoModelForCausalLM.from_pretrained(
        model_path,
        quantization_config=bnb_config_int8,
        device_map="auto",
        trust_remote_code=True
    )
    start_time = time.time()
    outputs = model_int8.generate(**inputs.to("cuda"), max_new_tokens=150)
    int8_time = time.time() - start_time
    int8_speed = 150 / int8_time
    results.append(("INT8", int8_speed, int8_time))
    del model_int8
    torch.cuda.empty_cache()
    
    # 3. INT4量化
    print("测试INT4量化...")
    bnb_config_int4 = BitsAndBytesConfig(
        load_in_4bit=True,
        bnb_4bit_quant_type="nf4",
        bnb_4bit_compute_dtype=torch.float16
    )
    model_int4 = AutoModelForCausalLM.from_pretrained(
        model_path,
        quantization_config=bnb_config_int4,
        device_map="auto",
        trust_remote_code=True
    )
    start_time = time.time()
    outputs = model_int4.generate(**inputs.to("cuda"), max_new_tokens=150)
    int4_time = time.time() - start_time
    int4_speed = 150 / int4_time
    results.append(("INT4", int4_speed, int4_time))
    del model_int4
    torch.cuda.empty_cache()
    
    return results

# 运行测试（以7B模型为例，适配RTX 4090）
model_path = "Qwen-7B-Chat"
results = test_quantization_effect(model_path)

# 输出测试结果
print("\n量化优化效果对比：")
for prec, speed, time_cost in results:
    print(f"{prec}：生成速度{speed:.2f}字/秒，耗时{time_cost:.2f}秒")

# 生成优化效果对比图
plt.rcParams['font.sans-serif'] = ['SimHei', 'Arial Unicode MS']
plt.figure(figsize=(10, 6))
precisions = [r[0] for r in results]
speeds = [r[1] for r in results]

plt.bar(precisions, speeds, color=['#FF6B6B', '#4ECDC4', '#45B7D1'])
plt.xlabel('量化精度', fontsize=12)
plt.ylabel('生成速度（字/秒）', fontsize=12)
plt.title('不同量化精度的算力优化效果对比（RTX 4090运行7B模型）', fontsize=14, fontweight='bold')
plt.grid(axis='y', alpha=0.3)

# 在柱状图上标注数值
for i, v in enumerate(speeds):
    plt.text(i, v+0.5, f'{v:.2f}', ha='center', va='bottom', fontsize=11)

plt.tight_layout()
plt.close()

import torch
import GPUtil
import time
import matplotlib.pyplot as plt
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from accelerate import Accelerator

# 初始化多卡加速器
accelerator = Accelerator()
device = accelerator.device

# 监控双卡负载状态
def monitor_dual_gpu(interval=0.5, duration=10):
    gpus = GPUtil.getGPUs()
    times = []
    gpu1_utils = []
    gpu2_utils = []
    gpu1_mems = []
    gpu2_mems = []
    
    start_time = time.time()
    while time.time() - start_time < duration:
        times.append(time.time() - start_time)
        gpu1_utils.append(gpus[0].load * 100)
        gpu2_utils.append(gpus[1].load * 100)
        gpu1_mems.append(gpus[0].memoryUsed / gpus[0].memoryTotal * 100)
        gpu2_mems.append(gpus[1].memoryUsed / gpus[1].memoryTotal * 100)
        time.sleep(interval)
    
    return times, gpu1_utils, gpu2_utils, gpu1_mems, gpu2_mems

# 加载70B INT4模型（双卡部署）
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16
)

model = AutoModelForCausalLM.from_pretrained(
    "Qwen-72B-Chat",
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True,
    max_memory={0: "22GB", 1: "22GB"}  # 预留显存，适配多卡调度
)
tokenizer = AutoTokenizer.from_pretrained("Qwen-72B-Chat", trust_remote_code=True)

# 适配多卡加速器
model = accelerator.prepare_model(model)

# 监控双卡负载并运行模型
print("开始监控双卡负载...")
times, gpu1_utils, gpu2_utils, gpu1_mems, gpu2_mems = monitor_dual_gpu(duration=20)

# 运行生成任务
inputs = tokenizer("讲解大模型双卡分片的算力均衡逻辑", return_tensors="pt").to(device)
outputs = model.generate(**inputs, max_new_tokens=150)
print("生成完成：", tokenizer.decode(outputs[0], skip_special_tokens=True))

# 生成双卡负载对比图
plt.rcParams['font.sans-serif'] = ['SimHei', 'Arial Unicode MS']
plt.figure(figsize=(12, 10))

# 子图1：算力利用率对比
plt.subplot(2, 1, 1)
plt.plot(times, gpu1_utils, 'r-', label='RTX 4090-0 算力利用率')
plt.plot(times, gpu2_utils, 'b-', label='RTX 4090-1 算力利用率')
plt.xlabel('时间（秒）', fontsize=12)
plt.ylabel('算力利用率（%）', fontsize=12)
plt.title('RTX 4090双卡部署70B INT4模型算力负载对比', fontsize=14, fontweight='bold')
plt.legend()
plt.grid(alpha=0.3)

# 子图2：显存占用率对比
plt.subplot(2, 1, 2)
plt.plot(times, gpu1_mems, 'r--', label='RTX 4090-0 显存占用率')
plt.plot(times, gpu2_mems, 'b--', label='RTX 4090-1 显存占用率')
plt.xlabel('时间（秒）', fontsize=12)
plt.ylabel('显存占用率（%）', fontsize=12)
plt.legend()
plt.grid(alpha=0.3)

plt.tight_layout()
plt.savefig('dual_gpu_load.png', dpi=300, bbox_inches='tight')
plt.close()

# 输出负载均衡结果
print(f"\nRTX 4090-0 平均算力利用率：{sum(gpu1_utils)/len(gpu1_utils):.2f}%")
print(f"RTX 4090-1 平均算力利用率：{sum(gpu2_utils)/len(gpu2_utils):.2f}%")
print(f"算力负载差：{abs(sum(gpu1_utils)-sum(gpu2_utils))/len(gpu1_utils):.2f}%（越小越均衡）")