大语言模型（LLMs）在过去一年取得了显著进步。从ChatGPT爆发以来，后来逐步发展了众多开源大模型LLMs，如Meta AI的Llama 2、Mistrals Mistral & Mixtral模型，TII Falcon等。这些LLMs能够胜任多种任务，包括聊天机器人、问答和自动摘要，而且无需进行额外的训练。但是，如果你想为你的应用定制模型，可能需要在你的数据集上对模型进行微调，以获得比直接使用或训练更小型模型更高质量的结果。
本文将介绍如何使用Hugging Face的TRL、Transformers框架和数据集来微调开放的大语言模型。我们将按照以下步骤进行：
-
明确我们的使用场景
-
设置开发环境
-
创建和准备数据集
-
使用**
trl和SFTTrainer**微调LLM -
测试和评估LLM
-
将LLM部署到生产环境
注意：本文是为了在消费者级别的GPU（24GB）上运行而编写的，例如NVIDIA A10G或RTX 4090/3090，但也可以轻松地适应在更大的GPU上运行。
一、定义我们的使用场景
微调LLM时，了解你的使用场景和要解决的问题至关重要。这将帮助你选择合适的模型，或者帮助你创建一个数据集来微调你的模型。如果你还没有定义你的使用场景，你可能需要重新思考。并非所有的使用场景都需要微调，建议在微调你自己的模型之前，先评估和尝试已经微调过的模型或基于API的模型。
例如，我们将使用以下使用场景：
我们想要微调一个模型，它可以基于自然语言指令生成SQL查询，然后可以集成到我们的BI工具中。目标是减少创建SQL查询所需的时间，并使非技术用户更容易创建SQL查询。
将自然语言转换为SQL查询是一个很好的微调LLM的使用场景，因为它是一个复杂的任务，需要对数据和SQL语言有深入的理解。
二、设置开发环境
首先，我们需要安装Hugging Face的库，包括trl、transformers和datasets，以及Pytorch。trl是一个新库，建立在transformers和datasets之上，它简化了微调大语言模型的过程，包括rlhf（强化学习从人类反馈中学习）和对齐开放LLM。如果你对trl还不太熟悉，不用担心，它是一个新工具，旨在让微调过程更加便捷。
# 安装Pytorch和其他库
!pip install "torch==2.1.2" tensorboard
# 安装Hugging Face库
!pip install --upgrade \
"transformers==4.36.2" \
"datasets==2.16.1" \
"accelerate==0.26.1" \
"evaluate==0.4.1" \
"bitsandbytes==0.42.0" \
# "trl==0.7.10" # \
# "peft==0.7.1" \
# 从github安装peft & trl
!pip install git+https://github.com/huggingface/trl@a3c5b7178ac4f65569975efadc97db2f3749c65e --upgrade
!pip install git+https://github.com/huggingface/peft@4a1559582281fc3c9283892caea8ccef1d6f5a4f--upgrade
如果你的GPU采用的是Ampere架构（如NVIDIA A10G或RTX 4090/3090）或更新版本，你可以利用Flash Attention技术。Flash Attention通过优化注意力机制的计算过程，并采用一些经典技术（如分块和重新计算）来显著提高计算速度，并降低内存消耗。简而言之，这项技术可以将训练速度提升至原来的三倍。想要了解更多详情，可以访问FlashAttention的官方页面。
注意：如果你的计算机内存不足96GB且拥有大量CPU核心，你可能需要调整_MAX_JOBS的数值。在我们的测试中，使用的是g5.2xlarge实例，设置了4_个作业。
import torch; assert torch.cuda.get_device_capability()[0] >= 8, 'Hardware not supported for Flash Attention'
# install flash-attn
!pip install ninja packaging
!MAX_JOBS=4 pip install flash-attn --no-build-isolation
安装Flash Attention可能需要一段时间（大约10到45分钟）。
我们将利用Hugging Face Hub作为一个远程模型版本控制服务。这意味着在训练过程中，我们的模型、日志和相关信息将自动上传到Hugging Face Hub。为了使用这项服务，你需要在Hugging Face上注册一个账户。注册完成后，我们会使用 huggingface_hub 包中的登录工具来登录你的账户，并在本地磁盘上保存你的访问令牌。
from huggingface_hub import login
login(
token=“”, # 在此处添加您的token
add_to_git_credential=True
)
三、创建和准备数据集
一旦您确定微调是正确的解决方案，我们需要准备一个数据集来训练我们的模型。这个数据集应该是多样化的任务示范，展示了你想要解决的问题。创建数据集的方法有很多，比如：
-
利用现有的开源数据集，如**
Spider** -
利用大语言模型生成合成数据集，如**
Alpaca** -
雇佣人类来创建数据集，如**
Dolly** -
结合以上方法，如**
Orca**
每种方法都有其自身的优势和劣势，并取决于预算、时间和质量要求。例如，使用现有数据集是最简单的，但可能不针对你的特定使用场景，而人工创建数据集虽然准确度高，但成本和时间消耗也大。也可以将几种方法结合起来创建指令数据集，如_Orca: Progressive Learning from Complex Explanation Traces of GPT-4_所示。
在我们的示例中，我们将使用一个名为**sql-create-context**的现有数据集，它包含了自然语言指令、数据库模式定义以及相应的SQL查询样本。
随着trl的最新版本发布，我们现在支持流行的指令和对话数据集格式。这意味着我们只需将数据集转换为支持的格式之一，trl就会自动处理后续步骤。支持的格式包括：
- 对话格式
{"messages": [{"role": "system", "content": "You are..."}, {"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]}{"messages": [{"role": "system", "content": "You are..."}, {"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]}{"messages": [{"role": "system", "content": "You are..."}, {"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]}
- 指令格式
{"prompt": "<prompt text>", "completion": "<ideal generated text>"}{"prompt": "<prompt text>", "completion": "<ideal generated text>"}{"prompt": "<prompt text>", "completion": "<ideal generated text>"}
我们将使用Hugging Face的Datasets库来加载我们的开源数据集，并将其转换为对话格式。在这种格式中，我们将在系统消息中包含数据库模式定义，作为我们助手的信息。然后，我们将数据集保存为jsonl文件，这样就可以用于微调我们的模型。我们对数据集进行了随机下采样，只保留了10,000个样本。
注意：如果你已经有了一个数据集，比如通过与OpenAI合作获得的，你可以跳过这一步，直接进行微调。
from datasets import load_dataset
# 将数据集转换为OAI消息
system_message = """您是SQL查询翻译的文本。用户将用英语向您提问，您将根据提供的SCHEMA生成SQL查询。
SCHEMA:
{schema}"""
def create_conversation(sample):
return {
"messages": [
{"role": "system", "content": system_message.format(schema=sample["context"])},
{"role": "user", "content": sample["question"]},
{"role": "assistant", "content": sample["answer"]}
]
}
# 从hub加载数据集
dataset = load_dataset("b-mc2/sql-create-context", split="train")
dataset = dataset.shuffle().select(range(12500))
# 将数据集转换为OAI消息
dataset = dataset.map(create_conversation, remove_columns=dataset.features,batched=False)
# 将数据集拆分为10000个训练样本和2500个测试样本
dataset = dataset.train_test_split(test_size=2500/12500)
print(dataset["train"][345]["messages"])
# 将数据集保存到磁盘
dataset["train"].to_json("train_dataset.json", orient="records")
dataset["test"].to_json("test_dataset.json", orient="records")
四、使用trl和SFTTrainer微调大语言模型
现在，我们准备开始微调我们的模型。我们将使用trl中的SFTTrainer来微调我们的模型。它简化了对开放的大语言模型进行监督式微调的过程。SFTTrainer是transformers库中Trainer的一个衍生类，它继承了所有核心功能，如日志记录、评估和模型检查点，并增加了一些实用功能，例如：
-
数据集格式转换，支持对话和指令格式
-
仅在数据集完成时进行训练，忽略掉提示信息
-
数据集打包，以提高训练效率
-
参数高效微调（PEFT）支持，包括Q-LoRA技术
-
为对话微调准备模型和标记器（例如添加特殊标记）
在我们的示例中，我们将利用数据集格式转换、数据集打包和参数高效微调（PEFT）功能。我们将采用QLoRA技术，这是一种通过量化来减少大型语言模型在微调过程中的内存占用，同时保持模型性能的方法。
🚀 首先，我们将从磁盘加载我们的json格式数据集。
from datasets import load_dataset
# 从磁盘加载jsonl数据
dataset = load_dataset("json", data_files="train_dataset.json", split="train")
接下来，我们将加载我们的大语言模型。在我们的应用场景中，我们选择了CodeLlama 7B，这是一个专门为代码合成和理解训练的大语言模型。如果你有其他偏好，比如**Mistral、Mixtral模型，或者TII Falcon，只需调整我们的model_id**即可轻松切换。我们将使用bitsandbytes工具将模型量化为4位，以减少内存需求。
请注意，模型的规模越大，它所需的内存就越多。在我们的示例中，我们使用的是7B版本的模型，它可以在24GB内存的GPU上进行微调。如果你的GPU内存较小，可能需要考虑使用更小的模型。
正确地为训练聊天/对话模型准备模型和标记器是至关重要的。我们需要向标记器和模型添加新的特殊标记，以教他们对话中的不同角色。在trl中，我们有一个方便的方法，使用**setup_chat_format**，它向标记器添加特殊标记，例如<|im_start|>和<|im_end|>，以表示对话的开始和结束。调整模型嵌入层的大小以适应新的标记。设置标记器的chat_template，它用于将输入数据格式化为类似于聊天的格式。默认是来自OpenAI的chatml。
正确配置模型和分词器以训练聊天或对话模型非常重要。我们需要向分词器和模型中添加特殊的标记，比如开始对话的<|im_start|>和结束对话的<|im_end|>，来教会它们在对话中扮演的角色。在trl库中，我们有一个名为**setup_chat_format**的便捷方法，它：
-
向分词器添加特殊的对话标记，以指示对话的开始和结束。
-
调整模型的嵌入层大小，以适应新的标记。
-
设置分词器的**
chat_template，这用于将输入数据格式化为类似聊天的格式。默认使用的是OpenAI提供的chatml**格式。
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
from trl import setup_chat_format
# Hugging Face model id
model_id = "codellama/CodeLlama-7b-hf" # or `mistralai/Mistral-7B-v0.1`
# BitsAndBytesConfig int-4 config
bnb_config = BitsAndBytesConfig(
load_in_4bit=True, bnb_4bit_use_double_quant=True, bnb_4bit_quant_type="nf4", bnb_4bit_compute_dtype=torch.bfloat16
)
# Load model and tokenizer
model = AutoModelForCausalLM.from_pretrained(
model_id,
device_map="auto",
attn_implementation="flash_attention_2",
torch_dtype=torch.bfloat16,
quantization_config=bnb_config
)
tokenizer = AutoTokenizer.from_pretrained(model_id)
tokenizer.padding_side = 'right' # 以防止警告
# 将聊天模板设置为OAI chatML，如果您从微调模型开始，请删除
model, tokenizer = setup_chat_format(model, tokenizer)
SFTTrainer 与 peft 的集成使得使用QLoRA高效调优LLM变得非常简单。我们只需要创建我们的LoraConfig并将其提供给训练器。我们的 LoraConfig 参数是根据QLoRA论文定义的。
from peft import LoraConfig
# 基于QLoRA论文和Sebastian Raschka实验的LoRA配置
peft_config = LoraConfig(
lora_alpha=128,
lora_dropout=0.05,
r=256,
bias="none",
target_modules="all-linear",
task_type="CAUSAL_LM",
)
在开始训练之前，我们需要定义我们想要使用的超参数（TrainingArguments）。
from transformers import TrainingArguments
args = TrainingArguments(
output_dir="code-llama-7b-text-to-sql", # 要保存的目录和存储库ID
num_train_epochs=3, # 训练周期数
per_device_train_batch_size=3, # 训练期间每个设备的批量大小
gradient_accumulation_steps=2, # 反向/更新前的步骤数
gradient_checkpointing=True, # 使用渐变检查点来节省内存
optim="adamw_torch_fused", # 使用融合的adamw优化器
logging_steps=10, # 每10步记录一次
save_strategy="epoch", # 每个epoch保存检查点
learning_rate=2e-4, # 学习率，基于QLoRA论文
bf16=True, # 使用bfloat16精度
tf32=True, # 使用tf32精度
max_grad_norm=0.3, # 基于QLoRA论文的最大梯度范数
warmup_ratio=0.03, # 根据QLoRA论文的预热比例
lr_scheduler_type="constant", # 使用恒定学习率调度器
push_to_hub=True, # 将模型推送到Hub
report_to="tensorboard", # 将指标报告到Tensorboard
)
现在，我们已经具备了创建 SFTTrainer 并启动模型训练的所有要素。
from trl import SFTTrainer
max_seq_length = 3072 # 数据集模型和打包的最大序列长度
trainer = SFTTrainer(
model=model,
args=args,
train_dataset=dataset,
peft_config=peft_config,
max_seq_length=max_seq_length,
tokenizer=tokenizer,
packing=True,
dataset_kwargs={
"add_special_tokens": False, # 我们使用特殊 tokens
"append_concat_token": False, # 不需要添加额外的分隔符 token
}
)
我们可以通过调用 Trainer 实例的 train() 方法来启动模型训练。这将启动一个训练循环，持续 3 个周期。由于我们采用的是参数高效微调方法，我们只会保存经过调整的模型权重，而不是整个模型。
# 开始训练，模型会自动保存到hub和输出目录
trainer.train()
# 保存模型
trainer.save_model()
使用Flash Attention进行3个周期的训练，在一个包含10k个样本的数据集上，在一台**g5.2xlarge上花费了01:29:58的时间。实例成本为1,212$/h，这使得总成本仅为1.8$**。
# 再次释放内存
del model
del trainer
torch.cuda.empty_cache()
可选步骤：将 LoRA 适配器合并到原始模型中
在使用 QLoRA 时，我们只训练适配器，而不是整个模型。这意味着在训练过程中保存模型时，我们只保存适配器的权重。如果你希望保存整个模型，以便更容易地与文本生成推理一起使用，你可以使用 merge_and_unload 方法将适配器权重合并到模型权重中，然后使用 save_pretrained 方法保存模型。这将保存一个默认模型，可用于推理。
注意：这个过程可能需要超过 30GB 的 CPU 内存。
#### COMMENT IN TO MERGE PEFT AND BASE MODEL ####
# from peft import PeftModel, PeftConfig
# from transformers import AutoModelForCausalLM, AutoTokenizer
# from peft import AutoPeftModelForCausalLM
# # Load PEFT model on CPU
# config = PeftConfig.from_pretrained(args.output_dir)
# model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path,low_cpu_mem_usage=True)
# tokenizer = AutoTokenizer.from_pretrained(args.output_dir)
# model.resize_token_embeddings(len(tokenizer))
# model = PeftModel.from_pretrained(model, args.output_dir)
# model = AutoPeftModelForCausalLM.from_pretrained(
# args.output_dir,
# torch_dtype=torch.float16,
# low_cpu_mem_usage=True,
# )
# # Merge LoRA and base model and save
# merged_model = model.merge_and_unload()
# merged_model.save_pretrained(args.output_dir,safe_serialization=True, max_shard_size="2GB")
五、测试和评估大语言模型
训练完成后，我们需要对模型进行评估和测试。我们将从原始数据集中选取不同的样本，并通过一个简单的循环和准确率作为衡量标准来评估模型的表现。
注意：评估生成式 AI（Generative AI）模型并不容易，因为一个输入可能有多种正确的输出。
import torch
from peft import AutoPeftModelForCausalLM
from transformers import AutoTokenizer, pipeline
peft_model_id = "./code-llama-7b-text-to-sql"
# peft_model_id = args.output_dir
# Load Model with PEFT adapter
model = AutoPeftModelForCausalLM.from_pretrained(
peft_model_id,
device_map="auto",
torch_dtype=torch.float16
)
# load into pipeline
pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
让我们加载测试数据集，尝试生成一个指令。
from datasets import load_dataset
from random import randint
# 加载我们的测试数据集
eval_dataset = load_dataset("json", data_files="test_dataset.json", split="train")
rand_idx = randint(0, len(eval_dataset))
# 样品测试
prompt = pipe.tokenizer.apply_chat_template(eval_dataset[rand_idx]["messages"][:2], tokenize=False, add_generation_prompt=True)
outputs = pipe(prompt, max_new_tokens=256, do_sample=False, temperature=0.1, top_k=50, top_p=0.1, eos_token_id=pipe.tokenizer.eos_token_id, pad_token_id=pipe.tokenizer.pad_token_id)
print(f"Query:\n{eval_dataset[rand_idx]['messages'][1]['content']}")
print(f"Original Answer:\n{eval_dataset[rand_idx]['messages'][2]['content']}")
print(f"Generated Answer:\n{outputs[0]['generated_text'][len(prompt):].strip()}")
我们的模型成功根据自然语言指令生成了 SQL 查询。现在，让我们对测试数据集中的 2,500 个样本进行全面评估。正如之前提到的，评估生成模型的准确性并非易事。在我们的实验中，我们以生成的 SQL 查询与真实 SQL 查询的匹配度作为评估标准。另一种更精确的方法是自动执行这些 SQL 查询，并将结果与真实数据进行对比，但这需要更多的准备工作。
from tqdm import tqdm
def evaluate(sample):
prompt = pipe.tokenizer.apply_chat_template(sample["messages"][:2], tokenize=False, add_generation_prompt=True)
outputs = pipe(prompt, max_new_tokens=256, do_sample=True, temperature=0.7, top_k=50, top_p=0.95, eos_token_id=pipe.tokenizer.eos_token_id, pad_token_id=pipe.tokenizer.pad_token_id)
predicted_answer = outputs[0]['generated_text'][len(prompt):].strip()
if predicted_answer == sample["messages"][2]["content"]:
return 1
else:
return 0
success_rate = []
number_of_eval_samples = 1000
# 迭代eval数据集并预测
for s in tqdm(eval_dataset.shuffle().select(range(number_of_eval_samples))):
success_rate.append(evaluate(s))
# 计算精度
accuracy = sum(success_rate)/len(success_rate)
print(f"Accuracy: {accuracy*100:.2f}%")
我们在评估数据集的 1000 个样本上进行了测试，准确率达到了 79.50%，整个过程大约花费了 25 分钟。
这个结果相当不错，但我们需要谨慎对待这个指标。如果能在真实数据库上运行这些查询并比较结果，那将是一个更可靠的评估方法。由于相同的指令可能对应多种正确的 SQL 查询，我们还可以通过少样本学习、RAG（Retrieval-Augmented Generation）和自我修复等技术来进一步提升模型的性能。
六、将大语言模型部署到生产环境
现在，你可以将你的大语言模型部署到生产环境中。为了在生产环境中部署开放的大语言模型，我们推荐使用文本生成推理（Text Generation Inference，TGI）。TGI 是一个专门为部署和提供大型语言模型（LLMs）而设计的高性能解决方案。它通过张量并行技术和连续批处理，支持包括 Llama、Mistral、Mixtral、StarCoder、T5 等在内的多种流行开放大语言模型。IBM、Grammarly、Uber、Deutsche Telekom 等公司都在使用文本生成推理。你可以通过多种方式部署你的模型，例如：
-
使用 Hugging Face 提供的推理端点
-
自主搭建（DIY）
如果你已经安装了 Docker，你可以使用以下命令来启动推理服务器。
注意：确保你的 GPU 内存足够运行容器。在笔记本中，你可能需要重启内核来释放所有已分配的 GPU 内存。
%%bash
# model=$PWD/{args.output_dir} # path to model
model=$(pwd)/code-llama-7b-text-to-sql # path to model
num_shard=1 # number of shards
max_input_length=1024 # max input length
max_total_tokens=2048 # max total tokens
docker run -d --name tgi --gpus all -ti -p 8080:80 \
-e MODEL_ID=/workspace \
-e NUM_SHARD=$num_shard \
-e MAX_INPUT_LENGTH=$max_input_length \
-e MAX_TOTAL_TOKENS=$max_total_tokens \
-v $model:/workspace \
ghcr.io/huggingface/text-generation-inference:latest
一旦你的容器启动，你就可以开始发送推理请求了。
import requests as r
from transformers import AutoTokenizer
from datasets import load_dataset
from random import randint
# 再次加载我们的测试数据集和Tokenizer
tokenizer = AutoTokenizer.from_pretrained("code-llama-7b-text-to-sql")
eval_dataset = load_dataset("json", data_files="test_dataset.json", split="train")
rand_idx = randint(0, len(eval_dataset))
# 生成与第一次本地测试相同的提示
prompt = tokenizer.apply_chat_template(eval_dataset[rand_idx]["messages"][:2], tokenize=False, add_generation_prompt=True)
request= {"inputs":prompt,"parameters":{"temperature":0.2, "top_p": 0.95, "max_new_tokens": 256}}
# 向推理服务器发送请求
resp = r.post("http://127.0.0.1:8080/generate", json=request)
output = resp.json()["generated_text"].strip()
time_per_token = resp.headers.get("x-time-per-token")
time_prompt_tokens = resp.headers.get("x-prompt-tokens")
# 打印结果
print(f"Query:\n{eval_dataset[rand_idx]['messages'][1]['content']}")
print(f"Original Answer:\n{eval_dataset[rand_idx]['messages'][2]['content']}")
print(f"Generated Answer:\n{output}")
print(f"Latency per token: {time_per_token}ms")
print(f"Latency prompt encoding: {time_prompt_tokens}ms")
完成工作后，别忘了停止你的容器。
!docker stop tgi
七、总结
随着大型语言模型的发展和 TRL 等工具的普及，现在是企业投资开放大语言模型技术的绝佳时机。针对特定任务微调开放的大语言模型可以显著提升效率，并为创新和服务质量提升带来新的可能性。随着技术的日益普及和成本效益的提高，现在是开始利用开放大语言模型的最佳时刻。
八、References
[1]. Llama 2 （https://huggingface.co/meta-llama/Llama-2-70b-chat-hf）
[2]. Mistral（https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.2）
[3]. Mixtral （https://huggingface.co/mistralai/Mixtral-8x7B-Instruct-v0.1）
[4]. Falcon（https://huggingface.co/tiiuae/falcon-40b）
[5]. TRL（https://huggingface.co/docs/trl/index）
[6]. Transformers（https://huggingface.co/docs/transformers/index）
[7]. datasets（https://huggingface.co/docs/datasets/index）
[8]. FlashAttention （https://github.com/Dao-AILab/flash-attention/tree/main）
[9]. Hugging Face Hub （https://huggingface.co/models）
[10]. Orca: Progressive Learning from Complex Explanation Traces of GPT-4. （https://arxiv.org/abs/2306.02707）
[11]. sql-create-context （https://huggingface.co/datasets/b-mc2/sql-create-context）
[12]. Text Generation Inference (TGI) https://github.com/huggingface/text-generation-inference
如何学习大模型 AI ？
由于新岗位的生产效率，要优于被取代岗位的生产效率，所以实际上整个社会的生产效率是提升的。
但是具体到个人，只能说是：
“最先掌握AI的人，将会比较晚掌握AI的人有竞争优势”。
这句话，放在计算机、互联网、移动互联网的开局时期，都是一样的道理。
我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。
我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多互联网行业朋友无法获得正确的资料得到学习提升，故此将并将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。
第一阶段（10天）：初阶应用
该阶段让大家对大模型 AI有一个最前沿的认识，对大模型 AI 的理解超过 95% 的人，可以在相关讨论时发表高级、不跟风、又接地气的见解，别人只会和 AI 聊天，而你能调教 AI，并能用代码将大模型和业务衔接。
- 大模型 AI 能干什么？
- 大模型是怎样获得「智能」的？
- 用好 AI 的核心心法
- 大模型应用业务架构
- 大模型应用技术架构
- 代码示例：向 GPT-3.5 灌入新知识
- 提示工程的意义和核心思想
- Prompt 典型构成
- 指令调优方法论
- 思维链和思维树
- Prompt 攻击和防范
- …
第二阶段（30天）：高阶应用
该阶段我们正式进入大模型 AI 进阶实战学习，学会构造私有知识库，扩展 AI 的能力。快速开发一个完整的基于 agent 对话机器人。掌握功能最强的大模型开发框架，抓住最新的技术进展，适合 Python 和 JavaScript 程序员。
- 为什么要做 RAG
- 搭建一个简单的 ChatPDF
- 检索的基础概念
- 什么是向量表示（Embeddings）
- 向量数据库与向量检索
- 基于向量检索的 RAG
- 搭建 RAG 系统的扩展知识
- 混合检索与 RAG-Fusion 简介
- 向量模型本地部署
- …
第三阶段（30天）：模型训练
恭喜你，如果学到这里，你基本可以找到一份大模型 AI相关的工作，自己也能训练 GPT 了！通过微调，训练自己的垂直大模型，能独立训练开源多模态大模型，掌握更多技术方案。
到此为止，大概2个月的时间。你已经成为了一名“AI小子”。那么你还想往下探索吗？
- 为什么要做 RAG
- 什么是模型
- 什么是模型训练
- 求解器 & 损失函数简介
- 小实验2：手写一个简单的神经网络并训练它
- 什么是训练/预训练/微调/轻量化微调
- Transformer结构简介
- 轻量化微调
- 实验数据集的构建
- …
第四阶段（20天）：商业闭环
对全球大模型从性能、吞吐量、成本等方面有一定的认知，可以在云端和本地等多种环境下部署大模型，找到适合自己的项目/创业方向，做一名被 AI 武装的产品经理。
- 硬件选型
- 带你了解全球大模型
- 使用国产大模型服务
- 搭建 OpenAI 代理
- 热身：基于阿里云 PAI 部署 Stable Diffusion
- 在本地计算机运行大模型
- 大模型的私有化部署
- 基于 vLLM 部署大模型
- 案例：如何优雅地在阿里云私有部署开源大模型
- 部署一套开源 LLM 项目
- 内容安全
- 互联网信息服务算法备案
- …
学习是一个过程，只要学习就会有挑战。天道酬勤，你越努力，就会成为越优秀的自己。
如果你能在15天内完成所有的任务，那你堪称天才。然而，如果你能完成 60-70% 的内容，你就已经开始具备成为一名大模型 AI 的正确特征了。
这份完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】
本文转自 https://blog.csdn.net/python122_/article/details/141086393，如有侵权，请联系删除。
1034
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
