สร้าง ฝึกฝน และปรับใช้โมเดลภาษาที่มีพารามิเตอร์หลายพันล้านพารามิเตอร์บนข้อมูลหลายเทราไบต์ด้วย TensorFlow และ Amazon SageMaker

ขนาดของโมเดลภาษาที่เพิ่มขึ้นเป็นหนึ่งในแนวโน้มที่ใหญ่ที่สุดในการประมวลผลภาษาธรรมชาติ (NLP) ในช่วงไม่กี่ปีที่ผ่านมา ตั้งแต่ปี 2018 เราได้เห็นการพัฒนาและการปรับใช้โมเดลภาษาที่ใหญ่ขึ้นอย่างที่ไม่เคยมีมาก่อน ซึ่งรวมถึง BERT และรูปแบบต่างๆ ของมัน, GPT-2, T-NLG และ GPT-3 (175 พันล้านพารามิเตอร์)

โมเดลเหล่านี้ได้ผลักดันขอบเขตของนวัตกรรมทางสถาปัตยกรรมที่เป็นไปได้ เราเผชิญกับความท้าทายหลายประการในการฝึกอบรมแบบจำลองการเรียนรู้เชิงลึกขนาดใหญ่ โดยเฉพาะอย่างยิ่งคลื่นลูกใหม่ของหม้อแปลงไฟฟ้าที่ได้รับการฝึกฝนมาล่วงหน้า ความท้าทายเหล่านี้รวมถึงข้อจำกัดด้านฮาร์ดแวร์และการแลกเปลี่ยนกับการคำนวณและประสิทธิภาพ เพื่อเอาชนะความท้าทายด้านแบบจำลองและข้อมูลแบบขนาน AWS จึงนำเสนอความสามารถที่หลากหลาย

ในโพสต์นี้ เราแนะนำสองแนวทางหลัก: การขนานข้อมูลและการขนานแบบจำลองโดยใช้ อเมซอน SageMakerและอภิปรายข้อดีข้อเสีย

นางแบบ

สำหรับโมเดลภาษา เราใช้ Transformers ซึ่งแนะนำไว้ในบทความนี้ ความสนใจคือสิ่งที่คุณต้องการ. Transformers เป็นโมเดลการเรียนรู้เชิงลึกที่ออกแบบมาเพื่อหลีกเลี่ยงหลุมพรางของ RNN โดยเจตนาโดยอาศัยกลไกการให้ความสนใจด้วยตนเองเพื่อดึงการพึ่งพาทั่วโลกระหว่างอินพุตและเอาต์พุต สถาปัตยกรรมโมเดล Transformer ช่วยให้สามารถต่อขนานกันได้ดีขึ้นอย่างมีนัยสำคัญ และสามารถบรรลุประสิทธิภาพสูงในเวลาฝึกที่ค่อนข้างสั้น สร้างขึ้นจากความสำเร็จของ Transformers, BERT นำเสนอในเอกสารนี้ BERT: การฝึกอบรมล่วงหน้าของหม้อแปลงสองทิศทางเชิงลึกเพื่อการทำความเข้าใจภาษาเพิ่มการฝึกอบรมล่วงหน้าแบบสองทิศทางสำหรับการแสดงภาษา BERT ได้รับแรงบันดาลใจจากงาน Cloze โดยได้รับการฝึกฝนล่วงหน้าด้วยการสร้างแบบจำลองภาษามาสก์ (MLM) ซึ่งแบบจำลองจะเรียนรู้ที่จะกู้คืนคำดั้งเดิมสำหรับโทเค็นที่ถูกปกปิดแบบสุ่ม แบบจำลอง BERT ยังได้รับการฝึกฝนล่วงหน้าในงานทำนายประโยคถัดไป (NSP) เพื่อทำนายว่าสองประโยคเรียงตามลำดับการอ่านที่ถูกต้องหรือไม่ นับตั้งแต่เปิดตัวในปี 2018 BERT และรูปแบบต่างๆ ของ BERT ได้ถูกนำมาใช้อย่างแพร่หลายในโมเดลภาษา

