Erstellen, trainieren und implementieren Sie mit TensorFlow und Amazon SageMaker ein Sprachmodell mit Milliarden Parametern auf Terabytes von Daten

Die zunehmende Größe von Sprachmodellen war in den letzten Jahren einer der größten Trends in der Verarbeitung natürlicher Sprache (NLP). Seit 2018 haben wir eine beispiellose Entwicklung und Bereitstellung immer größerer Sprachmodelle erlebt, darunter BERT und seine Varianten GPT-2, T-NLG und GPT-3 (175 Milliarden Parameter).

Diese Modelle haben die Grenzen möglicher architektonischer Innovationen verschoben. Beim Training von Deep-Learning-Modellen im großen Maßstab stehen wir vor mehreren Herausforderungen, insbesondere der neuen Welle generativer vortrainierter Transformer. Zu diesen Herausforderungen gehören Hardwarebeschränkungen und Kompromisse bei der Berechnung und Effizienz. Um diese Herausforderungen der Modell- und Datenparallelität zu bewältigen, bietet AWS eine breite Palette von Funktionen.

In diesem Beitrag stellen wir zwei Hauptansätze vor: Datenparallelisierung und Modellparallelisierung mit Amazon Sage Maker, und diskutieren Sie ihre Vor- und Nachteile.

Das Modell

Für das Sprachmodell verwenden wir Transformers, die im Artikel vorgestellt werden Aufmerksamkeit ist alles was Sie brauchen. Transformer sind Deep-Learning-Modelle, die entwickelt wurden, um die Fallstricke von RNNs bewusst zu vermeiden, indem sie sich auf einen Selbstaufmerksamkeitsmechanismus verlassen, um globale Abhängigkeiten zwischen Eingabe und Ausgabe herzustellen. Die Transformer-Modellarchitektur ermöglicht eine deutlich bessere Parallelisierung und kann in relativ kurzer Trainingszeit eine hohe Leistung erzielen. Aufbauend auf dem Erfolg von Transformers, BERT, vorgestellt in der Zeitung BERT: Vorschulung von tiefen bidirektionalen Transformatoren für das Sprachverständnis, bidirektionales Vortraining für die Sprachdarstellung hinzugefügt. Inspiriert von der Cloze-Aufgabe ist BERT mit maskierter Sprachmodellierung (MLM) vortrainiert, bei der das Modell lernt, die ursprünglichen Wörter für zufällig maskierte Token wiederherzustellen. Das BERT-Modell ist auch auf die Aufgabe zur Vorhersage des nächsten Satzes (NSP) vortrainiert, um vorherzusagen, ob zwei Sätze in der richtigen Lesereihenfolge sind. Seit seiner Einführung im Jahr 2018 werden BERT und seine Variationen häufig in Sprachmodellen verwendet.

Wir beginnen mit der Erstellung von zwei Einbettungsebenen für Token- und Positionseinbettung. Die Eingabeeinbettungen sind die Summe der Tokeneinbettungen und Positionseinbettungen.

class TokenAndPositionEmbedding(tf.keras.layers.Layer): """ Creates two separate embedding layers: one for tokens and one for token index (positions). """ def __init__(self, maxlen, vocab_size, embed_dim): super(TokenAndPositionEmbedding, self).__init__() self.token_emb = tf.keras.layers.Embedding(input_dim=vocab_size, output_dim=embed_dim) self.pos_emb = tf.keras.layers.Embedding(input_dim=maxlen, output_dim=embed_dim) def call(self, x): maxlen = tf.shape(x)[-1] # positions are represented by a token's index positions = tf.range(start=0, limit=maxlen, delta=1) positions = self.pos_emb(positions) # token embedding x = self.token_emb(x) # return sum as input return x + positions

Dann definieren wir einen Transformator-Decoder-Block mit zwei Unterschichten: einer Mehrkopf-Selbstaufmerksamkeitsschicht und einem einfachen, vollständig verbundenen Feed-Forward-Netzwerk, gefolgt von Schichtnormalisierung und Ausfall:

