02 - 低精度推理¶

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

def fp16_inference(model_name="meta-llama/Llama-2-7b-hf"):
    """
    FP16推理示例

    Args:
        model_name: 模型名称或路径
    """
    # 加载分词器
    tokenizer = AutoTokenizer.from_pretrained(model_name)

    # 加载FP16模型
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        torch_dtype=torch.float16,
        device_map="auto"
    )

    # 推理
    prompt = "请介绍一下人工智能的发展历程"
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

    with torch.no_grad():  # 禁用梯度计算，节省内存
        outputs = model.generate(
            **inputs,
            max_length=200,
            do_sample=True,
            temperature=0.7
        )

    result = tokenizer.decode(outputs[0], skip_special_tokens=True)
    print(result)

    return model, tokenizer

# 使用示例
# model, tokenizer = fp16_inference()

import torch
from torch.amp import autocast

def optimized_fp16_inference(model, tokenizer, prompt):
    """
    优化的FP16推理

    Args:
        model: FP16模型
        tokenizer: 分词器
        prompt: 输入提示
    """
    model.eval()  # eval()评估模式

    # 使用自动混合精度
    with torch.no_grad(), autocast('cuda'):
        inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
        outputs = model.generate(
            **inputs,
            max_length=200,
            do_sample=True,
            temperature=0.7
        )

    result = tokenizer.decode(outputs[0], skip_special_tokens=True)
    return result

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

def bf16_inference(model_name="meta-llama/Llama-2-7b-hf"):
    """
    BF16推理示例

    Args:
        model_name: 模型名称或路径
    """
    # 加载分词器
    tokenizer = AutoTokenizer.from_pretrained(model_name)

    # 加载BF16模型
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        torch_dtype=torch.bfloat16,
        device_map="auto"
    )

    # 推理
    prompt = "请介绍一下人工智能的发展历程"
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_length=200,
            do_sample=True,
            temperature=0.7
        )

    result = tokenizer.decode(outputs[0], skip_special_tokens=True)
    print(result)

    return model, tokenizer

import torch
import torch.quantization

def int8_quantization(model, dataloader):
    """
    INT8量化

    Args:
        model: 要量化的模型
        dataloader: 用于校准的数据加载器
    """
    # 设置模型为评估模式
    model.eval()

    # 配置量化
    # 注意：'fbgemm'用于x86 CPU，'qnnpack'用于ARM CPU
    # PyTorch 1.13+ 推荐使用 torch.ao.quantization.get_default_qconfig('x86')
    # 或使用 torch.ao.quantization.get_default_qconfig_mapping() 获得更灵活的配置
    model.qconfig = torch.quantization.get_default_qconfig('fbgemm')  # 兼容旧版本

    # 准备量化
    model_prepared = torch.quantization.prepare(model)

    # 使用校准数据进行校准
    print("开始校准...")
    with torch.no_grad():
        for batch_x, _ in dataloader:
            model_prepared(batch_x)

    # 转换为量化模型
    print("转换为量化模型...")
    quantized_model = torch.quantization.convert(model_prepared)

    return quantized_model

# 使用示例
# quantized_model = int8_quantization(model, dataloader)

import torch
import torch.quantization

def dynamic_int8_quantization(model):
    """
    动态INT8量化

    动态量化在推理时动态计算激活值的量化参数，
    不需要校准数据。

    Args:
        model: 要量化的模型
    """
    # 设置模型为评估模式
    model.eval()

    # 动态量化
    quantized_model = torch.quantization.quantize_dynamic(
        model,
        {torch.nn.Linear},  # 只量化线性层
        dtype=torch.qint8
    )

    return quantized_model

# 使用示例
# quantized_model = dynamic_int8_quantization(model)

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",  # 使用NF4而非FP4
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True
)

bnb_4bit_use_double_quant=True  # 进一步压缩量化参数

bnb_4bit_compute_dtype=torch.float16  # 或torch.bfloat16

from peft import LoraConfig, get_peft_model

# 在INT4量化基础上添加LoRA适配器
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05,
    bias="none"
)
model = get_peft_model(model, lora_config)

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