เราเริ่มต้นด้วยการสร้างชั้นการฝังสองชั้นสำหรับโทเค็นและการฝังตำแหน่ง การฝังอินพุตคือผลรวมของการฝังโทเค็นและการฝังตำแหน่ง

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

จากนั้นเราจะกำหนดบล็อกตัวถอดรหัสหม้อแปลงด้วยเลเยอร์ย่อยสองชั้น: เลเยอร์การเอาใจใส่ตนเองแบบหลายหัว และเครือข่ายฟีดฟอร์เวิร์ดที่เชื่อมต่ออย่างง่ายอย่างง่าย ตามด้วยการทำให้เป็นปกติของเลเยอร์และดร็อปเอาต์:

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)

สุดท้าย เราสร้างโมเดลภาษาของเราด้วยเลเยอร์การฝังก่อนหน้าและบล็อกตัวแปลง:

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

คุณสามารถปรับขนาดโมเดลนี้จากพารามิเตอร์หลายพันรายการไปจนถึงหลายพันล้านพารามิเตอร์ได้ ทั้งนี้ขึ้นอยู่กับไฮเปอร์พารามิเตอร์ของคุณ ความท้าทายหลักของโมเดลพันล้านพารามิเตอร์คือ คุณไม่สามารถโฮสต์โมเดลในอินสแตนซ์เดียวได้ และจำเป็นต้องกระจายโมเดลไปยังหลาย ๆ โหนดเพื่อการฝึกและการอนุมาน

ชุดข้อมูล

ในการทดลองของเรา เราใช้ ชุดข้อมูลกอง. The Pile เป็นชุดข้อมูลข้อความภาษาอังกฤษขนาด 800 GiB ที่ออกแบบมาสำหรับการฝึกอบรมโมเดลภาษาขนาดใหญ่ สร้างขึ้นจากชุดข้อมูลที่หลากหลายและมีคุณภาพสูง 22 ชุด รวมทั้งชุดข้อมูล NLP ที่จัดตั้งขึ้นและชุดข้อมูลที่เพิ่งเปิดตัว

ชุดข้อมูลถูกสร้างขึ้นจากแหล่งข้อมูลที่หลากหลาย รวมถึงหนังสือ ที่เก็บ GitHub; หน้าเว็บ; บันทึกการแชท; และเอกสารทางการแพทย์ ฟิสิกส์ คณิตศาสตร์ วิทยาการคอมพิวเตอร์ และปรัชญา โดยเฉพาะอย่างยิ่ง มันใช้แหล่งข้อมูลต่อไปนี้: Pile-CC, PubMed Central, ArXiv, GitHub, the FreeLaw Project, Stack Exchange, the US Patent and Trademark Office, PubMed, Ubuntu, IRC, HackerNews, YouTube, PhilPapers, Books3, Project Gutenberg ( ระดับ PG-19), OpenSubtitles, วิกิพีเดียภาษาอังกฤษ, DM Mathematics, EuroParl, Enron Email corpus และ NIH ExPorter นอกจากนี้ยังมี OpenWebText2 และ BookCorpus2 ซึ่งเป็นส่วนขยายของชุดข้อมูล OpenWebText และ BookCorpus ดั้งเดิมตามลำดับ ความหลากหลายในแหล่งข้อมูลสามารถปรับปรุงความรู้ข้ามโดเมนทั่วไป และเป็นผลให้ปรับปรุงความสามารถทั่วไปปลายน้ำ

ความท้าทายหลักของชุดข้อมูลนี้คือขนาดที่แท้จริง ชุดข้อมูลมีข้อความ 825 GiB ซึ่งแปลเป็น 4.2 TiB ของดาต้าพอยต์ที่ประมวลผลล่วงหน้าและบีบอัด เช่นเดียวกับความท้าทายที่เราเผชิญในการฝึกอบรมและการโฮสต์โมเดล การฝึกโมเดลด้วยชุดข้อมูลนี้ในอินสแตนซ์เดียวจะใช้เวลามากและใช้งานไม่ได้จริง

