量化 🤗 -AWQ

对于量化模型，推荐使用 AWQ结合 AutoAWQ。

AWQ：https://arxiv.org/abs/2306.00978

AutoAWQ：https://github.com/casper-hansen/AutoAWQ

AWQ即激活值感知的权重量化(Activation-aware Weight Quantization)，是针对LLM的低比特权重量化的硬件友好方法。

AutoAWQ是一个易于使用的工具包，用于4比特量化模型。相较于FP16，AutoAWQ能够将模型的运行速度提升3倍，并将内存需求降低至原来的三分之一。AutoAWQ实现了AWQ算法，可用于LLM的量化处理。

在本文档中，将展示如何在Hugging Face transformers框架下使用量化模型，以及如何对模型进行量化。

【1】在Hugging Face transformers中使用AWQ量化模型

transformers已经正式支持AutoAWQ，可以直接在transformers中使用AWQ量化模型。

以下是一个非常简单的代码片段，展示如何运行量化模型 Qwen2.5-7B-Instruct-AWQ ：

from transformers import AutoModelForCausalLM, AutoTokenizer  
  
model_name = "Qwen/Qwen2.5-7B-Instruct-AWQ"  
  
model = AutoModelForCausalLM.from_pretrained(  
    model_name,   
    device_map="auto",  
)  
tokenizer = AutoTokenizer.from_pretrained(model_name)  
  
prompt = "Give me a short introduction to large language model."  
messages = [  
    {"role": "system", "content": "You are Qwen, created by Alibaba Cloud. You are a helpful assistant."},  
    {"role": "user", "content": prompt},  
]  
text = tokenizer.apply_chat_template(  
    messages,  
    tokenize=False,  
    add_generation_prompt=True,  
)  
model_inputs = tokenizer([text], return_tensors="pt").to(model.device)  
  
generated_ids = model.generate(  
    **model_inputs,  
    max_new_tokens=512,  
)  
generated_ids = [  
    output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)  
]  
  
response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]  

【2】在vLLM中使用AWQ量化模型

vLLM已支持AWQ可以使用AWQ量化模型或使用AutoAWQ量化的模型。建议使用最新版的vLLM (vllm>=0.6.1)，新版为AWQ量化模型提升了效率；不然推理效率可能并为被良好优化（即效率可能较非量化模型低）。

实际上，使用AWQ模型与vLLM的基本用法相同。我们提供了一个简单的示例，展示了如何通过vLLM启动与OpenAI API兼容的接口，并使用 Qwen2.5-7B-Instruct-AWQ 模型：

在终端中运行以下命令以开启OpenAI兼容API：

vllm serve Qwen/Qwen2.5-7B-Instruct-AWQ  

随后，您可以这样调用API：

curl http://localhost:8000/v1/chat/completions -H "Content-Type: application/json" -d '{  
  "model": "Qwen/Qwen2.5-7B-Instruct-AWQ",  
  "messages": \[  
    {"role": "system", "content": "You are Qwen, created by Alibaba Cloud. You are a helpful assistant."},  
    {"role": "user", "content": "Tell me something about large language models."}  
  \],  
  "temperature": 0.7,  
  "top\_p": 0.8,  
  "repetition\_penalty": 1.05,  
  "max\_tokens": 512}'

或者你可以按照下面所示的方式，使用 openai Python包中的API客户端：

from openai import OpenAI  
openai\_api\_key = "EMPTY"  
openai\_api\_base = "http://localhost:8000/v1"  
  
client = OpenAI(  
    api\_key=openai\_api\_key,  
    base\_url=openai\_api\_base,  
)  
  
chat\_response = client.chat.completions.create(  
    model="Qwen/Qwen2.5-7B-Instruct-AWQ",  
    messages=\[  
        {"role": "system", "content": "You are Qwen, created by Alibaba Cloud. You are a helpful assistant."},  
        {"role": "user", "content": "Tell me something about large language models."},  
    \],  
    temperature=0.7,  
    top\_p=0.8,  
    max\_tokens=512,  
    extra\_body={  
        "repetition\_penalty": 1.05,  
    },  
)  
print("Chat response:", chat\_response)

【3】使用AutoAWQ量化你的模型