class TransformerBlock(tf.keras.layers.Layer): def __init__(self, embed_dim, num_heads, ff_dim, rate=0.1): # self attention layer super(TransformerBlock, self).__init__() self.att = tf.keras.layers.MultiHeadAttention( num_heads=num_heads, key_dim=embed_dim) # feed forward layer self.ffn = [tf.keras.layers.Dense(ff_dim, activation="relu"), tf.keras.layers.Dense(embed_dim)] # layer normalization self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6) self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6) # dropout self.dropout1 = tf.keras.layers.Dropout(rate) self.dropout2 = tf.keras.layers.Dropout(rate) def call(self, inputs): # getting batch size and seq len from input shape input_shape = tf.shape(inputs) batch_size = input_shape[0] seq_len = input_shape[1] # decoder casual mask casual_mask = casual_attention_mask(batch_size, seq_len, seq_len, tf.bool) # self attention forward pass attention_output = self.att(inputs, inputs, attention_mask=causal_mask) # dense layers, dropout and normalization attention_output = self.dropout1(attention_output) ffn_output = self.ffn[0](out1) ffn_output = self.ffn[1](ffn_output) out2 = self.dropout2(ffn_output) return self.layernorm2(out1 + out2)

Schließlich erstellen wir unser Sprachmodell mit der vorangehenden Einbettungsschicht und Transformatorblöcken:

class MyModel(tf.keras.Model): def __init__(self, maxlen, vocab_size, embed_dim, num_heads, feed_forward_dim, num_layers, learning_rate): super(MyModel, self).__init__(maxlen, vocab_size, embed_dim, num_heads, feed_forward_dim, num_layers, learning_rate) # embedding layer self.embedding_layer = TokenAndPositionEmbedding(maxlen, vocab_size, embed_dim) # transformer blocks self.transformer_blocks = [ TransformerBlock(embed_dim, num_heads, feed_forward_dim) for i in range(num_layers) ] # last dense layer self.dense = tf.keras.layers.Dense(vocab_size) def call(self, inputs, training=None): x_emb = self.embedding_layer(inputs) x = x_emb for transformer_block in self.transformer_blocks: x = transformer_block(x) outputs = self.dense(x) return [outputs, x_emb] def init_train_settings(maxlen, vocab_size, embed_dim, num_heads, feed_forward_dim, num_layers, learning_rate): """ Creates model, optimizer and loss function """ model = MyModel(maxlen, vocab_size, embed_dim, num_heads, feed_forward_dim, num_layers, learning_rate) loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate) return model, optimizer, loss_fn

Abhängig von Ihren Hyperparametern können Sie dieses Modell von Tausenden von Parametern auf Milliarden von Parametern skalieren. Die größte Herausforderung bei Modellen mit Milliarden Parametern besteht darin, dass Sie das Modell nicht in einer Instanz hosten können und das Modell zum Trainieren und Ableiten auf mehrere Knoten verteilen müssen.

Der Datensatz

In unseren Experimenten verwendeten wir die Stapeldatensatz. The Pile ist ein englisches Text-Dataset mit 800 GiB, das zum Trainieren umfangreicher Sprachmodelle entwickelt wurde. Es wird aus 22 unterschiedlichen und qualitativ hochwertigen Datensätzen erstellt, darunter sowohl etablierte als auch neu eingeführte NLP-Datensätze.

Der Datensatz wird aus einer Vielzahl von Datenquellen erstellt, einschließlich Büchern; GitHub-Repositorys; Webseiten; Chat-Protokolle; und medizinische, physikalische, mathematische, Informatik- und Philosophiearbeiten. Insbesondere werden die folgenden Quellen verwendet: Pile-CC, PubMed Central, ArXiv, GitHub, das FreeLaw Project, Stack Exchange, das US Patent and Trademark Office, PubMed, Ubuntu, IRC, HackerNews, YouTube, PhilPapers, Books3, Project Gutenberg ( PG-19), OpenSubtitles, englische Wikipedia, DM Mathematics, EuroParl, das Enron Emails-Korpus und NIH ExPorter. Es enthält auch OpenWebText2 und BookCorpus2, die Erweiterungen der ursprünglichen OpenWebText- bzw. BookCorpus-Datensätze sind. Die Vielfalt der Datenquellen kann das allgemeine domänenübergreifende Wissen verbessern und folglich nachgelagerte Generalisierungsfähigkeiten verbessern.

Die größte Herausforderung bei diesem Datensatz ist die schiere Größe; Das Dataset hat 825 GiB Text, was 4.2 TiB vorverarbeiteter und komprimierter Datenpunkte entspricht. Ähnlich wie bei den Herausforderungen, vor denen wir beim Trainieren und Hosten der Modelle stehen, wird das Trainieren eines Modells mit diesem Dataset auf einer einzelnen Instanz viel Zeit in Anspruch nehmen und ist nicht praktikabel.

