Creëer, train en implementeer een taalmodel met miljarden parameters op terabytes aan gegevens met TensorFlow en Amazon SageMaker

De toenemende omvang van taalmodellen is de afgelopen jaren een van de grootste trends in natuurlijke taalverwerking (NLP) geweest. Sinds 2018 hebben we een ongekende ontwikkeling en inzet gezien van steeds grotere taalmodellen, waaronder BERT en zijn varianten, GPT-2, T-NLG en GPT-3 (175 miljard parameters).

Deze modellen hebben de grenzen van mogelijke architectonische innovaties verlegd. We worden geconfronteerd met verschillende uitdagingen bij het trainen van grootschalige deep learning-modellen, met name de nieuwe golf van generatieve voorgetrainde transformatoren. Deze uitdagingen omvatten hardwarebeperkingen en compromissen met berekening en efficiëntie. Om deze uitdagingen van model- en dataparallellisme te overwinnen, biedt AWS een breed scala aan mogelijkheden.

In dit bericht introduceren we twee hoofdbenaderingen: gegevensparallellisatie en modelparallellisatie met behulp van: Amazon Sage Makeren bespreek hun voor- en nadelen.

Het model

Voor het taalmodel gebruiken we Transformers, geïntroduceerd in de paper Aandacht is alles wat je nodig hebt. Transformers zijn deep learning-modellen die zijn ontworpen om opzettelijk de valkuilen van RNN's te vermijden door te vertrouwen op een zelfaandachtsmechanisme om wereldwijde afhankelijkheden te trekken tussen input en output. De Transformer-modelarchitectuur zorgt voor een aanzienlijk betere parallellisatie en kan hoge prestaties behalen in relatief korte trainingstijd. Gebouwd op het succes van Transformers, BERT, geïntroduceerd in de krant BERT: Pre-training van Deep Bidirectional Transformers for Language Understanding, toegevoegde bidirectionele pre-training voor taalrepresentatie. Geïnspireerd door de Cloze-taak, is BERT vooraf getraind met gemaskeerde taalmodellering (MLM), waarbij het model leert de originele woorden voor willekeurig gemaskeerde tokens te herstellen. Het BERT-model is ook voorgetraind op de volgende zin voorspelling (NSP) taak om te voorspellen of twee zinnen in de juiste leesvolgorde staan. Sinds de komst in 2018 zijn BERT en zijn variaties op grote schaal gebruikt in taalmodellen.

We beginnen met het maken van twee inbeddingslagen voor token- en positionele inbedding. De invoerinbeddingen zijn de som van de tokeninbeddingen en positie-inbeddingen.

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

Vervolgens definiëren we een transformatordecoderblok met twee sublagen: een zelfaandachtslaag met meerdere koppen en een eenvoudig volledig verbonden feed-forward-netwerk gevolgd door laagnormalisatie en uitval:

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)

Ten slotte maken we ons taalmodel met de voorgaande inbeddingslaag en transformatorblokken:

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

Afhankelijk van uw hyperparameters kunt u dit model schalen van duizenden parameters naar miljarden parameters. De belangrijkste uitdaging bij modellen met miljarden parameters is dat u het model niet in één instantie kunt hosten en het model over verschillende knooppunten moet verdelen voor training en inferentie.

De dataset

In onze experimenten gebruikten we de Stapel dataset. The Pile is een 800 GiB Engelse tekstdataset die is ontworpen voor het trainen van grootschalige taalmodellen. Het is gemaakt op basis van 22 verschillende en hoogwaardige datasets, waaronder zowel bestaande NLP-datasets als nieuw geïntroduceerde.

De dataset is gemaakt op basis van verschillende gegevensbronnen, waaronder boeken; GitHub-opslagplaatsen; webpagina's; chatlogboeken; en medische, natuurkunde, wiskunde, informatica en filosofie papers. Het gebruikt met name de volgende bronnen: Pile-CC, PubMed Central, ArXiv, GitHub, het FreeLaw Project, Stack Exchange, het US Patent and Trademark Office, PubMed, Ubuntu, IRC, HackerNews, YouTube, PhilPapers, Books3, Project Gutenberg ( PG-19), OpenSubtitles, Engelse Wikipedia, DM Mathematics, EuroParl, het Enron Emails corpus en NIH ExPorter. Het bevat ook OpenWebText2 en BookCorpus2, die respectievelijk uitbreidingen zijn van de oorspronkelijke OpenWebText- en BookCorpus-datasets. De diversiteit in gegevensbronnen kan de algemene domeinoverschrijdende kennis verbeteren en bijgevolg de downstream-generalisatiemogelijkheden verbeteren.

