Looge, treenige ja juurutage miljardiparameetriline keelemudel terabaitidel andmetel TensorFlow ja Amazon SageMakeriga

Keelemudelite suurenemine on viimaste aastate üks suurimaid suundumusi loomuliku keele töötlemise (NLP) valdkonnas. Alates 2018. aastast oleme näinud enneolematut üha suuremate keelemudelite, sealhulgas BERTi ja selle variantide GPT-2, T-NLG ja GPT-3 (175 miljardit parameetrit) arendamist ja kasutuselevõttu.

Need mudelid on nihutanud võimalike arhitektuuriliste uuenduste piire. Suuremahuliste süvaõppemudelite koolitamisel seisame silmitsi mitme väljakutsega, eriti generatiivsete eelkoolitatud trafode uue lainega. Need väljakutsed hõlmavad riistvarapiiranguid ja kompromisse arvutuste ja tõhususega. Nende mudelite ja andmete paralleelsusega seotud väljakutsete ületamiseks pakub AWS laia valikut võimalusi.

Selles postituses tutvustame kahte peamist lähenemisviisi: andmete paralleelsus ja mudeli paralleelsus Amazon SageMakerning arutada nende plusse ja miinuseid.

Mudel

Keelemudeli jaoks kasutame töös tutvustatud transformereid Tähelepanu on kõik, mida vajate. Transformerid on süvaõppe mudelid, mis on loodud selleks, et tahtlikult vältida RNN-ide lõkse, tuginedes enesetähelepanumehhanismile, et tõmmata sisendi ja väljundi vahel globaalseid sõltuvusi. Transformeri mudeli arhitektuur võimaldab oluliselt paremat paralleelsust ja suudab saavutada kõrge jõudluse suhteliselt lühikese treeningajaga. Toetudes ajakirjas tutvustatud Transformersi BERTi edule BERT: sügavate kahesuunaliste trafode eelkoolitus keele mõistmiseks, lisatud kahesuunaline keeleesituse eelkoolitus. Cloze ülesandest inspireerituna on BERT eelnevalt koolitatud maskeeritud keele modelleerimisega (MLM), mille käigus mudel õpib taastama juhuslikult maskeeritud märkide algsõnu. BERT-i mudel on ka eelkoolitatud järgmise lause ennustamise (NSP) ülesande jaoks, et ennustada, kas kaks lauset on õiges lugemisjärjestuses. Alates selle tulekust 2018. aastal on BERTi ja selle variatsioone keelemudelites laialdaselt kasutatud.

Alustuseks loome kaks manustuskihti märgi ja positsioonilise manustamise jaoks. Sisendmanustused on märgimanustuste ja positsioonimanustuste 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

Seejärel määratleme trafodekoodri ploki, millel on kaks alamkihti: mitme peaga enesetähelepanu kiht ja lihtne täielikult ühendatud edasivooluvõrk, millele järgneb kihi normaliseerimine ja väljalangemine:

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)

Lõpuks loome oma keelemudeli eelneva manustamiskihi ja trafoplokkidega:

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

Sõltuvalt teie hüperparameetritest saate seda mudelit skaleerida tuhandetest parameetritest miljarditeni. Miljardiparameetriliste mudelite peamine väljakutse on see, et te ei saa mudelit ühes eksemplaris hostida ja mudelit on vaja koolitamiseks ja järelduste tegemiseks mitme sõlme vahel levitada.

Andmekogum

Oma katsetes kasutasime Vaia andmestik. Pile on 800 GiB ingliskeelse tekstiandmekogum, mis on loodud suuremahuliste keelemudelite koolitamiseks. See on loodud 22 erinevast ja kvaliteetsest andmekogumist, sealhulgas nii loodud NLP-andmestikud kui ka äsja kasutusele võetud andmekogumid.

