פרוס את BLOOM-176B ו-OPT-30B ב-Amazon SageMaker עם מסקנות מדגמים גדולים Deep Learning Containers ו-DeepSpeed

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

בפוסט קודם דנו יכולות והגדרות הניתנות להגדרה in פריסת מודל אמזון SageMaker שיכולים להקל על מסקנות עם דגמים גדולים אלה. היום, אנו מכריזים על חדש אמזון SageMaker מיכל למידה עמוק (DLC) שבו אתה יכול להשתמש כדי להתחיל עם הסקת מודלים גדולים תוך דקות ספורות. זֶה DLC מארז כמה מספריות הקוד הפתוח הפופולריות ביותר להסקת מודל מקבילית, כגון DeepSpeed ​​ו-Hugging Face Accelerate.

בפוסט זה, אנו משתמשים ב-DLC חדש של SageMaker להסקת דגמים גדולים כדי לפרוס שניים מדגמי ה-NLP הגדולים הפופולריים ביותר: BigScience's BLOOM-176B ושל מטא OPT-30B ממאגר החיבוקים. בפרט, אנו משתמשים בטכניקות הגשה של Deep Java Library (DJL) ובטכניקות מקבילות טנזור מ-DeepSpeed ​​כדי להשיג 0.1 שניות חביון לכל אסימון במקרה של שימוש ביצירת טקסט.

אתה יכול למצוא את מחברות הדוגמא המלאות שלנו מאגר GitHub.

טכניקות להסקת מודלים גדולים

דגמי השפה התפוצצו לאחרונה הן בגודל והן בפופולריות. עם גישה נוחה מגני חיות מדגמים כגון Hugging Face ודיוק וביצועים משופרים במשימות NLP כגון סיווג ויצירת טקסט, המתרגלים מגיעים יותר ויותר לדגמים גדולים אלה. עם זאת, דגמים גדולים הם לרוב גדולים מכדי להיכנס לזיכרון של מאיץ יחיד. לדוגמה, דגם BLOOM-176B יכול לדרוש יותר מ-350 גיגה-בייט של זיכרון מאיץ, מה שעולה בהרבה על הקיבולת של מאיצי חומרה הקיימים כיום. זה מחייב שימוש בטכניקות מקבילות של מודלים מספריות כמו DeepSpeed ​​ו-Hugging Face Accelerate כדי להפיץ מודל על פני מספר מאיצים לצורך הסקת מסקנות. בפוסט זה אנו משתמשים ב- מיכל מסקנות מדגם גדול של SageMaker ליצור ולהשוות את ביצועי השהיה ותפוקה באמצעות שתי ספריות קוד פתוח אלו.

DeepSpeed ​​ו-Accelerate משתמשים בטכניקות שונות כדי לייעל מודלים של שפה גדולים להסקת מסקנות. ההבדל העיקרי הוא של DeepSpeed שימוש בגרעינים מותאמים. גרעינים אלה יכולים לשפר באופן דרמטי את זמן ההסקה על ידי הפחתת צווארי בקבוק בגרף החישוב של המודל. גרעינים אופטימליים יכולים להיות קשים לפיתוח והם בדרך כלל ספציפיים לארכיטקטורת מודל מסוימת; DeepSpeed ​​תומך בדגמים גדולים פופולריים כגון OPT ו-BLOOM עם הגרעינים המותאמים הללו. לעומת זאת, ספריית ה-Accelerate של Hugging Face אינה כוללת גרעינים מותאמים בזמן הכתיבה. כפי שאנו דנים בסעיף התוצאות שלנו, ההבדל הזה אחראי לחלק גדול מהיתרון בביצועים שיש ל-DeepSpeed ​​על פני Accelerate.

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

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

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

