Creați, antrenați și implementați un model de limbaj cu un miliard de parametri pe terabytes de date cu TensorFlow și Amazon SageMaker

Dimensiunea în creștere a modelelor de limbaj a fost una dintre cele mai mari tendințe în procesarea limbajului natural (NLP) în ultimii ani. Din 2018, am asistat la dezvoltarea și implementarea fără precedent a modelelor de limbaj tot mai mari, inclusiv BERT și variantele sale, GPT-2, T-NLG și GPT-3 (175 de miliarde de parametri).

Aceste modele au depășit limitele posibilelor inovații arhitecturale. Ne confruntăm cu mai multe provocări atunci când antrenăm modele de deep learning la scară largă, în special noul val de transformatoare generative pre-antrenate. Aceste provocări includ limitări hardware și compromisuri cu calculul și eficiența. Pentru a depăși aceste provocări legate de paralelismul modelului și al datelor, AWS oferă o gamă largă de capabilități.

În acest post, prezentăm două abordări principale: paralelizarea datelor și utilizarea paralelizării modelelor Amazon SageMakerși discutați avantajele și dezavantajele lor.

Modelul

Pentru modelul de limbaj, folosim Transformers, introdus în lucrare Atenția este tot ce aveți nevoie. Transformatoarele sunt modele de învățare profundă concepute pentru a evita în mod deliberat capcanele RNN-urilor, bazându-se pe un mecanism de auto-atenție pentru a atrage dependențe globale între intrare și ieșire. Arhitectura modelului Transformer permite o paralelizare semnificativ mai bună și poate obține performanțe ridicate într-un timp de antrenament relativ scurt. Construit pe succesul Transformers, BERT, introdus în lucrare OART: Pre-instruire a transformatoarelor bidirecționale profunde pentru înțelegerea limbajului, a adăugat pre-instruire bidirecțională pentru reprezentarea limbii. Inspirat de sarcina Cloze, BERT este pre-antrenat cu modelarea limbajului mascat (MLM), în care modelul învață să recupereze cuvintele originale pentru jetoane mascate aleatoriu. Modelul BERT este, de asemenea, preantrenat pentru sarcina de predicție a următoarei propoziții (NSP) pentru a prezice dacă două propoziții sunt în ordinea corectă de citire. De la apariția sa în 2018, BERT și variațiile sale au fost utilizate pe scară largă în modelele lingvistice.

Începem prin a crea două straturi de încorporare pentru token și încorporare pozițională. Înglobările de intrare sunt suma înglobărilor de simboluri și a înglobărilor de poziție.

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

Apoi definim un bloc decodor transformator cu două substraturi: un strat de auto-atenție cu mai multe capete și o rețea de feed-forward simplă complet conectată, urmată de normalizarea stratului și abandon:

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)

În cele din urmă, creăm modelul nostru de limbaj cu stratul de încorporare precedent și blocurile transformatoare:

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

În funcție de hiperparametrii dvs., puteți scala acest model de la mii de parametri la miliarde de parametri. Principala provocare a modelelor cu miliarde de parametri este că nu puteți găzdui modelul într-o singură instanță și trebuie să distribuiți modelul pe mai multe noduri pentru instruire și inferență.

Setul de date

În experimentele noastre, am folosit Adunați setul de date. The Pile este un set de date text în limba engleză de 800 GiB conceput pentru antrenarea modelelor lingvistice la scară largă. Este creat din 22 de seturi de date diverse și de înaltă calitate, inclusiv seturi de date NLP consacrate și cele nou introduse.

Setul de date este creat dintr-o varietate de surse de date, inclusiv cărți; depozite GitHub; pagini web; jurnalele de chat; și lucrări de medicină, fizică, matematică, informatică și filozofie. Mai exact, folosește următoarele surse: 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, Wikipedia în engleză, DM Mathematics, EuroParl, corpus de e-mailuri Enron și NIH ExPorter. De asemenea, include OpenWebText2 și BookCorpus2, care sunt extensii ale setului de date original OpenWebText și, respectiv, BookCorpus. Diversitatea surselor de date poate îmbunătăți cunoștințele generale între domenii și, în consecință, poate îmbunătăți capacitățile de generalizare în aval.