Andmekogum luuakse mitmesugustest andmeallikatest, sealhulgas raamatutest; GitHubi hoidlad; veebilehed; vestluslogid; meditsiini-, füüsika-, matemaatika-, informaatika- ja filosoofiatööd. Täpsemalt kasutab see järgmisi allikaid: Pile-CC, PubMed Central, ArXiv, GitHub, FreeLaw Project, Stack Exchange, USA patendi- ja kaubamärgiamet, PubMed, Ubuntu, IRC, HackerNews, YouTube, PhilPapers, Books3, Project Gutenberg ( PG-19), OpenSubtitles, ingliskeelne Wikipedia, DM Mathematics, EuroParl, Enroni meilikorpus ja NIH ExPorter. See sisaldab ka OpenWebText2 ja BookCorpus2, mis on vastavalt algsete OpenWebTexti ja BookCorpuse andmekogumite laiendused. Andmeallikate mitmekesisus võib parandada üldisi valdkonnaüleseid teadmisi ja järelikult parandada allavoolu üldistusvõimet.

Selle andmestiku peamine väljakutse on tohutu suurus; andmestikus on 825 GiB teksti, mis tähendab 4.2 TiB eeltöödeldud ja tihendatud andmepunkte. Sarnaselt väljakutsetega, millega silmitsi seisame mudelite koolitamise ja hostimisega, võtab selle andmestikuga mudeli ühe eksemplari väljaõpetamine palju aega ja pole otstarbekas.

Meie lahendus on jagada andmekogum ligikaudu 1 GiB andmetükkideks, laadida ja eeltöödelda funktsioonid TensorFlow andmestik objekte ja neid sinna salvestada Amazon elastne failiteenus (Amazon EFS). TensorFlow andmestikud pakuvad lihtsalt kasutatavat ja suure jõudlusega andmekonveieri, mis integreerub hästi meie mudelitega. Amazon EFS on lihtsalt kasutatav teenus, mis võimaldab meil luua jagatud failisüsteemi, mis skaleerub automaatselt failide lisamisel ja kustutamisel. Lisaks suudab Amazon EFS vajaduse korral jõuda kõrgemale läbilaskevõimele, mis on meie andmete ja mudelite koolituse jaoks kriitilise tähtsusega.

Järgmisena uurime nende väljakutsete lahendamiseks hajutatud koolitusstrateegiaid.

Hajutatud koolitus

Selles projektis seisime silmitsi kahe väljakutsega: mudeli suuruse ja andmemahu skaleerimine. Mudeli suuruse ja treenitavate parameetrite arvu suurendamine võib kaasa tuua parema täpsuse, kuid mudelil on piirang, mida saate ühe GPU-mällu või isegi mitu GPU-d korraga mahutada. Lisaks kulub suuremate mudelite treenimiseks rohkem aega.

Saate neid väljakutseid lahendada kahel erineval viisil: andmete paralleelsus ja mudeli paralleelsus. Andmete paralleelsusega teostame stohhastilise gradiendi laskumise (SGD), jaotades koolituse kiirendamiseks minipartii kirjed erinevate seadmete vahel. Paralleelsel andmetreeningul on aga minipartii gradiendi keskmise arvutamine kõigi seadmete gradientidega eriti keerukas. AllReduce, mis muutub treeningklastri kasvades raskemaks. Andmete paralleelsuse kasutamisel peame suutma mahutada mudeli ja ühe andmepunkti seadmesse (CPU või GPU), mis on meie katsetes piirav tegur, kuna nii suure mudeli suurus on palju suurem kui ühe GPU mälu. suurus.

Teine lahendus on kasutada mudeli paralleelsust, mis jagab mudeli mitme seadme vahel. Mudeli paralleelsus on protsess, mille käigus jagatakse mudel mitme seadme või sõlme vahel (nt GPU-ga varustatud eksemplarid) ja luuakse tõhus konveier mudeli koolitamiseks nendes seadmetes, et maksimeerida GPU kasutust.

Andmete paralleelsus

Andmete paralleelsus on kõige levinum lähenemine mitmele GPU-le või hajutatud koolitusele. Saate oma andmed koondada, saata need mitmesse seadmesse (igaüks majutab kopeeritud mudelit) ja seejärel tulemused koondada. Katsetasime andmete paralleelseerimiseks kahe paketiga: Horovod ja the SageMakeri hajutatud andmete paralleelteek.

