Affinez Falcon 7B et d'autres LLM sur Amazon SageMaker avec @remote decorator

Aujourd'hui, les modèles d'IA générative couvrent une variété de tâches allant de la synthèse de texte aux questions-réponses en passant par la génération d'images et de vidéos. Pour améliorer la qualité de la sortie, des approches telles que l'apprentissage n-short, l'ingénierie rapide, la génération augmentée de récupération (RAG) et le réglage fin sont utilisées. Le réglage fin vous permet d'ajuster ces modèles d'IA génératifs pour obtenir de meilleures performances sur les tâches spécifiques à votre domaine.

Avec Amazon SageMaker, vous pouvez désormais exécuter une tâche de formation SageMaker simplement en annotant votre code Python avec @remote decorator. Le SDK Python SageMaker traduit automatiquement votre environnement d'espace de travail existant, ainsi que tout code de traitement de données et ensembles de données associés, en une tâche de formation SageMaker qui s'exécute sur la plateforme de formation. Cela présente l'avantage d'écrire le code de manière plus naturelle, orientée objet, tout en utilisant les fonctionnalités de SageMaker pour exécuter des tâches de formation sur un cluster distant avec un minimum de modifications.

Dans cet article, nous montrons comment affiner un Faucon-7B Modèles de fondation (FM) utilisant le décorateur @remote du SDK SageMaker Python. Il utilise également Réglage précis des paramètres de Hugging Face (PEFT) et techniques de quantification via bits et octets pour prendre en charge le réglage fin. Le code présenté dans ce blog peut également être utilisé pour affiner d'autres FM, tels que Lama-2 13b.

Les représentations de précision complète de ce modèle pourraient avoir du mal à tenir en mémoire sur un seul ou même plusieurs Unités de traitement graphique (GPU) - ou peut même avoir besoin d'une instance plus grande. Ainsi, afin d’affiner ce modèle sans augmenter le coût, nous utilisons la technique connue sous le nom de LLM quantifiés avec adaptateurs de bas rang (QLoRA). QLoRA est une approche de réglage efficace qui réduit l'utilisation de la mémoire des LLM tout en conservant de très bonnes performances.

Avantages de l'utilisation du décorateur @remote

Avant d'aller plus loin, comprenons comment le décorateur à distance améliore la productivité des développeurs tout en travaillant avec SageMaker :

• @remote decorator déclenche une tâche de formation directement à l'aide du code python natif, sans invocation explicite des estimateurs SageMaker et des canaux d'entrée SageMaker
• Faible barrière à l’entrée pour les modèles de formation des développeurs sur SageMaker.
• Pas besoin de changer Environnements de développement intégrés (IDE). Continuez à écrire du code dans l'EDI de votre choix et invoquez les tâches de formation SageMaker.
• Pas besoin de se renseigner sur les conteneurs. Continuer à fournir des dépendances dans un exigences.txt et fournissez-le au décorateur distant.

Conditions préalables

Un compte AWS est nécessaire avec un rôle AWS Identity and Access Management (AWS IAM) disposant des autorisations nécessaires pour gérer les ressources créées dans le cadre de la solution. Pour plus de détails, reportez-vous à Création d'un compte AWS.

Dans cet article, nous utilisons Amazon SageMaker Studio avec le Science des données 3.0 une image et un ml.t3.moyen instance de lancement rapide. Cependant, vous pouvez utiliser n'importe quel environnement de développement intégré (IDE) de votre choix. Il vous suffit de configurer correctement vos informations d'identification AWS Command Line Interface (AWS CLI). Pour plus d'informations, consultez Configurer l'AWS CLI.

Pour la mise au point, le Falcon-7B, un ml.g5.12xlarge L'instance est utilisée dans cet article. Veuillez garantir une capacité suffisante pour cette instance dans le compte AWS.

Tu dois cloner ça Dépôt Github pour reproduire la solution démontrée dans cet article.

Vue d'ensemble de la solution

1. Installer les prérequis pour affiner le modèle Falcon-7B
2. Configurer les configurations du décorateur à distance
3. Prétraiter l'ensemble de données contenant la FAQ sur les services AWS
4. FAQ sur l'optimisation du Falcon-7B sur les services AWS
5. Testez les modèles affinés sur des exemples de questions liées aux services AWS

