Luo, kouluta ja ota käyttöön miljardiparametrinen kielimalli teratavuilla datalla TensorFlown ja Amazon SageMakerin avulla

Kielimallien koon kasvu on ollut yksi suurimmista trendeistä luonnollisen kielen käsittelyssä (NLP) viime vuosina. Vuodesta 2018 lähtien olemme nähneet ennennäkemättömällä tavalla yhä suurempien kielimallien kehitystä ja käyttöönottoa, mukaan lukien BERT ja sen muunnelmat, GPT-2, T-NLG ja GPT-3 (175 miljardia parametria).

Nämä mallit ovat siirtäneet mahdollisten arkkitehtonisten innovaatioiden rajoja. Kohtaamme useita haasteita koulutettaessa laajamittaisia ​​syväoppimismalleja, erityisesti uusi generatiivisten esikoulutettujen muuntajien aalto. Näihin haasteisiin kuuluvat laitteiston rajoitukset ja kompromissit laskennan ja tehokkuuden kanssa. Näiden mallien ja tietojen rinnakkaisuuden haasteiden voittamiseksi AWS tarjoaa laajan valikoiman ominaisuuksia.

Tässä viestissä esittelemme kaksi päälähestymistapaa: tietojen rinnastamisen ja mallin rinnakkaistamisen Amazon Sage Makerja keskustella niiden eduista ja haitoista.

Malli

Kielimallissa käytämme paperissa esiteltyjä Transformers Huomio on kaikki mitä tarvitset. Muuntajat ovat syväoppimismalleja, jotka on suunniteltu tietoisesti välttämään RNN:iden sudenkuopat luottamalla itsehuomiomekanismiin, joka vetää globaaleja riippuvuuksia syötteen ja lähdön välille. Transformer-malliarkkitehtuuri mahdollistaa huomattavasti paremman rinnakkaissuorituksen ja voi saavuttaa korkean suorituskyvyn suhteellisen lyhyessä harjoitusajassa. Rakennettu lehdessä esitellyn Transformersin BERT:n menestykselle BERT: Syväsuuntaisten muuntajien esikoulutus kielen ymmärtämistä varten, lisätty kaksisuuntainen esikoulutus kielen esittämiseen. Cloze-tehtävän innoittamana BERT on valmiiksi koulutettu maskatun kielen mallintamiseen (MLM), jossa malli oppii palauttamaan alkuperäiset sanat satunnaisesti maskatuille tokeneille. BERT-malli on myös esiopetettu seuraavan lauseen ennustustehtävään (NSP) ennustamaan, ovatko kaksi lausetta oikeassa lukujärjestyksessä. Vuonna 2018 tulonsa jälkeen BERT ja sen muunnelmat ovat olleet laajasti käytössä kielimalleissa.

Aloitamme luomalla kaksi upotuskerrosta tunniste- ja paikkaupotusta varten. Syöttö upotukset ovat merkki-upotusten ja paikan upotusten summa.

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

Sitten määritämme muuntajan dekooderilohkon, jossa on kaksi alikerrosta: usean pään itsetarkkailukerros ja yksinkertainen täysin kytketty eteenpäinsyöttöverkko, jota seuraa kerroksen normalisointi ja poisto:

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)

Lopuksi luomme kielimallimme edellisellä upotuskerroksella ja muuntajalohkoilla:

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

Hyperparametreistäsi riippuen voit skaalata tämän mallin tuhansista parametreista miljardeihin parametreihin. Miljardiparametristen mallien ensisijainen haaste on se, että mallia ei voi isännöidä yhdessä tapauksessa ja malli on jaettava useille solmuille harjoittelua ja päätelmiä varten.

Tietojoukko

Kokeissamme käytimme Paalun tietojoukko. Pile on 800 GiB:n englanninkielinen tekstitietojoukko, joka on suunniteltu suurten kielimallien koulutukseen. Se on luotu 22:sta monipuolisesta ja korkealaatuisesta tietojoukosta, mukaan lukien sekä vakiintuneet NLP-tietojoukot että äskettäin käyttöön otetut.

