Créez, entraînez et déployez un modèle de langage d'un milliard de paramètres sur des téraoctets de données avec TensorFlow et Amazon SageMaker

La taille croissante des modèles de langage a été l'une des plus grandes tendances du traitement du langage naturel (TAL) ces dernières années. Depuis 2018, nous avons assisté à un développement et à un déploiement sans précédent de modèles de langage toujours plus grands, notamment BERT et ses variantes, GPT-2, T-NLG et GPT-3 (175 milliards de paramètres).

Ces modèles ont repoussé les limites des innovations architecturales possibles. Nous sommes confrontés à plusieurs défis lors de la formation de modèles d'apprentissage en profondeur à grande échelle, en particulier la nouvelle vague de transformateurs pré-formés génératifs. Ces défis incluent les limitations matérielles et les compromis avec le calcul et l'efficacité. Pour surmonter ces défis de parallélisme des modèles et des données, AWS propose un large éventail de fonctionnalités.

Dans cet article, nous introduisons deux approches principales : la parallélisation des données et la parallélisation des modèles à l'aide de Amazon Sage Maker, et discutez de leurs avantages et inconvénients.

Le modèle

Pour le modèle de langage, nous utilisons les transformateurs, introduits dans l'article L'attention est tout ce dont vous avez besoin. Les transformateurs sont des modèles d'apprentissage en profondeur conçus pour éviter délibérément les pièges des RNN en s'appuyant sur un mécanisme d'auto-attention pour établir des dépendances globales entre l'entrée et la sortie. L'architecture du modèle Transformer permet une parallélisation nettement meilleure et peut atteindre des performances élevées en un temps de formation relativement court. S'appuyant sur le succès de Transformers, BERT, présenté dans l'article BERT: Pré-formation de transformateurs bidirectionnels profonds pour la compréhension du langage, ajout d'une pré-formation bidirectionnelle pour la représentation du langage. Inspiré de la tâche Cloze, BERT est pré-formé avec la modélisation de langage masqué (MLM), dans laquelle le modèle apprend à récupérer les mots originaux pour des jetons masqués de manière aléatoire. Le modèle BERT est également pré-entraîné sur la tâche de prédiction de phrase suivante (NSP) pour prédire si deux phrases sont dans le bon ordre de lecture. Depuis son avènement en 2018, le BERT et ses variantes ont été largement utilisés dans les modèles de langage.

Nous commençons par créer deux couches d'intégration pour l'intégration de jeton et de position. Les plongements d'entrée sont la somme des plongements de jeton et des placement de position.

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

Ensuite, nous définissons un bloc de décodeur de transformateur avec deux sous-couches : une couche d'auto-attention multi-têtes et un simple réseau d'anticipation entièrement connecté suivi d'une normalisation et d'un abandon de couche :

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)

Enfin, nous créons notre modèle de langage avec la couche d'intégration et les blocs transformateurs précédents :

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

En fonction de vos hyperparamètres, vous pouvez faire évoluer ce modèle de milliers de paramètres à des milliards de paramètres. Le principal défi avec les modèles à un milliard de paramètres est que vous ne pouvez pas héberger le modèle dans une instance et que vous devez distribuer le modèle sur plusieurs nœuds pour la formation et l'inférence.

Le jeu de données

Dans nos expériences, nous avons utilisé le Jeu de données de pieux. The Pile est un ensemble de données textuelles en anglais de 800 Gio conçu pour la formation de modèles linguistiques à grande échelle. Il est créé à partir de 22 ensembles de données divers et de haute qualité, comprenant à la fois des ensembles de données NLP établis et des ensembles nouvellement introduits.

