Crea, addestra e distribuisci un modello linguistico di miliardi di parametri su terabyte di dati con TensorFlow e Amazon SageMaker

Ripubblicato da Platone

Seguaci: 0

La dimensione crescente dei modelli linguistici è stata una delle maggiori tendenze nell'elaborazione del linguaggio naturale (PNL) negli ultimi anni. Dal 2018 abbiamo assistito allo sviluppo e all'implementazione senza precedenti di modelli linguistici sempre più grandi, inclusi BERT e le sue varianti, GPT-2, T-NLG e GPT-3 (175 miliardi di parametri).

Questi modelli hanno spinto i confini delle possibili innovazioni architettoniche. Affrontiamo diverse sfide durante l'addestramento di modelli di deep learning su larga scala, in particolare la nuova ondata di trasformatori generativi pre-addestrati. Queste sfide includono limitazioni hardware e compromessi con calcolo ed efficienza. Per superare queste sfide di parallelismo di modelli e dati, AWS offre un'ampia gamma di funzionalità.

In questo post, introduciamo due approcci principali: la parallelizzazione dei dati e l'utilizzo della parallelizzazione del modello Amazon Sage Maker, e discutere i loro pro e contro.

Il modello

Per il modello linguistico, utilizziamo Transformers, introdotto nel documento L'attenzione è tutto ciò che serve. I trasformatori sono modelli di deep learning progettati per evitare deliberatamente le insidie degli RNN facendo affidamento su un meccanismo di auto-attenzione per disegnare dipendenze globali tra input e output. L'architettura del modello Transformer consente una parallelizzazione significativamente migliore e può ottenere prestazioni elevate in tempi di addestramento relativamente brevi. Basato sul successo di Transformers, BERT, introdotto nel giornale BERT: Pre-training di trasformatori bidirezionali profondi per la comprensione del linguaggio, aggiunta di pre-formazione bidirezionale per la rappresentazione linguistica. Ispirato dall'attività Cloze, BERT è stato pre-addestrato con la modellazione del linguaggio mascherato (MLM), in cui il modello impara a recuperare le parole originali per token mascherati casualmente. Il modello BERT è anche preaddestrato sul compito di previsione della frase successiva (NSP) per prevedere se due frasi sono nell'ordine di lettura corretto. Dal suo avvento nel 2018, BERT e le sue variazioni sono state ampiamente utilizzate nei modelli linguistici.

Iniziamo creando due livelli di incorporamento per il token e l'incorporamento posizionale. Gli incorporamenti di input sono la somma degli incorporamenti di token e degli incorporamenti di posizione.

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

Quindi definiamo un blocco di decodifica del trasformatore con due sottolivelli: un livello di auto-attenzione multi-testa e una semplice rete feed-forward completamente connessa seguita da normalizzazione e dropout del livello:

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)

Infine, creiamo il nostro modello di linguaggio con il livello di incorporamento precedente e i blocchi trasformatore:

class MyModel(tf.keras.Model): def __init__(self, maxlen, vocab_size, embed_dim, num_heads, feed_forward_dim, num_layers, learning_rate): super(MyModel, self).__init__(maxlen, vocab_size, embed_dim, num_heads, feed_forward_dim, num_layers, learning_rate) # embedding layer self.embedding_layer = TokenAndPositionEmbedding(maxlen, vocab_size, embed_dim) # transformer blocks self.transformer_blocks = [ TransformerBlock(embed_dim, num_heads, feed_forward_dim) for i in range(num_layers) ] # last dense layer self.dense = tf.keras.layers.Dense(vocab_size) def call(self, inputs, training=None): x_emb = self.embedding_layer(inputs) x = x_emb for transformer_block in self.transformer_blocks: x = transformer_block(x) outputs = self.dense(x) return [outputs, x_emb] def init_train_settings(maxlen, vocab_size, embed_dim, num_heads, feed_forward_dim, num_layers, learning_rate): """ Creates model, optimizer and loss function """ model = MyModel(maxlen, vocab_size, embed_dim, num_heads, feed_forward_dim, num_layers, learning_rate) loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate) return model, optimizer, loss_fn

