TensorFlow ve Amazon SageMaker ile terabaytlarca veri üzerinde milyar parametreli bir dil modeli oluşturun, eğitin ve devreye alın

Dil modellerinin artan boyutu, son yıllarda doğal dil işlemedeki (NLP) en büyük trendlerden biri olmuştur. 2018'den bu yana, BERT ve türevleri, GPT-2, T-NLG ve GPT-3 (175 milyar parametre) dahil olmak üzere her zamankinden daha büyük dil modellerinin benzeri görülmemiş bir şekilde geliştirildiğini ve devreye alındığını gördük.

Bu modeller, olası mimari yeniliklerin sınırlarını zorladı. Büyük ölçekli derin öğrenme modellerini eğitirken, özellikle yeni nesil önceden eğitilmiş transformatörler dalgasıyla, çeşitli zorluklarla karşılaşıyoruz. Bu zorluklar, donanım sınırlamalarını ve hesaplama ve verimlilikle ilgili ödünleri içerir. AWS, model ve veri paralelliğine ilişkin bu zorlukların üstesinden gelmek için çok çeşitli yetenekler sunar.

Bu yazıda, iki ana yaklaşımı tanıtıyoruz: veri paralelleştirme ve kullanarak model paralelleştirme Amazon Adaçayı Yapıcıve artılarını ve eksilerini tartışın.

model

Dil modeli için, makalede tanıtılan Transformers'ı kullanıyoruz. Dikkat İhtiyacınız Olan Her Şey. Transformatörler, girdi ve çıktı arasında küresel bağımlılıklar çekmek için bir öz-dikkat mekanizmasına güvenerek RNN'lerin tuzaklarından kasten kaçınmak için tasarlanmış derin öğrenme modelleridir. Transformer model mimarisi, önemli ölçüde daha iyi paralelleştirmeye izin verir ve nispeten kısa eğitim süresinde yüksek performans elde edebilir. Transformers'ın başarısı üzerine inşa edilen BERT, makalede tanıtılmıştır. BERT: Dil Anlayışı İçin Derin Çift Yönlü Transformatörlerin Ön Eğitimi, dil gösterimi için çift yönlü ön eğitim eklendi. Cloze görevinden ilham alan BERT, modelin rastgele maskelenmiş belirteçler için orijinal kelimeleri kurtarmayı öğrendiği maskeli dil modellemesi (MLM) ile önceden eğitilmiştir. BERT modeli ayrıca, iki cümlenin doğru okuma sırasında olup olmadığını tahmin etmek için bir sonraki cümle tahmini (NSP) görevi üzerinde önceden eğitilmiştir. 2018'deki gelişinden bu yana, BERT ve varyasyonları dil modellerinde yaygın olarak kullanılmaktadır.

Belirteç ve konumsal gömme için iki gömme katmanı oluşturarak başlıyoruz. Giriş gömmeleri, belirteç gömmelerinin ve konum gömmelerinin toplamıdır.

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

Ardından, iki alt katmana sahip bir transformatör kod çözücü bloğu tanımlarız: çok kafalı öz-dikkat katmanı ve basit, tam bağlantılı ileri beslemeli ağ, ardından katman normalizasyonu ve bırakma:

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)

Son olarak, önceki gömme katmanı ve dönüştürücü blokları ile dil modelimizi oluşturuyoruz:

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

Hiper parametrelerinize bağlı olarak, bu modeli binlerce parametreden milyarlarca parametreye kadar ölçeklendirebilirsiniz. Milyar parametreli modellerle ilgili birincil zorluk, modeli tek bir örnekte barındıramamanız ve modeli eğitim ve çıkarım için birkaç düğüme dağıtmanız gerekmesidir.

Veri kümesi

Deneylerimizde kullandığımız yığın veri seti. Pile, büyük ölçekli dil modellerini eğitmek için tasarlanmış 800 GiB İngilizce metin veri kümesidir. Hem yerleşik NLP veri kümeleri hem de yeni tanıtılanlar dahil olmak üzere 22 farklı ve yüksek kaliteli veri kümesinden oluşturulmuştur.

