צור, אימון ופריסה מודל שפה של מיליארד פרמטרים על טרה-בייט של נתונים עם TensorFlow ו-Amazon SageMaker

הגודל ההולך וגדל של מודלים של שפה הייתה אחת המגמות הגדולות ביותר בעיבוד שפה טבעית (NLP) בשנים האחרונות. מאז 2018, ראינו פיתוח ופריסה חסרי תקדים של דגמי שפה גדולים מתמיד, כולל BERT והגרסאות שלו, GPT-2, T-NLG ו-GPT-3 (175 מיליארד פרמטרים).

מודלים אלה דחפו את הגבולות של חידושים אדריכליים אפשריים. אנו מתמודדים עם מספר אתגרים בעת אימון מודלים של למידה עמוקה בקנה מידה גדול, במיוחד הגל החדש של שנאים שהוכשרו מראש. האתגרים הללו כוללים מגבלות חומרה ופשרות עם חישוב ויעילות. כדי להתגבר על האתגרים הללו של מקביליות מודלים ונתונים, AWS מציעה מגוון רחב של יכולות.

בפוסט זה, אנו מציגים שתי גישות עיקריות: הקבילת נתונים ושימוש בהקבלת מודלים אמזון SageMaker, ולדון ביתרונות ובחסרונות שלהם.

המודל

עבור מודל השפה, אנו משתמשים ברובוטריקים, שהוצגו בעיתון תשומת הלב היא כל מה שאתה צריך. רובוטריקים הם מודלים של למידה עמוקה שנועדו להימנע במכוון מהמלכודות של RNNs על ידי הסתמכות על מנגנון תשומת לב עצמית כדי למשוך תלות גלובלית בין קלט ופלט. ארכיטקטורת מודל ה-Transformer מאפשרת הקבלה טובה משמעותית ויכולה להגיע לביצועים גבוהים בזמן אימון קצר יחסית. נבנה על הצלחת רובוטריקים, BERT, שהוצגה בעיתון BERT: הכשרה מקדימה של רובוטריקים דו כיווניים עמוקים להבנת שפה, הוספה הדרכה דו-כיוונית לייצוג שפה. בהשראת משימת ה-Cloze, BERT עבר הכשרה מוקדמת עם מודלים של שפה מסיכה (MLM), שבה המודל לומד לשחזר את המילים המקוריות עבור אסימונים המסוכים באופן אקראי. מודל BERT מיומן מראש גם במשימת חיזוי המשפט הבא (NSP) כדי לחזות אם שני משפטים נמצאים בסדר הקריאה הנכון. מאז הופעתו ב-2018, נעשה שימוש נרחב ב-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, משרד הפטנטים והסימנים המסחריים בארה"ב, PubMed, Ubuntu, IRC, HackerNews, YouTube, PhilPapers, Books3, Project Gutenberg ( PG-19), OpenSubtitles, ויקיפדיה באנגלית, DM Mathematics, EuroParl, קורפוס האימיילים של Enron ו-NIH Exporter. זה כולל גם את OpenWebText2 ו-BookCorpus2, שהם הרחבות של מערכי הנתונים המקוריים של OpenWebText ו-BookCorpus, בהתאמה. הגיוון במקורות הנתונים יכול לשפר את הידע הכללי בין התחומים ובעקבות כך לשפר את יכולות ההכללה במורד הזרם.

האתגר העיקרי עם מערך הנתונים הזה הוא הגודל העצום; למערך הנתונים יש 825 GiB של טקסט, שמתורגמים ל-4.2 TiB של נקודות נתונים מעובדות ודחוסות מראש. בדומה לאתגרים העומדים בפנינו בהדרכה ואירוח המודלים, אימון מודל עם מערך נתונים זה על מופע בודד ייקח הרבה זמן ואינו מעשי.

