Razmestite BLOOM-176B in OPT-30B na Amazon SageMaker z velikimi vsebniki za globoko učenje in DeepSpeed ​​inference

V zadnjih nekaj letih je prišlo do hitrega razvoja na področju globokega učenja. Čeprav se je strojna oprema izboljšala, na primer z najnovejšo generacijo pospeševalnikov NVIDIA in Amazon, se izvajalci naprednega strojnega učenja (ML) še vedno redno srečujejo s težavami pri uvajanju svojih velikih modelov globokega učenja za aplikacije, kot je obdelava naravnega jezika (NLP).

V prejšnji objavi smo razpravljali zmogljivosti in nastavljive nastavitve in Uvedba modela Amazon SageMaker ki lahko olajša sklepanje s temi velikimi modeli. Danes objavljamo novo Amazon SageMaker Deep Learning Container (DLC), ki ga lahko uporabite za začetek sklepanja velikih modelov v nekaj minutah. to DLC paketi nekaterih najbolj priljubljenih odprtokodnih knjižnic za vzporedno sklepanje modelov, kot sta DeepSpeed ​​in Hugging Face Accelerate.

V tej objavi uporabljamo nov DLC za sklepanje velikih modelov SageMaker za uvedbo dveh najbolj priljubljenih velikih modelov NLP: BigScience's BLOOM-176B in Meta OPT-30B iz skladišča Hugging Face. Zlasti uporabljamo storitve strežbe Deep Java Library (DJL) in tehnike paralelizma tenzorjev podjetja DeepSpeed, da dosežemo 0.1 sekundno zakasnitev na žeton v primeru uporabe generiranja besedila.

Naše celotne primere zvezkov najdete v našem GitHub repozitorij.

Tehnike sklepanja velikih modelov

Jezikovni modeli so nedavno eksplodirali tako v velikosti kot v priljubljenosti. Z enostavnim dostopom iz živalskih vrtov modelov, kot je Hugging Face, ter izboljšano natančnostjo in zmogljivostjo pri nalogah NLP, kot sta klasifikacija in ustvarjanje besedila, praktiki vedno bolj posegajo po teh velikih modelih. Vendar so veliki modeli pogosto preveliki, da bi jih lahko spravili v pomnilnik enega pospeševalnika. Na primer, model BLOOM-176B lahko zahteva več kot 350 gigabajtov pomnilnika pospeševalnika, kar daleč presega zmogljivost strojnih pospeševalnikov, ki so danes na voljo. To zahteva uporabo modelnih vzporednih tehnik iz knjižnic, kot sta DeepSpeed ​​in Hugging Face Accelerate, za distribucijo modela med več pospeševalniki za sklepanje. V tej objavi uporabljamo SageMaker velik vsebnik sklepanja modela za ustvarjanje in primerjavo zakasnitve in zmogljivosti prepustnosti z uporabo teh dveh odprtokodnih knjižnic.

DeepSpeed ​​in Accelerate uporabljata različne tehnike za optimizacijo velikih jezikovnih modelov za sklepanje. Ključna razlika je pri DeepSpeedu uporaba optimiziranih jeder. Ta jedra lahko dramatično izboljšajo zakasnitev sklepanja z zmanjšanjem ozkih grl v računskem grafu modela. Optimizirana jedra je lahko težko razviti in so običajno specifična za določeno arhitekturo modela; DeepSpeed ​​podpira priljubljene velike modele, kot sta OPT in BLOOM s temi optimiziranimi jedri. V nasprotju s tem knjižnica Accelerate Hugging Face v času pisanja ne vključuje optimiziranih jeder. Kot razpravljamo v razdelku o rezultatih, je ta razlika odgovorna za velik del zmogljivosti, ki jo ima DeepSpeed ​​pred Accelerate.

