הפעל מספר מודלים של למידה עמוקה ב-GPU עם נקודות קצה מרובי דגמים של Amazon SageMaker

כאשר אימוץ הבינה המלאכותית מואצת בתעשייה, לקוחות בונים מודלים מתוחכמים המנצלים פריצות דרך מדעיות חדשות בלמידה עמוקה. מודלים מהדור הבא הללו מאפשרים לך להשיג ביצועים חדישים, דמויי אדם בתחומי עיבוד השפה הטבעית (NLP), ראייה ממוחשבת, זיהוי דיבור, מחקר רפואי, אבטחת סייבר, חיזוי מבנה חלבון ועוד רבים אחרים . לדוגמה, דגמי שפה גדולים כמו GPT-3, OPT ו-BLOOM יכולים לתרגם, לסכם ולכתוב טקסט עם ניואנסים דמויי אדם. במרחב הראייה הממוחשבת, מודלים של דיפוזיה של טקסט לתמונה כמו DALL-E ו-Image יכולים ליצור תמונות פוטוריאליסטיות משפה טבעית עם רמה גבוהה יותר של הבנת שפה וחזותית מהעולם הסובב אותנו. מודלים רב-מודאליים אלו מספקים תכונות עשירות יותר עבור משימות שונות במורד הזרם ויכולת לכוונן אותן עבור תחומים ספציפיים, והם מביאים הזדמנויות עסקיות רבות עוצמה ללקוחות שלנו.

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

אמזון SageMaker נקודות קצה מרובות מודלים (MMEs) מספקות דרך ניתנת להרחבה וחסכונית לפריסת מספר רב של מודלים של למידה עמוקה. MMEs הם בחירת אירוח פופולרית לאירוח מאות דגמים מבוססי מעבד בקרב לקוחות כמו Zendesk, Veeva ו-AT&T. בעבר, היו לך אפשרויות מוגבלות לפרוס מאות מודלים של למידה עמוקה שהצריכו מחשוב מואץ עם GPUs. היום, אנו מכריזים על תמיכת MME עבור GPU. עכשיו אתה יכול לפרוס אלפי מודלים של למידה עמוקה מאחורי נקודת קצה אחת של SageMaker. MMEs יכולים כעת להריץ דגמים מרובים על ליבת GPU, לשתף מופעי GPU מאחורי נקודת קצה על פני מספר דגמים, ולטעון ולפרוק באופן דינמי מודלים על סמך התעבורה הנכנסת. עם זה, אתה יכול לחסוך משמעותית בעלויות ולהשיג את ביצועי המחיר הטובים ביותר.

בפוסט זה, אנו מראים כיצד להפעיל דגמי למידה עמוקה מרובים על GPU עם SageMaker MMEs.

MME של SageMaker

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

התרשים הבא ממחיש את הארכיטקטורה של SageMaker MME.

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

SageMaker MMEs עם תמיכה ב-GPU

SageMaker MMEs עם GPU עובדים באמצעות NVIDIA Triton Inference Server. NVIDIA Triton Inference Server היא תוכנת הגשת מסקנות בקוד פתוח המפשטת את תהליך הגשת ההסקות ומספקת ביצועי מסקנות גבוהים. Triton תומך בכל מסגרות ההדרכה וההסקות העיקריות, כגון TensorFlow, NVIDIA® TensorRT™, PyTorch, MXNet, Python, ONNX, XGBoost, Scikit-learn, RandomForest, OpenVINO, C++ מותאם אישית ועוד. הוא מציע אצווה דינמית, ריצות במקביל, קוונטיזציה לאחר אימון ותצורת מודל אופטימלית להשגת מסקנות עם ביצועים גבוהים. בנוסף, NVIDIA Triton Inference Server הורחב ליישום חוזה MME API, כדי להשתלב עם MME.

התרשים הבא ממחיש זרימת עבודה של MME.

שלבי זרימת העבודה הם כדלקמן:

