Hozzon létre, képezzen és telepítsen egy milliárd paraméterű nyelvi modellt terabájtnyi adaton a TensorFlow és az Amazon SageMaker segítségével

A nyelvi modellek méretének növekedése a természetes nyelvi feldolgozás (NLP) egyik legnagyobb trendje volt az elmúlt években. 2018 óta példátlan mértékű fejlesztést és bevezetést láthattunk egyre nagyobb nyelvi modelleknél, beleértve a BERT-t és annak változatait, a GPT-2-t, a T-NLG-t és a GPT-3-at (175 milliárd paraméter).

Ezek a modellek kitágították a lehetséges építészeti újítások határait. Számos kihívással kell szembenéznünk a nagy léptékű mély tanulási modellek képzése során, különösen a generatív előképzett transzformátorok új hullámával. Ezek a kihívások magukban foglalják a hardveres korlátokat és a számítással és a hatékonysággal kapcsolatos kompromisszumokat. A modell- és adatpárhuzamosság ezen kihívásainak leküzdésére az AWS a lehetőségek széles skáláját kínálja.

Ebben a bejegyzésben két fő megközelítést mutatunk be: az adatok párhuzamosítását és a modell párhuzamosítását Amazon SageMaker, és megvitassák előnyeiket és hátrányaikat.

A modell

A nyelvi modellhez a dolgozatban bemutatott Transformers-t használjuk Csak a figyelem kell. A transzformátorok mély tanulási modellek, amelyeket az RNN-ek buktatóinak szándékosan történő elkerülésére terveztek azáltal, hogy egy önfigyelő mechanizmusra támaszkodnak, hogy globális függőséget vonjanak le a bemenet és a kimenet között. A Transformer modellarchitektúra lényegesen jobb párhuzamosítást tesz lehetővé, és viszonylag rövid edzési idő alatt nagy teljesítményt érhet el. A Transformers, a BERT sikerére építve, amelyet a lapban mutattak be BERT: Mély kétirányú transzformátorok előképzése a nyelv megértéséhez, hozzáadott kétirányú előképzés a nyelvi reprezentációhoz. A Cloze feladat ihlette a BERT-t a maszkolt nyelvi modellezéssel (MLM), amelyben a modell megtanulja visszaállítani a véletlenszerűen maszkolt tokenek eredeti szavait. A BERT-modell a következő mondat-előrejelzési (NSP) feladatra is előképzett, hogy megjósolja, hogy két mondat helyes olvasási sorrendben van-e. 2018-as megjelenése óta a BERT-et és annak változatait széles körben használják nyelvi modellekben.

Kezdjük azzal, hogy két beágyazási réteget hozunk létre a token és a pozíció szerinti beágyazáshoz. A bemeneti beágyazások a token beágyazások és a pozícióbeágyazások összege.

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

Ezután definiálunk egy transzformátor dekóder blokkot két alréteggel: egy többfejes önfigyelő réteggel és egy egyszerű, teljesen csatlakoztatott előrecsatolt hálózattal, amelyet rétegnormalizálás és kiesés követ:

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)

Végül elkészítjük nyelvi modellünket az előző beágyazó réteggel és transzformátor blokkokkal:

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

A hiperparamétereitől függően ezt a modellt több ezer paramétertől több milliárd paraméterig méretezheti. A milliárdparaméteres modellek elsődleges kihívása az, hogy a modellt nem lehet egy példányban tárolni, és a modellt több csomóponton kell elosztani a betanítás és a következtetés érdekében.

Az adatkészlet

Kísérleteink során a Cölöp adatkészlet. A Pile egy 800 GiB-os angol szöveges adatkészlet, amelyet nagyszabású nyelvi modellek betanításához terveztek. 22 változatos és kiváló minőségű adatkészletből jön létre, beleértve a már létrehozott és az újonnan bevezetett NLP-adatkészleteket is.