A seconda dei tuoi iperparametri, puoi ridimensionare questo modello da migliaia di parametri a miliardi di parametri. La sfida principale con i modelli a miliardi di parametri è che non puoi ospitare il modello in un'istanza e devi distribuire il modello su più nodi per l'addestramento e l'inferenza.

Il set di dati

Nei nostri esperimenti, abbiamo utilizzato il Insieme di dati della pila. The Pile è un set di dati di testo in inglese da 800 GiB progettato per l'addestramento di modelli linguistici su larga scala. Viene creato da 22 set di dati diversi e di alta qualità, inclusi set di dati NLP consolidati e nuovi introdotti.

Il set di dati viene creato da una varietà di origini dati, inclusi i libri; repository GitHub; pagine web; registri delle chat; e articoli di medicina, fisica, matematica, informatica e filosofia. In particolare, utilizza le seguenti fonti: 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 in inglese, DM Mathematics, EuroParl, Enron Emails corpus e NIH ExPorter. Include anche OpenWebText2 e BookCorpus2, che sono rispettivamente estensioni dei dataset originali OpenWebText e BookCorpus. La diversità delle fonti di dati può migliorare le conoscenze generali tra domini e di conseguenza migliorare le capacità di generalizzazione a valle.

La sfida principale con questo set di dati è l'enorme dimensione; il set di dati ha 825 GiB di testo, che si traducono in 4.2 TiB di punti dati preelaborati e compressi. Analogamente alle sfide che dobbiamo affrontare con il training e l'hosting dei modelli, il training di un modello con questo set di dati su una singola istanza richiederà molto tempo e non è pratico.

La nostra soluzione è suddividere il set di dati in blocchi di dati da circa 1 GiB, caricare e preelaborare le funzionalità Set di dati TensorFlow oggetti e conservarli Servizio file elastico Amazon (Amazon EFS). I set di dati TensorFlow forniscono una pipeline di dati facile da usare e ad alte prestazioni che si integra bene con i nostri modelli. Amazon EFS è un servizio facile da usare che ci consente di creare un file system condiviso che si ridimensiona automaticamente man mano che i file vengono aggiunti ed eliminati. Inoltre, Amazon EFS è in grado di raggiungere livelli di throughput più elevati quando necessario, il che è fondamentale nella nostra pipeline di formazione di dati e modelli.

Successivamente, esaminiamo strategie di formazione distribuita per affrontare queste sfide.

Formazione distribuita

In questo progetto, abbiamo affrontato due sfide: ridimensionare le dimensioni del modello e il volume dei dati. L'aumento delle dimensioni del modello e del numero di parametri addestrabili può comportare una migliore precisione, ma esiste un limite al modello che puoi inserire in una singola memoria GPU o anche in più GPU in una singola istanza. Inoltre, i modelli di taglie più grandi richiedono più tempo per l'allenamento.

Puoi affrontare queste sfide in due modi diversi: parallelismo dei dati e parallelismo del modello. Con il parallelismo dei dati, eseguiamo la Stochastic Gradient Descent (SGD) distribuendo i record di un mini-batch su diversi dispositivi per velocizzare l'allenamento. Tuttavia, l'addestramento dei dati in parallelo comporta una maggiore complessità di calcolo della media del gradiente mini-batch con i gradienti di tutti i dispositivi, un passaggio chiamato AllReduce, che diventa più difficile man mano che il gruppo di formazione cresce. Utilizzando il parallelismo dei dati, dobbiamo essere in grado di adattare il modello e un singolo datapoint in un dispositivo (CPU o GPU), che è un fattore limitante nei nostri esperimenti perché la dimensione di un modello così grande è molto più grande della memoria della singola GPU taglia.

Un'altra soluzione consiste nell'usare il parallelismo del modello, che divide il modello su più dispositivi. Il parallelismo del modello è il processo di suddivisione di un modello tra più dispositivi o nodi (come istanze dotate di GPU) e la creazione di una pipeline efficiente per addestrare il modello su questi dispositivi per massimizzare l'utilizzo della GPU.

Parallelizzazione dei dati

