Optimieren Sie Falcon 7B und andere LLMs auf Amazon SageMaker mit @remote decorator

Heutzutage decken generative KI-Modelle eine Vielzahl von Aufgaben ab, von der Textzusammenfassung über Fragen und Antworten bis hin zur Bild- und Videogenerierung. Um die Qualität der Ausgabe zu verbessern, werden Ansätze wie n-short learning, Prompt Engineering, Retrieval Augmented Generation (RAG) und Fine Tuning verwendet. Durch die Feinabstimmung können Sie diese generativen KI-Modelle anpassen, um eine verbesserte Leistung bei Ihren domänenspezifischen Aufgaben zu erzielen.

Mit Amazon SageMaker können Sie jetzt einen SageMaker-Trainingsjob ausführen, indem Sie einfach Ihren Python-Code mit @remote decorator annotieren. Der SageMaker Python SDK übersetzt automatisch Ihre vorhandene Arbeitsbereichsumgebung und alle damit verbundenen Datenverarbeitungscodes und Datensätze in einen SageMaker-Schulungsauftrag, der auf der Schulungsplattform ausgeführt wird. Dies hat den Vorteil, dass der Code natürlicher und objektorientierter geschrieben wird und dennoch SageMaker-Funktionen genutzt werden, um Trainingsjobs mit minimalen Änderungen auf einem Remote-Cluster auszuführen.

In diesem Beitrag zeigen wir, wie man a verfeinert Falcon-7B Foundation Models (FM) mit @remote decorator von SageMaker Python SDK. Es nutzt auch Parametereffiziente Feinabstimmung von Hugging Face (PEFT)-Bibliothek und Quantisierungstechniken durch Bits und Bytes zur Unterstützung der Feinabstimmung. Der in diesem Blog vorgestellte Code kann auch zur Feinabstimmung anderer FMs verwendet werden, z Lama-2 13b.

Es kann schwierig sein, die Darstellungen dieses Modells mit voller Präzision einzeln oder sogar bei mehreren in den Speicher zu passen Grafikprozessoren (GPUs) – oder benötigen möglicherweise sogar eine größere Instanz. Um dieses Modell ohne steigende Kosten zu verfeinern, verwenden wir daher die sogenannte Technik Quantisierte LLMs mit Low-Rank-Adaptern (QLoRA). QLoRA ist ein effizienter Feinabstimmungsansatz, der die Speichernutzung von LLMs reduziert und gleichzeitig eine sehr gute Leistung beibehält.

Vorteile der Verwendung von @remote decorator

Bevor wir fortfahren, wollen wir verstehen, wie Remote Decorator die Entwicklerproduktivität bei der Arbeit mit SageMaker verbessert:

• @remote decorator löst einen Trainingsjob direkt mit nativem Python-Code aus, ohne den expliziten Aufruf von SageMaker-Schätzern und SageMaker-Eingabekanälen
• Niedrige Eintrittsbarriere für Entwickler, die Modelle auf SageMaker schulen.
• Kein Wechsel nötig Integrierte Entwicklungsumgebungen (IDEs). Schreiben Sie weiterhin Code in der IDE Ihrer Wahl und rufen Sie SageMaker-Schulungsjobs auf.
• Sie müssen sich nicht mit Containern auskennen. Stellen Sie weiterhin Abhängigkeiten in a bereit Anforderungen.txt und stellen Sie diese dem Remote-Dekorateur zur Verfügung.

Voraussetzungen

Es ist ein AWS-Konto mit einer AWS Identity and Access Management (AWS IAM)-Rolle erforderlich, das über Berechtigungen zum Verwalten von Ressourcen verfügt, die als Teil der Lösung erstellt wurden. Einzelheiten finden Sie unter Erstellen eines AWS-Kontos.

In diesem Beitrag verwenden wir Amazon SageMaker Studio mit dem Datenwissenschaft 3.0 Bild und a ml.t3.medium Schnellstartinstanz. Sie können jedoch jede beliebige integrierte Entwicklungsumgebung (IDE) Ihrer Wahl verwenden. Sie müssen lediglich Ihre AWS Command Line Interface (AWS CLI)-Anmeldeinformationen korrekt einrichten. Weitere Informationen finden Sie unter Konfigurieren der AWS CLI.

Zur Feinabstimmung dient der Falcon-7B, ein ml.g5,12xgroß In diesem Beitrag wird die Instanz verwendet. Bitte stellen Sie sicher, dass im AWS-Konto ausreichend Kapazität für diese Instanz vorhanden ist.

Sie müssen dies klonen Github-Repository für die Replikation der in diesem Beitrag gezeigten Lösung.

Lösungsüberblick