הפתרון שלנו הוא לפרק את מערך הנתונים לכ-1 GiB של נתונים, לטעון ולעבד מראש את התכונות ב ערכת נתונים של TensorFlow חפצים, ולאחסן אותם שירות קבצים אלסטי של אמזון (Amazon EFS). מערכי נתונים של TensorFlow מספקים צינור נתונים קל לשימוש ובעל ביצועים גבוהים המשתלב היטב עם המודלים שלנו. Amazon EFS הוא שירות קל לשימוש המאפשר לנו לבנות מערכת קבצים משותפת שמתרחבת באופן אוטומטי עם הוספה ונמחקת קבצים. בנוסף, אמזון EFS מסוגלת לפרוץ לרמות תפוקה גבוהות יותר בעת הצורך, וזה קריטי בצנרת ההדרכה של הנתונים והמודלים שלנו.

לאחר מכן, אנו בוחנים אסטרטגיות הכשרה מבוזרות להתמודדות עם אתגרים אלו.

אימונים מבוזרים

בפרויקט זה התמודדנו עם שני אתגרים: קנה מידה של גודל המודל ונפח הנתונים. הגדלת גודל הדגם ומספר הפרמטרים הניתנים לאימון עשויה להביא לדיוק טוב יותר, אך יש גבול לדגם שניתן להכניס לזיכרון GPU בודד או אפילו למספר GPUs במופע אחד. בנוסף, לגדלים גדולים יותר לוקח יותר זמן להתאמן.

אתה יכול להתמודד עם אתגרים אלה בשתי דרכים שונות: מקביליות נתונים ומקביליות מודל. עם מקביליות נתונים, אנו מבצעים ירידה בדרגה סטוקהסטית (SGD) על ידי הפצת הרשומות של מיני-אצט על גבי מכשירים שונים כדי להאיץ את האימון. עם זאת, אימון נתונים מקביל מגיע עם מורכבות נוספת של מחשוב ממוצע שיפוע מיני-אצווה עם שיפועים מכל המכשירים, שלב שנקרא AllReduce, מה שהופך קשה יותר ככל שאשכול האימונים גדל. תוך כדי שימוש מקביליות נתונים, עלינו להיות מסוגלים להתאים את הדגם ונקודת נתונים בודדת במכשיר (CPU או GPU), וזה גורם מגביל בניסויים שלנו מכיוון שגודלו של דגם גדול כל כך גדול בהרבה מהזיכרון של ה-GPU היחיד. גודל.

פתרון נוסף הוא שימוש מקביליות מודל, אשר מפצלת את הדגם על פני מספר מכשירים. מקביליות מודל היא תהליך של פיצול מודל בין התקנים או צמתים מרובים (כגון מופעים המצוידים ב-GPU) ויצירת צינור יעיל לאימון המודל על פני מכשירים אלה כדי למקסם את ניצול ה-GPU.

הקבילת נתונים

הקבילה של הנתונים היא הגישה הנפוצה ביותר למספר GPUs או אימון מבוזר. אתה יכול לקבץ את הנתונים שלך, לשלוח אותם למספר מכשירים (כל אחד מארח דגם משוכפל), ואז לצבור את התוצאות. התנסינו בשתי חבילות להקבילת נתונים: Horovod וה- SageMaker הפיצה ספריית נתונים מקבילה.

Horovod היא מסגרת אימון למידה עמוקה מבוזרת עבור TensorFlow, Keras, PyTorch ו- Apache MXNet. כדי להשתמש בהרובוד, עברנו את התהליך הבא:

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 יחיד, או שנוכל להשתמש במקביל למודל כדי לפצל את המודל בין מספר GPUs על פני מספר מופעים. הגדלת מספר הפרמטרים הניתנים לאימון של דגם יכולה להביא לדיוק טוב יותר, אך יש גבול לגודל הדגם המקסימלי שניתן להכניס לזיכרון 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

בסעיפים הקודמים, דנו כיצד לייעל את האימון באמצעות טכניקות מקבילות מודלים ונתונים. עם באגים של SageMaker באמזון, כעת נוכל ללכוד מידע על פרופיל ביצועים מהריצות האימונים שלנו כדי לקבוע כמה השתפר האימון. כברירת מחדל, Debugger לוכד מדדי מערכת עבור כל עבודת אימון של SageMaker כגון GPU, ניצול מעבד, זיכרון, רשת ו-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()