Az adatkészletet számos adatforrásból hozzák létre, beleértve a könyveket is; GitHub adattárak; weboldalak; csevegési naplók; valamint orvosi, fizikai, matematikai, számítástechnikai és filozófiai dolgozatok. Konkrétan a következő forrásokat használja: Pile-CC, PubMed Central, ArXiv, GitHub, a FreeLaw Project, Stack Exchange, az Egyesült Államok Szabadalmi és Védjegyhivatala, PubMed, Ubuntu, IRC, HackerNews, YouTube, PhilPapers, Books3, Project Gutenberg ( PG-19), OpenSubtitles, angol Wikipédia, DM Mathematics, EuroParl, Enron Emails korpusz és NIH ExPorter. Tartalmazza továbbá az OpenWebText2-t és a BookCorpus2-t, amelyek az eredeti OpenWebText és BookCorpus adatkészletek kiterjesztései. Az adatforrások sokfélesége javíthatja az általános tartományok közötti tudást, és ennek következtében javíthatja a downstream általánosítási képességeket.

Az elsődleges kihívás ezzel az adatkészlettel a puszta méret; az adatkészlet 825 GiB szöveget tartalmaz, ami 4.2 TiB előre feldolgozott és tömörített adatpontot jelent. A modellek betanításával és üzemeltetésével kapcsolatos kihívásokhoz hasonlóan egy modell egyetlen példányon történő betanítása ezzel az adatkészlettel sok időt vesz igénybe, és nem praktikus.

Megoldásunk az, hogy az adatkészletet körülbelül 1 GiB-os adatdarabokra bontjuk, betöltjük és előfeldolgozzuk a funkciókat TensorFlow adatkészlet tárgyakat, és tárolja azokat Amazon Elastic File Service (Amazon EFS). A TensorFlow adatkészletek könnyen használható és nagy teljesítményű adatfolyamot biztosítanak, amely jól integrálható modelljeinkkel. Az Amazon EFS egy könnyen használható szolgáltatás, amely lehetővé teszi számunkra, hogy olyan megosztott fájlrendszert építsünk fel, amely automatikusan skálázódik a fájlok hozzáadásakor és törlésekor. Ezenkívül az Amazon EFS szükség esetén képes magasabb átviteli szintekre felrobbantani, ami kritikus fontosságú adat- és modellképzési folyamatunkban.

Ezután az elosztott képzési stratégiákat vizsgáljuk meg ezeknek a kihívásoknak a kezelésére.

Elosztott képzés

Ebben a projektben két kihívással kellett szembenéznünk: a modell méretének és az adatmennyiségnek a skálázásával. A modell méretének és a betanítható paraméterek számának növelése nagyobb pontosságot eredményezhet, de van egy korlát, hogy egyetlen GPU-memóriába vagy akár több GPU-ba is elférjen egyetlen példányban. Ráadásul a nagyobb modellek betanítása több időt vesz igénybe.

Ezeket a kihívásokat kétféleképpen kezelheti: az adatok párhuzamosságával és a modell párhuzamosságával. Az adatok párhuzamosságával sztochasztikus gradiens süllyedést (SGD) hajtunk végre úgy, hogy egy mini köteg rekordjait szétosztjuk különböző eszközök között, hogy felgyorsítsuk a képzést. A párhuzamos adattanítás azonban extra összetettséggel jár a mini kötegelt gradiensátlagok kiszámításában az összes eszköz gradienseivel, ez a lépés az ún. AllReduce, ami a képzési klaszter növekedésével nehezebbé válik. Az adatpárhuzam alkalmazása során képesnek kell lennünk arra, hogy a modellt és egyetlen adatpontot egy eszközbe (CPU vagy GPU) illesszük, ami korlátozó tényező a kísérleteinkben, mert egy ekkora modell mérete sokkal nagyobb, mint az egyetlen GPU memóriája. méret.

Egy másik megoldás a modell párhuzamos használata, amely több eszközre osztja fel a modellt. A modellpárhuzam az a folyamat, amikor egy modellt felosztanak több eszköz vagy csomópont (például GPU-val felszerelt példányok) között, és egy hatékony folyamatot hoznak létre a modell betanításához ezeken az eszközökön a GPU kihasználtságának maximalizálása érdekében.

Adatok párhuzamosítása

Az adatok párhuzamosítása a leggyakoribb megközelítés a több GPU-hoz vagy az elosztott képzéshez. Az adatokat kötegelni tudja, elküldheti több eszközre (mindegyik replikált modellt tartalmaz), majd összesítheti az eredményeket. Két csomaggal kísérleteztünk az adatok párhuzamosítására: Horovod és a SageMaker elosztott adatok párhuzamos könyvtár.

