Cree, entrene e implemente un modelo de lenguaje de mil millones de parámetros en terabytes de datos con TensorFlow y Amazon SageMaker

El tamaño cada vez mayor de los modelos de lenguaje ha sido una de las mayores tendencias en el procesamiento del lenguaje natural (PNL) en los últimos años. Desde 2018, hemos visto un desarrollo e implementación sin precedentes de modelos de lenguaje cada vez más grandes, incluidos BERT y sus variantes, GPT-2, T-NLG y GPT-3 (175 XNUMX millones de parámetros).

Estos modelos han ampliado los límites de las posibles innovaciones arquitectónicas. Nos enfrentamos a varios desafíos cuando entrenamos modelos de aprendizaje profundo a gran escala, especialmente la nueva ola de transformadores preentrenados generativos. Estos desafíos incluyen limitaciones de hardware y compensaciones con computación y eficiencia. Para superar estos desafíos de paralelismo de modelos y datos, AWS ofrece una amplia gama de capacidades.

En esta publicación, presentamos dos enfoques principales: paralelización de datos y paralelización de modelos usando Amazon SageMaker, y discutir sus pros y sus contras.

El modelo

Para el modelo de lenguaje, usamos Transformers, introducido en el artículo. La atención es todo lo que necesitas. Los transformadores son modelos de aprendizaje profundo diseñados para evitar deliberadamente las trampas de las RNN al depender de un mecanismo de autoatención para generar dependencias globales entre la entrada y la salida. La arquitectura del modelo Transformer permite una paralelización significativamente mejor y puede lograr un alto rendimiento en un tiempo de entrenamiento relativamente corto. Basado en el éxito de Transformers, BERT, presentado en el documento BERT: pre-entrenamiento de transformadores bidireccionales profundos para la comprensión del lenguaje, agregó pre-entrenamiento bidireccional para la representación del lenguaje. Inspirado en la tarea Cloze, BERT está preentrenado con modelado de lenguaje enmascarado (MLM), en el que el modelo aprende a recuperar las palabras originales para tokens enmascarados aleatoriamente. El modelo BERT también está preentrenado en la tarea de predicción de la siguiente oración (NSP) para predecir si dos oraciones están en el orden de lectura correcto. Desde su aparición en 2018, BERT y sus variaciones se han utilizado ampliamente en modelos de lenguaje.

Comenzamos creando dos capas de incrustación para token y incrustación posicional. Las incrustaciones de entrada son la suma de las incrustaciones de tokens y las incrustaciones de posición.

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

Luego, definimos un bloque decodificador de transformador con dos subcapas: una capa de autoatención de cabezales múltiples y una red de avance simple totalmente conectada seguida de normalización y abandono de capa:

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)

Finalmente, creamos nuestro modelo de lenguaje con la capa de incrustación anterior y los bloques transformadores:

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

Dependiendo de sus hiperparámetros, puede escalar este modelo de miles de parámetros a miles de millones de parámetros. El desafío principal con los modelos de mil millones de parámetros es que no puede hospedar el modelo en una instancia y necesita distribuir el modelo en varios nodos para entrenamiento e inferencia.

El conjunto de datos

En nuestros experimentos, usamos el Conjunto de datos de pila. The Pile es un conjunto de datos de texto en inglés de 800 GiB diseñado para entrenar modelos de lenguaje a gran escala. Se crea a partir de 22 conjuntos de datos diversos y de alta calidad, incluidos conjuntos de datos de PNL establecidos y nuevos.