1. ה-MME של SageMaker מקבל בקשת הפצת HTTP עבור דגם מסוים המשתמש TargetModel בבקשה יחד עם המטען.
2. SageMaker מנתב תעבורה למופע הנכון מאחורי נקודת הקצה שבה מודל היעד נטען. SageMaker מבין את דפוס התנועה בכל הדגמים שמאחורי ה-MME ומנתב בקשות בצורה חכמה.
3. SageMaker דואגת לניהול מודלים מאחורי נקודת הקצה, טוענת באופן דינמי את הדגם לזיכרון הקונטיינר, ופורקת את הדגם המבוסס מהצי המשותף של מופעי GPU כדי לתת את ביצועי המחיר הטובים ביותר.
4. SageMaker מוריד באופן דינמי דגמים מאמזון S3 לנפח האחסון של המופע. אם המודל שהופעל אינו זמין בנפח האחסון של המופע, המודל יוריד לנפח האחסון של המופע. אם נפח האחסון של המופע מגיע לקיבולת, SageMaker מוחק דגמים שאינם בשימוש מנפח האחסון.
5. SageMaker טוען את הדגם לזיכרון של מיכל NVIDIA Triton במופע מואץ של GPU ומגיש את בקשת ההסקה. ליבת ה-GPU משותפת לכל הדגמים במופע אחד. אם הדגם כבר נטען בזיכרון המכולה, הבקשות הבאות מוגשות מהר יותר מכיוון ש- SageMaker לא צריך להוריד ולטעון אותו שוב.
6. SageMaker דואגת לעיצוב תעבורה לנקודת הקצה של MME ושומרת על עותקי דגם אופטימליים במופעי GPU לביצועי המחיר הטובים ביותר. הוא ממשיך לנתב את התעבורה למופע שבו המודל נטען. אם משאבי המופע מגיעים לקיבולת עקב ניצול גבוה, SageMaker פורק את הדגמים הכי פחות בשימוש מהמיכל כדי לפנות משאבים לטעינת מודלים בשימוש תכוף יותר.

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

סקירת פתרונות

בפוסט זה, אנו מראים לך כיצד להשתמש בתכונות החדשות של SageMaker MMEs עם GPU עם מקרה שימוש לראייה ממוחשבת. למטרות הדגמה, אנו משתמשים במודל מיומן מראש של רשת עצבית קונבולוציונית של ResNet-50 שיכול לסווג תמונות ל-1,000 קטגוריות. אנו דנים כיצד לעשות את הפעולות הבאות:

• השתמש במיכל מסקנות של NVIDIA Triton ב-MME של SageMaker, תוך שימוש במסגרות עורפיות שונות של מודל Triton כגון PyTorch ו-TensorRT
• המר את דגמי ResNet-50 לפורמט מנוע TensorRT אופטימלי ופרוס אותו עם SageMaker MME
• הגדר מדיניות קנה מידה אוטומטי עבור ה-MME
• קבל תובנות לגבי מדדי מופע ותביעה באמצעות אמזון CloudWatch

צור חפצי מודל

סעיף זה מעביר את השלבים להכנת מודל מיומן מראש של ResNet-50 לפריסה על SageMaker MME באמצעות תצורות מודל Triton Inference Server. אתה יכול לשחזר את כל השלבים באמצעות המחברת שלב אחר שלב על GitHub.

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

הכן מודל PyTorch

ראשית, אנו טוענים דגם ResNet50 מאומן מראש באמצעות חבילת דגמי Torchvision. אנו שומרים את המודל כקובץ model.pt בפורמט אופטימלי וסדרתי של TorchScript. TorchScript מרכיב מעבר קדימה של דגם ResNet50 במצב להוט עם כניסות לדוגמה, כך שאנו מעבירים מופע אחד של תמונת RGB עם שלושה ערוצי צבע בגודל 224 על 224.

אז אנחנו צריכים להכין את המודלים עבור Triton Inference Server. הקוד הבא מציג את מאגר המודלים עבור ה-backend של PyTorch. טריטון משתמש בקובץ model.pt המוצב במאגר המודלים כדי להגיש תחזיות.

resnet
├── 1
│   └── model.pt
└── config.pbtxt

קובץ התצורה של הדגם config.pbtxt חייב לציין את שם הדגם (resnet), מאפייני הפלטפורמה והקצה האחורי (pytorch_libtorch), max_batch_size (128), וטנסור הקלט והפלט יחד עם סוג הנתונים (TYPE_FP32) מידע. בנוסף, אתה יכול לציין instance_group ו dynamic_batching תכונות להשגת הסקת ביצועים גבוהים. ראה את הקוד הבא:

name: "resnet"
platform: "pytorch_libtorch"
max_batch_size: 128
input {
  name: "INPUT__0"
  data_type: TYPE_FP32
  dims: 3
  dims: 224
  dims: 224
}
output {
  name: "OUTPUT__0"
  data_type: TYPE_FP32
  dims: 1000
}

