Twórz, trenuj i wdrażaj model języka o miliardach parametrów na terabajtach danych za pomocą TensorFlow i Amazon SageMaker

Rosnąca wielkość modeli językowych jest jednym z największych trendów w przetwarzaniu języka naturalnego (NLP) w ostatnich latach. Od 2018 roku byliśmy świadkami bezprecedensowego rozwoju i wdrażania coraz większych modeli językowych, w tym BERT i jego wariantów, GPT-2, T-NLG i GPT-3 (175 miliardów parametrów).

Modele te przesunęły granice możliwych innowacji architektonicznych. Podczas trenowania modeli uczenia głębokiego na dużą skalę stajemy przed kilkoma wyzwaniami, zwłaszcza z nową falą wstępnie przeszkolonych transformatorów generatywnych. Wyzwania te obejmują ograniczenia sprzętowe i kompromisy z obliczeniami i wydajnością. Aby sprostać tym wyzwaniom związanym z równoległością modeli i danych, AWS oferuje szeroki zakres możliwości.

W tym poście przedstawiamy dwa główne podejścia: zrównoleglanie danych i zrównoleglanie modelu za pomocą Amazon Sage Makeri przedyskutuj ich zalety i wady.

Model

Do modelu językowego wykorzystujemy wprowadzone w artykule Transformatory Uwaga jest wszystkim, czego potrzebujesz. Transformatory to modele uczenia głębokiego zaprojektowane w celu celowego unikania pułapek związanych z RNN poprzez poleganie na mechanizmie samouważności do rysowania globalnych zależności między danymi wejściowymi i wyjściowymi. Architektura modelu Transformer pozwala na znacznie lepszą równoległość i może osiągnąć wysoką wydajność w stosunkowo krótkim czasie uczenia. Zbudowany na sukcesie firmy Transformers, BERT, wprowadzonej w gazecie BERT: Wstępne szkolenie z głębokich transformatorów dwukierunkowych do zrozumienia języka, dodano dwukierunkowe szkolenie wstępne dotyczące reprezentacji języka. Zainspirowany zadaniem Cloze, BERT jest wstępnie przeszkolony w zakresie modelowania języka maskowanego (MLM), w którym model uczy się odzyskiwać oryginalne słowa dla losowo zamaskowanych tokenów. Model BERT jest również wstępnie wytrenowany w zadaniu przewidywania następnego zdania (NSP), aby przewidzieć, czy dwa zdania są w prawidłowej kolejności czytania. Od czasu pojawienia się w 2018 roku BERT i jego odmiany są szeroko stosowane w modelach językowych.

Zaczynamy od utworzenia dwóch warstw osadzania do osadzania tokenów i osadzania pozycyjnego. Osadzenia wejściowe są sumą osadzeń tokenów i osadzeń pozycji.

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

Następnie definiujemy blok dekodera transformatora z dwiema podwarstwami: wielogłowicową warstwą samouwagi i prostą, w pełni połączoną siecią ze sprzężeniem do przodu, po której następuje normalizacja warstwy i zanik:

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)

Na koniec tworzymy nasz model języka z poprzednią warstwą osadzania i blokami transformatora:

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

W zależności od hiperparametrów możesz skalować ten model od tysięcy parametrów do miliardów parametrów. Podstawowym wyzwaniem związanym z modelami miliardowymi parametrów jest to, że nie można hostować modelu w jednym wystąpieniu i trzeba rozprowadzić model na kilka węzłów w celu uczenia i wnioskowania.

Zbiór danych

W naszych eksperymentach wykorzystaliśmy Zbiór danych stosu. Pile to zbiór danych tekstowych w języku angielskim o wielkości 800 GiB, przeznaczony do trenowania modeli językowych na dużą skalę. Jest tworzony z 22 różnorodnych i wysokiej jakości zbiorów danych, w tym zarówno ustalonych zbiorów danych NLP, jak i nowo wprowadzonych.