L'ensemble de données est créé à partir de diverses sources de données, y compris des livres ; Référentiels GitHub ; les pages Web; journaux de discussion ; et des articles de médecine, de physique, de mathématiques, d'informatique et de philosophie. Plus précisément, il utilise les sources suivantes : Pile-CC, PubMed Central, ArXiv, GitHub, the FreeLaw Project, Stack Exchange, the US Patent and Trademark Office, PubMed, Ubuntu, IRC, HackerNews, YouTube, PhilPapers, Books3, Project Gutenberg ( PG-19), OpenSubtitles, Wikipedia anglais, DM Mathematics, EuroParl, le corpus Enron Emails et NIH ExPorter. Il inclut également OpenWebText2 et BookCorpus2, qui sont respectivement des extensions des jeux de données originaux OpenWebText et BookCorpus. La diversité des sources de données peut améliorer les connaissances générales inter-domaines et par conséquent améliorer les capacités de généralisation en aval.

Le principal défi avec cet ensemble de données est la taille même ; l'ensemble de données contient 825 Gio de texte, ce qui se traduit par 4.2 Tio de points de données prétraités et compressés. Semblable aux défis auxquels nous sommes confrontés avec la formation et l'hébergement des modèles, la formation d'un modèle avec cet ensemble de données sur une seule instance prendra beaucoup de temps et n'est pas pratique.

Notre solution consiste à décomposer l'ensemble de données en blocs de données d'environ 1 Gio, à charger et à prétraiter les fonctionnalités dans Ensemble de données TensorFlow objets et stockez-les dans Service de fichiers élastique Amazon (AmazonEFS). Les ensembles de données TensorFlow fournissent un pipeline de données facile à utiliser et hautes performances qui s'intègre bien à nos modèles. Amazon EFS est un service facile à utiliser qui nous permet de créer un système de fichiers partagé qui évolue automatiquement au fur et à mesure que des fichiers sont ajoutés et supprimés. De plus, Amazon EFS est capable d'atteindre des niveaux de débit plus élevés en cas de besoin, ce qui est essentiel dans notre pipeline de formation de modèles et de données.

Ensuite, nous examinons les stratégies de formation distribuée pour relever ces défis.

Formation distribuée

Dans ce projet, nous avons été confrontés à deux défis : la mise à l'échelle de la taille du modèle et du volume de données. L'augmentation de la taille du modèle et du nombre de paramètres pouvant être entraînés peut entraîner une meilleure précision, mais il y a une limite au modèle que vous pouvez intégrer dans une seule mémoire GPU ou même plusieurs GPU dans une seule instance. De plus, les tailles de modèles plus grandes prennent plus de temps à s'entraîner.

Vous pouvez relever ces défis de deux manières différentes : le parallélisme des données et le parallélisme des modèles. Avec le parallélisme des données, nous effectuons une descente de gradient stochastique (SGD) en répartissant les enregistrements d'un mini-lot sur différents appareils pour accélérer la formation. Cependant, la formation de données parallèles s'accompagne d'une complexité supplémentaire de calcul de la moyenne de gradient de mini-lot avec des gradients de tous les appareils, une étape appelée AllReduce, qui devient plus difficile au fur et à mesure que le cluster de formation s'agrandit. Lors de l'utilisation du parallélisme des données, nous devons être en mesure d'adapter le modèle et un seul point de données dans un appareil (CPU ou GPU), ce qui est un facteur limitant dans nos expériences car la taille d'un si grand modèle est beaucoup plus grande que la mémoire du GPU unique. Taille.

Une autre solution consiste à utiliser le parallélisme des modèles, qui divise le modèle sur plusieurs appareils. Le parallélisme de modèle est le processus consistant à diviser un modèle entre plusieurs appareils ou nœuds (tels que des instances équipées de GPU) et à créer un pipeline efficace pour former le modèle sur ces appareils afin de maximiser l'utilisation du GPU.

Parallélisation des données

La parallélisation des données est l'approche la plus courante pour plusieurs GPU ou la formation distribuée. Vous pouvez regrouper vos données, les envoyer à plusieurs appareils (chacun hébergeant un modèle répliqué), puis agréger les résultats. Nous avons expérimenté deux packages pour la parallélisation des données : Horovod et le Bibliothèque parallèle de données distribuées SageMaker.

Horovod est un cadre de formation d'apprentissage en profondeur distribué pour TensorFlow, Keras, PyTorch et Apache MXNet. Pour utiliser Horovod, nous sommes passés par le processus suivant :

