כוונון עדין מבוזר של דגם BERT Large עבור משימה של תשובות לשאלות באמצעות רובוטריקים של חיבוק פנים ב- Amazon SageMaker

חותמת זמן: 20 בינואר 2022 2:30
צומת המקור: 1885069

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

עם ספריית הקוד הפתוח של Transformers ופלטפורמת ה-ML, Hugging Face הופכת את למידת ההעברה ואת דגמי ה-ML העדכניים לנגישים לקהילת הבינה המלאכותית העולמית, ומצמצמת את הזמן הדרוש למדעני נתונים ומהנדסי ML בחברות ברחבי העולם כדי לנצל כל מידע מדעי חדש. הִתקַדְמוּת.

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

כוונון עדין של המודל כדי לייצר תחזיות מדויקות לבעיה העסקית שעל הפרק מצריך הכשרה של דגמי רובוטריקים גדולים, למשל, BERT, BART, RoBERTa, T5, שיכולים להיות מאתגרים לביצוע בצורה מדרגית.

Hugging Face עובד בשיתוף פעולה הדוק עם SageMaker כדי לספק מיכלי למידה עמוקה מוכנים לשימוש (DLCs) שהופכים את האימון והפריסה של דגמי הרובוטריקים העדכניים ביותר לקלים ומהירים מאי פעם. מכיוון שתכונות כגון SageMaker Data Parallel (SMDP), SageMaker Model Parallel (SMMP), מצב צינור S3, משולבות במיכל, השימוש בהן מקטין באופן דרסטי את הזמן של חברות ליצור פתרונות ML מבוססי רובוטריקים כגון מענה על שאלות, יצירת טקסט ותמונות, אופטימיזציה של תוצאות החיפוש, ומשפרת אוטומציה של תמיכת לקוחות, ממשקי שיחה, חיפוש סמנטי, ניתוחי מסמכים ויישומים רבים נוספים.

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

סקירה כללית של הכשרות מבוזרות

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

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

בהתבסס על מה שאנו רוצים להרחיב (מודל או נתונים) ישנן שתי גישות לאימון מבוזר: נתונים מקבילים ומודל מקביל.

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

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

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

תנאים מוקדמים

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

יישום הדרכה מבוזרת

ספריית Hugging Face Transformers מספקת Trainer API המותאם לאימון או כוונון עדין של הדגמים שהספרייה מספקת. אתה יכול גם להשתמש בו על דגמים משלך אם הם עובדים באותו אופן כמו דגמי רובוטריקים; לִרְאוֹת מאמן לפרטים נוספים. ממשק API זה נמצא בשימוש שלנו סקריפטים לדוגמה, שמראים כיצד לעבד מראש את הנתונים עבור משימות NLP שונות, שאותן תוכל לקחת כמודלים לכתיבת סקריפט הפותר את הבעיה המותאמת אישית שלך. ההבטחה של ה-API של Trainer היא שהסקריפט הזה עובד מחוץ לקופסה בכל הגדרה מבוזרת, כולל SageMaker.

ה-API של Trainer לוקח את כל הדרוש לאימון. זה כולל את מערכי הנתונים שלך, המודל שלך (או פונקציה שמחזירה את המודל שלך), א compute_metrics פונקציה שמחזירה את המדדים שאחריהם ברצונך לעקוב ממערכי החיזויים והתוויות, האופטימיזציה ומתזמן קצב הלמידה שלך (ברירות מחדל טובות מסופקות), כמו גם כל הפרמטרים שאתה יכול לכוונן עבור האימון שלך מקובצים במחלקת נתונים הנקראת TrainingArguments. עם כל זה, הוא חושף שלוש שיטות - לאמן, להעריך ולחזות - כדי לאמן את המודל שלך, לקבל את התוצאות המטריות על כל מערך נתונים, או לקבל את התחזיות על כל מערך נתונים. למידע נוסף על אובייקט ה-Trainer, עיין ב כוונון עדין של דגם עם ה-API של Trainer והסרטון ה-API של Trainer, שמוביל אותך דרך דוגמה פשוטה.