如果您希望将自定义模型量化为AWQ量化模型，我们建议您使用AutoAWQ。推荐通过安装源代码来获取并安装该工具包的最新版本：

git clone https://github.com/casper-hansen/AutoAWQ.git  
cd AutoAWQ  
pip install -e .  

假设你已经基于 Qwen2.5-7B 模型进行了微调，并将其命名为 Qwen2.5-7B-finetuned ，且使用的是你自己的数据集，比如Alpaca。若要构建你自己的AWQ量化模型，你需要使用训练数据进行校准。

以下，我们将为你提供一个简单的演示示例以便运行：

from awq import AutoAWQForCausalLM  
from transformers import AutoTokenizer  
  
# Specify paths and hyperparameters for quantization  
model_path = "your_model_path"  
quant_path = "your_quantized_model_path"  
quant_config = { "zero_point": True, "q_group_size": 128, "w_bit": 4, "version": "GEMM" }  
  
# Load your tokenizer and model with AutoAWQ  
tokenizer = AutoTokenizer.from_pretrained(model_path)  
model = AutoAWQForCausalLM.from_pretrained(model_path, device_map="auto", safetensors=True)  
  
data = []  
for msg in dataset:  
    text = tokenizer.apply_chat_template(msg, tokenize=False, add_generation_prompt=False)  
    data.append(text.strip())  
##只需通过一行代码运行校准过程：  
model.quantize(tokenizer, quant_config=quant_config, calib_data=data)  
  
##保存量化模型：  
model.save_quantized(quant_path, safetensors=True, shard_size="4GB")  
tokenizer.save_pretrained(quant_path)  

其中每个 msg 是一个典型的聊天消息，如下所示：

[  
    {"role": "system", "content": "You are Qwen, created by Alibaba Cloud. You are a helpful assistant."},  
    {"role": "user", "content": "Tell me who you are."},  
    {"role": "assistant", "content": "I am a large language model named Qwen..."}  
]  

量化 🤗 -GPTQ

GPTQ是一种针对类GPT大型语言模型的量化方法，它基于近似二阶信息进行一次性权重量化。在本文档中，将展示如何使用 transformers 库加载并应用量化后的模型，同时也会指导如何通过AutoGPTQ来模型进行量化处理。

GPTQ：https://arxiv.org/abs/2210.17323
AutoGPTQ：https://github.com/AutoGPTQ/AutoGPTQ

【1】在Hugging Face transformers中使用GPTQ模型

现在，transformers 正式支持了AutoGPTQ，这意味着您能够直接在transformers中使用量化后的模型。以下是一个非常简单的代码片段示例，展示如何运行 Qwen2.5-7B-Instruct-GPTQ-Int4 （请注意，对于每种大小的Qwen2.5模型，我们都提供了Int4和Int8两种量化版本）：

from transformers import AutoModelForCausalLM, AutoTokenizer  
model_name = "Qwen/Qwen2.5-7B-Instruct-GPTQ-Int4"  
model = AutoModelForCausalLM.from_pretrained(  
    model_name,   
    device_map="auto"  
)  
tokenizer = AutoTokenizer.from_pretrained(model_name)  
prompt = "Give me a short introduction to large language model."  
messages = [  
    {"role": "system", "content": "You are Qwen, created by Alibaba Cloud. You are a helpful assistant."},  
    {"role": "user", "content": prompt},  
]  
text = tokenizer.apply_chat_template(  
    messages,  
    tokenize=False,  
    add_generation_prompt=True,  
)  
model_inputs = tokenizer([text], return_tensors="pt").to(model.device)  
generated_ids = model.generate(  
    **model_inputs,  
    max_new_tokens=512,  
)  
generated_ids = [  
    output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)  
]  
response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]

【2】在vLLM中使用GPTQ模型

vLLM已支持GPTQ，可以直接使用我们提供的GPTQ量化模型或使用AutoGPTQ量化的模型。建议使用最新版的vLLM。如有可能，其会自动使用效率更好的GPTQ Marlin实现。

实际上，使用GPTQ模型与vLLM的基本用法相同。我们提供了一个简单的示例，展示了如何通过vLLM启动与OpenAI API兼容的接口，并使用 Qwen2.5-7B-Instruct-GPTQ-Int4 模型：

在终端中运行以下命令以开启OpenAI兼容API：

