Povečajte zmogljivost stabilne difuzije in znižajte stroške sklepanja z AWS Inferentia2 | Spletne storitve Amazon

Generativni modeli umetne inteligence so v zadnjih mesecih doživeli hitro rast zaradi svojih impresivnih zmogljivosti pri ustvarjanju realističnega besedila, slik, kode in zvoka. Med temi modeli modeli Stable Diffusion izstopajo po svoji edinstveni moči pri ustvarjanju visokokakovostnih slik na podlagi besedilnih pozivov. Stabilna difuzija lahko ustvari široko paleto visokokakovostnih slik, vključno z realističnimi portreti, pokrajinami in celo abstraktno umetnostjo. Tako kot drugi generativni modeli umetne inteligence tudi modeli stabilne difuzije zahtevajo zmogljivo računalništvo, da zagotovijo sklepanje z nizko zakasnitvijo.

V tej objavi prikazujemo, kako lahko izvajate modele stabilne difuzije in dosežete visoko zmogljivost z najnižjimi stroški v Amazonski elastični računalniški oblak (Amazon EC2) z uporabo Primerov Amazon EC2 Inf2 powered by AWS Inferentia2. Ogledamo si arhitekturo modela stabilne difuzije in se sprehodimo skozi korake sestavljanja modela stabilne difuzije z uporabo AWS nevron in njegovo uvajanje v primerek Inf2. Razpravljamo tudi o optimizacijah, ki jih Neuron SDK samodejno izvede za izboljšanje učinkovitosti. Različici Stable Diffusion 2.1 in 1.5 lahko izvajate na AWS Inferentia2 stroškovno učinkovito. Nazadnje pokažemo, kako lahko uvedete model stabilne difuzije v primerek Inf2 s Amazon SageMaker.

Velikost modela Stable Diffusion 2.1 v plavajoči vejici 32 (FP32) je 5 GB in 2.5 GB v bfoat16 (BF16). En primerek inf2.xlarge ima en pospeševalnik AWS Inferentia2 z 32 GB pomnilnika HBM. Model Stable Diffusion 2.1 se lahko prilega enemu primerku inf2.xlarge. Stable Diffusion je model pretvorbe besedila v sliko, ki ga lahko uporabite za ustvarjanje slik različnih slogov in vsebine tako, da preprosto zagotovite besedilni poziv kot vnos. Če želite izvedeti več o arhitekturi modela Stable Diffusion, glejte Ustvarite visokokakovostne slike z modeli Stable Diffusion in jih stroškovno učinkovito uvedite z Amazon SageMaker.

Kako Neuron SDK optimizira zmogljivost stabilne difuzije

Preden lahko uvedemo model Stable Diffusion 2.1 na primerkih AWS Inferentia2, moramo prevesti komponente modela z uporabo Neuron SDK. Neuron SDK, ki vključuje prevajalnik globokega učenja, čas izvajanja in orodja, prevaja in samodejno optimizira modele globokega učenja, tako da se lahko učinkovito izvajajo na primerkih Inf2 in izvlečejo polno zmogljivost pospeševalnika AWS Inferentia2. Na voljo imamo primere za model Stable Diffusion 2.1 na GitHub repo. Ta prenosni računalnik predstavlja primer od konca do konca, kako prevesti model stabilne difuzije, shraniti prevedene modele nevronov in jih naložiti v izvajalno okolje za sklepanje.

Mi uporabljamo StableDiffusionPipeline iz Objemljivega obraza diffusers knjižnico za nalaganje in prevajanje modela. Nato sestavimo vse komponente modela za uporabo Neurona torch_neuronx.trace() in shranite optimizirani model kot TorchScript. Postopki prevajanja so lahko precej pomnilniško intenzivni in zahtevajo precejšnjo količino RAM-a. Da bi se temu izognili, pred sledenjem vsakemu modelu ustvarimo a deepcopy dela cevovoda, ki ga sledimo. Po tem izbrišemo objekt cevovoda iz pomnilnika z uporabo del pipe. Ta tehnika je še posebej uporabna pri prevajanju na primerkih z malo RAM-a.

Poleg tega izvajamo tudi optimizacije modelov stabilne difuzije. UNet ima računsko najbolj intenziven vidik sklepanja. Komponenta UNet deluje na vhodnih tenzorjih, ki imajo serijsko velikost dve, pri čemer generira ustrezen izhodni tenzor prav tako s serijsko velikostjo dve, da ustvari eno samo sliko. Elementi znotraj teh sklopov so popolnoma neodvisni drug od drugega. To vedenje lahko izkoristimo, da dosežemo optimalno zakasnitev, tako da zaženemo eno serijo na vsakem jedru nevrona. UNet prevedemo za en paket (z uporabo vhodnih tenzorjev z enim paketom), nato uporabimo torch_neuronx.DataParallel API za nalaganje tega posameznega paketnega modela v vsako jedro. Izhod tega API-ja je neprekinjen dvopaketni modul: v UNet lahko posredujemo vhode dveh serij in vrne se dvopaketni izhod, toda interno se oba enopaketna modela izvajata na dveh jedrih Neuron . Ta strategija optimizira uporabo virov in zmanjša zakasnitev.

