Skapa, träna och distribuera en språkmodell med miljarder parametrar på terabyte data med TensorFlow och Amazon SageMaker

Den ökande storleken på språkmodeller har varit en av de största trenderna inom naturlig språkbehandling (NLP) de senaste åren. Sedan 2018 har vi sett en aldrig tidigare skådad utveckling och distribution av allt större språkmodeller, inklusive BERT och dess varianter, GPT-2, T-NLG och GPT-3 (175 miljarder parametrar).

Dessa modeller har flyttat fram gränserna för möjliga arkitektoniska innovationer. Vi står inför flera utmaningar när vi tränar storskaliga modeller för djupinlärning, särskilt den nya vågen av generativa förtränade transformatorer. Dessa utmaningar inkluderar hårdvarubegränsningar och avvägningar med beräkning och effektivitet. För att övervinna dessa utmaningar med modell- och dataparallellism erbjuder AWS ett brett utbud av möjligheter.

I det här inlägget introducerar vi två huvudsakliga tillvägagångssätt: dataparallellisering och modellparallellisering med hjälp av Amazon SageMakeroch diskutera deras för- och nackdelar.

Modellen

För språkmodellen använder vi Transformers, introducerade i tidningen Uppmärksamhet är allt du behöver. Transformatorer är modeller för djupinlärning utformade för att medvetet undvika fallgroparna i RNN:er genom att förlita sig på en självuppmärksamhetsmekanism för att skapa globala beroenden mellan input och output. Transformers modellarkitektur möjliggör betydligt bättre parallellisering och kan uppnå hög prestanda på relativt kort träningstid. Byggd på framgången med Transformers, BERT, som introducerades i tidningen BERT: Förutbildning av Deep Bidirectional Transformers för språkförståelse, lagt till dubbelriktad förträning för språkrepresentation. Inspirerad av Cloze-uppgiften är BERT förtränad med masked language modeling (MLM), där modellen lär sig att återställa originalorden för slumpmässigt maskerade tokens. BERT-modellen är också förtränad på nästa meningsprediktion (NSP) uppgift för att förutsäga om två meningar är i korrekt läsordning. Sedan dess tillkomst 2018 har BERT och dess varianter använts flitigt i språkmodeller.

Vi börjar med att skapa två inbäddningslager för token- och positionsinbäddning. Inmatningsinbäddningarna är summan av tokeninbäddningarna och positionsinbäddningarna.

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

Sedan definierar vi ett transformatoravkodarblock med två underskikt: ett självuppmärksamhetsskikt med flera huvuden och ett enkelt fullt anslutet framkopplingsnätverk följt av skiktnormalisering och bortfall:

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)

Slutligen skapar vi vår språkmodell med det föregående inbäddningsskiktet och transformatorblocken:

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

Beroende på dina hyperparametrar kan du skala den här modellen från tusentals parametrar till miljarder parametrar. Den primära utmaningen med miljardparametermodeller är att du inte kan vara värd för modellen i en instans och behöver fördela modellen över flera noder för träning och slutledning.

Datauppsättningen

I våra experiment använde vi Högdataset. The Pile är en 800 GiB engelsk textdatauppsättning designad för att träna storskaliga språkmodeller. Den är skapad av 22 olika och högkvalitativa datauppsättningar, inklusive både etablerade NLP-datauppsättningar och nyligen introducerade.

Datauppsättningen skapas från en mängd olika datakällor, inklusive böcker; GitHub-förråd; webbsidor; chattloggar; och uppsatser inom medicin, fysik, matematik, datavetenskap och filosofi. Specifikt använder den följande källor: 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, engelska Wikipedia, DM Mathematics, EuroParl, Enron Emails corpus och NIH ExPorter. Det inkluderar också OpenWebText2 och BookCorpus2, som är tillägg av de ursprungliga OpenWebText- respektive BookCorpus-datauppsättningarna. Mångfalden i datakällor kan förbättra den allmänna kunskapen över flera domäner och följaktligen förbättra nedströms generaliseringsförmåga.

Den primära utmaningen med denna datauppsättning är själva storleken; datasetet har 825 GiB text, vilket översätts till 4.2 TiB förbearbetade och komprimerade datapunkter. I likhet med de utmaningar vi står inför med att träna och vara värd för modellerna, kommer att träna en modell med denna datauppsättning på en enda instans ta mycket tid och är inte praktiskt.