Debugger מספק כלי עזר ל לחזות נתוני הפרופיל בדרכים שונות. בדוגמה הבאה, אנו רואים את סך ניצול ה-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%, מה שאומר שאנו יכולים לשפר את עיבוד הנתונים מראש על ידי הגדלת מספר תהליכי העבודה.

אנו יכולים לשפר את הביצועים על ידי מעבר מהורובוד לספריית הנתונים המקבילים המבוזרים של SageMaker. בגרפים הבאים, אנו יכולים לראות ש-GPUs מנוצלים בצורה יעילה יותר ורק יורדים לניצול נמוך לפרקי זמן קצרים.

תשתית הדרכה

להכשרת הדגמים, השתמשנו במופעים של 10 ml.p3.16xlarge באמצעות עבודת אימון של SageMaker. SageMaker מפחית את הזמן והעלות להכשיר ולכוונן מודלים של למידת מכונה (ML) ללא צורך בניהול תשתית. עם SageMaker, אתה יכול בקלות לאמן ולכוון מודלים של ML באמצעות כלים מובנים לניהול ומעקב אחר ניסויי אימון, לבחור אוטומטית בפרמטרים אופטימליים, לנפות באגים בעבודות אימון ולנטר את ניצול משאבי המערכת כגון GPUs, CPUs ורוחב פס רשת. הנתונים התארחו באמזון EFS, מה שאפשר לנו לגדול ולהצטמצם תוך כדי הוספה והסרה של קבצים ללא צורך בניהול או הקצאה. היעדים העיקריים שלנו היו לשפר את מהירות האימון ולהפחית עלויות.

מדרגיות מודל

למרות שתשתית זו משמשת בעיקר ליצירת שפה, עם ארכיטקטורת GPT ומערך הנתונים של Pile, אתה יכול להשתמש בטכניקות אלו כדי להכשיר מודלים של שנאים בקנה מידה גדול, דבר שימושי בתחומים רבים מעבר ל-NLP. בלמידת מכונה עצמה, משימות ראייה ממוחשבת רבות נפתרות כעת עם ארכיטקטורות בעלות פרמטרים גדולים (שנאי), שבהן הוכח שהן עולות על רשתות CNN מסורתיות (רשת עצבית משולבת) במשימות כמו למידת ייצוג (ראה קידום המצב הטכנולוגי בראייה ממוחשבת עם רובוטריקים בפיקוח עצמי ואימונים יעילים פי 10) ומיפוי בקנה מידה גדול של תמונות לטקסט (כגון CLIP). מודלים בעלי פרמטרים גדולים פורצים דרך גם במדעי החיים בתחומים כמו ניתוח מבנה חלבון ו ניתוח נתוני תמונה רפואית.

הפתרונות שאנו מפרטים בפוסט זה להדרכה מבוזרת ולניהול מודלים גדולים צריכים לחול גם על מודלים בכל אחד מהתחומים הללו.

תמורות

בקהילת המחקר התקיים דיון מתמשך לגבי הסיכונים בהכשרת מודלים של שפה בקנה מידה גדול, והאם הושקעה מספיק מחשבה בסיכונים הפוטנציאליים הקשורים בפיתוחם ואסטרטגיות להפחתת סיכונים אלו, שחלקם כוללים את הפיננסי עלויות סביבתיות. לפי א מאמר שפורסם ב-ACM, אימון מודל בסיס BERT יחיד (ללא כוונון היפרפרמטר) על GPU הוערך כדרוש אנרגיה רבה כמו טיסה טרנס-אמריקאית. ההשפעות הסביבתיות מתארכות בהתאם לגודל הדגם, והיכולת לכוונן ביעילות מודלים כאלה עלולה לצמצם את הפליטות באופן משמעותי. AWS השיקה לאחרונה גרסה חדשה כלי טביעת רגל פחמן ללקוח, זמין לכל לקוחות AWS ללא עלות, כחלק מהמאמצים של אמזון להגביר את הקיימות ולהפחית את פליטת הפחמן. הפעלת אפליקציות על AWS Cloud עשויה להקטין את טביעת הרגל הפחמנית (בהשוואה למרכזי נתונים ארגוניים שנסקרו ב- דוח 2019).