Unsere Lösung besteht darin, den Datensatz in Datenblöcke von etwa 1 GiB zu zerlegen, die Features zu laden und vorzuverarbeiten TensorFlow-Datensatz Objekte und speichern Sie sie darin Amazon Elastic File Service (Amazon EFS). TensorFlow-Datensätze bieten eine benutzerfreundliche und leistungsstarke Datenpipeline, die sich gut in unsere Modelle integrieren lässt. Amazon EFS ist ein benutzerfreundlicher Service, mit dem wir ein gemeinsam genutztes Dateisystem aufbauen können, das automatisch skaliert, wenn Dateien hinzugefügt und gelöscht werden. Darüber hinaus kann Amazon EFS bei Bedarf auf höhere Durchsatzniveaus hochgefahren werden, was für unsere Daten- und Modelltrainingspipeline von entscheidender Bedeutung ist.

Als nächstes untersuchen wir verteilte Trainingsstrategien, um diese Herausforderungen zu bewältigen.

Verteiltes Training

In diesem Projekt standen wir vor zwei Herausforderungen: Skalierung der Modellgröße und des Datenvolumens. Das Erhöhen der Modellgröße und der Anzahl der trainierbaren Parameter kann zu einer besseren Genauigkeit führen, aber das Modell, das Sie in einen einzelnen GPU-Speicher oder sogar mehrere GPUs in einer einzigen Instanz einbauen können, ist begrenzt. Darüber hinaus benötigen größere Modellgrößen mehr Zeit zum Trainieren.

Sie können diese Herausforderungen auf zwei verschiedene Arten angehen: Datenparallelität und Modellparallelität. Mit Datenparallelität führen wir einen stochastischen Gradientenabstieg (SGD) durch, indem wir die Aufzeichnungen eines Mini-Batches auf verschiedene Geräte verteilen, um das Training zu beschleunigen. Das parallele Datentraining ist jedoch mit einer zusätzlichen Komplexität der Berechnung des Mini-Batch-Gradientendurchschnitts mit Gradienten von allen Geräten verbunden, einem Schritt, der als „Schritt“ bezeichnet wird AllReduce, was schwieriger wird, wenn der Trainingscluster wächst. Bei der Verwendung von Datenparallelität müssen wir in der Lage sein, das Modell und einen einzelnen Datenpunkt in einem Gerät (CPU oder GPU) unterzubringen, was bei unseren Experimenten ein einschränkender Faktor ist, da die Größe eines so großen Modells viel größer ist als der Speicher der einzelnen GPU Größe.

Eine andere Lösung ist die Verwendung von Modellparallelität, die das Modell auf mehrere Geräte aufteilt. Modellparallelität ist der Prozess der Aufteilung eines Modells auf mehrere Geräte oder Knoten (z. B. GPU-ausgestattete Instanzen) und die Erstellung einer effizienten Pipeline zum Trainieren des Modells über diese Geräte hinweg, um die GPU-Auslastung zu maximieren.

Datenparallelisierung

Das Parallelisieren der Daten ist der häufigste Ansatz für mehrere GPUs oder verteiltes Training. Sie können Ihre Daten bündeln, an mehrere Geräte senden (die jeweils ein repliziertes Modell hosten) und dann die Ergebnisse aggregieren. Wir haben mit zwei Paketen zur Datenparallelisierung experimentiert: Horovod und the SageMaker verteilte parallele Datenbibliothek.

Horovod ist ein verteiltes Deep-Learning-Trainingsframework für TensorFlow, Keras, PyTorch und Apache MXNet. Um Horovod zu verwenden, haben wir den folgenden Prozess durchlaufen:

1. Durch Ausführen initialisieren hvd.init().
2. Ordnen Sie jedes Gerät einem einzelnen Prozess zu. Der erste Prozess oder Worker ist dem ersten Gerät zugeordnet, der zweite Prozess ist dem zweiten Gerät zugeordnet und so weiter.
3. Passen Sie die Lernrate basierend auf der Anzahl der Geräte an.
4. Wickeln Sie den Optimierer ein hvd.DistributedOptimizer.
5. Übertragen Sie die anfänglichen Variablenzustände vom ersten Worker mit Rang 0 an alle anderen Prozesse. Dies ist erforderlich, um eine konsistente Initialisierung aller Arbeiter sicherzustellen, wenn das Training mit zufälligen Gewichten gestartet oder von einem Kontrollpunkt wiederhergestellt wird.
6. Stellen Sie sicher, dass nur Gerät 0 Checkpoints speichern kann, um zu verhindern, dass andere Worker sie beschädigen.