วิธีแก้ไขของเราคือการแบ่งชุดข้อมูลออกเป็นชิ้นข้อมูลประมาณ 1 GiB โหลดและประมวลผลคุณสมบัติล่วงหน้าใน ชุดข้อมูล TensorFlow วัตถุและเก็บไว้ใน บริการไฟล์ Amazon Elastic (อีเอฟเอสของอเมซอน). ชุดข้อมูล TensorFlow นำเสนอไปป์ไลน์ข้อมูลที่ใช้งานง่ายและมีประสิทธิภาพสูง ซึ่งรวมเข้ากับโมเดลของเราได้เป็นอย่างดี Amazon EFS เป็นบริการที่ใช้งานง่ายซึ่งช่วยให้เราสร้างระบบไฟล์ที่ใช้ร่วมกันซึ่งปรับขนาดโดยอัตโนมัติเมื่อมีการเพิ่มและลบไฟล์ นอกจากนี้ Amazon EFS ยังสามารถขยายไปสู่ระดับปริมาณงานที่สูงขึ้นได้เมื่อจำเป็น ซึ่งมีความสำคัญอย่างยิ่งในไปป์ไลน์การฝึกอบรมข้อมูลและโมเดลของเรา

ต่อไป เราจะพิจารณากลยุทธ์การฝึกอบรมแบบกระจายเพื่อรับมือกับความท้าทายเหล่านี้

การฝึกอบรมแบบกระจาย

ในโครงการนี้ เราเผชิญกับความท้าทายสองประการ: การปรับขนาดโมเดลและปริมาณข้อมูล การเพิ่มขนาดโมเดลและจำนวนของพารามิเตอร์ที่ฝึกได้อาจส่งผลให้มีความแม่นยำมากขึ้น แต่โมเดลมีขีดจำกัดที่คุณสามารถใส่ลงในหน่วยความจำ GPU เดียวหรือแม้แต่ GPU หลายตัวในอินสแตนซ์เดียว นอกจากนี้ โมเดลที่ใหญ่กว่าจะใช้เวลาฝึกนานกว่า

คุณสามารถรับมือกับความท้าทายเหล่านี้ได้สองวิธี: ความขนานของข้อมูลและความขนานของแบบจำลอง ด้วยความเท่าเทียมกันของข้อมูล เราดำเนินการ Stochastic Gradient Descent (SGD) โดยกระจายบันทึกของชุดย่อยไปยังอุปกรณ์ต่างๆ เพื่อเร่งการฝึกอบรม อย่างไรก็ตาม การฝึกอบรมข้อมูลแบบคู่ขนานนั้นมาพร้อมกับความซับซ้อนเพิ่มเติมของการคำนวณค่าเฉลี่ยการไล่ระดับสีแบบมินิแบทช์ที่มีการไล่ระดับสีจากอุปกรณ์ทั้งหมด ซึ่งเป็นขั้นตอนที่เรียกว่า AllReduceซึ่งจะยากขึ้นเมื่อคลัสเตอร์การฝึกอบรมเติบโตขึ้น ในขณะที่ใช้การขนานข้อมูล เราต้องสามารถพอดีกับโมเดลและจุดข้อมูลเดียวในอุปกรณ์ (CPU หรือ GPU) ซึ่งเป็นปัจจัยจำกัดในการทดลองของเรา เนื่องจากขนาดของโมเดลขนาดใหญ่นั้นใหญ่กว่าหน่วยความจำของ GPU เดี่ยวมาก ขนาด.

อีกวิธีหนึ่งคือการใช้โมเดลแบบขนาน ซึ่งแยกโมเดลออกจากอุปกรณ์หลายเครื่อง ความเท่าเทียมกันของโมเดลคือกระบวนการแยกโมเดลระหว่างอุปกรณ์หรือโหนดหลายเครื่อง (เช่น อินสแตนซ์ที่ติดตั้ง GPU) และสร้างไปป์ไลน์ที่มีประสิทธิภาพเพื่อฝึกโมเดลในอุปกรณ์เหล่านี้เพื่อเพิ่มการใช้งาน GPU ให้ได้สูงสุด