1. Initialiser en exécutant hvd.init().
2. Associez chaque appareil à un seul processus. Le premier processus ou travailleur est associé au premier appareil, le deuxième processus est associé au deuxième appareil, et ainsi de suite.
3. Ajustez le taux d'apprentissage en fonction du nombre d'appareils.
4. Enveloppez l'optimiseur dans hvd.DistributedOptimizer.
5. Diffusez les états initiaux des variables du premier worker de rang 0 à tous les autres processus. Cela est nécessaire pour assurer une initialisation cohérente de tous les travailleurs lorsque la formation est démarrée avec des poids aléatoires ou restaurée à partir d'un point de contrôle.
6. Assurez-vous que seul le périphérique 0 peut enregistrer des points de contrôle pour empêcher d'autres travailleurs de les corrompre.

Voici le script de formation :

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 bibliothèque parallèle de données SageMaker nous permet d'adapter notre formation avec une efficacité quasi linéaire, en accélérant notre formation avec des modifications de code minimales. La bibliothèque effectue une AllReduce fonctionnement et optimise la communication d'appareil à appareil en utilisant pleinement l'infrastructure réseau d'AWS et Cloud de calcul élastique Amazon (Amazon EC2) topologie d'instance. Pour utiliser la bibliothèque parallèle de données SageMaker, nous avons suivi le processus suivant :

1. Importer et initialiser sdp.init().
2. Associez chaque appareil à un seul smdistributed.dataparallel processus avec local_rank. sdp.tensorflow.local_rank() nous donne le rang local des appareils. Le chef est de rang 0 et les ouvriers sont de rang 1, 2, 3, etc.
3. Ajustez le taux d'apprentissage en fonction du nombre d'appareils.
4. enveloppe tf.GradientTape comprenant DistributedGradientTape à effectuer AllReduce.
5. Diffusez les variables de modèle initiales du nœud leader à tous les nœuds de travail.
6. Assurez-vous que seul le périphérique 0 peut enregistrer des points de contrôle.

Parallélisation du modèle

Nous pouvons ajuster les hyperparamètres pour que le modèle reste suffisamment petit pour s'entraîner à l'aide d'un seul GPU, ou nous pouvons utiliser le parallélisme de modèle pour diviser le modèle entre plusieurs GPU sur plusieurs instances. L'augmentation du nombre de paramètres pouvant être entraînés d'un modèle peut entraîner une meilleure précision, mais il existe une limite à la taille maximale du modèle que vous pouvez intégrer dans une seule mémoire GPU. Nous avons utilisé la bibliothèque parallèle de modèles distribués SageMaker pour former nos plus grands modèles. Les étapes sont les suivantes:

1. Importer et initialiser la bibliothèque avec smp.init().
2. Le modèle Keras doit hériter de smp.DistributedModel au lieu de la classe Keras Model.
3. Ensemble drop_remainder=True dans l' tf.Dataset.batch() méthode pour s'assurer que la taille du lot est toujours divisible par le nombre de microlots.
4. Les opérations aléatoires dans le pipeline de données doivent toutes utiliser la même graine : smp.dp_rank(), Par exemple, shuffle(ds, seed=smp.dp_rank()). Cela garantit la cohérence des échantillons de données sur les appareils qui contiennent différentes partitions de modèle.
5. La logique avant et arrière doit être dans une fonction pas à pas avec smp.step décoration.
6. Effectuez un post-traitement sur les sorties des microlots à l'aide de méthodes StepOutput telles que reduce_meanL’ smp.step fonction doit avoir une valeur de retour qui dépend de la sortie de smp.DistributedModel.

Le script de formation est le suivant :

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) 

Pour obtenir un guide détaillé sur l'activation du script de formation TensorFlow pour la bibliothèque parallèle de modèles distribués SageMaker, reportez-vous à Modifier un script d'entraînement TensorFlow. Pour PyTorch, reportez-vous à Modifier un script de formation PyTorch.

Débogueur SageMaker

