Juurutage BLOOM-176B ja OPT-30B Amazon SageMakeris suure mudelijäreldamisega Deep Learning Containers ja DeepSpeed

Viimastel aastatel on süvaõppe vallas toimunud kiire areng. Kuigi riistvara on paranenud, näiteks NVIDIA ja Amazoni uusima põlvkonna kiirenditega, kogevad täiustatud masinõppe (ML) praktikud endiselt regulaarselt probleeme oma suurte süvaõppemudelite juurutamisel selliste rakenduste jaoks nagu loomuliku keele töötlemine (NLP).

Varasemas postituses arutasime võimalused ja konfigureeritavad seaded in Amazon SageMakeri mudeli juurutamine mis muudab nende suurte mudelite puhul järelduste tegemise lihtsamaks. Täna anname teada uuest Amazon SageMaker Deep Learning Container (DLC), mille abil saate mõne minutiga alustada suurte mudelite järeldustega. See DLC pakib mõned populaarsemad avatud lähtekoodiga teegid mudelite paralleelsete järelduste tegemiseks, näiteks DeepSpeed ​​ja Hugging Face Accelerate.

Selles postituses kasutame uut SageMakeri suure mudeli järelduse DLC-d, et juurutada kaks kõige populaarsemat suurt NLP mudelit: BigScience'i BLOOM-176B ja Meta oma OPT-30B Hugging Face hoidlast. Eelkõige kasutame DeepSpeedi Deep Java Library (DJL) teenindus- ja tensoriparalleelsuse tehnikaid, et saavutada teksti genereerimise kasutusjuhul 0.1-sekundiline latentsus märgi kohta.

Meie täielikud näidismärkmikud leiate meie lehelt GitHubi hoidla.

Suure mudeli järeldamistehnikad

Keelemudelid on viimasel ajal plahvatuslikult kasvanud nii suuruse kui ka populaarsuse poolest. Tänu lihtsale juurdepääsule mudeliloomaaedadest, nagu Hugging Face, ning NLP-ülesannete (nt klassifitseerimine ja teksti genereerimine) täiustatud täpsus ja jõudlus, otsivad praktikud üha enam nende suurte mudelite poole. Suured mudelid on aga sageli liiga suured, et mahutada ühe kiirendi mällu. Näiteks BLOOM-176B mudel võib nõuda rohkem kui 350 gigabaidist kiirendi mälu, mis ületab tunduvalt tänapäeval saadaolevate riistvarakiirendite mahu. See nõuab mudelite paralleelsete tehnikate kasutamist teekides nagu DeepSpeed ​​ja Hugging Face Accelerate, et jaotada mudel järelduste tegemiseks mitmele kiirendile. Selles postituses kasutame SageMakeri suur mudeli järelduskonteiner latentsuse ja läbilaskevõime genereerimiseks ja võrdlemiseks, kasutades neid kahte avatud lähtekoodiga teeki.

DeepSpeed ​​ja Accelerate kasutavad suuri keelemudeleid järelduste tegemiseks erinevaid tehnikaid. Peamine erinevus on DeepSpeed optimeeritud tuumade kasutamine. Need tuumad võivad järsult parandada järelduste latentsust, vähendades mudeli arvutusgraafiku kitsaskohti. Optimeeritud tuumasid võib olla raske välja töötada ja need on tavaliselt spetsiifilised konkreetse mudeli arhitektuuri jaoks; DeepSpeed ​​toetab nende optimeeritud tuumadega populaarseid suuri mudeleid, nagu OPT ja BLOOM. Seevastu Hugging Face'i Accelerate'i teek ei sisalda kirjutamise ajal optimeeritud tuumasid. Nagu me oma tulemuste jaotises arutame, põhjustab see erinevus suure osa DeepSpeedi jõudluse eelistest võrreldes Accelerate'iga.

Teine erinevus DeepSpeedi ja Accelerate'i vahel on mudeli paralleelsuse tüüp. Accelerate kasutab konveieri paralleelsust mudeli jaotamiseks mudeli peidetud kihtide vahel, samas kui DeepSpeed ​​kasutab kihtide endi jaotamiseks tensorparalleelsust. Torujuhtme paralleelsus on paindlik lähenemisviis, mis toetab rohkem mudelitüüpe ja võib parandada läbilaskevõimet suuremate partiide kasutamisel. Tensori paralleelsus nõuab suuremat suhtlust GPU-de vahel, kuna mudelikihte saab hajutada mitme seadme vahel, kuid need võivad parandada järelduste latentsust, kui lülitate korraga sisse mitu GPU-d. Paralleelsuse tehnikate kohta saate lisateavet aadressilt Sissejuhatus mudeliparallelismi ja Mudeli paralleelsus.