De grootste uitdaging met deze dataset is de enorme omvang; de dataset heeft 825 GiB aan tekst, wat zich vertaalt in 4.2 TiB aan voorverwerkte en gecomprimeerde datapunten. Net als de uitdagingen waarmee we worden geconfronteerd bij het trainen en hosten van de modellen, zal het trainen van een model met deze dataset op een enkele instantie veel tijd kosten en is niet praktisch.

Onze oplossing is om de dataset op te splitsen in gegevensblokken van ongeveer 1 GiB, de functies te laden en voor te verwerken in TensorFlow-gegevensset voorwerpen en bewaar ze in Amazon Elastic-bestandsservice (Amazon EFS). TensorFlow-datasets bieden een gebruiksvriendelijke en krachtige datapijplijn die goed integreert met onze modellen. Amazon EFS is een gebruiksvriendelijke service waarmee we een gedeeld bestandssysteem kunnen bouwen dat automatisch wordt geschaald naarmate bestanden worden toegevoegd en verwijderd. Bovendien is Amazon EFS in staat om indien nodig naar hogere doorvoerniveaus te springen, wat van cruciaal belang is in onze pijplijn voor gegevens- en modeltraining.

Vervolgens kijken we naar gedistribueerde trainingsstrategieën om deze uitdagingen aan te gaan.

Gedistribueerde training

In dit project stonden we voor twee uitdagingen: schaalmodelgrootte en datavolume. Het vergroten van de modelgrootte en het aantal trainbare parameters kan resulteren in een betere nauwkeurigheid, maar er is een limiet aan het model dat u in een enkel GPU-geheugen of zelfs meerdere GPU's in één instantie kunt passen. Bovendien hebben grotere modelmaten meer tijd nodig om te trainen.

U kunt deze uitdagingen op twee verschillende manieren aanpakken: gegevensparallellisme en modelparallellisme. Met dataparallellisme voeren we Stochastic Gradient Descent (SGD) uit door de records van een mini-batch over verschillende apparaten te verdelen om de training te versnellen. Parallelle datatraining gaat echter gepaard met extra complexiteit van het berekenen van mini-batch gradiëntgemiddelde met gradiënten van alle apparaten, een stap genaamd AllReduce, wat moeilijker wordt naarmate het trainingscluster groeit. Bij het gebruik van dataparallellisme moeten we in staat zijn om het model en een enkel datapunt in een apparaat (CPU of GPU) te passen, wat een beperkende factor is in onze experimenten omdat de grootte van zo'n groot model veel groter is dan het geheugen van de enkele GPU maat.

Een andere oplossing is om modelparallellisme te gebruiken, waarbij het model over meerdere apparaten wordt verdeeld. Modelparallellisme is het proces van het opsplitsen van een model tussen meerdere apparaten of knooppunten (zoals met GPU uitgeruste instanties) en het creëren van een efficiënte pijplijn om het model over deze apparaten te trainen om het GPU-gebruik te maximaliseren.

Gegevensparallellisatie

Het parallelliseren van de gegevens is de meest gebruikelijke benadering voor meerdere GPU's of gedistribueerde training. U kunt uw gegevens in batches verzenden, naar meerdere apparaten verzenden (elk met een gerepliceerd model) en vervolgens de resultaten samenvoegen. We hebben geëxperimenteerd met twee pakketten voor gegevensparallellisatie: Horovod en de SageMaker gedistribueerde parallelle gegevensbibliotheek.

Horovod is een gedistribueerd deep learning-trainingsframework voor TensorFlow, Keras, PyTorch en Apache MXNet. Om Horovod te gebruiken, hebben we het volgende proces doorlopen:

1. Initialiseren door te rennen hvd.init().
2. Koppel elk apparaat aan één proces. Het eerste proces of de eerste werknemer is gekoppeld aan het eerste apparaat, het tweede proces is gekoppeld aan het tweede apparaat, enzovoort.
3. Pas de leersnelheid aan op basis van het aantal apparaten.
4. Wikkel de optimizer in hvd.DistributedOptimizer.
5. Zend de initiële variabelestatussen van de eerste werknemer met rang 0 uit naar alle andere processen. Dit is nodig om een ​​consistente initialisatie van alle werknemers te garanderen wanneer de training wordt gestart met willekeurige gewichten of wordt hersteld vanaf een controlepunt.
6. Zorg ervoor dat alleen apparaat 0 controlepunten kan opslaan om te voorkomen dat andere werknemers ze beschadigen.

Het volgende is het trainingsscript:

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)

De parallelle databibliotheek van SageMaker stelt ons in staat om onze training op te schalen met bijna lineaire efficiëntie, waardoor onze training wordt versneld met minimale codewijzigingen. De bibliotheek voert een custom AllReduce werking en optimaliseert de communicatie van apparaat naar apparaat door volledig gebruik te maken van de netwerkinfrastructuur van AWS en Amazon Elastic Compute-cloud (Amazon EC2) instantietopologie. Om de parallelle databibliotheek van SageMaker te gebruiken, hebben we het volgende proces doorlopen:

1. Importeren en initialiseren sdp.init().
2. Koppel elk apparaat aan een enkele smdistributed.dataparallel verwerken met local_rank. sdp.tensorflow.local_rank() geeft ons de lokale rangorde van apparaten. De leider is rang 0 en arbeiders zijn rang 1, 2, 3, enzovoort.
3. Pas de leersnelheid aan op basis van het aantal apparaten.
4. Wikkel tf.GradientTape Met DistributedGradientTape presteren AllReduce.
5. Zend de initiële modelvariabelen uit van het leiderknooppunt naar alle werkknooppunten.
6. Zorg ervoor dat alleen apparaat 0 controlepunten kan opslaan.

Modelparallellisatie

We kunnen de hyperparameters aanpassen om het model klein genoeg te houden om te trainen met een enkele GPU, of we kunnen modelparallellisme gebruiken om het model te splitsen tussen meerdere GPU's over meerdere instanties. Het verhogen van het aantal trainbare parameters van een model kan resulteren in een betere nauwkeurigheid, maar er is een limiet aan de maximale modelgrootte die u in een enkel GPU-geheugen kunt passen. We hebben de parallelle bibliotheek van gedistribueerde modellen van SageMaker gebruikt om onze grotere modellen te trainen. De stappen zijn als volgt:

1. Importeer en initialiseer de bibliotheek met smp.init().
2. Het Keras-model moet overerven van smp.DistributedModel in plaats van de Keras Model-klasse.
3. Zet de drop_remainder=True in de tf.Dataset.batch() methode om ervoor te zorgen dat de batchgrootte altijd deelbaar is door het aantal microbatches.
4. Willekeurige bewerkingen in de gegevenspijplijn moeten allemaal dezelfde seed gebruiken: smp.dp_rank()Bijvoorbeeld shuffle(ds, seed=smp.dp_rank()). Dit zorgt voor consistentie van gegevensvoorbeelden op apparaten die verschillende modelpartities bevatten.
5. Voorwaartse en achterwaartse logica moet in een stapfunctie zijn met smp.step decoratie.
6. Voer nabewerking uit op de uitvoer in microbatches met behulp van StepOutput-methoden zoals: reduce_mean. De smp.step functie moet een retourwaarde hebben die afhangt van de uitvoer van smp.DistributedModel.

Het trainingsscript is als volgt:

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) 

Raadpleeg voor een gedetailleerde handleiding om het TensorFlow-trainingsscript voor de parallelle bibliotheek met gedistribueerde modellen van SageMaker in te schakelen: Een TensorFlow-trainingsscript wijzigen. Raadpleeg voor PyTorch: Een PyTorch-trainingsscript wijzigen.

SageMaker-foutopsporing