การขนานข้อมูล

การเทียบเคียงข้อมูลเป็นวิธีการทั่วไปสำหรับ GPU หลายตัวหรือการฝึกอบรมแบบกระจาย คุณสามารถแบทช์ข้อมูลของคุณ ส่งไปยังอุปกรณ์หลายเครื่อง (แต่ละเครื่องโฮสต์โมเดลจำลอง) จากนั้นรวมผลลัพธ์ เราทดลองกับสองแพ็คเกจสำหรับการขนานข้อมูล: Horovod และ the SageMaker กระจายไลบรารีข้อมูลแบบคู่ขนาน.

Horovod เป็นกรอบการฝึกอบรมการเรียนรู้เชิงลึกแบบกระจายสำหรับ TensorFlow, Keras, PyTorch และ Apache MXNet ในการใช้ Horovod เราได้ดำเนินการตามขั้นตอนต่อไปนี้:

1. เริ่มต้นด้วยการวิ่ง hvd.init().
2. เชื่อมโยงแต่ละอุปกรณ์ด้วยกระบวนการเดียว กระบวนการหรือผู้ปฏิบัติงานแรกเชื่อมโยงกับอุปกรณ์เครื่องแรก กระบวนการที่สองเชื่อมโยงกับอุปกรณ์ที่สอง และอื่นๆ
3. ปรับอัตราการเรียนรู้ตามจำนวนอุปกรณ์
4. รวมเครื่องมือเพิ่มประสิทธิภาพไว้ใน hvd.DistributedOptimizer.
5. เผยแพร่สถานะตัวแปรเริ่มต้นจากผู้ปฏิบัติงานคนแรกที่มีอันดับ 0 ไปยังกระบวนการอื่นๆ ทั้งหมด สิ่งนี้จำเป็นเพื่อให้แน่ใจว่าการเริ่มต้นของผู้ปฏิบัติงานทุกคนสอดคล้องกันเมื่อการฝึกอบรมเริ่มต้นขึ้นด้วยตุ้มน้ำหนักแบบสุ่มหรือคืนค่าจากจุดตรวจ
6. ตรวจสอบให้แน่ใจว่ามีเพียงอุปกรณ์ 0 เท่านั้นที่สามารถบันทึกจุดตรวจสอบเพื่อป้องกันไม่ให้ผู้ปฏิบัติงานรายอื่นทำความเสียหายได้

ต่อไปนี้เป็นสคริปต์การฝึกอบรม:

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 ช่วยให้เราสามารถปรับขนาดการฝึกอบรมของเราด้วยประสิทธิภาพที่ใกล้เคียงเชิงเส้น เร่งการฝึกอบรมของเราด้วยการเปลี่ยนแปลงโค้ดเพียงเล็กน้อย ห้องสมุดดำเนินการกำหนดเอง AllReduce การทำงานและเพิ่มประสิทธิภาพการสื่อสารระหว่างอุปกรณ์โดยใช้โครงสร้างพื้นฐานเครือข่ายของ AWS และ อเมซอน อีลาสติก คอมพิวท์ คลาวด์ (Amazon EC2) โทโพโลยีอินสแตนซ์ ในการใช้คลังข้อมูลคู่ขนานของ SageMaker เราได้ดำเนินการตามขั้นตอนต่อไปนี้:

1. นำเข้าและเริ่มต้น sdp.init().
2. เชื่อมโยงแต่ละอุปกรณ์เข้ากับอุปกรณ์เดียว smdistributed.dataparallel ประมวลผลด้วย local_rank. sdp.tensorflow.local_rank() ให้อันดับอุปกรณ์ในท้องถิ่นแก่เรา ผู้นำอยู่ในอันดับ 0 และพนักงานอยู่ในอันดับ 1, 2, 3 และอื่น ๆ
3. ปรับอัตราการเรียนรู้ตามจำนวนอุปกรณ์
4. ห่อ tf.GradientTape กับ DistributedGradientTape ในการดำเนินการ AllReduce.
5. เผยแพร่ตัวแปรโมเดลเริ่มต้นจากโหนดผู้นำไปยังโหนดผู้ปฏิบัติงานทั้งหมด
6. ตรวจสอบให้แน่ใจว่ามีเพียงอุปกรณ์ 0 เท่านั้นที่สามารถบันทึกจุดตรวจได้