Principala provocare cu acest set de date este dimensiunea; setul de date are 825 GiB de text, ceea ce se traduce în 4.2 TiB de puncte de date preprocesate și comprimate. Similar cu provocările cu care ne confruntăm cu antrenarea și găzduirea modelelor, antrenarea unui model cu acest set de date pe o singură instanță va dura mult timp și nu este practică.

Soluția noastră este să împărțim setul de date în bucăți de date de aproximativ 1 GiB, să încărcăm și să preprocesăm caracteristicile în Setul de date TensorFlow obiecte și depozitați-le în Serviciul Amazon Elastic File (Amazon EFS). Seturile de date TensorFlow oferă o conductă de date ușor de utilizat și de înaltă performanță, care se integrează bine cu modelele noastre. Amazon EFS este un serviciu ușor de utilizat care ne permite să construim un sistem de fișiere partajat care se scalează automat pe măsură ce fișierele sunt adăugate și șterse. În plus, Amazon EFS este capabil să ajungă la niveluri de debit mai ridicate atunci când este necesar, ceea ce este esențial în pipeline-ul nostru de formare a datelor și modelelor.

În continuare, analizăm strategiile de formare distribuite pentru a face față acestor provocări.

Instruire distribuită

În acest proiect, ne-am confruntat cu două provocări: scalarea dimensiunii modelului și volumul de date. Creșterea dimensiunii modelului și a numărului de parametri antrenabili poate duce la o mai bună acuratețe, dar există o limită a modelului pe care îl puteți încadra într-o singură memorie GPU sau chiar în mai multe GPU-uri într-o singură instanță. În plus, modelele de dimensiuni mai mari necesită mai mult timp pentru antrenament.

Puteți aborda aceste provocări în două moduri diferite: paralelismul datelor și paralelismul modelului. Cu paralelismul de date, efectuăm Stochastic Gradient Descent (SGD) prin distribuirea înregistrărilor unui mini-lot pe diferite dispozitive pentru a accelera antrenamentul. Cu toate acestea, antrenamentul de date în paralel vine cu o complexitate suplimentară de calcul a mediei gradientului mini-lot cu gradienți de pe toate dispozitivele, un pas numit AllReduce, care devine mai greu pe măsură ce grupul de antrenament crește. În timp ce folosim paralelismul de date, trebuie să fim capabili să potrivim modelul și un singur punct de date într-un dispozitiv (CPU sau GPU), ceea ce este un factor limitativ în experimentele noastre, deoarece dimensiunea unui model atât de mare este mult mai mare decât memoria unui singur GPU. mărimea.

O altă soluție este utilizarea paralelismului modelului, care împarte modelul pe mai multe dispozitive. Paralelismul modelului este procesul de împărțire a unui model între mai multe dispozitive sau noduri (cum ar fi instanțe echipate cu GPU) și crearea unei conducte eficiente pentru a antrena modelul pe aceste dispozitive pentru a maximiza utilizarea GPU-ului.

Paralelizarea datelor

Paralelizarea datelor este cea mai comună abordare pentru mai multe GPU-uri sau instruire distribuită. Puteți să vă grupați datele, să le trimiteți pe mai multe dispozitive (fiecare găzduiește un model replicat), apoi să agregați rezultatele. Am experimentat cu două pachete pentru paralelizarea datelor: Horovod și the SageMaker a distribuit biblioteca paralelă de date.

Horovod este un cadru distribuit de instruire pentru învățare profundă pentru TensorFlow, Keras, PyTorch și Apache MXNet. Pentru a folosi Horovod, am trecut prin următorul proces:

1. Inițializați rulând hvd.init().
2. Asociați fiecare dispozitiv cu un singur proces. Primul proces sau lucrător este asociat cu primul dispozitiv, al doilea proces este asociat cu al doilea dispozitiv și așa mai departe.
3. Ajustați rata de învățare în funcție de numărul de dispozitive.
4. Închideți optimizatorul hvd.DistributedOptimizer.
5. Difuzați stările inițiale ale variabilei de la primul lucrător cu rangul 0 la toate celelalte procese. Acest lucru este necesar pentru a asigura inițializarea consecventă a tuturor lucrătorilor atunci când antrenamentul este început cu greutăți aleatorii sau restabilit dintr-un punct de control.
6. Asigurați-vă că numai dispozitivul 0 poate salva puncte de control pentru a preveni alți lucrători să le corupă.

Următorul este scenariul de antrenament:

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)

Biblioteca paralelă de date SageMaker ne permite să ne extindem antrenamentul cu o eficiență aproape liniară, accelerându-ne antrenamentul cu modificări minime de cod. Biblioteca realizează un obicei AllReduce funcționarea și optimizează comunicarea de la dispozitiv la dispozitiv utilizând pe deplin infrastructura de rețea a AWS și Cloud Elastic de calcul Amazon (Amazon EC2) topologie de instanță. Pentru a folosi biblioteca paralelă de date SageMaker, am trecut prin următorul proces:

1. Importă și inițializează sdp.init().
2. Asociați fiecare dispozitiv cu unul singur smdistributed.dataparallel proces cu local_rank. sdp.tensorflow.local_rank() ne oferă rangul local al dispozitivelor. Liderul este de rangul 0, iar muncitorii sunt de rangul 1, 2, 3 și așa mai departe.
3. Ajustați rata de învățare în funcție de numărul de dispozitive.
4. Wrap tf.GradientTape cu DistributedGradientTape a efectua AllReduce.
5. Difuzați variabilele modelului inițial de la nodul lider către toate nodurile de lucru.
6. Asigurați-vă că numai dispozitivul 0 poate salva puncte de control.

Paralelizarea modelului

Putem ajusta hiperparametrii pentru a menține modelul suficient de mic pentru a fi antrenat folosind un singur GPU sau putem folosi paralelismul modelului pentru a împărți modelul între mai multe GPU-uri în mai multe instanțe. Creșterea numărului de parametri antrenabili ai unui model poate duce la o mai bună acuratețe, dar există o limită la dimensiunea maximă a modelului pe care o puteți încadra într-o singură memorie GPU. Am folosit biblioteca de modele paralele distribuite SageMaker pentru a antrena modelele noastre mai mari. Pașii sunt următorii:

1. Importați și inițializați biblioteca cu smp.init().
2. Modelul Keras trebuie să moștenească de la smp.DistributedModel în loc de clasa Keras Model.
3. set drop_remainder=True în tf.Dataset.batch() metodă pentru a se asigura că dimensiunea lotului este întotdeauna divizibilă cu numărul de microloturi.
4. Toate operațiunile aleatorii din conducta de date trebuie să utilizeze același seed: smp.dp_rank(), De exemplu, shuffle(ds, seed=smp.dp_rank()). Acest lucru asigură consistența eșantioanelor de date pe dispozitivele care dețin diferite partiții model.
5. Logica înainte și înapoi trebuie să fie într-o funcție de pas cu smp.step decor.
6. Efectuați postprocesare pe ieșiri în microloturi folosind metode StepOutput, cum ar fi reduce_mean. smp.step funcția trebuie să aibă o valoare returnată care depinde de rezultatul lui smp.DistributedModel.

Scriptul de antrenament este următorul:

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) 

Pentru un ghid detaliat pentru a activa scriptul de antrenament TensorFlow pentru biblioteca paralelă model distribuită SageMaker, consultați Modificați un script de antrenament TensorFlow. Pentru PyTorch, consultați Modificați un script de antrenament PyTorch.

SageMaker Debugger