def int4_quantization(model_name="meta-llama/Llama-2-7b-hf"):
    """
    INT4量化（推荐使用NF4）

    Args:
        model_name: 模型名称或路径
    """
    # 加载分词器
    tokenizer = AutoTokenizer.from_pretrained(model_name)

    # 配置INT4量化
    quantization_config = BitsAndBytesConfig(
        load_in_4bit=True,  # 启用4位量化
        bnb_4bit_compute_dtype=torch.float16,  # 计算数据类型：FP16
        bnb_4bit_use_double_quant=True,  # 启用双重量化
        bnb_4bit_quant_type="nf4"  # 使用NF4量化类型（推荐）
    )

    # 加载量化模型
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        quantization_config=quantization_config,
        device_map="auto"
    )

    print(f"模型量化完成！")
    print(f"模型大小: {model.get_memory_footprint() / 1e9:.2f} GB")

    return model, tokenizer

# 使用示例
# model, tokenizer = int4_quantization()

from transformers import BitsAndBytesConfig

def create_int4_config():
    """
    创建INT4量化配置

    返回：
        BitsAndBytesConfig: INT4量化配置对象
    """
    quantization_config = BitsAndBytesConfig(
        # ========== 基础配置 ==========
        load_in_4bit=True,  # 启用4位量化

        # ========== 量化类型选择 ==========
        # "nf4": NormalFloat4（推荐，针对神经网络优化）
        # "fp4": Float4（传统浮点数表示）
        bnb_4bit_quant_type="nf4",

        # ========== 计算数据类型 ==========
        # torch.float16: 16位浮点数（速度更快，适合推理）
        # torch.bfloat16: 16位脑浮点数（数值范围更大，适合训练）
        bnb_4bit_compute_dtype=torch.float16,

        # ========== 双重量化 ==========
        # True: 对量化参数进行二次量化，进一步减少内存
        # False: 不使用双重量化
        bnb_4bit_use_double_quant=True,

        # ========== 其他高级配置 ==========
        # llm_int8_threshold: INT8量化的异常值阈值（默认6.0）
        # llm_int8_skip_modules: 跳过量化的模块列表
        # llm_int8_enable_fp32_cpu_offload: 启用FP32 CPU卸载
    )

    return quantization_config

# 使用示例
# config = create_int4_config()
# model = AutoModelForCausalLM.from_pretrained(
#     model_name,
#     quantization_config=config,
#     device_map="auto"
# )

from transformers import BitsAndBytesConfig
import torch

def compare_quantization_types():
    """
    对比不同INT4量化类型的配置
    """
    configs = {
        "NF4（推荐）": BitsAndBytesConfig(
            load_in_4bit=True,
            bnb_4bit_compute_dtype=torch.float16,
            bnb_4bit_use_double_quant=True,
            bnb_4bit_quant_type="nf4"
        ),
        "FP4": BitsAndBytesConfig(
            load_in_4bit=True,
            bnb_4bit_compute_dtype=torch.float16,
            bnb_4bit_use_double_quant=True,
            bnb_4bit_quant_type="fp4"
        ),
        "NF4 + BF16": BitsAndBytesConfig(
            load_in_4bit=True,
            bnb_4bit_compute_dtype=torch.bfloat16,
            bnb_4bit_use_double_quant=True,
            bnb_4bit_quant_type="nf4"
        ),
        "NF4 + 无双重量化": BitsAndBytesConfig(
            load_in_4bit=True,
            bnb_4bit_compute_dtype=torch.float16,
            bnb_4bit_use_double_quant=False,
            bnb_4bit_quant_type="nf4"
        )
    }

    for name, config in configs.items():
        print(f"{name}:")
        print(f"  - 量化类型: {config.bnb_4bit_quant_type}")
        print(f"  - 计算类型: {config.bnb_4bit_compute_dtype}")
        print(f"  - 双重量化: {config.bnb_4bit_use_double_quant}")
        print()

    return configs

# 使用示例
# configs = compare_quantization_types()

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

