Ustvarite, učite in uvedite jezikovni model z milijardo parametrov na terabajtih podatkov s TensorFlow in Amazon SageMaker

Povečevanje velikosti jezikovnih modelov je eden največjih trendov v obdelavi naravnega jezika (NLP) v zadnjih letih. Od leta 2018 smo bili priča razvoju in uvajanju vse večjih jezikovnih modelov brez primere, vključno z BERT in njegovimi različicami, GPT-2, T-NLG in GPT-3 (175 milijard parametrov).

Ti modeli so premaknili meje možnih arhitekturnih inovacij. Pri usposabljanju obsežnih modelov globokega učenja se soočamo z več izzivi, zlasti z novim valom generativnih vnaprej usposobljenih transformatorjev. Ti izzivi vključujejo omejitve strojne opreme in kompromise z računanjem in učinkovitostjo. Za premagovanje teh izzivov vzporednosti modelov in podatkov AWS ponuja široko paleto zmogljivosti.

V tem prispevku predstavljamo dva glavna pristopa: vzporeditev podatkov in uporabo paralelizacije modela Amazon SageMakerin razpravljali o njihovih prednostih in slabostih.

Model

Za jezikovni model uporabljamo v prispevku predstavljene transformatorje Pozornost je vse, kar potrebujete. Transformatorji so modeli globokega učenja, zasnovani tako, da se namenoma izognejo pastem RNN-jev, tako da se zanašajo na mehanizem samopozornosti, da narišejo globalne odvisnosti med vhodom in izhodom. Arhitektura modela Transformer omogoča znatno boljšo paralelizacijo in lahko doseže visoko zmogljivost v relativno kratkem času usposabljanja. Zgrajen na uspehu Transformerjev, BERT, predstavljen v časopisu BERT: predhodno usposabljanje globokih dvosmernih transformatorjev za jezikovno razumevanje, dodano dvosmerno predhodno usposabljanje za predstavitev jezika. Po navdihu naloge Cloze je BERT predhodno usposobljen za modeliranje maskiranega jezika (MLM), pri katerem se model nauči obnoviti izvirne besede za naključno maskirane žetone. Model BERT je tudi predhodno usposobljen za nalogo napovedi naslednjega stavka (NSP), da napove, ali sta dva stavka v pravilnem vrstnem redu branja. Od njegovega pojava leta 2018 se BERT in njegove različice pogosto uporabljajo v jezikovnih modelih.

Začnemo z ustvarjanjem dveh vdelanih plasti za žetonsko in pozicijsko vdelavo. Vhodne vdelave so vsota vdelav žetonov in vdelav pozicij.

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

Nato definiramo transformatorski dekodirni blok z dvema podslojema: plastjo samopozornosti z več glavami in preprostim popolnoma povezanim omrežjem za naprej, ki mu sledita normalizacija in izpad plasti:

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)

Končno ustvarimo naš jezikovni model s predhodnim vdelanim slojem in transformatorskimi bloki:

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

Odvisno od vaših hiperparametrov lahko ta model prilagodite na več tisoč parametrov na milijarde parametrov. Primarni izziv pri modelih z milijardo parametrov je, da modela ne morete gostiti v enem primeru in morate model porazdeliti po več vozliščih za usposabljanje in sklepanje.

Nabor podatkov

V naših poskusih smo uporabili Nabor podatkov Pile. Pile je 800 GiB nabor podatkov angleškega besedila, zasnovan za usposabljanje obsežnih jezikovnih modelov. Ustvarjen je iz 22 raznolikih in visokokakovostnih naborov podatkov, vključno z uveljavljenimi nabori podatkov NLP in na novo uvedenimi.

