Telepítse a BLOOM-176B-t és az OPT-30B-t az Amazon SageMaker-en a nagy modellkövetkeztetésekkel, Deep Learning Container-ekkel és DeepSpeed-del

Az elmúlt néhány évben gyors fejlődés ment végbe a mély tanulás területén. Bár a hardver javult, például az NVIDIA és az Amazon gyorsítóinak legújabb generációjával, a fejlett gépi tanulást (ML) gyakorló szakemberek továbbra is rendszeresen találkoznak problémákkal a nagy mélységű tanulási modelljeik alkalmazásakor olyan alkalmazásokban, mint a természetes nyelvi feldolgozás (NLP).

Egy korábbi bejegyzésünkben megbeszéltük képességek és konfigurálható beállítások in Amazon SageMaker modell bevezetése ami megkönnyíti a következtetések levonását ezekkel a nagy modellekkel. Ma egy újat jelentünk be Amazon SageMaker Deep Learning Container (DLC), amellyel percek alatt elkezdheti a nagyméretű modellkövetkeztetést. Ez DLC becsomagolja a legnépszerűbb nyílt forráskódú könyvtárakat a párhuzamos modellkövetkeztetéshez, mint például a DeepSpeed ​​és Hugging Face Accelerate.

Ebben a bejegyzésben egy új SageMaker nagy modell-következtetési DLC-t használunk a két legnépszerűbb nagy NLP-modell telepítéséhez: a BigScience BLOOM-176B és Métáé OPT-30B a Hugging Face adattárból. Konkrétan a DeepSpeed ​​Deep Java Library (DJL) kiszolgálási és tenzorpárhuzamossági technikáit használjuk, hogy tokenenként 0.1 másodperces késést érjünk el egy szöveggenerálási használati esetben.

Teljes példafüzeteinket megtalálja nálunk GitHub tárház.

Nagy modell-következtetési technikák

A nyelvi modellek az utóbbi időben robbanásszerűen megnőttek méretükben és népszerűségükben is. A modellállatkertekből, például a Hugging Face-ből való könnyű hozzáférésnek, valamint az NLP-feladatok (például osztályozás és szöveggenerálás) jobb pontosságának és teljesítményének köszönhetően a szakemberek egyre gyakrabban nyúlnak ezekhez a nagy modellekhez. A nagy modellek azonban gyakran túl nagyok ahhoz, hogy elférjenek egyetlen gyorsító memóriájában. A BLOOM-176B modell például több mint 350 gigabájt gyorsítómemóriát igényelhet, ami messze meghaladja a ma elérhető hardveres gyorsítók kapacitását. Ez szükségessé teszi az olyan könyvtárak modell párhuzamos technikáinak használatát, mint a DeepSpeed ​​és a Hugging Face Accelerate, hogy a modellt több gyorsító között eloszthassák következtetések levonásához. Ebben a bejegyzésben a SageMaker nagy modell-következtető tároló a várakozási idő és az átviteli teljesítmény létrehozásához és összehasonlításához e két nyílt forráskódú könyvtár használatával.

A DeepSpeed ​​és Accelerate különböző technikákat használ a nagy nyelvi modellek optimalizálására a következtetésekhez. A legfontosabb különbség a DeepSpeed optimalizált kernelek használata. Ezek a kernelek drámaian javíthatják a következtetések késleltetését azáltal, hogy csökkentik a szűk keresztmetszetek számát a modell számítási grafikonjában. Az optimalizált kerneleket nehéz lehet fejleszteni, és jellemzően egy adott modellarchitektúrára jellemzőek; A DeepSpeed ​​támogatja az olyan népszerű nagy modelleket, mint az OPT és a BLOOM ezekkel az optimalizált kernelekkel. Ezzel szemben a Hugging Face Accelerate könyvtára az írás idején nem tartalmaz optimalizált rendszermagokat. Amint azt az eredmények részben tárgyaljuk, ez a különbség felelős a DeepSpeed ​​teljesítményének jelentős részéért az Accelerate-hoz képest.