1. Installieren Sie die Voraussetzungen für die Feinabstimmung des Falcon-7B-Modells
2. Richten Sie Remote-Decorator-Konfigurationen ein
3. Verarbeiten Sie den Datensatz mit den FAQs zu AWS-Services vor
4. Optimieren Sie Falcon-7B in den FAQs zu AWS-Services
5. Testen Sie die Feinabstimmungsmodelle anhand von Beispielfragen zu AWS-Services

1. Installieren Sie die Voraussetzungen für die Feinabstimmung des Falcon-7B-Modells

Starten Sie das Notebook falcon-7b-qlora-remote-decorator_qa.ipynb in SageMaker Studio durch Auswahl von IMagier als Datenwissenschaft Und Kernel als Python 3. Installieren Sie alle erforderlichen Bibliotheken, die im aufgeführt sind Anforderungen.txt. Einige der Bibliotheken müssen auf der Notebook-Instanz selbst installiert werden. Führen Sie andere Vorgänge aus, die für die Datensatzverarbeitung und das Auslösen eines SageMaker-Trainingsauftrags erforderlich sind.

%pip install -r require.txt %pip install -q -U Transformers==4.31.0 %pip install -q -U datasets==2.13.1 %pip install -q -U peft==0.4.0 %pip install -q -U beschleunigen ==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. Richten Sie Remote-Decorator-Konfigurationen ein

Erstellen Sie eine Konfigurationsdatei, in der alle Konfigurationen im Zusammenhang mit dem Amazon SageMaker-Schulungsjob angegeben sind. Diese Datei wird vom @remote decorator gelesen, während der Trainingsjob ausgeführt wird. Diese Datei enthält Einstellungen wie Abhängigkeiten, Trainingsbild, Instanz und die Ausführungsrolle, die für den Trainingsjob verwendet werden soll. Eine detaillierte Referenz aller von der Konfigurationsdatei unterstützten Einstellungen finden Sie hier Konfigurieren und Verwenden von Standardeinstellungen mit dem SageMaker Python SDK.

SchemaVersion: '1.0' SageMaker: PythonSDK: Module: RemoteFunction: Abhängigkeiten: ./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

Es ist nicht zwingend erforderlich, das zu verwenden config.yaml Datei, um mit dem @remote Decorator arbeiten zu können. Dies ist lediglich eine sauberere Möglichkeit, dem @remote-Dekorator alle Konfigurationen bereitzustellen. Dadurch bleiben SageMaker- und AWS-bezogene Parameter außerhalb des Codes und es entsteht ein einmaliger Aufwand für die Einrichtung der Konfigurationsdatei, die von allen Teammitgliedern verwendet wird. Alle Konfigurationen könnten auch direkt in den Decorator-Argumenten bereitgestellt werden, aber das verringert auf lange Sicht die Lesbarkeit und Wartbarkeit von Änderungen. Außerdem kann die Konfigurationsdatei von einem Administrator erstellt und für alle Benutzer in einer Umgebung freigegeben werden.

Verarbeiten Sie den Datensatz mit den FAQs zu AWS-Services vor

Der nächste Schritt besteht darin, den Datensatz zu laden und vorzuverarbeiten, um ihn für den Trainingsauftrag vorzubereiten. Schauen wir uns zunächst den Datensatz an:

Es zeigt FAQ für einen der AWS-Dienste. Zusätzlich zu QLoRA, Bitsanbyte wird zur Konvertierung in 4-Bit-Präzision verwendet, um eingefrorenes LLM auf 4-Bit zu quantisieren und anzuhängen LoRA Adapter drauf.

Erstellen Sie eine Eingabeaufforderungsvorlage, um jedes FAQ-Beispiel in ein Eingabeaufforderungsformat zu konvertieren:

from random import randint # custom instruct prompt start prompt_template = f"{{question}}\n---\nAntwort:\n{{answer}}{{eos_token}}" #-Vorlagendatensatz zum Hinzufügen einer Eingabeaufforderung zu jedem Beispieldef template_dataset (Beispiel): sample["text"] = prompt_template.format(question=sample["question"], answer=sample["answers"], eos_token=tokenizer.eos_token) Beispiel zurückgeben

Der nächste Schritt besteht darin, die Eingaben (Text) in Token-IDs umzuwandeln. Dies geschieht durch a Hugging Face Transformers Tokenizer.

from Transformers Import AutoTokenizer model_id = "tiiuae/falcon-7b" tokenizer = AutoTokenizer.from_pretrained(model_id) # Setzen Sie den Falcon-Tokenizer tokenizer.pad_token = tokenizer.eos_token

Nutzen Sie jetzt einfach die prompt_template Funktion zum Konvertieren aller FAQ in das Eingabeaufforderungsformat und zum Einrichten von Trainings- und Testdatensätzen.

4. Feinabstimmung von Falcon-7B in den FAQs zu AWS-Diensten