In de vorige paragrafen hebben we besproken hoe de training kan worden geoptimaliseerd met behulp van model- en dataparallelisatietechnieken. Met Amazon SageMaker-foutopsporing, kunnen we nu prestatieprofileringsinformatie van onze trainingsruns vastleggen om te bepalen in hoeverre de training is verbeterd. Standaard legt Debugger systeemstatistieken vast voor elke SageMaker-trainingstaak, zoals GPU, CPU-gebruik, geheugen, netwerk en I/O met een bemonsteringsinterval van 500 milliseconden. We hebben als volgt toegang tot de gegevens:

from smdebug.profiler.analysis.notebook_utils.training_job import TrainingJob
tj = TrainingJob('SMD-MP-demo-2022-01-21-06-43-23-841', "us-east-1")
tj.wait_for_sys_profiling_data_to_be_available()
system_metrics_reader = tj.get_systems_metrics_reader()

Debugger biedt hulpprogramma's om visualiseren de profileringsgegevens op verschillende manieren. In het volgende voorbeeld zien we het totale GPU- en CPU-gebruik en de I/O-wachttijd voor de multi-GPU-trainingstaak met Horovod. Om deze grafieken te genereren, voeren we de volgende code uit:

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 )

Het GPU-gebruik schommelt vaak tussen 0–100%, en hoge I/O-wachttijden met een laag GPU-gebruik zijn een indicator van een I/O-knelpunt. Bovendien is het totale CPU-gebruik nooit hoger dan 70%, wat betekent dat we de voorverwerking van gegevens kunnen verbeteren door het aantal werkprocessen te vergroten.

We kunnen de prestaties verbeteren door over te stappen van Horovod naar de parallelle gedistribueerde databibliotheek van SageMaker. In de volgende grafieken kunnen we zien dat GPU's efficiënter worden gebruikt en slechts gedurende korte perioden tot een laag gebruik dalen.

Trainingsinfrastructuur

Voor het trainen van de modellen hebben we 10 ml.p3.16xgrote instanties gebruikt met behulp van een SageMaker-trainingstaak. SageMaker reduceert de tijd en kosten voor het trainen en afstemmen van machine learning (ML)-modellen zonder de noodzaak om de infrastructuur te beheren. Met SageMaker kunt u eenvoudig ML-modellen trainen en afstemmen met behulp van ingebouwde tools om trainingsexperimenten te beheren en bij te houden, automatisch optimale hyperparameters te kiezen, fouten op te sporen in trainingstaken en het gebruik van systeembronnen zoals GPU's, CPU's en netwerkbandbreedte te bewaken. De gegevens werden gehost in Amazon EFS, waardoor we konden groeien en krimpen terwijl we bestanden toevoegen en verwijderen zonder dat beheer of voorziening nodig was. Onze primaire doelstellingen waren het verbeteren van de trainingssnelheid en het verlagen van de kosten.

Modelschaalbaarheid

Hoewel deze infrastructuur voornamelijk wordt gebruikt voor het genereren van talen, kunt u met de GPT-architectuur en Pile-dataset deze technieken gebruiken om grootschalige transformatormodellen te trainen, wat nuttig is in veel domeinen buiten NLP. Bij machine learning zelf worden veel computervisietaken nu opgelost met architecturen met grote parameters (transformatoren), waarvan is aangetoond dat ze beter presteren dan traditionele CNN's (Convolutional Neural Network) voor taken zoals representatieleren (zie Vooruitgang in de stand van de techniek op het gebied van computervisie met zelf-gecontroleerde Transformers en 10x efficiëntere training) en grootschalige toewijzing van afbeeldingen aan tekst (zoals CLIP). Modellen met grote parameters zijn ook baanbrekend in de biowetenschappen op gebieden als eiwitstructuuranalyse en analyse van medische beeldgegevens.

De oplossingen die we in dit bericht beschrijven voor gedistribueerde training en het beheren van grote modellen, moeten ook van toepassing zijn op modellen in elk van deze domeinen.

Afwegingen