def mixed_precision_inference(model_name="meta-llama/Llama-2-7b-hf"):
    """
    混合精度推理

    Args:
        model_name: 模型名称或路径
    """
    # 加载分词器
    tokenizer = AutoTokenizer.from_pretrained(model_name)

    # 配置混合精度（使用INT4量化）
    quantization_config = BitsAndBytesConfig(
        load_in_4bit=True,  # 启用4位量化
        bnb_4bit_compute_dtype=torch.float16,  # 计算数据类型：FP16
        bnb_4bit_use_double_quant=True,  # 启用双重量化
        bnb_4bit_quant_type="nf4"  # 使用NF4量化类型（推荐）
    )

    # 加载模型
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        quantization_config=quantization_config,
        torch_dtype=torch.float16,
        device_map="auto"
    )

    # 推理
    prompt = "请介绍一下人工智能的发展历程"
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_length=200,
            do_sample=True,
            temperature=0.7
        )

    result = tokenizer.decode(outputs[0], skip_special_tokens=True)
    print(result)

    return model, tokenizer

import torch
import torch.nn as nn

class MixedPrecisionModel(nn.Module):  # 继承nn.Module定义网络层
    """
    自定义混合精度模型
    """
    def __init__(self, input_size, hidden_size, output_size):
        super().__init__()  # super()调用父类方法
        # 输入层使用FP32
        self.input_layer = nn.Linear(input_size, hidden_size).float()

        # 隐藏层使用FP16
        self.hidden_layer = nn.Linear(hidden_size, hidden_size).half()

        # 输出层使用FP32
        self.output_layer = nn.Linear(hidden_size, output_size).float()

        self.relu = nn.ReLU()

    def forward(self, x):
        # FP32
        x = self.input_layer(x)
        x = self.relu(x)

        # FP16
        x = x.half()
        x = self.hidden_layer(x)
        x = self.relu(x)

        # FP32
        x = x.float()
        x = self.output_layer(x)

        return x

# 使用示例
# model = MixedPrecisionModel(784, 256, 10)

import torch
import time
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

class PerformanceBenchmark:
    """
    性能基准测试
    """
    def __init__(self, model_name):
        self.model_name = model_name
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.results = {}

    def load_model(self, precision="fp32"):
        """
        加载不同精度的模型

        Args:
            precision: 精度类型 ("fp32", "fp16", "int8", "int4")
        """
        if precision == "fp32":
            model = AutoModelForCausalLM.from_pretrained(
                self.model_name,
                device_map="auto"
            )
        elif precision == "fp16":
            model = AutoModelForCausalLM.from_pretrained(
                self.model_name,
                torch_dtype=torch.float16,
                device_map="auto"
            )
        elif precision == "int8":
            quantization_config = BitsAndBytesConfig(
                load_in_8bit=True
            )
            model = AutoModelForCausalLM.from_pretrained(
                self.model_name,
                quantization_config=quantization_config,
                device_map="auto"
            )
        elif precision == "int4":
            # INT4量化配置（推荐使用NF4）
            quantization_config = BitsAndBytesConfig(
                load_in_4bit=True,  # 启用4位量化
                bnb_4bit_compute_dtype=torch.float16,  # 计算数据类型：FP16
                bnb_4bit_use_double_quant=True,  # 启用双重量化
                bnb_4bit_quant_type="nf4"  # 使用NF4量化类型（推荐）
            )
            model = AutoModelForCausalLM.from_pretrained(
                self.model_name,
                quantization_config=quantization_config,
                device_map="auto"
            )
        else:
            raise ValueError(f"Unknown precision: {precision}")

        return model

    def benchmark(self, model, prompt, num_runs=10):
        """
        运行基准测试

        Args:
            model: 要测试的模型
            prompt: 测试提示
            num_runs: 运行次数
        """
        model.eval()
        inputs = self.tokenizer(prompt, return_tensors="pt").to(model.device)

        # 预热
        with torch.no_grad():
            _ = model.generate(**inputs, max_length=50)

        # 测试
        times = []
        with torch.no_grad():
            for _ in range(num_runs):
                start = time.time()
                _ = model.generate(**inputs, max_length=50)
                end = time.time()
                times.append(end - start)

        avg_time = sum(times) / len(times)
        memory = model.get_memory_footprint() / 1e9

        return {
            "avg_time": avg_time,
            "memory": memory,
            "tokens_per_second": 50 / avg_time
        }

    def compare_precisions(self, prompt="Hello, how are you?"):
        """
        对比不同精度的性能
        """
        precisions = ["fp32", "fp16", "int8", "int4"]

        print("开始性能对比测试...")
        print(f"测试提示: {prompt}\n")

        for precision in precisions:
            print(f"加载 {precision.upper()} 模型...")
            model = self.load_model(precision)

            print(f"运行 {precision.upper()} 基准测试...")
            results = self.benchmark(model, prompt)

            self.results[precision] = results

            print(f"{precision.upper()} 结果:")
            print(f"  平均时间: {results['avg_time']:.4f}s")
            print(f"  内存占用: {results['memory']:.2f} GB")
            print(f"  生成速度: {results['tokens_per_second']:.2f} tokens/s")
            print()

        return self.results