Nabor podatkov je ustvarjen iz različnih virov podatkov, vključno s knjigami; repozitoriji GitHub; spletne strani; dnevniki klepetov; ter članke iz medicine, fizike, matematike, računalništva in filozofije. Natančneje, uporablja naslednje vire: Pile-CC, PubMed Central, ArXiv, GitHub, FreeLaw Project, Stack Exchange, Urad ZDA za patente in blagovne znamke, PubMed, Ubuntu, IRC, HackerNews, YouTube, PhilPapers, Books3, Project Gutenberg ( PG-19), OpenSubtitles, angleška Wikipedia, DM Mathematics, EuroParl, korpus Enron Emails in NIH ExPorter. Vključuje tudi OpenWebText2 in BookCorpus2, ki sta razširitvi izvirnih naborov podatkov OpenWebText oziroma BookCorpus. Raznolikost podatkovnih virov lahko izboljša splošno znanje med domenami in posledično izboljša zmožnosti posploševanja na nižji stopnji.

Glavni izziv pri tem naboru podatkov je sama velikost; nabor podatkov ima 825 GiB besedila, kar pomeni 4.2 TiB vnaprej obdelanih in stisnjenih podatkovnih točk. Podobno kot izzivi, s katerimi se srečujemo pri usposabljanju in gostovanju modelov, bo usposabljanje modela s tem naborom podatkov na enem primeru vzelo veliko časa in ni praktično.

Naša rešitev je, da nabor podatkov razdelimo na približno 1 GiB dele podatkov, naložimo in predhodno obdelamo funkcije v Nabor podatkov TensorFlow predmete in jih shranite Amazon Elastic File Service (Amazon EFS). Nabori podatkov TensorFlow zagotavljajo enostaven za uporabo in visoko zmogljiv podatkovni cevovod, ki se dobro integrira z našimi modeli. Amazon EFS je storitev, enostavna za uporabo, ki nam omogoča, da zgradimo datotečni sistem v skupni rabi, ki se samodejno prilagaja, ko se datoteke dodajajo in brišejo. Poleg tega je Amazon EFS sposoben dvigniti višjo prepustnost, ko je to potrebno, kar je ključnega pomena v našem sistemu za usposabljanje podatkov in modelov.

Nato preučimo porazdeljene strategije usposabljanja za spopadanje s temi izzivi.

Porazdeljeno usposabljanje

V tem projektu smo se soočili z dvema izzivoma: skaliranjem velikosti modela in količine podatkov. Povečanje velikosti modela in števila parametrov, ki jih je mogoče učiti, lahko povzroči boljšo natančnost, vendar obstaja omejitev modela, ki ga lahko vstavite v en pomnilnik GPE ali celo v več GPE v enem primeru. Poleg tega večje velikosti modelov zahtevajo več časa za treniranje.

Teh izzivov se lahko lotite na dva različna načina: vzporednost podatkov in vzporednost modelov. S paralelizmom podatkov izvajamo stohastični gradientni spust (SGD) z distribucijo zapisov mini serije po različnih napravah, da pospešimo usposabljanje. Vendar vzporedno usposabljanje podatkov vključuje dodatno zapletenost računanja minipaketnega gradientnega povprečja z gradienti iz vseh naprav, korak, imenovan AllReduce, ki postane težje, ko se grozd za usposabljanje poveča. Pri uporabi podatkovne paralelnosti moramo biti sposobni prilagoditi model in eno podatkovno točko v napravi (CPE ali GPE), kar je omejevalni dejavnik v naših poskusih, ker je velikost tako velikega modela veliko večja od pomnilnika posamezne GPE. velikost.

Druga rešitev je uporaba paralelizma modela, ki razdeli model na več naprav. Paralelizem modela je postopek razdelitve modela med več naprav ali vozlišč (kot so primerki, opremljeni z grafično procesorsko enoto) in ustvarjanje učinkovitega cevovoda za usposabljanje modela v teh napravah za čim večjo uporabo grafične procesorske enote.

Paralelizacija podatkov

Vzporedno zbiranje podatkov je najpogostejši pristop k več grafičnih procesorjem ali porazdeljenemu usposabljanju. Svoje podatke lahko združite v pakete, jih pošljete v več naprav (vsaka gosti podvojen model), nato pa združite rezultate. Eksperimentirali smo z dvema paketoma za paralelizacijo podatkov: Horovod in the Porazdeljena podatkovna vzporedna knjižnica SageMaker.

