Crie, treine e implante um modelo de linguagem de bilhões de parâmetros em terabytes de dados com o TensorFlow e o Amazon SageMaker

O tamanho crescente dos modelos de linguagem tem sido uma das maiores tendências no processamento de linguagem natural (PLN) nos últimos anos. Desde 2018, vimos o desenvolvimento e a implantação sem precedentes de modelos de linguagem cada vez maiores, incluindo BERT e suas variantes, GPT-2, T-NLG e GPT-3 (175 bilhões de parâmetros).

Esses modelos ultrapassaram os limites de possíveis inovações arquitetônicas. Enfrentamos vários desafios ao treinar modelos de aprendizagem profunda em larga escala, especialmente a nova onda de transformadores generativos pré-treinados. Esses desafios incluem limitações de hardware e compensações com computação e eficiência. Para superar esses desafios de paralelismo de modelos e dados, a AWS oferece uma ampla variedade de recursos.

Neste post, apresentamos duas abordagens principais: paralelização de dados e paralelização de modelos usando Amazon Sage Maker, e discutir seus prós e contras.

O modelo

Para o modelo de linguagem, usamos Transformers, introduzidos no artigo Atenção É Tudo Que Você Precisa. Os transformadores são modelos de aprendizado profundo projetados para evitar deliberadamente as armadilhas das RNNs, contando com um mecanismo de autoatenção para desenhar dependências globais entre entrada e saída. A arquitetura do modelo Transformer permite uma paralelização significativamente melhor e pode alcançar alto desempenho em um tempo de treinamento relativamente curto. Baseado no sucesso de Transformers, o BERT, lançado no jornal BERT: Pré-treinamento de transformadores bidirecionais profundos para compreensão de idiomas, adicionado pré-treinamento bidirecional para representação de idioma. Inspirado na tarefa Cloze, o BERT é pré-treinado com modelagem de linguagem mascarada (MLM), na qual o modelo aprende a recuperar as palavras originais para tokens mascarados aleatoriamente. O modelo BERT também é pré-treinado na tarefa de previsão da próxima sentença (NSP) para prever se duas sentenças estão na ordem correta de leitura. Desde seu advento em 2018, o BERT e suas variações têm sido amplamente utilizados em modelos de linguagem.

Começamos criando duas camadas de incorporação para incorporação de token e posicional. Os embeddings de entrada são a soma dos embeddings de token e embeddings de posição.

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

Em seguida, definimos um bloco decodificador de transformador com duas subcamadas: uma camada de autoatenção de várias cabeças e uma rede feed-forward simples totalmente conectada seguida de normalização e dropout de camada:

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)

Por fim, criamos nosso modelo de linguagem com a camada de incorporação e os blocos transformadores anteriores:

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

Dependendo de seus hiperparâmetros, você pode dimensionar esse modelo de milhares de parâmetros para bilhões de parâmetros. O principal desafio com modelos de bilhões de parâmetros é que você não pode hospedar o modelo em uma instância e precisa distribuir o modelo por vários nós para treinamento e inferência.

O conjunto de dados

Em nossos experimentos, usamos o Empilhar conjunto de dados. O Pile é um conjunto de dados de texto em inglês de 800 GiB projetado para treinar modelos de linguagem em larga escala. Ele é criado a partir de 22 conjuntos de dados diversos e de alta qualidade, incluindo conjuntos de dados de PNL estabelecidos e recém-introduzidos.

O conjunto de dados é criado a partir de uma variedade de fontes de dados, incluindo livros; repositórios GitHub; paginas web; registros de bate-papo; e artigos de medicina, física, matemática, ciência da computação e filosofia. Especificamente, ele usa as seguintes fontes: 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 em inglês, DM Mathematics, EuroParl, o corpus Enron Emails e NIH ExPorter. Também inclui OpenWebText2 e BookCorpus2, que são extensões dos conjuntos de dados originais OpenWebText e BookCorpus, respectivamente. A diversidade nas fontes de dados pode melhorar o conhecimento geral entre domínios e, consequentemente, melhorar os recursos de generalização downstream.

O principal desafio com esse conjunto de dados é o tamanho; o conjunto de dados tem 825 GiB de texto, que se traduz em 4.2 TiB de pontos de dados pré-processados ​​e compactados. Semelhante aos desafios que enfrentamos ao treinar e hospedar os modelos, treinar um modelo com esse conjunto de dados em uma única instância levará muito tempo e não é prático.