El conjunto de datos se crea a partir de una variedad de fuentes de datos, incluidos libros; repositorios de GitHub; páginas web; registros de chat; y trabajos de medicina, física, matemáticas, informática y filosofía. Específicamente, utiliza las siguientes fuentes: Pile-CC, PubMed Central, ArXiv, GitHub, FreeLaw Project, Stack Exchange, la Oficina de Marcas y Patentes de EE. UU., PubMed, Ubuntu, IRC, HackerNews, YouTube, PhilPapers, Books3, Project Gutenberg ( PG-19), OpenSubtitles, Wikipedia en inglés, DM Mathematics, EuroParl, el corpus de correos electrónicos de Enron y NIH ExPorter. También incluye OpenWebText2 y BookCorpus2, que son extensiones de los conjuntos de datos originales de OpenWebText y BookCorpus, respectivamente. La diversidad en las fuentes de datos puede mejorar el conocimiento general entre dominios y, en consecuencia, mejorar las capacidades de generalización posteriores.

El desafío principal con este conjunto de datos es el gran tamaño; el conjunto de datos tiene 825 GiB de texto, lo que se traduce en 4.2 TiB de puntos de datos preprocesados ​​y comprimidos. Al igual que los desafíos que enfrentamos con la capacitación y el alojamiento de los modelos, la capacitación de un modelo con este conjunto de datos en una sola instancia llevará mucho tiempo y no es práctico.

Nuestra solución es dividir el conjunto de datos en fragmentos de datos de aproximadamente 1 GiB, cargar y preprocesar las funciones en Conjunto de datos TensorFlow objetos y almacenarlos en Servicio de archivos elásticos de Amazon (Amazon EFS). Los conjuntos de datos de TensorFlow proporcionan una canalización de datos fácil de usar y de alto rendimiento que se integra bien con nuestros modelos. Amazon EFS es un servicio fácil de usar que nos permite crear un sistema de archivos compartidos que escala automáticamente a medida que se agregan y eliminan archivos. Además, Amazon EFS es capaz de alcanzar niveles de rendimiento más altos cuando sea necesario, lo cual es fundamental en nuestra canalización de capacitación de modelos y datos.

A continuación, analizamos las estrategias de capacitación distribuida para abordar estos desafíos.

Entrenamiento distribuido

En este proyecto, enfrentamos dos desafíos: escalar el tamaño del modelo y el volumen de datos. Aumentar el tamaño del modelo y la cantidad de parámetros entrenables puede resultar en una mayor precisión, pero hay un límite para el modelo que puede caber en una sola memoria de GPU o incluso en varias GPU en una sola instancia. Además, los tamaños de modelo más grandes toman más tiempo para entrenar.

Puede abordar estos desafíos de dos maneras diferentes: paralelismo de datos y paralelismo de modelos. Con el paralelismo de datos, realizamos Stochastic Gradient Descent (SGD) al distribuir los registros de un mini lote en diferentes dispositivos para acelerar el entrenamiento. Sin embargo, el entrenamiento de datos paralelos viene con la complejidad adicional de calcular el promedio de gradiente de mini lotes con gradientes de todos los dispositivos, un paso llamado AllReduce, que se vuelve más difícil a medida que crece el grupo de entrenamiento. Mientras usamos el paralelismo de datos, debemos poder ajustar el modelo y un único punto de datos en un dispositivo (CPU o GPU), lo cual es un factor limitante en nuestros experimentos porque el tamaño de un modelo tan grande es mucho mayor que la memoria de una sola GPU. Talla.

Otra solución es utilizar el paralelismo del modelo, que divide el modelo en varios dispositivos. El paralelismo de modelos es el proceso de dividir un modelo entre varios dispositivos o nodos (como instancias equipadas con GPU) y crear una canalización eficiente para entrenar el modelo en estos dispositivos para maximizar la utilización de GPU.

Paralelización de datos

Paralelizar los datos es el enfoque más común para múltiples GPU o entrenamiento distribuido. Puede procesar por lotes sus datos, enviarlos a varios dispositivos (cada uno con un modelo replicado) y luego agregar los resultados. Experimentamos con dos paquetes para la paralelización de datos: Horovod y el Biblioteca paralela de datos distribuidos de SageMaker.

Horovod es un marco de capacitación de aprendizaje profundo distribuido para TensorFlow, Keras, PyTorch y Apache MXNet. Para usar Horovod, pasamos por el siguiente proceso:

1. Inicializar ejecutando hvd.init().
2. Asociar cada dispositivo a un solo proceso. El primer proceso o trabajador está asociado con el primer dispositivo, el segundo proceso está asociado con el segundo dispositivo y así sucesivamente.
3. Ajuste la tasa de aprendizaje en función del número de dispositivos.
4. Envuelva el optimizador en hvd.DistributedOptimizer.
5. Transmita los estados variables iniciales del primer trabajador con rango 0 a todos los demás procesos. Esto es necesario para garantizar una inicialización consistente de todos los trabajadores cuando el entrenamiento se inicia con pesos aleatorios o se restaura desde un punto de control.
6. Asegúrese de que solo el dispositivo 0 pueda guardar puntos de control para evitar que otros trabajadores los dañen.

El siguiente es el script de entrenamiento:

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 biblioteca paralela de datos de SageMaker nos permite escalar nuestra capacitación con una eficiencia casi lineal, acelerando nuestra capacitación con cambios mínimos en el código. La biblioteca realiza una costumbre AllReduce operación y optimiza la comunicación de dispositivo a dispositivo al utilizar completamente la infraestructura de red de AWS y Nube informática elástica de Amazon (Amazon EC2) topología de instancia. Para utilizar la biblioteca paralela de datos de SageMaker, realizamos el siguiente proceso:

1. Importar e inicializar sdp.init().
2. Asociar cada dispositivo con un único smdistributed.dataparallel proceso con local_rank. sdp.tensorflow.local_rank() nos da la clasificación local de los dispositivos. El líder es de rango 0 y los trabajadores son de rango 1, 2, 3, etc.
3. Ajuste la tasa de aprendizaje en función del número de dispositivos.
4. Envuelva tf.GradientTape DistributedGradientTape actuar AllReduce.
5. Transmita las variables del modelo inicial desde el nodo líder a todos los nodos trabajadores.
6. Asegúrese de que solo el dispositivo 0 pueda guardar puntos de control.

Paralelización de modelos

Podemos ajustar los hiperparámetros para mantener el modelo lo suficientemente pequeño para entrenar con una sola GPU, o podemos usar el paralelismo del modelo para dividir el modelo entre varias GPU en varias instancias. Aumentar la cantidad de parámetros entrenables de un modelo puede resultar en una mejor precisión, pero hay un límite para el tamaño máximo del modelo que puede caber en una sola memoria de GPU. Usamos la biblioteca paralela de modelos distribuidos de SageMaker para entrenar nuestros modelos más grandes. Los pasos son los siguientes:

1. Importe e inicialice la biblioteca con smp.init().
2. El modelo Keras debe heredar de smp.DistributedModel en lugar de la clase Keras Model.
3. Set drop_remainder=True existentes tf.Dataset.batch() método para garantizar que el tamaño del lote sea siempre divisible por el número de microlotes.
4. Todas las operaciones aleatorias en la canalización de datos deben usar la misma semilla: smp.dp_rank(), por ejemplo, shuffle(ds, seed=smp.dp_rank()). Esto garantiza la coherencia de las muestras de datos en los dispositivos que contienen particiones de diferentes modelos.
5. La lógica de avance y retroceso debe estar en una función de paso con smp.step decoración.
6. Realice el posprocesamiento de las salidas en microlotes utilizando métodos StepOutput como reduce_mean. smp.step La función debe tener un valor de retorno que depende de la salida de smp.DistributedModel.

El script de entrenamiento es el siguiente:

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 obtener una guía detallada para habilitar el script de entrenamiento de TensorFlow para la biblioteca paralela del modelo distribuido de SageMaker, consulte Modificar un script de entrenamiento de TensorFlow. Para PyTorch, consulte Modificar un script de entrenamiento de PyTorch.

Depurador de SageMaker

