实战Llama3

实战 Llama 3
今天有时间，我们来实测一下，如何玩转Llama 3 。

这里我就挑选比较重要的一些部分来说，想要看完整版的请移步到文章末尾。

Llama-3 8b 用疯狂的 15 万亿代币进行训练！ Llama-2 是 2 万亿。

%%capture
import torch

获取CUDA设备的能力，主要版本和次要版本

major_version, minor_version = torch.cuda.get_device_capability()

安装适用于Colab环境的unsloth包的特定版本，该版本解决了与torch 2.2.1的兼容性问题

!pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"

根据CUDA设备的主要版本选择要安装的软件包

if major_version >= 8:

# 如果CUDA主要版本大于等于8，则安装适用于新GPU架构（如Ampere、Hopper等）的软件包
!pip install --no-deps packaging ninja einops flash-attn xformers trl peft accelerate bitsandbytes

else:

# 如果CUDA主要版本小于8，则安装适用于旧GPU架构（如V100、Tesla T4、RTX 20xx）的软件包
!pip install --no-deps xformers trl peft accelerate bitsandbytes

pass # 此处的pass关键字是为了保持语法完整性，实际上在Jupyter Notebook中，它不需要被执行

设置模型相关的参数

from unsloth import FastLanguageModel
import torch
max_seq_length = 2048 # 可自选！我们内部自动支持RoPE Scaling！
dtype = None # 自动检测。Tesla T4, V100使用Float16，Ampere+使用Bfloat16
load_in_4bit = True # 使用4bit量化以减少内存使用。可以设为False。

我们支持的4bit预量化模型，下载速度提高4倍，且不会出现内存不足的情况。

fourbit_models = [

"unsloth/mistral-7b-bnb-4bit",
"unsloth/mistral-7b-instruct-v0.2-bnb-4bit",
"unsloth/llama-2-7b-bnb-4bit",
"unsloth/gemma-7b-bnb-4bit",
"unsloth/gemma-7b-it-bnb-4bit",  # Gemma 7b的Instruct版本
"unsloth/gemma-2b-bnb-4bit",
"unsloth/gemma-2b-it-bnb-4bit",  # Gemma 2b的Instruct版本
"unsloth/llama-3-8b-bnb-4bit",  # [NEW] 15 Trillion token的Llama-3

] # 更多模型参见https://huggingface.co/unsloth

从预训练模型加载FastLanguageModel和对应的tokenizer

model, tokenizer = FastLanguageModel.from_pretrained(

model_name="unsloth/llama-3-8b-bnb-4bit",
max_seq_length=max_seq_length,
dtype=dtype,
load_in_4bit=load_in_4bit,
# token="hf_...",  # 如果使用如meta-llama/Llama-2-7b-hf等门控模型，则使用一个token

)
参数:

model: 基础语言模型，将对此模型进行PEFT fine-tuning。
r: LoRA方法中的空间维度参数。选择大于0的整数，建议值包括8, 16, 32, 64, 128。
target_modules: 需要应用LoRA更新的模块列表。
lora_alpha: LoRA方法中的另一个重要参数，控制低秩近似的效果。
lora_dropout: 应用于LoRA参数的dropout比例。为优化，默认设置为0。
bias: 指定是否在LoRA更新中使用偏置。"none"表示不使用。
use_gradient_checkpointing: 是否启用梯度检查点以节省内存。"unsloth"模式进一步优化内存使用。
random_state: 用于模型初始化的随机状态，确保实验可复现性。
use_rslora: 是否使用排名稳定的LoRA方法进行更新。
loftq_config: LoftQ的配置，用于进一步的参数量化和压缩。
返回:

model: 经过PEFT fine-tuning处理的模型实例。
model = FastLanguageModel.get_peft_model(

model,
r = 16, # Choose any number > 0 ! Suggested 8, 16, 32, 64, 128
target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
                  "gate_proj", "up_proj", "down_proj",],
lora_alpha = 16,
lora_dropout = 0, # Supports any, but = 0 is optimized
bias = "none",    # Supports any, but = "none" is optimized
# [NEW] "unsloth" uses 30% less VRAM, fits 2x larger batch sizes!
use_gradient_checkpointing = "unsloth", # True or "unsloth" for very long context
random_state = 3407,
use_rslora = False,  # We support rank stabilized LoRA
loftq_config = None, # And LoftQ

)

定义一个格式化提示信息的函数

参数 examples 是一个包含指令、输入和输出的字典

返回一个包含格式化后文本的字典