סיכום

פוסט זה הדגים פתרון שמקל על כוונון עדין של מודלים של שפה עם מיליארד פרמטרים בענן AWS באמצעות SageMaker.

למידע נוסף על מקביליות מודל עם SageMaker, עיין אימון של 175+ מיליארד פרמטרים של דגמי NLP עם תוספות מקבילות לדגמים ו-Huging Face ב-Amazon SageMaker ו כיצד החלל הסמוי השתמש בספריית ההקבלה של אמזון SageMaker לדחיפת גבולות השנאים בקנה מידה גדול.

אם תרצה עזרה בהאצת השימוש שלך ב- ML במוצרים ובתהליכים שלך, אנא צור קשר עם מעבדת פתרונות אמזון ML.

על הכותבים

סיה גולמי הוא מדען נתונים בכיר במעבדת אמזון ML Solutions, שם הוא בונה פתרונות AI/ML עבור לקוחות בתעשיות שונות. הוא נלהב מעיבוד שפה טבעית (NLP) ולמידה עמוקה. מחוץ לעבודה, סיה נהנית לבלות בטבע ולשחק טניס.

מהדי נוריהוא מנהל ומדען יישומי בכיר במעבדת אמזון ML Solutions, שם הוא עובד עם לקוחות בתעשיות שונות, ועוזר להם להאיץ את מסע ההגירה שלהם לענן ולפתור את בעיות ה-ML שלהם באמצעות פתרונות חדישים ו טכנולוגיות.

מוחיון קים הוא מדען נתונים במעבדת Amazon Machine Learning Solutions. הוא פותר את הבעיות העסקיות השונות של הלקוח על ידי יישום למידה מכונה ולמידה עמוקה, ועוזר להם גם להיות מיומנים.

דני בירד הוא מדען יישומי במעבדת פתרונות ML של אמזון. במעבדה הוא עזר ללקוחות לפתח פתרונות ML מתקדמים, בהתמחויות ML מראייה ממוחשבת ועד למידת חיזוק. הוא נלהב לדחוף את הטכנולוגיה קדימה ולפתור פוטנציאל חדש ממוצרי AWS לאורך הדרך.

פרנסיסקו קלדרון רודריגז הוא מדען נתונים במעבדת פתרונות ML של אמזון. כחבר במעבדת פתרונות ML, הוא עוזר לפתור בעיות עסקיות קריטיות עבור לקוחות AWS באמצעות למידה עמוקה. בזמנו הפנוי, פרנסיסקו אוהב לנגן מוזיקה וגיטרה, לשחק כדורגל עם בנותיו וליהנות מזמן עם משפחתו.

יוהי נקיאמה הוא אדריכל למידה עמוקה במעבדת פתרונות ML של אמזון. הוא עובד עם לקוחות בתחומים שונים כדי להאיץ את השימוש שלהם בבינה מלאכותית ובשירותי ענן AWS כדי לפתור את האתגרים העסקיים שלהם. הוא מעוניין ליישם טכנולוגיות ML/AI בתעשיית החלל.

נטלי ראושמאייר היא מדענית שימושית בכירה ב-AWS, שם היא עוזרת ללקוחות לפתח יישומי למידה עמוקה.

• Coinsmart. בורסת הביטקוין והקריפטו הטובה באירופה.
• Platoblockchain. Web3 Metaverse Intelligence. ידע מוגבר. גישה חופשית.
• CryptoHawk. רדאר אלטקוין. ניסיון חינם.
• מקור: 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/