Horovod on hajutatud süvaõppe koolitusraamistik TensorFlow, Keras, PyTorch ja Apache MXNet jaoks. Horovodi kasutamiseks läbisime järgmise protsessi:

1. Käivitage käivitades hvd.init().
2. Seostage iga seade ühe protsessiga. Esimene protsess või töötaja on seotud esimese seadmega, teine ​​protsess on seotud teise seadmega jne.
3. Reguleerige õppimiskiirust seadmete arvu järgi.
4. Pakkige optimeerija sisse hvd.DistributedOptimizer.
5. Esitage algmuutuja olekud esimeselt töötajalt, kelle auaste on 0, kõigile teistele protsessidele. See on vajalik, et tagada kõigi töötajate järjepidev initsialiseerimine, kui koolitust alustatakse juhuslike raskustega või taastatakse kontrollpunktist.
6. Veenduge, et ainult seade 0 saab kontrollpunkte salvestada, et teised töötajad neid ei rikuks.

Treeningu skript on järgmine:

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)

SageMakeri andmete paralleelteek võimaldab meil oma koolitust peaaegu lineaarselt tõhustada, kiirendades koolitust minimaalsete koodimuudatustega. Raamatukogu täidab tava AllReduce toimimist ja optimeerib seadmete vahelist suhtlust, kasutades täielikult ära AWS-i võrguinfrastruktuuri ja Amazon Elastic Compute Cloud (Amazon EC2) eksemplari topoloogia. Andmete paralleelteegi SageMaker kasutamiseks tegime läbi järgmise protsessi:

1. Importige ja lähtestage sdp.init().
2. Seostage iga seade ühe seadmega smdistributed.dataparallel töötlema koos local_rank. sdp.tensorflow.local_rank() annab meile seadmete kohaliku auastme. Juht on auaste 0 ja töötajad on auaste 1, 2, 3 jne.
3. Reguleerige õppimiskiirust seadmete arvu järgi.
4. Mähi tf.GradientTape koos DistributedGradientTape esinema AllReduce.
5. Esitage mudeli esialgsed muutujad juhtsõlmest kõigile töötaja sõlmedele.
6. Veenduge, et kontrollpunkte saab salvestada ainult seade 0.

Mudeli paralleelsus

Saame kohandada hüperparameetreid, et mudel oleks piisavalt väike, et treenida ühe GPU-ga, või saame kasutada mudeli paralleelsust, et jagada mudel mitme GPU vahel mitme eksemplari vahel. Mudeli treenitavate parameetrite arvu suurendamine võib kaasa tuua parema täpsuse, kuid ühe GPU-mällu mahutava mudeli maksimaalne suurus on piiratud. Suuremate mudelite koolitamiseks kasutasime SageMakeri hajutatud mudelite paralleelteeki. Toimingud on järgmised.

1. Importige ja lähtestage teek rakendusega smp.init().
2. Kerase mudel peab pärima smp.DistributedModel klassi Kerase mudeli asemel.
3. komplekt drop_remainder=True aasta tf.Dataset.batch() meetod, mis tagab, et partii suurus jagub alati mikropartiide arvuga.
4. Kõik andmekonveieri juhuslikud toimingud peavad kasutama sama seemet: smp.dp_rank()Näiteks shuffle(ds, seed=smp.dp_rank()). See tagab andmenäidiste järjepidevuse seadmetes, mis sisaldavad erinevaid mudelisektsioone.
5. Edasi ja tagasi loogika peab olema astmefunktsioonis smp.step kaunistamine.
6. Viige läbi mikropartiide väljundite järeltöötlus, kasutades StepOutput meetodeid, näiteks reduce_mean. smp.step funktsioonil peab olema tagastusväärtus, mis sõltub väljundist smp.DistributedModel.

Treeningu skript on järgmine:

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) 

Üksikasjaliku juhendi saamiseks TensorFlow treeningskripti lubamiseks SageMakeri hajutatud mudeli paralleelteegi jaoks vaadake Muutke TensorFlow treeningskripti. PyTorchi kohta vaadake Muutke PyTorchi koolitusskripti.