În secțiunile anterioare, am discutat cum să optimizați antrenamentul folosind tehnici de paralelizare a modelului și a datelor. Cu Debugger Amazon SageMaker, acum putem captura informații de profilare a performanței din cursele noastre de antrenament pentru a determina cât de mult s-a îmbunătățit antrenamentul. În mod implicit, Debugger captează valorile de sistem pentru fiecare sarcină de antrenament SageMaker, cum ar fi GPU, utilizarea CPU, memorie, rețea și I/O la un interval de eșantionare de 500 de milisecunde. Putem accesa datele astfel:

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 oferă utilități pentru imagina datele de profilare în moduri diferite. În exemplul următor, vedem utilizarea totală a GPU și CPU, precum și timpul de așteptare I/O pentru jobul de antrenament cu mai multe GPU folosind Horovod. Pentru a genera aceste grafice, rulăm următorul cod:

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 )

Utilizarea GPU-ului fluctuează frecvent între 0-100%, iar timpii mari de așteptare I/O cu o utilizare scăzută a GPU sunt un indicator al unui blocaj I/O. În plus, utilizarea totală a CPU nu depășește niciodată 70%, ceea ce înseamnă că putem îmbunătăți preprocesarea datelor prin creșterea numărului de procese de lucru.

Putem îmbunătăți performanța trecând de la Horovod la biblioteca paralelă de date distribuită SageMaker. În graficele următoare, putem vedea că GPU-urile sunt utilizate mai eficient și scad doar la o utilizare scăzută pentru perioade scurte de timp.

Infrastructura de formare

Pentru antrenamentul modelelor, am folosit instanțe de 10 ml.p3.16xlarge folosind un job de antrenament SageMaker. SageMaker reduce timpul și costurile pentru instruirea și reglarea modelelor de învățare automată (ML) fără a fi nevoie de a gestiona infrastructura. Cu SageMaker, puteți antrena și regla cu ușurință modele ML folosind instrumente încorporate pentru a gestiona și urmări experimentele de antrenament, pentru a alege automat hiperparametrii optimi, pentru a depana lucrările de antrenament și pentru a monitoriza utilizarea resurselor sistemului, cum ar fi GPU-uri, procesoare și lățimea de bandă a rețelei. Datele au fost găzduite în Amazon EFS, ceea ce ne-a permis să creștem și să ne micșorăm pe măsură ce adăugăm și eliminăm fișiere fără a fi nevoie de gestionare sau aprovizionare. Obiectivele noastre principale au fost să îmbunătățim viteza de antrenament și să reducem costurile.

Scalabilitatea modelului

Deși această infrastructură este utilizată în principal pentru generarea de limbaje, cu arhitectura GPT și setul de date Pile, puteți utiliza aceste tehnici pentru a antrena modele de transformatoare la scară largă, ceea ce este util în multe domenii dincolo de NLP. În învățarea automată în sine, multe sarcini de viziune computerizată sunt acum rezolvate cu arhitecturi cu parametri mari (transformator), unde s-a demonstrat că depășesc CNN-urile tradiționale (Rețeaua neuronală convoluțională) în sarcini precum învățarea reprezentării (vezi Avansarea stadiului tehnicii în viziunea computerizată cu transformatoare auto-supravegheate și formare de 10 ori mai eficientă) și maparea la scară largă a imaginilor în text (cum ar fi CLIP). Modelele cu parametri mari fac, de asemenea, noi deschideri în științele vieții în domenii precum analiza structurii proteinelor și analiza datelor de imagine medicală.

Soluțiile pe care le detaliem în această postare pentru instruirea distribuită și gestionarea modelelor mari ar trebui să se aplice și modelelor din oricare dintre aceste domenii.

Compromisuri