Druga razlika med DeepSpeed ​​in Accelerate je vrsta vzporednosti modela. Accelerate uporablja paralelizem cevovoda za razdelitev modela med skrite plasti modela, medtem ko DeepSpeed ​​uporablja tenzorski paralelizem za razdelitev samih plasti. Paralelizem cevovoda je prilagodljiv pristop, ki podpira več vrst modelov in lahko izboljša prepustnost, ko se uporabljajo večje velikosti paketov. Paralelizem tenzorjev zahteva več komunikacije med grafičnimi procesorji, ker se sloji modela lahko razširijo na več naprav, vendar lahko izboljšajo zakasnitev sklepanja s hkratnim vključevanjem več grafičnih procesorjev. Več o tehnikah paralelizma lahko izveste v Uvod v modelni paralelizem in Paralelizem modela.

Pregled rešitev

Za učinkovito gostovanje velikih jezikovnih modelov potrebujemo funkcije in podporo na naslednjih ključnih področjih:

• Gradnja in testiranje rešitev – Glede na iterativno naravo razvoja strojnega jezika potrebujemo zmožnost gradnje, hitrega ponavljanja in testiranja, kako se bo končna točka sklepanja obnašala, ko bodo ti modeli gostovani, vključno z zmožnostjo hitre odpovedi. Te modele je običajno mogoče gostiti le na večjih primerkih, kot sta p4dn ali g5, in glede na velikost modelov lahko traja nekaj časa, da zavrtimo primerek sklepanja in izvedemo morebitno ponovitev preizkusa. Lokalno testiranje ima običajno omejitve, ker za testiranje potrebujete primerek podobne velikosti, teh modelov pa ni enostavno dobiti.
• Uvajanje in izvajanje v velikem obsegu – Datoteke modela je treba naložiti v primerke sklepanja, kar je samo po sebi izziv glede na velikost. Tar / Un-Tar kot primer za Bloom-176B traja približno 1 uro za ustvarjanje in še eno uro za nalaganje. Potrebujemo nadomestni mehanizem, ki omogoča enostaven dostop do datotek modela.
• Nalaganje modela kot singleton – Za proces z več delavci moramo zagotoviti, da se model naloži samo enkrat, da ne naletimo na tekmovalne pogoje in dodatno porabimo nepotrebne vire. V tej objavi prikazujemo način nalaganja neposredno iz Preprosta storitev shranjevanja Amazon (Amazon S3). Vendar to deluje le, če uporabimo privzete nastavitve DJL. Poleg tega mora imeti možnost, da se vsako skaliranje končnih točk zavrti v nekaj minutah, kar zahteva ponovni premislek o tem, kako bi se lahko modeli naložili in porazdelili.
• Ogrodja za razčlenjevanje – Ti modeli morajo biti običajno , običajno z mehanizmom vzporednosti tenzorjev ali s cevovodnim drobljenjem kot tipičnimi tehnikami drobljenja, in imamo napredne koncepte, kot je drobljenje ZeRO, zgrajeno na vrhu tenzorskega drobljenja. Za več informacij o tehnikah razrezovanja glejte Paralelizem modela. Da bi to dosegli, lahko imamo različne kombinacije in uporabljamo okvire NIVIDIA, DeepSpeed ​​in drugih. Za to je potrebna možnost testiranja BYOC ali uporabe vsebnikov 1P ter ponavljanja rešitev in izvajanja primerjalnih testov. Morda boste želeli preizkusiti tudi različne možnosti gostovanja, kot so asinhrono, brez strežnika in druge.
• Izbira strojne opreme – Vašo izbiro strojne opreme določajo vse prej omenjene točke in nadaljnji vzorci prometa, potrebe primerov uporabe in velikosti modelov.

V tej objavi uporabljamo optimizirana jedra DeepSpeed ​​in tehnike paralelizma tenzorjev za gostovanje BLOOM-176B in OPT-30B na SageMakerju. Primerjamo tudi rezultate iz programa Accelerate, da pokažemo prednosti delovanja optimiziranih jeder in paralelizma tenzorjev. Za več informacij o DeepSpeed ​​in Accelerate glejte DeepSpeed ​​Inference: omogočanje učinkovitega sklepanja transformatorskih modelov v neverjetnem obsegu in Neverjetno hitro sklepanje BLOOM z DeepSpeed ​​in Accelerate.