Lahenduse ülevaade

Suurte keelemudelite tõhusaks hostimiseks vajame funktsioone ja tuge järgmistes võtmevaldkondades.

• Lahenduste ehitamine ja katsetamine – Arvestades ML arenduse iteratiivset olemust, vajame võimet luua, kiiresti itereerida ja testida, kuidas järeldamise lõpp-punkt käitub nende mudelite hostimisel, sealhulgas võimet kiiresti ebaõnnestuda. Neid mudeleid saab tavaliselt majutada ainult suurematel eksemplaridel, nagu p4dn või g5, ning mudelite suurust arvestades võib järelduseksemplari keerutamine ja mis tahes testiteratsiooni käivitamine võtta aega. Kohalikul testimisel on tavaliselt piirangud, kuna testimiseks on vaja sarnase suurusega eksemplari ja neid mudeleid pole lihtne hankida.
• Juurutamine ja mastaabis töötamine – Mudelifailid tuleb laadida järelduseksemplaridesse, mis kujutab endast suurust arvestades väljakutset. Tõrva / Un-Tar näitena Bloom-176B jaoks kulub loomiseks umbes 1 tund ja laadimiseks veel tund. Mudelifailidele lihtsa juurdepääsu võimaldamiseks vajame alternatiivset mehhanismi.
• Mudeli laadimine üksikuna – Mitme töötajaga protsessi jaoks peame tagama, et mudel laaditakse ainult üks kord, et me ei satuks võistlustingimustesse ega kulutaks täiendavalt tarbetuid ressursse. Selles postituses näitame viisi, kuidas otse laadida Amazoni lihtne salvestusteenus (Amazon S3). Kuid see töötab ainult siis, kui kasutame DJL-i vaikesätteid. Lisaks peab lõpp-punktide mis tahes skaleerimine saama mõne minutiga üles tõusta, mis nõuab mudelite laadimise ja levitamise võimalust.
• Raamistiku jagamine – Need mudelid peavad tavaliselt olema , tavaliselt tensori paralleelsuse mehhanismi või konveieri jagamise abil, ja meil on arenenud kontseptsioonid, nagu näiteks null-jaotamine, mis on ehitatud tensori jagamise peale. Lisateabe saamiseks killustamistehnikate kohta vt Mudeli paralleelsus. Selle saavutamiseks saame kasutada erinevaid kombinatsioone ja kasutada NIVIDIA, DeepSpeedi ja teiste raamistikke. Selleks on vaja testida BYOC-i või kasutada 1P-konteinereid ning itereerida lahendusi ja käivitada võrdlusteste. Samuti võiksite katsetada erinevaid hostimisvõimalusi, nagu asünkroonne, serverita ja muud.
• Riistvara valik – Teie valiku riistvara osas määravad kõik eelnimetatud punktid ja edasised liiklusmustrid, kasutusjuhtude vajadused ja mudeli suurused.

Selles postituses kasutame SageMakeris BLOOM-176B ja OPT-30B hostimiseks DeepSpeedi optimeeritud tuumasid ja tensori paralleelsuse tehnikaid. Võrdleme ka Accelerate'i tulemusi, et näidata optimeeritud tuumade ja tensori paralleelsuse eeliseid. DeepSpeedi ja Accelerate'i kohta lisateabe saamiseks vaadake DeepSpeedi järeldus: trafomudelite tõhusa järelduse võimaldamine enneolematus mahus ja Uskumatult kiire BLOOM järeldus DeepSpeed ​​ja Accelerate abil.

Selles näites kasutame mudeli serveerimislahendusena DJLServing. DJLServing on suure jõudlusega universaalne mudelite teenindamise lahendus, mille toiteallikaks on Deep Java Library (DJL), mis on programmeerimiskeele agnostik. DJL-i ja DJLServingu kohta lisateabe saamiseks vaadake Rakendage Amazon SageMakeris suuri mudeleid, kasutades DJLServingi ja DeepSpeedi mudeli paralleelset järeldust.