การขนานแบบจำลอง

เราสามารถปรับไฮเปอร์พารามิเตอร์เพื่อให้โมเดลมีขนาดเล็กพอที่จะฝึกโดยใช้ GPU ตัวเดียว หรือเราสามารถใช้การขนานโมเดลเพื่อแบ่งโมเดลระหว่าง GPU หลายตัวในหลายๆ อินสแตนซ์ การเพิ่มจำนวนพารามิเตอร์ที่ฝึกได้ของโมเดลอาจส่งผลให้มีความแม่นยำดีขึ้น แต่ขนาดโมเดลสูงสุดที่คุณใส่ในหน่วยความจำ GPU เดียวก็มีขีดจำกัด เราใช้ไลบรารีแบบขนานของโมเดลแบบกระจายของ SageMaker เพื่อฝึกโมเดลขนาดใหญ่ของเรา ขั้นตอนมีดังนี้:

1. นำเข้าและเริ่มต้นไลบรารีด้วย smp.init().
2. โมเดล Keras จำเป็นต้องสืบทอดจาก smp.DistributedModel แทนคลาส Keras Model
3. ชุด drop_remainder=True ใน tf.Dataset.batch() วิธีการเพื่อให้แน่ใจว่าขนาดของแบทช์นั้นหารด้วยจำนวนไมโครแบทช์เสมอ
4. การดำเนินการแบบสุ่มในไปป์ไลน์ข้อมูลทั้งหมดจำเป็นต้องใช้เมล็ดพันธุ์เดียวกัน: smp.dp_rank(), ตัวอย่างเช่น, shuffle(ds, seed=smp.dp_rank()). สิ่งนี้ทำให้มั่นใจถึงความสอดคล้องกันของตัวอย่างข้อมูลในอุปกรณ์ที่มีพาร์ติชันรุ่นต่างๆ
5. ลอจิกไปข้างหน้าและย้อนกลับจำเป็นต้องอยู่ในฟังก์ชันขั้นตอนด้วย smp.step เครื่องประดับ
6. ดำเนินการประมวลผลภายหลังบนเอาต์พุตในไมโครแบทช์โดยใช้วิธีการ StepOutput เช่น reduce_mean. smp.step ฟังก์ชันจะต้องมีค่าส่งคืนที่ขึ้นอยู่กับผลลัพธ์ของ smp.DistributedModel.

สคริปต์การฝึกอบรมมีดังนี้:

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) 

สำหรับคำแนะนำโดยละเอียดเพื่อเปิดใช้งานสคริปต์การฝึกอบรม TensorFlow สำหรับไลบรารีแบบขนานของโมเดลกระจาย SageMaker โปรดดูที่ แก้ไขสคริปต์การฝึกอบรม TensorFlow. สำหรับ PyTorch โปรดดูที่ แก้ไขสคริปต์การฝึกอบรม PyTorch.

ดีบักเกอร์ SageMaker

ในหัวข้อที่แล้ว เราได้กล่าวถึงวิธีการเพิ่มประสิทธิภาพการฝึกอบรมโดยใช้แบบจำลองและเทคนิคการขนานข้อมูล กับ ดีบักเกอร์ Amazon SageMakerขณะนี้ เราสามารถรวบรวมข้อมูลโปรไฟล์ประสิทธิภาพจากการดำเนินการฝึกอบรมของเรา เพื่อพิจารณาว่าการฝึกอบรมมีการปรับปรุงมากน้อยเพียงใด ตามค่าเริ่มต้น ดีบักเกอร์จะจับเมตริกระบบสำหรับงานฝึกอบรม SageMaker แต่ละงาน เช่น GPU, การใช้งาน CPU, หน่วยความจำ, เครือข่าย และ I/O ที่ช่วงเวลาสุ่มตัวอย่าง 500 มิลลิวินาที เราสามารถเข้าถึงข้อมูลได้ดังนี้

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