Zbiór danych jest tworzony z różnych źródeł danych, w tym książek; repozytoria GitHub; strony internetowe; dzienniki czatów; oraz artykuły z dziedziny medycyny, fizyki, matematyki, informatyki i filozofii. W szczególności korzysta z następujących źródeł: Pile-CC, PubMed Central, ArXiv, GitHub, FreeLaw Project, Stack Exchange, US Patent and Trademark Office, PubMed, Ubuntu, IRC, HackerNews, YouTube, PhilPapers, Books3, Project Gutenberg ( PG-19), OpenSubtitles, angielska Wikipedia, DM Mathematics, EuroParl, korpus Enron Emails oraz NIH ExPorter. Zawiera również OpenWebText2 i BookCorpus2, które są odpowiednio rozszerzeniami oryginalnych zestawów danych OpenWebText i BookCorpus. Różnorodność źródeł danych może poprawić ogólną wiedzę międzydziedzinową, a w konsekwencji poprawić możliwości uogólniania na dalszych etapach.

Głównym wyzwaniem związanym z tym zestawem danych jest sam rozmiar; zestaw danych ma 825 GiB tekstu, co przekłada się na 4.2 TiB wstępnie przetworzonych i skompresowanych punktów danych. Podobnie jak w przypadku wyzwań, przed którymi stoimy w przypadku trenowania i hostowania modeli, trenowanie modelu za pomocą tego zestawu danych w jednym wystąpieniu zajmie dużo czasu i jest niepraktyczne.

Naszym rozwiązaniem jest rozbicie zbioru danych na porcje danych o wielkości około 1 GiB, załadowanie i wstępne przetworzenie funkcji w Zbiór danych TensorFlow przedmiotów i przechowuj je w Elastyczna usługa plików Amazon (Amazon EFS). Zestawy danych TensorFlow zapewniają łatwy w użyciu i wydajny potok danych, który dobrze integruje się z naszymi modelami. Amazon EFS to łatwa w użyciu usługa, która umożliwia nam zbudowanie współdzielonego systemu plików, który skaluje się automatycznie w miarę dodawania i usuwania plików. Ponadto Amazon EFS jest w stanie w razie potrzeby osiągnąć wyższy poziom przepustowości, co ma kluczowe znaczenie w naszym potoku uczenia danych i modeli.

Następnie przyjrzymy się rozproszonym strategiom szkoleniowym, aby sprostać tym wyzwaniom.

Rozproszone szkolenie

W tym projekcie stanęliśmy przed dwoma wyzwaniami: skalowaniem rozmiaru modelu i objętości danych. Zwiększenie rozmiaru modelu i liczby parametrów, które można trenować, może skutkować lepszą dokładnością, ale istnieje ograniczenie modelu, który można zmieścić w jednej pamięci GPU lub nawet w wielu procesorach GPU w jednym wystąpieniu. Ponadto większe rozmiary modeli wymagają więcej czasu na trenowanie.

Możesz stawić czoła tym wyzwaniom na dwa różne sposoby: równoległość danych i równoległość modelu. Dzięki równoległości danych wykonujemy Stochastic Gradient Descent (SGD) poprzez dystrybucję zapisów mini-partii na różne urządzenia w celu przyspieszenia treningu. Jednak równoległe trenowanie danych wiąże się z dodatkową złożonością obliczania średniej gradientu mini-partii z gradientami ze wszystkich urządzeń, krok zwany AllReduce, co staje się trudniejsze w miarę rozwoju klastra szkoleniowego. Korzystając z równoległości danych, musimy być w stanie zmieścić model i pojedynczy punkt danych w urządzeniu (CPU lub GPU), co jest czynnikiem ograniczającym nasze eksperymenty, ponieważ rozmiar tak dużego modelu jest znacznie większy niż pamięć pojedynczego GPU rozmiar.

Innym rozwiązaniem jest użycie równoległości modelu, która dzieli model na wiele urządzeń. Równoległość modelu to proces dzielenia modelu między wiele urządzeń lub węzłów (takich jak wystąpienia wyposażone w procesory GPU) i tworzenia wydajnego potoku do trenowania modelu na tych urządzeniach w celu maksymalizacji wykorzystania procesora GPU.

Równoległość danych

Równoległość danych jest najczęstszym podejściem do wielu procesorów graficznych lub szkolenia rozproszonego. Możesz grupować swoje dane, wysyłać je do wielu urządzeń (każde hostuje replikowany model), a następnie agregować wyniki. Eksperymentowaliśmy z dwoma pakietami do zrównoleglania danych: Horovod i the SageMaker rozproszona równoległa biblioteka danych.

Horovod to rozproszona platforma szkolenia głębokiego dla TensorFlow, Keras, PyTorch i Apache MXNet. Aby użyć Horovod, przeszliśmy przez następujący proces:

1. Zainicjuj przez uruchomienie hvd.init().
2. Powiąż każde urządzenie z jednym procesem. Pierwszy proces lub pracownik jest powiązany z pierwszym urządzeniem, drugi proces jest powiązany z drugim urządzeniem i tak dalej.
3. Dostosuj szybkość uczenia się na podstawie liczby urządzeń.
4. Owiń optymalizator w hvd.DistributedOptimizer.
5. Rozgłaszaj stany zmiennej początkowej z pierwszego procesu roboczego z pozycją 0 do wszystkich pozostałych procesów. Jest to konieczne, aby zapewnić spójną inicjalizację wszystkich pracowników, gdy szkolenie rozpoczyna się z losowymi wagami lub przywracane z punktu kontrolnego.
6. Upewnij się, że tylko urządzenie 0 może zapisywać punkty kontrolne, aby zapobiec ich uszkodzeniu przez innych pracowników.

Poniżej znajduje się skrypt szkoleniowy:

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)

Biblioteka równoległa danych SageMaker umożliwia nam skalowanie naszego szkolenia z niemal liniową wydajnością, przyspieszając nasze szkolenie przy minimalnych zmianach kodu. Biblioteka wykonuje niestandardowe AllReduce działanie i optymalizuje komunikację między urządzeniami, w pełni wykorzystując infrastrukturę sieciową AWS i Elastyczna chmura obliczeniowa Amazon (Amazon EC2) topologia instancji. Aby użyć równoległej biblioteki danych SageMaker, przeszliśmy przez następujący proces:

1. Importuj i inicjuj sdp.init().
2. Powiąż każde urządzenie z jednym smdistributed.dataparallel przetwarzać z local_rank. sdp.tensorflow.local_rank() daje nam lokalną rangę urządzeń. Lider ma rangę 0, robotnicy mają rangę 1, 2, 3 i tak dalej.
3. Dostosuj szybkość uczenia się na podstawie liczby urządzeń.
4. Owiń tf.GradientTape w DistributedGradientTape występować AllReduce.
5. Roześlij początkowe zmienne modelu z węzła wiodącego do wszystkich węzłów roboczych.
6. Upewnij się, że tylko urządzenie 0 może zapisywać punkty kontrolne.

Równoległość modelu

Możemy dostosować hiperparametry, aby model był wystarczająco mały, aby można go było trenować przy użyciu jednego procesora GPU, lub możemy użyć równoległości modelu, aby podzielić model między wiele procesorów GPU w wielu instancjach. Zwiększenie liczby możliwych do trenowania parametrów modelu może skutkować większą dokładnością, ale istnieje limit maksymalnego rozmiaru modelu, który można zmieścić w pojedynczej pamięci GPU. Użyliśmy biblioteki równoległej modelu rozproszonego SageMaker do trenowania naszych większych modeli. Kroki są następujące:

1. Zaimportuj i zainicjuj bibliotekę za pomocą smp.init().
2. Model Keras musi dziedziczyć z smp.DistributedModel zamiast z klasy Keras Model.
3. Zestaw drop_remainder=True tf.Dataset.batch() metoda zapewniająca, że ​​wielkość partii jest zawsze podzielna przez liczbę mikropartii.
4. Wszystkie operacje losowe w potoku danych muszą używać tego samego materiału siewnego: smp.dp_rank()Na przykład, shuffle(ds, seed=smp.dp_rank()). Zapewnia to spójność próbek danych na urządzeniach, które przechowują różne partycje modelu.
5. Logika do przodu i do tyłu musi być funkcją kroku z smp.step dekoracja.
6. Wykonaj przetwarzanie końcowe na wyjściach w mikropartii przy użyciu metod StepOutput, takich jak reduce_mean, smp.step funkcja musi mieć zwracaną wartość, która zależy od wyniku smp.DistributedModel.

Skrypt szkoleniowy wygląda następująco:

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) 

Aby uzyskać szczegółowy przewodnik dotyczący włączania skryptu szkoleniowego TensorFlow dla biblioteki równoległej modelu rozproszonego SageMaker, zobacz Zmodyfikuj skrypt szkoleniowy TensorFlow. W przypadku PyTorch, patrz Zmodyfikuj skrypt szkoleniowy PyTorch.

Debuger SageMakera