Väärib märkimist, et optimeeritud tuumad võivad põhjustada täpsuse muutusi ja muudetud arvutusgraafikut, mis võib teoreetiliselt põhjustada mudeli käitumise muutumist. Kuigi see võib aeg-ajalt muuta järelduste tulemust, ei eelda me, et need erinevused mõjutavad oluliselt mudeli põhilisi hindamismõõdikuid. Sellegipoolest soovitatakse praktikutel kontrollida, kas mudeli väljundid on nende tuumade kasutamisel ootuspärased.

Järgmised sammud näitavad, kuidas juurutada BLOOM-176B mudelit SageMakeris, kasutades DJLServingit ja SageMakeri suurt mudeli järelduskonteinerit. Täielik näide on saadaval ka meie lehel GitHubi hoidla.

DJLServing SageMakeri DLC-pildi kasutamine

Kasutage järgmist koodi, et kasutada DJLServing SageMakeri DLC kujutist pärast piirkonna asendamist konkreetse piirkonnaga, kus sülearvuti töötab:

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

Looge meie mudelifail

Esiteks loome faili nimega serving.properties mis sisaldab ainult ühte koodirida. See käsib DJL-i mudeliserveril kasutada DeepSpeedi mootorit. Fail sisaldab järgmist koodi:

engine=DeepSpeed

serving.properties on DJLServingi määratletud fail, mida kasutatakse mudelipõhise konfiguratsiooni konfigureerimiseks.

Järgmisena loome oma model.py faili, mis määratleb mudeli laadimiseks ja seejärel teenindamiseks vajaliku koodi. Meie koodis loeme TENSOR_PARALLEL_DEGREE keskkonnamuutuja (vaikeväärtus on 1). See määrab seadmete arvu, mille vahel tensori paralleelmoodulid jaotatakse. Pange tähele, et DeepSpeed ​​pakub mõningaid sisseehitatud partitsioonide määratlusi, sealhulgas ühe BLOOM-mudelite jaoks. Kasutame seda täpsustades replace_method ja relpace_with_kernel_inject. Kui teil on kohandatud mudel ja vajate DeepSpeedi tõhusaks partitsiooniks, peate muutma relpace_with_kernel_inject et false ja lisage injection_policy käitusaja partitsiooni tööle panemiseks. Lisateabe saamiseks vaadake Initsialiseerimine järelduste tegemiseks. Meie näites kasutasime DeepSpeedis eelnevalt partitsioonitud BLOOM-mudelit.

Teiseks, aastal model.py faili, laadime mudeli ka Amazon S3-st pärast lõpp-punkti üles keeramist. Mudel laaditakse seadmesse /tmp ruumi konteineris, sest SageMaker kaardistab selle /tmp Euroopa Amazoni elastsete plokkide pood (Amazon EBS) köide, mis paigaldatakse lõpp-punkti loomise parameetri määramisel VolumeSizeInGB. Selliste juhtumite puhul nagu p4dn, mis on koos mahueksemplariga eelehitatud, saame jätkata /tmp konteineri peal. Vaadake järgmist koodi:

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 haldab käitusaegset installimist kõigis punktis määratletud pip-pakettides requirement.txt. Sellel failil on:

awscli
boto3

Oleme loonud kataloogi nimega code ja model.py, serving.propertiesja requirements.txt failid on selles kataloogis juba loodud. Failide vaatamiseks saate terminalist käivitada järgmise koodi:

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

Järgmisel joonisel on näidatud selle struktuur model.tar.gz.

Lõpuks loome mudelifaili ja laadime selle Amazon S3 üles:

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

Laadige mudel alla ja salvestage Hugging Face'ist (valikuline)

Oleme selles jaotises pakkunud juhiseid juhuks, kui soovite mudeli Amazon S3 alla laadida ja seda sealt kasutada. Toimingud on esitatud GitHubi Jupyteri failis. Järgmine ekraanipilt näitab sammude ülevaadet.

Looge SageMakeri mudel