vllm serve Qwen2.5-7B-Instruct-GPTQ-Int4

随后，您可以这样调用API：

curl http://localhost:8000/v1/chat/completions -H "Content-Type: application/json" -d '{  
  "model": "Qwen2.5-7B-Instruct-GPTQ-Int4",  
  "messages": [  
    {"role": "system", "content": "You are Qwen, created by Alibaba Cloud. You are a helpful assistant."},  
    {"role": "user", "content": "Tell me something about large language models."}  
  ],  
  "temperature": 0.7,  
  "top_p": 0.8,  
  "repetition_penalty": 1.05,  
  "max_tokens": 512}  

或者你可以按照下面所示的方式，使用 openai Python包中的API客户端：

from openai import OpenAI  
openai_api_key = "EMPTY"  
openai_api_base = "http://localhost:8000/v1"  
client = OpenAI(  
    api_key=openai_api_key,  
    base_url=openai_api_base,  
)  
chat_response = client.chat.completions.create(  
    model="Qwen2.5-7B-Instruct-GPTQ-Int4",  
    messages=[  
        {"role": "system", "content": "You are Qwen, created by Alibaba Cloud. You are a helpful assistant."},  
        {"role": "user", "content": "Tell me something about large language models."},  
    ],  
    temperature=0.7,  
    top_p=0.8,  
    max_tokens=512,  
    extra_body={  
        "repetition_penalty": 1.05,  
    },  
)  
print("Chat response:", chat_response)  

【2】使用AutoGPTQ量化你的模型

如果你想将自定义模型量化为GPTQ量化模型，我们建议你使用AutoGPTQ工具。推荐通过安装源代码的方式获取并安装最新版本的该软件包。

git clone https://github.com/AutoGPTQ/AutoGPTQ  
cd AutoGPTQpip install -e .

假设你已经基于 Qwen2.5-7B 模型进行了微调，并将该微调后的模型命名为 Qwen2.5-7B-finetuned ，且使用的是自己的数据集，比如Alpaca。要构建你自己的GPTQ量化模型，你需要使用训练数据进行校准。以下是一个简单的演示示例，供你参考运行：

from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig  
from transformers import AutoTokenizer  
  
# Specify paths and hyperparameters for quantization  
model_path = "your_model_path"  
quant_path = "your_quantized_model_path"  
quantize_config = BaseQuantizeConfig(  
    bits=8, # 4 or 8  
    group_size=128,  
    damp_percent=0.01,  
    desc_act=False,  # set to False can significantly speed up inference but the perplexity may slightly bad  
    static_groups=False,  
    sym=True,  
    true_sequential=True,  
    model_name_or_path=None,  
    model_file_base_name="model"  
)  
max_len = 8192  
  
# Load your tokenizer and model with AutoGPTQ  
# To learn about loading model to multiple GPUs,  
# visit https://github.com/AutoGPTQ/AutoGPTQ/blob/main/docs/tutorial/02-Advanced-Model-Loading-and-Best-Practice.md  
tokenizer = AutoTokenizer.from_pretrained(model_path)  
model = AutoGPTQForCausalLM.from_pretrained(model_path, quantize_config)

但是，如果你想使用多GPU来读取模型，你需要使用 max_memory 而不是 device_map。下面是一段示例代码：

model = AutoGPTQForCausalLM.from_pretrained(  
    model_path,  
    quantize_config,  
    max_memory={i: "20GB" for i in range(4)})

接下来，你需要准备数据进行校准。你需要做的是将样本放入一个列表中，其中每个样本都是一段文本。由于直接使用微调数据进行校准，所以我们首先使用ChatML模板对它进行格式化处理。例如：

import torch  
  
data = []  
for msg in dataset:  
    text = tokenizer.apply_chat_template(msg, tokenize=False, add_generation_prompt=False)  
    model_inputs = tokenizer([text])  
    input_ids = torch.tensor(model_inputs.input_ids[:max_len], dtype=torch.int)      
data.append(dict(input_ids=input_ids, attention_mask=input_ids.ne(tokenizer.pad_token_id)))

logging.basicConfig(  
    format="%(asctime)s %(levelname)s [%(name)s] %(message)s", level=logging.INFO, datefmt="%Y-%m-%d %H:%M:%S"  
)  
model.quantize(data, cache_examples_on_gpu=False)