Jetzt können Sie das Trainingsskript vorbereiten und die Trainingsfunktion definieren train_fn und setzen Sie @remote decorator auf die Funktion.

Die Trainingsfunktion führt Folgendes aus:

• tokenisiert und segmentiert den Datensatz
• aufstellen BitsAndBytesConfig, der angibt, dass das Modell in 4-Bit geladen werden soll, während der Berechnung jedoch in konvertiert werden soll bfloat16.
• Laden Sie das Modell
• Finden Sie Zielmodule und aktualisieren Sie die erforderlichen Matrizen mithilfe der Utility-Methode find_all_linear_names
• Erstellen LoRA Konfigurationen, die die Rangfolge der Aktualisierungsmatrizen festlegen (S), Vergößerungsfaktor, Verkleinerungsfaktor (lora_alpha), die Module zum Anwenden der LoRA-Update-Matrizen (target_modules), Ausfallwahrscheinlichkeit für Lora-Schichten(lora_dropout), task_type, usw.
• Beginnen Sie mit der Schulung und Bewertung

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

Und rufe das an train_fn()

train_fn(model_id, train_dataset, test_dataset)

Der Optimierungsjob würde auf dem Amazon SageMaker-Trainingscluster ausgeführt. Warten Sie, bis der Tuning-Auftrag abgeschlossen ist.

5. Testen Sie die Feinabstimmungsmodelle anhand von Beispielfragen zu AWS-Services

Jetzt ist es an der Zeit, einige Tests am Modell durchzuführen. Laden wir zunächst das Modell:

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)

Laden Sie nun eine Beispielfrage aus dem Trainingsdatensatz, um die ursprüngliche Antwort zu sehen, und stellen Sie dann dieselbe Frage aus dem optimierten Modell, um die Antwort im Vergleich zu sehen.

Hier ist ein Beispiel für eine Frage aus dem Trainingssatz und die Originalantwort:

Nun wird die gleiche Frage an das getunte Falcon-7B-Modell gestellt:

Damit ist die Implementierung der Feinabstimmung von Falcon-7B im FAQ-Datensatz für AWS-Dienste mithilfe des @remote decorator aus dem Amazon SageMaker Python SDK abgeschlossen.

Aufräumen

Führen Sie die folgenden Schritte aus, um Ihre Ressourcen zu bereinigen:

• Fahren Sie die Amazon SageMaker Studio-Instanzen herunter, um zusätzliche Kosten zu vermeiden.
• Bereinigen Sie Ihr Amazon Elastic File System (Amazon EFS)-Verzeichnis, indem Sie das Hugging Face-Cache-Verzeichnis löschen:

  rm -R ~/.cache/huggingface/hub

Abschluss

In diesem Beitrag haben wir Ihnen gezeigt, wie Sie die Funktionen des @remote decorators effektiv zur Feinabstimmung des Falcon-7B-Modells mithilfe von QLoRA und Hugging Face PEFT nutzen können bitsandbtyes ohne wesentliche Änderungen im Trainingsnotizbuch vorzunehmen und Amazon SageMaker-Funktionen zu nutzen, um Trainingsjobs auf einem Remote-Cluster auszuführen.

Der gesamte in diesem Beitrag gezeigte Code zur Feinabstimmung von Falcon-7B ist im verfügbar GitHub-Repository. Das Repository enthält auch ein Notizbuch, das die Feinabstimmung von Llama-13B zeigt.

Als nächsten Schritt empfehlen wir Ihnen, sich die @remote decorator-Funktionalität anzusehen und Python SDK-API und verwenden Sie es in der Umgebung und IDE Ihrer Wahl. Weitere Beispiele finden Sie im Amazon-Sagemaker-Beispiele Repository, damit Sie schnell loslegen können. Sie können sich auch die folgenden Beiträge ansehen:

Über die Autoren

Bruno Pistone ist ein KI/ML-Spezialist für Lösungsarchitekten für AWS mit Sitz in Mailand. Er arbeitet mit großen Kunden zusammen und hilft ihnen dabei, ihre technischen Anforderungen genau zu verstehen und KI- und maschinelle Lernlösungen zu entwickeln, die die AWS Cloud und den Amazon Machine Learning-Stack optimal nutzen. Zu seinen Fachkenntnissen gehören: End-to-End-Maschinelles Lernen, Industrialisierung des Maschinellen Lernens und Generative KI. Er genießt es, Zeit mit seinen Freunden zu verbringen, neue Orte zu erkunden und zu neuen Zielen zu reisen.

Vikesh Pandey ist ein auf maschinelles Lernen spezialisierter Lösungsarchitekt bei AWS und unterstützt Kunden aus der Finanzbranche beim Entwerfen und Erstellen von Lösungen für generative KI und ML. Außerhalb der Arbeit probiert Vikesh gerne verschiedene Küchen aus und betreibt Sport im Freien.