V tem primeru kot modelno rešitev za serviranje uporabljamo DJLServing. DJLServing je visoko zmogljiva univerzalna rešitev za streženje modelov, ki jo poganja Deep Java Library (DJL), ki je agnostična za programski jezik. Če želite izvedeti več o DJL in DJLServing, glejte Razmestite velike modele v Amazon SageMaker z vzporednim sklepanjem modelov DJLServing in DeepSpeed.

Omeniti velja, da lahko optimizirana jedra povzročijo spremembe natančnosti in spremenjen računski graf, kar bi lahko teoretično povzročilo spremenjeno vedenje modela. Čeprav bi to lahko občasno spremenilo izid sklepanja, ne pričakujemo, da bodo te razlike bistveno vplivale na osnovne meritve vrednotenja modela. Kljub temu strokovnjakom svetujemo, da pri uporabi teh jeder potrdijo, da so rezultati modela pričakovani.

Naslednji koraki prikazujejo, kako razmestiti model BLOOM-176B v SageMaker z uporabo DJLServing in velikega vsebnika sklepanja modela SageMaker. Celoten primer je na voljo tudi v naši GitHub repozitorij.

Uporaba slike DJLServing SageMaker DLC

Uporabite naslednjo kodo za uporabo slike DJLServing SageMaker DLC po zamenjavi regije z vašo specifično regijo, v kateri uporabljate prenosni računalnik:

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

Ustvarite datoteko našega modela

Najprej ustvarimo datoteko z imenom serving.properties ki vsebuje samo eno vrstico kode. To strežniku modela DJL sporoči, naj uporablja mehanizem DeepSpeed. Datoteka vsebuje naslednjo kodo:

engine=DeepSpeed

serving.properties je datoteka, ki jo definira DJLServing in se uporablja za konfiguracijo konfiguracije po modelu.

Nato ustvarimo svoje model.py datoteko, ki definira kodo, potrebno za nalaganje in nato serviranje modela. V naši kodi beremo v TENSOR_PARALLEL_DEGREE spremenljivka okolja (privzeta vrednost je 1). To nastavi število naprav, po katerih so porazdeljeni tenzorski paralelni moduli. Upoštevajte, da DeepSpeed ​​ponuja nekaj vgrajenih definicij particij, vključno z eno za modele BLOOM. Uporabljamo ga tako, da navedemo replace_method in relpace_with_kernel_inject. Če imate model po meri in potrebujete DeepSpeed ​​za učinkovito particioniranje, ga morate spremeniti relpace_with_kernel_inject do false in dodaj injection_policy da bo izvajalna particija delovala. Za več informacij glejte Inicializacija za sklepanje. Za naš primer smo uporabili vnaprej particioniran model BLOOM na DeepSpeed.

Drugič, v model.py datoteko, naložimo tudi model iz Amazon S3, potem ko se končna točka zavrti. Model je naložen v /tmp prostora na vsebniku, ker SageMaker preslika /tmp k Trgovina z elastičnimi bloki Amazon (Amazon EBS), ki je nameščen, ko podamo parameter za ustvarjanje končne točke VolumeSizeInGB. Za primere, kot je p4dn, ki so vnaprej zgrajeni s primerkom glasnosti, lahko še naprej izkoriščamo /tmp na posodi. Oglejte si naslednjo kodo:

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 upravlja namestitev med izvajanjem na vseh paketih pip, definiranih v requirement.txt. Ta datoteka bo imela:

awscli
boto3

Ustvarili smo imenik z imenom code in model.py, serving.propertiesin requirements.txt v tem imeniku je že ustvarjenih . Za ogled datotek lahko s terminala zaženete naslednjo kodo:

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

Naslednja slika prikazuje strukturo model.tar.gz.

Na koncu ustvarimo datoteko modela in jo naložimo v Amazon S3:

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

Prenesite in shranite model iz Hugging Face (izbirno)

V tem razdelku smo zagotovili korake, če želite prenesti model v Amazon S3 in ga uporabljati od tam. Koraki so na voljo v datoteki Jupyter na GitHubu. Naslednji posnetek zaslona prikazuje posnetek korakov.

Ustvarite model SageMaker