ดีบักเกอร์จัดเตรียมยูทิลิตี้ให้ เห็นภาพ ข้อมูลโปรไฟล์ในรูปแบบต่างๆ ในตัวอย่างต่อไปนี้ เราเห็นการใช้งาน GPU และ CPU ทั้งหมด ตลอดจนเวลารอ I/O สำหรับงานฝึกอบรมหลาย GPU โดยใช้ Horovod ในการสร้างกราฟเหล่านี้ เรารันโค้ดต่อไปนี้:

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 มักจะผันผวนระหว่าง 0–100% และเวลารอ I/O สูงโดยที่การใช้งาน GPU ต่ำเป็นตัวบ่งชี้ถึงปัญหาคอขวดของ I/O นอกจากนี้ การใช้งาน CPU ทั้งหมดไม่เกิน 70% ซึ่งหมายความว่าเราสามารถปรับปรุงการประมวลผลข้อมูลล่วงหน้าได้โดยการเพิ่มจำนวนกระบวนการของผู้ปฏิบัติงาน

เราสามารถปรับปรุงประสิทธิภาพโดยเปลี่ยนจาก Horovod เป็นไลบรารีข้อมูลแบบกระจายของ SageMaker แบบขนาน ในกราฟต่อไปนี้ เราจะเห็นว่า GPU ถูกใช้งานอย่างมีประสิทธิภาพมากขึ้น และลดลงเหลือเพียงการใช้งานที่ต่ำในช่วงเวลาสั้นๆ เท่านั้น

โครงสร้างพื้นฐานการฝึกอบรม

สำหรับการฝึกอบรมโมเดล เราใช้อินสแตนซ์ 10 ml.p3.16xlarge โดยใช้งานการฝึกอบรม SageMaker SageMaker ช่วยลดเวลาและค่าใช้จ่ายในการฝึกอบรมและปรับแต่งโมเดลแมชชีนเลิร์นนิง (ML) โดยไม่จำเป็นต้องจัดการโครงสร้างพื้นฐาน ด้วย SageMaker คุณสามารถฝึกและปรับแต่งโมเดล ML ได้อย่างง่ายดายโดยใช้เครื่องมือในตัวเพื่อจัดการและติดตามการทดสอบการฝึก เลือกไฮเปอร์พารามิเตอร์ที่เหมาะสมโดยอัตโนมัติ ดีบักงานฝึก และตรวจสอบการใช้ทรัพยากรระบบ เช่น GPU, CPU และแบนด์วิธเครือข่าย ข้อมูลถูกโฮสต์ใน Amazon EFS ซึ่งทำให้เราสามารถขยายและย่อขนาดเมื่อเราเพิ่มและลบไฟล์โดยไม่จำเป็นต้องจัดการหรือจัดเตรียม วัตถุประสงค์หลักของเราคือการปรับปรุงความเร็วในการฝึกอบรมและลดค่าใช้จ่าย

ความสามารถในการปรับขนาดโมเดล

แม้ว่าโครงสร้างพื้นฐานนี้จะใช้สำหรับการสร้างภาษาเป็นหลัก แต่ด้วยสถาปัตยกรรม GPT และชุดข้อมูล Pile คุณสามารถใช้เทคนิคเหล่านี้เพื่อฝึกโมเดล Transformer ขนาดใหญ่ได้ ซึ่งมีประโยชน์ในหลายโดเมนนอกเหนือจาก NLP ในแมชชีนเลิร์นนิงเอง งานด้านคอมพิวเตอร์วิทัศน์จำนวนมากได้รับการแก้ไขด้วยสถาปัตยกรรมพารามิเตอร์ขนาดใหญ่ (หม้อแปลง) ซึ่งแสดงให้เห็นว่ามีประสิทธิภาพดีกว่า CNN แบบดั้งเดิม (Convolutional Neural Network) ในงานต่างๆ เช่น การเรียนรู้การเป็นตัวแทน (ดู ยกระดับความล้ำหน้าในการมองเห็นด้วยคอมพิวเตอร์ด้วย Transformers ที่ควบคุมตนเองและการฝึกอบรมที่มีประสิทธิภาพยิ่งขึ้นถึง 10 เท่า) และการแมปภาพขนาดใหญ่กับข้อความ (เช่น CLIP). แบบจำลองที่มีพารามิเตอร์ขนาดใหญ่ยังเป็นการพลิกโฉมหน้าใหม่ในด้านวิทยาศาสตร์เพื่อชีวิตในสาขาต่างๆ เช่น การวิเคราะห์โครงสร้างโปรตีน และ การวิเคราะห์ข้อมูลภาพทางการแพทย์.