SageMakeri silur

Eelmistes osades arutasime, kuidas optimeerida koolitust mudeli ja andmete paralleelsustehnikate abil. Koos Amazon SageMakeri silur, saame nüüd koguda oma treeningutest tulemuslikkuse profiiliteavet, et teha kindlaks, kui palju treening on paranenud. Vaikimisi jäädvustab siluja süsteemimõõdikud iga SageMakeri treeningtöö kohta, nagu GPU, CPU kasutus, mälu, võrk ja I/O, 500 millisekundilise diskreetimisintervalliga. Saame andmetele juurde pääseda järgmiselt:

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

Silur pakub utiliite visualiseeri profiiliandmeid erinevatel viisidel. Järgmises näites näeme GPU ja CPU kogukasutust ning sisend-väljundi ooteaega mitme GPU-ga koolitustöö jaoks Horovodi abil. Nende graafikute loomiseks käivitame järgmise koodi:

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 )

GPU-kasutus kõigub sageli vahemikus 0–100% ja kõrged I/O-ooteajad madala GPU-kasutusega näitavad I/O-pudelikaela. Lisaks ei ületa protsessori kogukasutus kunagi 70%, mis tähendab, et saame parandada andmete eeltöötlust, suurendades tööprotsesside arvu.

Saame jõudlust parandada, kui lülitame Horovodilt üle SageMakeri hajutatud andmete paralleelteegile. Järgmistel graafikutel on näha, et GPU-sid kasutatakse tõhusamalt ja need langevad madalale kasutusastmele vaid lühikeseks ajaks.

Koolituse infrastruktuur

Mudelite koolitamiseks kasutasime SageMakeri koolitustöö abil 10 ml.p3.16xsuurt eksemplari. SageMaker vähendab masinõppe (ML) mudelite koolitamiseks ja häälestamiseks kuluvat aega ja kulusid ilma infrastruktuuri haldamise vajaduseta. SageMakeriga saate hõlpsalt treenida ja häälestada ML-mudeleid, kasutades sisseehitatud tööriistu treeningkatsete haldamiseks ja jälgimiseks, valida automaatselt optimaalseid hüperparameetreid, siluda treeningtöid ja jälgida süsteemiressursside, nagu GPU-d, protsessorid ja võrgu ribalaiust, kasutamist. Andmeid majutati Amazon EFS-is, mis võimaldas meil kasvada ja kahaneda, kui lisame ja eemaldame faile, ilma et oleks vaja haldust ega varustada. Meie peamised eesmärgid olid treeningkiiruse parandamine ja kulude vähendamine.

Mudeli skaleeritavus

Kuigi seda infrastruktuuri kasutatakse peamiselt keelte genereerimiseks, saate GPT arhitektuuri ja Pile'i andmestikuga kasutada neid tehnikaid suuremahuliste trafomudelite koolitamiseks, mis on kasulik paljudes valdkondades peale NLP. Masinõppes endas lahendatakse paljud arvutinägemise ülesanded nüüd suure parameetriga (trafo) arhitektuuriga, kus on näidatud, et need edestavad traditsioonilisi CNN-e (konvolutsiooniline närvivõrk) selliste ülesannete puhul nagu esitusõpe (vt. Edendage arvutinägemise tipptasemel enesejärelevalvega transformereid ja 10 korda tõhusamat koolitust) ja piltide suuremahuline vastendamine tekstiks (nt CLIP). Suure parameetriga mudelid murravad ka eluteadustes uut teed sellistes valdkondades nagu valgu struktuuri analüüs ja meditsiiniliste kujutiste andmete analüüs.

Lahendused, mida selles postituses kirjeldame hajutatud koolituse ja suurte mudelite haldamiseks, peaksid kehtima ka kõigi nende valdkondade mudelite puhul.

Kompromissid