• בנייה ובדיקה של פתרונות – בהתחשב באופי האיטרטיבי של פיתוח ML, אנו זקוקים ליכולת לבנות, לבצע איטרציה מהירה ולבדוק כיצד תתנהג נקודת הסיום כאשר המודלים הללו מתארחים, כולל היכולת להיכשל במהירות. מודלים אלה יכולים להתארח בדרך כלל רק במופעים גדולים יותר כמו p4dn או g5, ובהתחשב בגודלם של הדגמים, זה יכול לקחת זמן מה להעלות מופע מסקנות ולהפעיל כל איטרציה של בדיקה. לבדיקות מקומיות יש בדרך כלל אילוצים כי אתה צריך מופע דומה בגודל כדי לבדוק, ולא קל להשיג את המודלים האלה.
• פריסה והפעלה בקנה מידה – יש לטעון את קבצי המודל על מופעי ההסקה, מה שמציב בפני עצמו אתגר בהתחשב בגודל. Tar / Un-Tar כדוגמה ל-Bloom-176B לוקח בערך שעה ליצור ועוד שעה לטעון. אנחנו צריכים מנגנון חלופי כדי לאפשר גישה קלה לקבצי הדגם.
• טוען את הדגם כיחיד - עבור תהליך מרובה עובדים, עלינו להבטיח שהמודל ייטען פעם אחת בלבד כדי שלא ניתקל בתנאי מירוץ ונבזבז משאבים מיותרים. בפוסט זה, אנו מראים דרך לטעון ישירות מ שירות אחסון פשוט של אמזון (אמזון S3). עם זאת, זה עובד רק אם אנו משתמשים בהגדרות ברירת המחדל של ה-DJL. יתר על כן, כל קנה מידה של נקודות הקצה צריך להיות מסוגל להסתובב תוך מספר דקות, מה שמחייב לשקול מחדש כיצד המודלים עשויים להיטען ולהפיץ.
• פיצול מסגרות - מודלים אלה בדרך כלל צריכים להיות , בדרך כלל על ידי מנגנון מקביליות טנזור או על ידי ריסוק צינורות כמו טכניקות ריסוק טיפוסיות, ויש לנו מושגים מתקדמים כמו ריסוק ZeRO שנבנו על גבי ריסוק טנזור. למידע נוסף על טכניקות ריסוק, עיין ב מקביליות מודל. כדי להשיג זאת, אנו יכולים לקבל שילובים שונים ולהשתמש במסגרות מ-NIVIDIA, DeepSpeed ​​ואחרים. זה מצריך את היכולת לבדוק BYOC או להשתמש בקונטיינרים 1P ולחזור על פתרונות ולהריץ בדיקות בנצ'מרקינג. ייתכן שתרצה גם לבדוק אפשרויות אירוח שונות כמו אסינכרוני, חסר שרת ואחרות.
• בחירת חומרה - הבחירה שלך בחומרה נקבעת על ידי כל הנקודות שהוזכרו לעיל ודפוסי תעבורה נוספים, צרכי מקרה שימוש וגדלי דגמים.

בפוסט זה, אנו משתמשים בקרנלים ובטכניקות מקביליות טנזור המותאמות של DeepSpeed ​​כדי לארח את BLOOM-176B ו-OPT-30B ב- SageMaker. אנו גם משווים תוצאות מ-Accelerate כדי להדגים את יתרונות הביצועים של גרעינים אופטימליים ומקביליות טנזור. למידע נוסף על DeepSpeed ​​ו-Accelerate, עיין ב DeepSpeed ​​Inference: מאפשר הסקה יעילה של דגמי רובוטריקים בקנה מידה חסר תקדים ו הסקת BLOOM מהירה להפליא עם DeepSpeed ​​ו-Accelerate.

אנו משתמשים ב-DJLServing כפתרון ההגשה למודל בדוגמה זו. DJLServing הוא פתרון מודל אוניברסלי בעל ביצועים גבוהים המופעל על ידי ספריית ג'אווה עמוקה (DJL) שהיא אגנוסטית בשפת התכנות. למידע נוסף על DJL ו- DJLServing, עיין ב פרוס דגמים גדולים ב-Amazon SageMaker באמצעות מסקנות מקבילות של מודל DJLServing ו-DeepSpeed.

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

השלבים הבאים מדגימים כיצד לפרוס דגם BLOOM-176B ב- SageMaker באמצעות DJLServing ומיכל מסקנות מדגם גדול של SageMaker. הדוגמה המלאה זמינה גם אצלנו מאגר GitHub.

שימוש בתמונת DJLServing SageMaker DLC