A Horovod egy elosztott mélytanulási képzési keretrendszer a TensorFlow, a Keras, a PyTorch és az Apache MXNet számára. A Horovod használatához a következő folyamaton mentünk keresztül:

1. Inicializálás futtatással hvd.init().
2. Minden eszközt egyetlen folyamathoz társítson. Az első folyamat vagy dolgozó az első eszközhöz, a második folyamat a második eszközhöz van társítva, és így tovább.
3. Állítsa be a tanulási sebességet az eszközök száma alapján.
4. Tekerje be az optimalizálót hvd.DistributedOptimizer.
5. A kezdeti változó állapotok sugárzása az első, 0-s rangú dolgozótól az összes többi folyamat felé. Erre azért van szükség, hogy biztosítsuk az összes dolgozó következetes inicializálását, amikor a képzést véletlenszerű súlyokkal kezdik, vagy egy ellenőrzőpontból állítják vissza.
6. Győződjön meg arról, hogy csak a 0-s eszköz mentheti az ellenőrzőpontokat, nehogy más dolgozók megsértsék azokat.

A következő a képzési szkript:

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)

A SageMaker adatpárhuzamos könyvtár lehetővé teszi, hogy szinte lineáris hatékonysággal skálázzuk képzésünket, minimális kódmódosítással felgyorsítva a képzést. A könyvtár egy szokást végez AllReduce működését és optimalizálja az eszközök közötti kommunikációt az AWS hálózati infrastruktúrájának teljes kihasználásával és Amazon rugalmas számítási felhő (Amazon EC2) példány topológiája. A SageMaker adatpárhuzamos könyvtár használatához a következő folyamaton mentünk keresztül:

1. Importálás és inicializálás sdp.init().
2. Társítson minden eszközt egyetlen eszközhöz smdistributed.dataparallel feldolgozni vele local_rank. sdp.tensorflow.local_rank() megadja nekünk az eszközök helyi rangját. A vezető a 0., a munkások pedig az 1., 2., 3. és így tovább.
3. Állítsa be a tanulási sebességet az eszközök száma alapján.
4. Tekerjük tf.GradientTape val vel DistributedGradientTape előadni AllReduce.
5. Közvetítse a kezdeti modellváltozókat a vezető csomóponttól az összes dolgozó csomóponthoz.
6. Győződjön meg arról, hogy csak a 0-s eszköz tud ellenőrzési pontokat menteni.

Modell párhuzamosítás

Beállíthatjuk a hiperparamétereket, hogy a modell elég kicsi legyen ahhoz, hogy egyetlen GPU-val tudjon betanítani, vagy modellpárhuzamot alkalmazhatunk a modell felosztására több GPU között több példányban. A modell betanítható paramétereinek számának növelése nagyobb pontosságot eredményezhet, de az egyetlen GPU-memóriában elhelyezhető maximális modellméret korlátozott. A SageMaker elosztott modell párhuzamos könyvtárát használtuk nagyobb modelljeink betanításához. A lépések a következők:

1. Importálja és inicializálja a könyvtárat ezzel smp.init().
2. A Keras modellnek az smp.DistributedModeltől kell örökölnie a Keras Model osztály helyett.
3. Készlet drop_remainder=True a tf.Dataset.batch() módszer annak biztosítására, hogy a tétel mérete mindig osztható legyen a mikroadagok számával.
4. Az adatfolyamban végrehajtott véletlenszerű műveleteknek ugyanazt a magot kell használniuk: smp.dp_rank(), Például a shuffle(ds, seed=smp.dp_rank()). Ez biztosítja az adatminták konzisztenciáját a különböző modellpartíciókat tartalmazó eszközökön.
5. Az előre és visszafelé irányuló logikának lépésfüggvényben kell lennie smp.step dekoráció.
6. Végezzen utófeldolgozást a kimeneteken a mikrokötegek között StepOutput módszerekkel, mint pl reduce_mean Az smp.step függvénynek olyan visszatérési értékkel kell rendelkeznie, amely a kimenetétől függ smp.DistributedModel.

A képzési forgatókönyv a következő:

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) 

A SageMaker elosztott modell párhuzamos könyvtár TensorFlow tanító szkriptjének engedélyezésére vonatkozó részletes útmutatóért lásd: Módosítson egy TensorFlow képzési szkriptet. A PyTorch esetében lásd: PyTorch képzési parancsfájl módosítása.

