Verteilte Feinabstimmung eines großen BERT-Modells für eine Frage-Antwort-Aufgabe mit Hugging Face Transformers auf Amazon SageMaker

Neuauflage von Plato

Verfolger: 0

Vom Training neuer Modelle bis zum Einsatz in der Produktion, Amazon Sage Maker bietet den umfassendsten Satz an Tools für Start-ups und Unternehmen, um die Leistungsfähigkeit von maschinellem Lernen (ML) und Deep Learning zu nutzen.

Mit seiner Open-Source-Bibliothek Transformers und seiner ML-Plattform macht Hugging Face Transfer Learning und die neuesten ML-Modelle für die globale KI-Community zugänglich und reduziert so die Zeit, die Datenwissenschaftler und ML-Ingenieure in Unternehmen auf der ganzen Welt benötigen, um von jeder neuen wissenschaftlichen Erkenntnis zu profitieren Förderung.

Die Anwendung von Transformern auf neue NLP-Aufgaben oder -Domänen erfordert die Feinabstimmung großer Sprachmodelle, eine Technik, die das gesammelte Wissen vortrainierter Modelle nutzt, um sie in einem zusätzlichen, effizienten Trainingsprozess an eine neue Aufgabe oder einen bestimmten Dokumententyp anzupassen.

Die Feinabstimmung des Modells zur Erstellung genauer Vorhersagen für das vorliegende Geschäftsproblem erfordert das Training großer Transformers-Modelle, z. B. BERT, BART, RoBERTa, T5, deren skalierbare Ausführung schwierig sein kann.

Hugging Face hat bei der Umsetzung eng mit SageMaker zusammengearbeitet gebrauchsfertige Deep-Learning-Container (DLCs), die das Training und die Bereitstellung der neuesten Transformers-Modelle einfacher und schneller als je zuvor machen. Da Funktionen wie SageMaker Data Parallel (SMDP), SageMaker Model Parallel (SMMP) und S3-Pipe-Modus in den Container integriert sind, verkürzt die Verwendung dieser Funktionen die Zeit für Unternehmen drastisch, um Transformers-basierte ML-Lösungen wie Fragenbeantwortung und Generierung zu erstellen Text und Bilder, Optimierung der Suchergebnisse und Verbesserung der Automatisierung des Kundensupports, Konversationsschnittstellen, semantische Suche, Dokumentenanalysen und viele weitere Anwendungen.

In diesem Beitrag konzentrieren wir uns auf die tiefe Integration von verteilten SageMaker-Bibliotheken mit Hugging Face, die es Data Scientists ermöglicht, das Training und die Feinabstimmung von Transformers-Modellen von Tagen auf Stunden zu beschleunigen, alles in SageMaker.

Überblick über das verteilte Training

ML-Praktiker und Datenwissenschaftler stehen beim Trainieren von Modellen vor zwei Skalierungsherausforderungen: Skalierung der Modellgröße (Anzahl der Parameter und Schichten) und Skalierung der Trainingsdaten. Das Skalieren entweder der Modellgröße oder der Trainingsdaten kann zu einer besseren Genauigkeit führen, aber es kann Fälle beim Deep Learning geben, in denen die Speichermenge auf dem Beschleuniger (CPU oder GPU) die Kombination aus der Größe der Trainingsdaten und der Größe der Modell. Wenn Sie beispielsweise ein großes Sprachmodell trainieren, ist die Stapelgröße häufig auf eine kleine Anzahl von Beispielen beschränkt, was zu einem weniger genauen Modell führen kann.

Verteiltes Training kann die Arbeitslast zum Trainieren des Modells auf mehrere Prozessoren aufteilen, genannt Arbeiter. Diese Arbeiter arbeiten parallel, um das Modelltraining zu beschleunigen.

Basierend auf dem, was wir skalieren möchten (Modell oder Daten), gibt es zwei Ansätze für verteiltes Training: Datenparallel und Modellparallel.

