Maksimeerige stabiilse difusiooni jõudlust ja vähendage järelduskulusid AWS Inferentia2 | abil Amazoni veebiteenused

Generatiivsed AI mudelid on viimastel kuudel kiiresti kasvanud tänu nende muljetavaldavatele võimalustele luua realistlikku teksti, pilte, koodi ja heli. Nende mudelite hulgas paistavad Stable Diffusion mudelid silma oma ainulaadse tugevuse poolest tekstiviipade põhjal kvaliteetsete piltide loomisel. Stabiilne difusioon võib luua mitmesuguseid kvaliteetseid pilte, sealhulgas realistlikke portreesid, maastikke ja isegi abstraktset kunsti. Ja nagu teised generatiivsed AI mudelid, vajavad stabiilse hajutamise mudelid madala latentsusajaga järelduste tegemiseks võimsat andmetöötlust.

Selles postituses näitame, kuidas saate kasutada stabiilse difusiooni mudeleid ja saavutada kõrge jõudluse madalaima kuluga Amazon Elastic Compute Cloud (Amazon EC2) kasutades Amazon EC2 Inf2 eksemplarid powered by AWS Inferentia2. Vaatame stabiilse difusiooni mudeli arhitektuuri ja käime läbi stabiilse difusiooni mudeli koostamise etapid, kasutades AWS Neuron ja juurutades selle Inf2 eksemplari. Arutame ka optimeerimisi, mida Neuron SDK toimivuse parandamiseks automaatselt teeb. Saate AWS Inferentia2.1 kulutõhusalt käitada nii Stable Diffusion 1.5 kui ka 2 versioone. Lõpuks näitame, kuidas saate stabiilse hajutuse mudeli juurutada Inf2 eksemplarile Amazon SageMaker.

Stable Diffusion 2.1 mudeli suurus ujukomaga 32 (FP32) on 5 GB ja bfoat2.5 (BF16) 16 GB. Ühel inf2.xlarge eksemplaril on üks AWS Inferentia2 kiirendi koos 32 GB HBM-mäluga. Stable Diffusion 2.1 mudel mahub ühele inf2.xlarge eksemplarile. Stabiilne hajutamine on tekst-pildiks mudel, mida saate kasutada erineva stiili ja sisuga piltide loomiseks, pakkudes sisendiks lihtsalt tekstiviipa. Stabiilse difusiooni mudeli arhitektuuri kohta lisateabe saamiseks vaadake Looge stabiilse difusiooni mudelitega kvaliteetseid pilte ja juurutage need kuluefektiivselt Amazon SageMakeriga.

Kuidas Neuron SDK optimeerib stabiilse difusiooni jõudlust

Enne kui saame mudeli Stable Diffusion 2.1 juurutada AWS Inferentia2 eksemplaridel, peame kompileerima mudeli komponendid, kasutades Neuron SDK. Neuron SDK, mis sisaldab süvaõppekompilaatorit, käitusaega ja tööriistu, kompileerib ja optimeerib automaatselt süvaõppe mudeleid, et need saaksid tõhusalt töötada Inf2 eksemplaridel ja eraldada AWS Inferentia2 kiirendi täielikku jõudlust. Meil on saadaval näited Stable Diffusion 2.1 mudeli kohta GitHub repo. See märkmik esitab täieliku näite, kuidas koostada stabiilse difusiooni mudelit, salvestada kompileeritud Neuroni mudelid ja laadida see käitusaega järelduste tegemiseks.

Me kasutame StableDiffusionPipeline Kallistavast Näost diffusers teek mudeli laadimiseks ja kompileerimiseks. Seejärel koostame Neuroni jaoks kõik mudeli komponendid torch_neuronx.trace() ja salvestage optimeeritud mudel TorchScriptina. Kompileerimisprotsessid võivad olla üsna mälumahukad, nõudes märkimisväärsel hulgal RAM-i. Sellest kõrvalehoidmiseks loome enne iga mudeli jälgimist a deepcopy torujuhtme selle osa kohta, mida jälgitakse. Pärast seda kustutame konveieri objekti mälust kasutades del pipe. See tehnika on eriti kasulik väikese RAM-iga eksemplaride kompileerimisel.