Nüüd loome a SageMakeri mudel. Me kasutame Amazoni elastsete konteinerite register (Amazon ECR) kujutise ja mudeli artefakt eelmisest etapist SageMakeri mudeli loomiseks. Mudeli seadistuses konfigureerime TENSOR_PARALLEL_DEGREE=8, mis tähendab, et mudel on jaotatud 8 GPU vahel. Vaadake järgmist koodi:

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

Pärast Jupyteri failis eelmise lahtri käivitamist näete väljundit, mis sarnaneb järgmisega:

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

Looge SageMakeri lõpp-punkt

Saate testimiseks kasutada mis tahes eksemplare, millel on mitu GPU-d. Selles demos kasutame p4d.24xlarge eksemplari. Järgmises koodis pange tähele, kuidas me määrasime ModelDataDownloadTimeoutInSeconds, ContainerStartupHealthCheckTimeoutInSecondsja VolumeSizeInGB parameetrid, mis sobivad suure mudeli suurusega. The VolumeSizeInGB parameeter on rakendatav GPU eksemplaridele, mis toetavad EBS-i köitemanust.

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

Lõpuks loome SageMakeri lõpp-punkti:

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

Näete seda väljaprindituna järgmises koodis:

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

Lõpp-punkti käivitamine võib veidi aega võtta. Kui satute sellesse, võite proovida veel paar korda InsufficientInstanceCapacity või võite esitada AWS-ile taotluse oma konto limiidi suurendamiseks.

Jõudluse häälestamine

Kui kavatsete seda postitust ja sellega kaasnevat sülearvutit kasutada mõne muu mudeliga, võiksite uurida mõningaid häälestatavaid parameetreid, mida SageMaker, DeepSpeed ​​ja DJL pakuvad. Nende parameetritega korduv katsetamine võib oluliselt mõjutada teie hostitud suure mudeli latentsust, läbilaskevõimet ja maksumust. Lisateavet häälestusparameetrite (nt töötajate arv, tensori paralleelsuse aste, tööjärjekorra suurus ja muud) kohta leiate DJL-i serveerimiskonfiguratsioonid ja Rakendage Amazon SageMakeris suuri mudeleid, kasutades DJLServingi ja DeepSpeedi mudeli paralleelset järeldust.

Tulemused

Selles postituses kasutasime DeepSpeed'i BLOOM-176B ja OPT-30B hostimiseks SageMaker ML-i eksemplaridel. Järgmine tabel võtab kokku meie tulemuslikkuse tulemused, sealhulgas võrdluse Hugging Face's Accelerate'iga. Latentsus peegeldab millisekundite arvu, mis kulub 256 märgiga stringi neljakordseks loomiseks (batch_size=4) mudelist. Läbilaskevõime peegeldab iga testi jaoks sekundis toodetud žetoonide arvu. Hugging Face Accelerate'i jaoks kasutasime teegi vaikelaadimist koos GPU mälu vastendamisega. DeepSpeedi jaoks kasutasime selle kiiremat kontrollpunktide laadimismehhanismi.

Latentsusaja seisukohast on DeepSpeed ​​BLOOM-3.4B puhul umbes 176 korda ja OPT-5.6B puhul 30 korda kiirem kui Accelerate. DeepSpeedi optimeeritud tuumad vastutavad suure osa latentsuse erinevusest. Neid tulemusi arvestades soovitame kasutada funktsiooni DeepSpeed ​​over Accelerate, kui teie valitud mudelit toetatakse.

Samuti väärib märkimist, et mudeli laadimisajad DeepSpeediga olid palju lühemad, mistõttu on see parem valik, kui arvate, et peate oma lõpp-punktide arvu kiiresti suurendama. Accelerate'i paindlikum torujuhtme paralleelsuse tehnika võib olla parem valik, kui teil on mudeleid või mudeli täpsusi, mida DeepSpeed ​​ei toeta.

Need tulemused näitavad ka erinevate mudelisuuruste latentsuse ja läbilaskevõime erinevust. Meie testides genereerib OPT-30B 2.4 korda rohkem märke ajaühiku kohta kui BLOOM-176B eksemplaritüübil, mis on rohkem kui kolm korda odavam. Ühiku läbilaskevõime alusel on OPT-30B g5.24xl eksemplaris 8.9 korda parem kui BLOOM-176B p4d.24xl eksemplaris. Kui teil on ranged latentsus-, läbilaskevõime- või kulupiirangud, kaaluge väikseima võimaliku mudeli kasutamist, mis täidab siiski funktsionaalsed nõuded.