הכן את מודל TensorRT

NVIDIA TensorRT הוא SDK להסקת למידה עמוקה בעלת ביצועים גבוהים, וכוללת אופטימיזציית הסקת מסקנות למידה עמוקה וזמן ריצה המספק חביון נמוך ותפוקה גבוהה עבור יישומי מסקנות. אנו משתמשים בכלי שורת הפקודה trtexec כדי ליצור מנוע TensorRT בסידורי מ- an אונקס פורמט דגם. השלם את השלבים הבאים כדי להמיר דגם מיומן מראש של ResNet-50 ל-NVIDIA TensorRT:

1. ייצא את דגם ResNet-50 שהוכשר מראש לפורמט ONNX באמצעות torch.onnx.שלב זה מריץ את המודל פעם אחת כדי להתחקות אחר הריצה שלו עם קלט לדוגמה ולאחר מכן מייצא את המודל המתחקה לקובץ שצוין model.onnx.
2. השתמש ב-trtexec כדי ליצור תוכנית מנוע TensorRT מה- model.onnx קוֹבֶץ. ניתן לצמצם באופן אופציונלי את הדיוק של חישובי נקודה צפה, או על ידי הפעלתם בנקודה צפה של 16 סיביות, או על ידי כימות ערכי נקודה צפה כך שניתן לבצע חישובים באמצעות מספרים שלמים של 8 סיביות.

הקוד הבא מציג את מבנה מאגר המודלים עבור מודל TensorRT:

resnet
├── 1
│   └── model.plan
└── config.pbtxt

עבור מודל TensorRT, אנו מציינים tensorrt_plan כפלטפורמה והזן את מפרטי Tensor של התמונה בגודל 224 x 224, שיש לה את ערוצי הצבע. הפלט Tensor עם 1,000 מידות הוא מסוג TYPE_FP32, בהתאמה לקטגוריות האובייקטים השונות. ראה את הקוד הבא:

name: "resnet"
platform: "tensorrt_plan"
max_batch_size: 128
input {
  name: "input"
  data_type: TYPE_FP32
  dims: 3
  dims: 224
  dims: 224
}
output {
  name: "output"
  data_type: TYPE_FP32
  dims: 1000
}
model_warmup {
    name: "bs128 Warmup"
    batch_size: 128
    inputs: {
        key: "input"
        value: {
            data_type: TYPE_FP32
            dims: 3
            dims: 224
            dims: 224
            zero_data: false
        }
    }
}

אחסן חפצי דגם באמזון S3

SageMaker מצפה את חפצי הדגם .tar.gz פוּרמָט. הם צריכים גם לעמוד בדרישות המכולה של Triton כגון שם הדגם, הגרסה, config.pbtxt קבצים ועוד. tar התיקיה המכילה את קובץ הדגם as .tar.gz והעלה אותו לאמזון S3:

!mkdir -p triton-serve-pt/resnet/1/
!mv -f workspace/model.pt triton-serve-pt/resnet/1/
!tar -C triton-serve-pt/ -czf resnet_pt_v0.tar.gz resnet
model_uri_pt = sagemaker_session.upload_data(path="resnet_pt_v0.tar.gz", key_prefix="resnet-mme-gpu")
!mkdir -p triton-serve-trt/resnet/1/
!mv -f workspace/model.plan triton-serve-trt/resnet/1/
!tar -C triton-serve-trt/ -czf resnet_trt_v0.tar.gz resnet
model_uri_trt = sagemaker_session.upload_data(path="resnet_trt_v0.tar.gz", key_prefix="resnet-mme-gpu")

כעת, לאחר שהעלינו את חפצי הדגם לאמזון S3, אנו יכולים ליצור SageMaker MME.

פרוס דגמים עם MME

כעת אנו פורסים דגם ResNet-50 עם שני מסגרת עורפית שונה (PyTorch ו-TensorRT) ל-MME של SageMaker.

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

אנו משתמשים AWS SDK עבור Python (Boto3) ממשקי API ליצור_מודל, create_endpoint_config, ו create_endpoint כדי ליצור MME.

הגדירו את מיכל ההגשה