Vår lösning är att dela upp datamängden i cirka 1 GiB data, ladda och förbearbeta funktionerna i TensorFlow Dataset föremål och förvara dem i Amazon Elastic File Service (Amazon EFS). TensorFlow-datauppsättningar ger en lättanvänd och högpresterande datapipeline som integreras väl med våra modeller. Amazon EFS är en lättanvänd tjänst som gör att vi kan bygga ett delat filsystem som skalas automatiskt när filer läggs till och tas bort. Dessutom kan Amazon EFS spricka till högre genomströmningsnivåer när det behövs, vilket är avgörande i vår data- och modellutbildningspipeline.

Därefter undersöker vi distribuerade utbildningsstrategier för att hantera dessa utmaningar.

Distribuerad utbildning

I det här projektet stod vi inför två utmaningar: skalning av modellstorlek och datavolym. Att öka modellstorleken och antalet inlärningsbara parametrar kan resultera i bättre noggrannhet, men det finns en gräns för modellen som du kan passa in i ett enda GPU-minne eller till och med flera GPU:er i en enda instans. Dessutom tar större modellstorlekar längre tid att träna.

Du kan tackla dessa utmaningar på två olika sätt: dataparallellism och modellparallellism. Med dataparallellism utför vi Stokastisk Gradient Descent (SGD) genom att distribuera posterna för en minibatch över olika enheter för att påskynda träningen. Men parallell dataträning kommer med extra komplexitet att beräkna mini-batch-gradientgenomsnitt med gradienter från alla enheter, ett steg som kallas AllReduce, vilket blir svårare när träningsklustret växer. När vi använder dataparallellism måste vi kunna passa in modellen och en enda datapunkt i en enhet (CPU eller GPU), vilket är en begränsande faktor i våra experiment eftersom storleken på en så stor modell är mycket större än den enstaka GPU:ns minne storlek.

En annan lösning är att använda modellparallellism, som delar upp modellen över flera enheter. Modellparallellism är processen att dela upp en modell mellan flera enheter eller noder (som GPU-utrustade instanser) och skapa en effektiv pipeline för att träna modellen över dessa enheter för att maximera GPU-användningen.

Dataparallellisering

Parallellisering av data är den vanligaste metoden för flera GPU:er eller distribuerad träning. Du kan batcha dina data, skicka dem till flera enheter (var och en med en replikerad modell) och sedan sammanställa resultaten. Vi experimenterade med två paket för dataparallellisering: Horovod och the SageMaker distribuerade dataparallellt bibliotek.

Horovod är ett distribuerat ramverk för djupinlärning för TensorFlow, Keras, PyTorch och Apache MXNet. För att använda Horovod gick vi igenom följande process:

1. Initiera genom att springa hvd.init().
2. Koppla varje enhet med en enda process. Den första processen eller arbetaren är associerad med den första enheten, den andra processen är associerad med den andra enheten och så vidare.
3. Justera inlärningshastigheten baserat på antalet enheter.
4. Slå in optimeraren hvd.DistributedOptimizer.
5. Sänd de initiala variabeltillstånden från den första arbetaren med rang 0 till alla andra processer. Detta är nödvändigt för att säkerställa konsekvent initiering av alla arbetare när träning påbörjas med slumpmässiga vikter eller återställs från en kontrollpunkt.
6. Se till att endast enhet 0 kan spara kontrollpunkter för att förhindra att andra arbetare korrumperar dem.

Följande är träningsmanuset:

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)

SageMakers dataparallellbibliotek gör det möjligt för oss att skala vår träning med nästan linjär effektivitet, vilket påskyndar vår träning med minimala kodändringar. Biblioteket utför en beställning AllReduce drift och optimerar enhet-till-enhet-kommunikation genom att fullt ut utnyttja AWS nätverksinfrastruktur och Amazon Elastic Compute Cloud (Amazon EC2) instanstopologi. För att använda SageMakers dataparallellbibliotek gick vi igenom följande process:

1. Importera och initiera sdp.init().
2. Associera varje enhet med en singel smdistributed.dataparallel bearbeta med local_rank. sdp.tensorflow.local_rank() ger oss den lokala rankningen av enheter. Ledaren är rang 0, och arbetare är rang 1, 2, 3, och så vidare.
3. Justera inlärningshastigheten baserat på antalet enheter.
4. Wrap tf.GradientTape med DistributedGradientTape att prestera AllReduce.
5. Sänd de initiala modellvariablerna från ledarnoden till alla arbetarnoderna.
6. Se till att endast enhet 0 kan spara kontrollpunkter.