Zdaj ustvarjamo a Model SageMaker. Uporabljamo Registar elastičnih zabojnikov Amazon Slika (Amazon ECR) in artefakt modela iz prejšnjega koraka za ustvarjanje modela SageMaker. V nastavitvi modela konfiguriramo TENSOR_PARALLEL_DEGREE=8, kar pomeni, da je model razdeljen na 8 GPE. Oglejte si naslednjo kodo:

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

Ko zaženete prejšnjo celico v datoteki Jupyter, vidite rezultat, podoben naslednjemu:

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

Ustvarite končno točko SageMaker

Za testiranje lahko uporabite poljubne primerke z več grafičnimi procesorji. V tej predstavitvi uporabljamo primerek p4d.24xlarge. V naslednji kodi si oglejte, kako smo nastavili ModelDataDownloadTimeoutInSeconds, ContainerStartupHealthCheckTimeoutInSecondsin VolumeSizeInGB parametri za prilagoditev velike velikosti modela. The VolumeSizeInGB parameter velja za primerke GPE, ki podpirajo priponko nosilca 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,
        },
    ],
)'

Nazadnje ustvarimo končno točko SageMaker:

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

Vidite ga natisnjenega v naslednji kodi:

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

Zagon končne točke lahko traja nekaj časa. Lahko poskusite še nekajkrat, če naletite na InsufficientInstanceCapacity napako ali pa pri AWS vložite zahtevo za povečanje omejitve v vašem računu.

Nastavitev zmogljivosti

Če nameravate to objavo in spremljajoči prenosni računalnik uporabiti z drugim modelom, boste morda želeli raziskati nekatere nastavljive parametre, ki jih ponujajo SageMaker, DeepSpeed ​​in DJL. Ponavljajoče eksperimentiranje s temi parametri lahko pomembno vpliva na zakasnitev, prepustnost in stroške vašega gostujočega velikega modela. Če želite izvedeti več o nastavitvah parametrov, kot so število delavcev, stopnja vzporednosti tenzorjev, velikost čakalne vrste opravil in drugi, glejte DJL Serving konfiguracije in Razmestite velike modele v Amazon SageMaker z vzporednim sklepanjem modelov DJLServing in DeepSpeed.

Rezultati

V tej objavi smo uporabili DeepSpeed ​​za gostovanje BLOOM-176B in OPT-30B na instancah SageMaker ML. Naslednja tabela povzema naše rezultate uspešnosti, vključno s primerjavo s Hugging Face's Accelerate. Zakasnitev odraža število milisekund, ki so potrebne, da se štirikrat ustvari niz s 256 žetoni (batch_size=4) od modela. Prepustnost odraža število žetonov, proizvedenih na sekundo za vsak test. Za Hugging Face Accelerate smo uporabili privzeto nalaganje knjižnice s preslikavo pomnilnika GPU. Za DeepSpeed ​​smo uporabili hitrejši mehanizem nalaganja kontrolnih točk.

Z vidika zakasnitve je DeepSpeed ​​približno 3.4-krat hitrejši za BLOOM-176B in 5.6-krat hitrejši za OPT-30B kot Accelerate. Optimizirana jedra DeepSpeed ​​so odgovorna za velik del te razlike v zakasnitvi. Glede na te rezultate priporočamo uporabo DeepSpeed ​​namesto Accelerate, če je vaš izbrani model podprt.

Omeniti velja tudi, da so bili časi nalaganja modela z DeepSpeed ​​veliko krajši, zaradi česar je boljša možnost, če predvidevate, da boste morali hitro povečati število končnih točk. Prilagodljivejša tehnika paralelizma cevovoda Accelerate je morda boljša možnost, če imate modele ali natančnosti modelov, ki jih DeepSpeed ​​ne podpira.

Ti rezultati prav tako prikazujejo razliko v zakasnitvi in ​​prepustnosti različnih velikosti modelov. V naših testih OPT-30B ustvari 2.4-kratno število žetonov na časovno enoto kot BLOOM-176B na vrsti primerka, ki je več kot trikrat cenejši. Na podlagi cene na enoto prepustnosti je OPT-30B na instanci g5.24xl 8.9-krat boljši od BLOOM-176B na instanci p4d.24xl. Če imate stroge omejitve zakasnitve, prepustnosti ali stroškov, razmislite o uporabi najmanjšega možnega modela, ki bo še vedno dosegal funkcionalne zahteve.