SageMaker hibakereső

Az előző részekben megbeszéltük, hogyan lehet optimalizálni a képzést modell- és adatpárhuzamosítási technikák segítségével. Val vel Amazon SageMaker Debugger, immáron teljesítményprofil-információkat rögzíthetünk edzéseinkből, hogy meghatározzuk, mennyit fejlődött az edzés. Alapértelmezés szerint a Debugger 500 ezredmásodperces mintavételi időközönként rögzíti a rendszermetrikákat minden SageMaker képzési feladathoz, például a GPU-hoz, a CPU-kihasználtsághoz, a memóriához, a hálózathoz és az I/O-hoz. Az adatokhoz az alábbiak szerint férhetünk hozzá:

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

A Debugger segédprogramokat biztosít a Képzeld a profilalkotási adatokat különböző módokon. A következő példában láthatjuk a teljes GPU és CPU kihasználtságot, valamint az I/O várakozási idejét a több GPU-s betanítási feladathoz a Horovod használatával. A grafikonok létrehozásához a következő kódot futtatjuk:

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 )

A GPU kihasználtsága gyakran 0 és 100% között ingadozik, és a magas I/O várakozási idő alacsony GPU kihasználtság mellett az I/O szűk keresztmetszetét jelzi. Továbbá a teljes CPU kihasználtság soha nem haladja meg a 70%-ot, ami azt jelenti, hogy a dolgozói folyamatok számának növelésével javíthatjuk az adatok előfeldolgozását.

A teljesítményt a Horovodról a SageMaker elosztott adatok párhuzamos könyvtárára váltva javíthatjuk. A következő grafikonokon azt láthatjuk, hogy a GPU-kat hatékonyabban használják, és csak rövid időre csökkennek alacsony kihasználtságra.

Képzési infrastruktúra

A modellek betanítására 10 ml.p3.16xnagy példányt használtunk SageMaker képzési feladat segítségével. A SageMaker csökkenti a gépi tanulási (ML) modellek betanításának és hangolásának idejét és költségeit az infrastruktúra kezelése nélkül. A SageMaker segítségével könnyedén betaníthatja és hangolhatja az ML-modelleket a beépített eszközök segítségével a képzési kísérletek kezeléséhez és nyomon követéséhez, automatikusan kiválaszthatja az optimális hiperparamétereket, hibakeresheti a képzési feladatokat, és figyelemmel kísérheti a rendszererőforrások, például a GPU-k, CPU-k és a hálózati sávszélesség kihasználását. Az adatok az Amazon EFS-ben voltak tárolva, ami lehetővé tette számunkra, hogy növekedjünk és csökkenjünk, miközben a fájlokat hozzáadjuk és eltávolítjuk anélkül, hogy szükség lenne kezelésre vagy kiépítésre. Elsődleges célunk az edzés sebességének javítása és a költségek csökkentése volt.

Modell méretezhetőség

Bár ezt az infrastruktúrát elsősorban nyelvgenerálásra használják, a GPT architektúrával és a Pile adatkészlettel ezeket a technikákat használhatja nagyméretű transzformátormodellek betanításához, ami az NLP-n kívül számos területen hasznos. Magában a gépi tanulásban sok számítógépes látási feladatot ma már nagyparaméteres (transzformátoros) architektúrákkal oldanak meg, ahol kimutatták, hogy a hagyományos CNN-eket (Convolutional Neural Network) felülmúlják az olyan feladatokban, mint a reprezentációs tanulás (lásd A számítógépes látás korszerű fejlesztése önfelügyelt transzformátorokkal és 10-szer hatékonyabb képzéssel) és a képek nagyméretű leképezése szöveggé (pl CLIP). A nagyparaméteres modellek az élettudományokban is új utakat törnek olyan területeken, mint pl fehérjeszerkezet elemzés és a orvosi képadatok elemzése.

Az ebben a bejegyzésben részletezett megoldások az elosztott képzésre és a nagy modellek kezelésére vonatkoznak ezen területek bármelyikének modelljére is.

Kompromisszumokat