Veri kümesi, kitaplar da dahil olmak üzere çeşitli veri kaynaklarından oluşturulur; GitHub depoları; internet sayfaları; sohbet günlükleri; ve tıp, fizik, matematik, bilgisayar bilimi ve felsefe kağıtları. Spesifik olarak şu kaynakları kullanır: Pile-CC, PubMed Central, ArXiv, GitHub, FreeLaw Projesi, Stack Exchange, ABD Patent ve Ticari Marka Ofisi, PubMed, Ubuntu, IRC, HackerNews, YouTube, PhilPapers, Books3, Project Gutenberg ( PG-19), OpenSubtitles, English Wikipedia, DM Mathematics, EuroParl, Enron Emails corpus ve NIH ExPorter. Ayrıca, sırasıyla orijinal OpenWebText ve BookCorpus veri kümelerinin uzantıları olan OpenWebText2 ve BookCorpus2'yi içerir. Veri kaynaklarındaki çeşitlilik, genel alanlar arası bilgiyi geliştirebilir ve sonuç olarak aşağı yönlü genelleme yeteneklerini geliştirebilir.

Bu veri kümesiyle ilgili birincil zorluk, boyutun çok büyük olmasıdır; veri kümesinde 825 GiB metin bulunur ve bu, 4.2 TiB önceden işlenmiş ve sıkıştırılmış veri noktalarına dönüşür. Modelleri eğitme ve barındırma konusunda karşılaştığımız zorluklara benzer şekilde, bir modeli bu veri kümesiyle tek bir örnek üzerinde eğitmek çok zaman alacak ve pratik değil.

Çözümümüz, veri kümesini yaklaşık 1 GiB veri yığınına bölmek, özellikleri aşağıdakilere yüklemek ve önceden işlemek. TensorFlow Veri Kümesi nesneler ve bunları içinde saklayın Amazon Elastik Dosya Hizmeti (Amazon EFS). TensorFlow veri kümeleri, modellerimizle iyi bir şekilde bütünleşen, kullanımı kolay ve yüksek performanslı bir veri hattı sağlar. Amazon EFS, dosyalar eklendikçe ve silindikçe otomatik olarak ölçeklenen paylaşılan bir dosya sistemi oluşturmamızı sağlayan kullanımı kolay bir hizmettir. Buna ek olarak, Amazon EFS, veri ve model eğitim hattımızda kritik olan gerektiğinde daha yüksek aktarım hızı düzeylerine çıkabilir.

Ardından, bu zorlukların üstesinden gelmek için dağıtılmış eğitim stratejilerini inceliyoruz.

Dağıtılmış eğitim

Bu projede iki zorlukla karşılaştık: ölçekleme modeli boyutu ve veri hacmi. Model boyutunu ve eğitilebilir parametre sayısını artırmak daha iyi doğrulukla sonuçlanabilir, ancak tek bir örnekte tek bir GPU belleğine veya hatta birden çok GPU'ya sığdırabileceğiniz modelin bir sınırı vardır. Ayrıca, daha büyük model boyutlarının eğitilmesi daha fazla zaman alır.

Bu zorlukların üstesinden iki farklı şekilde gelebilirsiniz: veri paralelliği ve model paralelliği. Veri paralelliği ile eğitimi hızlandırmak için bir mini partinin kayıtlarını farklı cihazlara dağıtarak Stokastik Gradient İniş (SGD) gerçekleştiriyoruz. Bununla birlikte, paralel veri eğitimi, tüm cihazlardan gelen gradyanlarla mini toplu gradyan ortalamasını hesaplamanın ekstra karmaşıklığı ile birlikte gelir. AllReduceeğitim kümesi büyüdükçe zorlaşan . Veri paralelliğini kullanırken, modeli ve tek bir veri noktasını bir cihaza (CPU veya GPU) sığdırabilmemiz gerekir, bu da deneylerimizde sınırlayıcı bir faktördür çünkü böyle büyük bir modelin boyutu tek GPU'nun belleğinden çok daha büyüktür. boyut.

Başka bir çözüm, modeli birden çok cihaza bölen model paralelliğini kullanmaktır. Model paralelliği, bir modeli birden fazla cihaz veya düğüm (GPU donanımlı örnekler gibi) arasında bölme ve GPU kullanımını en üst düzeye çıkarmak için modeli bu cihazlar arasında eğitmek için verimli bir ardışık düzen oluşturma sürecidir.

Veri paralelleştirme

Verileri paralel hale getirmek, birden çok GPU'ya veya dağıtılmış eğitime yönelik en yaygın yaklaşımdır. Verilerinizi gruplayabilir, birden fazla cihaza gönderebilir (her biri çoğaltılmış bir model barındırır), ardından sonuçları toplayabilirsiniz. Veri paralelleştirme için iki paket denedik: Horovod ve SageMaker dağıtılmış veri paralel kitaplığı.

Horovod, TensorFlow, Keras, PyTorch ve Apache MXNet için dağıtılmış bir derin öğrenme eğitim çerçevesidir. Horovod'u kullanmak için aşağıdaki süreçten geçtik:

1. Çalıştırarak başlat hvd.init().
2. Her cihazı tek bir işlemle ilişkilendirin. Birinci süreç veya çalışan birinci aygıtla ilişkilendirilir, ikinci süreç ikinci aygıtla ilişkilendirilir ve bu böyle devam eder.
3. Cihaz sayısına göre öğrenme oranını ayarlayın.
4. Optimize ediciyi içine sarın hvd.DistributedOptimizer.
5. 0 dereceli ilk çalışandan ilk değişken durumlarını diğer tüm süreçlere yayınlayın. Bu, eğitim rastgele ağırlıklarla başlatıldığında veya bir kontrol noktasından geri yüklendiğinde tüm çalışanların tutarlı bir şekilde başlatılmasını sağlamak için gereklidir.
6. Diğer çalışanların onları bozmasını önlemek için yalnızca 0 cihazının kontrol noktalarını kaydedebildiğinden emin olun.

Aşağıdaki eğitim komut dosyasıdır:

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)

SageMaker veri paralel kitaplığı, eğitimimizi doğrusala yakın bir verimlilikle ölçeklendirmemizi sağlar ve minimum kod değişikliği ile eğitimimizi hızlandırır. Kütüphane özel bir işlem gerçekleştirir AllReduce AWS'nin ağ altyapısından tam olarak yararlanarak cihazdan cihaza iletişimi optimize eder ve Amazon Elastik Bilgi İşlem Bulutu (Amazon EC2) örnek topolojisi. SageMaker veri paralel kitaplığını kullanmak için aşağıdaki süreçten geçtik:

1. İçe aktar ve başlat sdp.init().
2. Her cihazı tek bir cihazla ilişkilendirin smdistributed.dataparallel ile işlem local_rank. sdp.tensorflow.local_rank() bize cihazların yerel sıralamasını verir. Lider sıra 0 ve işçiler sıra 1, 2, 3 vb.
3. Cihaz sayısına göre öğrenme oranını ayarlayın.
4. Şal tf.GradientTape ile DistributedGradientTape gerçekleştirmek AllReduce.
5. İlk model değişkenlerini lider düğümden tüm çalışan düğümlere yayınlayın.
6. Yalnızca 0 cihazının kontrol noktalarını kaydedebildiğinden emin olun.

Model paralelleştirme

Modeli tek bir GPU kullanarak eğitmek için yeterince küçük tutmak için hiperparametreleri ayarlayabilir veya modeli birden çok örneğe birden çok GPU arasında bölmek için model paralelliğini kullanabiliriz. Bir modelin eğitilebilir parametre sayısını artırmak, daha iyi doğrulukla sonuçlanabilir, ancak tek bir GPU belleğine sığdırabileceğiniz maksimum model boyutunun bir sınırı vardır. Daha büyük modellerimizi eğitmek için SageMaker dağıtılmış model paralel kitaplığını kullandık. Adımlar aşağıdaki gibidir:

1. Kitaplığı içe aktarın ve şununla başlatın: smp.init().
2. Keras modelinin, Keras Model sınıfı yerine smp.DistributedModel'den devralması gerekir.
3. set drop_remainder=True içinde tf.Dataset.batch() Parti boyutunun her zaman mikro partilerin sayısına bölünebilmesini sağlamak için yöntem.
4. Veri hattındaki rastgele işlemlerin hepsinin aynı tohumu kullanması gerekir: smp.dp_rank()Örneğin, shuffle(ds, seed=smp.dp_rank()). Bu, farklı model bölümlerine sahip cihazlar arasında veri örneklerinin tutarlılığını sağlar.
5. İleri ve geri mantığın bir adım işlevinde olması gerekir. smp.step dekorasyon.
6. Aşağıdaki gibi StepOutput yöntemlerini kullanarak mikro yığınlar arasında çıktılar üzerinde son işleme gerçekleştirin. reduce_mean. smp.step fonksiyonun çıktısına bağlı olan bir dönüş değeri olmalıdır. smp.DistributedModel.

Eğitim komut dosyası aşağıdaki gibidir:

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) 

SageMaker dağıtılmış model paralel kitaplığı için TensorFlow eğitim komut dosyasını etkinleştirmeye yönelik ayrıntılı bir kılavuz için bkz. TensorFlow Eğitim Komut Dosyasını Değiştirin. PyTorch için bkz. PyTorch Eğitim Komut Dosyasını Değiştirin.

SageMaker Hata Ayıklayıcı