其中每个 msg 是一个典型的聊天消息，如下所示：

[  
    {"role": "system", "content": "You are Qwen, created by Alibaba Cloud. You are a helpful assistant."},  
    {"role": "user", "content": "Tell me who you are."},  
    {"role": "assistant", "content": "I am a large language model named Qwen..."}  
]  

最后，保存量化模型：

import torch  
from torch.nn import functional as F  
  
from transformers import AutoModelForCausalLM  
  
model.save\_quantized(quant\_path, use\_safetensors=True)  
tokenizer.save\_pretrained(quant\_path)  

很遗憾， save_quantized 方法不支持模型分片。若要实现模型分片，您需要先加载模型，然后使用来自 transformers 库的 save_pretrained 方法来保存并分片模型。除此之外，一切操作都非常简单。祝您使用愉快！

【3】问题排查

#1.在使用 transformers 和 auto_gptq 时，日志提示 CUDA extension not installed,并且推理速度缓慢。

auto_gptq 未能找到与您的环境兼容的融合CUDA算子，因此退回到基础实现。请遵循其 安装指南 来安装预构建的 wheel 或尝试从源代码安装 auto_gptq 。

#2.vllm 使用自行量化的 Qwen2.5-72B-Instruct-GPTQ 时，会引发 ValueError: … must be divisible by … 错误。自量化的模型的 intermediate size 与官方的 Qwen2.5-72B-Instruct-GPTQ 模型不同。

量化后，量化权重的大小将被 group size（通常为128）整除。Qwen2-72B 中FFN块的中间大小为29568。不幸的是， 29568÷128=231 。由于注意力头的数量和权重的维度必须能够被张量并行大小整除，这意味着你只能使用 tensor_parallel_size=1 ，即一张 GPU 卡，来运行量化的模型。

一个解决方案是使中间大小能够被 128×8=1024 整除。为了达到这一目的，应该使用零值对权重进行填充。虽然在数学上，在对权重进行零填充前后是等价的，但在现实中结果可能会略有不同。

尝试以下方法：

import torch  
from torch.nn import functional as F  
  
from transformers import AutoModelForCausalLM  
  
# must use AutoModelForCausalLM  
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-72B-Instruct", torch_dtype="auto")  
  
# this size is Qwen2.5-72B only  
pad_size = 128  
  
sd = model.state_dict()  
  
for i, k in enumerate(sd):  
    v = sd[k]  
    print(k, i)  
    # interleaving the padded zeros  
    if ('mlp.up_proj.weight' in k) or ('mlp.gate_proj.weight' in k):  
        prev_v = F.pad(v.unsqueeze(1), (0, 0, 0, 1, 0, 0)).reshape(29568*2, -1)[:pad_size*2]  
        new_v = torch.cat([prev_v, v[pad_size:]], dim=0)  
        sd[k] = new_v  
    elif 'mlp.down_proj.weight' in k:  
        prev_v= F.pad(v.unsqueeze(2), (0, 1)).reshape(8192, 29568*2)[:, :pad_size*2]  
        new_v = torch.cat([prev_v, v[:, pad_size:]], dim=1)  
        sd[k] = new_v  
  
# this is a very large file; make sure your RAM is enough to load the model  
torch.save(sd, '/path/to/padded_model/pytorch_model.bin')

这将会把填充后的检查点保存到指定的目录。然后，你需要从原始检查点复制其他文件到新目录，并将 config.json 中的 intermediate_size 修改为 29696 。最后，你可以量化保存的模型检查点。

量化 🤗 -llama.cpp

【1】llama.cpp

量化(Quantization)是本地运行大规模语言模型的主要议题，因为它能减少内存占用。毫无疑问，llama.cpp原生支持大规模语言模型的量化，并且一如既往地保持了灵活性。

在高层次上，llama.cpp所支持的所有量化都是权重量化(weight quantization)：模型参数被量化为低位(bit)数，在推理过程中，它们会被反量化(dequantize)并用于计算。

可以在单一的量化模型中混合使用不同的量化数据类型，例如，可以使用一种量化数据类型量化嵌入权重(embedding)，而使用另一种量化其他权重。通过适当的量化类型组合，只需略微增加bpw （bit-per-weight, 位权比），就能达到更低的量化误差。示例程序llama-quantize支持许多量化预设，如Q4_K_M和Q8_0。