A másik különbség a DeepSpeed ​​és az Accelerate között a modell párhuzamosságának típusa. Az Accelerate csővezeték-párhuzamot használ a modell felosztására a modell rejtett rétegei között, míg a DeepSpeed ​​tenzorpárhuzamot használ a rétegek particionálására. A csővezeték párhuzamosítása egy rugalmas megközelítés, amely több modelltípust támogat, és nagyobb kötegméretek használata esetén javíthatja az átviteli sebességet. A tenzoros párhuzamosság több kommunikációt igényel a GPU-k között, mivel a modellrétegek több eszköz között is szétoszthatók, de több GPU egyidejű bekapcsolásával javíthatják a következtetések késését. A párhuzamosítási technikákról bővebben itt olvashat Bevezetés a modellpárhuzamba és a Modellpárhuzam.

Megoldás áttekintése

A nagy nyelvi modellek hatékony üzemeltetéséhez funkciókra és támogatásra van szükségünk a következő kulcsfontosságú területeken:

• Megoldások építése és tesztelése – Tekintettel az ML-fejlesztés iteratív jellegére, szükségünk van arra, hogy építsünk, gyorsan iteráljunk és teszteljünk, hogyan fog viselkedni a következtetési végpont ezeknek a modelleknek a hosztolásakor, beleértve a gyors meghibásodás képességét is. Ezeket a modelleket általában csak nagyobb példányokon, például p4dn-en vagy g5-ön lehet tárolni, és a modellek méretétől függően eltarthat egy ideig, amíg egy következtetési példányt felpörgetnek, és bármilyen teszt-iterációt futtatnak. A helyi tesztelésnek általában vannak megkötései, mivel a teszteléshez hasonló méretű példányra van szükség, és ezeket a modelleket nem könnyű megszerezni.
• Telepítés és méretarányos futás – A modellfájlokat be kell tölteni a következtetési példányokra, ami a mérethez képest önmagában is kihívást jelent. A Tar / Un-Tar példaként a Bloom-176B esetében körülbelül 1 órát vesz igénybe a létrehozása és egy másik óra a betöltése. Szükségünk van egy alternatív mechanizmusra, amely lehetővé teszi a modellfájlok könnyű elérését.
• A modell betöltése szingliként – Egy több munkás folyamathoz gondoskodnunk kell arról, hogy a modell csak egyszer töltsön be, hogy ne ütközzünk versenykörülményekbe és ne költsünk tovább felesleges erőforrásokat. Ebben a bejegyzésben bemutatjuk, hogyan tölthet be közvetlenül innen Amazon egyszerű tárolási szolgáltatás (Amazon S3). Ez azonban csak akkor működik, ha a DJL alapértelmezett beállításait használjuk. Ezenkívül a végpontok bármilyen skálázásának képesnek kell lennie néhány perc alatt felpörögni, ami szükségessé teszi a modellek betöltésének és elosztásának újragondolását.
• A keretrendszerek megosztása – Ezeket a modelleket általában tenzorpárhuzamossági mechanizmussal vagy csővezeték-felosztással, mint tipikus felosztási technikával kell megvalósítani, és olyan fejlett koncepcióink vannak, mint a zero sharding, amely a tenzorfelosztásra épül. A felosztási technikákkal kapcsolatos további információkért lásd: Modellpárhuzam. Ennek eléréséhez különféle kombinációkat használhatunk, és használhatjuk a NIVIDIA, DeepSpeed ​​és mások keretrendszereit. Ehhez képesnek kell lennie a BYOC tesztelésére vagy az 1P tárolók használatára, valamint a megoldások iterálására és benchmarking tesztek futtatására. Érdemes lehet tesztelni a különféle tárhely-lehetőségeket is, például az aszinkron, a szerver nélküli és egyebeket.
• Hardver kiválasztása – Hardverválasztását a fent említett pontok és a további forgalmi minták, a felhasználási igények és a modellméretek határozzák meg.

Ebben a bejegyzésben a DeepSpeed ​​optimalizált kerneleit és tenzorpárhuzamossági technikákat használjuk a BLOOM-176B és OPT-30B tárolására a SageMakeren. Összehasonlítjuk az Accelerate eredményeit is, hogy bemutassuk az optimalizált kernelek és a tenzorpárhuzamosság teljesítménybeli előnyeit. A DeepSpeed ​​és Accelerate további információért lásd: DeepSpeed ​​Inference: A transzformátormodellek hatékony következtetésének lehetővé tétele soha nem látott méretekben és a Hihetetlenül gyors BLOOM következtetés a DeepSpeed ​​és Accelerate segítségével.