Prevedite in razmestite model Stable Diffusion na primerku Inf2 EC2

Če želite prevesti in razmestiti model Stable Diffusion na primerku Inf2 EC2, se podpišite na Konzola za upravljanje AWS in ustvarite primerek inf2.8xlarge. Upoštevajte, da je primerek inf2.8xlarge potreben le za prevajanje modela, ker prevajanje zahteva večji pomnilnik gostitelja. Model Stable Diffusion lahko gostuje na primerku inf2.xlarge. Najnovejši AMI s knjižnicami Neuron lahko najdete z naslednjim Vmesnik ukazne vrstice AWS (AWS CLI) ukaz:

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

Za ta primer smo ustvarili primerek EC2 z uporabo Deep Learning AMI Neuron PyTorch 1.13 (Ubuntu 20.04). Nato lahko ustvarite laboratorijsko okolje JupyterLab tako, da se povežete s primerkom in izvedete naslednje korake:

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

Na voljo je prenosni računalnik z vsemi koraki za sestavljanje in gostovanje modela GitHub.

Oglejmo si korake prevajanja za enega od blokov kodirnika besedila. Druge bloke, ki so del cevovoda Stable Diffusion, je mogoče sestaviti podobno.

Prvi korak je nalaganje predhodno usposobljenega modela iz Hugging Face. The StableDiffusionPipeline.from_pretrained metoda naloži predhodno usposobljen model v naš objekt cevovoda, pipe. Nato ustvarimo a deepcopy kodirnika besedila iz našega cevovoda in ga učinkovito klonira. The del pipe ukaz se nato uporabi za brisanje prvotnega objekta cevovoda, s čimer se sprosti pomnilnik, ki ga je zasedel. Tukaj kvantiziramo model na uteži BF16:

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

Ta korak vključuje ovijanje našega kodirnika besedila z NeuronTextEncoder ovoj. Izhod prevedenega modula kodirnika besedila bo dict. Pretvorimo ga v a list vnesite s tem ovojom:

text_encoder = NeuronTextEncoder(text_encoder)

Inicializiramo tenzor PyTorch emb z nekaterimi vrednostmi. The emb tenzor se uporablja kot primer vnosa za torch_neuronx.trace funkcijo. Ta funkcija sledi našemu kodirniku besedila in ga prevede v format, optimiziran za Neuron. Pot do imenika za prevedeni model je sestavljena z združevanjem COMPILER_WORKDIR_ROOT s podimenikom 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'),
        )

Prevedeni kodirnik besedila se shrani z uporabo torch.jit.save. Shranjen je pod imenom datoteke model.pt v text_encoder imenik delovnega prostora našega prevajalnika:

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

O prenosnik vključuje podobne korake za prevajanje drugih komponent modela: UNet, dekoder VAE in VAE post_quant_conv. Ko prevedete vse modele, lahko naložite in zaženete model po naslednjih korakih:

1. Določite poti za prevedene modele.
2. Naložite predhodno usposobljeno StableDiffusionPipeline model, s konfiguracijo, določeno za uporabo podatkovnega tipa bfloat16.
3. Naložite model UNet na dve jedri Neuron z uporabo torch_neuronx.DataParallel API. To omogoča izvajanje vzporednega sklepanja podatkov, kar lahko znatno pospeši delovanje modela.
4. Naložite preostale dele modela (text_encoder, decoderin post_quant_conv) na eno samo nevronsko jedro.

Nato lahko zaženete cevovod tako, da vnesete vhodno besedilo kot pozive. Sledi nekaj slik, ki jih je ustvaril model za pozive:

• Portret renauda sechana, pero in črnilo, zapletene črtne risbe, avtorji craig mullins, ruan jia, kentaro miura, greg rutkowski, loundraw

• Portret starega premogovnika v 19. stoletju, čudovita slika z zelo podrobno poslikavo obraza Grega Rutkowskega

• Grad sredi gozda

Gostovanje Stable Diffusion 2.1 na AWS Inferentia2 in SageMaker

Gostovanje modelov Stable Diffusion s SageMaker zahteva tudi kompilacijo z Neuron SDK. Prevajanje lahko dokončate pred časom ali med izvajanjem z uporabo vsebnikov Large Model Inference (LMI). Prevajanje pred časom omogoča hitrejše nalaganje modela in je prednostna možnost.

Vsebniki SageMaker LMI ponujajo dva načina za namestitev modela:

• Možnost brez kode, kjer samo zagotovimo a serving.properties datoteko z zahtevanimi konfiguracijami
• S seboj prinesite svoj sklepni scenarij

Ogledamo si obe rešitvi in ​​pregledamo konfiguracije in sklepni skript (model.py). V tej objavi prikazujemo uvajanje z uporabo vnaprej prevedenega modela, shranjenega v Preprosta storitev shranjevanja Amazon (Amazon S3) vedro. Ta vnaprej prevedeni model lahko uporabite za svoje uvedbe.

Konfigurirajte model s priloženim skriptom

V tem razdelku pokažemo, kako konfigurirati vsebnik LMI za gostovanje modelov stabilne difuzije. Prenosnik SD2.1, ki je na voljo na GitHub. Prvi korak je ustvariti konfiguracijski paket modela glede na naslednjo strukturo imenika. Naš cilj je uporabiti minimalne konfiguracije modela, potrebne za gostovanje modela. Potrebna struktura imenika je naslednja:

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

Nato ustvarimo serviranje.lastnosti datoteka z naslednjimi parametri:

%%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

Parametri določajo naslednje:

• option.model_id – Vsebniki LMI uporabljajo s5cmd za nalaganje modela z lokacije S3, zato moramo določiti lokacijo, kjer so naše prevedene uteži.
• option.entryPoint – Za uporabo vgrajenih upravljavcev določimo razred transformers-neuronx. Če imate skript sklepanja po meri, ga morate zagotoviti namesto tega.
• option.dtype – To določa nalaganje uteži v določeni velikosti. Za to objavo uporabljamo BF16, ki dodatno zmanjša naše pomnilniške zahteve v primerjavi s FP32 in zaradi tega zmanjša našo zakasnitev.
• možnost.tensor_parallel_degree – Ta parameter določa število pospeševalnikov, ki jih uporabljamo za ta model. Čipni pospeševalnik AWS Inferentia2 ima dve jedri Neuron, zato določitev vrednosti 2 pomeni, da uporabljamo en pospeševalnik (dve jedri). To pomeni, da lahko zdaj ustvarimo več delavcev, da povečamo prepustnost končne točke.
• možnost.motor – To je nastavljeno na Python, kar pomeni, da za to gostovanje ne bomo uporabljali drugih prevajalnikov, kot sta DeepSpeed ​​ali Faster Transformer.

Prinesite svoj scenarij

Če želite prinesti lasten skript sklepanja po meri, morate odstraniti option.entryPoint iz serving.properties. Vsebnik LMI bo v tem primeru iskal a model.py datoteko na istem mestu kot serving.properties in to uporabite za izvajanje sklepanja.

Ustvarite lasten sklepni skript (model.py)

Ustvarjanje lastnega sklepnega skripta je razmeroma preprosto z uporabo vsebnika LMI. Posoda zahteva vašo model.py datoteka, da ima implementacijo naslednje metode:

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

Oglejmo si nekaj kritičnih področij priložen zvezek, ki prikazuje funkcijo prinašanja lastnega skripta.

Zamenjajte cross_attention modul z optimizirano različico:

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

To so imena prevedenih datotek z utežmi, ki smo jih uporabili pri ustvarjanju kompilacij. Imena datotek lahko spremenite, vendar se prepričajte, da se imena datotek z utežmi ujemajo s tem, kar ste tukaj navedli.

Nato jih moramo naložiti s pomočjo Neuron SDK in jih nastaviti v dejanskih utežeh modela. Pri nalaganju uteži, optimiziranih za UNet, upoštevajte, da določamo tudi število nevronskih jeder, na katera jih moramo naložiti. Tukaj naložimo en sam pospeševalnik z dvema jedroma:

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

Izvajanje sklepanja s pozivom prikliče predmet cevi za ustvarjanje slike.

Ustvarite končno točko SageMaker

Za ustvarjanje končne točke SageMaker uporabljamo API-je Boto3. Izvedite naslednje korake:

1. Ustvarite arhiv samo s serviranjem in neobveznim model.py datoteke in jih naložite v Amazon S3.
2. Ustvarite model z uporabo vsebnika slik in prej naloženega arhiva modela.
3. Ustvarite konfiguracijo končne točke z uporabo naslednjih ključnih parametrov:
   1. Uporabite ml.inf2.xlarge na primer.
   2. Kompleti ContainerStartupHealthCheckTimeoutInSeconds do 240, da zagotovite, da se zdravstveni pregled začne po uvedbi modela.
   3. Kompleti VolumeInGB na večjo vrednost, tako da se lahko uporabi za nalaganje uteži modela, ki so velike 32 GB.

Ustvarite model SageMaker