โซลูชันที่เราให้รายละเอียดในโพสต์นี้สำหรับการฝึกอบรมแบบกระจายและการจัดการโมเดลขนาดใหญ่ควรใช้กับโมเดลในโดเมนเหล่านี้ด้วยเช่นกัน

การแลกเปลี่ยน

มีการอภิปรายอย่างต่อเนื่องในชุมชนการวิจัยเกี่ยวกับความเสี่ยงของการฝึกอบรมแบบจำลองภาษาขนาดใหญ่ และพิจารณาว่ามีการคิดอย่างเพียงพอเกี่ยวกับความเสี่ยงที่อาจเกิดขึ้นที่เกี่ยวข้องกับการพัฒนาและกลยุทธ์เพื่อลดความเสี่ยงเหล่านี้หรือไม่ ซึ่งบางส่วนรวมถึงการเงินและ ต้นทุนด้านสิ่งแวดล้อม ตามที่ ก กระดาษ เผยแพร่ใน ACM การฝึกอบรมโมเดลพื้นฐาน BERT เดียว (โดยไม่มีการปรับไฮเปอร์พารามิเตอร์) บน GPU คาดว่าจะต้องใช้พลังงานมากเท่ากับเที่ยวบินข้ามทวีปอเมริกา มาตราส่วนผลกระทบต่อสิ่งแวดล้อมพร้อมขนาดของโมเดล และความสามารถในการปรับแต่งโมเดลดังกล่าวอย่างมีประสิทธิภาพอาจลดการปล่อยมลพิษลงได้อย่างมาก AWS เพิ่งเปิดตัวใหม่ เครื่องมือ Carbon Footprint ของลูกค้าพร้อมให้บริการแก่ลูกค้า AWS ทุกคนโดยไม่มีค่าใช้จ่าย ซึ่งเป็นส่วนหนึ่งของความพยายามของ Amazon ในการเพิ่มความยั่งยืนและลดการปล่อยคาร์บอน การเรียกใช้แอปพลิเคชันบน AWS Cloud สามารถลดรอยเท้าคาร์บอนได้ (เมื่อเปรียบเทียบกับศูนย์ข้อมูลขององค์กรที่สำรวจใน รายงาน 2019).

สรุป

โพสต์นี้สาธิตโซลูชันที่ช่วยอำนวยความสะดวกในการปรับแต่งโมเดลภาษาอย่างละเอียดด้วยพารามิเตอร์นับพันล้านตัวบน AWS Cloud โดยใช้ SageMaker

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับความขนานของโมเดลกับ SageMaker โปรดดูที่ ฝึกโมเดล NLP พารามิเตอร์ 175+ พันล้านด้วยการเพิ่มโมเดลแบบขนานและ Hugging Face บน Amazon SageMaker และ วิธีที่ Latent Space ใช้ไลบรารีแบบขนานของแบบจำลอง Amazon SageMaker เพื่อผลักดันขอบเขตของหม้อแปลงขนาดใหญ่.

หากคุณต้องการความช่วยเหลือในการเร่งการใช้ ML ในผลิตภัณฑ์และกระบวนการของคุณ โปรดติดต่อ ห้องปฏิบัติการโซลูชัน Amazon ML.

เกี่ยวกับผู้เขียน

