ChatGLM2-6B模型发布及魔搭最佳实践-阿里云开发者社区

智谱 AI 及清华 KEG 实验室为了更好地支持国产大模型开源生态的繁荣发展，将ChatGLM-6B 和 ChatGLM2-6B 权重对学术研究完全开放，并且在完成企业登记获得授权后，允许免费商业使用。

魔搭社区也近期也推出了ChatGLM-6B 和 ChatGLM2-6B基于魔搭社区的微调教程，希望通过详细的教程，更多的开发者可以基于开源或行业数据集微调ChatGLM-6B 和 ChatGLM2-6B模型，共同推进生态繁荣。

环境配置与安装

本文在8*3090的环境配置下运行 (可以单卡运行, 显存要求16G)
python>=3.8

服务器连接与环境准备

# 服务器连接 (CentOS)
ssh root@xxx.xxx.xxx.xxx  # 可通过vscode连接
passwd  # 修改root密码
lsb_release -a  # 查看操作系统版本
# 安装git并配置
yum install git
git config --global user.name "chatglm" 
git config --global user.email "chatglm@abc.com"
git config --global init.defaultBranch main
git config --list
# 创建用户, 并设置密码(当然你也可以在root下操作)
useradd -d /home/chatglm -m chatglm
passwd chatglm
su chatglm
# 安装miniconda
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
# 一直[ENTER], yes即可
sh Miniconda3-latest-Linux-x86_64.sh
# conda虚拟环境搭建
conda create --name modelscope python=3.10
conda activate modelscope
# pip设置全局镜像与相关python包安装
pip config set global.index-url https://mirrors.aliyun.com/pypi/simple/
pip install numpy pandas matplotlib scikit-learn
pip install transformers datasets
conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia
pip install tqdm tensorboard torchmetrics sentencepiece charset_normalizer accelerate
# 从源码安装modelscope(支持chatglm2 gradient_checkpoininging)
git clone https://github.com/modelscope/modelscope.git
cd modelscope
pip install .
# 如果设置GRADIENT_CHECKPOINTING=False, 则可直接从pypi下载安装. 显存要求40G
pip install modelscope
pip install numpy -U  # Resolve torchmetrics dependencies and update numpy

git clone ModelScope，运行示例代码

#获取示例代码
git clone https://github.com/modelscope/modelscope.git
cd modelscope/examples/pytorch/llm
python chatglm2_sft.py

以下介绍代码中的具体细节

进入python环境，获取环境基本信息

# https://github.com/modelscope/modelscope/blob/master/examples/pytorch/llm/_common.py
from _common import *
device_ids = [0, 1]
select_device(device_ids)
seed_everything(42)

模型链接及下载

ChatGLM系列模型现已在ModelScope社区开源，包括：

ChatGLM-6B

模型链接：https://modelscope.cn/models/ZhipuAI/ChatGLM-6B/summary

ChatGLM2-6B

模型链接：https://modelscope.cn/models/ZhipuAI/chatglm2-6b/summary

社区支持直接下载模型的repo

模型weights下载

# ### Loading Model and Tokenizer
WORK_DIR = 'runs/chatglm2'
#
model_dir = snapshot_download('ZhipuAI/chatglm2-6b', 'v1.0.6')

或者通过如下代码，实现模型下载，以及load model, tokenizer：

模型下载，load model，tokenizer

model, tokenizer = get_chatglm2_model_tokenizer(model_dir)

设置GRADIENT_CHECKPOINTING的训练方式，可以有效降低训练显存

GRADIENT_CHECKPOINTING = True
if GRADIENT_CHECKPOINTING:
    model.gradient_checkpointing_enable()
    model.enable_input_require_grads()

模型推理

ChatGLM2-6B推理代码

from modelscope.utils.constant import Tasks
from modelscope import Model
from modelscope.pipelines import pipeline
model = Model.from_pretrained('ZhipuAI/chatglm2-6b', device_map='auto', revision='v1.0.6')
pipe = pipeline(task=Tasks.chat, model=model)
inputs = {'text':'你好', 'history': []}
result = pipe(inputs)
inputs = {'text':'介绍下清华大学', 'history': result['history']}
result = pipe(inputs)
print(result)