La parallelizzazione dei dati è l'approccio più comune a più GPU o formazione distribuita. Puoi raggruppare i tuoi dati, inviarli a più dispositivi (ciascuno ospita un modello replicato), quindi aggregare i risultati. Abbiamo sperimentato due pacchetti per la parallelizzazione dei dati: Horovod e the Libreria parallela di dati distribuita SageMaker.

Horovod è un framework di formazione di deep learning distribuito per TensorFlow, Keras, PyTorch e Apache MXNet. Per utilizzare Horovod, abbiamo seguito il seguente processo:

Inizializza eseguendo hvd.init().
Associa ogni dispositivo a un singolo processo. Il primo processo o lavoratore è associato al primo dispositivo, il secondo processo è associato al secondo dispositivo e così via.
Regola la velocità di apprendimento in base al numero di dispositivi.
Avvolgi l'ottimizzatore hvd.DistributedOptimizer.
Trasmetti gli stati della variabile iniziale dal primo lavoratore con rango 0 a tutti gli altri processi. Ciò è necessario per garantire un'inizializzazione coerente di tutti i lavoratori quando la formazione viene avviata con pesi casuali o ripristinata da un checkpoint.
Assicurati che solo il dispositivo 0 possa salvare i checkpoint per impedire ad altri lavoratori di danneggiarli.

Quello che segue è lo script di formazione:

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)

La libreria di dati paralleli di SageMaker ci consente di scalare la nostra formazione con un'efficienza quasi lineare, accelerando la nostra formazione con modifiche minime al codice. La libreria esegue una personalizzazione AllReduce funzionamento e ottimizza la comunicazione da dispositivo a dispositivo utilizzando completamente l'infrastruttura di rete di AWS e Cloud di calcolo elastico di Amazon Topologia dell'istanza (Amazon EC2). Per utilizzare la libreria di dati SageMaker parallela, abbiamo eseguito il seguente processo:

Importa e inizializza sdp.init().
Associa ogni dispositivo ad un singolo smdistributed.dataparallel elaborare con local_rank. sdp.tensorflow.local_rank() ci fornisce il rango locale dei dispositivi. Il leader è di rango 0 e i lavoratori sono di rango 1, 2, 3 e così via.
Regola la velocità di apprendimento in base al numero di dispositivi.
Avvolgere tf.GradientTape con DistributedGradientTape per eseguire AllReduce.
Trasmetti le variabili del modello iniziale dal nodo leader a tutti i nodi di lavoro.
Assicurati che solo il dispositivo 0 possa salvare i checkpoint.

Parallelizzazione del modello

Possiamo regolare gli iperparametri per mantenere il modello sufficientemente piccolo da poter essere addestrato utilizzando una singola GPU, oppure possiamo usare il parallelismo del modello per dividere il modello tra più GPU su più istanze. L'aumento del numero di parametri addestrabili di un modello può comportare una migliore precisione, ma esiste un limite alla dimensione massima del modello che puoi inserire in una singola memoria GPU. Abbiamo utilizzato la libreria parallela del modello distribuito SageMaker per addestrare i nostri modelli più grandi. I passi sono come segue:

Importa e inizializza la libreria con smp.init().
Il modello Keras deve ereditare da smp.DistributedModel invece della classe Keras Model.
Impostato drop_remainder=True nel tf.Dataset.batch() metodo per garantire che la dimensione del batch sia sempre divisibile per il numero di microbatch.
Tutte le operazioni casuali nella pipeline di dati devono utilizzare lo stesso seme: smp.dp_rank(), Per esempio, shuffle(ds, seed=smp.dp_rank()). Ciò garantisce la coerenza dei campioni di dati tra i dispositivi che contengono partizioni di modelli differenti.
La logica avanti e indietro deve essere in una funzione di passo con smp.step decorazione.
Eseguire la postelaborazione sugli output attraverso i microbatch utilizzando metodi StepOutput come reduce_mean. smp.step la funzione deve avere un valore di ritorno che dipende dall'output di smp.DistributedModel.

Lo script di formazione è il seguente:

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)