Das Folgende ist das Trainingsskript:

import horovod.tensorflow as hvd
# Initialize Horovod
hvd.init() # Pin GPU to be used to process local rank (one GPU per process)
gpus = tf.config.experimental.list_physical_devices('GPU')
for gpu in gpus: tf.config.experimental.set_memory_growth(gpu, True)
if gpus: tf.config.experimental.set_visible_devices(gpus[hvd.local_rank()], 'GPU') # Build model
... @tf.function
def training_step(texts, labels, first_batch): with tf.GradientTape() as tape: predictions = model(texts, training=True) loss = loss_fn(labels, predictions[0]) # Horovod: add Horovod Distributed GradientTape. tape = hvd.DistributedGradientTape(tape) grads = tape.gradient(loss, model.trainable_variables) opt.apply_gradients(zip(grads, model.trainable_variables)) # Horovod: broadcast initial variable states from rank 0 to all other processes. # This is necessary to ensure consistent initialization of all workers when # training is started with random weights or restored from a checkpoint. # # Note: broadcast should be done after the first gradient step to ensure optimizer # initialization. if first_batch: hvd.broadcast_variables(model.variables, root_rank=0) hvd.broadcast_variables(opt.variables(), root_rank=0) return loss # Horovod: adjust number of steps based on number of GPUs.
for batch, (texts, labels) in enumerate(dataset.take(10000 // hvd.size())): loss = training_step(texts, labels, batch == 0) if batch % 10 == 0 and hvd.local_rank() == 0: print('Step #%dtLoss: %.6f' % (batch, loss)) # Horovod: save checkpoints only on worker 0 to prevent other workers from
# corrupting it.
if hvd.rank() == 0: checkpoint.save(checkpoint_dir)

Die SageMaker-Datenparallelbibliothek ermöglicht es uns, unser Training mit nahezu linearer Effizienz zu skalieren und unser Training mit minimalen Codeänderungen zu beschleunigen. Die Bibliothek führt eine benutzerdefinierte AllReduce Betrieb und optimiert die Gerät-zu-Gerät-Kommunikation durch vollständige Nutzung der Netzwerkinfrastruktur von AWS und Amazon Elastic Compute-Cloud (Amazon EC2)-Instance-Topologie. Um die SageMaker-Datenparallelbibliothek zu verwenden, haben wir den folgenden Prozess durchlaufen:

1. Importieren und initialisieren sdp.init().
2. Ordnen Sie jedem Gerät ein einzelnes zu smdistributed.dataparallel verarbeiten mit local_rank. sdp.tensorflow.local_rank() gibt uns den lokalen Rang der Geräte. Der Anführer hat Rang 0 und Arbeiter haben Rang 1, 2, 3 und so weiter.
3. Passen Sie die Lernrate basierend auf der Anzahl der Geräte an.
4. einwickeln tf.GradientTape mit DistributedGradientTape aufführen AllReduce.
5. Übertragen Sie die anfänglichen Modellvariablen vom Leader-Knoten an alle Worker-Knoten.
6. Stellen Sie sicher, dass nur Gerät 0 Prüfpunkte speichern kann.

Modellparallelisierung

Wir können die Hyperparameter anpassen, um das Modell klein genug zu halten, um es mit einer einzelnen GPU zu trainieren, oder wir können die Modellparallelität verwenden, um das Modell auf mehrere GPUs über mehrere Instanzen hinweg aufzuteilen. Das Erhöhen der Anzahl der trainierbaren Parameter eines Modells kann zu einer besseren Genauigkeit führen, aber es gibt eine Grenze für die maximale Modellgröße, die Sie in einen einzelnen GPU-Speicher einbauen können. Wir haben die parallele SageMaker-Bibliothek für verteilte Modelle verwendet, um unsere größeren Modelle zu trainieren. Die Schritte sind wie folgt:

1. Importieren und initialisieren Sie die Bibliothek mit smp.init().
2. Das Keras-Modell muss von smp.DistributedModel statt von der Keras-Modellklasse erben.
3. Sept drop_remainder=True der tf.Dataset.batch() Methode, um sicherzustellen, dass die Chargengröße immer durch die Anzahl der Mikrobatches teilbar ist.
4. Zufällige Operationen in der Datenpipeline müssen alle denselben Seed verwenden: smp.dp_rank(), beispielsweise, shuffle(ds, seed=smp.dp_rank()). Dadurch wird die Konsistenz von Datenbeispielen über Geräte hinweg sichergestellt, die unterschiedliche Modellpartitionen enthalten.
5. Vorwärts- und Rückwärtslogik müssen in einer Schrittfunktion mit sein smp.step Dekoration.
6. Führen Sie eine Nachbearbeitung der Ausgaben über Mikrobatches hinweg mit StepOutput-Methoden wie z reduce_meandem „Vermischten Geschmack“. Seine smp.step Die Funktion muss einen Rückgabewert haben, der von der Ausgabe von abhängt smp.DistributedModel.

Das Trainingsskript lautet wie folgt:

import smdistributed.modelparallel.tensorflow as smp # SMP: Initialize
smp.init() # SMP: Define smp.DistributedModel the same way as Keras sub-classing API
class MyModel(smp.DistributedModel): def __init__(self, maxlen, vocab_size, embed_dim, num_heads, feed_forward_dim, num_layers, learning_rate): super(MyModel, self).__init__(maxlen, vocab_size, embed_dim, num_heads, feed_forward_dim, num_layers, learning_rate) self.embedding_layer = gpt_model.TokenAndPositionEmbedding(maxlen, vocab_size, embed_dim) self.transformer_blocks = [ gpt_model.TransformerBlock(embed_dim, num_heads, feed_forward_dim) for i in range(num_layers) ] self.dense = tf.keras.layers.Dense(vocab_size) def call(self, inputs, training=None): x_emb = self.embedding_layer(inputs) x = x_emb for transformer_block in self.transformer_blocks: x = transformer_block(x) outputs = self.dense(x) return [outputs, x_emb] # SMP: Define smp.step. Return any tensors needed outside
@smp.step
def get_grads(texts, labels): predictions = model(texts, training=True) loss = loss_fn(labels, predictions[0]) grads = optimizer.get_gradients(loss, model.trainable_variables) return grads, loss, predictions[0] @tf.function
def train_step(texts, labels, first_batch): gradients, loss, predictions = get_grads(texts, labels) # SMP: Accumulate the gradients across microbatches gradients = [g.accumulate() for g in gradients] optimizer.apply_gradients(zip(gradients, model.trainable_variables)) # SMP: Average the loss across microbatches train_loss(loss.reduce_mean()) # SMP: Merge predictions across microbatches train_accuracy(labels, predictions.merge()) return loss.reduce_mean() histories = [] for _ in range(epochs): train_loss.reset_states() train_accuracy.reset_states() for texts, labels in text_ds: for i in range(128): text = tf.expand_dims(texts[0][i], axis=0) label = tf.expand_dims(labels[0][i], axis=0) train_step(text, label) 

Eine ausführliche Anleitung zum Aktivieren des TensorFlow-Trainingsskripts für die parallele SageMaker-Modellbibliothek finden Sie unter Ändern Sie ein TensorFlow-Trainingsskript. Informationen zu PyTorch finden Sie unter Ändern Sie ein PyTorch-Trainingsskript.

SageMaker-Debugger

In den vorherigen Abschnitten haben wir besprochen, wie das Training mithilfe von Modell- und Datenparallelisierungstechniken optimiert werden kann. Mit Amazon SageMaker-Debuggerkönnen wir jetzt Leistungsprofilinformationen aus unseren Trainingsläufen erfassen, um festzustellen, wie stark sich das Training verbessert hat. Standardmäßig erfasst Debugger Systemmetriken für jeden SageMaker-Trainingsjob wie GPU, CPU-Auslastung, Arbeitsspeicher, Netzwerk und E/A in einem Abtastintervall von 500 Millisekunden. Wir können wie folgt auf die Daten zugreifen:

from smdebug.profiler.analysis.notebook_utils.training_job import TrainingJob
tj = TrainingJob('SMD-MP-demo-2022-01-21-06-43-23-841', "us-east-1")
tj.wait_for_sys_profiling_data_to_be_available()
system_metrics_reader = tj.get_systems_metrics_reader()

Debugger stellt Dienstprogramme bereit visualisieren die Profildaten auf unterschiedliche Weise. Im folgenden Beispiel sehen wir die gesamte GPU- und CPU-Auslastung sowie die I/O-Wartezeit für den Multi-GPU-Trainingsjob mit Horovod. Um diese Diagramme zu generieren, führen wir den folgenden Code aus:

from smdebug.profiler.analysis.notebook_utils.timeline_charts import TimelineCharts view_timeline_charts = TimelineCharts( system_metrics_reader, framework_metrics_reader, select_dimensions=["CPU", "GPU", "I/O"], select_events=["total"], show_workers=False )

Die GPU-Auslastung schwankt häufig zwischen 0–100 % und hohe I/O-Wartezeiten bei geringer GPU-Auslastung sind ein Indikator für einen I/O-Engpass. Darüber hinaus überschreitet die CPU-Gesamtauslastung nie 70 %, was bedeutet, dass wir die Datenvorverarbeitung verbessern können, indem wir die Anzahl der Worker-Prozesse erhöhen.

Wir können die Leistung verbessern, indem wir von Horovod auf die parallele Bibliothek für verteilte Daten von SageMaker umsteigen. In den folgenden Grafiken können wir sehen, dass GPUs effizienter genutzt werden und nur für kurze Zeit auf eine niedrige Auslastung fallen.

Ausbildungsinfrastruktur

Zum Trainieren der Modelle haben wir 10 ml.p3.16xlarge-Instanzen mit einem SageMaker-Trainingsjob verwendet. SageMaker reduziert den Zeit- und Kostenaufwand für das Trainieren und Optimieren von Modellen für maschinelles Lernen (ML), ohne dass die Infrastruktur verwaltet werden muss. Mit SageMaker können Sie ML-Modelle einfach trainieren und optimieren, indem Sie integrierte Tools verwenden, um Trainingsexperimente zu verwalten und zu verfolgen, automatisch optimale Hyperparameter auszuwählen, Trainingsjobs zu debuggen und die Nutzung von Systemressourcen wie GPUs, CPUs und Netzwerkbandbreite zu überwachen. Die Daten wurden in Amazon EFS gehostet, wodurch wir wachsen und schrumpfen konnten, wenn wir Dateien hinzufügen und entfernen, ohne dass eine Verwaltung oder Bereitstellung erforderlich ist. Unsere Hauptziele waren die Verbesserung der Trainingsgeschwindigkeit und die Reduzierung der Kosten.

Skalierbarkeit des Modells

Obwohl diese Infrastruktur hauptsächlich für die Sprachgenerierung verwendet wird, können Sie mit der GPT-Architektur und dem Pile-Datensatz diese Techniken verwenden, um große Transformer-Modelle zu trainieren, was in vielen Bereichen über NLP hinaus nützlich ist. Beim maschinellen Lernen selbst werden viele Aufgaben des maschinellen Sehens jetzt mit Architekturen mit großen Parametern (Transformatoren) gelöst, bei denen gezeigt wurde, dass sie herkömmliche CNNs (Convolutional Neural Network) bei Aufgaben wie Repräsentationslernen übertreffen (siehe Fortschritt im Bereich Computer Vision mit selbstüberwachten Transformern und 10x effizienterem Training) und großflächige Zuordnung von Bildern zu Text (z CLIP). Modelle mit großen Parametern beschreiten auch neue Wege in den Biowissenschaften in Bereichen wie z Proteinstrukturanalyse und Analyse medizinischer Bilddaten.

Die Lösungen, die wir in diesem Beitrag für das verteilte Training und die Verwaltung großer Modelle beschreiben, sollten auch für Modelle in allen diesen Domänen gelten.

Kompromisse

In der Forschungsgemeinschaft gab es eine anhaltende Diskussion über die Risiken des Trainierens von Sprachmodellen im großen Maßstab und darüber, ob die potenziellen Risiken, die mit ihrer Entwicklung verbunden sind, und Strategien zur Minderung dieser Risiken, von denen einige finanzielle und finanzielle Risiken umfassen, ausreichend berücksichtigt wurden Umweltkosten. Laut a Krepppapier veröffentlicht in ACM, wurde geschätzt, dass das Trainieren eines einzelnen BERT-Basismodells (ohne Hyperparameter-Tuning) auf GPUs so viel Energie erfordert wie ein transamerikanischer Flug. Die Umweltauswirkungen skalieren mit der Modellgröße, und die Möglichkeit, solche Modelle effizient zu optimieren, kann die Emissionen möglicherweise erheblich reduzieren. AWS hat kürzlich eine neue gestartet Kunde Carbon Footprint-Tool, das allen AWS-Kunden kostenlos zur Verfügung steht und Teil der Bemühungen von Amazon ist, die Nachhaltigkeit zu erhöhen und die COXNUMX-Emissionen zu reduzieren. Das Ausführen von Anwendungen in der AWS Cloud kann möglicherweise den COXNUMX-Fußabdruck verringern (im Vergleich zu Unternehmensrechenzentren, in denen eine Umfrage durchgeführt wurde ein 2019-Bericht).

Zusammenfassung

Dieser Beitrag demonstrierte eine Lösung, die die Feinabstimmung von Sprachmodellen mit einer Milliarde Parametern in der AWS Cloud mit SageMaker erleichtert.

Weitere Informationen zur Modellparallelität mit SageMaker finden Sie unter Trainieren Sie mehr als 175 Milliarden Parameter-NLP-Modelle mit modellparallelen Ergänzungen und Hugging Face auf Amazon SageMaker und Wie Latent Space die Parallelitätsbibliothek des Amazon SageMaker-Modells verwendete, um die Grenzen großer Transformatoren zu erweitern.

Wenn Sie dabei helfen möchten, die Verwendung von ML in Ihren Produkten und Prozessen zu beschleunigen, wenden Sie sich bitte an die Amazon ML-Lösungslabor.

Über die Autoren

Sia Gholami ist Senior Data Scientist im Amazon ML Solutions Lab, wo er KI/ML-Lösungen für Kunden aus verschiedenen Branchen entwickelt. Seine Leidenschaft gilt Natural Language Processing (NLP) und Deep Learning. Außerhalb der Arbeit verbringt Sia gerne Zeit in der Natur und spielt Tennis.

Mehdi Nooriist Manager und Senior Applied Scientist im Amazon ML Solutions Lab, wo er mit Kunden aus verschiedenen Branchen zusammenarbeitet und ihnen hilft, ihre Cloud-Migration zu beschleunigen und ihre ML-Probleme mit modernsten Lösungen zu lösen Technologien.

Muhyun Kim ist Datenwissenschaftler bei Amazon Machine Learning Solutions Lab. Er löst die verschiedenen geschäftlichen Probleme der Kunden durch Anwendung von maschinellem Lernen und Deep Learning und hilft ihnen, sich weiterzubilden.

Danny Byrd ist Applied Scientist im Amazon ML Solutions Lab. Im Labor hat er Kunden geholfen, fortschrittliche ML-Lösungen zu entwickeln, in ML-Spezialitäten von Computer Vision bis Reinforcement Learning. Er ist leidenschaftlich daran interessiert, Technologie voranzutreiben und dabei neues Potenzial von AWS-Produkten zu erschließen.

Francisco Calderón Rodríguez ist Data Scientist im Amazon ML Solutions Lab. Als Mitglied des ML Solutions Lab hilft er mithilfe von Deep Learning bei der Lösung kritischer Geschäftsprobleme für AWS-Kunden. In seiner Freizeit spielt Francisco gerne Musik und Gitarre, spielt mit seinen Töchtern Fußball und genießt die Zeit mit seiner Familie.

Yohei Nakayama ist Deep Learning Architect im Amazon ML Solutions Lab. Er arbeitet mit Kunden aus verschiedenen Branchen zusammen, um ihre Nutzung von künstlicher Intelligenz und AWS Cloud-Services zu beschleunigen, um ihre geschäftlichen Herausforderungen zu lösen. Er interessiert sich für die Anwendung von ML/KI-Technologien in der Raumfahrtindustrie.

Nathalie Rauschmayr ist Senior Applied Scientist bei AWS, wo sie Kunden bei der Entwicklung von Deep-Learning-Anwendungen unterstützt.

• Coinsmart. Europas beste Bitcoin- und Krypto-Börse.
• Platoblockkette. Web3-Metaverse-Intelligenz. Wissen verstärkt. DEN FREIEN ZUGANG.
• CryptoHawk. Altcoin-Radar. Kostenlose Testphase.
• Quelle: https://aws.amazon.com/blogs/machine-learning/create-train-and-deploy-a-billion-parameter-language-model-on-terabytes-of-data-with-tensorflow-and- amazon-sagemaker/