Nossa solução é dividir o conjunto de dados em blocos de dados de aproximadamente 1 GiB, carregar e pré-processar os recursos em Conjunto de dados do TensorFlow objetos e armazená-los em Serviço de arquivo elástico da Amazon (Amazônia EFS). Os conjuntos de dados do TensorFlow fornecem um pipeline de dados fácil de usar e de alto desempenho que se integra bem aos nossos modelos. O Amazon EFS é um serviço fácil de usar que nos permite criar um sistema de arquivos compartilhado que é dimensionado automaticamente à medida que os arquivos são adicionados e excluídos. Além disso, o Amazon EFS é capaz de atingir níveis de taxa de transferência mais altos quando necessário, o que é fundamental em nosso pipeline de treinamento de dados e modelos.

Em seguida, analisamos as estratégias de treinamento distribuído para enfrentar esses desafios.

Treinamento distribuído

Neste projeto, enfrentamos dois desafios: dimensionar o tamanho do modelo e o volume de dados. Aumentar o tamanho do modelo e o número de parâmetros treináveis ​​pode resultar em melhor precisão, mas há um limite para o modelo que você pode ajustar em uma única memória de GPU ou até mesmo em várias GPUs em uma única instância. Além disso, tamanhos de modelo maiores levam mais tempo para treinar.

Você pode enfrentar esses desafios de duas maneiras diferentes: paralelismo de dados e paralelismo de modelo. Com o paralelismo de dados, realizamos o Stochastic Gradient Descent (SGD) distribuindo os registros de um mini-lote por diferentes dispositivos para acelerar o treinamento. No entanto, o treinamento de dados paralelos vem com complexidade extra de computação média de gradiente de mini-lote com gradientes de todos os dispositivos, uma etapa chamada AllReduce, o que se torna mais difícil à medida que o cluster de treinamento cresce. Ao usar o paralelismo de dados, devemos ser capazes de ajustar o modelo e um único ponto de dados em um dispositivo (CPU ou GPU), o que é um fator limitante em nossos experimentos porque o tamanho de um modelo tão grande é muito maior que a memória da GPU única Tamanho.

Outra solução é usar o paralelismo de modelo, que divide o modelo em vários dispositivos. O paralelismo de modelo é o processo de dividir um modelo entre vários dispositivos ou nós (como instâncias equipadas com GPU) e criar um pipeline eficiente para treinar o modelo nesses dispositivos para maximizar a utilização da GPU.

Paralelização de dados

Paralelizar os dados é a abordagem mais comum para várias GPUs ou treinamento distribuído. Você pode agrupar seus dados, enviá-los para vários dispositivos (cada um hospedando um modelo replicado) e agregar os resultados. Experimentamos dois pacotes para paralelização de dados: Horovod e o Biblioteca paralela de dados distribuídos SageMaker.

Horovod é uma estrutura de treinamento de aprendizado profundo distribuído para TensorFlow, Keras, PyTorch e Apache MXNet. Para usar o Horovod, passamos pelo seguinte processo:

1. Inicialize executando hvd.init().
2. Associe cada dispositivo a um único processo. O primeiro processo ou trabalhador está associado ao primeiro dispositivo, o segundo processo está associado ao segundo dispositivo e assim por diante.
3. Ajuste a taxa de aprendizado com base no número de dispositivos.
4. Envolva o otimizador em hvd.DistributedOptimizer.
5. Transmita os estados das variáveis ​​iniciais do primeiro trabalhador com classificação 0 para todos os outros processos. Isso é necessário para garantir a inicialização consistente de todos os trabalhadores quando o treinamento é iniciado com pesos aleatórios ou restaurado a partir de um ponto de verificação.
6. Certifique-se de que apenas o dispositivo 0 possa salvar pontos de verificação para evitar que outros trabalhadores os corrompam.

Segue o roteiro de treinamento:

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)

A biblioteca paralela de dados do SageMaker nos permite dimensionar nosso treinamento com eficiência quase linear, acelerando nosso treinamento com alterações mínimas de código. A biblioteca realiza uma AllReduce operação e otimiza a comunicação dispositivo a dispositivo utilizando totalmente a infraestrutura de rede da AWS e Amazon Elastic Compute Nuvem (Amazon EC2) topologia de instância. Para usar a biblioteca paralela de dados do SageMaker, passamos pelo seguinte processo:

1. Importar e inicializar sdp.init().
2. Associe cada dispositivo a um único smdistributed.dataparallel processo com local_rank. sdp.tensorflow.local_rank() nos dá a classificação local dos dispositivos. O líder é o posto 0 e os trabalhadores são os postos 1, 2, 3 e assim por diante.
3. Ajuste a taxa de aprendizado com base no número de dispositivos.
4. Embrulhe tf.GradientTape de DistributedGradientTape para executar AllReduce.
5. Transmita as variáveis ​​do modelo inicial do nó líder para todos os nós do trabalhador.
6. Certifique-se de que apenas o dispositivo 0 possa salvar pontos de verificação.