Dans les sections précédentes, nous avons expliqué comment optimiser la formation à l'aide de techniques de parallélisation de modèles et de données. Avec Débogueur Amazon SageMaker, nous pouvons désormais capturer des informations de profilage des performances à partir de nos cycles de formation pour déterminer dans quelle mesure la formation s'est améliorée. Par défaut, Debugger capture les métriques système pour chaque tâche de formation SageMaker telles que le GPU, l'utilisation du processeur, la mémoire, le réseau et les E/S à un intervalle d'échantillonnage de 500 millisecondes. Nous pouvons accéder aux données comme suit :

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

Le débogueur fournit des utilitaires pour visualiser les données de profilage de différentes manières. Dans l'exemple suivant, nous voyons l'utilisation totale du GPU et du CPU ainsi que le temps d'attente d'E/S pour le travail d'entraînement multi-GPU utilisant Horovod. Pour générer ces graphiques, nous exécutons le code suivant :

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'utilisation du GPU fluctue fréquemment entre 0 et 100 %, et des temps d'attente d'E/S élevés avec une faible utilisation du GPU sont un indicateur d'un goulot d'étranglement d'E/S. De plus, l'utilisation totale du processeur ne dépasse jamais 70 %, ce qui signifie que nous pouvons améliorer le prétraitement des données en augmentant le nombre de processus de travail.

Nous pouvons améliorer les performances en passant d'Horovod à la bibliothèque parallèle de données distribuées SageMaker. Dans les graphiques suivants, nous pouvons voir que les GPU sont utilisés plus efficacement et ne chutent à une faible utilisation que pendant de courtes périodes.

Infrastructures de formation

Pour entraîner les modèles, nous avons utilisé 10 instances ml.p3.16xlarge à l'aide d'une tâche d'entraînement SageMaker. SageMaker réduit le temps et les coûts de formation et d'optimisation des modèles d'apprentissage automatique (ML) sans qu'il soit nécessaire de gérer l'infrastructure. Avec SageMaker, vous pouvez facilement former et ajuster les modèles ML à l'aide d'outils intégrés pour gérer et suivre les expériences de formation, choisir automatiquement les hyperparamètres optimaux, déboguer les tâches de formation et surveiller l'utilisation des ressources système telles que les GPU, les CPU et la bande passante du réseau. Les données étaient hébergées dans Amazon EFS, ce qui nous a permis de grandir et de diminuer au fur et à mesure que nous ajoutons et supprimons des fichiers sans avoir besoin de gestion ou de provisionnement. Nos principaux objectifs étaient d'améliorer la vitesse de formation et de réduire les coûts.

Évolutivité du modèle

Bien que cette infrastructure soit principalement utilisée pour la génération de langage, avec l'architecture GPT et l'ensemble de données Pile, vous pouvez utiliser ces techniques pour former des modèles de transformateur à grande échelle, ce qui est utile dans de nombreux domaines au-delà du NLP. Dans l'apprentissage automatique lui-même, de nombreuses tâches de vision par ordinateur sont désormais résolues avec des architectures à grands paramètres (transformateurs) où il a été démontré qu'elles surpassent les CNN traditionnels (réseau de neurones convolutifs) sur des tâches telles que l'apprentissage de la représentation (voir Faire progresser l'état de l'art en matière de vision par ordinateur avec des transformateurs auto-supervisés et une formation 10 fois plus efficace) et le mappage à grande échelle d'images sur du texte (comme CLIP). Les modèles à grands paramètres ouvrent également de nouvelles perspectives en sciences de la vie dans des domaines tels que analyse de la structure des protéines ainsi que le analyse de données d'images médicales.

Les solutions que nous détaillons dans cet article pour la formation distribuée et la gestion de grands modèles devraient également s'appliquer aux modèles de l'un de ces domaines.

Compromis