1. Installez les prérequis pour affiner le modèle Falcon-7B

Lancez le bloc-notes falcon-7b-qlora-remote-decorator_qa.ipynb dans SageMaker Studio en sélectionnant le Image comme Science des données et Noyau comme Python3. Installez toutes les bibliothèques requises mentionnées dans le exigences.txt. Peu de bibliothèques doivent être installées sur l'instance de notebook elle-même. Effectuez d'autres opérations nécessaires au traitement de l'ensemble de données et au déclenchement d'une tâche de formation SageMaker.

%pip install -r exigences.txt %pip install -q -U transformateurs==4.31.0 %pip install -q -U datasets==2.13.1 %pip install -q -U peft==0.4.0 %pip install -q -U accélérer ==0.21.0 %pip install -q -U bitsandbytes==0.40.2 %pip install -q -U boto3 %pip install -q -U sagemaker==2.154.0 %pip install -q -U scikit-learn

2. Configurer les configurations du décorateur à distance

Créez un fichier de configuration dans lequel toutes les configurations liées à la tâche de formation Amazon SageMaker sont spécifiées. Ce fichier est lu par @remote decorator lors de l'exécution de la tâche de formation. Ce fichier contient des paramètres tels que les dépendances, l'image de formation, l'instance et le rôle d'exécution à utiliser pour la tâche de formation. Pour une référence détaillée de tous les paramètres pris en charge par le fichier de configuration, consultez Configuration et utilisation des valeurs par défaut avec le SDK SageMaker Python.

SchemaVersion : '1.0' SageMaker : PythonSDK : Modules : RemoteFunction : Dépendances : ./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

Il n'est pas obligatoire d'utiliser le config.yaml fichier afin de travailler avec le décorateur @remote. C'est juste une façon plus propre de fournir toutes les configurations au décorateur @remote. Cela maintient les paramètres liés à SageMaker et AWS en dehors du code avec un effort unique pour configurer le fichier de configuration utilisé par les membres de l'équipe. Toutes les configurations pourraient également être fournies directement dans les arguments du décorateur, mais cela réduit la lisibilité et la maintenabilité des modifications à long terme. De plus, le fichier de configuration peut être créé par un administrateur et partagé avec tous les utilisateurs d'un environnement.

Prétraiter l'ensemble de données contenant la FAQ sur les services AWS

L'étape suivante consiste à charger et prétraiter l'ensemble de données pour le préparer pour la tâche de formation. Tout d’abord, jetons un coup d’œil à l’ensemble de données :

Il affiche la FAQ pour l'un des services AWS. En plus de QLoRA, bitsanoctets est utilisé pour convertir en précision 4 bits afin de quantifier le LLM gelé en 4 bits et de l'attacher LoRA adaptateurs dessus.

Créez un modèle d'invite pour convertir chaque exemple de FAQ en un format d'invite :

à partir d'une importation aléatoire randint #, invite d'instruction personnalisée, démarrage prompt_template = f"{{question}}\n---\nRéponse :\n{{answer}}{{eos_token}}" Ensemble de données de modèle # pour ajouter une invite à chaque échantillon def template_dataset (exemple) : sample["text"] = prompt_template.format(question=sample["question"],answer=sample["answers"], eos_token=tokenizer.eos_token) renvoie un échantillon

L'étape suivante consiste à convertir les entrées (texte) en identifiants de jeton. Ceci est réalisé par un Tokenizer de transformateurs de visage câlin.

à partir des transformateurs import AutoTokenizer model_id = "tiiuae/falcon-7b" tokenizer = AutoTokenizer.from_pretrained(model_id) # Définir le tokenizer Falcon tokenizer.pad_token = tokenizer.eos_token

Maintenant, utilisez simplement le invite_template fonction pour convertir toutes les FAQ au format d'invite et configurer des ensembles de données d'entraînement et de test.

4. Affinez la FAQ sur les services Falcon-7B sur AWS

Vous pouvez maintenant préparer le script de formation et définir la fonction de formation train_fn et mettez @remote decorator sur la fonction.