# 使用示例
# benchmark = PerformanceBenchmark("meta-llama/Llama-2-7b-hf")
# results = benchmark.compare_precisions()

# 将Hugging Face模型转换为GGUF格式
# 需要使用llama.cpp的转换脚本

# 步骤1: 克隆llama.cpp
# git clone https://github.com/ggerganov/llama.cpp
# cd llama.cpp
# pip install -r requirements.txt

# 步骤2: 下载原始模型
# from huggingface_hub import snapshot_download
# snapshot_download("meta-llama/Llama-2-7b-hf", local_dir="./llama2-7b")

# 步骤3: 转换为GGUF（FP16）
# python convert-hf-to-gguf.py ./llama2-7b --outfile llama2-7b-f16.gguf --outtype f16

# 步骤4: 量化（例如Q4_K_M）
# ./llama-quantize llama2-7b-f16.gguf llama2-7b-q4_k_m.gguf Q4_K_M

import subprocess
import json

def run_llama_cpp(model_path, prompt, n_predict=128, temp=0.7):
    """
    使用llama.cpp运行GGUF模型

    Args:
        model_path: GGUF模型路径
        prompt: 输入提示
        n_predict: 生成的token数量
        temp: 温度参数
    """
    cmd = [
        "./llama-cli",  # llama.cpp主程序
        "-m", model_path,
        "-p", prompt,
        "-n", str(n_predict),
        "--temp", str(temp),
        "-ngl", "99",  # GPU层数（99表示全部）
        "-c", "4096",  # 上下文长度
        "-b", "512",   # 批处理大小
        "--no-display-prompt"
    ]

    result = subprocess.run(cmd, capture_output=True, text=True)
    return result.stdout

# 使用示例
# output = run_llama_cpp(
#     "./models/llama2-7b-q4_k_m.gguf",
#     "请介绍一下人工智能的发展历程"
# )
# print(output)

from llama_cpp import Llama

def llama_cpp_python_example():
    """
    使用llama-cpp-python库进行推理
    """
    # 加载模型
    llm = Llama(
        model_path="./models/llama2-7b-q4_k_m.gguf",
        n_gpu_layers=-1,  # -1表示全部加载到GPU
        n_ctx=4096,       # 上下文长度
        verbose=False
    )

    # 生成文本
    output = llm(
        "请介绍一下人工智能的发展历程",
        max_tokens=200,
        temperature=0.7,
        top_p=0.9,
        echo=False
    )

    print(output['choices'][0]['text'])
    return llm

# 使用示例
# llm = llama_cpp_python_example()

import tensorrt_llm
from tensorrt_llm.runtime import ModelConfig, SamplingConfig
from tensorrt_llm.builder import Builder

def build_tensorrt_engine(model_path, output_path, dtype="float16"):
    """
    构建TensorRT-LLM引擎

    Args:
        model_path: Hugging Face模型路径
        output_path: 引擎输出路径
        dtype: 数据类型
    """
    # 创建构建器
    builder = Builder()

    # 模型配置
    config = {
        "model_dir": model_path,
        "dtype": dtype,
        "max_batch_size": 8,
        "max_input_len": 2048,
        "max_output_len": 512,
        "max_beam_width": 1,
        "use_gpt_attention_plugin": True,
        "use_gemm_plugin": True,
        "use_layernorm_plugin": True,
    }

    # 构建引擎
    builder.build(config, output_path)
    print(f"TensorRT引擎构建完成: {output_path}")