Tietojoukko luodaan useista tietolähteistä, mukaan lukien kirjoista; GitHub-arkistot; verkkosivut; keskustelulokit; sekä lääketieteen, fysiikan, matematiikan, tietojenkäsittelytieteen ja filosofian paperit. Se käyttää erityisesti seuraavia lähteitä: 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, Englanti Wikipedia, DM Mathematics, EuroParl, Enron Emails -korpus ja NIH ExPorter. Se sisältää myös OpenWebText2:n ja BookCorpus2:n, jotka ovat alkuperäisen OpenWebText- ja BookCorpus-tietojoukon laajennuksia. Tietolähteiden monimuotoisuus voi parantaa yleistä verkkotunnusten välistä tietämystä ja siten parantaa loppupään yleistyskykyä.

Tämän tietojoukon ensisijainen haaste on pelkkä koko; tietojoukossa on 825 GiB tekstiä, mikä tarkoittaa 4.2 TiB esikäsiteltyjä ja pakattuja tietopisteitä. Kuten haasteet, joita kohtaamme mallien koulutuksessa ja isännöinnissa, mallin kouluttaminen tällä tietojoukolla yhdellä kertaa vie paljon aikaa, eikä se ole käytännöllistä.

Ratkaisumme on jakaa tietojoukko noin 1 GiB:n tietopaloiksi, ladata ja esikäsitellä ominaisuudet TensorFlow Dataset esineitä ja säilytä niitä Amazon elastinen tiedostopalvelu (Amazon EFS). TensorFlow-tietojoukot tarjoavat helppokäyttöisen ja tehokkaan dataputken, joka integroituu hyvin malleihimme. Amazon EFS on helppokäyttöinen palvelu, jonka avulla voimme rakentaa jaetun tiedostojärjestelmän, joka skaalautuu automaattisesti, kun tiedostoja lisätään ja poistetaan. Lisäksi Amazon EFS pystyy nousemaan tarvittaessa korkeammalle suorituskyvylle, mikä on kriittistä data- ja mallikoulutusputkistossamme.

Seuraavaksi tarkastelemme hajautettuja koulutusstrategioita näihin haasteisiin vastaamiseksi.

Hajautettu koulutus

Tässä projektissa kohtasimme kaksi haastetta: mallin koon ja datamäärän skaalaus. Mallin koon ja koulutettavien parametrien määrän lisääminen voi parantaa tarkkuutta, mutta mallilla on rajansa, jonka voit majoittaa yhteen GPU-muistiin tai jopa useisiin GPU:ihin yhdessä esiintymässä. Lisäksi isompien mallikokojen harjoittelu vie enemmän aikaa.

Voit vastata näihin haasteisiin kahdella eri tavalla: tietojen rinnakkaisuudella ja mallin rinnakkaisuudella. Tietojen rinnakkaisuuden avulla suoritamme stokastisen gradientin laskeutumisen (SGD) jakamalla minierän tietueet eri laitteille harjoituksen nopeuttamiseksi. Rinnakkaiseen tiedonharjoitukseen liittyy kuitenkin ylimääräistä monimutkaisuutta laskea minierägradientin keskiarvoja kaikkien laitteiden gradienteilla, vaihe ns. AllReduce, mikä vaikeutuu koulutusklusterin kasvaessa. Datan rinnakkaisuutta käytettäessä meidän on kyettävä sovittamaan malli ja yksi tietopiste laitteeseen (CPU tai GPU), mikä on rajoittava tekijä kokeissamme, koska niin suuren mallin koko on paljon suurempi kuin yksittäisen GPU:n muisti. koko.

Toinen ratkaisu on käyttää mallin rinnakkaisuutta, mikä jakaa mallin useille laitteille. Mallin rinnakkaisuus on prosessi, jossa malli jaetaan useiden laitteiden tai solmujen (kuten GPU:lla varustettujen esiintymien) kesken ja luodaan tehokas putki mallin kouluttamiseksi näiden laitteiden välillä GPU-käytön maksimoimiseksi.

Tietojen rinnastaminen

Datan rinnakkaistaminen on yleisin lähestymistapa useisiin GPU:ihin tai hajautettuun koulutukseen. Voit ryhmitellä tietosi, lähettää ne useille laitteille (jokainen isännöi replikoitua mallia) ja sitten koota tulokset. Kokeilimme kahta pakettia tietojen rinnakkaisuudelle: Horovod ja the SageMaker hajautti rinnakkaistietoja.

Horovod on hajautettu syväoppimisen koulutuskehys TensorFlowille, Kerasille, PyTorchille ja Apache MXNetille. Käyttääksemme Horovodia kävimme läpi seuraavan prosessin:

1. Alusta ajamalla hvd.init().
2. Yhdistä jokainen laite yhteen prosessiin. Ensimmäinen prosessi tai työntekijä liittyy ensimmäiseen laitteeseen, toinen prosessi liittyy toiseen laitteeseen ja niin edelleen.
3. Säädä oppimisnopeutta laitteiden lukumäärän mukaan.
4. Kääri optimoija sisään hvd.DistributedOptimizer.
5. Lähetä alkumuuttujan tilat ensimmäiseltä työntekijältä, jonka arvo on 0, kaikille muille prosesseille. Tämä on tarpeen kaikkien työntekijöiden johdonmukaisen alustamisen varmistamiseksi, kun koulutus aloitetaan satunnaisilla painoilla tai palautetaan tarkastuspisteestä.
6. Varmista, että vain laite 0 voi tallentaa tarkistuspisteitä, jotta muut työntekijät eivät vahingoita niitä.

Seuraava on harjoitusskripti:

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)

SageMaker-datan rinnakkaiskirjaston avulla voimme skaalata harjoitteluamme lähes lineaarisella tehokkuudella, mikä nopeuttaa harjoitteluamme minimaalisilla koodimuutoksilla. Kirjasto suorittaa räätälöityjä AllReduce toiminnan ja optimoi laitteiden välisen viestinnän hyödyntämällä täysin AWS:n verkkoinfrastruktuuria ja Amazonin elastinen laskentapilvi (Amazon EC2) ilmentymän topologia. Käyttääksemme SageMaker-datan rinnakkaiskirjastoa, kävimme läpi seuraavan prosessin:

1. Tuo ja alusta sdp.init().
2. Yhdistä jokainen laite yhteen smdistributed.dataparallel prosessi kanssa local_rank. sdp.tensorflow.local_rank() antaa meille laitteiden paikallisen sijoituksen. Johtaja on arvolla 0 ja työntekijät 1, 2, 3 ja niin edelleen.
3. Säädä oppimisnopeutta laitteiden lukumäärän mukaan.
4. Kääri tf.GradientTape with DistributedGradientTape esiintyä AllReduce.
5. Lähetä mallin alkuperäiset muuttujat johtajasolmusta kaikille työntekijäsolmuille.
6. Varmista, että vain laite 0 voi tallentaa tarkistuspisteitä.

Mallin rinnastaminen

Voimme säätää hyperparametreja, jotta malli pysyy riittävän pienenä, jotta sitä voidaan harjoitella yhdellä grafiikkasuorittimella, tai voimme käyttää mallin rinnakkaisuutta mallin jakamiseen useiden GPU:iden kesken useiden esiintymien kesken. Mallin koulutettavien parametrien määrän lisääminen voi johtaa parempaan tarkkuuteen, mutta mallin enimmäiskokoa, joka mahtuu yhteen GPU-muistiin, on rajoitettu. Käytämme SageMaker-hajautettua mallien rinnakkaiskirjastoa kouluttaaksemme suurempia mallejamme. Vaiheet ovat seuraavat:

1. Tuo ja alusta kirjasto smp.init().
2. Keras-mallin on perittävä smp.DistributedModel Keras Model -luokan sijaan.
3. Asettaa drop_remainder=True vuonna tf.Dataset.batch() menetelmä, jolla varmistetaan, että erän koko on aina jaollinen mikroerien lukumäärällä.
4. Kaikkien dataliukuhihnan satunnaisten toimintojen on käytettävä samaa siementä: smp.dp_rank()Esimerkiksi shuffle(ds, seed=smp.dp_rank()). Tämä varmistaa tietonäytteiden yhdenmukaisuuden laitteissa, joissa on eri malliosioita.
5. Eteenpäin ja taaksepäin logiikan on oltava askelfunktiossa smp.step koriste.
6. Suorita tulosteiden jälkikäsittely mikroerien välillä käyttämällä StepOutput-menetelmiä, kuten reduce_mean. smp.step -funktiolla on oltava palautusarvo, joka riippuu funktion lähdöstä smp.DistributedModel.

Koulutusskripti on seuraava:

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) 

Yksityiskohtainen opas TensorFlow-harjoituskomentosarjan käyttöönottamisesta SageMaker-hajautetun mallin rinnakkaiskirjastolle on osoitteessa Muokkaa TensorFlow-harjoitusskriptiä. PyTorch, katso Muokkaa PyTorch-harjoituskomentosarjaa.

SageMaker-virheenkorjaus