A existat o discuție în curs de desfășurare în comunitatea de cercetare cu privire la riscurile antrenării modelelor lingvistice la scară largă și dacă s-a gândit suficient la riscurile potențiale asociate cu dezvoltarea acestora și la strategiile de atenuare a acestor riscuri, dintre care unele includ costurile de mediu. Potrivit unui hârtie publicat în ACM, s-a estimat că antrenarea unui singur model de bază BERT (fără reglarea hiperparametrului) pe GPU-uri necesită la fel de multă energie ca un zbor trans-american. Impactul asupra mediului se adaptează la dimensiunea modelului și posibilitatea de a ajusta eficient astfel de modele poate reduce emisiile în mod semnificativ. AWS a lansat recent un nou Instrument pentru amprenta de carbon a clientului, disponibil pentru toți clienții AWS fără costuri, ca parte a eforturilor Amazon de a crește durabilitatea și de a reduce emisiile de carbon. Rularea aplicațiilor pe AWS Cloud poate reduce amprenta de carbon (în comparație cu centrele de date ale întreprinderilor care au fost chestionate în un raport 2019).

Concluzie

Această postare a demonstrat o soluție care facilitează reglarea fină a modelelor de limbaj cu un miliard de parametri pe AWS Cloud folosind SageMaker.

Pentru mai multe informații despre paralelismul modelului cu SageMaker, consultați Antrenați peste 175 de miliarde de modele NLP cu parametri cu adăugiri paralele de model și Hugging Face pe Amazon SageMaker și Cum Latent Space a folosit biblioteca paralelismului modelului Amazon SageMaker pentru a împinge frontierele transformatoarelor la scară largă.

Dacă doriți ajutor pentru accelerarea utilizării ML în produsele și procesele dvs., vă rugăm să contactați Laboratorul Amazon ML Solutions.

Despre Autori

Sia Gholami este Senior Data Scientist la Amazon ML Solutions Lab, unde creează soluții AI/ML pentru clienți din diverse industrii. Este pasionat de procesarea limbajului natural (NLP) și de învățare profundă. În afara serviciului, Siei îi place să petreacă timpul în natură și să joace tenis.

Mehdi Noorieste manager și om de știință senior aplicat la Amazon ML Solutions Lab, unde lucrează cu clienți din diverse industrii și îi ajută să-și accelereze călătoria de migrare în cloud și să-și rezolve problemele ML folosind soluții de ultimă generație și tehnologii.

Muhyun Kim este cercetător de date la Amazon Machine Learning Solutions Lab. El rezolvă diferitele probleme de afaceri ale clienților prin aplicarea învățării automate și a învățării profunde și, de asemenea, îi ajută să devină calificați.

Danny Byrd este un om de știință aplicat la Amazon ML Solutions Lab. În laborator, el a ajutat clienții să dezvolte soluții avansate de ML, în specialități ML, de la viziune pe computer la învățare prin consolidare. Este pasionat de a promova tehnologia și de a debloca noul potențial de la produsele AWS pe parcurs.

Francisco Calderon Rodriguez este Data Scientist în Amazon ML Solutions Lab. În calitate de membru al Laboratorului de soluții ML, el ajută la rezolvarea problemelor critice de afaceri pentru clienții AWS folosind deep learning. În timpul liber, lui Francisco îi place să cânte muzică și chitară, să joace fotbal cu fiicele sale și să se bucure de timpul cu familia.

Yohei Nakayama este arhitect Deep Learning la Amazon ML Solutions Lab. El lucrează cu clienți din diferite verticale pentru a-și accelera utilizarea inteligenței artificiale și a serviciilor AWS Cloud pentru a-și rezolva provocările de afaceri. El este interesat de aplicarea tehnologiilor ML/AI în industria spațială.

Nathalie Rauschmayr este cercetător senior aplicat la AWS, unde îi ajută pe clienți să dezvolte aplicații de deep learning.

• Coinsmart. Cel mai bun schimb de Bitcoin și Crypto din Europa.
• Platoblockchain. Web3 Metaverse Intelligence. Cunoștințe amplificate. ACCES LIBER.
• CryptoHawk. Radar Altcoin. Încercare gratuită.
• Sursa: 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/