Per una guida dettagliata per abilitare lo script di addestramento TensorFlow per la libreria parallela del modello distribuito SageMaker, fare riferimento a Modifica uno script di addestramento TensorFlow. Per PyTorch, fare riferimento a Modifica uno script di addestramento PyTorch.

Debugger di SageMaker

Nelle sezioni precedenti, abbiamo discusso come ottimizzare l'addestramento utilizzando tecniche di parallelizzazione del modello e dei dati. Insieme a Debugger di Amazon SageMaker, ora possiamo acquisire informazioni sulla profilazione delle prestazioni dalle nostre sessioni di formazione per determinare quanto è migliorata la formazione. Per impostazione predefinita, Debugger acquisisce le metriche di sistema per ogni processo di addestramento SageMaker come GPU, utilizzo della CPU, memoria, rete e I/O a un intervallo di campionamento di 500 millisecondi. Possiamo accedere ai dati come segue:

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

Il debugger fornisce utilità a visualizzare i dati di profilazione in diversi modi. Nell'esempio seguente, vediamo l'utilizzo totale di GPU e CPU, nonché il tempo di attesa I/O per il processo di addestramento multi-GPU utilizzando Horovod. Per generare questi grafici, eseguiamo il seguente codice:

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 )

L'utilizzo della GPU oscilla spesso tra lo 0 e il 100% e tempi di attesa I/O elevati con un utilizzo ridotto della GPU sono un indicatore di un collo di bottiglia I/O. Inoltre, l'utilizzo totale della CPU non supera mai il 70%, il che significa che possiamo migliorare la preelaborazione dei dati aumentando il numero di processi di lavoro.

Possiamo migliorare le prestazioni passando da Horovod alla libreria parallela di dati distribuiti SageMaker. Nei grafici seguenti, possiamo vedere che le GPU vengono utilizzate in modo più efficiente e scendono a un utilizzo basso solo per brevi periodi di tempo.

Infrastrutture di formazione

Per addestrare i modelli, abbiamo utilizzato istanze 10 ml.p3.16xlarge utilizzando un processo di formazione SageMaker. SageMaker riduce i tempi e i costi per addestrare e ottimizzare i modelli di machine learning (ML) senza la necessità di gestire l'infrastruttura. Con SageMaker, puoi facilmente addestrare e ottimizzare i modelli ML utilizzando strumenti integrati per gestire e tenere traccia degli esperimenti di addestramento, scegliere automaticamente gli iperparametri ottimali, eseguire il debug dei processi di addestramento e monitorare l'utilizzo delle risorse di sistema come GPU, CPU e larghezza di banda di rete. I dati sono stati ospitati in Amazon EFS, che ci ha consentito di crescere e ridursi man mano che aggiungiamo e rimuoviamo file senza necessità di gestione o provisioning. I nostri obiettivi primari erano migliorare la velocità di formazione e ridurre i costi.

Scalabilità del modello