Edellisissä osioissa keskustelimme, kuinka koulutusta voidaan optimoida malli- ja tietojen rinnakkaistekniikoilla. Kanssa Amazon SageMaker -korjaamo, voimme nyt kerätä suoritusprofiilitietoja harjoituksistamme määrittääksemme, kuinka paljon harjoitus on parantunut. Oletusarvoisesti Debugger kaappaa järjestelmätiedot jokaiselle SageMaker-harjoitustyölle, kuten GPU, suorittimen käyttöaste, muisti, verkko ja I/O 500 millisekunnin näytevälillä. Voimme käyttää tietoja seuraavasti:

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 tarjoaa apuohjelmia havainnollistaa profilointidataa eri tavoin. Seuraavassa esimerkissä näemme GPU:n ja CPU:n kokonaiskäyttöasteen sekä I/O-odotusajan usean grafiikkasuorittimen harjoitustyölle Horovodilla. Näiden kaavioiden luomiseksi suoritamme seuraavan koodin:

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 )

Grafiikkasuorittimen käyttöaste vaihtelee usein välillä 0–100 %, ja korkeat I/O-odotusajat alhaisella GPU:n käyttöasteella ovat osoitus I/O-pullonkaulasta. Lisäksi suorittimen kokonaiskäyttöaste ei koskaan ylitä 70 %, mikä tarkoittaa, että voimme parantaa tietojen esikäsittelyä lisäämällä työprosessien määrää.

Voimme parantaa suorituskykyä vaihtamalla Horovodista SageMakerin hajautettuun datan rinnakkaiskirjastoon. Seuraavista kaavioista voimme nähdä, että grafiikkasuoritteita hyödynnetään tehokkaammin ja ne laskevat alhaiselle käyttöasteelle vain lyhyeksi ajaksi.

Koulutuksen infrastruktuuri

Mallien koulutukseen käytimme 10 ml.p3.16xsuuria kappaletta SageMaker-harjoitustyön avulla. SageMaker vähentää koneoppimismallien (ML) kouluttamiseen ja virittämiseen kuluvaa aikaa ja kustannuksia ilman infrastruktuurin hallintaa. SageMakerin avulla voit helposti kouluttaa ja virittää ML-malleja käyttämällä sisäänrakennettuja työkaluja harjoituskokeiden hallintaan ja seurantaan, valita automaattisesti optimaaliset hyperparametrit, virheenkorjaus koulutustöitä ja seurata järjestelmäresurssien, kuten GPU:iden, suorittimien ja verkon kaistanleveyden, käyttöä. Dataa isännöitiin Amazon EFS:ssä, minkä ansiosta pystyimme kasvamaan ja pienentymään, kun lisäämme ja poistamme tiedostoja ilman hallintaa tai provisiointia. Päätavoitteemme oli parantaa harjoitusnopeutta ja vähentää kustannuksia.

Mallin skaalautuvuus

Vaikka tätä infrastruktuuria käytetään ensisijaisesti kielten luomiseen, GPT-arkkitehtuurin ja Pile-tietojoukon avulla voit käyttää näitä tekniikoita suuren mittakaavan muuntajamallien kouluttamiseen, mikä on hyödyllistä monilla aloilla NLP:n lisäksi. Itse koneoppimisessa monet tietokonenäkötehtävät ratkaistaan ​​nyt suurten parametrien (muuntaja) arkkitehtuureilla, joissa niiden on osoitettu ylittävän perinteiset CNN:t (Convolutional Neural Network) sellaisissa tehtävissä kuin esitysoppiminen (katso Tietokonenäön huipputason edistäminen itse valvotuilla muuntajilla ja 10x tehokkaammalla koulutuksella) ja kuvien laajamittainen kartoitus tekstiksi (esim CLIP). Suurparametriset mallit ovat myös murtamassa uutta tietä biotieteissä mm proteiinin rakenneanalyysi ja lääketieteellisten kuvatietojen analysointi.

Tässä viestissä yksityiskohtaisia ​​ratkaisuja hajautettuun koulutukseen ja suurten mallien hallintaan tulisi koskea myös minkä tahansa näiden alueiden malleissa.

Kompromissit