מאחורי הקלעים, ה-API של Trainer מתחיל בניתוח הסביבה שבה אתה משיק את הסקריפט שלך כשאתה יוצר את TrainingArguments. לדוגמה, אם השקת את האימון שלך עם SageMaker, זה מסתכל על SM_FRAMEWORK_PARAMS משתנה בסביבה כדי לזהות אם הפעלת את SageMaker נתונים מקביליות או מקביליות מודל. לאחר מכן הוא מקבל את המשתנים הרלוונטיים (כגון דרגת התהליך או גודל העולם) מהסביבה לפני ביצוע שלבי האתחול הדרושים (כגון smdistributed.dataparallel.torch.distributed.init_process_group()).

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

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

בעת שימוש בשיטות ההערכה והניבוי, המאמן מבצע הערכה מבוזרת, כדי לנצל את כל ה-GPUs שלך. זה מטפל כראוי בפיצול הנתונים שלך עבור כל תהליך (תהליך של אותו דבר dp_rank אם מקביליות מודל מופעלת) ומוודא שהתחזיות נאספו כראוי באותו סדר כמו מערך הנתונים שבו אתה משתמש לפני שהם נשלחים ל- compute_metrics פונקציה או רק חזר. השימוש ב- Trainer API אינו חובה. משתמשים עדיין יכולים להשתמש ב-Keras או PyTorch בתוך Hugging Face. עם זאת, ה-API של Trainer יכול לספק שכבת הפשטה מועילה.

אימון דוגמנית באמצעות SageMaker Hugging Face Estimators

An Estimator הוא ממשק ברמה גבוהה להדרכה של SageMaker ומטפל במשימות הדרכה ופריסה של SageMaker מקצה לקצה. ההכשרה של התסריט שלך מופעלת כשאתה מתקשר fit על HuggingFace אומדן. באומדן, אתה מגדיר באיזה סקריפט כוונון עדין להשתמש entry_point, אשר instance_type להשתמש, ובאילו היפרפרמטרים מועברים. למידע נוסף על HuggingFace פרמטרים, ראה מעריך פנים מחבקים.

אימון מבוזר: נתונים מקבילים

בדוגמה זו, אנו משתמשים ב-DLC החדשים של Hugging Face וב-SageMaker SDK כדי להכשיר מודל מבוזר של Seq2Seq-טרנספורמטור במשימת השאלות והתשובות תוך שימוש בספריות רובוטריקים ומערכות נתונים. ה bert-large-uncased-all-word-masking הדגם מכוון עדין על חוליה מערך נתונים.

דוגמאות הקוד הבאות מציגות את השלבים ליצירת א HuggingFace אומדן לאימון מבוזר עם מקביליות נתונים.

  1. בחר תסריט מחבק פנים רובוטריקים: 
    # git configuration to download our fine-tuning script
git_config = {'repo': 'https://github.com/huggingface/transformers.git','branch': 'v4.6.1'}

כאשר אתה יוצר א HuggingFace Estimator, אתה יכול לציין סקריפט אימון שמאוחסן במאגר GitHub כנקודת הכניסה של ה-Estimator, כך שלא תצטרך להוריד את הסקריפטים באופן מקומי. אתה יכול להשתמש git_config להפעיל את תסריטי הדוגמאות של ה-Huging Face Transformers ו'הענף' הנכון אם שלך transformers_version צריך להגדיר. לדוגמה, אם אתה משתמש transformers_version 4.6.1, עליך להשתמש ב'branch':'v4.6.1'.

  1. קבע תצורה של היפרפרמטרים של אימון המועברים לעבודת ההדרכה: 
    # hyperparameters, which are passed into the training job
hyperparameters={ 'model_name_or_path': 'bert-large-uncased-whole-word-masking', 'dataset_name':'squad', 'do_train': True, 'do_eval': True, 'fp16': True, 'per_device_train_batch_size': 4, 'per_device_eval_batch_size': 4, 'num_train_epochs': 2, 'max_seq_length': 384, 'max_steps': 100, 'pad_to_max_length': True, 'doc_stride': 128, 'output_dir': '/opt/ml/model'
}

כהיפרפרמטר, אנו יכולים להגדיר כל Seq2SeqTrainingArguments ואלה המוגדרים בתסריט האימון.

  1. הגדר את פרמטרי ההפצה ב- HuggingFace מעריך: 
    # configuration for running training on smdistributed Data Parallel