W poprzednich sekcjach omówiliśmy, jak zoptymalizować szkolenie przy użyciu technik zrównoleglania modelu i danych. Z Debuger Amazon SageMaker, możemy teraz przechwytywać informacje o profilowaniu wydajności z naszych biegów treningowych, aby określić, jak bardzo poprawił się trening. Domyślnie Debugger przechwytuje metryki systemowe dla każdego zadania szkoleniowego SageMaker, takie jak GPU, wykorzystanie procesora, pamięć, sieć i operacje we/wy z interwałem próbkowania wynoszącym 500 milisekund. Dostęp do danych możemy uzyskać w następujący sposób:

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

Debuger zapewnia narzędzia do wyobrażać sobie profilowania danych na różne sposoby. W poniższym przykładzie widzimy całkowite wykorzystanie procesora graficznego i procesora, a także czas oczekiwania na operacje we/wy dla zadania uczenia wielu procesorów graficznych przy użyciu Horovod. Aby wygenerować te wykresy, uruchamiamy następujący kod:

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 )

Wykorzystanie procesora GPU często waha się od 0 do 100%, a długi czas oczekiwania na operacje we/wy przy niskim wykorzystaniu procesora GPU jest wskaźnikiem wąskiego gardła we/wy. Co więcej, całkowite wykorzystanie procesora nigdy nie przekracza 70%, co oznacza, że ​​możemy poprawić wstępne przetwarzanie danych poprzez zwiększenie liczby procesów roboczych.

Możemy poprawić wydajność, przełączając się z Horovod na bibliotekę równoległą danych rozproszonych SageMaker. Na poniższych wykresach widzimy, że procesory graficzne są wykorzystywane bardziej efektywnie i spadają do niskiego poziomu wykorzystania tylko na krótkie okresy czasu.

Infrastruktura szkoleniowa

Do szkolenia modeli użyliśmy 10 instancji ml.p3.16xlarge przy użyciu zadania szkoleniowego SageMaker. SageMaker skraca czas i koszty szkolenia i dostrajania modeli uczenia maszynowego (ML) bez konieczności zarządzania infrastrukturą. Dzięki SageMaker możesz łatwo trenować i dostrajać modele ML za pomocą wbudowanych narzędzi do zarządzania i śledzenia eksperymentów szkoleniowych, automatycznego wybierania optymalnych hiperparametrów, debugowania zadań szkoleniowych i monitorowania wykorzystania zasobów systemowych, takich jak procesory graficzne, procesory i przepustowość sieci. Dane były hostowane w Amazon EFS, co pozwoliło nam rosnąć i zmniejszać się w miarę dodawania i usuwania plików bez potrzeby zarządzania lub udostępniania. Naszymi głównymi celami było zwiększenie szybkości treningu i obniżenie kosztów.

Skalowalność modelu

Chociaż ta infrastruktura jest używana głównie do generowania języka, z architekturą GPT i zestawem danych Pile można użyć tych technik do trenowania modeli transformatorów na dużą skalę, co jest przydatne w wielu domenach poza NLP. W samym uczeniu maszynowym wiele zadań związanych z widzeniem komputerowym jest obecnie rozwiązywanych za pomocą architektur z dużymi parametrami (transformatorami), w których wykazano, że przewyższają tradycyjne CNN (Convolutional Neural Network) w zadaniach takich jak uczenie reprezentacji (patrz Postęp w dziedzinie wizji komputerowej dzięki samonadzorowanym Transformatorom i 10-krotnie wydajniejszemu szkoleniu) i wielkoskalowe mapowanie obrazów na tekst (takie jak CLIP). Modele wielkoparametrowe są również przełomowe w naukach przyrodniczych w takich dziedzinach jak analiza struktury białka i analiza medycznych danych obrazowych.

Rozwiązania, które szczegółowo opisaliśmy w tym poście, dotyczące szkolenia rozproszonego i zarządzania dużymi modelami, powinny również dotyczyć modeli w dowolnej z tych domen.

Kompromisy