Modellparallellisering

Vi kan justera hyperparametrarna för att hålla modellen tillräckligt liten för att träna med en enda GPU, eller så kan vi använda modellparallellism för att dela modellen mellan flera GPU:er över flera instanser. Att öka en modells antal inlärningsbara parametrar kan resultera i bättre noggrannhet, men det finns en gräns för den maximala modellstorleken du får plats i ett enda GPU-minne. Vi använde SageMakers distribuerade modell parallellbibliotek för att träna våra större modeller. Stegen är följande:

1. Importera och initiera biblioteket med smp.init().
2. Keras-modellen måste ärva från smp.DistributedModel istället för Keras Model-klassen.
3. uppsättning drop_remainder=True i tf.Dataset.batch() metod för att säkerställa att batchstorleken alltid är delbar med antalet mikrobatcher.
4. Slumpmässiga operationer i datapipeline behöver alla använda samma frö: smp.dp_rank(), Till exempel, shuffle(ds, seed=smp.dp_rank()). Detta säkerställer konsistens av dataprover över enheter som har olika modellpartitioner.
5. Framåt- och bakåtlogik måste vara i en stegfunktion med smp.step dekoration.
6. Utför efterbearbetning av utgångarna över mikrobatcher med StepOutput-metoder som t.ex reduce_mean. De smp.step funktion måste ha ett returvärde som beror på resultatet av smp.DistributedModel.

Träningsmanuset är som följer:

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) 

För en detaljerad guide för att aktivera TensorFlow-utbildningsskriptet för SageMakers distribuerade modell parallellbibliotek, se Ändra ett TensorFlow-träningsskript. För PyTorch, se Ändra ett PyTorch-träningsskript.

SageMaker-felsökare

I de föregående avsnitten diskuterade vi hur man kan optimera träningen med hjälp av modell- och dataparallelliseringstekniker. Med Amazon SageMaker Debugger, kan vi nu fånga upp prestationsprofileringsinformation från våra träningskörningar för att avgöra hur mycket träningen har förbättrats. Som standard fångar Debugger systemstatistik för varje SageMaker-utbildningsjobb som GPU, CPU-användning, minne, nätverk och I/O med ett samplingsintervall på 500 millisekunder. Vi kan komma åt uppgifterna enligt följande:

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 tillhandahåller verktyg för att visualisera profileringsuppgifterna på olika sätt. I följande exempel ser vi den totala GPU- och CPU-användningen samt I/O-väntetiden för träningsjobbet med flera GPU med Horovod. För att generera dessa grafer kör vi följande kod:

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 )

GPU-användningen varierar ofta mellan 0–100 %, och höga I/O-väntetider med låg GPU-användning är en indikator på en I/O-flaskhals. Dessutom överstiger det totala CPU-utnyttjandet aldrig 70 %, vilket innebär att vi kan förbättra dataförbearbetningen genom att öka antalet arbetsprocesser.

Vi kan förbättra prestandan genom att byta från Horovod till SageMakers distribuerade dataparallellbibliotek. I följande grafer kan vi se att GPU:er används mer effektivt och bara sjunker till lågt utnyttjande under korta tidsperioder.

Utbildningsinfrastruktur

För att träna modellerna använde vi 10 ml.p3.16xlarge instanser med ett SageMaker-träningsjobb. SageMaker minskar tiden och kostnaderna för att träna och trimma modeller för maskininlärning (ML) utan att behöva hantera infrastruktur. Med SageMaker kan du enkelt träna och ställa in ML-modeller med hjälp av inbyggda verktyg för att hantera och spåra träningsexperiment, automatiskt välja optimala hyperparametrar, felsöka träningsjobb och övervaka utnyttjandet av systemresurser som GPU:er, CPU:er och nätverksbandbredd. Data var värd i Amazon EFS, vilket gjorde det möjligt för oss att växa och krympa när vi lägger till och tar bort filer utan behov av hantering eller provisionering. Våra primära mål var att förbättra träningshastigheten och minska kostnaderna.

Modellens skalbarhet