数据集链接及下载

这里使用alpaca-gpt4-data-zh，alpaca-gpt4-data-en作为指令微调数据集(保证代码的完整性). 因为chatglm2已经经过chat微调, 所以请用自己的数据集替换这里的数据集.

from modelscope import MsDataset
dataset_zh = MsDataset.load("AI-ModelScope/alpaca-gpt4-data-zh", split="train")
dataset_en = MsDataset.load("AI-ModelScope/alpaca-gpt4-data-en", split="train")
print(len(dataset_zh["instruction"]))
print(len(dataset_en["instruction"]))
print(dataset_zh[0])
"""Out
48818
52002
{'instruction': '保持健康的三个提示。', 'input': None, 'output': '以下是保持健康的三个提示：\n\n1. 保持身体活动。每天做适当的身体运动，如散步、跑步或游泳，能促进心血管健康，增强肌肉力量，并有助于减少体重。\n\n2. 均衡饮食。每天食用新鲜的蔬菜、水果、全谷物和脂肪含量低的蛋白质食物，避免高糖、高脂肪和加工食品，以保持健康的饮食习惯。\n\n3. 睡眠充足。睡眠对人体健康至关重要，成年人每天应保证 7-8 小时的睡眠。良好的睡眠有助于减轻压力，促进身体恢复，并提高注意力和记忆力。'}
"""

模型训练最佳实践

微调过程分为如下几步：

prompt的设计
使用ModelScope提供的微调方法构建最终模型
使用ModelScope提供的Trainer对模型进行微调

准备LoRA

# ### Preparing lora
LORA_TARGET_MODULES = ['query_key_value']
LORA_RANK = 8
LORA_ALPHA = 32
LORA_DROPOUT_P = 0.1
lora_config = LoRAConfig(
    replace_modules=LORA_TARGET_MODULES,
    rank=LORA_RANK,
    lora_alpha=LORA_ALPHA,
    lora_dropout=LORA_DROPOUT_P)
logger.info(f'lora_config: {lora_config}')
Swift.prepare_model(model, lora_config)
#
# Show the frozen layer and view the model device and dtype
show_freeze_layers(model)
print_model_info(model)
_p = list(model.parameters())[100]
logger.info(f'device: {_p.device}, dtype: {_p.dtype}')
model.bfloat16()

导入datasets

# ### Loading Dataset
tokenize_function = partial(tokenize_function, tokenizer=tokenizer)
# Gets the dataset and converts the text to input_ids
train_dataset, val_dataset = get_alpaca_en_zh_dataset(tokenize_function)
# Data analysis
stat_dataset(train_dataset)
stat_dataset(val_dataset)
data_collate_fn = partial(data_collate_fn, tokenizer=tokenizer)
# print dataset example
print_examples(train_dataset[0], tokenizer)

配置Config

# ### Setting Config
cfg_file = os.path.join(model_dir, 'configuration.json')
#
BATCH_SIZE = 1
MAX_EPOCHS = 1
T_max = get_T_max(len(train_dataset), BATCH_SIZE, MAX_EPOCHS, True)
WORK_DIR = get_work_dir(WORK_DIR)
EVAL_INTERVAL = 500
CONFIG = Config({
    'train': {
        'dataloader': {
            'batch_size_per_gpu': BATCH_SIZE,
            'workers_per_gpu': 1,
            'shuffle': True,
            'drop_last': True,
            'pin_memory': True
        },
        'max_epochs':
        MAX_EPOCHS,
        'work_dir':
        WORK_DIR,
        'optimizer': {
            'type': 'AdamW',
            'lr': 1e-4,
            'weight_decay': 0.01,
            'options': {
                'cumulative_iters': 16,
                'grad_clip': {
                    'norm_type': 2,
                    'max_norm': 2.0
                }
            }
        },
        'lr_scheduler': {
            'type': 'CosineAnnealingLR',
            'T_max': T_max,
            'eta_min': 1e-5,
            'options': {
                'by_epoch': False,
                'warmup': {
                    'type': 'LinearWarmup',
                    'warmup_ratio': 0.1,
                    'warmup_iters': 200
                }
            }
        },
        'hooks': [
            {
                'type': 'CheckpointHook',
                'by_epoch': False,
                'interval': EVAL_INTERVAL,
                'max_checkpoint_num': 1
            },
            {
                'type': 'EvaluationHook',
                'by_epoch': False,
                'interval': EVAL_INTERVAL
            },
            {
                'type': 'BestCkptSaverHook',
                'metric_key': 'acc',
                'save_best': True,
                'rule': 'max',
                'max_checkpoint_num': 1
            },
            {
                'type': 'TextLoggerHook',
                'by_epoch': True,  # Whether EpochBasedTrainer is used
                'interval': 5
            },
            {
                'type': 'TensorboardHook',
                'by_epoch': False,
                'interval': 5
            }
        ]
    },
    'evaluation': {
        'dataloader': {
            'batch_size_per_gpu': BATCH_SIZE,
            'workers_per_gpu': 1,
            'shuffle': False,
            'drop_last': False,
            'pin_memory': True
        },
        'metrics': [{
            'type': 'my_metric',
            'vocab_size': tokenizer.vocab_size
        }]
    }
})