W środowisku naukowym toczy się dyskusja na temat zagrożeń związanych z trenowaniem modeli językowych na dużą skalę oraz tego, czy dostatecznie przemyślano potencjalne zagrożenia związane z ich opracowywaniem i strategiami ograniczania tych zagrożeń, z których niektóre obejmują kwestie finansowe i koszty środowiskowe. Według papier opublikowany w ACM, oszacowano, że trenowanie pojedynczego modelu podstawowego BERT (bez dostrajania hiperparametrów) na GPU wymagało takiej samej energii, jak lot transamerykański. Wpływ na środowisko skaluje się wraz z rozmiarem modelu, a możliwość skutecznego dostrojenia takich modeli może potencjalnie znacznie ograniczyć emisje. AWS niedawno uruchomił nowy Narzędzie do pomiaru śladu węglowego klienta, dostępne dla wszystkich klientów AWS bez żadnych kosztów, jako część wysiłków Amazona na rzecz zwiększenia zrównoważonego rozwoju i zmniejszenia emisji dwutlenku węgla. Uruchamianie aplikacji w chmurze AWS może potencjalnie zmniejszyć ślad węglowy (w porównaniu z korporacyjnymi centrami danych, które były badane w raport 2019).

Wnioski

Ten post zademonstrował rozwiązanie, które ułatwia dostrajanie modeli językowych z miliardem parametrów w chmurze AWS za pomocą SageMaker.

Aby uzyskać więcej informacji na temat równoległości modeli z programem SageMaker, zobacz Trenuj ponad 175 miliardów parametrów NLP modeli z równoległymi dodawaniem modeli i Hugging Face w Amazon SageMaker i Jak firma Latent Space wykorzystała bibliotekę równoległości modelu Amazon SageMaker, aby przesunąć granice transformatorów wielkoskalowych.

Jeśli potrzebujesz pomocy w przyspieszeniu wykorzystania ML w swoich produktach i procesach, skontaktuj się z Laboratorium rozwiązań Amazon ML.

O autorach

Sia Gholami jest starszym analitykiem danych w Amazon ML Solutions Lab, gdzie buduje rozwiązania AI/ML dla klientów z różnych branż. Pasjonuje się przetwarzaniem języka naturalnego (NLP) i głębokim uczeniem się. Poza pracą Sia lubi spędzać czas na łonie natury i grać w tenisa.

Mehdi Noorijest menedżerem i starszym naukowcem stosowanym w Amazon ML Solutions Lab, gdzie pracuje z klientami z różnych branż i pomaga im przyspieszyć migrację do chmury oraz rozwiązywać problemy ML przy użyciu najnowocześniejszych rozwiązań i technologie.

Muhyun Kim jest analitykiem danych w Amazon Machine Learning Solutions Lab. Rozwiązuje różne problemy biznesowe klientów, stosując uczenie maszynowe i głębokie uczenie, a także pomaga im zdobyć umiejętności.

Danny'ego Byrda jest naukowcem stosowanym w laboratorium Amazon ML Solutions Lab. W laboratorium pomagał klientom opracowywać zaawansowane rozwiązania ML, w specjalnościach ML, od wizji komputerowej po uczenie ze wzmocnieniem. Pasjonuje go rozwijanie technologii i odblokowywanie nowego potencjału produktów AWS.

Francisco Calderona Rodrigueza jest analitykiem danych w laboratorium Amazon ML Solutions Lab. Jako członek ML Solutions Lab pomaga rozwiązywać krytyczne problemy biznesowe dla klientów AWS z wykorzystaniem głębokiego uczenia się. W wolnym czasie Francisco lubi grać na gitarze, grać w piłkę nożną z córkami i spędzać czas z rodziną.

Yoheia Nakayamy jest architektem głębokiego uczenia się w laboratorium Amazon ML Solutions Lab. Współpracuje z klientami z różnych branż, aby przyspieszyć korzystanie przez nich ze sztucznej inteligencji i usług AWS Cloud w celu rozwiązywania ich wyzwań biznesowych. Interesuje się zastosowaniem technologii ML/AI w przemyśle kosmicznym.

Nathalie Rauschmayr jest Senior Applied Scientist w AWS, gdzie pomaga klientom rozwijać aplikacje do głębokiego uczenia się.

• Coinsmart. Najlepsza w Europie giełda bitcoinów i kryptowalut.
• Platoblockchain. Web3 Inteligencja Metaverse. Wzmocniona wiedza. DARMOWY DOSTĘP.
• CryptoJastrząb. Radar Altcoin. Bezpłatna wersja próbna.
• Źródło: https://aws.amazon.com/blogs/machine-learning/create-train-and-deploy-a-billion-parameter-language-model-on-terabytes-of-data-with-tensorflow-and- amazonka-sagemaker/