Ebben a példában a DJLServing modellszolgáltatási megoldást használjuk. A DJLServing egy nagy teljesítményű univerzális modellkiszolgáló megoldás, amelyet a Deep Java Library (DJL) hajt, amely programnyelv-agnosztikus. Ha többet szeretne megtudni a DJL-ről és a DJLServingről, lásd: Telepítsen nagy modelleket az Amazon SageMaker-en a DJLServing és a DeepSpeed ​​modell párhuzamos következtetésével.

Érdemes megjegyezni, hogy az optimalizált kernelek precíziós változásokat és módosított számítási gráfot eredményezhetnek, ami elméletileg a modell viselkedésének megváltozását eredményezheti. Bár ez időnként megváltoztathatja a következtetés eredményét, nem várjuk, hogy ezek a különbségek érdemben befolyásolják a modell alapvető értékelési mutatóit. Mindazonáltal a szakembereknek azt tanácsoljuk, hogy e kernelek használatakor ellenőrizze, hogy a modell kimenetei megfelelnek-e az elvárásoknak.

A következő lépések bemutatják, hogyan telepíthet egy BLOOM-176B modellt a SageMakerben a DJLServing és egy SageMaker nagy modellkövetkeztető tároló használatával. A teljes példa nálunk is elérhető GitHub tárház.

A DJLServing SageMaker DLC kép használata

Használja a következő kódot a DJLServing SageMaker DLC-kép használatához, miután lecserélte a régiót arra a régióra, amelyben a notebook fut:

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

Készítse el modellfájlunkat

Először létrehozunk egy fájlt, melynek neve serving.properties amely csak egy kódsort tartalmaz. Ez arra utasítja a DJL modellszervert, hogy használja a DeepSpeed ​​motort. A fájl a következő kódot tartalmazza:

engine=DeepSpeed

serving.properties a DJLServing által meghatározott fájl, amely a modellenkénti konfiguráció konfigurálására szolgál.

Ezután létrehozzuk a sajátunkat model.py fájl, amely meghatározza a modell betöltéséhez, majd kiszolgálásához szükséges kódot. Kódunkban a TENSOR_PARALLEL_DEGREE környezeti változó (az alapértelmezett érték 1). Ez beállítja azon eszközök számát, amelyek között a tenzor párhuzamos modulok el vannak osztva. Vegye figyelembe, hogy a DeepSpeed ​​néhány beépített partíciódefiníciót biztosít, köztük egyet a BLOOM modellekhez. Megadással használjuk replace_method és a relpace_with_kernel_inject. Ha személyre szabott modellel rendelkezik, és DeepSpeed-re van szüksége a hatékony particionáláshoz, módosítania kell relpace_with_kernel_inject nak nek false és adjunk hozzá injection_policy hogy a futásidejű partíció működjön. További információkért lásd: Inicializálás a következtetéshez. Példánkban az előre particionált BLOOM modellt használtuk a DeepSpeeden.

Másodszor, a model.py fájlt, a végpont felpörgetése után az Amazon S3-ból is betöltjük a modellt. A modell betöltődik a /tmp helyet a tárolón, mert a SageMaker leképezi a /tmp hoz Amazon Elastic Block Store (Amazon EBS) kötet, amely a végpont-létrehozási paraméter megadásakor fel van csatolva VolumeSizeInGB. Az olyan esetekben, mint a p4dn, amelyek előre be vannak építve a kötetpéldányhoz, továbbra is kihasználhatjuk a /tmp a konténeren. Lásd a következő kódot:

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

A DJLServing kezeli a futásidejű telepítést a ben meghatározott pip csomagokon requirement.txt. Ennek a fájlnak a következők lesznek:

awscli
boto3

Létrehoztunk egy könyvtárat code és a model.py, serving.propertiesés requirements.txt fájlok már létrejöttek ebben a könyvtárban. A fájlok megtekintéséhez futtassa a következő kódot a terminálról:

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

A következő ábra a szerkezet felépítését mutatja be model.tar.gz.

Végül létrehozzuk a modellfájlt, és feltöltjük az Amazon S3-ba:

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

Töltse le és tárolja a modellt a Hugging Face webhelyről (opcionális)

Ebben a részben megadtuk a lépéseket arra az esetre, ha le szeretné tölteni a modellt az Amazon S3-ra, és onnan használni szeretné. A lépéseket a GitHubon található Jupyter fájl tartalmazza. A következő képernyőképen a lépések pillanatképe látható.

Hozzon létre egy SageMaker modellt