Sebbene questa infrastruttura sia utilizzata principalmente per la generazione del linguaggio, con l'architettura GPT e il set di dati Pile, è possibile utilizzare queste tecniche per addestrare modelli di trasformatori su larga scala, utili in molti domini oltre alla NLP. Nello stesso apprendimento automatico, molte attività di visione artificiale sono ora risolte con architetture di grandi parametri (trasformatore) in cui è stato dimostrato che superano le tradizionali CNN (Convolutional Neural Network) su attività come l'apprendimento della rappresentazione (vedi Avanzare lo stato dell'arte nella visione artificiale con trasformatori auto-supervisionati e una formazione 10 volte più efficiente) e mappatura su larga scala di immagini su testo (come CLIP). I modelli di grandi parametri stanno anche aprendo nuovi orizzonti nelle scienze della vita in campi come analisi della struttura proteica ed analisi di dati di immagini mediche.

Le soluzioni descritte in dettaglio in questo post per la formazione distribuita e la gestione di modelli di grandi dimensioni dovrebbero applicarsi anche ai modelli in uno qualsiasi di questi domini.

Trade-off

C'è stata una discussione in corso nella comunità di ricerca in merito ai rischi della formazione di modelli linguistici su larga scala e se è stata pensata abbastanza sui potenziali rischi associati allo sviluppo di essi e sulle strategie per mitigare questi rischi, alcuni dei quali includono gli aspetti finanziari e costi ambientali. Secondo a carta pubblicato su ACM, si stima che l'addestramento di un singolo modello base BERT (senza messa a punto degli iperparametri) su GPU richieda la stessa energia di un volo transamericano. Gli impatti ambientali scalano con le dimensioni del modello e la possibilità di mettere a punto in modo efficiente tali modelli può potenzialmente ridurre significativamente le emissioni. AWS ha recentemente lanciato un nuovo Strumento per l'impronta di carbonio del cliente, disponibile gratuitamente per tutti i clienti AWS, nell'ambito degli sforzi di Amazon per aumentare la sostenibilità e ridurre le emissioni di carbonio. L'esecuzione di applicazioni su AWS Cloud può potenzialmente ridurre l'impronta di carbonio (rispetto ai data center aziendali in cui sono stati intervistati un rapporto 2019).

Conclusione

Questo post ha dimostrato una soluzione che facilita la messa a punto di modelli linguistici con un miliardo di parametri su AWS Cloud utilizzando SageMaker.

Per ulteriori informazioni sul parallelismo del modello con SageMaker, fare riferimento a Addestra oltre 175 miliardi di modelli NLP di parametri con aggiunte di modelli paralleli e Hugging Face su Amazon SageMaker ed In che modo Latent Space ha utilizzato la libreria di parallelismo dei modelli di Amazon SageMaker per spingere le frontiere dei trasformatori su larga scala.

Se desideri aiuto per accelerare l'utilizzo del machine learning nei tuoi prodotti e processi, contatta il Laboratorio di soluzioni Amazon ML.

Informazioni sugli autori

Sia Golami è Senior Data Scientist presso l'Amazon ML Solutions Lab, dove crea soluzioni AI/ML per clienti di vari settori. È appassionato di elaborazione del linguaggio naturale (PNL) e deep learning. Al di fuori del lavoro, Sia ama trascorrere il tempo nella natura e giocare a tennis.

Crea, addestra e distribuisci un modello linguistico da miliardi di parametri su terabyte di dati con TensorFlow e Amazon SageMaker PlatoBlockchain Data Intelligence. Ricerca verticale. Ai. Mahdi Nooriè Manager e Senior Applied Scientist presso l'Amazon ML Solutions Lab, dove lavora con clienti in vari settori e li aiuta ad accelerare il loro percorso di migrazione al cloud e a risolvere i loro problemi di ML utilizzando soluzioni all'avanguardia e tecnologie.

Crea, addestra e distribuisci un modello linguistico da miliardi di parametri su terabyte di dati con TensorFlow e Amazon SageMaker PlatoBlockchain Data Intelligence. Ricerca verticale. Ai. Muhyun Kim è un data scientist presso Amazon Machine Learning Solutions Lab. Risolve i vari problemi aziendali dei clienti applicando l'apprendimento automatico e l'apprendimento profondo e li aiuta anche a diventare esperti.

Danny Byrd è uno scienziato applicato presso l'Amazon ML Solutions Lab. In laboratorio ha aiutato i clienti a sviluppare soluzioni ML avanzate, nelle specialità ML dalla visione artificiale all'apprendimento per rinforzo. È appassionato di portare avanti la tecnologia e sbloccare nuovo potenziale dai prodotti AWS lungo il percorso.

Francisco Calderón Rodriguez è un Data Scientist nell'Amazon ML Solutions Lab. In qualità di membro del ML Solutions Lab, aiuta a risolvere problemi aziendali critici per i clienti AWS utilizzando il deep learning. Nel tempo libero, a Francisco piace suonare musica e chitarra, giocare a calcio con le sue figlie e godersi il tempo con la sua famiglia.

Yohei Nakayama è un Deep Learning Architect presso Amazon ML Solutions Lab. Collabora con clienti di diversi verticali per accelerare il loro utilizzo dell'intelligenza artificiale e dei servizi cloud AWS per risolvere le loro sfide aziendali. È interessato all'applicazione delle tecnologie ML/AI all'industria spaziale.