Datenparallelität ist der häufigste Ansatz für verteiltes Training. Bei der Datenparallelität wird eine Kopie der Modellarchitektur erstellt und auf verschiedenen Beschleunigern gewichtet. Anstatt den gesamten Trainingssatz an einen einzelnen Beschleuniger weiterzugeben, können wir dann den Trainingssatz auf die verschiedenen Beschleuniger aufteilen und den Trainingssatz schneller durchlaufen. Obwohl dies den Schritt hinzufügt, dass die Beschleuniger ihre Gradienteninformationen an einen Parameterserver zurückmelden müssen, wird diese Zeit durch die Geschwindigkeitssteigerung der Iteration über einen Bruchteil des gesamten Datensatzes pro Beschleuniger mehr als ausgeglichen. Aus diesem Grund kann die Datenparallelität erheblich dazu beitragen, die Trainingszeiten zu verkürzen. Beispielsweise dauert das Training eines einzelnen Modells ohne Parallelisierung 4 Stunden. Durch die Verwendung von verteiltem Training kann dies auf 24 Minuten reduziert werden. Das verteilte SageMaker-Training implementiert auch modernste Techniken in Gradientenaktualisierungen.

Bei großen Modellen, die zu groß sind, um auf einen Beschleuniger (GPU) zu passen, wird ein modellparalleler Ansatz verwendet. Dieser Ansatz implementiert eine Parallelisierungsstrategie, bei der die Modellarchitektur in Shards unterteilt und auf verschiedenen Beschleunigern platziert wird. Die Konfiguration jedes dieser Shards hängt von der Architektur des neuronalen Netzwerks ab und umfasst typischerweise mehrere Schichten. Die Kommunikation zwischen den Beschleunigern erfolgt jedes Mal, wenn die Trainingsdaten von einem der Shards zum nächsten übertragen werden.

Zusammenfassend lässt sich sagen, dass Sie die verteilte Trainingsdatenparallelität für zeitintensive Aufgaben aufgrund großer Datasets verwenden sollten oder wenn Sie Ihre Trainingsexperimente beschleunigen möchten. Sie sollten die Modellparallelität verwenden, wenn Ihr Modell nicht auf einen Beschleuniger passt.

Voraussetzungen:

Um verteiltes Training von Hugging Face Transformers-Modellen in SageMaker durchzuführen, müssen Sie die folgenden Voraussetzungen erfüllen:

Implementieren Sie verteiltes Training

Die Hugging Face Transformers-Bibliothek bietet eine Trainer-API, die zum Trainieren oder Feinabstimmen der von der Bibliothek bereitgestellten Modelle optimiert ist. Sie können es auch für Ihre eigenen Modelle verwenden, wenn sie genauso funktionieren wie Transformers-Modelle. sehen Trainer:innen für mehr Details. Diese API wird in unserem verwendet Beispielskripte, die zeigen, wie die Daten für verschiedene NLP-Aufgaben vorverarbeitet werden, die Sie als Modelle verwenden können, um ein Skript zu schreiben, das Ihr eigenes benutzerdefiniertes Problem löst. Das Versprechen der Trainer-API ist, dass dieses Skript in jedem verteilten Setup, einschließlich SageMaker, sofort einsatzbereit ist.

Die Trainer-API übernimmt alles, was für das Training benötigt wird. Dazu gehören Ihre Datensätze, Ihr Modell (oder eine Funktion, die Ihr Modell zurückgibt), a compute_metrics Funktion, die die Metriken, die Sie verfolgen möchten, aus den Arrays von Vorhersagen und Labels zurückgibt, Ihren Optimierer und Lernratenplaner (gute Standardwerte werden bereitgestellt) sowie alle Hyperparameter, die Sie für Ihr Training optimieren können, gruppiert in einer Datenklasse namens TrainingArguments. Mit all dem stellt es drei Methoden bereit – Trainieren, Bewerten und Vorhersagen – um Ihr Modell zu trainieren, die Metrikergebnisse für beliebige Datensätze abzurufen oder die Vorhersagen für beliebige Datensätze abzurufen. Weitere Informationen zum Trainer-Objekt finden Sie unter Feinabstimmung eines Modells mit der Trainer-API und das Video Die Trainer-API, das Sie durch ein einfaches Beispiel führt.