Most létrehozunk a SageMaker modell. Használjuk a Amazon Elastic Container Registry (Amazon ECR) által biztosított kép és a SageMaker modell létrehozásának előző lépéséből származó modelltermék. A modell beállításánál konfiguráljuk TENSOR_PARALLEL_DEGREE=8, ami azt jelenti, hogy a modell 8 GPU mentén van felosztva. Lásd a következő kódot:

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

Miután futtatta az előző cellát a Jupyter fájlban, a következőhöz hasonló kimenet jelenik meg:

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

Hozzon létre egy SageMaker végpontot

A teszteléshez bármilyen több GPU-val rendelkező példányt használhat. Ebben a bemutatóban p4d.24xlarge példányt használunk. A következő kódban jegyezze meg, hogyan állítjuk be a ModelDataDownloadTimeoutInSeconds, ContainerStartupHealthCheckTimeoutInSecondsés VolumeSizeInGB paraméterek a nagy modellmérethez. Az VolumeSizeInGB paraméter az EBS-kötetmellékletet támogató GPU-példányokra vonatkozik.

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,
        },
    ],
)'

Végül létrehozunk egy SageMaker végpontot:

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

A következő kódban látja kinyomtatva:

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

A végpont elindítása eltarthat egy ideig. Megpróbálhatod még néhányszor, ha belefutsz a InsufficientInstanceCapacity hiba, vagy kérheti az AWS-t a fiók korlátjának növelésére.

Teljesítmény növelés

Ha ezt a bejegyzést és a hozzá tartozó notebookot egy másik modellel szeretné használni, érdemes lehet felfedezni néhány hangolható paramétert, amelyet a SageMaker, a DeepSpeed ​​és a DJL kínál. Ezekkel a paraméterekkel való iteratív kísérletezés jelentős hatással lehet a tárolt nagy modell késleltetésére, átviteli sebességére és költségére. Ha többet szeretne megtudni a hangolási paraméterekről, mint például a dolgozók száma, a tenzor párhuzamosság mértéke, a feladatsor mérete és egyebek, tekintse meg a következőt: DJL kiszolgálási konfigurációk és a Telepítsen nagy modelleket az Amazon SageMaker-en a DJLServing és a DeepSpeed ​​modell párhuzamos következtetésével.

Eredmények

Ebben a bejegyzésben a DeepSpeed-et használtuk a BLOOM-176B és OPT-30B tárolására SageMaker ML példányokon. Az alábbi táblázat összefoglalja teljesítményeink eredményeit, beleértve a Hugging Face's Accelerate összehasonlítását. A késleltetés egy 256 tokenből álló karakterlánc négyszeri előállításához szükséges ezredmásodpercek számát tükrözi (batch_size=4) a modellből. Az áteresztőképesség az egyes teszteknél másodpercenként előállított tokenek számát tükrözi. A Hugging Face Accelerate esetében a könyvtár alapértelmezett betöltését használtuk GPU-memória-leképezéssel. A DeepSpeed ​​esetében a gyorsabb ellenőrzőpont-betöltési mechanizmust használtuk.

A késleltetés szempontjából a DeepSpeed ​​körülbelül 3.4-szer gyorsabb a BLOOM-176B esetében, és 5.6-szor gyorsabb az OPT-30B esetében, mint az Accelerate. A DeepSpeed ​​optimalizált kerneljei felelősek a késleltetési időbeli különbségek nagy részéért. Ezen eredmények alapján javasoljuk a DeepSpeed ​​over Accelerate használatát, ha a választott modell támogatott.

Azt is érdemes megjegyezni, hogy a DeepSpeed ​​modell betöltési ideje sokkal rövidebb volt, így ez jobb megoldás, ha arra számít, hogy gyorsan növelni kell a végpontok számát. Az Accelerate rugalmasabb folyamatpárhuzamossági technikája jobb megoldás lehet, ha olyan modelljei vagy modellpontosságai vannak, amelyeket a DeepSpeed ​​nem támogat.

Ezek az eredmények a különböző méretű modellek késleltetésében és áteresztőképességében mutatkozó különbségeket is demonstrálják. Tesztjeink során az OPT-30B 2.4-szer annyi tokent generál egységnyi idő alatt, mint a BLOOM-176B egy több mint háromszor olcsóbb példánytípuson. Egységenkénti átviteli sebesség alapján az OPT-30B a g5.24xl példányon 8.9-szer jobb, mint a BLOOM-176B a p4d.24xl példányon. Ha szigorú késleltetési, átviteli vagy költségkorlátai vannak, fontolja meg a lehető legkisebb modell használatát, amely továbbra is teljesíti a funkcionális követelményeket.