Koristage

Parimate tavade osana on alati soovitatav jõudeoleku eksemplarid kustutada. Allolev kood näitab, kuidas eksemplare kustutada.

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

Soovi korral kustutage S3-st mudeli kontrollpunkt

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

Järeldus

Selles postituses näitasime, kuidas kasutada SageMakeri suuri mudeli järelduskonteinereid kahe suure keelemudeli, BLOOM-176B ja OPT-30B, hostimiseks. Kasutasime DeepSpeedi mudeli paralleelseid tehnikaid mitme GPU-ga ühes SageMaker ML-i eksemplaris.

Lisateavet Amazon SageMakeri ja selle suurte mudelijäreldamisvõimaluste kohta leiate aadressilt Amazon SageMaker toetab nüüd suurte mudelite juurutamist konfigureeritava helitugevuse ja ajalõpu kvootide kaudu ja Reaalajas järeldus.

Autoritest

Simon Zamarin on AI/ML-lahenduste arhitekt, kelle põhirõhk on aidata klientidel oma andmevaradest väärtust ammutada. Vabal ajal veedab Simon meelsasti perega aega, loeb ulmet ja töötab erinevate isetegemismajade projektidega.

Rupinder Grewal on AWS-iga Sr Ai/ML spetsialistide lahenduste arhitekt. Praegu keskendub ta mudelite ja MLO-de teenindamisele SageMakeris. Enne seda rolli on ta töötanud masinõppeinsenerina mudelite ehitamise ja hostimise kohta. Töövälisel ajal meeldib talle tennist mängida ja mägiradadel jalgrattaga sõita.

Frank Liu on AWS-i süvaõppe tarkvarainsener. Ta keskendub uuenduslike süvaõppe tööriistade loomisele tarkvarainseneridele ja teadlastele. Vabal ajal meeldib talle sõprade ja perega matkata.

Alan Tan on SageMakeri vanemtootejuht, kes juhib jõupingutusi suurte mudelite järelduste tegemisel. Ta on kirglik masinõppe rakendamisest Analyticsi valdkonnas. Väljaspool tööd naudib ta õues olemist.

Dhawal Patel on AWS-i peamine masinõppearhitekt. Ta on töötanud hajutatud andmetöötluse ja tehisintellektiga seotud probleemide lahendamisel organisatsioonidega alates suurettevõtetest kuni keskmise suurusega idufirmadeni. Ta keskendub süvaõppele, sealhulgas NLP ja Computer Vision domeenidele. Ta aitab klientidel teha SageMakeris suure jõudlusega mudeli järeldusi.

Qing Lan on AWS-i tarkvaraarenduse insener. Ta on Amazonis töötanud mitmete väljakutset pakkuvate toodetega, sealhulgas suure jõudlusega ML järelduslahenduste ja suure jõudlusega logimissüsteemiga. Qingi meeskond käivitas Amazon Advertisingis edukalt esimese miljardi parameetriga mudeli, mille latentsusaeg on väga väike. Qingil on põhjalikud teadmised infrastruktuuri optimeerimise ja süvaõppe kiirendamise kohta.

Qingwei Li on Amazon Web Servicesi masinõppe spetsialist. Ta sai doktorikraadi. operatsioonide uurimisel pärast seda, kui ta murdis oma nõustaja uurimistoetuse konto ja ei suutnud väljastada lubatud Nobeli preemiat. Praegu aitab ta finantsteenuste ja kindlustussektori klientidel AWS-is masinõppelahendusi luua. Vabal ajal meeldib talle lugeda ja õpetada.

Robert Van Dusen on Amazon SageMakeri vanem tootejuht. Ta juhib süvaõppe mudelite optimeerimist selliste rakenduste jaoks nagu suurte mudelite järeldus.

Siddharth Venkatesan on AWS-i süvaõppe tarkvarainsener. Praegu keskendub ta lahenduste loomisele suurte mudelite järelduste tegemiseks. Enne AWS-i töötas ta organisatsioonis Amazon Grocery, luues uusi maksefunktsioone klientidele kogu maailmas. Väljaspool tööd meeldib talle suusatada, õues olla ja sporti vaadata.