如果你发现量化误差仍然超出预期，你可以引入自己的量化尺度，例如由AWQ计算的，或者使用校准数据用llama-imatrix来计算一个“重要性矩阵”(importance matrix)，然后在量化过程中使用以提高量化模型的质量。

在本文档中，将展示量化和评估量化模型性能的常见方法。我们会假设你手头有llama.cpp的示例程序。如果没有，请查看我们的指南。

https://qwen.readthedocs.io/zh-cn/latest/run_locally/llama.cpp.html#getting-the-program

【2】获取GGUF

现在，假设你想量化Qwen2.5-7B-Instruct。需要首先创建一个GGUF文件，如下所示：

python convert-hf-to-gguf.py Qwen/Qwen2.5-7B-Instruct --outfile qwen2.5-7b-instruct-f16.gguf

‍有时，可能最好将fp32作为量化的起点。在这种情况下，使用

python convert-hf-to-gguf.py Qwen/Qwen2.5-7B-Instruct --outtype f32 --outfile qwen2.5-7b-instruct-f32.gguf  

‍

【2】无校准量化GGUF

最简单的方法是，你可以根据需求直接将模型量化到低位数。下面是一个将模型量化到8 bit的例子：

./llama-quantize qwen2.5-7b-instruct-f16.gguf qwen2.5-7b-instruct-q8_0.gguf Q8_0  

Q8_0是一个量化预设的代号。你可以在llama-quantize的源代码中找到所有预设。寻找变量QUANT_OPTIONS。对于7B模型常用的包括Q8_0、Q5_0和Q4_K_M。字母大小写不重要，所以q8_0或q4_K_m都是可以接受的。

https://github.com/ggerganov/llama.cpp/blob/master/examples/quantize/quantize.cpp

现在，你可以使用基于llama.cpp的应用程序中的量化模型的GGUF文件。确实很简单。

然而，量化模型的准确性偶尔可能低于预期，特别是对于低位数量化。程序甚至可能阻止你这样做。

有几种方法可以提高量化模型的质量。一种常见的方法是在目标域中使用校准数据集来识别真正重要的权重，并以这些权重具有较低量化误差的方式量化模型，如下两种方法中将介绍。

【2】使用AWQ尺度量化GGUF

为了提高量化模型的质量，一种可能的解决方案是应用AWQ尺度，遵循这个脚本。首先，当你使用autoawq运行model.quantize()时，记得添加export_compatible=True，如下所示：

...  
model.quantize(  
    tokenizer,  
    quant_config=quant_config,  
    export_compatible=True  
)  
model.save_pretrained(quant_path)...

上述代码实际上不会量化权重。相反，它会根据数据集调整权重，使它们“更容易”量化。[1]

然后，当你运行convert-hf-to-gguf.py时，记得将模型路径替换为新模型的路径：

python convert-hf-to-gguf.py <quant_path> --outfile qwen2.5-7b-instruct-f16-awq.gguf  

最后，你可以像最后一个例子那样量化模型：

./llama-quantize qwen2.5-7b-instruct-f16-awq.gguf qwen2.5-7b-instruct-q8_0.gguf Q8_0

这样，应该有可能以更低的bpw实现相似的质量。

【2】使用重要性矩阵量化GGUF¶

另一个可能的解决方案是使用”重要矩阵”[2]，参照这里。

---

首先，你需要使用校准数据集（-f）计算模型权重的重要性矩阵数据（-m）：

./llama-imatrix -m qwen2.5-7b-instruct-f16.gguf -f calibration-text.txt --chunk 512 -o qwen2.5-7b-instruct-imatrix.dat -ngl 80

文本被切割成长度为--chunk的块进行计算。最好，文本应代表目标领域。最终结果将保存在名为qwen2.5-7b-instruct-imatrix.dat（-o）的文件中，然后可以使用：

./llama-quantize --imatrix qwen2.5-7b-instruct-imatrix.data \  
    qwen2.5-7b-instruct-f16-awq.gguf qwen2.5-7b-instruct-q4_k_m.gguf Q4_K_M

对于1 bit或2 bit的低位数量化混合，如果你不提供--imatrix，llama-quantize将打印出有用的警告。