Paralelização do modelo

Podemos ajustar os hiperparâmetros para manter o modelo pequeno o suficiente para treinar usando uma única GPU ou podemos usar o paralelismo de modelo para dividir o modelo entre várias GPUs em várias instâncias. Aumentar o número de parâmetros treináveis ​​de um modelo pode resultar em melhor precisão, mas há um limite para o tamanho máximo do modelo que você pode ajustar em uma única memória de GPU. Usamos a biblioteca paralela de modelos distribuídos SageMaker para treinar nossos modelos maiores. Os passos são os seguintes:

1. Importe e inicialize a biblioteca com smp.init().
2. O modelo Keras precisa herdar de smp.DistributedModel em vez da classe Keras Model.
3. Conjunto drop_remainder=True no tf.Dataset.batch() método para garantir que o tamanho do lote seja sempre divisível pelo número de microlotes.
4. Todas as operações aleatórias no pipeline de dados precisam usar a mesma semente: smp.dp_rank(), Por exemplo, shuffle(ds, seed=smp.dp_rank()). Isso garante a consistência de amostras de dados em dispositivos que mantêm partições de modelo diferentes.
5. A lógica para frente e para trás precisa estar em uma função de etapa com smp.step decoração.
6. Execute o pós-processamento nas saídas em microlotes usando métodos StepOutput, como reduce_mean. O smp.step função deve ter um valor de retorno que depende da saída de smp.DistributedModel.

O roteiro de treinamento é o seguinte:

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) 

Para obter um guia detalhado para habilitar o script de treinamento do TensorFlow para a biblioteca paralela de modelo distribuído SageMaker, consulte Modificar um script de treinamento do TensorFlow. Para PyTorch, consulte Modificar um script de treinamento do PyTorch.

Depurador SageMaker

Nas seções anteriores, discutimos como otimizar o treinamento usando técnicas de paralelização de modelos e dados. Com Depurador do Amazon SageMaker, agora podemos capturar informações de perfil de desempenho de nossas execuções de treinamento para determinar o quanto o treinamento melhorou. Por padrão, o Debugger captura as métricas do sistema para cada trabalho de treinamento do SageMaker, como GPU, utilização da CPU, memória, rede e E/S em um intervalo de amostragem de 500 milissegundos. Podemos acessar os dados da seguinte forma:

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

O depurador fornece utilitários para visualizar os dados de perfil de diferentes maneiras. No exemplo a seguir, vemos a utilização total de GPU e CPU, bem como o tempo de espera de E/S para o trabalho de treinamento multi-GPU usando Horovod. Para gerar esses gráficos, executamos o seguinte código:

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 )

A utilização da GPU frequentemente flutua entre 0–100%, e os altos tempos de espera de E/S com baixa utilização da GPU são um indicador de um gargalo de E/S. Além disso, a utilização total da CPU nunca excede 70%, o que significa que podemos melhorar o pré-processamento de dados aumentando o número de processos de trabalho.

Podemos melhorar o desempenho mudando do Horovod para a biblioteca paralela de dados distribuídos SageMaker. Nos gráficos a seguir, podemos ver que as GPUs são utilizadas de forma mais eficiente e caindo apenas para baixa utilização por curtos períodos de tempo.

Infraestrutura de treinamento

Para treinar os modelos, usamos instâncias de 10 ml.p3.16xlarge usando um trabalho de treinamento do SageMaker. O SageMaker reduz o tempo e o custo para treinar e ajustar modelos de machine learning (ML) sem a necessidade de gerenciar a infraestrutura. Com o SageMaker, você pode treinar e ajustar facilmente modelos de ML usando ferramentas integradas para gerenciar e rastrear experimentos de treinamento, escolher automaticamente os hiperparâmetros ideais, depurar trabalhos de treinamento e monitorar a utilização de recursos do sistema, como GPUs, CPUs e largura de banda de rede. Os dados foram hospedados no Amazon EFS, o que nos permitiu crescer e diminuir à medida que adicionamos e removemos arquivos sem a necessidade de gerenciamento ou provisionamento. Nossos principais objetivos eram melhorar a velocidade de treinamento e reduzir custos.

Escalabilidade do modelo

Embora essa infraestrutura seja usada principalmente para geração de linguagem, com a arquitetura GPT e o conjunto de dados Pile, você pode usar essas técnicas para treinar modelos de transformador em grande escala, o que é útil em muitos domínios além do NLP. No aprendizado de máquina em si, muitas tarefas de visão computacional agora são resolvidas com arquiteturas de grande parâmetro (transformador), onde demonstraram superar as tradicionais CNNs (Rede Neural Convolucional) em tarefas como aprendizado de representação (consulte Avançando o estado da arte em visão computacional com transformadores autossupervisionados e treinamento 10x mais eficiente) e mapeamento em grande escala de imagens para texto (como CLIP). Modelos de grandes parâmetros também estão abrindo novos caminhos nas ciências da vida em campos como análise de estrutura de proteínas e análise de dados de imagens médicas.