Önceki bölümlerde, model ve veri paralelleştirme tekniklerini kullanarak eğitimin nasıl optimize edileceğini tartıştık. İle birlikte Amazon SageMaker Hata Ayıklayıcısı, artık eğitimin ne kadar geliştiğini belirlemek için eğitim çalıştırmalarımızdan performans profili oluşturma bilgilerini yakalayabiliriz. Varsayılan olarak Hata Ayıklayıcı, GPU, CPU kullanımı, bellek, ağ ve G/Ç gibi her SageMaker eğitim işi için sistem ölçümlerini 500 milisaniyelik bir örnekleme aralığında yakalar. Verilere şu şekilde erişebiliriz:

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

Hata ayıklayıcı aşağıdakilere yardımcı programlar sağlar: görselleştirmek profil oluşturma verileri farklı şekillerde. Aşağıdaki örnekte, Horovod kullanan çoklu GPU eğitim işi için toplam GPU ve CPU kullanımının yanı sıra G/Ç bekleme süresini görüyoruz. Bu grafikleri oluşturmak için aşağıdaki kodu çalıştırıyoruz:

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 kullanımı sıklıkla %0-100 arasında dalgalanır ve düşük GPU kullanımıyla yüksek G/Ç bekleme süreleri bir G/Ç darboğazının göstergesidir. Ayrıca, toplam CPU kullanımı hiçbir zaman %70'i geçmez; bu, çalışan işlemlerin sayısını artırarak veri ön işlemeyi iyileştirebileceğimiz anlamına gelir.

Horovod'dan SageMaker dağıtılmış veri paralel kitaplığına geçerek performansı iyileştirebiliriz. Aşağıdaki grafiklerde GPU'ların daha verimli kullanıldığını ve yalnızca kısa süreliğine düşük kullanıma düştüğünü görebiliriz.

Eğitim altyapısı

Modelleri eğitmek için bir SageMaker eğitim işi kullanarak 10 ml.p3.16xlarge örnekleri kullandık. SageMaker, altyapıyı yönetmeye gerek kalmadan makine öğrenimi (ML) modellerini eğitmek ve ayarlamak için gereken zamanı ve maliyeti azaltır. SageMaker ile eğitim deneylerini yönetmek ve izlemek, otomatik olarak en uygun hiper parametreleri seçmek, eğitim işlerinde hata ayıklamak ve GPU'lar, CPU'lar ve ağ bant genişliği gibi sistem kaynaklarının kullanımını izlemek için yerleşik araçları kullanarak makine öğrenimi modellerini kolayca eğitebilir ve ayarlayabilirsiniz. Veriler Amazon EFS'de barındırıldı ve bu, yönetim veya tedarik gerektirmeden dosya ekleyip kaldırdıkça büyümemizi ve küçülmemizi sağladı. Öncelikli hedeflerimiz eğitim hızını artırmak ve maliyetleri azaltmaktı.

Model ölçeklenebilirliği

Bu altyapı öncelikle GPT mimarisi ve Pile veri seti ile dil üretimi için kullanılsa da, bu teknikleri NLP'nin ötesinde birçok alanda faydalı olan büyük ölçekli transformatör modellerini eğitmek için kullanabilirsiniz. Makine öğreniminin kendisinde, birçok bilgisayarla görme görevi, temsil öğrenimi gibi görevlerde geleneksel CNN'lerden (Evrişimli Sinir Ağı) daha iyi performans gösterdikleri gösterilmiş olan büyük parametreli (transformatör) mimarilerle çözülmektedir (bkz. Kendi kendini denetleyen Transformatörler ve 10 kat daha verimli eğitim ile bilgisayar vizyonunda en son teknolojiyi geliştirmek) ve görüntülerin metne büyük ölçekli eşlenmesi (örneğin CLIP). Büyük parametreli modeller, yaşam bilimlerinde aşağıdaki gibi alanlarda da çığır açmaktadır: protein yapı analizi ve tıbbi görüntü verilerinin analizi.

Dağıtılmış eğitim ve büyük modelleri yönetmek için bu gönderide detaylandırdığımız çözümler, bu alanların herhangi birindeki modeller için de geçerli olmalıdır.

Ticaret-off