Lisaks teostame ka stabiilse difusiooni mudelite optimeerimisi. UNet sisaldab järelduse kõige arvutusmahukamat aspekti. UNeti komponent töötab sisendtensoritel, mille partii suurus on kaks, genereerides ühe kujutise saamiseks vastava väljundtensori, mille partii suurus on kaks. Nende partiide elemendid on üksteisest täiesti sõltumatud. Saame seda käitumist ära kasutada, et saavutada optimaalne latentsusaeg, käivitades ühe partii igal neuroni tuumal. Koostame UNeti ühe partii jaoks (kasutades ühe partiiga sisendtensoreid), seejärel kasutame torch_neuronx.DataParallel API selle ühe partiimudeli igasse tuuma laadimiseks. Selle API väljund on sujuv kahe partii moodul: saame edastada UNetile kahe partii sisendid ja tagastatakse kahe partii väljund, kuid sisemiselt töötavad kaks ühe partii mudelit kahel Neuroni tuumal. . See strateegia optimeerib ressursside kasutamist ja vähendab latentsust.

Kompileerige ja juurutage stabiilse difusiooni mudel Inf2 EC2 eksemplaris

Stabiilse difusiooni mudeli kompileerimiseks ja juurutamiseks Inf2 EC2 eksemplaris logige sisse AWS-i juhtimiskonsool ja looge inf2.8xlarge eksemplar. Pange tähele, et inf2.8xlarge eksemplari on vaja ainult mudeli koostamiseks, kuna kompileerimine nõuab suuremat hostimälu. Stabiilse difusiooni mudelit saab majutada eksemplaris inf2.xlarge. Uusima AMI koos Neuron raamatukogudega leiate järgmiselt AWS-i käsurea liides (AWS CLI) käsk:

aws ec2 describe-images --region us-east-1 --owners amazon --filters 'Name=name,Values=Deep Learning AMI Neuron PyTorch 1.13.? (Amazon Linux 2) ????????' 'Name=state,Values=available' --query 'reverse(sort_by(Images, &CreationDate))[:1].ImageId' --output text

Selle näite jaoks lõime EC2 eksemplari, kasutades Deep Learning AMI Neuron PyTorch 1.13 (Ubuntu 20.04). Seejärel saate luua JupyterLabi laborikeskkonna, luues ühenduse eksemplariga ja käivitades järgmised toimingud.

run source /opt/aws_neuron_venv_pytorch/bin/activate
pip install jupyterlab
jupyter-lab

Sülearvuti, millel on kõik mudeli koostamise ja majutamise sammud, asub GitHub.

Vaatame ühe tekstikodeerija ploki koostamise etappe. Sarnaselt saab koostada ka teisi plokke, mis on osa stabiilse difusiooni torujuhtmest.

Esimene samm on Hugging Face'i eelkoolitatud modelli laadimine. The StableDiffusionPipeline.from_pretrained meetod laadib eelkoolitatud mudeli meie konveieriobjekti, pipe. Seejärel loome a deepcopy meie torujuhtme tekstikooderist, kloonides selle tõhusalt. The del pipe Seejärel kasutatakse käsku algse konveieriobjekti kustutamiseks, vabastades selle tarbitud mälu. Siin kvantifitseerime mudeli BF16 kaaludele:

model_id = "stabilityai/stable-diffusion-2-1-base"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.bfloat16)
text_encoder = copy.deepcopy(pipe.text_encoder)
del pipe

See samm hõlmab meie tekstikodeerija mähkimist NeuronTextEncoder ümbris. Kompileeritud tekstikodeerija mooduli väljund on dict. Teisendame selle a list tippige selle ümbrise abil:

text_encoder = NeuronTextEncoder(text_encoder)