# 使用示例
# build_tensorrt_engine(
#     "meta-llama/Llama-2-7b-hf",
#     "./trt_engines/llama2-7b"
# )

import tensorrt_llm
from tensorrt_llm.runtime import GenerationSession

def tensorrt_llm_inference(engine_path, prompts):
    """
    使用TensorRT-LLM进行推理

    Args:
        engine_path: TensorRT引擎路径
        prompts: 输入提示列表
    """
    # 加载引擎
    session = GenerationSession.from_engine(engine_path)

    # 采样配置
    sampling_config = SamplingConfig(
        max_new_tokens=200,
        temperature=0.7,
        top_k=50,
        top_p=0.9
    )

    # 批量推理
    outputs = session.generate(prompts, sampling_config)

    for prompt, output in zip(prompts, outputs):
        print(f"提示: {prompt}")
        print(f"生成: {output}\n")

    return outputs

# 使用示例
# outputs = tensorrt_llm_inference(
#     "./trt_engines/llama2-7b",
#     ["什么是机器学习？", "解释深度学习"]
# )

def quantize_tensorrt_llm(model_path, output_path, quantization="int8"):
    """
    TensorRT-LLM量化配置

    Args:
        model_path: 模型路径
        output_path: 输出路径
        quantization: 量化类型（int8, int4, fp8）
    """
    config = {
        "model_dir": model_path,
        "dtype": "float16",
        # 量化配置
        "quantization": {
            "enabled": True,
            "type": quantization,
            "calib_dataset": "cnn_dailymail",
            "calib_samples": 512
        },
        # INT4特定配置
        "int4": {
            "group_size": 128,
            "zero_point": True
        },
        # INT8特定配置
        "int8": {
            "smoothquant_alpha": 0.5
        }
    }

    print(f"量化配置: {config}")
    return config

# 使用示例
# config = quantize_tensorrt_llm(
#     "meta-llama/Llama-2-7b-hf",
#     "./trt_engines/llama2-7b-int8",
#     "int8"
# )

optimized_config = {
    # 基础配置
    "max_batch_size": 32,
    "max_input_len": 4096,
    "max_output_len": 512,

    # 插件启用
    "use_gpt_attention_plugin": True,  # Flash Attention
    "use_gemm_plugin": True,           # 优化矩阵乘法
    "use_layernorm_plugin": True,      # 优化LayerNorm

    # 高级优化
    "enable_context_fmha": True,       # Flash Multi-Head Attention
    "remove_input_padding": True,      # 移除输入padding
    "paged_kv_cache": True,            # Paged KV Cache

    # 并行配置
    "tensor_parallel": 2,              # 张量并行度
    "pipeline_parallel": 1             # 流水线并行度
}

from vllm import LLM, SamplingParams

def vllm_inference(model_path):
    """
    vLLM推理示例

    Args:
        model_path: 模型路径
    """
    # 加载模型
    llm = LLM(
        model=model_path,
        tensor_parallel_size=1,
        gpu_memory_utilization=0.9,
        max_model_len=4096
    )

    # 采样参数
    sampling_params = SamplingParams(
        temperature=0.7,
        top_p=0.9,
        max_tokens=200,
        repetition_penalty=1.1
    )

    # 批量推理
    prompts = [
        "什么是机器学习？",
        "解释深度学习的概念",
        "自然语言处理有哪些应用？"
    ]

    outputs = llm.generate(prompts, sampling_params)

    for output in outputs:
        print(f"提示: {output.prompt}")
        print(f"生成: {output.outputs[0].text}\n")

    return llm

# 使用示例
# llm = vllm_inference("meta-llama/Llama-2-7b-hf")