בהגדרת המכולה, הגדר את model_data_url כדי לציין את ספריית S3 המכילה את כל הדגמים שבהם משתמש ה-MME של SageMaker כדי לטעון ולהגיש תחזיות. מַעֲרֶכֶת Mode ל MultiModel כדי לציין ש- SageMaker יוצר את נקודת הקצה עם מפרטי מיכל MME. הגדרנו את המכולה עם תמונה התומכת בפריסת MMEs עם GPU. ראה את הקוד הבא:

container = {
"Image": ,
"ModelDataUrl": ,
"Mode": "MultiModel"
}

צור אובייקט מרובה דגמים

השתמש בלקוח SageMaker Boto3 כדי ליצור את המודל באמצעות create_model ממשק API. אנו מעבירים את הגדרת המכולה ל- Create model API יחד עם ModelName ו ExecutionRoleArn:

create_model_response = sm_client.create_model(
    ModelName=, ExecutionRoleArn=role, PrimaryContainer=container
)

הגדר תצורות MME

צור תצורות MME באמצעות create_endpoint_config API של Boto3. ציין מופע מחשוב GPU מואץ ב InstanceType (אנו משתמשים בסוג המופע g4dn.4xlarge). אנו ממליצים להגדיר את נקודות הקצה שלך עם שני מופעים לפחות. זה מאפשר ל-SageMaker לספק קבוצה זמינה ביותר של תחזיות על פני מספר אזורי זמינות עבור הדגמים.

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

create_endpoint_config_response = sm_client.create_endpoint_config(
    EndpointConfigName=,
    ProductionVariants=[
        {
            "InstanceType": "ml.g4dn.4xlarge",
            "InitialVariantWeight": 1,
            "InitialInstanceCount": 2,
            "ModelName": ,
            "VariantName": "AllTraffic",
        }
    ],
)

צור MME

עם תצורת נקודת הקצה הקודמת, אנו יוצרים SageMaker MME באמצעות ה create_endpoint ממשק API. SageMaker יוצר את ה-MME, משיק את מופע המחשוב ML g4dn.4xlarge, ופורס עליהם את הדגמים PyTorch ו-TensorRT ResNet-50. ראה את הקוד הבא:

create_endpoint_response = sm_client.create_endpoint(
    EndpointName=, EndpointConfigName=
)

הפעל את מודל היעד ב-MME

לאחר שניצור את נקודת הקצה, נוכל לשלוח בקשת הסקה ל-MME באמצעות ה- invoke_enpoint ממשק API. אנו מציינים את TargetModel בקריאת ההזמנה והעבירו את המטען עבור כל סוג דגם. הקוד הבא הוא דוגמה למודל PyTorch ומודל TensorRT:

runtime_sm_client.invoke_endpoint(
    EndpointName=,
    ContentType="application/octet-stream",
    Body=json.dumps(pt_payload),
    TargetModel='resnet_pt_v0.tar.gz', #PyTorch Model
)
runtime_sm_client.invoke_endpoint(
    EndpointName=, 
    ContentType="application/octet-stream", 
    Body=json.dumps(trt_payload),
    TargetModel='resnet_trt_v0.tar.gz' #TensorRT Model
)

הגדר מדיניות קנה מידה אוטומטי עבור ה-GPU MME

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

במדיניות קנה המידה הבאה, אנו משתמשים במדד המותאם אישית GPUUtilization ב TargetTrackingScalingPolicyConfiguration תצורה וקבע א TargetValue of 60.0 עבור ערך היעד של מדד זה. מדיניות קנה מידה אוטומטי זו קובעת מקרים נוספים עד MaxCapacity כאשר ניצול ה-GPU הוא יותר מ-60%.

auto_scaling_client = boto3.client('application-autoscaling')

resource_id='endpoint/' +  + '/variant/' + 'AllTraffic' 
response = auto_scaling_client.register_scalable_target(
    ServiceNamespace='sagemaker',
    ResourceId=resource_id,
    ScalableDimension='sagemaker:variant:DesiredInstanceCount',
    MinCapacity=1,
    MaxCapacity=5
)