Tutkimusyhteisössä on käyty jatkuvaa keskustelua laajamittaisten kielimallien koulutuksen riskeistä ja siitä, onko niiden kehittämiseen liittyviä mahdollisia riskejä ja strategioita näiden riskien lieventämiseksi mietitty tarpeeksi. Näitä riskejä ovat mm. ympäristökustannukset. Mukaan a paperi ACM:ssä julkaistun yksittäisen BERT-perusmallin (ilman hyperparametrien viritystä) koulutuksen GPU:illa arvioitiin vaativan yhtä paljon energiaa kuin transamerikkalaisen lennon. Ympäristövaikutukset skaalautuvat mallin koon mukaan, ja tällaisten mallien tehokas hienosäätö voi mahdollisesti vähentää päästöjä merkittävästi. AWS julkaisi äskettäin uuden Asiakkaan hiilijalanjälkityökalu, joka on kaikkien AWS-asiakkaiden saatavilla veloituksetta osana Amazonin pyrkimyksiä lisätä kestävyyttä ja vähentää hiilidioksidipäästöjä. Sovellusten käyttäminen AWS-pilvessä voi mahdollisesti pienentää hiilijalanjälkeä (verrattuna vuonna XNUMX tutkittuihin yrityspalvelinkeskuksiin). 2019-raportti).

Yhteenveto

Tämä viesti esitteli ratkaisun, joka helpottaa kielimallien hienosäätöä miljardilla parametrilla AWS-pilvessä SageMakerin avulla.

Lisätietoja mallien rinnakkaisuudesta SageMakerin kanssa on kohdassa Harjoittele yli 175 miljardia parametri-NLP-mallia mallien rinnakkaisilla lisäyksillä ja Hugging Facella Amazon SageMakerissa ja Kuinka latentti avaruus käytti Amazon SageMaker -mallikirjastokirjastoa suurten muuntajien rajojen työntämiseen.

Jos haluat apua ML: n käytön nopeuttamisessa tuotteissasi ja prosesseissasi, ota yhteyttä Amazon ML Solutions Lab.

Tietoja Tekijät

Sia Gholami on vanhempi tietotutkija Amazon ML Solutions Labissa, jossa hän rakentaa AI/ML-ratkaisuja asiakkaille eri toimialoilla. Hän on intohimoinen luonnollisen kielen käsittelyyn (NLP) ja syväoppimiseen. Työn ulkopuolella Sia viihtyy luonnossa ja pelaa tennistä.

Mehdi Noorion johtaja ja vanhempi soveltuva tutkija Amazon ML Solutions Labissa, jossa hän työskentelee asiakkaiden kanssa eri toimialoilta ja auttaa heitä nopeuttamaan pilvisiirtoa ja ratkaisemaan ML-ongelmiaan käyttämällä huippuluokan ratkaisuja ja teknologioita.

Muhyun Kim on Amazon Machine Learning Solutions Labin datatieteilijä. Hän ratkaisee asiakkaan erilaiset liiketoimintaongelmat soveltamalla koneoppimista ja syvällistä oppimista sekä auttaa heitä taitamaan.

Danny Byrd on soveltuva tutkija Amazon ML Solutions Labissa. Laboratoriossa hän on auttanut asiakkaita kehittämään edistyneitä ML-ratkaisuja ML-erikoisuuksissa tietokonenäöstä vahvistusoppimiseen. Hän on intohimoinen teknologian edistämisestä ja uuden potentiaalin avaamisesta AWS-tuotteista matkan varrella.

Francisco Calderon Rodriguez on datatutkija Amazon ML Solutions Labissa. ML Solutions Labin jäsenenä hän auttaa ratkaisemaan kriittisiä liiketoimintaongelmia AWS-asiakkaille syväoppimisen avulla. Vapaa-ajallaan Francisco tykkää soittaa musiikkia ja kitaraa, pelata jalkapalloa tyttäriensä kanssa ja viettää aikaa perheensä kanssa.

Yohei Nakayama on syväoppiva arkkitehti Amazon ML Solutions Labissa. Hän työskentelee asiakkaiden kanssa eri toimialoilla nopeuttaakseen tekoälyn ja AWS-pilvipalveluiden käyttöä yritysten haasteiden ratkaisemiseksi. Hän on kiinnostunut ML/AI-tekniikoiden soveltamisesta avaruusteollisuuteen.

Nathalie Rauschmayr on vanhempi sovellettu tutkija AWS:ssä, jossa hän auttaa asiakkaita kehittämään syväoppimissovelluksia.

• Coinsmart. Euroopan paras Bitcoin- ja kryptopörssi.
• Platoblockchain. Web3 Metaverse Intelligence. Tietoa laajennettu. VAPAA PÄÄSY.
• CryptoHawk. Altcoinin tutka. Ilmainen kokeilu.
• Lähde: 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/