# 启动vLLM OpenAI兼容服务器
# python -m vllm.entrypoints.openai.api_server \
#     --model meta-llama/Llama-2-7b-hf \
#     --host 0.0.0.0 \
#     --port 8000 \
#     --tensor-parallel-size 1

# 客户端调用
import openai

client = openai.OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="dummy"
)

response = client.chat.completions.create(
    model="meta-llama/Llama-2-7b-hf",
    messages=[
        {"role": "user", "content": "什么是机器学习？"}
    ],
    temperature=0.7,
    max_tokens=200
)

print(response.choices[0].message.content)

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
import onnxruntime as ort

def export_to_onnx(model_path, output_path):
    """
    将PyTorch模型导出为ONNX格式

    Args:
        model_path: 模型路径
        output_path: ONNX输出路径
    """
    model = AutoModelForCausalLM.from_pretrained(model_path)
    tokenizer = AutoTokenizer.from_pretrained(model_path)

    model.eval()

    # 创建示例输入
    dummy_input = tokenizer("Hello", return_tensors="pt")

    # 导出ONNX
    torch.onnx.export(
        model,
        (dummy_input["input_ids"], dummy_input["attention_mask"]),
        output_path,
        input_names=["input_ids", "attention_mask"],
        output_names=["logits"],
        dynamic_axes={
            "input_ids": {0: "batch", 1: "sequence"},
            "attention_mask": {0: "batch", 1: "sequence"},
            "logits": {0: "batch", 1: "sequence"}
        },
        opset_version=14
    )

    print(f"ONNX模型导出完成: {output_path}")

def onnx_inference(onnx_path, prompt):
    """
    ONNX Runtime推理

    Args:
        onnx_path: ONNX模型路径
        prompt: 输入提示
    """
    # 创建推理会话
    session = ort.InferenceSession(
        onnx_path,
        providers=['CUDAExecutionProvider', 'CPUExecutionProvider']
    )

    # 准备输入
    tokenizer = AutoTokenizer.from_pretrained("gpt2")
    inputs = tokenizer(prompt, return_tensors="np")

    # 推理
    outputs = session.run(
        None,
        {
            "input_ids": inputs["input_ids"].astype(np.int64),
            "attention_mask": inputs["attention_mask"].astype(np.int64)
        }
    )

    return outputs

# 使用示例
# export_to_onnx("gpt2", "./gpt2.onnx")
# outputs = onnx_inference("./gpt2.onnx", "Hello world")

def select_deployment_strategy(
    gpu_memory_gb: float,
    is_nvidia: bool,
    throughput_priority: str,  # "high", "medium", "low"
    ease_of_use: str,  # "high", "medium", "low"
    model_size_b: float
) -> dict:
    """
    部署策略选择工具

    Args:
        gpu_memory_gb: GPU显存大小（GB）
        is_nvidia: 是否为NVIDIA GPU
        throughput_priority: 吞吐量优先级
        ease_of_use: 易用性要求
        model_size_b: 模型大小（B参数）

    Returns:
        dict: 推荐的部署策略
    """
    recommendation = {
        "framework": "",
        "quantization": "",
        "config": {}
    }

    # 显存不足或非NVIDIA GPU
    if gpu_memory_gb < 16 or not is_nvidia:
        recommendation["framework"] = "llama.cpp"
        recommendation["quantization"] = "GGUF Q4_K_M"
        recommendation["config"] = {
            "n_gpu_layers": -1,
            "n_ctx": 4096
        }
    # 高吞吐量需求
    elif throughput_priority == "high":
        if ease_of_use == "high":
            recommendation["framework"] = "vLLM"
            recommendation["quantization"] = "AWQ INT4"
        else:
            recommendation["framework"] = "TensorRT-LLM"
            recommendation["quantization"] = "INT8"
    # 平衡需求
    else:
        recommendation["framework"] = "vLLM"
        recommendation["quantization"] = "FP16"

    return recommendation

# 使用示例
# strategy = select_deployment_strategy(
#     gpu_memory_gb=24,
#     is_nvidia=True,
#     throughput_priority="high",
#     ease_of_use="medium",
#     model_size_b=7
# )
# print(strategy)