Teadlaskonnas on käimas arutelu suuremahuliste keelemudelite koolitamisega kaasnevate riskide üle ning selle üle, kas on piisavalt läbimõeldud nende väljatöötamisega kaasnevatele võimalikele riskidele ja nende maandamise strateegiatele, millest mõned hõlmavad rahalisi ja keskkonnakulud. Vastavalt a paber ACM-is avaldatud, ühe BERT-i baasmudeli (ilma hüperparameetrite häälestamiseta) GPU-del treenimine eeldas hinnanguliselt sama palju energiat kui üle-Ameerika lend. Keskkonnamõjud ulatuvad mudeli suuruse järgi ja selliste mudelite tõhus viimistlemine võib heitkoguseid märkimisväärselt vähendada. AWS tõi hiljuti turule uue Kliendi süsiniku jalajälje tööriist, mis on kõigile AWS-i klientidele tasuta saadaval osana Amazoni jõupingutustest jätkusuutlikkuse suurendamiseks ja süsinikdioksiidi heitkoguste vähendamiseks. Rakenduste käitamine AWS-i pilves võib potentsiaalselt vähendada süsiniku jalajälge (võrreldes ettevõtete andmekeskustega, mida uuriti aastal 2019-i aruanne).

Järeldus

See postitus demonstreeris lahendust, mis hõlbustab SageMakeri abil AWS-i pilves miljardi parameetriga keelemudelite peenhäälestamist.

Lisateavet mudeli paralleelsuse kohta SageMakeriga vt Treenige Amazon SageMakeris 175+ miljardi parameetriga NLP-mudelit koos mudeli paralleelsete lisandite ja kallistava näoga ja Kuidas Latent Space kasutas Amazon SageMakeri mudeli paralleelsuse raamatukogu, et suruda suuremahuliste trafode piire.

Kui soovite abi ML-i kasutamise kiirendamisel oma toodetes ja protsessides, võtke ühendust Amazon ML Solutions Lab.

Autoritest

Sia Gholami on vanemandmeteadlane Amazon ML Solutions Labis, kus ta ehitab AI/ML lahendusi klientidele erinevatest tööstusharudest. Ta on kirglik loomuliku keele töötlemise (NLP) ja sügava õppimise vastu. Väljaspool tööd veedab Sia meelsasti looduses ja mängib tennist.

Mehdi Noorion Amazon ML Solutions Labi juht ja vanemrakendusteadlane, kus ta töötab klientidega erinevatest tööstusharudest ning aitab neil kiirendada nende pilverände teekonda ning lahendada ML-probleeme, kasutades uusimaid lahendusi ja tehnoloogiaid.

Muhyun Kim on andmeteadlane Amazon Machine Learning Solutions Labis. Ta lahendab klientide erinevaid äriprobleeme masinõppe ja süvaõppe rakendamisega ning aitab neil ka oskusi omandada.

Danny Byrd on Amazon ML Solutions Labi rakendusteadlane. Laboris on ta aidanud klientidel arendada täiustatud ML-lahendusi, ML-i erialadel alates arvutinägemisest kuni arendusõppeni. Ta on kirglik tehnoloogia edasiviimise ja AWS-i toodete uue potentsiaali avamise vastu.

Francisco Calderon Rodriguez on andmeteadlane Amazon ML Solutions Labis. ML Solutions Labi liikmena aitab ta süvaõppe abil lahendada AWS-i klientide kriitilisi äriprobleeme. Vabal ajal meeldib Franciscole muusikat ja kitarri mängida, tütardega jalgpalli mängida ja perega koos aega veeta.

Yohei Nakayama on Amazon ML Solutions Labi süvaõppe arhitekt. Ta teeb koostööd klientidega erinevatest vertikaalidest, et kiirendada tehisintellekti ja AWS-i pilveteenuste kasutamist nende äriprobleemide lahendamisel. Ta on huvitatud ML/AI tehnoloogiate rakendamisest kosmosetööstuses.

Nathalie Rauschmayr on AWS-i vanemrakendusteadlane, kus ta aitab klientidel arendada süvaõppe rakendusi.

• Münditark. Euroopa parim Bitcoini ja krüptobörs.
• Platoblockchain. Web3 metaversiooni intelligentsus. Täiustatud teadmised. TASUTA PÄÄS.
• CryptoHawk. Altcoini radar. Tasuta prooviversioon.
• Allikas: 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/