Hinter den Kulissen beginnt die Trainer-API mit der Analyse der Umgebung, in der Sie Ihr Skript starten, wenn Sie das erstellen TrainingArguments. Wenn Sie beispielsweise Ihr Training mit SageMaker gestartet haben, sieht es sich die an SM_FRAMEWORK_PARAMS Variable in der Umgebung, um zu erkennen, ob Sie SageMaker-Datenparallelität oder Modellparallelität aktiviert haben. Dann ruft es die relevanten Variablen (wie den Rang des Prozesses oder die Weltgröße) aus der Umgebung ab, bevor es die notwendigen Initialisierungsschritte durchführt (wie z smdistributed.dataparallel.torch.distributed.init_process_group()).

Der Trainer enthält die gesamte Trainingsschleife, sodass er die erforderlichen Schritte anpassen kann, um dies sicherzustellen smdistributed.dataparallel Backend wird bei Bedarf verwendet, ohne dass Sie eine Codezeile in Ihrem Skript ändern müssen. Es kann immer noch (wenn auch viel langsamer) auf Ihrem lokalen Computer zum Debuggen ausgeführt werden. Es handhabt das Sharding Ihres Datensatzes so, dass jeder Prozess automatisch verschiedene Samples sieht, mit einer Neuordnung in jeder Epoche, Synchronisierung Ihrer Gradienten vor dem Optimierungsschritt, gemischtem Präzisionstraining, wenn Sie es aktiviert haben, Gradientenakkumulation, wenn Sie keine große Batchgröße unterbringen können Ihre GPUs und viele weitere Optimierungen.

Wenn Sie die Modellparallelität aktiviert haben, stellt sie sicher, dass die Prozesse, die dieselben Daten sehen müssen (falls ihre dp_rank ist das gleiche) bekommen die gleichen Chargen, und das mit unterschiedlichen Prozessen dp_rank sehen Sie nicht die gleichen Proben, wieder mit einer Neuordnung in jeder Epoche. Es stellt sicher, dass die Zustandswörterbücher des Modells oder der Optimierer beim Checkpointing ordnungsgemäß synchronisiert werden, und übernimmt erneut alle Optimierungen wie gemischte Genauigkeit und Gradientenakkumulation.

Bei Verwendung der Bewertungs- und Vorhersagemethoden führt der Trainer eine verteilte Bewertung durch, um alle Ihre GPUs zu nutzen. Es handhabt die Aufteilung Ihrer Daten für jeden Prozess ordnungsgemäß (Prozess derselben dp_rank wenn die Modellparallelität aktiviert ist) und stellt sicher, dass die Vorhersagen ordnungsgemäß in derselben Reihenfolge wie das von Ihnen verwendete Dataset erfasst werden, bevor sie an gesendet werden compute_metrics Funktion oder gerade zurückgegeben. Die Verwendung der Trainer-API ist nicht obligatorisch. Benutzer können weiterhin Keras oder PyTorch innerhalb von Hugging Face verwenden. Die Trainer-API kann jedoch eine hilfreiche Abstraktionsschicht bereitstellen.

Trainieren Sie ein Modell mit SageMaker Hugging Face Estimators

Ein Estimator ist eine High-Level-Schnittstelle für das SageMaker-Training und verarbeitet End-to-End-SageMaker-Trainings- und Bereitstellungsaufgaben. Das Training Ihres Skripts wird aufgerufen, wenn Sie es aufrufen fit auf einem HuggingFace Schätzer. Im Estimator definieren Sie, welches Feinabstimmungsskript verwendet werden soll entry_point, Die instance_type verwenden und welche Hyperparameter übergeben werden. Weitere Informationen zu HuggingFace Parameter siehe Umarmungs-Gesichtsschätzer.

Verteiltes Training: Daten parallel

In diesem Beispiel verwenden wir die neuen Hugging Face DLCs und das SageMaker SDK, um ein verteiltes Seq2Seq-Transformer-Modell mit der Frage-und-Antwort-Aufgabe unter Verwendung der Transformers- und Dataset-Bibliotheken zu trainieren. Der bert-large-uncased-ganze-wort-maskierung Modell ist auf die Feinabstimmung Kader Datensatz.

Die folgenden Codebeispiele zeigen Ihnen die Schritte zum Erstellen einer HuggingFace Schätzer für verteiltes Training mit Datenparallelität.