As soluções que detalhamos neste post para treinamento distribuído e gerenciamento de modelos grandes também devem ser aplicadas a modelos em qualquer um desses domínios.

Trocas

Tem havido uma discussão contínua na comunidade de pesquisa sobre os riscos de treinar modelos de linguagem em larga escala, e se foi pensado o suficiente sobre os riscos potenciais associados ao seu desenvolvimento e estratégias para mitigar esses riscos, alguns dos quais incluem os riscos financeiros e custos ambientais. De acordo com um papel publicado no ACM, o treinamento de um único modelo base BERT (sem ajuste de hiperparâmetro) em GPUs foi estimado para exigir tanta energia quanto um voo transamericano. Os impactos ambientais aumentam com o tamanho do modelo e a capacidade de ajustar esses modelos com eficiência pode reduzir significativamente as emissões. A AWS lançou recentemente um novo Ferramenta de pegada de carbono do cliente, disponível para todos os clientes da AWS sem custo, como parte dos esforços da Amazon para aumentar a sustentabilidade e reduzir as emissões de carbono. A execução de aplicativos na Nuvem AWS pode diminuir potencialmente a pegada de carbono (quando comparado aos data centers corporativos que foram pesquisados ​​em um relatório 2019).

Conclusão

Este post demonstrou uma solução que facilita o ajuste fino de modelos de linguagem com um bilhão de parâmetros na Nuvem AWS usando o SageMaker.

Para obter mais informações sobre o paralelismo de modelo com o SageMaker, consulte Treine mais de 175 bilhões de modelos de NLP de parâmetros com adições paralelas de modelo e Hugging Face no Amazon SageMaker e Como o Espaço Latente usou a biblioteca de paralelismo de modelos Amazon SageMaker para expandir as fronteiras dos transformadores de grande escala.

Se você quiser ajuda para acelerar o uso de ML em seus produtos e processos, entre em contato com o Laboratório de soluções de ML da Amazon.

Sobre os autores

Sia Gholami é Cientista de Dados Sênior no Amazon ML Solutions Lab, onde desenvolve soluções de IA/ML para clientes em vários setores. Ele é apaixonado por processamento de linguagem natural (PNL) e aprendizado profundo. Fora do trabalho, Sia gosta de passar o tempo na natureza e jogar tênis.

Mehdi Noorié Gerente e Cientista Aplicado Sênior no Amazon ML Solutions Lab, onde trabalha com clientes em vários setores e os ajuda a acelerar sua jornada de migração para a nuvem e a resolver seus problemas de ML usando soluções de última geração e tecnologias.

Muhyun Kim é cientista de dados do Amazon Machine Learning Solutions Lab. Ele resolve os vários problemas de negócios do cliente aplicando aprendizado de máquina e aprendizado profundo, e também os ajuda a se tornarem qualificados.

Danny Byrd é um cientista aplicado no Amazon ML Solutions Lab. No laboratório, ele ajudou clientes a desenvolver soluções avançadas de ML, em especialidades de ML, desde visão computacional até aprendizado por reforço. Ele é apaixonado por impulsionar a tecnologia e desbloquear novos potenciais dos produtos da AWS ao longo do caminho.

Francisco Calderón Rodríguez é cientista de dados no Amazon ML Solutions Lab. Como membro do ML Solutions Lab, ele ajuda a resolver problemas críticos de negócios para clientes da AWS usando aprendizado profundo. Nas horas vagas, Francisco gosta de tocar música e violão, jogar futebol com as filhas e aproveitar o tempo com a família.

Yohei Nakayama é um Deep Learning Architect no Amazon ML Solutions Lab. Ele trabalha com clientes em diferentes verticais para acelerar o uso de inteligência artificial e serviços da Nuvem AWS para resolver seus desafios de negócios. Ele está interessado em aplicar tecnologias ML/AI à indústria espacial.

Natalie Rauschmayr é Cientista Aplicada Sênior na AWS, onde ajuda os clientes a desenvolver aplicativos de aprendizado profundo.

• Coinsmart. A melhor troca de Bitcoin e criptografia da Europa.
• Platoblockchain. Inteligência Metaverso Web3. Conhecimento Ampliado. ACESSO LIVRE.
• CryptoHawk. Radar Altcoin. Teste grátis.
• Fonte: 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/