Buat, latih, dan terapkan model bahasa miliar-parameter pada terabyte data dengan TensorFlow dan Amazon SageMaker

Meningkatnya ukuran model bahasa telah menjadi salah satu tren terbesar dalam pemrosesan bahasa alami (NLP) dalam beberapa tahun terakhir. Sejak 2018, kami telah melihat pengembangan dan penerapan model bahasa yang lebih besar yang belum pernah terjadi sebelumnya, termasuk BERT dan variannya, GPT-2, T-NLG, dan GPT-3 (175 miliar parameter).

Model-model ini telah mendorong batas-batas kemungkinan inovasi arsitektur. Kami menghadapi beberapa tantangan saat melatih model pembelajaran mendalam skala besar, terutama gelombang baru transformator pra-pelatihan generatif. Tantangan ini mencakup keterbatasan perangkat keras dan kompromi dengan komputasi dan efisiensi. Untuk mengatasi tantangan model dan paralelisme data ini, AWS menawarkan berbagai kemampuan.

Dalam posting ini, kami memperkenalkan dua pendekatan utama: paralelisasi data dan paralelisasi model menggunakan Amazon SageMaker, dan mendiskusikan pro dan kontra mereka.

Model

Untuk model bahasa, kami menggunakan Transformers, yang diperkenalkan di makalah Perhatian Yang Anda Butuhkan. Transformer adalah model pembelajaran mendalam yang dirancang untuk secara sengaja menghindari jebakan RNN dengan mengandalkan mekanisme perhatian-diri untuk menarik ketergantungan global antara input dan output. Arsitektur model Transformer memungkinkan paralelisasi yang jauh lebih baik dan dapat mencapai kinerja tinggi dalam waktu pelatihan yang relatif singkat. Dibangun di atas kesuksesan Transformers, BERT, diperkenalkan di koran BERT: Pra-pelatihan Transformers Dua Arah Dalam untuk Pemahaman Bahasa, menambahkan pra-pelatihan dua arah untuk representasi bahasa. Terinspirasi oleh tugas Cloze, BERT telah dilatih sebelumnya dengan pemodelan bahasa bertopeng (MLM), di mana model belajar untuk memulihkan kata-kata asli untuk token yang disamarkan secara acak. Model BERT juga dilatih pada tugas prediksi kalimat (NSP) berikutnya untuk memprediksi apakah dua kalimat berada dalam urutan bacaan yang benar. Sejak kemunculannya pada tahun 2018, BERT dan variasinya telah banyak digunakan dalam model bahasa.

Kita mulai dengan membuat dua lapisan penyematan untuk penyematan token dan posisi. Penyematan input adalah jumlah penyematan token dan penyematan posisi.

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

Kemudian kami mendefinisikan blok dekoder transformator dengan dua sub-lapisan: lapisan self-attention multi-head, dan jaringan feed-forward sederhana yang terhubung penuh diikuti dengan normalisasi dan dropout lapisan:

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)

Akhirnya, kami membuat model bahasa kami dengan lapisan penyematan dan blok transformator sebelumnya:

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

Bergantung pada hyperparameter Anda, Anda dapat menskalakan model ini dari ribuan parameter hingga miliaran parameter. Tantangan utama dengan model miliaran parameter adalah Anda tidak dapat meng-host model dalam satu instance dan perlu mendistribusikan model ke beberapa node untuk pelatihan dan inferensi.

Dataset

Dalam percobaan kami, kami menggunakan Kumpulan data tumpukan. The Pile adalah kumpulan data teks bahasa Inggris 800 GiB yang dirancang untuk melatih model bahasa skala besar. Itu dibuat dari 22 kumpulan data yang beragam dan berkualitas tinggi, termasuk kumpulan data NLP yang sudah ada dan yang baru diperkenalkan.