Horovod je distribuirano ogrodje za usposabljanje za globoko učenje za TensorFlow, Keras, PyTorch in Apache MXNet. Za uporabo Horovoda smo šli skozi naslednji postopek:

1. Inicializirajte z zagonom hvd.init().
2. Vsako napravo povežite z enim procesom. Prvi proces ali delavec je povezan s prvo napravo, drugi proces je povezan z drugo napravo in tako naprej.
3. Prilagodite hitrost učenja glede na število naprav.
4. Zavijte optimizator hvd.DistributedOptimizer.
5. Oddaj začetna stanja spremenljivke od prvega delavca z rangom 0 vsem ostalim procesom. To je potrebno za zagotovitev dosledne inicializacije vseh delavcev, ko se usposabljanje začne z naključnimi utežmi ali se obnovi s kontrolne točke.
6. Prepričajte se, da samo naprava 0 lahko shrani kontrolne točke, da preprečite, da bi jih drugi delavci poškodovali.

Sledi scenarij usposabljanja:

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)

Vzporedna podatkovna knjižnica SageMaker nam omogoča prilagajanje našega usposabljanja s skoraj linearno učinkovitostjo in pospeši naše usposabljanje z minimalnimi spremembami kode. Knjižnica izvaja po meri AllReduce delovanje in optimizira komunikacijo med napravami s popolno uporabo omrežne infrastrukture AWS in Amazonski elastični računalniški oblak (Amazon EC2) topologija primerka. Za uporabo vzporedne podatkovne knjižnice SageMaker smo šli skozi naslednji postopek:

1. Uvozi in inicializiraj sdp.init().
2. Vsako napravo povežite z eno samo smdistributed.dataparallel postopek z local_rank. sdp.tensorflow.local_rank() nam daje lokalni rang naprav. Vodja ima rang 0, delavci pa rang 1, 2, 3 itd.
3. Prilagodite hitrost učenja glede na število naprav.
4. Ovijte tf.GradientTape z DistributedGradientTape nastopiti AllReduce.
5. Razširite začetne spremenljivke modela iz vodilnega vozlišča vsem delovnim vozliščem.
6. Prepričajte se, da samo naprava 0 lahko shrani kontrolne točke.

Paralelizacija modela

Hiperparametre lahko prilagodimo tako, da ostane model dovolj majhen za usposabljanje z uporabo enega samega GPE-ja, lahko pa uporabimo vzporednost modela, da model razdelimo med več GPU-jev v več instancah. Povečanje števila parametrov modela, ki jih je mogoče učiti, lahko povzroči boljšo natančnost, vendar obstaja omejitev največje velikosti modela, ki jo lahko shranite v en pomnilnik GPE. Uporabili smo porazdeljeno vzporedno knjižnico modelov SageMaker za usposabljanje naših večjih modelov. Koraki so naslednji:

1. Uvozite in inicializirajte knjižnico z smp.init().
2. Model Keras mora podedovati smp.DistributedModel namesto razreda modela Keras.
3. Kompleti drop_remainder=True v tf.Dataset.batch() metoda za zagotovitev, da je velikost serije vedno deljiva s številom mikroserij.
4. Vse naključne operacije v podatkovnem cevovodu morajo uporabljati isto seme: smp.dp_rank(), Na primer, shuffle(ds, seed=smp.dp_rank()). To zagotavlja skladnost vzorcev podatkov med napravami, ki imajo različne modelne particije.
5. Logika naprej in nazaj mora biti v stopenjski funkciji smp.step okras.
6. Izvedite naknadno obdelavo izhodov v mikroserijah z uporabo metod StepOutput, kot je npr reduce_mean. smp.step funkcija mora imeti vrnjeno vrednost, ki je odvisna od izhoda smp.DistributedModel.

Scenarij usposabljanja je naslednji:

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) 

Za podroben vodnik za omogočanje skripta za usposabljanje TensorFlow za vzporedno knjižnico distribuiranega modela SageMaker glejte Spremenite skript za usposabljanje TensorFlow. Za PyTorch glejte Spremenite skript za usposabljanje PyTorch.