Il y a eu une discussion en cours dans la communauté de recherche concernant les risques de la formation de modèles linguistiques à grande échelle, et si suffisamment de réflexion a été consacrée aux risques potentiels associés à leur développement et aux stratégies pour atténuer ces risques, dont certaines comprennent les risques financiers et coûts environnementaux. Selon un papier publié dans ACM, il a été estimé que la formation d'un seul modèle de base BERT (sans réglage d'hyperparamètre) sur des GPU nécessitait autant d'énergie qu'un vol transaméricain. L'échelle des impacts environnementaux avec la taille du modèle et la capacité d'affiner efficacement ces modèles peuvent potentiellement réduire considérablement les émissions. AWS a récemment lancé une nouvelle Outil d'empreinte carbone client, disponible gratuitement pour tous les clients AWS, dans le cadre des efforts d'Amazon pour accroître la durabilité et réduire les émissions de carbone. L'exécution d'applications sur le cloud AWS peut potentiellement réduire l'empreinte carbone (par rapport aux centres de données d'entreprise qui ont été étudiés dans un rapport 2019).

Conclusion

Cet article a présenté une solution qui facilite le réglage fin des modèles de langage avec un milliard de paramètres sur le cloud AWS à l'aide de SageMaker.

Pour plus d'informations sur le parallélisme des modèles avec SageMaker, reportez-vous à Entraînez plus de 175 milliards de modèles de paramètres PNL avec des ajouts parallèles de modèles et Hugging Face sur Amazon SageMaker ainsi que le Comment Latent Space a utilisé la bibliothèque de parallélisme de modèles Amazon SageMaker pour repousser les frontières des transformateurs à grande échelle.

Si vous souhaitez de l'aide pour accélérer votre utilisation du ML dans vos produits et processus, veuillez contacter le Laboratoire de solutions Amazon ML.

À propos des auteurs

Sia Gholami est Senior Data Scientist au Amazon ML Solutions Lab, où il conçoit des solutions d'IA/ML pour des clients de divers secteurs. Il est passionné par le traitement du langage naturel (TAL) et l'apprentissage en profondeur. En dehors du travail, Sia aime passer du temps dans la nature et jouer au tennis.

Mehdi Nouriest un responsable et un scientifique appliqué senior au Amazon ML Solutions Lab, où il travaille avec des clients de divers secteurs et les aide à accélérer leur parcours de migration vers le cloud et à résoudre leurs problèmes de ML à l'aide de solutions de pointe et les technologies.

Mu Hyun Kim est un data scientist chez Amazon Machine Learning Solutions Lab. Il résout les divers problèmes commerciaux des clients en appliquant l'apprentissage automatique et l'apprentissage en profondeur, et les aide également à devenir qualifiés.

Danny Byrd est scientifique appliquée au Amazon ML Solutions Lab. Au laboratoire, il a aidé des clients à développer des solutions ML avancées, dans des spécialités ML allant de la vision par ordinateur à l'apprentissage par renforcement. Il est passionné par le fait de faire avancer la technologie et de libérer le nouveau potentiel des produits AWS en cours de route.

Francisco Calderón Rodríguez est Data Scientist au Amazon ML Solutions Lab. En tant que membre du ML Solutions Lab, il aide à résoudre les problèmes commerciaux critiques des clients AWS à l'aide de l'apprentissage en profondeur. Dans ses temps libres, Francisco aime jouer de la musique et de la guitare, jouer au football avec ses filles et passer du temps avec sa famille.

Yohei Nakayama est un architecte d'apprentissage en profondeur au Amazon ML Solutions Lab. Il travaille avec des clients de différents secteurs verticaux pour accélérer leur utilisation de l'intelligence artificielle et des services AWS Cloud afin de résoudre leurs défis commerciaux. Il s'intéresse à l'application des technologies ML/AI à l'industrie spatiale.

Nathalie Rauschmayr est Senior Applied Scientist chez AWS, où elle aide les clients à développer des applications d'apprentissage en profondeur.

• Coinsmart. Le meilleur échange Bitcoin et Crypto d'Europe.
• Platoblockchain. Intelligence métaverse Web3. Connaissance amplifiée. ACCÈS LIBRE.
• CryptoHawk. Radar Altcoins. Essai gratuit.
• Source : 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/