Dataset dibuat dari berbagai sumber data, termasuk buku; repositori GitHub; Halaman web; log obrolan; dan makalah medis, fisika, matematika, ilmu komputer, dan filsafat. Secara khusus, ia menggunakan sumber-sumber berikut: Pile-CC, PubMed Central, ArXiv, GitHub, Proyek FreeLaw, Stack Exchange, Kantor Paten dan Merek Dagang AS, PubMed, Ubuntu, IRC, HackerNews, YouTube, PhilPapers, Books3, Project Gutenberg ( PG-19), OpenSubtitles, Wikipedia bahasa Inggris, Matematika DM, EuroParl, korpus Email Enron, dan NIH ExPorter. Ini juga mencakup OpenWebText2 dan BookCorpus2, yang merupakan ekstensi dari dataset OpenWebText dan BookCorpus asli, masing-masing. Keragaman sumber data dapat meningkatkan pengetahuan lintas domain umum dan akibatnya meningkatkan kemampuan generalisasi hilir.

Tantangan utama dengan dataset ini adalah ukurannya yang tipis; kumpulan data memiliki 825 GiB teks, yang diterjemahkan menjadi 4.2 TiB titik data yang telah diproses sebelumnya dan dikompresi. Serupa dengan tantangan yang kita hadapi dalam melatih dan menghosting model, melatih model dengan kumpulan data ini pada satu instans akan memakan banyak waktu dan tidak praktis.

Solusi kami adalah memecah set data menjadi sekitar 1 GiB potongan data, memuat dan memproses fitur sebelumnya di Kumpulan Data TensorFlow objek, dan menyimpannya di Layanan File Amazon Elastis (Amazon EFS). Set data TensorFlow menyediakan pipeline data yang mudah digunakan dan berperforma tinggi yang terintegrasi dengan baik dengan model kami. Amazon EFS adalah layanan yang mudah digunakan yang memungkinkan kami membangun sistem file bersama yang diskalakan secara otomatis saat file ditambahkan dan dihapus. Selain itu, Amazon EFS mampu melonjak ke tingkat throughput yang lebih tinggi saat dibutuhkan, yang sangat penting dalam alur pelatihan data dan model kami.

Selanjutnya, kami melihat strategi pelatihan terdistribusi untuk mengatasi tantangan ini.

Pelatihan yang didistribusikan

Dalam proyek ini, kami menghadapi dua tantangan: penskalaan ukuran model dan volume data. Meningkatkan ukuran model dan jumlah parameter yang dapat dilatih dapat menghasilkan akurasi yang lebih baik, tetapi ada batasan untuk model yang dapat Anda masukkan ke dalam satu memori GPU atau bahkan beberapa GPU dalam satu instans. Selain itu, ukuran model yang lebih besar membutuhkan lebih banyak waktu untuk dilatih.

Anda dapat mengatasi tantangan ini dengan dua cara berbeda: paralelisme data dan paralelisme model. Dengan paralelisme data, kami melakukan Stochastic Gradient Descent (SGD) dengan mendistribusikan catatan mini-batch melalui perangkat yang berbeda untuk mempercepat pelatihan. Namun, pelatihan data paralel hadir dengan kompleksitas ekstra komputasi rata-rata gradien mini-batch dengan gradien dari semua perangkat, langkah yang disebut AllReduce, yang menjadi lebih sulit saat kluster pelatihan berkembang. Saat menggunakan paralelisme data, kami harus dapat menyesuaikan model dan satu titik data dalam perangkat (CPU atau GPU), yang merupakan faktor pembatas dalam eksperimen kami karena ukuran model sebesar itu jauh lebih besar daripada memori GPU tunggal. ukuran.

Solusi lain adalah dengan menggunakan model paralelisme, yang membagi model ke beberapa perangkat. Paralelisme model adalah proses pemisahan model antara beberapa perangkat atau node (seperti instans yang dilengkapi GPU) dan membuat jalur yang efisien untuk melatih model di seluruh perangkat ini guna memaksimalkan pemanfaatan GPU.

Paralelisasi data

Memparalelkan data adalah pendekatan paling umum untuk beberapa GPU atau pelatihan terdistribusi. Anda dapat mengelompokkan data Anda, mengirimkannya ke beberapa perangkat (masing-masing menghosting model yang direplikasi), lalu menggabungkan hasilnya. Kami bereksperimen dengan dua paket untuk paralelisasi data: Horovod dan SageMaker mendistribusikan pustaka paralel data.

Horovod adalah framework pelatihan deep learning terdistribusi untuk TensorFlow, Keras, PyTorch, dan Apache MXNet. Untuk menggunakan Horovod, kami melalui proses berikut:

1. Inisialisasi dengan menjalankan hvd.init().
2. Kaitkan setiap perangkat dengan satu proses. Proses atau pekerja pertama dikaitkan dengan perangkat pertama, proses kedua dikaitkan dengan perangkat kedua, dan seterusnya.
3. Sesuaikan kecepatan pembelajaran berdasarkan jumlah perangkat.
4. Bungkus pengoptimal dalam hvd.DistributedOptimizer.
5. Menyiarkan status variabel awal dari pekerja pertama dengan peringkat 0 ke semua proses lainnya. Ini diperlukan untuk memastikan inisialisasi yang konsisten dari semua pekerja saat pelatihan dimulai dengan bobot acak atau dipulihkan dari pos pemeriksaan.
6. Pastikan hanya perangkat 0 yang dapat menyimpan pos pemeriksaan untuk mencegah pekerja lain merusaknya.

Berikut script pelatihannya:

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)

Pustaka paralel data SageMaker memungkinkan kami untuk menskalakan pelatihan kami dengan efisiensi hampir linier, mempercepat pelatihan kami dengan perubahan kode yang minimal. Perpustakaan melakukan kebiasaan AllReduce operasi dan mengoptimalkan komunikasi perangkat-ke-perangkat dengan sepenuhnya memanfaatkan infrastruktur jaringan AWS dan Cloud komputasi elastis Amazon (Amazon EC2) topologi instans. Untuk menggunakan pustaka paralel data SageMaker, kami melalui proses berikut:

1. Impor dan inisialisasi sdp.init().
2. Kaitkan setiap perangkat dengan satu smdistributed.dataparallel proses dengan local_rank. sdp.tensorflow.local_rank() memberi kita peringkat perangkat lokal. Pemimpin adalah peringkat 0, dan pekerja adalah peringkat 1, 2, 3, dan seterusnya.
3. Sesuaikan kecepatan pembelajaran berdasarkan jumlah perangkat.
4. Bungkus tf.GradientTape dengan DistributedGradientTape untuk melakukan AllReduce.
5. Siarkan variabel model awal dari node pemimpin ke semua node pekerja.
6. Pastikan hanya perangkat 0 yang dapat menyimpan pos pemeriksaan.

Paralelisasi model

Kita dapat menyesuaikan hyperparameter agar model tetap cukup kecil untuk dilatih menggunakan satu GPU, atau kita dapat menggunakan paralelisme model untuk membagi model antara beberapa GPU di beberapa instance. Meningkatkan jumlah model parameter yang dapat dilatih dapat menghasilkan akurasi yang lebih baik, tetapi ada batasan ukuran model maksimum yang dapat Anda muat dalam satu memori GPU. Kami menggunakan pustaka paralel model terdistribusi SageMaker untuk melatih model kami yang lebih besar. Langkah-langkahnya adalah sebagai berikut:

1. Impor dan inisialisasi perpustakaan dengan smp.init().
2. Model Keras perlu mewarisi dari smp.DistributedModel alih-alih kelas Model Keras.
3. set drop_remainder=True dalam tf.Dataset.batch() metode untuk memastikan bahwa ukuran batch selalu dapat dibagi dengan jumlah mikrobatch.
4. Operasi acak dalam pipa data semua harus menggunakan benih yang sama: smp.dp_rank(), Misalnya, shuffle(ds, seed=smp.dp_rank()). Ini memastikan konsistensi sampel data di seluruh perangkat yang memiliki partisi model berbeda.
5. Logika maju dan mundur harus dalam fungsi langkah dengan smp.step dekorasi.
6. Lakukan postprocessing pada output di seluruh microbatch menggunakan metode StepOutput seperti: reduce_mean. itu smp.step fungsi harus memiliki nilai balik yang bergantung pada output dari smp.DistributedModel.

Script pelatihannya adalah sebagai berikut:

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) 

Untuk panduan mendetail untuk mengaktifkan skrip pelatihan TensorFlow untuk pustaka paralel model terdistribusi SageMaker, lihat Memodifikasi Skrip Pelatihan TensorFlow. Untuk PyTorch, lihat Memodifikasi Skrip Pelatihan PyTorch.