Initsialiseerime PyTorchi tensori emb teatud väärtustega. The emb tensorit kasutatakse näidissisendina torch_neuronx.trace funktsiooni. See funktsioon jälgib meie tekstikodeerijat ja kompileerib selle Neuroni jaoks optimeeritud vormingusse. Kompileeritud mudeli kataloogitee konstrueeritakse ühendamise teel COMPILER_WORKDIR_ROOT alamkataloogiga text_encoder:

emb = torch.tensor([...])
text_encoder_neuron = torch_neuronx.trace(
        text_encoder.neuron_text_encoder,
        emb,
        compiler_workdir=os.path.join(COMPILER_WORKDIR_ROOT, 'text_encoder'),
        )

Koostatud tekstikooder salvestatakse kasutades torch.jit.save. See on salvestatud failinime model.pt all text_encoder meie kompilaatori tööruumi kataloog:

text_encoder_filename = os.path.join(COMPILER_WORKDIR_ROOT, 'text_encoder/model.pt')
torch.jit.save(text_encoder_neuron, text_encoder_filename)

. märkmik sisaldab sarnaseid samme mudeli muude komponentide koostamiseks: UNet, VAE dekooder ja VAE post_quant_conv. Kui olete kõik mudelid koostanud, saate mudeli laadida ja käivitada järgmiselt.

1. Määrake koostatud mudelite teed.
2. Laadige eelkoolitatud StableDiffusionPipeline mudel, mille konfiguratsioon on määratud kasutama andmetüüpi bfloat16.
3. Laadige UNeti mudel kahele Neuroni tuumale, kasutades torch_neuronx.DataParallel API. See võimaldab teha andmete paralleelset järeldust, mis võib mudeli jõudlust oluliselt kiirendada.
4. Laadige mudeli ülejäänud osad (text_encoder, decoderja post_quant_conv) ühele neuroni tuumale.

Seejärel saate konveieri käivitada, esitades viipadena sisendteksti. Siin on mõned mudeli poolt viipade jaoks loodud pildid:

• Renaud Sechani portree, pliiats ja tint, keerulised joonjoonised, autor Craig Mullins, Ruan Jia, Kentaro Miura, greg Rutkowski, loundraw

• Vana söekaevuri portree 19. sajandil, ilus maal, greg rutkowski väga detailse näomaalinguga

• Loss keset metsa

Host Stable Diffusion 2.1 AWS Inferentia2 ja SageMakeris

Stabiilse difusiooni mudelite hostimine koos SageMakeriga nõuab ka kompileerimist Neuron SDK-ga. Saate kompileerimise lõpule viia enne tähtaega või käitusajal, kasutades suure mudeli järelduse (LMI) konteinereid. Varasem koostamine võimaldab kiirendada mudeli laadimisaega ja on eelistatud valik.

SageMaker LMI konteinerid pakuvad mudeli juurutamiseks kahte võimalust:

• Koodivaba valik, kus pakume lihtsalt a serving.properties vajalike konfiguratsioonidega fail
• Tooge oma järeldusskript

Vaatame mõlemat lahendust ja vaatame üle konfiguratsioonid ja järeldusskripti (model.py). Selles postituses demonstreerime juurutamist, kasutades eelnevalt kompileeritud mudelit, mis on salvestatud an Amazoni lihtne salvestusteenus (Amazon S3) kopp. Saate seda eelkompileeritud mudelit kasutada oma juurutuste jaoks.

Seadistage mudel kaasasoleva skriptiga

Selles jaotises näitame, kuidas konfigureerida LMI konteinerit stabiilse difusiooni mudelite majutamiseks. SD2.1 sülearvuti on saadaval aadressil GitHub. Esimene samm on mudeli konfiguratsioonipaketi loomine järgmise kataloogistruktuuri järgi. Meie eesmärk on kasutada mudeli hostimiseks vajalikke minimaalseid mudelikonfiguratsioone. Vajalik kataloogistruktuur on järgmine:

<config-root-directory> / 
    ├── serving.properties
    │   
    └── model.py [OPTIONAL]

Järgmisena loome serveerimine.omadused fail järgmiste parameetritega:

%%writefile code_sd/serving.properties
engine=Python
option.entryPoint=djl_python.transformers-neuronx
option.use_stable_diffusion=True
option.model_id=s3url
option.tensor_parallel_degree=2
option.dtype=bf16

Parameetrid täpsustavad järgmist:

• option.model_id – LMI konteinerid kasutavad mudeli laadimiseks S5 asukohast s3cmd ja seetõttu peame täpsustama asukoha, kus meie koostatud kaalud asuvad.
• option.entryPoint – Sisseehitatud käitlejate kasutamiseks määrame klassi trafod-neuronx. Kui teil on kohandatud järeldusskript, peate selle asemel esitama.
• option.dtype – See määrab raskuste laadimise kindlas suuruses. Selle postituse jaoks kasutame BF16, mis vähendab veelgi meie mäluvajadust võrreldes FP32-ga ja vähendab seetõttu meie latentsust.
• option.tensor_parallel_degree – See parameeter määrab selle mudeli jaoks kasutatavate kiirendite arvu. AWS Inferentia2 kiibikiirendil on kaks Neuroni südamikku ja seega tähendab väärtuse 2 määramine, et kasutame ühte kiirendit (kaks südamikku). See tähendab, et saame nüüd luua mitu töötajat, et suurendada lõpp-punkti läbilaskevõimet.
• variant.mootor - See on seatud Pythonile, mis näitab, et me ei kasuta selle hostimise jaoks muid kompilaatoreid, nagu DeepSpeed ​​või Faster Transformer.

Tooge oma stsenaarium

Kui soovite tuua oma kohandatud järeldusskripti, peate eemaldama skripti option.entryPoint Alates serving.properties. Sel juhul otsib LMI konteiner a model.py fail samas kohas, kus serving.properties ja kasutage seda järelduste tegemiseks.

Looge oma järeldusskript (model.py)

Oma järeldusskripti loomine on LMI konteineri abil suhteliselt lihtne. Konteiner nõuab teie model.py failil on järgmise meetodi rakendamine:

def handle(inputs: Input) which returns an object of type Outputs

Uurime mõnda kriitilist valdkonda lisatud märkmik, mis näitab oma skripti funktsiooni toomist.

Vahetage cross_attention optimeeritud versiooniga moodul:

# Replace original cross-attention module with custom cross-attention module for better performance
    CrossAttention.get_attention_scores = get_attention_scores
Load the compiled weights for the following
text_encoder_filename = os.path.join(COMPILER_WORKDIR_ROOT, 'text_encoder.pt')
decoder_filename = os.path.join(COMPILER_WORKDIR_ROOT, 'vae_decoder.pt')
unet_filename = os.path.join(COMPILER_WORKDIR_ROOT, 'unet.pt')
post_quant_conv_filename =. os.path.join(COMPILER_WORKDIR_ROOT, 'vae_post_quant_conv.pt')

Need on koostatud kaalufailide nimed, mida kasutasime kompilatsioonide loomisel. Muutke failinimesid, kuid veenduge, et teie kaalufailide nimed vastaksid siin määratule.

Seejärel peame need laadima Neuron SDK abil ja määrama need tegelikesse mudelikaaludesse. UNeti optimeeritud kaalude laadimisel pange tähele, et täpsustame ka neuronite tuumade arvu, millele peame need laadima. Siin laadime ühele kahe südamikuga kiirendile:

# Load the compiled UNet onto two neuron cores.
    pipe.unet = NeuronUNet(UNetWrap(pipe.unet))
    logging.info(f"Loading model: unet:created")
    device_ids = [idx for idx in range(tensor_parallel_degree)]
   
    pipe.unet.unetwrap = torch_neuronx.DataParallel(torch.jit.load(unet_filename), device_ids, set_dynamic_batching=False)
   
 
    # Load other compiled models onto a single neuron core.
 
    # - load encoders
    pipe.text_encoder = NeuronTextEncoder(pipe.text_encoder)
    clip_compiled = torch.jit.load(text_encoder_filename)
    pipe.text_encoder.neuron_text_encoder = clip_compiled
    #- load decoders
    pipe.vae.decoder = torch.jit.load(decoder_filename)
    pipe.vae.post_quant_conv = torch.jit.load(post_quant_conv_filename)

Järelduse käivitamine viipaga kutsub esile toruobjekti kujutise genereerimiseks.

Looge SageMakeri lõpp-punkt

Kasutame SageMakeri lõpp-punkti loomiseks Boto3 API-sid. Tehke järgmised sammud.

1. Looge tarball, kasutades ainult serveerimist ja valikulist model.py failid ja laadige see Amazon S3-sse.
2. Looge mudel, kasutades varem üles laaditud pildikonteinerit ja mudeli tarballi.
3. Looge lõpp-punkti konfiguratsioon järgmiste võtmeparameetrite abil:
   1. Kasutage a ml.inf2.xlarge Näiteks
   2. komplekt ContainerStartupHealthCheckTimeoutInSeconds 240-ni, et tagada tervisekontrolli alustamine pärast mudeli kasutuselevõttu.
   3. komplekt VolumeInGB suuremale väärtusele, et seda saaks kasutada 32 GB suuruste mudelikaalude laadimiseks.

Looge SageMakeri mudel

Pärast faili model.tar.gz loomist ja selle Amazon S3 üleslaadimist peame looma SageMakeri mudeli. SageMakeri mudeli loomiseks kasutame eelmises etapis LMI konteinerit ja mudeli artefakti. SageMaker võimaldab meil kohandada ja sisestada erinevaid keskkonnamuutujaid. Selle töövoo jaoks võime kõik vaikimisi jätta. Vaadake järgmist koodi:

inference_image_uri = (
    f"763104351884.dkr.ecr.{region}.amazonaws.com/djl-inference:0 djl-serving-inf2"
)

Looge mudelobjekt, mis sisuliselt loob lukustuskonteineri, mis laaditakse eksemplari ja mida kasutatakse järelduste tegemiseks:

model_name = name_from_base(f"inf2-sd")
create_model_response = boto3_sm_client.create_model(
    ModelName=model_name,
    ExecutionRoleArn=role,
    PrimaryContainer={"Image": inference_image_uri, "ModelDataUrl": s3_code_artifact},
)

Looge SageMakeri lõpp-punkt

Selles demos kasutame eksemplari ml.inf2.xlarge. Peame määrama VolumeSizeInGB parameetrid, et tagada mudeli ja kaalude laadimiseks vajalik kettaruum. See parameeter kehtib eksemplaride puhul, mis toetavad Amazoni elastsete plokkide pood (Amazon EBS) helitugevuse kinnitus. Võime jätta mudeli allalaadimise ajalõpu ja konteineri käivitamise tervisekontrolli kõrgemale väärtusele, mis annab konteinerile piisavalt aega Amazon S3 raskuste tõmbamiseks ja AWS Inferentia2 kiirenditesse laadimiseks. Lisateabe saamiseks vaadake Loo EndpointConfig.

endpoint_config_response = boto3_sm_client.create_endpoint_config( EndpointConfigName=endpoint_config_name,
    ProductionVariants=[
        {
            "VariantName": "variant1",
            "ModelName": model_name,
            "InstanceType": "ml.inf2.xlarge", # - 
            "InitialInstanceCount": 1,
            "ContainerStartupHealthCheckTimeoutInSeconds": 360, 
            "VolumeSizeInGB": 400
        },
    ],
)

Lõpuks loome SageMakeri lõpp-punkti:

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

Kutsuge mudeli lõpp-punkt

See on generatiivne mudel, seega edastame viipa, mida mudel pildi genereerimiseks kasutab. Kasulik koormus on JSON tüüpi:

response_model = boto3_sm_run_client.invoke_endpoint( EndpointName=endpoint_name,
    Body=json.dumps(
        {
            "prompt": "Mountain Landscape", 
            "parameters": {} # 
        }
    ), 
    ContentType="application/json",
)

Stabiilse difusiooni mudeli võrdlusuuringud saidil Inf2

Tegime mõned testid, et võrrelda stabiilse difusiooni mudelit BF 16 andmetüübiga Inf2-s, ja suudame tuletada latentsusarvud, mis konkureerivad mõne muu stabiilse difusiooni kiirendiga või ületavad neid. See koos AWS Inferentia2 kiipide madalama hinnaga muudab selle äärmiselt väärtuslikuks ettepanekuks.

Järgmised numbrid pärinevad inf2.xl eksemplaril juurutatud mudelist Stable Diffusion. Kulude kohta lisateabe saamiseks vaadake Amazon EC2 Inf2 eksemplarid.

Järeldus

Selles postituses uurime põhjalikult Stable Diffusion 2.1 mudeli koostamist, optimeerimist ja juurutamist, kasutades Inf2 eksemplare. Samuti demonstreerisime SageMakeri abil stabiilse difusiooni mudelite juurutamist. Inf2 eksemplarid pakuvad ka Stable Diffusion 1.5 jaoks suurepärast hinnajõudlust. Lisateavet selle kohta, miks Inf2 eksemplarid on generatiivsete AI ja suurte keelemudelite jaoks suurepärased, vaadake artiklit Amazon EC2 Inf2 eksemplarid odavate ja suure jõudlusega generatiivse AI järelduse jaoks on nüüd üldiselt saadaval. Toimivuse üksikasjade kohta vt Inf2 jõudlus. Vaadake täiendavaid näiteid saidil GitHub repo.

Eriline tänu Matthew Mclainile, Beni Hegedusele, Kamran Khanile, Shruti Koparkarile ja Qing Lanile väärtuslike sisendite ülevaatamise ja andmise eest.

Autoritest

Vivek Gangasani on Amazon Web Services'i masinõppelahenduste vanemarhitekt. Ta töötab masinõppe idufirmadega, et luua ja juurutada AI/ML-i rakendusi AWS-is. Praegu on ta keskendunud MLO-de, ML-i järelduste ja madala koodiga ML-i lahenduste pakkumisele. Ta on töötanud projektidega erinevates valdkondades, sealhulgas loomuliku keele töötlemise ja arvutinägemise valdkonnas.

KC Tung on AWS Annapurna Labsi vanemlahenduse arhitekt. Ta on spetsialiseerunud suurte süvaõppemudelite väljaõppele ja pilves laialdasele kasutuselevõtule. Tal on Ph.D. molekulaarbiofüüsikas Texase ülikooli Southwesterni meditsiinikeskusest Dallases. Ta on esinenud AWS Summits ja AWS Reinvent. Täna aitab ta klientidel koolitada ja juurutada suuri PyTorchi ja TensorFlow mudeleid AWS-i pilves. Ta on kahe raamatu autor: Õppige TensorFlow Enterprise'i ja TensorFlow 2 taskuviide.

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.

• SEO-põhise sisu ja PR-levi. Võimenduge juba täna.
• PlatoData.Network Vertikaalne generatiivne Ai. Jõustage ennast. Juurdepääs siia.
• PlatoAiStream. Web3 luure. Täiustatud teadmised. Juurdepääs siia.
• PlatoESG. Autod/elektrisõidukid, Süsinik, CleanTech, Energia, Keskkond päikeseenergia, Jäätmekäitluse. Juurdepääs siia.
• BlockOffsets. Keskkonnakompensatsiooni omandi ajakohastamine. Juurdepääs siia.
• Allikas: https://aws.amazon.com/blogs/machine-learning/maximize-stable-diffusion-performance-and-lower-inference-costs-with-aws-inferentia2/