השתמש בקוד הבא כדי להשתמש בתמונת DJLServing SageMaker DLC לאחר החלפת האזור באזור הספציפי שלך שבו אתה מפעיל את המחברת:

763104351884.dkr.ecr..amazonaws.com/djl-inference:0.19.0-deepspeed0.7.3-cu113
# example uri might be like 763104351884.dkr.ecr.us-east-1.amazonaws.com/djl-inference:0.19.0-deepspeed0.7.3-cu113

צור את קובץ הדגם שלנו

ראשית, אנו יוצרים קובץ בשם serving.properties שמכיל רק שורת קוד אחת. זה אומר לשרת דגם DJL להשתמש במנוע DeepSpeed. הקובץ מכיל את הקוד הבא:

engine=DeepSpeed

serving.properties הוא קובץ שהוגדר על ידי DJLServing המשמש לקביעת תצורה לפי דגם.

לאחר מכן, אנו יוצרים את שלנו model.py קובץ, שמגדיר את הקוד הדרוש לטעינה ולאחר מכן לשרת את המודל. בקוד שלנו, אנו קוראים ב- TENSOR_PARALLEL_DEGREE משתנה סביבה (ערך ברירת המחדל הוא 1). זה קובע את מספר ההתקנים שעליהם מופצים המודולים המקבילים טנזור. שימו לב ש-DeepSpeed ​​מספקת כמה הגדרות מחיצות מובנות, כולל אחת עבור דגמי BLOOM. אנו משתמשים בו על ידי ציון replace_method ו relpace_with_kernel_inject. אם יש לך דגם מותאם אישית ואתה זקוק ל-DeepSpeed ​​כדי לחלק בצורה יעילה, עליך לשנות relpace_with_kernel_inject ל false ולהוסיף injection_policy כדי לגרום למחיצת זמן הריצה לעבוד. למידע נוסף, עיין ב אתחול להסקת מסקנות. לדוגמא שלנו, השתמשנו במודל BLOOM המחולק מראש ב-DeepSpeed.

שנית, ב model.py קובץ, אנו גם טוענים את הדגם מאמזון S3 לאחר שנקודת הקצה הופעלה. הדגם נטען לתוך /tmp מקום על המכולה כי SageMaker ממפה את /tmp אל ה חנות בלוקים אלסטית של אמזון נפח (Amazon EBS) שמותקן כאשר אנו מציינים את פרמטר יצירת נקודת הקצה VolumeSizeInGB. עבור מקרים כמו p4dn, שמגיעים בנויים מראש עם מופע הווליום, נוכל להמשיך למנף את /tmp על המיכל. ראה את הקוד הבא:

from djl_python import Input, Output
import os
import deepspeed
import torch
import torch.distributed as dist
import sys
import subprocess
import time
from glob import glob
from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
from transformers.models.opt.modeling_opt import OPTDecoderLayer

predictor = None

def check_config():
    local_rank = os.getenv('LOCAL_RANK')
    
    if not local_rank:
        return False
    return True
    
def get_model():

    if not check_config():
        raise Exception("DJL:DeepSpeed configurations are not default. This code does not support non default configurations") 
    
    tensor_parallel = int(os.getenv('TENSOR_PARALLEL_DEGREE', '1'))
    local_rank = int(os.getenv('LOCAL_RANK', '0'))
    model_dir = "/tmp/model"
    bucket = os.environ.get("MODEL_S3_BUCKET")
    key_prefix = os.environ.get("MODEL_S3_PREFIX")
    print(f"rank: {local_rank}")
    if local_rank == 0:
        if f"{model_dir}/DONE" not in glob(f"{model_dir}/*"):
            print("Starting Model downloading files")
            try:
                proc_run = subprocess.run(
                    ["aws", "s3", "cp", "--recursive", f"s3://{bucket}/{key_prefix}", model_dir]
                )
                print("Model downloading finished")
                # write file when download complete. Could use dist.barrier() but this makes it easier to check if model is downloaded in case of retry
                with open(f"{model_dir}/DONE", "w") as f:
                    f.write("download_complete")
                    
                proc_run.check_returncode() # to throw the error in case there was one
                
            except subprocess.CalledProcessError as e:
                print ( "Model download failed: Error:nreturn code: ", e.returncode, "nOutput: ", e.stderr )
                raise # FAIL FAST  
                               
    dist.barrier()
                
    
    tokenizer = AutoTokenizer.from_pretrained(model_dir)
    
    # has to be FP16 as Int8 model loading not yet supported
    with deepspeed.OnDevice(dtype=torch.float16, device="meta"):
        model = AutoModelForCausalLM.from_config(
            AutoConfig.from_pretrained(model_dir), torch_dtype=torch.bfloat16
        )
    model = model.eval()
    
    model = deepspeed.init_inference(
        model,
        mp_size=tensor_parallel,
        dtype=torch.int8,
        base_dir = model_dir,
        checkpoint=os.path.join(model_dir, "ds_inference_config.json"),
        replace_method='auto',
        replace_with_kernel_inject=True
    )

    model = model.module
    dist.barrier()
    return model, tokenizer