Debugger SageMaker

Pada bagian sebelumnya, kita telah membahas bagaimana mengoptimalkan pelatihan menggunakan model dan teknik paralelisasi data. Dengan Debugger Amazon SageMaker, kami sekarang dapat menangkap informasi profil kinerja dari pelatihan kami untuk menentukan seberapa banyak pelatihan telah meningkat. Secara default, Debugger menangkap metrik sistem untuk setiap tugas pelatihan SageMaker seperti GPU, penggunaan CPU, memori, jaringan, dan I/O pada interval pengambilan sampel 500 milidetik. Kami dapat mengakses data sebagai berikut:

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 menyediakan utilitas untuk membayangkan data profil dengan cara yang berbeda. Dalam contoh berikut, kita melihat total penggunaan GPU dan CPU serta waktu tunggu I/O untuk tugas pelatihan multi-GPU menggunakan Horovod. Untuk menghasilkan grafik ini, kami menjalankan kode berikut:

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 )

Penggunaan GPU sering berfluktuasi antara 0–100%, dan waktu tunggu I/O yang tinggi dengan penggunaan GPU yang rendah merupakan indikator hambatan I/O. Selain itu, penggunaan CPU total tidak pernah melebihi 70%, yang berarti bahwa kami dapat meningkatkan prapemrosesan data dengan meningkatkan jumlah proses pekerja.

Kami dapat meningkatkan kinerja dengan beralih dari Horovod ke perpustakaan paralel data terdistribusi SageMaker. Dalam grafik berikut, kita dapat melihat bahwa GPU digunakan lebih efisien dan hanya turun ke penggunaan rendah untuk waktu yang singkat.

Infrastruktur pelatihan

Untuk melatih model, kami menggunakan 10 ml.p3.16xlarge instans menggunakan tugas pelatihan SageMaker. SageMaker mengurangi waktu dan biaya untuk melatih dan menyempurnakan model machine learning (ML) tanpa perlu mengelola infrastruktur. Dengan SageMaker, Anda dapat dengan mudah melatih dan menyetel model ML menggunakan alat bawaan untuk mengelola dan melacak eksperimen pelatihan, secara otomatis memilih hyperparameter yang optimal, men-debug tugas pelatihan, dan memantau pemanfaatan sumber daya sistem seperti GPU, CPU, dan bandwidth jaringan. Data dihosting di Amazon EFS, yang memungkinkan kami untuk berkembang dan menyusut saat kami menambahkan dan menghapus file tanpa perlu pengelolaan atau penyediaan. Tujuan utama kami adalah untuk meningkatkan kecepatan pelatihan dan mengurangi biaya.

Skalabilitas model

Meskipun infrastruktur ini terutama digunakan untuk pembuatan bahasa, dengan arsitektur GPT dan kumpulan data Pile, Anda dapat menggunakan teknik ini untuk melatih model transformator skala besar, yang berguna di banyak domain di luar NLP. Dalam pembelajaran mesin itu sendiri, banyak tugas visi komputer sekarang diselesaikan dengan arsitektur parameter besar (transformator) di mana mereka telah terbukti mengungguli CNN tradisional (Convolutional Neural Network) pada tugas-tugas seperti pembelajaran representasi (lihat Memajukan seni dalam visi komputer dengan Transformer yang diawasi sendiri dan pelatihan 10x lebih efisien) dan pemetaan skala besar gambar ke teks (seperti CLIP). Model parameter besar juga membuat terobosan baru dalam ilmu kehidupan di bidang-bidang seperti analisis struktur protein dan analisis data citra medis.

Solusi yang kami perinci dalam posting ini untuk pelatihan terdistribusi dan mengelola model besar harus berlaku untuk model di salah satu domain ini juga.

Trade-off