Ko ustvarite datoteko model.tar.gz in jo naložite v Amazon S3, moramo ustvariti model SageMaker. Za izdelavo modela SageMaker uporabimo vsebnik LMI in artefakt modela iz prejšnjega koraka. SageMaker nam omogoča prilagajanje in vstavljanje različnih spremenljivk okolja. Za ta potek dela lahko vse pustimo privzeto. Oglejte si naslednjo kodo:

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

Ustvarite objekt modela, ki v bistvu ustvari vsebnik za zaklepanje, ki se naloži v primerek in se uporablja za sklepanje:

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

Ustvarite končno točko SageMaker

V tej predstavitvi uporabljamo primerek ml.inf2.xlarge. Nastaviti moramo VolumeSizeInGB parametrov za zagotovitev potrebnega prostora na disku za nalaganje modela in uteži. Ta parameter se uporablja za primerke, ki podpirajo Trgovina z elastičnimi bloki Amazon (Amazon EBS) nastavek za volumen. Časovno omejitev prenosa modela in preverjanje stanja zagona vsebnika lahko pustimo na višji vrednosti, kar bo vsebniku dalo dovolj časa, da potegne uteži iz Amazon S3 in naloži v pospeševalnike AWS Inferentia2. Za več podrobnosti glejte UstvariEndpointConfig.

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

Nazadnje ustvarimo končno točko SageMaker:

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

Prikličite končno točko modela

To je generativni model, zato posredujemo poziv, ki ga model uporablja za ustvarjanje slike. Tovor je vrste JSON:

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

Primerjava modela stabilne difuzije na Inf2

Izvedli smo nekaj testov za primerjavo modela Stable Diffusion s podatkovnim tipom BF 16 na Inf2 in lahko izpeljemo številke zakasnitve, ki tekmujejo ali presegajo nekatere druge pospeševalnike za Stable Diffusion. Zaradi tega, skupaj z nižjimi stroški čipov AWS Inferentia2, je to izjemno dragocena ponudba.

Naslednje številke so iz modela stabilne difuzije, ki je nameščen na primerku inf2.xl. Za več informacij o stroških glejte Primerki Amazon EC2 Inf2.

zaključek

V tej objavi smo se poglobili v kompilacijo, optimizacijo in uvajanje modela Stable Diffusion 2.1 z uporabo primerkov Inf2. Prikazali smo tudi uvajanje modelov Stable Diffusion z uporabo SageMakerja. Primerki Inf2 zagotavljajo tudi odlično cenovno zmogljivost za Stable Diffusion 1.5. Če želite izvedeti več o tem, zakaj so primerki Inf2 odlični za generativne AI in velike jezikovne modele, glejte Primerki Amazon EC2 Inf2 za nizkocenovne in visoko zmogljive generativne sklepe z umetno inteligenco so zdaj splošno na voljo. Za podrobnosti o delovanju glejte Zmogljivost Inf2. Oglejte si dodatne primere na GitHub repo.

Posebna zahvala Matthewu Mcclainu, Beni Hegedusu, Kamranu Khanu, Shrutiju Koparkarju in Qing Lanu za pregled in zagotavljanje dragocenih prispevkov.

O avtorjih

Vivek Gangasani je višji arhitekt rešitev za strojno učenje pri Amazon Web Services. Sodeluje z zagonskimi podjetji strojnega učenja pri gradnji in uvajanju aplikacij AI/ML na AWS. Trenutno je osredotočen na zagotavljanje rešitev za MLOps, sklepanje ML in ML z nizko kodo. Delal je na projektih na različnih področjih, vključno z obdelavo naravnega jezika in računalniškim vidom.

KC Tung je višji arhitekt rešitev v AWS Annapurna Labs. Specializiran je za usposabljanje in uvajanje velikih modelov globokega učenja v oblaku. Ima doktorat znanosti. doktor molekularne biofizike iz Southwestern medicinskega centra Univerze v Teksasu v Dallasu. Govoril je na AWS Summits in AWS Reinvent. Danes strankam pomaga pri usposabljanju in uvajanju velikih modelov PyTorch in TensorFlow v oblaku AWS. Je avtor dveh knjig: Spoznajte TensorFlow Enterprise in TensorFlow 2 Pocket Reference.

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.

• Distribucija vsebine in PR s pomočjo SEO. Okrepite se še danes.
• PlatoData.Network Vertical Generative Ai. Opolnomočite se. Dostopite tukaj.
• PlatoAiStream. Web3 Intelligence. Razširjeno znanje. Dostopite tukaj.
• PlatoESG. Avtomobili/EV, Ogljik, CleanTech, Energija, Okolje, sončna energija, Ravnanje z odpadki. Dostopite tukaj.
• BlockOffsets. Posodobitev okoljskega offset lastništva. Dostopite tukaj.
• vir: https://aws.amazon.com/blogs/machine-learning/maximize-stable-diffusion-performance-and-lower-inference-costs-with-aws-inferentia2/