使用 @remote 装饰器在 Amazon SageMaker 上微调 Falcon 7B 和其他 LLM

%pip install -r requests.txt %pip install -q -U 变压器==4.31.0 %pip install -q -U 数据集==2.13.1 %pip install -q -U peft==0.4.0 %pip install -q -U 加速==0.21.0 %pip 安装-q -U 位和字节==0.40.2 %pip 安装-q -U boto3 %pip 安装-q -U sagemaker==2.154.0 %pip 安装-q -U scikit-learn

SchemaVersion: '1.0' SageMaker: PythonSDK: 模块: RemoteFunction: 依赖项: ./requirements.txt ImageUri: '{aws_account_id}.dkr.ecr.{region}.amazonaws.com/huggingface-pytorch-training:2.0.0-transformers4 .28.1-gpu-py310-cu118-ubuntu20.04' InstanceType: ml.g5.12xlarge RoleArn: arn:aws:iam::111122223333:role/ExampleSageMakerRole

from random import randint # 自定义指示提示启动prompt_template = f"{{question}}\n---\nAnswer:\n{{answer}}{{eos_token}}" # 模板数据集向每个样本添加提示 def template_dataset （示例）：sample["text"] =prompt_template.format(question=sample["question"],answer=sample["answers"],eos_token=tokenizer.eos_token)返回示例

from Transformers import AutoTokenizer model_id = "tiiuae/falcon-7b" tokenizer = AutoTokenizer.from_pretrained(model_id) # 设置 Falcon tokenizer tokenizer.pad_token = tokenizer.eos_token

import bitsandbytes as bnb

def find_all_linear_names(hf_model):
    lora_module_names = set()
    for name, module in hf_model.named_modules():
        if isinstance(module, bnb.nn.Linear4bit):
            names = name.split(".")
            lora_module_names.add(names[0] if len(names) == 1 else names[-1])

    if "lm_head" in lora_module_names:
        lora_module_names.remove("lm_head")
    return list(lora_module_names)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from sagemaker.remote_function import remote
import torch
from transformers import AutoModelForCausalLM, BitsAndBytesConfig
import transformers

# Start training
@remote(volume_size=50)
def train_fn(
        model_name,
        train_ds,
        test_ds,
        lora_r=8,
        lora_alpha=32,
        lora_dropout=0.05,
        per_device_train_batch_size=8,
        per_device_eval_batch_size=8,
        learning_rate=2e-4,
        num_train_epochs=1
):
    # tokenize and chunk dataset
    lm_train_dataset = train_ds.map(
        lambda sample: tokenizer(sample["text"]), batched=True, batch_size=24, remove_columns=list(train_dataset.features)
    )


    lm_test_dataset = test_ds.map(
        lambda sample: tokenizer(sample["text"]), batched=True, remove_columns=list(test_dataset.features)
    )

    # Print total number of samples
    print(f"Total number of train samples: {len(lm_train_dataset)}")

    bnb_config = BitsAndBytesConfig(
        load_in_4bit=True,
        bnb_4bit_use_double_quant=True,
        bnb_4bit_quant_type="nf4",
        bnb_4bit_compute_dtype=torch.bfloat16
    )
    # Falcon requires you to allow remote code execution. This is because the model uses a new architecture that is not part of transformers yet.
    # The code is provided by the model authors in the repo.
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        trust_remote_code=True,
        quantization_config=bnb_config,
        device_map="auto")

    model.gradient_checkpointing_enable()
    model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True)

    # get lora target modules
    modules = find_all_linear_names(model)
    print(f"Found {len(modules)} modules to quantize: {modules}")

    config = LoraConfig(
        r=lora_r,
        lora_alpha=lora_alpha,
        target_modules=modules,
        lora_dropout=lora_dropout,
        bias="none",
        task_type="CAUSAL_LM"
    )

    model = get_peft_model(model, config)
    print_trainable_parameters(model)

    trainer = transformers.Trainer(
        model=model,
        train_dataset=lm_train_dataset,
        eval_dataset=lm_test_dataset,
        args=transformers.TrainingArguments(
            per_device_train_batch_size=per_device_train_batch_size,
            per_device_eval_batch_size=per_device_eval_batch_size,
            logging_steps=2,
            num_train_epochs=num_train_epochs,
            learning_rate=learning_rate,
            bf16=True,
            save_strategy="no",
            output_dir="outputs"
        ),
        data_collator=transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False),
    )
    model.config.use_cache = False

    trainer.train()
    trainer.evaluate()

    model.save_pretrained("/opt/ml/model")

train_fn(model_id, train_dataset, test_dataset)

from peft import PeftModel, PeftConfig import torch from Transformers import AutoModelForCausalLM device="cuda" if torch.cuda.is_available() else 'mps' if torch.backends.mps.is_available() else 'cpu' config = PeftConfig.from_pretrained(" ./model") model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path, trust_remote_code=True) model = PeftModel.from_pretrained(model, "./model") model.to(device)