Odpravljalnik napak SageMaker

V prejšnjih razdelkih smo razpravljali o tem, kako optimizirati usposabljanje z uporabo modelov in tehnik paralelizacije podatkov. z Napaka Amazon SageMaker, lahko zdaj zajamemo podatke o profiliranju uspešnosti iz naših treningov, da ugotovimo, koliko se je trening izboljšal. Razhroščevalnik privzeto zajame sistemske meritve za vsako učno opravilo SageMaker, kot so GPU, uporaba CPE, pomnilnik, omrežje in V/I v intervalu vzorčenja 500 milisekund. Do podatkov lahko dostopamo na naslednji način:

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 ponuja pripomočke za vizualizirati podatke profiliranja na različne načine. V naslednjem primeru vidimo skupno uporabo GPE in CPE ter čakalni čas V/I za opravilo usposabljanja z več GPU z uporabo Horovoda. Za ustvarjanje teh grafov zaženemo naslednjo kodo:

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 )

Izkoriščenost GPU pogosto niha med 0–100 %, dolgi V/I čakalni časi z nizko izkoriščenostjo GPE pa so pokazatelj ozkega V/I grla. Poleg tega celotna izkoriščenost procesorja nikoli ne preseže 70 %, kar pomeni, da lahko izboljšamo predprocesiranje podatkov s povečanjem števila delovnih procesov.

Učinkovitost lahko izboljšamo s prehodom s Horovoda na porazdeljeno podatkovno vzporedno knjižnico SageMaker. V naslednjih grafih lahko vidimo, da se grafični procesorji uporabljajo učinkoviteje in le za kratek čas padejo na nizko izkoriščenost.

Infrastruktura za usposabljanje

Za usposabljanje modelov smo uporabili primerke velikosti 10 ml.p3.16xlarge z učnim opravilom SageMaker. SageMaker zmanjša čas in stroške za usposabljanje in prilagajanje modelov strojnega učenja (ML) brez potrebe po upravljanju infrastrukture. S SageMakerjem lahko enostavno trenirate in prilagajate modele ML z uporabo vgrajenih orodij za upravljanje in sledenje poskusom usposabljanja, samodejno izbirate optimalne hiperparametre, odpravljate napake pri izobraževalnih opravilih in spremljate uporabo sistemskih virov, kot so GPE, CPU in pasovna širina omrežja. Podatke je gostil Amazon EFS, kar nam je omogočilo rast in krčenje, ko dodajamo in odstranjujemo datoteke brez potrebe po upravljanju ali zagotavljanju. Naši glavni cilji so bili izboljšati hitrost usposabljanja in zmanjšati stroške.

Razširljivost modela

Čeprav se ta infrastruktura uporablja predvsem za ustvarjanje jezikov, lahko z arhitekturo GPT in naborom podatkov Pile uporabite te tehnike za usposabljanje transformatorskih modelov velikega obsega, kar je uporabno na številnih področjih zunaj NLP. V samem strojnem učenju se številne naloge računalniškega vida zdaj rešujejo z arhitekturami velikih parametrov (transformatorji), kjer se je pokazalo, da prekašajo tradicionalne CNN (konvolucijska nevronska mreža) pri nalogah, kot je učenje predstavitve (glej Napredovanje najsodobnejšega računalniškega vida s samonadzorovanimi transformatorji in 10-krat učinkovitejšim usposabljanjem) in obsežno preslikavo slik v besedilo (kot npr CLIP). Modeli z velikimi parametri prav tako orjejo ledino v znanosti o življenju na področjih, kot je analiza strukture beljakovin in analiza medicinskih slikovnih podatkov.

Rešitve, ki jih podrobno opisujemo v tej objavi za porazdeljeno usposabljanje in upravljanje velikih modelov, bi morale veljati tudi za modele v kateri koli od teh domen.

Kompromisi