Wählen Sie ein Hugging Face Transformers-Skript:

# git configuration to download our fine-tuning script
git_config = {'repo': 'https://github.com/huggingface/transformers.git','branch': 'v4.6.1'}

Wenn Sie ein erstellen HuggingFace Estimator können Sie ein in einem GitHub-Repository gespeichertes Trainingsskript als Einstiegspunkt für den Estimator angeben, sodass Sie die Skripts nicht lokal herunterladen müssen. Sie können verwenden git_config , um die Hugging Face Transformers-Beispielskripte und den rechten 'Zweig' auszuführen, wenn Sie transformers_version muss konfiguriert werden. Wenn Sie zum Beispiel verwenden transformers_version 4.6.1, müssen Sie 'branch':'v4.6.1'.

Konfigurieren Sie Trainings-Hyperparameter, die an den Trainingsjob übergeben werden:

# hyperparameters, which are passed into the training job
hyperparameters={ 'model_name_or_path': 'bert-large-uncased-whole-word-masking', 'dataset_name':'squad', 'do_train': True, 'do_eval': True, 'fp16': True, 'per_device_train_batch_size': 4, 'per_device_eval_batch_size': 4, 'num_train_epochs': 2, 'max_seq_length': 384, 'max_steps': 100, 'pad_to_max_length': True, 'doc_stride': 128, 'output_dir': '/opt/ml/model'
}

Als Hyperparameter können wir beliebig definieren Seq2SeqTrainingArgumente und die im Trainingsskript definierten.

Definieren Sie die Verteilungsparameter in der HuggingFace Schätzer:

# configuration for running training on smdistributed Data Parallel
distribution = {'smdistributed':{'dataparallel':{ 'enabled': True }}}

Sie können die Verwendung SageMaker-Datenparallelitätsbibliothek sofort einsatzbereit für verteiltes Training. Wir haben die Funktionalität der Datenparallelität direkt in den Trainer integriert. Um die Datenparallelität zu aktivieren, können Sie einfach einen einzelnen Parameter zu Ihrer hinzufügen HuggingFace Estimator, damit Ihr Trainer-basierter Code ihn automatisch verwendet.

Erstellen Sie HuggingFace Schätzer einschließlich der in den vorherigen Schritten definierten Parameter und Start des Trainings:

from sagemaker.huggingface import HuggingFace
# estimator
huggingface_estimator = HuggingFace(entry_point='run_qa.py', source_dir='./examples/pytorch/question-answering', git_config=git_config, instance_type= 'ml.p3.16xlarge', instance_count= 2, volume_size= 200, role= <SageMaker Role>, # IAM role, transformers_version='4.6', pytorch_version='1.7', py_version='py36', distribution= distribution, hyperparameters = hyperparameters) # starting the train job huggingface_estimator.fit()

Das Hugging Face Transformers-Repository enthält mehrere Beispiele und Skripte zur Feinabstimmung von Modellen für Aufgaben von der Sprachmodellierung bis zur Token-Klassifizierung. In unserem Fall verwenden wir run_qa.py von dem examples/pytorch/question-answering Beispiele.

smdistributed.dataparallel unterstützt das Modelltraining auf SageMaker mit nur die folgenden Instanztypen. Für die beste Leistung empfehlen wir die Verwendung eines Instance-Typs, der unterstützt Adapter aus elastischem Stoff (EFA):

ml.p3.16xgroß
ml.p3dn.24xlarge (empfohlen)
ml.p4d.24xlarge (empfohlen)

Um die beste Leistung und das Beste aus sich herauszuholen SMDataParallelverwenden, sollten Sie mindestens zwei Instanzen verwenden, aber Sie können auch eine zum Testen dieses Beispiels verwenden.

Folgende Beispiel Notizbuch bietet eine detaillierte Schritt-für-Schritt-Anleitung.

Verteiltes Training: Parallel modellieren

Für das verteilte Training mit Modellparallelität verwenden wir die Hugging Face Transformers- und Datensatzbibliothek zusammen mit dem SageMaker SDK für die Sequenzklassifizierung auf der Allgemeine Bewertung des Sprachverständnisses (GLUE) Benchmark auf einem Multi-Node-Multi-GPU-Cluster mit dem SageMaker-Modellparallelismusbibliothek.

Wie bei der Datenparallelität legen wir zunächst die Git-Konfiguration, Trainings-Hyperparameter und Verteilungsparameter in der HuggingFace Schätzer:

# git configuration to download our fine-tuning script
git_config = {'repo': 'https://github.com/huggingface/transformers.git','branch': 'v4.6.1'} # hyperparameters, which are passed into the training job
hyperparameters={ 'model_name_or_path':'roberta-large', 'task_name': 'mnli', 'per_device_train_batch_size': 16, 'per_device_eval_batch_size': 16, 'do_train': True, 'do_eval': True, 'do_predict': True, 'num_train_epochs': 2, 'output_dir':'/opt/ml/model', 'max_steps': 500,
} # configuration for running training on smdistributed Model Parallel
mpi_options = { "enabled" : True, "processes_per_host" : 8,
}
smp_options = { "enabled":True, "parameters": { "microbatches": 4, "placement_strategy": "spread", "pipeline": "interleaved", "optimize": "speed", "partitions": 4, "ddp": True, }
} distribution={ "smdistributed": {"modelparallel": smp_options}, "mpi": mpi_options
}

Die Bibliothek für die Modellparallelität verwendet intern MPI. Um die Modellparallelität zu verwenden, muss MPI also mithilfe des Verteilungsparameters aktiviert werden. „processes_per_host” im vorhergehenden Code gibt die Anzahl der Prozesse an, die MPI auf jedem Host starten soll. Wir empfehlen diese zur Entwicklung und zum Testen. Zur Produktionszeit können Sie sich an den AWS-Support wenden, wenn Sie umfangreiche GPU-Kapazität anfordern. Weitere Informationen finden Sie unter Führen Sie einen parallelen Trainingsjob für verteilte SageMaker-Modelle aus.

Folgende Beispiel Notizbuch enthält die vollständigen Codeskripte.

Spot Instances

Mit der Hugging Face-Framework-Erweiterung für das SageMaker-Python-SDK können wir auch vollständig verwaltete Funktionen nutzen Amazon Elastic Compute-Cloud (Amazon EC2) Spot Instances und sparen Sie bis zu 90 % unserer Schulungskosten.

Sofern Ihr Trainingsjob nicht schnell abgeschlossen wird, empfehlen wir Ihnen die Verwendung Checkpointing mit verwaltetem Spot-Training, daher müssen Sie definieren checkpoint_s3_uri.

Um Spot-Instances mit der HuggingFace Schätzer, wir müssen das einstellen use_spot_instances Parameter auf True und definieren Sie Ihre max_wait und max_run Zeit. Weitere Informationen zum Managed Spot-Trainingslebenszyklus finden Sie unter Verwaltete Spot-Schulung in Amazon SageMaker.

Das Folgende ist ein Code-Snippet zum Einrichten eines Spot-Training-Schätzers:

from sagemaker.huggingface import HuggingFace # hyperparameters, which are passed into the training job
hyperparameters={'epochs': 1, 'train_batch_size': 32, 'model_name':'distilbert-base-uncased', 'output_dir':'/opt/ml/checkpoints' } # s3 uri where our checkpoints will be uploaded during training
job_name = "using-spot"
checkpoint_s3_uri = f's3://{sess.default_bucket()}/{job_name}/checkpoints' huggingface_estimator = HuggingFace(entry_point='train.py', source_dir='./scripts', instance_type='ml.p3.2xlarge', instance_count=1, base_job_name=job_name, checkpoint_s3_uri=checkpoint_s3_uri, use_spot_instances=True, max_wait=3600, # This should be equal to or greater than max_run in seconds' max_run=1000, # expected max run in seconds role=role, transformers_version='4.6', pytorch_version='1.7', py_version='py36', hyperparameters = hyperparameters)

Folgende Notizbuch enthält die vollständigen Codeskripte.

Zusammenfassung

In diesem Beitrag haben wir das verteilte Training von Hugging Face Transformers mit SageMaker besprochen. Wir haben zuerst die Anwendungsfälle für Datenparallelität vs. Modellparallelität überprüft. Die Datenparallelität ist in der Regel besser geeignet, aber nicht unbedingt darauf beschränkt, wenn das Training durch Rechenleistung beeinträchtigt wird, während Sie die Modellparallelität verwenden können, wenn ein Modell nicht in den Arbeitsspeicher passt, der auf einem einzelnen Beschleuniger bereitgestellt wird. Wir haben dann gezeigt, wie man mit beiden Methoden trainiert.

In dem von uns besprochenen Anwendungsfall für Datenparallelität dauert das Trainieren eines Modells auf einer einzelnen p3.2xlarge-Instanz (mit einer einzelnen GPU) 4 Stunden und kostet zum Zeitpunkt der Erstellung dieses Artikels etwa 15 US-Dollar. Mit Datenparallelität können wir dasselbe Modell in 24 Minuten zu einem Preis von 28 $ trainieren. Obwohl sich die Kosten verdoppelt haben, hat dies die Trainingszeit um den Faktor 10 reduziert. Für eine Situation, in der Sie viele Modelle innerhalb kurzer Zeit trainieren müssen, kann die Datenparallelität dies zu einem relativ geringen Kostenanstieg ermöglichen. Was den Anwendungsfall der Modellparallelität betrifft, fügt er die Möglichkeit hinzu, Modelle zu trainieren, die zuvor aufgrund von Hardwareeinschränkungen überhaupt nicht hätten trainiert werden können. Beide Funktionen ermöglichen neue Arbeitsabläufe für ML-Experten und sind über die leicht zugänglich HuggingFace Estimator als Teil des SageMaker Python SDK. Die Bereitstellung dieser Modelle auf gehosteten Endpunkten erfolgt nach demselben Verfahren wie bei anderen Estimators.

Diese Integration aktiviert andere Funktionen, die Teil des SageMaker-Ökosystems sind. Sie können beispielsweise Spot-Instances verwenden, indem Sie dem Estimator für eine zusätzliche Kostenoptimierung ein einfaches Flag hinzufügen. Als nächsten Schritt können Sie die Trainingsdemo und Beispiel Notizbuch.

Über die Autoren

Archis Joglekar ist ein AI/ML Partner Solutions Architect im Emerging Technologies-Team. Er interessiert sich für performantes, skalierbares Deep Learning und wissenschaftliches Rechnen mit den Bausteinen von AWS. Seine bisherigen Erfahrungen reichen von computergestützter Physikforschung bis zur Entwicklung von Plattformen für maschinelles Lernen in der Wissenschaft, in nationalen Labors und in Startups. Die Zeit abseits des Computers verbringt er mit Fußballspielen und mit Freunden und Familie.

James Yi ist Senior AI/ML Partner Solutions Architect im Team Emerging Technologies bei Amazon Web Services. Er arbeitet leidenschaftlich gerne mit Unternehmenskunden und -partnern zusammen, um KI/ML-Anwendungen zu entwerfen, bereitzustellen und zu skalieren, um deren Geschäftswerte abzuleiten. Außerhalb der Arbeit spielt er gerne Fußball, reist und verbringt gerne Zeit mit seiner Familie.

Philipp Schmidt ist Machine Learning Engineer und Tech Lead bei Hugging Face, wo er die Zusammenarbeit mit dem Amazon SageMaker-Team leitet. Seine Leidenschaft gilt der Demokratisierung, Optimierung und Produktion modernster NLP-Modelle und der Verbesserung der Benutzerfreundlichkeit von Deep Learning.

Sylvain Gugger ist Forschungsingenieur bei Hugging Face und einer der Hauptbetreuer der Transformers-Bibliothek. Er liebt Open-Source-Software und hilft der Community, sie zu nutzen.

Jeff Boudier entwickelt Produkte bei Hugging Face, dem Entwickler von Transformers, der führenden Open-Source-ML-Bibliothek. Zuvor war Jeff Mitbegründer von Stupeflix, das von GoPro übernommen wurde, wo er als Direktor für Produktmanagement, Produktmarketing, Geschäftsentwicklung und Unternehmensentwicklung tätig war.