distribution = {'smdistributed':{'dataparallel':{ 'enabled': True }}}

אתה יכול להשתמש ב ספריית מקבילות נתונים של SageMaker מחוץ לקופסה לאימון מבוזר. הוספנו את הפונקציונליות של מקביליות נתונים ישירות ל-Trainer. כדי לאפשר מקביליות נתונים, אתה יכול פשוט להוסיף פרמטר בודד לפרמטר שלך HuggingFace אומדן לאפשר לקוד המבוסס על ה-Trainer שלך להשתמש בו באופן אוטומטי.

  1. צור HuggingFace הערכה הכוללת פרמטרים שהוגדרו בשלבים הקודמים והתחלת אימון:
from sagemaker.huggingface import HuggingFace
# estimator
huggingface_estimator = HuggingFace(entry_point='run_qa.py', source_dir='./examples/pytorch/question-answering', git_config=git_config, instance_type= 'ml.p3.16xlarge', instance_count= 2, volume_size= 200, role= <SageMaker Role>, # IAM role, transformers_version='4.6', pytorch_version='1.7', py_version='py36', distribution= distribution, hyperparameters = hyperparameters) # starting the train job huggingface_estimator.fit()

השמיים מאגר רובוטריקים מחבקים מכיל מספר דוגמאות ותסריטים לכוונון עדין של מודלים במשימות, החל ממודל שפה ועד לסיווג אסימון. במקרה שלנו, אנחנו משתמשים run_qa.py מ examples/pytorch/question-answering דוגמאות.

smdistributed.dataparallel תומך באימון מודלים ב- SageMaker עם סוגי המופעים הבאים בלבד. לביצועים הטובים ביותר, אנו ממליצים להשתמש בסוג מופע התומך מתאם בד אלסטי (EFA):

  • ml.p3.16xlarge
  • ml.p3dn.24xlarge (מומלץ)
  • ml.p4d.24xlarge (מומלץ)

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

הבא מחברת דוגמה מספק הדרכה מפורטת יותר שלב אחר שלב.

אימון מבוזר: מקביל לדגם

לאימון מבוזר עם מקביליות מודל, אנו משתמשים בספריית Hugging Face Transformers ו-Datasettes יחד עם SageMaker SDK לסיווג רצף על הערכת הבנת שפה כללית (GLUE) אמת מידה על אשכול מרובה צמתים, מרובה GPU באמצעות ספריית מקביליות מודל SageMaker.

כמו עם מקביליות נתונים, אנו מגדירים תחילה את תצורת git, אימון היפרפרמטרים ופרמטרי הפצה ב- HuggingFace מעריך:

# git configuration to download our fine-tuning script
git_config = {'repo': 'https://github.com/huggingface/transformers.git','branch': 'v4.6.1'} # hyperparameters, which are passed into the training job
hyperparameters={ 'model_name_or_path':'roberta-large', 'task_name': 'mnli', 'per_device_train_batch_size': 16, 'per_device_eval_batch_size': 16, 'do_train': True, 'do_eval': True, 'do_predict': True, 'num_train_epochs': 2, 'output_dir':'/opt/ml/model', 'max_steps': 500,
} # configuration for running training on smdistributed Model Parallel
mpi_options = { "enabled" : True, "processes_per_host" : 8,
}
smp_options = { "enabled":True, "parameters": { "microbatches": 4, "placement_strategy": "spread", "pipeline": "interleaved", "optimize": "speed", "partitions": 4, "ddp": True, }
} distribution={ "smdistributed": {"modelparallel": smp_options}, "mpi": mpi_options
}

ספריית המקביליות של המודל משתמשת באופן פנימי ב-MPI, כך שכדי להשתמש במקביל במודל, יש להפעיל את MPI באמצעות פרמטר ההפצה. "processes_per_host” בקוד הקודם מציין את מספר התהליכים ש-MPI צריך להפעיל בכל מארח. אנו מציעים אותם לפיתוח ובדיקה. בזמן הייצור, אתה יכול לפנות לתמיכה של AWS אם אתה מבקש קיבולת GPU נרחבת. למידע נוסף, ראה הפעל משרת אימון מקבילית של SageMaker מודל מבוזרת.

הבא מחברת דוגמה מכיל את סקריפטי הקוד המלאים.

מופעי ספוט

עם תוסף המסגרת של Hugging Face עבור SageMaker Python SDK, נוכל גם לנצל את היתרון המנוהל במלואו ענן מחשוב אלסטי של אמזון (אמזון EC2) מופעי ספוט ולחסוך עד 90% מעלות ההדרכה שלנו.

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

כדי להשתמש ב- Spot Instances עם ה HuggingFace מעריך, אנחנו צריכים להגדיר את use_spot_instances פרמטר ל-True ולהגדיר את שלך max_wait ו max_run זְמַן. למידע נוסף על מחזור החיים של אימון נקודתי מנוהל, ראה ניהל אימוני ספוט באמזון SageMaker.

להלן קטע קוד להגדרת מעריך אימון נקודתי:

from sagemaker.huggingface import HuggingFace # hyperparameters, which are passed into the training job
hyperparameters={'epochs': 1, 'train_batch_size': 32, 'model_name':'distilbert-base-uncased', 'output_dir':'/opt/ml/checkpoints' } # s3 uri where our checkpoints will be uploaded during training
job_name = "using-spot"
checkpoint_s3_uri = f's3://{sess.default_bucket()}/{job_name}/checkpoints' huggingface_estimator = HuggingFace(entry_point='train.py', source_dir='./scripts', instance_type='ml.p3.2xlarge', instance_count=1, base_job_name=job_name, checkpoint_s3_uri=checkpoint_s3_uri, use_spot_instances=True, max_wait=3600, # This should be equal to or greater than max_run in seconds' max_run=1000, # expected max run in seconds role=role, transformers_version='4.6', pytorch_version='1.7', py_version='py36', hyperparameters = hyperparameters)

הבא מחברה מכיל את סקריפטי הקוד המלאים.

סיכום

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

במקרה השימוש בהקבלת נתונים שדנו בו, אימון מודל על מופע אחד של p3.2xlarge (עם GPU יחיד) לוקח 4 שעות ועולה בערך $15 בזמן כתיבת שורות אלה. עם מקביליות נתונים, נוכל לאמן את אותו דגם תוך 24 דקות בעלות של 28$. למרות שהעלות הוכפלה, זה הפחית את זמן האימון בפקטור של 10. במצב בו צריך להכשיר דגמים רבים תוך פרק זמן קצר, מקביליות נתונים יכולה לאפשר זאת בתוספת עלות נמוכה יחסית. באשר למקרה השימוש במודל המקביליות, הוא מוסיף את היכולת לאמן דגמים שלא יכלו להיות מאומנים קודם לכן בכלל בגלל מגבלות חומרה. שתי התכונות מאפשרות זרימות עבודה חדשות עבור מתרגלי ML, והן נגישות בקלות דרך HuggingFace הערכה כחלק מ-SageMaker Python SDK. פריסת מודלים אלה לנקודות קצה מתארחות מתבצעת באותו הליך כמו עבור אומדנים אחרים.

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

על הכותבים

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

ג'יימס יי הוא Sr. AI/ML Partner Solutions Architect בצוות Emerging Technologies ב- Amazon Web Services. הוא נלהב לעבוד עם לקוחות ארגוניים ושותפים לתכנון, פריסה והרחבה של יישומי AI/ML כדי להפיק את הערכים העסקיים שלהם. מחוץ לעבודה, הוא נהנה לשחק כדורגל, לטייל ולבלות עם משפחתו.

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

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

ג'ף בודייה בונה מוצרים בחברת Hugging Face, היוצר של Transformers, ספריית ה-ML המובילה בקוד פתוח. בעבר ג'ף היה מייסד שותף של Stupeflix, שנרכשה על ידי GoPro, שם שימש כמנהל ניהול מוצר, שיווק מוצר, פיתוח עסקי ופיתוח תאגידי.

מקור: https://aws.amazon.com/blogs/machine-learning/distributed-fine-tuning-of-a-bert-large-model-for-a-question-answering-task-using-hugging-face- שנאים-על-amazon-sagemaker/

בול זמן:

עוד מ בלוג למידת מכונות AWS