Tisztítsuk meg

A legjobb gyakorlatok részeként mindig javasolt a tétlen példányok törlése. Az alábbi kód megmutatja, hogyan törölheti a példányokat.

# - 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)

Opcionálisan törölje a modellellenőrző pontot az S3-ból

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

Következtetés

Ebben a bejegyzésben bemutattuk, hogyan lehet SageMaker nagy modell-következtetési tárolókat használni két nagy nyelvi modell, a BLOOM-176B és az OPT-30B befogadására. A DeepSpeed ​​modell párhuzamos technikáit alkalmaztuk több GPU-val egyetlen SageMaker ML példányon.

Az Amazon SageMakerrel és annak nagy modellkövetkeztetési képességeivel kapcsolatos további részletekért lásd: Az Amazon SageMaker mostantól támogatja a nagy modellek telepítését a konfigurálható kötetméret és időtúllépési kvóták révén és a Valós idejű következtetés.

A szerzőkről

Simon Zamarin egy AI/ML Solutions Architect, akinek fő célja az, hogy segítse az ügyfeleket abban, hogy értéket vonjanak ki adatvagyonukból. Szabadidejében Simon szívesen tölt időt a családjával, sci-fit olvas, és különféle barkácsházi projekteken dolgozik.

Rupinder Grewal Sr Ai/ML Specialist Solutions Architect, az AWS-vel. Jelenleg a SageMaker modellek és MLOp-k kiszolgálására összpontosít. Ezt megelőzően gépi tanulási mérnökként dolgozott modellek építésében és üzemeltetésében. Munkán kívül szeret teniszezni és hegyi ösvényeken kerékpározni.

Frank Liu az AWS Deep Learning szoftvermérnöke. Arra összpontosít, hogy innovatív mély tanulási eszközöket építsen szoftvermérnökök és tudósok számára. Szabadidejében szívesen túrázik barátaival és családjával.

Alan Tan a SageMaker vezető termékmenedzsere a nagy modellkövetkeztetések terén. Szenvedélyesen szereti a gépi tanulást az Analytics területén alkalmazni. Munkán kívül élvezi a szabad levegőt.

Dhawal Patel az AWS vezető gépi tanulási építésze. Az elosztott számítástechnikával és a mesterséges intelligenciával kapcsolatos problémákon a nagyvállalatoktól a közepes méretű induló vállalkozásokig szervezetekkel dolgozott együtt. A mély tanulásra összpontosít, beleértve az NLP és a Computer Vision tartományokat. Segít az ügyfeleknek abban, hogy a SageMaker-en nagy teljesítményű modellkövetkeztetést érjenek el.

Qing Lan az AWS szoftverfejlesztő mérnöke. Számos kihívást jelentő terméken dolgozott az Amazonban, beleértve a nagy teljesítményű ML következtetési megoldásokat és a nagy teljesítményű naplózási rendszert. Qing csapata sikeresen elindította az Amazon Advertising első milliárdos paraméterű modelljét, nagyon alacsony késleltetéssel. Qing mélyreható ismeretekkel rendelkezik az infrastruktúra optimalizálásával és a Deep Learning gyorsításával kapcsolatban.

Qingwei Li az Amazon Web Services gépi tanulási szakértője. Ph.D fokozatot szerzett. az Operations Researchben, miután feltörte tanácsadója kutatási támogatási számláját, és nem teljesítette az ígért Nobel-díjat. Jelenleg a pénzügyi szolgáltatási és biztosítási ágazatban tevékenykedő ügyfeleknek segít abban, hogy gépi tanulási megoldásokat építsenek az AWS-re. Szabadidejében szeret olvasni és tanítani.

Robert Van Dusen az Amazon SageMaker vezető termékmenedzsere. Ő vezeti a mély tanulási modelloptimalizálást olyan alkalmazásokhoz, mint például a nagy modellkövetkeztetés.

Siddharth Venkatesan az AWS Deep Learning szoftvermérnöke. Jelenleg a nagy modellkövetkeztetések megoldására összpontosít. Az AWS előtt az Amazon Grocery szervezetben dolgozott, új fizetési funkciókat épített ki az ügyfelek számára világszerte. Munkán kívül szeret síelni, a szabadban lenni és sportokat nézni.