V raziskovalni skupnosti poteka stalna razprava o tveganjih usposabljanja obsežnih jezikovnih modelov in o tem, ali je bilo dovolj razmišljanja o možnih tveganjih, povezanih z njihovim razvojem, in o strategijah za ublažitev teh tveganj, med katerimi so nekatera finančna in okoljski stroški. Po mnenju a papirja objavljeno v ACM, je bilo ocenjeno, da usposabljanje enega samega osnovnega modela BERT (brez nastavitve hiperparametrov) na grafičnih procesorjih zahteva toliko energije kot transameriški let. Vplivi na okolje se spreminjajo z velikostjo modela in zmožnost učinkovitega natančnega prilagajanja takšnih modelov lahko znatno zmanjša emisije. AWS je pred kratkim lansiral novo Orodje za ogljični odtis strank, ki je na voljo vsem strankam AWS brezplačno, kot del Amazonovih prizadevanj za povečanje trajnosti in zmanjšanje emisij ogljika. Izvajanje aplikacij v oblaku AWS lahko potencialno zmanjša ogljični odtis (v primerjavi s podjetniškimi podatkovnimi centri, ki so bili anketirani v poročilo 2019).

zaključek

Ta objava je prikazala rešitev, ki olajša fino nastavitev jezikovnih modelov z milijardo parametrov v oblaku AWS z uporabo SageMakerja.

Za več informacij o vzporednosti modela s SageMakerjem glejte Urite 175+ milijard NLP modelov parametrov z vzporednimi dodatki modelov in Hugging Face na Amazon SageMaker in Kako je Latent Space s pomočjo knjižnice paralelnosti modela Amazon SageMaker potisnil meje velikih transformatorjev.

Če želite pomoč pri pospeševanju uporabe ML v svojih izdelkih in procesih, se obrnite na Amazon ML Solutions Lab.

O avtorjih

Sia Gholami je višji podatkovni znanstvenik v Amazon ML Solutions Lab, kjer gradi rešitve AI/ML za stranke v različnih panogah. Navdušen je nad obdelavo naravnega jezika (NLP) in globokim učenjem. Sia izven službe rada preživlja čas v naravi in ​​igra tenis.

Mehdi Noorije vodja in višji aplikativni znanstvenik v Amazon ML Solutions Lab, kjer dela s strankami v različnih panogah in jim pomaga pospešiti njihovo migracijsko pot v oblak ter rešiti njihove težave z ML z uporabo najsodobnejših rešitev in tehnologije.

Muhyun Kim je podatkovni znanstvenik v laboratoriju Amazon Machine Learning Solutions. Različne poslovne probleme stranke rešuje z uporabo strojnega učenja in poglobljenega učenja, pomaga pa jim tudi, da postanejo usposobljeni.

Danny Byrd je uporabni znanstvenik v Amazon ML Solutions Lab. V laboratoriju je strankam pomagal razviti napredne rešitve ML, v specialitetah ML od računalniškega vida do učenja s krepitvijo. Navdušen je nad potiskanjem tehnologije naprej in sproščanjem novih potencialov izdelkov AWS na tej poti.

Francisco Calderon Rodriguez je podatkovni znanstvenik v Amazon ML Solutions Lab. Kot član laboratorija ML Solutions Lab pomaga pri reševanju kritičnih poslovnih problemov za stranke AWS z uporabo globokega učenja. V prostem času Francisco rad igra glasbo in kitaro, igra nogomet s svojima hčerkama in preživlja čas s svojo družino.

Yohei Nakayama je arhitekt poglobljenega učenja v Amazon ML Solutions Lab. Sodeluje s strankami v različnih vertikalah, da bi pospešil njihovo uporabo umetne inteligence in storitev AWS Cloud za reševanje njihovih poslovnih izzivov. Zanima ga uporaba tehnologij ML/AI v vesoljski industriji.

Nathalie Rauschmayr je višja uporabna znanstvenica pri AWS, kjer strankam pomaga pri razvoju aplikacij za globoko učenje.

• Coinsmart. Najboljša evropska borza bitcoinov in kriptovalut.
• Platoblockchain. Web3 Metaverse Intelligence. Razširjeno znanje. PROST DOSTOP.
• CryptoHawk. Altcoin radar. Brezplačen preizkus.
• Vir: 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/