DJLServing מנהל את התקנת זמן הריצה על כל חבילות pip המוגדרות ב requirement.txt. בקובץ הזה יהיו:

awscli
boto3

יצרנו ספרייה בשם code ו model.py, serving.properties, ו requirements.txt קבצים כבר נוצרו בספרייה זו. כדי לצפות בקבצים, תוכל להריץ את הקוד הבא מהמסוף:

mkdir -p code
cat code/model.py 
cat code/serving.properties 
cat code/requirements.txt 

האיור הבא מציג את המבנה של model.tar.gz.

לבסוף, אנו יוצרים את קובץ הדגם ומעלים אותו לאמזון S3:

tar cvfz model.tar.gz code
s3_code_artifact = sess.upload_data("model.tar.gz", bucket, s3_code_prefix)

הורד ואחסן את הדגם מ- Hugging Face (אופציונלי)

סיפקנו את השלבים בסעיף זה למקרה שתרצו להוריד את הדגם לאמזון S3 ולהשתמש בו משם. השלבים מסופקים בקובץ Jupyter ב- GitHub. צילום המסך הבא מציג תמונת מצב של השלבים.

צור מודל של SageMaker

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

PrimaryContainer={
        "Image": inference_image_uri,
        "ModelDataUrl": s3_code_artifact,
        "Environment": {
            "MODEL_S3_BUCKET": bucket,
            "MODEL_S3_PREFIX": s3_model_prefix,
            "TENSOR_PARALLEL_DEGREE": "8",
},

לאחר הפעלת התא הקודם בקובץ Jupyter, תראה פלט דומה לזה:

{
    "ModelArn": "arn:aws:sagemaker:us-east-1::model/bloom-djl-ds-"
}

צור נקודת קצה של SageMaker

אתה יכול להשתמש בכל מופע עם מספר GPUs לבדיקה. בהדגמה זו, אנו משתמשים במופע p4d.24xlarge. בקוד הבא, שים לב כיצד אנו מגדירים את ModelDataDownloadTimeoutInSeconds, ContainerStartupHealthCheckTimeoutInSeconds, ו VolumeSizeInGB פרמטרים שיתאימו לגודל הדגם הגדול. ה VolumeSizeInGB הפרמטר חל על מופעי GPU התומכים בקובץ המצורף לנפח EBS.

endpoint_config_response = sm_client.create_endpoint_config(
    EndpointConfigName=endpoint_config_name,
    ProductionVariants=[
        {
            "VariantName": "variant1",
            "ModelName": model_name,
            "InstanceType": "ml.p4d.24xlarge",
            "InitialInstanceCount": 1,
            #"VolumeSizeInGB" : 200,
            "ModelDataDownloadTimeoutInSeconds": 2400,
            "ContainerStartupHealthCheckTimeoutInSeconds": 2400,
        },
    ],
)'

לבסוף, אנו יוצרים נקודת קצה של SageMaker:

create_endpoint_response = sm_client.create_endpoint(
    EndpointName=f"{endpoint_name}", EndpointConfigName=endpoint_config_name
)

אתה רואה את זה מודפס בקוד הבא:

{
    "EndpointArn": "arn:aws:sagemaker:us-east-1::endpoint/bloom-djl-ds-"
}

התחלת נקודת הסיום עשויה להימשך זמן מה. אתה יכול לנסות עוד כמה פעמים אם אתה נתקל ב InsufficientInstanceCapacity שגיאה, או שאתה יכול להעלות בקשה ל-AWS להגדיל את המגבלה בחשבון שלך.

כוונון ביצועים

אם אתה מתכוון להשתמש בפוסט הזה ובמחברת הנלווית עם דגם אחר, אולי תרצה לחקור כמה מהפרמטרים הניתנים לכוונון שמציעים SageMaker, DeepSpeed ​​וה-DJL. לניסוי איטרטיבי עם פרמטרים אלה יכולה להיות השפעה מהותית על זמן ההשהיה, התפוקה והעלות של הדגם הגדול המתארח שלך. למידע נוסף על פרמטרי כוונון כגון מספר עובדים, מידת מקביליות טנזור, גודל תור עבודה ואחרים, עיין ב תצורות הגשה של DJL ו פרוס דגמים גדולים ב-Amazon SageMaker באמצעות מסקנות מקבילות של מודל DJLServing ו-DeepSpeed.

תוצאות

בפוסט זה, השתמשנו ב-DeepSpeed ​​כדי לארח את BLOOM-176B ו-OPT-30B במופעי SageMaker ML. הטבלה הבאה מסכמת את תוצאות הביצועים שלנו, כולל השוואה ל-Accelerate של Hugging Face. חביון משקף את מספר האלפיות שניות שלוקח להפיק מחרוזת של 256 אסימונים ארבע פעמים (batch_size=4) מהדגם. התפוקה משקפת את מספר האסימונים המיוצרים בשנייה עבור כל בדיקה. עבור Hugging Face Accelerate, השתמשנו בטעינת ברירת המחדל של הספרייה עם מיפוי זיכרון GPU. עבור DeepSpeed, השתמשנו במנגנון טעינת המחסום המהיר יותר שלו.

מנקודת מבט של חביון, DeepSpeed ​​מהירה בערך פי 3.4 עבור BLOOM-176B ופי 5.6 עבור OPT-30B מהירה יותר מאשר Accelerate. הגרעינים האופטימליים של DeepSpeed ​​אחראים לחלק גדול מההבדל הזה בהשהיה. בהתחשב בתוצאות אלו, אנו ממליצים להשתמש ב-DeepSpeed ​​על פני Accelerate אם הדגם שבחרת נתמך.

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

תוצאות אלו מדגימות גם את ההבדל בחביון ובתפוקה של גדלי מודל שונים. בבדיקות שלנו, OPT-30B מייצר פי 2.4 ממספר האסימונים ליחידת זמן מאשר BLOOM-176B בסוג מופע שזול יותר מפי שלושה. על בסיס מחיר ליחידת תפוקה, OPT-30B במופע g5.24xl טוב פי 8.9 מ-BLOOM-176B במופע p4d.24xl. אם יש לך מגבלות חביון, תפוקה או עלויות קפדניות, שקול להשתמש במודל הקטן ביותר האפשרי שעדיין ישיג דרישות פונקציונליות.

לנקות את

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

# - Delete the end point
sm_client.delete_endpoint(EndpointName=endpoint_name)

# - In case the end point failed we still want to delete the model
sm_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
sm_client.delete_model(ModelName=model_name)

אפשר למחוק את נקודת הבדיקה של הדגם מה-S3 שלך

!aws s3 rm --recursive s3:///{s3_model_prefix}

סיכום

בפוסט זה, הדגמנו כיצד להשתמש במיכלי מסקנות מדגמים גדולים של SageMaker כדי לארח שני דגמי שפה גדולים, BLOOM-176B ו-OPT-30B. השתמשנו בטכניקות המקבילות של DeepSpeed ​​עם מספר GPUs במופע אחד של SageMaker ML.

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

על המחברים

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

רופנדר גרוואל הוא אדריכל פתרונות מומחה Sr Ai/ML עם AWS. כיום הוא מתמקד בהגשת דגמים ו-MLOps ב- SageMaker. לפני תפקיד זה עבד כמהנדס למידת מכונה בבניית ואירוח מודלים. מחוץ לעבודה הוא נהנה לשחק טניס ולרכוב על אופניים בשבילי הרים.

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

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

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

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

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

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

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