Čiščenje

Kot del najboljših praks je vedno priporočljivo izbrisati nedejavne primerke. Spodnja koda prikazuje, kako izbrišete primerke.

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

Po želji izbrišite kontrolno točko modela iz vašega S3

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

zaključek

V tej objavi smo pokazali, kako uporabiti vsebnike sklepanja velikih modelov SageMaker za gostovanje dveh velikih jezikovnih modelov, BLOOM-176B in OPT-30B. Uporabili smo vzporedne tehnike modela DeepSpeed ​​z več grafičnimi procesorji na enem primerku SageMaker ML.

Za več podrobnosti o Amazon SageMaker in njegovih zmožnostih sklepanja velikih modelov glejte Amazon SageMaker zdaj podpira uvajanje velikih modelov prek nastavljive velikosti nosilca in časovnih omejitev in Sklepanje v realnem času.

O avtorjih

Simon Zamarin je arhitekt rešitev AI / ML, katerega glavni poudarek je pomagati strankam izvleči vrednost iz njihovih podatkovnih sredstev. V prostem času Simon rad preživlja čas z družino, bere znanstvene fantastike in dela na različnih hišnih projektih.

Rupinder Grewal je Sr Ai/ML Specialist Solutions Architect pri AWS. Trenutno se osredotoča na streženje modelov in MLO na SageMakerju. Pred to vlogo je delal kot inženir strojnega učenja za gradnjo in gostovanje modelov. Izven službe rad igra tenis in kolesari po gorskih poteh.

Frank Liu je programski inženir za globoko učenje AWS. Osredotoča se na izdelavo inovativnih orodij za globoko učenje za programske inženirje in znanstvenike. V prostem času uživa na pohodništvu s prijatelji in družino.

Alan Tan je višji produktni vodja pri podjetju SageMaker, ki vodi prizadevanja za sklepanje velikih modelov. Navdušen je nad uporabo strojnega učenja na področju analitike. Izven dela uživa na prostem.

Dhawal Patel je glavni arhitekt strojnega učenja pri AWS. Sodeloval je z organizacijami, od velikih podjetij do srednje velikih zagonskih podjetij, pri problemih, povezanih s porazdeljenim računalništvom in umetno inteligenco. Osredotoča se na poglobljeno učenje, vključno s področja NLP in računalniškega vida. Strankam pomaga doseči visoko zmogljivo sklepanje o modelih na SageMakerju.

Qing Lan je inženir za razvoj programske opreme v AWS. Delal je na več zahtevnih izdelkih v Amazonu, vključno z visoko zmogljivimi rešitvami sklepanja ML in visoko zmogljivim sistemom beleženja. Qingova ekipa je uspešno lansirala prvi model z milijardami parametrov v Amazon Advertising z zelo nizko zahtevano zakasnitvijo. Qing ima poglobljeno znanje o optimizaciji infrastrukture in pospeševanju globokega učenja.

Qingwei Li je strokovnjak za strojno učenje pri Amazon Web Services. Doktoriral je v operacijskem raziskovanju, potem ko je zlomil račun svojega svetovalca za raziskovalno pomoč in mu ni uspel izročiti Nobelove nagrade, ki jo je obljubil. Trenutno strankam v finančni in zavarovalniški industriji pomaga pri izdelavi rešitev strojnega učenja na AWS. V prostem času rad bere in poučuje.

Robert Van Dusen je višji produktni vodja pri Amazon SageMaker. Vodi optimizacijo modela globokega učenja za aplikacije, kot je sklepanje velikih modelov.

Siddharth Venkatesan je programski inženir v AWS Deep Learning. Trenutno se osredotoča na gradnjo rešitev za sklepanje velikih modelov. Pred AWS je delal v organizaciji Amazon Grocery in gradil nove plačilne funkcije za stranke po vsem svetu. Izven službe uživa v smučanju, na prostem in spremlja šport.