Även om den här infrastrukturen främst används för språkgenerering, med GPT-arkitekturen och Pile-dataset, kan du använda dessa tekniker för att träna storskaliga transformatormodeller, vilket är användbart inom många områden bortom NLP. I själva maskininlärningen löses nu många datorseendeuppgifter med arkitekturer med stora parametrar (transformatorer) där de har visat sig överträffa traditionella CNN:er (Convolutional Neural Network) på uppgifter som representationsinlärning (se Avancera det senaste inom datorseende med självövervakade transformatorer och 10 gånger effektivare träning) och storskalig kartläggning av bilder till text (som t.ex KLÄMMA). Modeller med stora parametrar bryter också ny mark inom life science inom områden som analys av proteinstruktur och analys av medicinska bilddata.

Lösningarna som vi beskriver i det här inlägget för distribuerad utbildning och hantering av stora modeller bör också gälla modeller inom någon av dessa domäner.

Avvägningar

Det har pågått en diskussion i forskarvärlden om riskerna med att träna storskaliga språkmodeller, och om man har tänkt tillräckligt på de potentiella riskerna med att utveckla dem och strategier för att mildra dessa risker, av vilka några inkluderar de ekonomiska och miljökostnader. Enligt a papper publicerad i ACM beräknades att träna en enda BERT-basmodell (utan hyperparameterjustering) på GPU:er kräva lika mycket energi som en transamerikansk flygning. Miljöpåverkan skalar med modellstorlek, och att effektivt kunna finjustera sådana modeller kan potentiellt minska utsläppen avsevärt. AWS lanserade nyligen en ny Customer Carbon Footprint Tool, tillgängligt för alla AWS-kunder utan kostnad, som en del av Amazons ansträngningar att öka hållbarheten och minska koldioxidutsläppen. Att köra applikationer på AWS Cloud kan potentiellt minska koldioxidavtrycket (jämfört med företagsdatacenter som undersöktes i en 2019-rapport).

Slutsats

Det här inlägget demonstrerade en lösning som underlättar finjusteringen av språkmodeller med en miljard parametrar på AWS-molnet med SageMaker.

För mer information om modellparallellism med SageMaker, se Träna 175+ miljarder NLP-parametermodeller med parallella modelltillägg och Hugging Face på Amazon SageMaker och Hur Latent Space använde Amazon SageMaker-modellens parallellbibliotek för att skjuta gränserna för storskaliga transformatorer.

Om du vill ha hjälp med att påskynda din användning av ML i dina produkter och processer, vänligen kontakta Amazon ML Solutions Lab.

Om författarna

Sia Gholami är Senior Data Scientist på Amazon ML Solutions Lab, där han bygger AI/ML-lösningar för kunder inom olika branscher. Han brinner för naturlig språkbehandling (NLP) och djupinlärning. Utanför jobbet tycker Sia om att spendera tid i naturen och spela tennis.

Mehdi Nooriär chef och senior tillämpad forskare på Amazon ML Solutions Lab, där han arbetar med kunder inom olika branscher och hjälper dem att påskynda sin molnmigreringsresa och att lösa sina ML-problem med hjälp av toppmoderna lösningar och tekniker.

Muhyun Kim är datavetare vid Amazon Machine Learning Solutions Lab. Han löser kundens olika affärsproblem genom att använda maskininlärning och djupinlärning, och hjälper dem också att bli skickliga.

Danny Byrd är en tillämpad forskare vid Amazon ML Solutions Lab. På labbet har han hjälpt kunder att utveckla avancerade ML-lösningar, inom ML-specialiteter från datorseende till förstärkningsinlärning. Han brinner för att driva teknik framåt och låsa upp ny potential från AWS-produkter längs vägen.

Francisco Calderon Rodriguez är en dataforskare i Amazon ML Solutions Lab. Som medlem i ML Solutions Lab hjälper han till att lösa kritiska affärsproblem för AWS-kunder med hjälp av djupinlärning. På fritiden gillar Francisco att spela musik och gitarr, spela fotboll med sina döttrar och njuta av tid med sin familj.

Yohei Nakayama är en Deep Learning Architect vid Amazon ML Solutions Lab. Han arbetar med kunder över olika vertikaler för att påskynda deras användning av artificiell intelligens och AWS Cloud-tjänster för att lösa deras affärsutmaningar. Han är intresserad av att tillämpa ML/AI-teknologier på rymdindustrin.

Nathalie Rauschmayr är Senior Applied Scientist på AWS, där hon hjälper kunder att utveckla applikationer för djupinlärning.

• Myntsmart. Europas bästa bitcoin- och kryptobörs.
• Platoblockchain. Web3 Metaverse Intelligence. Kunskap förstärkt. FRI TILLGÅNG.
• CryptoHawk. Altcoin radar. Gratis provperiod.
• Källa: 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/