בעת פריסת מודלים של Deep Learning בקנה מידה, זה חיוני להשתמש ביעילות בחומרה הבסיסית כדי למקסם את הביצועים ואת העלות היתרונות. עבור עומסי עבודה של ייצור הדורשים תפוקה גבוהה והשהייה נמוכה, הבחירה של ענן מחשוב אלסטי של אמזון מופע (EC2), מודל שרת מחסנית וארכיטקטורת פריסה חשובים מאוד. ארכיטקטורה לא יעילה עלולה להוביל לניצול לא מיטבי של המאיצים ולעלות ייצור גבוהה שלא לצורך.
בפוסט זה נלווה אותך בתהליך של פריסת שרתי מודל FastAPI במכשירי AWS Inferentia (נמצא ב- Amazon EC2 אינפ 1 ואמזון EC אינפ 2 מקרים). אנו גם מדגימים אירוח של דגם לדוגמה שנפרס במקביל בכל NeuronCores לניצול מקסימלי של החומרה.
סקירת פתרונות
FastAPI היא מסגרת אינטרנט בקוד פתוח לשרת יישומי Python שהיא הרבה יותר מהירה ממסגרות מסורתיות כמו Flask ו-Django. הוא משתמש ב- ממשק שער שרת אסינכרוני (ASGI) במקום בשימוש נרחב ממשק שער שרת האינטרנט (WSGI). ASGI מעבד בקשות נכנסות באופן אסינכרוני בניגוד ל-WSGI שמעבד בקשות ברצף. זה הופך את FastAPI לבחירה האידיאלית לטיפול בבקשות רגישות לאחזור. אתה יכול להשתמש ב-FastAPI כדי לפרוס שרת המארח נקודת קצה במופעי Inferentia (Inf1/Inf2) שמאזין לבקשות הלקוח דרך יציאה ייעודית.
המטרה שלנו היא להשיג את הביצועים הגבוהים ביותר בעלות הנמוכה ביותר באמצעות ניצול מקסימלי של החומרה. זה מאפשר לנו להתמודד עם יותר בקשות מסקנות עם פחות מאיצים. כל מכשיר AWS Inferentia1 מכיל ארבעה NeuronCores-v1 וכל מכשיר AWS Inferentia2 מכיל שני NeuronCores-v2. ה AWS נוירון SDK מאפשר לנו להשתמש בכל אחד מה-NeuronCores במקביל, מה שנותן לנו יותר שליטה בטעינה והסקת ארבעה דגמים או יותר במקביל מבלי להקריב את התפוקה.
עם FastAPI, יש לך בחירת שרת אינטרנט Python (גוניקהורן, אוֹיקָן, היפרקורן, דַפנָה). שרתי אינטרנט אלו מספקים שכבת הפשטה על גבי המודל הבסיסי של Machine Learning (ML). ללקוח המבקש יש את היתרון שהוא לא מודע למודל המתארח. לקוח לא צריך לדעת את שם הדגם או את הגרסה שנפרסה מתחת לשרת; שם נקודת הקצה הוא כעת רק פרוקסי לפונקציה שטוענת ומריצה את המודל. לעומת זאת, בכלי הגשה ספציפי למסגרת, כמו TensorFlow Serving, שם הדגם והגרסה הם חלק משם נקודת הקצה. אם המודל משתנה בצד השרת, הלקוח צריך לדעת ולשנות את קריאת ה-API שלו לנקודת הקצה החדשה בהתאם. לכן, אם אתה מפתח ברציפות את דגמי הגרסה, כמו במקרה של בדיקות A/B, אז השימוש בשרת אינטרנט גנרי של Python עם FastAPI הוא דרך נוחה להגיש מודלים, מכיוון ששם נקודת הקצה הוא סטטי.
תפקידו של שרת ASGI הוא להוליד מספר מוגדר של עובדים שמאזינים לבקשות לקוח ומריצים את קוד ההסקה. יכולת חשובה של השרת היא לוודא שמספר העובדים המבוקש זמין ופעיל. במקרה שעובד נהרג, השרת חייב להפעיל עובד חדש. בהקשר זה, השרת והעובדים עשויים להיות מזוהים על ידי מזהה תהליך Unix שלהם (PID). עבור פוסט זה, אנו משתמשים ב-a היפרקורן שרת, שהוא בחירה פופולרית עבור שרתי אינטרנט של Python.
בפוסט זה, אנו חולקים שיטות עבודה מומלצות לפריסת מודלים של למידה עמוקה עם FastAPI ב-AWS Inferentia NeuronCores. אנו מראים שאתה יכול לפרוס דגמים מרובים על NeuronCores נפרדים שניתן לקרוא להם במקביל. הגדרה זו מגדילה את התפוקה מכיוון שניתן להסיק דגמים מרובים במקביל והניצול של NeuronCore מותאם באופן מלא. את הקוד ניתן למצוא ב- GitHub ריפו. האיור הבא מציג את הארכיטקטורה של איך להגדיר את הפתרון במופע EC2 Inf2.
אותה ארכיטקטורה חלה על סוג מופע EC2 Inf1 למעט שיש לו ארבע ליבות. אז זה משנה מעט את דיאגרמת הארכיטקטורה.
AWS Inferentia NeuronCores
בואו נחפור קצת יותר עמוק לתוך הכלים שסופק על ידי AWS Neuron ליצירת קשר עם NeuronCores. הטבלאות הבאות מציגות את מספר NeuronCores בכל סוג מופע Inf1 ו-Inf2. ה-vCPUs המארח וזיכרון המערכת משותפים לכל NeuronCores הזמינים.
גודל מופע | # מאיצי הסקת מסקנות | # NeuronCores-v1 | מעבדי vCPU | זיכרון (GiB) |
Inf1.xlarge | 1 | 4 | 4 | 8 |
Inf1.2xlarge | 1 | 4 | 8 | 16 |
Inf1.6xlarge | 4 | 16 | 24 | 48 |
Inf1.24xlarge | 16 | 64 | 96 | 192 |
גודל מופע | # מאיצי הסקת מסקנות | # NeuronCores-v2 | מעבדי vCPU | זיכרון (GiB) |
Inf2.xlarge | 1 | 2 | 4 | 32 |
Inf2.8xlarge | 1 | 2 | 32 | 32 |
Inf2.24xlarge | 6 | 12 | 96 | 192 |
Inf2.48xlarge | 12 | 24 | 192 | 384 |
מופעי Inf2 מכילים את NeuronCores-v2 החדש בהשוואה ל-NeuronCore-v1 במופעי Inf1. למרות פחות ליבות, הם מסוגלים להציע תפוקה גבוהה פי 4 והשהייה נמוכה פי 10 בהשוואה למופעי Inf1. מופעי Inf2 הם אידיאליים לעומסי עבודה של למידה עמוקה כמו AI Generative, Large Language Models (LLM) במשפחת OPT/GPT ושנאי ראייה כמו Stable Diffusion.
Neuron Runtime אחראי להרצת דגמים במכשירי Neuron. Neuron Runtime קובע איזה NeuronCore יריץ איזה דגם וכיצד להפעיל אותו. תצורה של Neuron Runtime נשלטת באמצעות שימוש ב משתני סביבה ברמת התהליך. כברירת מחדל, הרחבות Neuron Framework ידאגו לתצורת Neuron Runtime מטעם המשתמש; עם זאת, תצורות מפורשות אפשריות גם להשיג התנהגות אופטימלית יותר.
שני משתני סביבה פופולריים הם NEURON_RT_NUM_CORES
ו NEURON_RT_VISIBLE_CORES
. עם משתני סביבה אלה, ניתן לקשור תהליכי Python ל-NeuronCore. עם NEURON_RT_NUM_CORES
, ניתן לשמור מספר מוגדר של ליבות לתהליך, ועם NEURON_RT_VISIBLE_CORES
, ניתן להזמין מגוון של NeuronCores. לדוגמה, NEURON_RT_NUM_CORES=2 myapp.py
ישמור שתי ליבות ו NEURON_RT_VISIBLE_CORES=’0-2’ myapp.py
ישמור אפס, אחד ושתי ליבות עבור myapp.py
. אתה יכול להזמין NeuronCores בין מכשירים (שבבי AWS Inferentia) גם כן. כך, NEURON_RT_VISIBLE_CORES=’0-5’ myapp.py
ישמור את ארבע הליבות הראשונות device1
וליבה אחת על device2
בסוג מופע Ec2 Inf1. באופן דומה, בסוג מופע EC2 Inf2, תצורה זו תשמור שתי ליבות על פני device1
ו device2
וליבה אחת על device3
. הטבלה הבאה מסכמת את התצורה של משתנים אלה.
שם | תיאור | סוּג | ערכים צפויים | ערך ברירת מחדל | גרסת RT |
NEURON_RT_VISIBLE_CORES |
טווח של NeuronCores ספציפיים הדרושים לתהליך | טווח מספרים שלמים (כמו 1-3) | כל ערך או טווח בין 0 ל- Max NeuronCore במערכת | ללא חתימה | 2.0 + |
NEURON_RT_NUM_CORES |
מספר NeuronCores הנדרש בתהליך | מספר שלם | ערך מ-1 עד Max NeuronCore במערכת | 0, שמתפרש כ"הכל" | 2.0 + |
לרשימה של כל משתני הסביבה, עיין ב תצורת זמן ריצה של Neuron.
כברירת מחדל, בעת טעינת מודלים, מודלים נטענים על NeuronCore 0 ולאחר מכן על NeuronCore 1, אלא אם כן צוין במפורש על ידי משתני הסביבה הקודמים. כפי שצוין קודם לכן, ה- NeuronCores חולקים את ה-vCPUs המארחים ואת זיכרון המערכת הזמינים. לכן, מודלים הפרוסים על כל NeuronCore יתחרו על המשאבים הזמינים. זו לא תהיה בעיה אם המודל משתמש ב- NeuronCores במידה רבה. אבל אם מודל פועל רק בחלקו על ה-NeuronCores והשאר על מעבדי vCPU מארח, אז בחינת זמינות ה-CPU לכל NeuronCore הופכת חשובה. זה משפיע גם על בחירת המופע.
הטבלה הבאה מציגה את מספר ה-vCPUs המארח וזיכרון המערכת הזמינים לכל דגם אם דגם אחד נפרס לכל NeuronCore. בהתאם לשימוש ב-NeuronCore, ב-vCPU ובזיכרון של היישום שלך, מומלץ להריץ בדיקות כדי לגלות איזו תצורה היא הביצועית ביותר עבור היישום שלך. ה כלי Neuron Top יכול לעזור בהמחשת ניצול הליבה וניצול זיכרון המכשיר והמארח. על סמך מדדים אלו ניתן לקבל החלטה מושכלת. אנו מדגימים את השימוש ב- Neuron Top בסוף הבלוג הזה.
גודל מופע | # מאיצי הסקת מסקנות | # דגמים | vCPUs/דגם | זיכרון/דגם (GiB) |
Inf1.xlarge | 1 | 4 | 1 | 2 |
Inf1.2xlarge | 1 | 4 | 2 | 4 |
Inf1.6xlarge | 4 | 16 | 1.5 | 3 |
Inf1.24xlarge | 16 | 64 | 1.5 | 3 |
גודל מופע | # מאיצי הסקת מסקנות | # דגמים | vCPUs/דגם | זיכרון/דגם (GiB) |
Inf2.xlarge | 1 | 2 | 2 | 8 |
Inf2.8xlarge | 1 | 2 | 16 | 64 |
Inf2.24xlarge | 6 | 12 | 8 | 32 |
Inf2.48xlarge | 12 | 24 | 8 | 32 |
כדי לבדוק את תכונות ה- Neuron SDK בעצמך, עיין במאפיינים האחרונים יכולות נוירון עבור PyTorch.
התקנת מערכת
להלן הגדרת המערכת המשמשת לפתרון זה:
הגדר את הפתרון
יש כמה דברים שעלינו לעשות כדי להגדיר את הפתרון. התחל ביצירת תפקיד IAM שמופע ה-EC2 שלך הולך לקבל שיאפשר לו לדחוף ולמשוך ממנו מרשם מיכל אלסטי של אמזון.
שלב 1: הגדר את תפקיד IAM
- התחל בכניסה למסוף וגישה ל-IAM > תפקידים > צור תפקיד
- בחר סוג ישות מהימנה
AWS Service
- בחר EC2 כשירות תחת שימוש-מקרה
- נְקִישָׁה הַבָּא ותוכל לראות את כל המדיניות הזמינה
- לצורך פתרון זה, אנו הולכים לתת למופע ה-EC2 שלנו גישה מלאה ל-ECR. סינון עבור AmazonEC2ContainerRegistryFullAccess ובחר אותו.
- לחץ על הבא ושם לתפקיד
inf-ecr-access
הערה: המדיניות שצירפנו מעניקה למופע EC2 גישה מלאה לאמזון ECR. אנו ממליצים בחום לעקוב אחר ה מנהל המינימום-פריבילגיה לעומסי עבודה בייצור.
שלב 2: הגדר את AWS CLI
אם אתה משתמש ב-Deep Learning AMI שנקבע לעיל, הוא מגיע עם AWS CLI מותקן. אם אתה משתמש ב-AMI אחר (Amazon Linux 2023, Base Ubuntu וכו'), התקן את כלי CLI על ידי ביצוע מדריך זה.
לאחר שהתקנת את כלי ה-CLI, הגדר את ה-CLI באמצעות הפקודה aws configure
. אם יש לך מפתחות גישה, אתה יכול להוסיף אותם כאן אבל לא בהכרח צריך אותם כדי ליצור אינטראקציה עם שירותי AWS. אנחנו מסתמכים על תפקידי IAM כדי לעשות זאת.
הערות: עלינו להזין ערך אחד לפחות (אזור ברירת מחדל או פורמט ברירת מחדל) כדי ליצור את פרופיל ברירת המחדל. עבור הדוגמה הזו, אנחנו הולכים עם us-east-2
כמו האזור ו json
כפלט ברירת המחדל.
שכפל את מאגר Github
השמיים GitHub ריפו מספק את כל הסקריפטים הדרושים לפריסת מודלים באמצעות FastAPI ב- NeuronCores במופעי AWS Inferentia. דוגמה זו משתמשת בקונטיינרים של Docker כדי להבטיח שנוכל ליצור פתרונות לשימוש חוזר. כלול בדוגמה זו את הדברים הבאים config.properties קובץ למשתמשים לספק קלט.
קובץ התצורה זקוק לקידומות שמות המוגדרות על ידי המשתמש עבור תמונת Docker ומכולות Docker. ה build.sh
תסריט ב fastapi
ו trace-model
תיקיות משתמשות בכך כדי ליצור תמונות Docker.
הרכיב מודל על AWS Inferentia
נתחיל במעקב אחר הדגם ובהפקת קובץ PyTorch Torchscript.pt. התחל בגישה trace-model
ספריה ושינוי קובץ ה-env. בהתאם לסוג המופע שבחרת, שנה את ה CHIP_TYPE
בתוך .env
קוֹבֶץ. כדוגמה, נבחר ב-Inf2 כמדריך. אותם שלבים חלים על תהליך הפריסה עבור Inf1.
לאחר מכן הגדר את אזור ברירת המחדל באותו קובץ. אזור זה ישמש ליצירת מאגר ECR ותמונות Docker יידחקו למאגר זה. גם בתיקייה זו, אנו מספקים את כל הסקריפטים הדרושים כדי להתחקות אחר א bert-base-uncased
דגם על AWS Inferentia. סקריפט זה יכול לשמש עבור רוב הדגמים הזמינים ב פנים מחבקות. ה דוקרפיל יש לו את כל התלות להפעיל מודלים עם Neuron ומפעיל את trace-model.py קוד כנקודת הכניסה.
הוסבר אוסף נוירונים
ה-API של Neuron SDK דומה מאוד ל-PyTorch Python API. ה torch.jit.trace()
מ- PyTorch לוקח את המודל ואת טנזור הקלט לדוגמה כארגומנטים. התשומות לדוגמה מוזנות למודל והפעולות המופעלות כאשר הקלט הזה עושה את דרכו בשכבות המודל מתועדות כ TorchScript. למידע נוסף על JIT Tracing ב- PyTorch, עיין בסעיף הבא תיעוד.
בדיוק כמו torch.jit.trace()
, אתה יכול לבדוק אם ניתן להרכיב את המודל שלך ב-AWS Inferentia עם הקוד הבא עבור מופעי inf1.
עבור inf2, הספרייה נקראת torch_neuronx
. הנה איך אתה יכול לבדוק את הידור המודל שלך מול מופעי inf2.
לאחר יצירת מופע המעקב, נוכל להעביר את קלט הטנזור לדוגמה כך:
ולבסוף שמור את פלט TorchScript שהתקבל בדיסק המקומי
כפי שמוצג בקוד הקודם, אתה יכול להשתמש compiler_args
ו optimizations
כדי לייעל את הפריסה. לרשימה מפורטת של טיעונים עבור torch.neuron.trace
API, עיין ב PyTorch-Neuron trace python API.
זכור את הנקודות החשובות הבאות:
- ה- Neuron SDK אינו תומך בצורות טנזור דינמיות נכון לכתיבת שורות אלה. לכן, מודל יצטרך להיות מורכב בנפרד עבור צורות קלט שונות. למידע נוסף על הפעלת הסקת מסקנות על צורות קלט משתנות עם דליית, עיין ב הפעלת מסקנות על צורות קלט משתנות עם דליית.
- אם אתה נתקל בבעיות של חוסר זיכרון בעת הידור של מודל, נסה להדר את המודל על מופע AWS Inferentia עם יותר vCPUs או זיכרון, או אפילו מופע c6i או r6i גדול מכיוון שהקומפילציה משתמשת רק במעבדים. לאחר הקומפילציה, המודל המתחקה כנראה יכול להיות מופעל על גדלי מופעים קטנים יותר של AWS Inferentia.
בניית הסבר תהליך
כעת נבנה את המיכל הזה על ידי ריצה build.sh. קובץ הסקריפט לבנות פשוט יוצר את תמונת Docker על ידי משיכת תמונת Deep Learning Container בסיסית והתקנת HuggingFace transformers
חֲבִילָה. מבוסס על ה CHIP_TYPE
שצוין ב .env
קובץ, docker.properties
הקובץ מחליט על המתאים BASE_IMAGE
. זֶה BASE_IMAGE
מצביע על תמונת מיכל ללמידה עמוקה עבור Neuron Runtime שסופקה על ידי AWS.
זה זמין דרך מאגר ECR פרטי. לפני שנוכל למשוך את התמונה, עלינו להתחבר ולקבל אישורי AWS זמניים.
הערות: עלינו להחליף את האזור הרשום בפקודה שצוינה בדגל האזור ובתוך URI המאגר באזור ששמנו ב- .v קובץ.
כדי להקל על תהליך זה, אנו יכולים להשתמש ב- fetch-credentials.sh
קוֹבֶץ. האזור יילקח מקובץ ה-.env באופן אוטומטי.
לאחר מכן, נדחוף את התמונה באמצעות הסקריפט push.sh. סקריפט הדחיפה יוצר עבורך מאגר באמזון ECR ודוחף את תמונת המכולה.
לבסוף, כאשר התמונה נבנית ונדחפת, נוכל להפעיל אותה כמיכל על ידי ריצה run.sh וזנב ריצה יומני עם logs.sh. ביומני המהדר (ראה את צילום המסך הבא), תראה את אחוז האופרטורים האריתמטיים שקומפלו על Neuron ואחוז תת-גרפים של מודלים שהורכבו בהצלחה על Neuron. צילום המסך מציג את יומני המהדר עבור bert-base-uncased-squad2
דֶגֶם. היומנים מראים ש-95.64% מהאופרטורים האריתמטיים חוברו, והוא גם נותן רשימה של אופרטורים שהורשמו על Neuron וכאלה שאינם נתמכים.
הנה רשימה מכל המפעילים הנתמכים בחבילת PyTorch Neuron העדכנית ביותר. באופן דומה, הנה הרשימה מכל המפעילים הנתמכים בחבילת PyTorch Neuronx העדכנית ביותר.
פרוס מודלים עם FastAPI
לאחר הידור של המודלים, המודל המתחקה יהיה קיים ב- trace-model
תיקייה. בדוגמה זו, מיקמנו את המודל המתחקה עבור גודל אצווה של 1. אנו רואים כאן גודל אצווה של 1 כדי לקחת בחשבון את מקרי השימוש שבהם גודל אצווה גבוה יותר אינו אפשרי או נדרש. למקרי שימוש בהם יש צורך בגדלים גבוהים יותר של אצווה, ה torch.neuron.DataParallel (עבור Inf1) או torch.neuronx.DataParallel (עבור Inf2) API עשוי גם להיות שימושי.
השמיים מהיר-API התיקייה מספקת את כל הסקריפטים הדרושים לפריסת מודלים עם FastAPI. כדי לפרוס את הדגמים ללא כל שינוי, פשוט הפעל את deploy.sh סקריפט והוא יבנה תמונת קונטיינר של FastAPI, יפעיל קונטיינרים על מספר הליבות שצוין ויפרוס את מספר הדגמים שצוין לכל שרת בכל שרת מודל FastAPI. תיקיה זו מכילה גם א .env
קובץ, שנה אותו כך שישקף את הקובץ הנכון CHIP_TYPE
ו AWS_DEFAULT_REGION
.
הערות: סקריפטים של FastAPI מסתמכים על אותם משתני סביבה המשמשים לבנייה, דחיפה והרצה של התמונות כמכולות. סקריפטים של פריסת FastAPI ישתמשו בערכים האחרונים הידועים מהמשתנים הללו. לכן, אם עקבת אחר המודל עבור סוג המופע של Inf1, המודל הזה ייפרס באמצעות סקריפטים אלה.
השמיים fastapi-server.py קובץ שאחראי על אירוח השרת ושליחת הבקשות לדגם עושה את הפעולות הבאות:
- קורא את מספר הדגמים לשרת ואת המיקום של המודל המהודר מקובץ המאפיינים
- מגדיר NeuronCores גלויים כמשתני סביבה למיכל Docker וקורא את משתני הסביבה כדי לציין באילו NeuronCores להשתמש
- מספק ממשק API להסקת ה-
bert-base-uncased-squad2
מודל - עם
jit.load()
, טוען את מספר הדגמים לכל שרת כפי שצוין בתצורה ומאחסן את המודלים ואת הטוקנים הנדרשים במילונים גלובליים
עם הגדרה זו, יהיה קל יחסית להגדיר ממשקי API שמפרטים אילו דגמים וכמה דגמים מאוחסנים בכל NeuronCore. באופן דומה, אפשר לכתוב ממשקי API כדי למחוק מודלים מ- NeuronCores ספציפיים.
השמיים דוקרפיל לבניית מכולות FastAPI בנוי על תמונת Docker שבנינו למעקב אחר המודלים. זו הסיבה ש- docker.properties הקובץ מציין את נתיב ה-ECR לתמונת Docker לצורך מעקב אחר הדגמים. בהגדרה שלנו, הקונטיינרים של Docker בכל NeuronCores דומים, כך שנוכל לבנות תמונה אחת ולהריץ קונטיינרים מרובים מתמונה אחת. כדי למנוע שגיאות נקודת כניסה, אנו מציינים ENTRYPOINT ["/usr/bin/env"]
ב-Dockerfile לפני הפעלת startup.sh
תסריט, שנראה כמו hypercorn fastapi-server:app -b 0.0.0.0:8080
. סקריפט הפעלה זה זהה לכל המכילים. אם אתה משתמש באותה תמונת בסיס כמו למעקב אחר מודלים, אתה יכול לבנות את המיכל הזה על ידי הפעלת הסקריפט build.sh. ה push.sh
הסקריפט נשאר זהה לקודם לאיתור דגמים. תמונת ה-Docker ושם המכולה שהשתנו מסופקים על ידי docker.properties
קובץ.
השמיים run.sh file
עושה את הפעולות הבאות:
- קורא את תמונת ה-Docker ואת שם המיכל מה- נכסים קובץ, אשר בתורו קורא את
config.properties
קובץ, שיש בו אnum_cores
הגדרות משתמש - מתחיל לולאה מ-0 עד
num_cores
ולכל ליבה:- מגדיר את מספר היציאה ומספר ההתקן
- קובע את
NEURON_RT_VISIBLE_CORES
משתנה הסביבה - מציין את עוצמת הקול
- מפעיל קונטיינר Docker
לשם הבהירות, פקודת ההפעלה של Docker לפריסה ב- NeuronCore 0 עבור Inf1 תיראה כמו הקוד הבא:
פקודת ההפעלה לפריסה ב- NeuronCore 5 תיראה כמו הקוד הבא:
לאחר פריסת המכולות, אנו משתמשים ב- run_apis.py script, הקורא לממשקי ה-API בשרשורים מקבילים. הקוד מוגדר להתקשר לשישה דגמים שנפרסו, אחד בכל NeuronCore, אך ניתן לשנות אותו בקלות להגדרה אחרת. אנו קוראים לממשקי ה-API מצד הלקוח באופן הבא:
ניטור NeuronCore
לאחר פריסת שרתי המודל, כדי לפקח על ניצול NeuronCore, אנו עשויים להשתמש neuron-top
לצפות בזמן אמת באחוז הניצול של כל NeuronCore. נוירון-טופ הוא כלי CLI ב- Neuron SDK כדי לספק מידע כגון NeuronCore, vCPU וניצול זיכרון. במסוף נפרד, הזן את הפקודה הבאה:
הפלט שלך צריך להיות דומה לאיור הבא. בתרחיש זה, ציינו להשתמש בשני NeuronCores ושני מודלים לכל שרת במופע Inf2.xlarge. צילום המסך הבא מראה ששני דגמים בגודל 287.8MB כל אחד נטענים על שני NeuronCores. עם סך של 4 דגמים טעונים, אתה יכול לראות את זיכרון המכשיר בשימוש הוא 1.3 GB. השתמש במקשי החצים כדי לעבור בין NeuronCores במכשירים שונים
באופן דומה, בסוג מופע Inf1.16xlarge אנו רואים סך של 12 דגמים (2 דגמים לכל ליבה על פני 6 ליבות) נטענים. נצרך זיכרון כולל של 2.1GB וכל דגם בגודל 177.2MB.
אחרי שאתה מנהל את run_apis.py סקריפט, אתה יכול לראות את אחוז הניצול של כל אחת מששת NeuronCores (ראה את צילום המסך הבא). אתה יכול גם לראות את השימוש ב-vCPU של המערכת ואת השימוש ב-vCPU בזמן ריצה.
צילום המסך הבא מציג את אחוז השימוש בליבת המופע של Inf2.
באופן דומה, צילום מסך זה מציג ניצול ליבה בסוג מופע inf1.6xlarge.
לנקות את
כדי לנקות את כל מכולות ה-Docker שיצרת, אנו מספקים א cleanup.sh סקריפט שמסיר את כל הקונטיינרים הפועלים והעצורים. סקריפט זה יסיר את כל הקונטיינרים, אז אל תשתמש בו אם ברצונך להשאיר חלק מהמכולות פועלות.
סיכום
לעומסי עבודה בייצור יש לרוב תפוקה גבוהה, זמן אחזור נמוך ועלויות. ארכיטקטורות לא יעילות המנצלות באופן לא אופטימלי מאיצים עלולות להוביל לעלויות ייצור גבוהות שלא לצורך. בפוסט זה, הראינו כיצד לנצל בצורה אופטימלית את NeuronCores עם FastAPI כדי למקסם את התפוקה במינימום זמן השהייה. פרסמנו את ההוראות אצלנו GitHub ריפו. עם ארכיטקטורת פתרון זו, אתה יכול לפרוס מודלים מרובים בכל NeuronCore ולהפעיל מספר מודלים במקביל על NeuronCores שונים מבלי לאבד ביצועים. למידע נוסף על איך לפרוס מודלים בקנה מידה עם שירותים כמו שירות קוברנט של אמזון (Amazon EKS), עיין הגישו 3,000 דגמי למידה מעמיקה ב- Amazon EKS עם AWS Inferentia תמורת פחות מ- $ 50 לשעה.
על המחברים
אנקור סריבסטאבה הוא אדריכל פתרונות Sr. בצוות ML Frameworks. הוא מתמקד בסיוע ללקוחות עם הכשרה מבוזרת בניהול עצמי והסקת מסקנות בקנה מידה על AWS. הניסיון שלו כולל תחזוקה חיזוי תעשייתי, תאומים דיגיטליים, אופטימיזציה של עיצוב הסתברותי והשלים את לימודי הדוקטורט שלו מהנדסת מכונות באוניברסיטת רייס ומחקר פוסט-דוקטורט מהמכון הטכנולוגי של מסצ'וסטס.
KC טונג הוא ארכיטקט פתרונות בכיר במעבדות AWS Annapurna. הוא מתמחה בהדרכה ובפריסה של מודלים גדולים של למידה עמוקה בקנה מידה בענן. יש לו דוקטורט. בביופיזיקה מולקולרית מהמרכז הרפואי הדרום-מערבי של אוניברסיטת טקסס בדאלאס. הוא דיבר ב-AWS Summits וב-AWS Reinvent. כיום הוא עוזר ללקוחות להכשיר ולפרוס דגמי PyTorch ו-TensorFlow גדולים בענן AWS. הוא מחברם של שני ספרים: למד את TensorFlow Enterprise ו TensorFlow 2 Pocket Reference.
פרונוי צ'ופרה הוא ארכיטקט פתרונות בכיר בצוות ה-Startups Generative AI ב-AWS. הוא מתמחה באדריכלות ופיתוח פתרונות IoT ו-Machine Learning. הוא היה שותף להקמת שני סטארטאפים בעבר ונהנה להיות פעיל בפרויקטים בתחום ה-IoT, AI/ML ו-Serverless.
- הפצת תוכן ויחסי ציבור מופעל על ידי SEO. קבל הגברה היום.
- PlatoData.Network Vertical Generative Ai. העצים את עצמך. גישה כאן.
- PlatoAiStream. Web3 Intelligence. הידע מוגבר. גישה כאן.
- PlatoESG. רכב / רכבים חשמליים, פחמן, קלינטק, אנרגיה, סביבה, שמש, ניהול פסולת. גישה כאן.
- BlockOffsets. מודרניזציה של בעלות על קיזוז סביבתי. גישה כאן.
- מקור: https://aws.amazon.com/blogs/machine-learning/optimize-aws-inferentia-utilization-with-fastapi-and-pytorch-models-on-amazon-ec2-inf1-inf2-instances/
- :יש ל
- :הוא
- :לֹא
- :איפה
- $ למעלה
- 000
- 1
- 1.3
- 10
- 100
- 12
- 13
- 15%
- 2023
- 7
- 8
- 91
- a
- יכול
- אודות
- מֵעַל
- הפשטה
- מאיצים
- גישה
- גישה
- לפיכך
- חֶשְׁבּוֹן
- להשיג
- לרוחב
- פעיל
- להוסיף
- נגד
- AI
- AI / ML
- תעשיות
- להתיר
- מאפשר
- גם
- אמזון בעברית
- אמזון
- אמזון שירותי אינטרנט
- an
- ו
- כל
- API
- ממשקי API
- האפליקציה
- בקשה
- יישומים
- החל
- מתאים
- ארכיטקטורה
- ARE
- טיעונים
- AS
- לְהַנִיחַ
- At
- מחבר
- באופן אוטומטי
- זמינות
- זמין
- לְהִמָנַע
- AWS
- Afer Inferentia
- בסיס
- מבוסס
- BE
- כי
- להיות
- היה
- לפני
- בשם
- התנהגות
- להיות
- תועלת
- הטבות
- הטוב ביותר
- שיטות עבודה מומלצות
- בֵּין
- ביופיסיקה
- קצת
- בלוג
- ספרים
- לִבנוֹת
- בִּניָן
- נבנה
- אבל
- by
- שיחה
- נקרא
- שיחות
- CAN
- יכולות
- יכולת
- אשר
- מקרה
- מקרים
- מרכז
- שינוי
- השתנה
- שינויים
- לבדוק
- שבבי
- בחירה
- בחרו
- בחר
- בהירות
- לקוחות
- מקרוב
- ענן
- קוד
- מגיע
- השוואה
- להתחרות
- השלמת
- לחשב
- תְצוּרָה
- לשקול
- בהתחשב
- קונסול
- מאוכל
- להכיל
- מכולה
- מכולות
- מכיל
- הקשר
- ברציפות
- לעומת זאת
- לִשְׁלוֹט
- נשלט
- נוֹחַ
- ליבה
- לתקן
- עלות
- עלויות
- יכול
- זוג
- לִיצוֹר
- נוצר
- יוצר
- יוצרים
- אישורים
- מכריע
- לקוחות
- דאלאס
- החלטה
- עמוק
- למידה עמוקה
- עמוק יותר
- בְּרִירַת מֶחדָל
- להפגין
- תלוי
- לפרוס
- פרס
- פריסה
- פריסה
- עיצוב
- יעוד
- למרות
- מְפוֹרָט
- קובע
- מתפתח
- מכשיר
- התקנים
- אחר
- שידור
- לחפור
- דיגיטלי
- תאומים דיגיטליים
- מופץ
- הכשרה מבוזרת
- ג'נגו
- do
- סַוָר
- עושה
- לא
- תחום
- לא
- דינמי
- כל אחד
- מוקדם יותר
- קל יותר
- בקלות
- קל
- EC
- יעילות
- סוף
- נקודת קצה
- לעסוק
- הנדסה
- לְהַבטִיחַ
- זן
- ישות
- כניסה
- סביבה
- שגיאות
- וכו '
- אֲפִילוּ
- כל
- מתפתח
- דוגמה
- אלא
- ניסיון
- סיומות
- פָּנִים
- משפחה
- מהר יותר
- אפשרי
- תכונות
- הפד
- פחות
- תרשים
- שלח
- לסנן
- בסופו של דבר
- ראשון
- מתמקד
- הבא
- כדלקמן
- בעד
- פוּרמָט
- מצא
- ארבע
- מסגרת
- מסגרות
- החל מ-
- מלא
- לגמרי
- פונקציה
- שער כניסה
- גנרטטיבית
- AI Generative
- לקבל
- GitHub
- לתת
- נותן
- גלוֹבָּלִי
- הולך
- מדריך
- לטפל
- ידות על
- חומרה
- יש
- he
- לעזור
- עזרה
- עוזר
- כאן
- גָבוֹהַ
- גבוה יותר
- הגבוה ביותר
- שֶׁלוֹ
- המארח
- אירח
- אירוח
- מארחים
- איך
- איך
- אולם
- HTML
- http
- HTTPS
- חיבוק פנים
- ID
- אידאל
- מזוהה
- if
- תמונה
- תמונות
- לייבא
- חשוב
- in
- כלול
- כולל
- נכנס
- עליות
- התעשייה
- לֹא יָעִיל
- מידע
- הודעה
- קלט
- תשומות
- להתקין
- מותקן
- התקנה
- למשל
- במקום
- מכון
- הוראות
- אינטראקציה
- אל תוך
- הופעל
- IOT
- סוגיה
- בעיות
- IT
- שֶׁלָה
- JIT
- jpg
- רק
- שמור
- מפתחות
- לדעת
- ידוע
- מעבדות
- שפה
- גָדוֹל
- אחרון
- חֶבִיוֹן
- האחרון
- לשגר
- שכבה
- שכבות
- עוֹפֶרֶת
- לִלמוֹד
- למידה
- רמה
- סִפְרִיָה
- כמו
- לינוקס
- רשימה
- ברשימה
- קְצָת
- קצת יותר עמוק
- LLM
- טוען
- המון
- מקומי
- מיקום
- רישום
- התחבר
- נראה
- נראה כמו
- נראה
- לאבד
- נמוך
- להוריד
- הנמוך ביותר
- מכונה
- למידת מכונה
- עשוי
- תחזוקה
- לעשות
- עושה
- עשייה
- רב
- מסצ'וסטס
- המכון הטכנולוגי של מסצ'וסטס
- מקסימום
- לְהַגדִיל
- מקסימום
- מאי..
- מֵכָנִי
- רפואי
- זכרון
- מדדים
- אכפת לי
- מינימום
- ML
- מודל
- מודלים
- שונים
- לשנות
- מולקולרי
- צג
- יותר
- רוב
- המהלך
- הרבה
- מספר
- צריך
- שם
- בהכרח
- הכרחי
- צורך
- נחוץ
- צרכי
- חדש
- הבא
- עַכשָׁיו
- מספר
- מטרה
- להתבונן
- of
- הַצָעָה
- לעתים קרובות
- on
- פעם
- ONE
- רק
- עַל גַבֵּי
- קוד פתוח
- להפעיל
- תפעול
- מפעילי
- מִתנַגֵד
- אופטימיזציה
- מטב
- אופטימיזציה
- or
- שלנו
- הַחוּצָה
- תפוקה
- יותר
- חבילה
- מקביל
- חלק
- לעבור
- עבר
- נתיב
- עבור
- אחוזים
- ביצועים
- אפלטון
- מודיעין אפלטון
- אפלטון נתונים
- נקודה
- נקודות
- מדיניות
- מדיניות
- פופולרי
- אפשרי
- הודעה
- פרקטיקות
- להציג
- פְּרָטִי
- כנראה
- תהליך
- תהליכים
- הפקת
- הפקה
- פּרוֹפִיל
- פרויקטים
- נכסים
- לספק
- ובלבד
- מספק
- פרוקסי
- לאור
- מושך
- מטרה
- דחוף
- דחף
- דוחף
- גם
- פיתון
- פיטורך
- רכס
- ממשי
- זמן אמת
- להמליץ
- מוּמלָץ
- מוקלט
- לשקף
- באזור
- יחסית
- לסמוך
- הסתמכות
- שְׂרִידִים
- להסיר
- להחליף
- מאגר
- בקשות
- נדרש
- דרישות
- מחקר
- דומה
- עתודה
- שמור
- משאבים
- תגובה
- אחראי
- REST
- וכתוצאה מכך
- לשימוש חוזר
- אורז
- תפקיד
- תפקידים
- הפעלה
- ריצה
- פועל
- מקריב
- אותו
- שמור
- סולם
- תרחיש
- סקריפטים
- Sdk
- לִרְאוֹת
- מבחר
- שליחה
- לחצני מצוקה לפנסיונרים
- רגיש
- נפרד
- ללא שרת
- שרתים
- שרות
- שירותים
- הגשה
- סט
- הצבה
- התקנה
- צורות
- שיתוף
- משותף
- צריך
- לְהַצִיג
- הראה
- הראה
- הופעות
- צד
- דומה
- באופן דומה
- בפשטות
- שישה
- מידה
- גדל
- קטן יותר
- So
- פִּתָרוֹן
- פתרונות
- כמה
- מתמחה
- ספציפי
- מפורט
- דיבר
- יציב
- לערום
- התחלה
- סטארט - אפ
- חברות סטארט
- אמור
- צעדים
- נעצר
- מאוחסן
- חנויות
- בְּתוֹקֶף
- מחקרים
- בהצלחה
- כזה
- פסגות
- תמיכה
- נתמך
- בטוח
- מערכת
- שולחן
- לקחת
- משימות
- לוקח
- נבחרת
- טכנולוגיה
- זמני
- tensorflow
- מסוף
- מבחן
- בדיקות
- בדיקות
- טקסס
- מֵאֲשֶׁר
- זֶה
- השמיים
- שֶׁלָהֶם
- אותם
- אז
- לכן
- אלה
- הֵם
- דברים
- זֶה
- אלה
- דרך
- תפוקה
- קָשׁוּר
- זמן
- ל
- היום
- כלי
- כלים
- חלק עליון
- לפיד
- סה"כ
- עקבות
- מעקב
- מסורתי
- רכבת
- הדרכה
- רוֹבּוֹטרִיקִים
- מהימן
- לנסות
- תור
- תְאוּמִים
- שתיים
- סוג
- אובונטו
- תחת
- בְּסִיסִי
- אוניברסיטה
- יוניקס
- ללא צורך
- על
- us
- נוֹהָג
- להשתמש
- מְשׁוּמָשׁ
- משתמש
- משתמשים
- שימושים
- באמצעות
- לנצל
- מנצל
- ניצול
- ערך
- ערכים
- גרסה
- מאוד
- נראה
- חזון
- כֶּרֶך
- רוצה
- היה
- דֶרֶך..
- we
- אינטרנט
- שרת אינטרנט
- שירותי אינטרנט
- טוֹב
- היו
- מתי
- אשר
- למה
- באופן נרחב
- יצטרך
- עם
- בתוך
- לְלֹא
- עובד
- עובדים
- היה
- כתיבה
- כתוב
- אתה
- עצמך
- זפירנט
- אפס