Er is in de onderzoeksgemeenschap een voortdurende discussie gaande over de risico's van het trainen van grootschalige taalmodellen, en of er voldoende is nagedacht over de mogelijke risico's die gepaard gaan met de ontwikkeling ervan en strategieën om deze risico's te beperken, waaronder de financiële en milieu kosten. Volgens een papier gepubliceerd in ACM, werd geschat dat het trainen van een enkel BERT-basismodel (zonder hyperparameterafstemming) op GPU's evenveel energie kostte als een trans-Amerikaanse vlucht. De milieueffecten schalen mee met de modelgrootte, en het efficiënt kunnen afstemmen van dergelijke modellen kan de emissies mogelijk aanzienlijk inperken. AWS heeft onlangs een nieuwe Tool voor koolstofvoetafdruk van klanten, gratis beschikbaar voor alle AWS-klanten, als onderdeel van Amazon's inspanningen om de duurzaamheid te vergroten en de COXNUMX-uitstoot te verminderen. Het uitvoeren van applicaties op de AWS Cloud kan mogelijk de ecologische voetafdruk verkleinen (in vergelijking met enterprise datacenters die werden onderzocht in een 2019-rapport).

Conclusie

Dit bericht demonstreerde een oplossing die de fijnafstemming van taalmodellen met een miljard parameters op de AWS Cloud vergemakkelijkt met behulp van SageMaker.

Raadpleeg voor meer informatie over modelparallellisme met SageMaker: Train 175+ miljard parameter NLP-modellen met modelparallelle toevoegingen en Hugging Face op Amazon SageMaker en Hoe Latent Space de parallellismebibliotheek van Amazon SageMaker gebruikte om de grenzen van grootschalige transformatoren te verleggen.

Als u hulp nodig heeft bij het versnellen van uw gebruik van ML in uw producten en processen, neem dan contact op met de Amazon ML Solutions-lab.

Over de auteurs

Sia Gholami is Senior Data Scientist bij het Amazon ML Solutions Lab, waar hij AI/ML-oplossingen bouwt voor klanten in verschillende sectoren. Hij is gepassioneerd door natuurlijke taalverwerking (NLP) en deep learning. Naast haar werk brengt Sia graag tijd door in de natuur en speelt ze graag tennis.

Mehdi Nooriis een Manager en Senior Applied Scientist bij het Amazon ML Solutions Lab, waar hij samenwerkt met klanten in verschillende sectoren, en hen helpt hun cloudmigratietraject te versnellen en hun ML-problemen op te lossen met behulp van state-of-the-art oplossingen en technologieën.

Muhyun Kim is data scientist bij Amazon Machine Learning Solutions Lab. Hij lost de verschillende zakelijke problemen van klanten op door machine learning en deep learning toe te passen, en helpt hen ook om vaardig te worden.

Danny Byrd is een Applied Scientist bij het Amazon ML Solutions Lab. In het lab hielp hij klanten bij het ontwikkelen van geavanceerde ML-oplossingen, in ML-specialiteiten van computervisie tot versterkend leren. Hij is gepassioneerd over het vooruithelpen van technologie en het ontsluiten van nieuwe mogelijkheden van AWS-producten.

Francisco Calderón Rodriguez is een datawetenschapper in het Amazon ML Solutions Lab. Als lid van het ML Solutions Lab helpt hij bij het oplossen van kritieke bedrijfsproblemen voor AWS-klanten met behulp van deep learning. In zijn vrije tijd speelt Francisco graag muziek en gitaar, voetbalt hij met zijn dochters en geniet hij van tijd met zijn gezin.

Johei Nakayama is een Deep Learning Architect bij het Amazon ML Solutions Lab. Hij werkt met klanten in verschillende branches om hun gebruik van kunstmatige intelligentie en AWS Cloud-services te versnellen om hun zakelijke uitdagingen op te lossen. Hij is geïnteresseerd in het toepassen van ML/AI-technologieën in de ruimtevaartindustrie.

Nathalie Rauschmayr is Senior Applied Scientist bij AWS, waar ze klanten helpt bij het ontwikkelen van deep learning-applicaties.

• Coinsmart. Europa's beste Bitcoin- en crypto-uitwisseling.
• Platoblockchain. Web3 Metaverse Intelligentie. Kennis versterkt. GRATIS TOEGANG.
• CryptoHawk. Altcoin-radar. Gratis proefversie.
• Bron: https://aws.amazon.com/blogs/machine-learning/create-train-and-deploy-a-billion-parameter-language-model-on-terabytes-of-data-with-tensorflow-and- amazon-saliemaker/