เสี่ยโกลามิ เป็นนักวิทยาศาสตร์ข้อมูลอาวุโสที่ Amazon ML Solutions Lab ซึ่งเขาสร้างโซลูชัน AI/ML สำหรับลูกค้าในอุตสาหกรรมต่างๆ เขาหลงใหลในการประมวลผลภาษาธรรมชาติ (NLP) และการเรียนรู้อย่างลึกซึ้ง นอกเวลางาน เซียะชอบใช้เวลากับธรรมชาติและเล่นเทนนิส

เมห์ดี นูรีเป็นผู้จัดการและนักวิทยาศาสตร์ประยุกต์อาวุโสที่ Amazon ML Solutions Lab ซึ่งเขาทำงานร่วมกับลูกค้าในอุตสาหกรรมต่างๆ และช่วยพวกเขาในการเร่งเส้นทางการย้ายระบบคลาวด์ และแก้ปัญหา ML โดยใช้โซลูชันที่ล้ำสมัยและ เทคโนโลยี

มูฮยอน คิม เป็นนักวิทยาศาสตร์ข้อมูลที่ Amazon Machine Learning Solutions Lab เขาแก้ปัญหาทางธุรกิจต่างๆ ของลูกค้าด้วยการใช้แมชชีนเลิร์นนิงและการเรียนรู้เชิงลึก และยังช่วยให้พวกเขามีทักษะ

แดนนี่ เบิร์ด เป็นนักวิทยาศาสตร์ประยุกต์ที่ Amazon ML Solutions Lab ที่ห้องแล็บ เขาช่วยลูกค้าพัฒนาโซลูชัน ML ขั้นสูง ในความเชี่ยวชาญพิเศษด้าน ML ตั้งแต่การมองเห็นด้วยคอมพิวเตอร์ไปจนถึงการเรียนรู้แบบเสริมแรง เขาหลงใหลในการผลักดันเทคโนโลยีไปข้างหน้าและปลดล็อกศักยภาพใหม่ๆ จากผลิตภัณฑ์ AWS ไปพร้อมกัน

ฟรานซิสโก คัลเดรอน โรดริเกซ เป็นนักวิทยาศาสตร์ข้อมูลใน Amazon ML Solutions Lab ในฐานะสมาชิกของ ML Solutions Lab เขาช่วยแก้ปัญหาทางธุรกิจที่สำคัญให้กับลูกค้า AWS โดยใช้การเรียนรู้เชิงลึก ในเวลาว่าง ฟรานซิสโกชอบเล่นดนตรีและเล่นกีตาร์ เล่นฟุตบอลกับลูกสาว และใช้เวลากับครอบครัวอย่างสนุกสนาน

โยเฮ นากายามะ เป็นสถาปนิก Deep Learning ที่ Amazon ML Solutions Lab เขาทำงานร่วมกับลูกค้าในแนวดิ่งต่างๆ เพื่อเร่งการใช้ปัญญาประดิษฐ์และบริการ AWS Cloud เพื่อแก้ปัญหาความท้าทายทางธุรกิจ เขาสนใจที่จะนำเทคโนโลยี ML/AI มาใช้กับอุตสาหกรรมอวกาศ

Nathalie Rauschmayr . นาตาลี เราชไมร์ เป็นนักวิทยาศาสตร์ประยุกต์อาวุโสที่ AWS ซึ่งเธอช่วยลูกค้าพัฒนาแอปพลิเคชันการเรียนรู้เชิงลึก

• คอยน์สมาร์ท การแลกเปลี่ยน Bitcoin และ Crypto ที่ดีที่สุดในยุโรป
• เพลโตบล็อคเชน Web3 Metaverse ข่าวกรอง ขยายความรู้. เข้าฟรี
• คริปโตฮอว์ก เรดาร์ Altcoin ทดลองฟรี.
• ที่มา: https://aws.amazon.com/blogs/machine-learning/create-train-and-deploy-a-billion-parameter-language-model-on-terabytes-of-data-with-tensorflow-and- อเมซอน-sagemaker/