alpaca_prompt = """Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.

Instruction:

{}

Input:

{}

Response:

{}"""

EOS_TOKEN = tokenizer.eos_token # 必须添加 EOS_TOKEN，以避免生成过程无限进行

def formatting_prompts_func(examples):

instructions = examples["instruction"] # 指令列表
inputs       = examples["input"]       # 输入列表
outputs      = examples["output"]      # 输出列表
texts = []
for instruction, input, output in zip(instructions, inputs, outputs):
    # 为每个指令、输入和输出生成格式化的文本，并添加 EOS_TOKEN
    text = alpaca_prompt.format(instruction, input, output) + EOS_TOKEN
    texts.append(text)
return { "text" : texts, } # 返回包含所有格式化文本的字典

加载数据集

from datasets import load_dataset
dataset = load_dataset("yahma/alpaca-cleaned", split = "train")

对数据集应用 formatting_prompts_func 函数，进行预处理

dataset = dataset.map(formatting_prompts_func, batched = True,)
最关键的一步来了，开始训练

初始化一个SFTTrainer用于模型训练

SFTTrainer是用于序列标注任务的训练器，封装了训练和评估的逻辑

from trl import SFTTrainer
from transformers import TrainingArguments

创建SFTTrainer实例

trainer = SFTTrainer(

model = model,  # 要训练的模型
tokenizer = tokenizer,  # 用于文本分词的工具
train_dataset = dataset,  # 训练数据集
dataset_text_field = "text",  # 数据集中文本字段的名称
max_seq_length = max_seq_length,  # 最大序列长度
dataset_num_proc = 2,  # 数据集加载时的进程数
packing = False,  # 是否使用序列打包以提高训练速度，对于短序列有效
args = TrainingArguments(
    per_device_train_batch_size = 2,  # 每个设备的训练批次大小
    gradient_accumulation_steps = 4,  # 累积梯度计算的步数
    warmup_steps = 5,  # 预热步数
    max_steps = 60,  # 最大训练步数
    learning_rate = 2e-4,  # 学习率
    fp16 = not torch.cuda.is_bf16_supported(),  # 是否使用半精度训练，取决于硬件支持
    bf16 = torch.cuda.is_bf16_supported(),  # 是否使用BFloat16训练，取决于硬件支持
    logging_steps = 1,  # 每多少步打印一次日志
    optim = "adamw_8bit",  # 优化器选择
    weight_decay = 0.01,  # 权重衰减
    lr_scheduler_type = "linear",  # 学习率调度器类型
    seed = 3407,  # 随机种子
    output_dir = "outputs",  # 输出目录
),

)

使用FastLanguageModel进行推理加速

FastLanguageModel.for_inference(model) # 启用原生2倍加速推理

准备输入数据

inputs = tokenizer(
[

alpaca_prompt.format(
    "Continue the fibonnaci sequence.", # 给出的指令是继续斐波那契数列
    "1, 1, 2, 3, 5, 8", # 输入的初始数列
    "", # 生成的输出留空
)

], return_tensors = "pt").to("cuda") # 将输入数据转换为适合模型的格式并移动到CUDA设备上

生成输出

outputs = model.generate(**inputs, max_new_tokens = 64, use_cache = True) # 生成最多64个新令牌，使用缓存加速
tokenizer.batch_decode(outputs) # 解码输出结果

使用FastLanguageModel进行推理加速

FastLanguageModel.for_inference(model) # 启用原生2倍加速推理

准备输入数据，这里使用tokenizer对输入文本进行编码

inputs = tokenizer(
[

alpaca_prompt.format(
    "Continue the fibonnaci sequence.", # 给出的指令是继续斐波那契数列
    "1, 1, 2, 3, 5, 8", # 输入的初始斐波那契数列
    "", # 生成输出时留空
)

], return_tensors = "pt").to("cuda") # 返回tensor类型的数据，并转移到CUDA设备上

引入TextStreamer用于流式生成文本

from transformers import TextStreamer
text_streamer = TextStreamer(tokenizer) # 创建文本流处理器

使用模型生成文本，这里使用了streamer参数以支持流式生成

_ = model.generate(**inputs, streamer = text_streamer, max_new_tokens = 128)

max_new_tokens参数限制了一次生成的新token数量，用于控制生成文本的长度

当然我把colab的代码共享出来了，你可以直接访问查看

https://colab.research.google.com/drive/1ImsCv6W69GVjdUUdnQEK...

原创声明：本文为本人原创作品，首发于AI ONES https://wuxiongwei.com，如果转载，请保留本文链接，谢谢。