开启微调：

# ### Finetuning
def cfg_modify_fn(cfg: Config) -> Config:
    cfg.update(CONFIG)
    return cfg
trainer = EpochBasedTrainer(
    model=model,
    cfg_file=cfg_file,
    data_collator=data_collate_fn,
    train_dataset=train_dataset,
    eval_dataset=val_dataset,
    remove_unused_data=True,
    seed=42,
    device='cpu',  # No placement for model, leave the model to `device_map`
    cfg_modify_fn=cfg_modify_fn,
)
trainer.train()

可视化：

Tensorboard 命令: (e.g.)

tensorboard --logdir /home/chatglm2/my_git/modelscope/runs/chatglm2/v0-20230715-203505 --port 6006

# ### Visualization
tb_dir = os.path.join(WORK_DIR, 'tensorboard_output')
plot_image(tb_dir, ['loss'], 0.9)

资源消耗

chatglm2用lora的方式训练的显存占用如下，大约在16G. (batch_size=1, max_length=2048)

推理训练后的模型

# ### Setting up experimental environment.
from _common import *
from transformers import TextStreamer
device_ids = [0]
select_device(device_ids)
# Note: You need to set the value of `CKPT_FPATH`
CKPT_FPATH = '/path/to/your/iter_xxx.pth'
# ### Loading Model and Tokenizer
model_dir = snapshot_download('ZhipuAI/chatglm2-6b', 'v1.0.6')
model, tokenizer = get_chatglm2_model_tokenizer(model_dir)
model.bfloat16()  # Consistent with training
# ### Preparing lora
LORA_TARGET_MODULES = ['query_key_value']
LORA_RANK = 8
LORA_ALPHA = 32
LORA_DROPOUT_P = 0  # Arbitrary value
lora_config = LoRAConfig(
    replace_modules=LORA_TARGET_MODULES,
    rank=LORA_RANK,
    lora_alpha=LORA_ALPHA,
    lora_dropout=LORA_DROPOUT_P,
    pretrained_weights=CKPT_FPATH)
logger.info(f'lora_config: {lora_config}')
Swift.prepare_model(model, lora_config)
# ### Loading Dataset
_, test_dataset = get_alpaca_en_zh_dataset(None, True)
# ### Inference
streamer = TextStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
while True:
    instruction = input("<<< ")
    d = {"instruction": instruction, "input": None, "output": None}
    input_ids = tokenize_function(d, tokenizer)['input_ids']
    print(f'[TEST]{tokenizer.decode(input_ids)}', end='')
    input_ids = torch.tensor(input_ids)[None].cuda()
    attention_mask = torch.ones_like(input_ids)
    generate_ids = model.generate(
        input_ids=input_ids,
        max_new_tokens=512,
        attention_mask=attention_mask,
        streamer=streamer,
        pad_token_id=tokenizer.eos_token_id,
        temperature=0.7,
        top_k=50,
        top_p=0.7,
        do_sample=True)
    # output_ids -> text
    # text = tokenizer.decode(generate_ids[0])