En las secciones anteriores, discutimos cómo optimizar el entrenamiento usando técnicas de paralelización de datos y modelos. Con Depurador de Amazon SageMaker, ahora podemos capturar información de perfiles de rendimiento de nuestras ejecuciones de capacitación para determinar cuánto ha mejorado la capacitación. De manera predeterminada, Debugger captura las métricas del sistema para cada trabajo de capacitación de SageMaker, como GPU, uso de CPU, memoria, red y E/S en un intervalo de muestreo de 500 milisegundos. Podemos acceder a los datos de la siguiente manera:

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

El depurador proporciona utilidades para visualizar los datos de perfilado de diferentes maneras. En el siguiente ejemplo, vemos la utilización total de GPU y CPU, así como el tiempo de espera de E/S para el trabajo de entrenamiento de varias GPU con Horovod. Para generar estos gráficos, ejecutamos el siguiente 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 )

La utilización de la GPU fluctúa con frecuencia entre 0 y 100 %, y los tiempos de espera de E/S elevados con una utilización baja de la GPU son un indicador de un cuello de botella de E/S. Además, la utilización total de la CPU nunca supera el 70 %, lo que significa que podemos mejorar el preprocesamiento de datos aumentando la cantidad de procesos de trabajo.

Podemos mejorar el rendimiento cambiando de Horovod a la biblioteca paralela de datos distribuidos de SageMaker. En los siguientes gráficos, podemos ver que las GPU se utilizan de manera más eficiente y solo se reducen a un uso bajo durante períodos cortos de tiempo.

Infraestructura de entrenamiento

Para entrenar los modelos, usamos instancias de 10 ml.p3.16xlarge mediante un trabajo de entrenamiento de SageMaker. SageMaker reduce el tiempo y el costo de entrenar y ajustar los modelos de aprendizaje automático (ML) sin la necesidad de administrar la infraestructura. Con SageMaker, puede entrenar y ajustar fácilmente los modelos de aprendizaje automático con herramientas integradas para administrar y realizar un seguimiento de los experimentos de entrenamiento, elegir automáticamente los hiperparámetros óptimos, depurar trabajos de entrenamiento y monitorear la utilización de los recursos del sistema, como GPU, CPU y ancho de banda de red. Los datos se alojaron en Amazon EFS, lo que nos permitió crecer y reducirnos a medida que agregamos y eliminamos archivos sin necesidad de administración o aprovisionamiento. Nuestros objetivos principales eran mejorar la velocidad de entrenamiento y reducir los costos.

Escalabilidad del modelo

Aunque esta infraestructura se usa principalmente para la generación de lenguaje, con la arquitectura GPT y el conjunto de datos de Pile, puede usar estas técnicas para entrenar modelos de transformadores a gran escala, lo cual es útil en muchos dominios más allá de NLP. En el aprendizaje automático en sí mismo, muchas tareas de visión por computadora ahora se resuelven con arquitecturas de parámetros grandes (transformadores) en las que se ha demostrado que superan a las CNN (redes neuronales convolucionales) tradicionales en tareas como el aprendizaje de representación (ver Avanzando en el estado del arte en visión por computadora con Transformers autosupervisados ​​y entrenamiento 10 veces más eficiente) y mapeo a gran escala de imágenes a texto (como CLIP). Los modelos de parámetros grandes también están abriendo nuevos caminos en las ciencias de la vida en campos como análisis de la estructura de proteínas y análisis de datos de imágenes médicas.

Las soluciones que detallamos en esta publicación para el entrenamiento distribuido y la gestión de modelos grandes también deberían aplicarse a los modelos en cualquiera de estos dominios.

Compensaciones