Ada diskusi yang sedang berlangsung di komunitas riset mengenai risiko pelatihan model bahasa skala besar, dan apakah cukup pemikiran telah dimasukkan ke dalam potensi risiko yang terkait dengan pengembangannya dan strategi untuk mengurangi risiko ini, beberapa di antaranya termasuk keuangan dan biaya lingkungan. Menurut kertas diterbitkan di ACM, melatih model dasar BERT tunggal (tanpa penyetelan hyperparameter) pada GPU diperkirakan membutuhkan energi sebanyak penerbangan trans-Amerika. Skala dampak lingkungan dengan ukuran model, dan kemampuan untuk menyempurnakan model tersebut secara efisien berpotensi mengurangi emisi secara signifikan. AWS baru-baru ini meluncurkan yang baru Alat Jejak Karbon Pelanggan, tersedia untuk semua pelanggan AWS tanpa biaya, sebagai bagian dari upaya Amazon untuk meningkatkan keberlanjutan dan mengurangi emisi karbon. Menjalankan aplikasi di AWS Cloud berpotensi mengurangi jejak karbon (bila dibandingkan dengan pusat data perusahaan yang disurvei di laporan 2019).

Kesimpulan

Postingan ini menunjukkan solusi yang memfasilitasi penyempurnaan model bahasa dengan satu miliar parameter di AWS Cloud menggunakan SageMaker.

Untuk informasi lebih lanjut tentang paralelisme model dengan SageMaker, lihat Latih 175+ miliar model parameter NLP dengan penambahan paralel model dan Hugging Face di Amazon SageMaker dan Bagaimana Latent Space menggunakan pustaka paralelisme model Amazon SageMaker untuk mendorong batasan transformator skala besar.

Jika Anda ingin membantu mempercepat penggunaan ML dalam produk dan proses Anda, harap hubungi Lab Solusi Amazon ML.

Tentang Penulis

Sia Gholami adalah Senior Data Scientist di Amazon ML Solutions Lab, tempat ia membangun solusi AI/ML untuk pelanggan di berbagai industri. Dia bersemangat tentang pemrosesan bahasa alami (NLP) dan pembelajaran mendalam. Di luar pekerjaan, Sia senang menghabiskan waktu di alam dan bermain tenis.

Mahdi Nooriadalah Manajer dan Ilmuwan Terapan Senior di Amazon ML Solutions Lab, tempat dia bekerja dengan pelanggan di berbagai industri, dan membantu mereka mempercepat perjalanan migrasi cloud mereka, dan untuk memecahkan masalah ML mereka menggunakan solusi dan teknologi.

Muhyun Kim adalah seorang ilmuwan data di Amazon Machine Learning Solutions Lab. Dia memecahkan berbagai masalah bisnis pelanggan dengan menerapkan pembelajaran mesin dan pembelajaran mendalam, serta membantu mereka menjadi terampil.

Danny Byrd adalah Ilmuwan Terapan di Amazon ML Solutions Lab. Di lab, dia membantu pelanggan mengembangkan solusi ML tingkat lanjut, dalam spesialisasi ML dari visi komputer hingga pembelajaran penguatan. Dia bersemangat untuk mendorong teknologi ke depan dan membuka potensi baru dari produk AWS di sepanjang jalan.

Fransisco Calderon Rodriguez adalah Ilmuwan Data di Amazon ML Solutions Lab. Sebagai anggota Lab Solusi ML, dia membantu memecahkan masalah bisnis penting bagi pelanggan AWS menggunakan pembelajaran mendalam. Di waktu luangnya, Francisco suka bermain musik dan gitar, bermain sepak bola dengan putrinya, dan menikmati waktu bersama keluarganya.

Yohei Nakayama adalah Arsitek Pembelajaran Mendalam di Amazon ML Solutions Lab. Dia bekerja dengan pelanggan di berbagai vertikal untuk mempercepat penggunaan kecerdasan buatan dan layanan AWS Cloud untuk memecahkan tantangan bisnis mereka. Dia tertarik untuk menerapkan teknologi ML/AI ke industri luar angkasa.

Nathalie Rauschmayr adalah Ilmuwan Terapan Senior di AWS, di mana dia membantu pelanggan mengembangkan aplikasi pembelajaran mendalam.

• Coinsmart. Pertukaran Bitcoin dan Crypto Terbaik Eropa.
• Platoblockchain. Intelijen Metaverse Web3. Pengetahuan Diperkuat. AKSES GRATIS.
• CryptoHawk. Radar Altcoin. Uji Coba Gratis.
• Sumber: 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/