【2】困惑度(Perplexity)评估

llama.cpp为我们提供了一个示例程序来计算困惑度，这评估了给定文本对模型而言的“不可能”程度。它主要用于比较：困惑度越低，模型对给定文本的记忆越好。

要做到这一点，你需要准备一个数据集，比如”wiki测试集”[3]。你可以使用以下命令下载数据集：

wget https://s3.amazonaws.com/research.metamind.io/wikitext/wikitext-2-raw-v1.zip?ref=salesforce-research -O wikitext-2-raw-v1.zipunzip wikitext-2-raw-v1.zip

然后你可以使用以下命令运行测试：

./llama-perplexity -m qwen2.5-7b-instruct-q8_0.gguf -f wiki.test.raw -ngl 80

稍等一段时间，你将得到模型的困惑度。这里提供了不同类型的量化模型的数值。观察差异可能有助于理解不同量化方式的潜在表现。

【2】结束语

在本指南中，我们展示了如何使用llama.cpp进行量化和评估困惑度。更多信息，请访问llama.cpp GitHub仓库。

我们通常将fp16模型量化为2、3、4、5、6和8位模型，采用不同的量化混合，但有时特定的混合就是不起作用，所以我们不在HuggingFace Hub中提供这些。但是，社区中的其他人可能会成功，因此，如果你在我们的仓库中没有找到所需的内容，请四处看看。

享受你新鲜量化的模型吧！

最后的最后

感谢你们的阅读和喜欢，我收藏了很多技术干货，可以共享给喜欢我文章的朋友们，如果你肯花时间沉下心去学习，它们一定能帮到你。

因为这个行业不同于其他行业，知识体系实在是过于庞大，知识更新也非常快。作为一个普通人，无法全部学完，所以我们在提升技术的时候，首先需要明确一个目标，然后制定好完整的计划，同时找到好的学习方法，这样才能更快的提升自己。

这份完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】

AI大模型学习路线

如果你对AI大模型入门感兴趣，那么你需要的话可以点击这里大模型重磅福利：入门进阶全套104G学习资源包免费分享！

扫描下方csdn官方合作二维码获取哦！

这是一份大模型从零基础到进阶的学习路线大纲全览，小伙伴们记得点个收藏！

第一阶段： 从大模型系统设计入手，讲解大模型的主要方法；

第二阶段： 在通过大模型提示词工程从Prompts角度入手更好发挥模型的作用；

第三阶段： 大模型平台应用开发借助阿里云PAI平台构建电商领域虚拟试衣系统；

第四阶段： 大模型知识库应用开发以LangChain框架为例，构建物流行业咨询智能问答系统；

第五阶段： 大模型微调开发借助以大健康、新零售、新媒体领域构建适合当前领域大模型；

第六阶段： 以SD多模态大模型为主，搭建了文生图小程序案例；

第七阶段： 以大模型平台应用与开发为主，通过星火大模型，文心大模型等成熟大模型构建大模型行业应用。

100套AI大模型商业化落地方案

大模型全套视频教程

200本大模型PDF书籍

👉学会后的收获：👈

• 基于大模型全栈工程实现（前端、后端、产品经理、设计、数据分析等），通过这门课可获得不同能力；

• 能够利用大模型解决相关实际项目需求： 大数据时代，越来越多的企业和机构需要处理海量数据，利用大模型技术可以更好地处理这些数据，提高数据分析和决策的准确性。因此，掌握大模型应用开发技能，可以让程序员更好地应对实际项目需求；

• 基于大模型和企业数据AI应用开发，实现大模型理论、掌握GPU算力、硬件、LangChain开发框架和项目实战技能， 学会Fine-tuning垂直训练大模型（数据准备、数据蒸馏、大模型部署）一站式掌握；

• 能够完成时下热门大模型垂直领域模型训练能力，提高程序员的编码能力： 大模型应用开发需要掌握机器学习算法、深度学习框架等技术，这些技术的掌握可以提高程序员的编码能力和分析能力，让程序员更加熟练地编写高质量的代码。

LLM面试题合集

大模型产品经理资源合集

大模型项目实战合集

👉获取方式：
😝有需要的小伙伴，可以保存图片到wx扫描二v码免费领取【保证100%免费】🆓