response = auto_scaling_client.put_scaling_policy(
    PolicyName='GPUUtil-ScalingPolicy',
    ServiceNamespace='sagemaker',
    ResourceId=resource_id,
    ScalableDimension='sagemaker:variant:DesiredInstanceCount', 
    PolicyType='TargetTrackingScaling',
    TargetTrackingScalingPolicyConfiguration={
        'TargetValue': 60.0, 
        'CustomizedMetricSpecification':
        {
            'MetricName': 'GPUUtilization',
            'Namespace': '/aws/sagemaker/Endpoints',
            'Dimensions': [
                {'Name': 'EndpointName', 'Value':  },
                {'Name': 'VariantName','Value': 'AllTraffic'}
            ],
            'Statistic': 'Average',
            'Unit': 'Percent'
        },
        'ScaleInCooldown': 600,
        'ScaleOutCooldown': 200 
    }
)

אנו ממליצים להשתמש GPUUtilization or InvocationsPerInstance כדי להגדיר מדיניות קנה מידה אוטומטי עבור ה-MME שלך. לפרטים נוספים, ראה הגדר מדיניות קנה מידה אוטומטי עבור פריסות נקודות קצה מרובות

מדדי CloudWatch עבור GPU MMEs

SageMaker MMEs מספקים את המדדים הבאים ברמת המופע לניטור:

• LoadedModelCount – מספר הדגמים שהועמסו במכולות
• GPUUtilization – אחוז יחידות ה-GPU המשמשות את המכולות
• GPUMemoryUtilization – אחוז זיכרון ה-GPU המשמש את הקונטיינרים
• שימוש בדיסק – אחוז שטח הדיסק המשמש את הקונטיינרים

מדדים אלה מאפשרים לך לתכנן ניצול יעיל של משאבי מופעי GPU. בגרף הבא, אנו רואים GPUMemoryUtilization היה 38.3% כאשר יותר מ-16 דגמי ResNet-50 הועמסו במיכל. סכום הניצול של כל ליבת מעבד בודדת (CPUUtilization) היה 60.9%, ואחוז הזיכרון בשימוש המכולות (MemoryUtilization) היה 9.36%.

MMEs של SageMaker מספקים גם מדדי טעינת מודל כדי לקבל תובנות ברמת הפעלת המודל:

• ModelLoadingWaitTime - מרווח זמן להורדה או טעינה של הדגם
• ModelUnloadingTime - מרווח זמן לפריקת הדגם מהמיכל
• זמן הורדה של דגם - הגיע הזמן להוריד את הדגם מאמזון S3
• ModelCacheHit – מספר הפניות לדגם שכבר הועמסו על המכולה

בגרף הבא, אנו יכולים לראות שלקח 8.22 שניות למודל להגיב לבקשת הסקה (ModelLatency), ו-24.1 אלפיות שניות נוספו לאחזור מקצה לקצה עקב תקורה של SageMaker (OverheadLatency). אנו יכולים גם לראות מדדי שגיאה כלשהם מקריאות להפעלת קריאת API של נקודת קצה, כגון Invocation4XXErrors ו Invocation5XXErrors.

למידע נוסף על מדדי MME CloudWatch, עיין ב מדדי CloudWatch עבור פריסות נקודות קצה מרובות.

<br> סיכום

בפוסט זה, למדת על התמיכה החדשה של SageMaker בריבוי דגמים עבור GPU, המאפשרת לך לארח בצורה חסכונית מאות מודלים של למידה עמוקה על חומרת מחשוב מואצת. למדת כיצד להשתמש ב-NVIDIA Triton Inference Server, אשר יוצר תצורת מאגר מודלים עבור מסגרת עורפית שונות, וכיצד לפרוס MME עם קנה מידה אוטומטי. תכונה זו תאפשר לך להרחיב מאות דגמים מותאמים אישית במיוחד המותאמים היטב כדי לספק חוויות ייחודיות של משתמשי קצה ביישומי AI. אתה יכול גם למנף את התכונה הזו כדי להשיג ביצועי מחיר נחוצים עבור יישום ההסקה שלך באמצעות GPU חלקי.

כדי להתחיל עם תמיכת MME עבור GPU, ראה תמיכה בנקודות קצה מרובות דגמים עבור GPU.

על המחברים

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

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

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

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

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

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

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

מקסימיליאנו מקנטי הוא מהנדס ראשי ב-AWS כרגע עם DynamoDB, הייתי בצוות ההשקה של SageMaker ב-re:Invent 2017 וביליתי את 5 השנים הבאות בפלטפורמת האירוח בהוספת כל סוגי הלקוחות העומדים בפני תכונות. בזמני הפנוי אני אוסף, מתקן ומשחק עם קונסולות משחקי וידאו וינטג'.