Araştırma topluluğunda, büyük ölçekli dil modellerinin eğitiminin riskleri ve bunların geliştirilmesiyle ilgili potansiyel riskler ve bu riskleri hafifletmek için stratejiler üzerinde yeterince düşünülüp düşünülmediği, bunlardan bazıları finansal ve çevresel maliyetler. göre kâğıt ACM'de yayınlanan, GPU'larda tek bir BERT temel modelinin (hiperparametre ayarı olmadan) eğitiminin, bir trans-Amerikan uçuşu kadar enerji gerektirdiği tahmin ediliyordu. Çevresel etkiler, model boyutuna göre ölçeklenir ve bu tür modellerde verimli bir şekilde ince ayar yapabilmek, emisyonları potansiyel olarak önemli ölçüde azaltabilir. AWS kısa süre önce yeni bir Müşteri Karbon Ayak İzi Aracı, Amazon'un sürdürülebilirliği artırma ve karbon emisyonlarını azaltma çabalarının bir parçası olarak tüm AWS müşterilerine ücretsiz olarak sunulmaktadır. Uygulamaların AWS Bulut üzerinde çalıştırılması, karbon ayak izini potansiyel olarak azaltabilir (şu anda ankete katılan kurumsal veri merkezleriyle karşılaştırıldığında). bir 2019 raporu).

Sonuç

Bu gönderi, SageMaker kullanarak AWS Cloud'da bir milyar parametreyle dil modellerinin ince ayarını kolaylaştıran bir çözümü gösterdi.

SageMaker ile model paralelliği hakkında daha fazla bilgi için bkz. Amazon SageMaker'da paralel model eklemeleri ve Hugging Face ile 175 milyardan fazla parametreli NLP modelini eğitin ve Latent Space, büyük ölçekli transformatörlerin sınırlarını zorlamak için Amazon SageMaker model paralellik kitaplığını nasıl kullandı?.

Ürünlerinizde ve süreçlerinizde makine öğrenimi kullanımınızı hızlandırmak için yardıma ihtiyacınız varsa, lütfen şurayla iletişime geçin: Amazon ML Çözümleri Laboratuvarı.

Yazarlar Hakkında

Sia Gholami Çeşitli sektörlerdeki müşteriler için AI/ML çözümleri oluşturduğu Amazon ML Çözümleri Laboratuvarı'nda Kıdemli Veri Bilimcisi olarak görev yapmaktadır. Doğal dil işleme (NLP) ve derin öğrenme konusunda tutkulu. Sia, iş dışında doğada vakit geçirmeyi ve tenis oynamayı sever.

Mehdi NuriAmazon ML Çözümleri Laboratuvarı'nda Yönetici ve Kıdemli Uygulamalı Bilim Adamıdır, burada çeşitli sektörlerdeki müşterilerle birlikte çalışır ve buluta geçiş yolculuklarını hızlandırmalarına ve ML sorunlarını son teknoloji çözümler ve kullanarak çözmelerine yardımcı olur. teknolojiler.

Muhyun Kim Amazon Machine Learning Solutions Lab'de bir veri bilimcisi. Makine öğrenimi ve derin öğrenmeyi uygulayarak müşterinin çeşitli iş sorunlarını çözer ve ayrıca yetenekli olmalarına yardımcı olur.

Danny Byrd Amazon ML Çözümleri Laboratuvarı'nda Uygulamalı Bilim Adamıdır. Laboratuarda, müşterilerin bilgisayar vizyonundan pekiştirici öğrenmeye kadar makine öğrenimi uzmanlıklarında gelişmiş makine öğrenimi çözümleri geliştirmelerine yardımcı oldu. Teknolojiyi ilerletmek ve yol boyunca AWS ürünlerinden yeni potansiyeller ortaya çıkarmak konusunda tutkulu.

Francisco Calderon Rodriguez Amazon ML Çözümleri Laboratuvarı'nda bir Veri Bilimcisidir. ML Solutions Lab'ın bir üyesi olarak, derin öğrenmeyi kullanan AWS müşterilerinin kritik iş sorunlarının çözülmesine yardımcı olur. Francisco boş zamanlarında müzik ve gitar çalmayı, kızlarıyla futbol oynamayı ve ailesiyle vakit geçirmeyi seviyor.

Yohei Nakayama Amazon ML Çözümleri Laboratuvarı'nda Derin Öğrenme Mimarıdır. İş zorluklarını çözmek için yapay zeka ve AWS Bulut hizmetlerini kullanmalarını hızlandırmak için farklı sektörlerde müşterilerle birlikte çalışır. ML/AI teknolojilerini uzay endüstrisine uygulamakla ilgileniyor.

Nathalie Rauschmayr AWS'de Kıdemli Uygulamalı Bilim Adamıdır ve müşterilerin derin öğrenme uygulamaları geliştirmesine yardımcı olur.

• Akıllı para. Avrupa'nın En İyi Bitcoin ve Kripto Borsası.
• Plato blok zinciri. Web3 Metaverse Zekası. Bilgi Güçlendirildi. SERBEST ERİŞİM.
• KriptoHawk. Altcoin Radarı. Ücretsiz deneme.
• Kaynak: 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/