A kutatói közösségben folyamatosan vita folyik a nagyszabású nyelvi modellek képzésének kockázatairól, és arról, hogy kellőképpen átgondolták-e a kidolgozásukkal kapcsolatos lehetséges kockázatokat és az e kockázatok mérséklésére szolgáló stratégiákat, amelyek közül néhányan a pénzügyi és környezetvédelmi költségek. szerint a papír Az ACM-ben megjelent, egyetlen BERT-alapmodell (hiperparaméter-hangolás nélkül) GPU-kon való betanítása a becslések szerint annyi energiát igényel, mint egy transz-amerikai repülés. A környezeti hatások a modell méretéhez igazodnak, és az ilyen modellek hatékony finomhangolása jelentősen csökkentheti a kibocsátást. Az AWS nemrégiben elindított egy újat Vevői szénlábnyom eszköz, minden AWS-ügyfél számára ingyenesen elérhető, az Amazon fenntarthatóság növelésére és a szén-dioxid-kibocsátás csökkentésére irányuló erőfeszítéseinek részeként. Az alkalmazások AWS felhőn való futtatása potenciálisan csökkentheti a szénlábnyomot (ha összehasonlítjuk azokkal a vállalati adatközpontokkal, amelyek 2019 jelentés).

Következtetés

Ez a bejegyzés egy olyan megoldást mutatott be, amely megkönnyíti a nyelvi modellek finomhangolását milliárd paraméterrel az AWS Cloudban a SageMaker segítségével.

A SageMakerrel való modellpárhuzamról további információkért lásd: Tanítson több mint 175 milliárd paraméterű NLP-modellt modell párhuzamos kiegészítésekkel és Hugging Face-vel az Amazon SageMakeren és a Hogyan használta a Latent Space az Amazon SageMaker modell párhuzamossági könyvtárát a nagyméretű transzformátorok határainak kitűzésére.

Ha segítségre van szüksége az ML használatának felgyorsításához termékeiben és folyamataiban, kérjük, forduljon a Amazon ML Solutions Lab.

A szerzőkről

Sia Gholami vezető adattudós az Amazon ML Solutions Labnál, ahol AI/ML megoldásokat épít ügyfelei számára a különböző iparágakban. Szenvedélye a természetes nyelvi feldolgozás (NLP) és a mély tanulás. A munkán kívül Sia szívesen tölt időt a természetben és teniszez.

Mehdi Noorimenedzser és vezető alkalmazott tudós az Amazon ML Solutions Labnál, ahol különböző iparágakban dolgozó ügyfelekkel dolgozik, és segít nekik felgyorsítani a felhőbe való migrációjukat, valamint megoldani ML problémáikat a legmodernebb megoldások és technológiákat.

Muhyun Kim az Amazon Machine Learning Solutions Lab adattudósa. Gépi tanulással és mély tanulással oldja meg az ügyfelek különféle üzleti problémáit, valamint segíti a szakképzettséget.

Danny Byrd az Amazon ML Solutions Lab alkalmazott tudósa. A laborban segített ügyfeleinek fejlett ML-megoldások kifejlesztésében, az ML-specialitásokon a számítógépes látástól a megerősítő tanulásig. Szenvedélyesen törekszik a technológia előremozdítására és az AWS-termékekben rejlő új lehetőségek felszabadítására.

Francisco Calderon Rodriguez az Amazon ML Solutions Lab adatkutatója. Az ML Solutions Lab tagjaként mély tanulással segít megoldani az AWS-ügyfelek kritikus üzleti problémáit. Szabadidejében Francisco szeret zenélni és gitározni, focizni a lányaival, és élvezi a családjával töltött időt.

Yohei Nakayama az Amazon ML Solutions Lab Deep Learning Architect-je. Különböző ágazatokban együttműködő ügyfelekkel dolgozik, hogy felgyorsítsa a mesterséges intelligencia és az AWS felhőszolgáltatások használatát üzleti kihívásaik megoldása érdekében. Érdekli az ML/AI technológiák alkalmazása az űriparban.

Nathalie Rauschmayr Senior Applied Scientist az AWS-nél, ahol segít az ügyfeleknek mély tanulási alkalmazások fejlesztésében.

• Coinsmart. Európa legjobb Bitcoin- és kriptográfiai tőzsdéje.
• Platoblockchain. Web3 metaverzum intelligencia. Felerősített tudás. SZABAD HOZZÁFÉRÉS.
• CryptoHawk. Altcoin radar. Ingyenes próbaverzió.
• Forrás: 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/