Ha habido una discusión en curso en la comunidad de investigación con respecto a los riesgos de entrenar modelos de lenguaje a gran escala, y si se ha pensado lo suficiente en los riesgos potenciales asociados con el desarrollo de ellos y las estrategias para mitigar estos riesgos, algunos de los cuales incluyen los financieros y costos ambientales. De acuerdo a un publicado en ACM, se estimó que entrenar un solo modelo base BERT (sin ajuste de hiperparámetros) en GPU requería tanta energía como un vuelo transamericano. Los impactos ambientales escalan con el tamaño del modelo, y ser capaz de ajustar dichos modelos de manera eficiente puede potencialmente reducir significativamente las emisiones. AWS lanzó recientemente un nuevo Herramienta Huella de Carbono del Cliente, disponible para todos los clientes de AWS sin costo alguno, como parte de los esfuerzos de Amazon para aumentar la sustentabilidad y reducir las emisiones de carbono. La ejecución de aplicaciones en la nube de AWS puede reducir potencialmente la huella de carbono (en comparación con los centros de datos empresariales encuestados en un informe del 2019).

Conclusión

Esta publicación demostró una solución que facilita el ajuste de los modelos de lenguaje con mil millones de parámetros en la nube de AWS mediante SageMaker.

Para obtener más información sobre el paralelismo de modelos con SageMaker, consulte Entrene más de 175 XNUMX millones de modelos de NLP con parámetros con adiciones paralelas de modelos y Hugging Face en Amazon SageMaker y Cómo Latent Space utilizó la biblioteca de paralelismo de modelos de Amazon SageMaker para ampliar las fronteras de los transformadores a gran escala.

Si desea obtener ayuda para acelerar el uso de ML en sus productos y procesos, comuníquese con el Laboratorio de soluciones de Amazon ML.

Acerca de los autores

Sia Gholami es un científico de datos sénior en Amazon ML Solutions Lab, donde crea soluciones de IA/ML para clientes de diversas industrias. Le apasiona el procesamiento del lenguaje natural (PNL) y el aprendizaje profundo. Fuera del trabajo, a Sia le gusta pasar tiempo en la naturaleza y jugar al tenis.

mehdi noories gerente y científico aplicado sénior en Amazon ML Solutions Lab, donde trabaja con clientes de diversas industrias y los ayuda a acelerar su viaje de migración a la nube y a resolver sus problemas de ML utilizando soluciones y soluciones de última generación. tecnologías

muhyun kim es científico de datos en Amazon Machine Learning Solutions Lab. Resuelve los diversos problemas comerciales de los clientes mediante la aplicación del aprendizaje automático y el aprendizaje profundo, y también los ayuda a capacitarse.

Danny Byrd es científico aplicado en Amazon ML Solutions Lab. En el laboratorio, ayudó a los clientes a desarrollar soluciones avanzadas de ML, en especialidades de ML, desde visión por computadora hasta aprendizaje reforzado. Le apasiona impulsar la tecnología y desbloquear el nuevo potencial de los productos de AWS en el camino.

Francisco Calderón Rodríguez es científico de datos en Amazon ML Solutions Lab. Como miembro del ML Solutions Lab, ayuda a resolver problemas comerciales críticos para los clientes de AWS mediante el aprendizaje profundo. En su tiempo libre, a Francisco le gusta tocar música y guitarra, jugar fútbol con sus hijas y disfrutar del tiempo con su familia.

yohei nakayama es un arquitecto de aprendizaje profundo en el laboratorio de soluciones de Amazon ML. Trabaja con clientes de diferentes verticales para acelerar el uso de la inteligencia artificial y los servicios en la nube de AWS para resolver sus desafíos comerciales. Está interesado en aplicar tecnologías ML / AI a la industria espacial.

Nathalie Rauschmayr es científica aplicada sénior en AWS, donde ayuda a los clientes a desarrollar aplicaciones de aprendizaje profundo.

• Coinsmart. El mejor intercambio de Bitcoin y criptografía de Europa.
• Platoblockchain. Inteligencia del Metaverso Web3. Conocimiento amplificado. ACCESO LIBRE.
• CriptoHawk. Radar de altcoins. Prueba gratis.
• Fuente: 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/