La fonction de formation effectue les tâches suivantes :

• tokenise et fragmente l'ensemble de données
• installation BitsAndBytesConfig, qui spécifie que le modèle doit être chargé en 4 bits mais que le calcul doit être converti en bfloat16.
• Charger le modèle
• Recherchez les modules cibles et mettez à jour les matrices nécessaires en utilisant la méthode utilitaire find_all_linear_names
• Créer LoRA configurations qui spécifient le classement des matrices de mise à jour (s), facteur d'échelle (lora_alpha), les modules pour appliquer les matrices de mise à jour LoRA (modules_cibles), probabilité d'abandon pour les couches Lora (lora_dropout), type_tâche, etc.
• Commencer la formation et l'évaluation

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")

Et invoque le train_fn()

train_fn (model_id, train_dataset, test_dataset)

La tâche de réglage s'exécuterait sur le cluster de formation Amazon SageMaker. Attendez la fin du travail de réglage.

5. Testez les modèles de réglage fin sur des exemples de questions liées aux services AWS

Il est maintenant temps d'effectuer quelques tests sur le modèle. Commençons par charger le modèle :

depuis peft import PeftModel, PeftConfig import torch depuis 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") modèle = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path, trust_remote_code=True) modèle = PeftModel.from_pretrained(model, "./model") model.to(device)

Chargez maintenant un exemple de question à partir de l'ensemble de données d'entraînement pour voir la réponse originale, puis posez la même question à partir du modèle optimisé pour voir la réponse en comparaison.

Voici un exemple de question de l'ensemble de formation et la réponse originale :

Maintenant, la même question est posée au modèle Falcon-7B réglé :

Ceci conclut la mise en œuvre du réglage fin de Falcon-7B sur l'ensemble de données FAQ des services AWS à l'aide du décorateur @remote du SDK Amazon SageMaker Python.

Nettoyer

Effectuez les étapes suivantes pour nettoyer vos ressources :

• Arrêtez les instances Amazon SageMaker Studio pour éviter d'engager des coûts supplémentaires.
• Nettoyez votre répertoire Amazon Elastic File System (Amazon EFS) en effaçant le répertoire de cache Hugging Face :

  rm -R ~/.cache/huggingface/hub

Conclusion

Dans cet article, nous vous avons montré comment utiliser efficacement les capacités du décorateur @remote pour affiner le modèle Falcon-7B à l'aide de QLoRA, Hugging Face PEFT avec bitsandbtyes sans appliquer de modifications significatives dans le bloc-notes de formation, et j'ai utilisé les fonctionnalités d'Amazon SageMaker pour exécuter des tâches de formation sur un cluster distant.

Tout le code présenté dans le cadre de cet article pour affiner le réglage du Falcon-7B est disponible dans le Dépôt GitHub. Le référentiel contient également un cahier montrant comment affiner Llama-13B.

Dans la prochaine étape, nous vous encourageons à consulter la fonctionnalité @remote decorator et API du SDK Python et utilisez-le dans l'environnement et l'IDE de votre choix. Des exemples supplémentaires sont disponibles dans le Amazon-sagemaker-exemples référentiel pour vous permettre de démarrer rapidement. Vous pouvez également consulter les articles suivants :

à propos des auteurs

Bruno Pistone est un architecte de solutions spécialisé en IA/ML pour AWS basé à Milan. Il travaille avec de grands clients en les aidant à comprendre en profondeur leurs besoins techniques et à concevoir des solutions d'IA et d'apprentissage automatique qui tirent le meilleur parti du cloud AWS et de la pile Amazon Machine Learning. Son expertise comprend : l'apprentissage automatique de bout en bout, l'industrialisation de l'apprentissage automatique et l'IA générative. Il aime passer du temps avec ses amis et explorer de nouveaux endroits, ainsi que voyager vers de nouvelles destinations.

Vikesh Pandey est un architecte de solutions spécialisé en apprentissage automatique chez AWS, aidant les clients des secteurs financiers à concevoir et à créer des solutions sur l'IA générative et le ML. En dehors du travail, Vikesh aime essayer différentes cuisines et pratiquer des sports de plein air.