Maximaliseer de prestaties van Stable Diffusion en verlaag de inferentiekosten met AWS Inferentia2 | Amazon-webservices

Generatieve AI-modellen hebben de afgelopen maanden een snelle groei doorgemaakt vanwege de indrukwekkende mogelijkheden voor het creëren van realistische tekst, afbeeldingen, code en audio. Van deze modellen vallen de Stable Diffusion-modellen op vanwege hun unieke kracht bij het creëren van afbeeldingen van hoge kwaliteit op basis van tekstaanwijzingen. Stabiele diffusie kan een grote verscheidenheid aan afbeeldingen van hoge kwaliteit genereren, waaronder realistische portretten, landschappen en zelfs abstracte kunst. En net als andere generatieve AI-modellen vereisen Stable Diffusion-modellen krachtige rekenkracht om gevolgtrekkingen met lage latentie te kunnen maken.

In dit bericht laten we zien hoe u Stable Diffusion-modellen kunt gebruiken en hoge prestaties kunt bereiken tegen de laagste kosten Amazon Elastic Compute-cloud (Amazon EC2) gebruikt Amazon EC2 Inf2-instanties Mogelijk gemaakt door AWS Inferentie2. We bekijken de architectuur van een stabiel diffusiemodel en doorlopen de stappen voor het samenstellen van een stabiel diffusiemodel met behulp van AWS-neuron en het implementeren ervan op een Inf2-instantie. Ook bespreken we de optimalisaties die de Neuron SDK automatisch doorvoert om de prestaties te verbeteren. U kunt zowel Stable Diffusion 2.1 als 1.5 versies op AWS Inferentia2 kosteneffectief uitvoeren. Ten slotte laten we zien hoe u een Stable Diffusion-model kunt implementeren op een Inf2-instantie met Amazon Sage Maker.

De Stable Diffusion 2.1-modelgrootte in floating point 32 (FP32) is 5 GB en 2.5 GB in bfoat16 (BF16). Eén enkele inf2.xlarge-instantie heeft één AWS Inferentia2-accelerator met 32 ​​GB HBM-geheugen. Het Stable Diffusion 2.1-model past op een enkele inf2.xlarge-instantie. Stable Diffusion is een tekst-naar-afbeelding-model dat u kunt gebruiken om afbeeldingen met verschillende stijlen en inhoud te maken door simpelweg een tekstprompt als invoer op te geven. Voor meer informatie over de architectuur van het Stable Diffusion-model raadpleegt u Creëer afbeeldingen van hoge kwaliteit met Stable Diffusion-modellen en implementeer ze kostenefficiënt met Amazon SageMaker.

Hoe de Neuron SDK de prestaties van stabiele diffusie optimaliseert

Voordat we het Stable Diffusion 2.1-model op AWS Inferentia2-instanties kunnen implementeren, moeten we de modelcomponenten compileren met behulp van de Neuron-SDK. De Neuron SDK, die een deep learning-compiler, runtime en tools bevat, compileert en optimaliseert automatisch deep learning-modellen, zodat ze efficiënt kunnen draaien op Inf2-instanties en de volledige prestaties van de AWS Inferentia2-accelerator kunnen extraheren. We hebben voorbeelden beschikbaar voor het Stable Diffusion 2.1-model op de GitHub repo. Dit notebook biedt een end-to-end voorbeeld van hoe u een Stable Diffusion-model compileert, de gecompileerde Neuron-modellen opslaat en deze in de runtime laadt voor gevolgtrekking.

Wij gebruiken StableDiffusionPipeline van het knuffelgezicht diffusers bibliotheek om het model te laden en te compileren. Vervolgens compileren we alle componenten van het model voor Neuron torch_neuronx.trace() en sla het geoptimaliseerde model op als TorchScript. Compilatieprocessen kunnen behoorlijk geheugenintensief zijn en vereisen een aanzienlijke hoeveelheid RAM. Om dit te omzeilen, maken we, voordat we elk model traceren, een deepcopy van het deel van de pijpleiding dat wordt getraceerd. Hierna verwijderen we het pijplijnobject uit het geheugen met behulp van del pipe. Deze techniek is vooral handig bij het compileren op instances met weinig RAM.

Daarnaast voeren we ook optimalisaties uit op de Stable Diffusion-modellen. UNet bevat het meest rekenintensieve aspect van de gevolgtrekking. De UNet-component werkt op invoertensors met een batchgrootte van twee, en genereert een overeenkomstige uitvoertensor, ook met een batchgrootte van twee, om een ​​enkel beeld te produceren. De elementen binnen deze batches zijn geheel onafhankelijk van elkaar. We kunnen van dit gedrag profiteren om een ​​optimale latentie te verkrijgen door één batch op elke Neuron-kern uit te voeren. We compileren het UNet voor één batch (door invoertensoren te gebruiken met één batch) en gebruiken vervolgens de torch_neuronx.DataParallel API om dit enkele batchmodel op elke kern te laden. De uitvoer van deze API is een naadloze module met twee batches: we kunnen de invoer van twee batches doorgeven aan de UNet, en er wordt een uitvoer met twee batches geretourneerd, maar intern draaien de twee single-batch-modellen op de twee Neuron-kernen . Deze strategie optimaliseert het gebruik van bronnen en vermindert de latentie.

Compileer en implementeer een stabiel diffusiemodel op een Inf2 EC2-instantie

Om het Stable Diffusion-model te compileren en te implementeren op een Inf2 EC2-instantie, meldt u zich aan bij de AWS-beheerconsole en maak een inf2.8xlarge-instantie. Houd er rekening mee dat een inf2.8xlarge-instantie alleen vereist is voor de compilatie van het model, omdat voor de compilatie een hoger hostgeheugen nodig is. Het Stable Diffusion-model kan worden gehost op een inf2.xlarge-instantie. U kunt de nieuwste AMI met Neuron-bibliotheken vinden met behulp van het volgende AWS-opdrachtregelinterface (AWS CLI) -opdracht:

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

Voor dit voorbeeld hebben we een EC2-instantie gemaakt met behulp van de Deep Learning AMI Neuron PyTorch 1.13 (Ubuntu 20.04). U kunt vervolgens een JupyterLab-labomgeving maken door verbinding te maken met het exemplaar en de volgende stappen uit te voeren:

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

Er bevindt zich een notitieboekje met alle stappen voor het compileren en hosten van het model GitHub.

Laten we eens kijken naar de compilatiestappen voor een van de tekstcoderingsblokken. Andere blokken die deel uitmaken van de Stable Diffusion-pijplijn kunnen op dezelfde manier worden samengesteld.

De eerste stap is het laden van het vooraf getrainde model vanuit Hugging Face. De StableDiffusionPipeline.from_pretrained methode laadt het vooraf getrainde model in ons pijplijnobject, pipe. Wij maken dan een deepcopy van de tekstencoder uit onze pijplijn, waardoor deze effectief wordt gekloond. De del pipe De opdracht wordt vervolgens gebruikt om het oorspronkelijke pijplijnobject te verwijderen, waardoor het geheugen vrijkomt dat erdoor werd verbruikt. Hier kwantificeren we het model naar BF16-gewichten:

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

Deze stap omvat het omwikkelen van onze tekstencoder met de NeuronTextEncoder wikkel. De uitvoer van een gecompileerde tekstcoderingsmodule zal zijn van dict. Wij converteren het naar een list typ met behulp van deze wrapper:

text_encoder = NeuronTextEncoder(text_encoder)

We initialiseren de PyTorch-tensor emb met enkele waarden. De emb tensor wordt gebruikt als voorbeeldinvoer voor de torch_neuronx.trace functie. Deze functie traceert onze tekstencoder en compileert deze in een formaat dat is geoptimaliseerd voor Neuron. Het directorypad voor het gecompileerde model wordt samengesteld door join COMPILER_WORKDIR_ROOT met de submap 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'),
        )

De gecompileerde tekstencoder wordt opgeslagen met behulp van torch.jit.save. Het wordt opgeslagen onder de bestandsnaam model.pt in het text_encoder directory van de werkruimte van onze compiler:

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

De notitieboekje omvat soortgelijke stappen om andere componenten van het model te compileren: UNet, VAE-decoder en VAE post_quant_conv. Nadat u alle modellen heeft gecompileerd, kunt u het model als volgt laden en uitvoeren:

1. Definieer de paden voor de gecompileerde modellen.
2. Laad een vooraf getrainde StableDiffusionPipeline model, waarbij de configuratie is gespecificeerd om het gegevenstype bfloat16 te gebruiken.
3. Laad het UNet-model op twee Neuron-kernen met behulp van de torch_neuronx.DataParallel API. Hierdoor kan parallelle inferentie van gegevens worden uitgevoerd, wat de modelprestaties aanzienlijk kan versnellen.
4. Laad de resterende delen van het model (text_encoder, decoder en post_quant_conv) op een enkele neuronkern.

Vervolgens kunt u de pijplijn uitvoeren door invoertekst als aanwijzingen op te geven. Hieronder volgen enkele afbeeldingen die door het model voor de aanwijzingen zijn gegenereerd:

• Portret van renaud sechan, pen en inkt, ingewikkelde lijntekeningen, door craig mullins, ruan jia, kentaro miura, greg rutkowski, loundraw

• Portret van oude mijnwerker in 19e eeuw, prachtig schilderij, met zeer gedetailleerde schmink door greg rutkowski

• Een kasteel midden in een bos

Host Stable Diffusion 2.1 op AWS Inferentia2 en SageMaker

Voor het hosten van stabiele diffusiemodellen met SageMaker is ook compilatie met de Neuron SDK vereist. U kunt de compilatie van tevoren of tijdens runtime voltooien met behulp van LMI-containers (Large Model Inference). Compilatie vooraf zorgt voor snellere laadtijden van modellen en heeft de voorkeur.

SageMaker LMI-containers bieden twee manieren om het model te implementeren:

• Een optie zonder code waarbij we alleen een serving.properties bestand met de vereiste configuraties
• Breng uw eigen inferentiescript mee

We bekijken beide oplossingen en bespreken de configuraties en het inferentiescript (model.py). In dit bericht demonstreren we de implementatie met behulp van een vooraf gecompileerd model dat is opgeslagen in een Amazon eenvoudige opslagservice (Amazon S3) bak. U kunt dit vooraf samengestelde model gebruiken voor uw implementaties.

Configureer het model met een meegeleverd script

In deze sectie laten we zien hoe u de LMI-container kunt configureren om de stabiele diffusiemodellen te hosten. De SD2.1-notebook beschikbaar op GitHub. De eerste stap is het maken van het modelconfiguratiepakket volgens de volgende mapstructuur. Ons doel is om de minimale modelconfiguraties te gebruiken die nodig zijn om het model te hosten. De benodigde mapstructuur is als volgt:

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

Vervolgens maken we het serveren.eigenschappen bestand met de volgende parameters:

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

De parameters specificeren het volgende:

• optie.model_id – De LMI-containers gebruiken s5cmd om het model vanaf de S3-locatie te laden en daarom moeten we de locatie opgeven waar onze gecompileerde gewichten zich bevinden.
• optie.entryPoint – Om de ingebouwde handlers te gebruiken, specificeren we de klasse Transformers-neuronx. Als u een aangepast inferentiescript heeft, moet u dat in plaats daarvan opgeven.
• optie.dtype – Hiermee wordt aangegeven dat de gewichten in een specifiek formaat moeten worden geladen. Voor dit bericht gebruiken we BF16, wat onze geheugenvereisten verder verlaagt ten opzichte van FP32 en daardoor onze latentie verlaagt.
• optie.tensor_parallel_degree – Deze parameter specificeert het aantal versnellers dat we voor dit model gebruiken. De AWS Inferentia2-chipversneller heeft twee Neuron-kernen en als we een waarde van 2 opgeven, betekent dit dat we één versneller gebruiken (twee kernen). Dit betekent dat we nu meerdere werknemers kunnen creëren om de doorvoer van het eindpunt te vergroten.
• optie.motor – Dit is ingesteld op Python om aan te geven dat we voor deze hosting geen andere compilers zoals DeepSpeed ​​of Faster Transformer zullen gebruiken.

Neem je eigen schrift mee

Als u uw eigen aangepaste inferentiescript wilt gebruiken, moet u de option.entryPoint oppompen van serving.properties. De LMI-container zoekt in dat geval naar een model.py bestand op dezelfde locatie als het serving.properties en gebruik dat om de gevolgtrekking uit te voeren.

Maak uw eigen inferentiescript (model.py)

Het maken van uw eigen inferentiescript is relatief eenvoudig met behulp van de LMI-container. De container vereist uw model.py bestand om een ​​implementatie van de volgende methode te hebben:

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

Laten we enkele van de kritieke gebieden van de bijgevoegd notitieboekje, die de functie 'Bring your own script' demonstreert.

Vervang de cross_attention module met de geoptimaliseerde versie:

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

Dit zijn de namen van het gecompileerde gewichtsbestand dat we hebben gebruikt bij het maken van de compilaties. U kunt de bestandsnamen gerust wijzigen, maar zorg ervoor dat de bestandsnamen voor uw gewichten overeenkomen met wat u hier opgeeft.

Vervolgens moeten we ze laden met behulp van de Neuron SDK en deze instellen in de daadwerkelijke modelgewichten. Houd er bij het laden van de UNet-geoptimaliseerde gewichten rekening mee dat we ook het aantal Neuron-kernen specificeren waarop we deze moeten laden. Hier laden we naar een enkele versneller met twee kernen:

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

Als u de gevolgtrekking uitvoert met een prompt, wordt het pipe-object aangeroepen om een ​​afbeelding te genereren.

Maak het SageMaker-eindpunt

We gebruiken Boto3 API's om een ​​SageMaker-eindpunt te creëren. Voer de volgende stappen uit:

1. Maak de tarball met alleen de portie en de optionele model.py bestanden en upload deze naar Amazon S3.
2. Maak het model met behulp van de afbeeldingscontainer en de model-tarball die eerder is geüpload.
3. Maak de eindpuntconfiguratie met behulp van de volgende sleutelparameters:
   1. Gebruik een ml.inf2.xlarge aanleg.
   2. Zet de ContainerStartupHealthCheckTimeoutInSeconds naar 240 om ervoor te zorgen dat de statuscontrole begint nadat het model is geïmplementeerd.
   3. Zet de VolumeInGB naar een grotere waarde, zodat deze kan worden gebruikt voor het laden van modelgewichten van 32 GB.

Een SageMaker-model maken

Nadat u het model.tar.gz-bestand hebt gemaakt en naar Amazon S3 hebt geüpload, moeten we een SageMaker-model maken. We gebruiken de LMI-container en het modelartefact uit de vorige stap om het SageMaker-model te maken. Met SageMaker kunnen we verschillende omgevingsvariabelen aanpassen en injecteren. Voor deze workflow kunnen we alles op de standaard laten staan. Zie de volgende code:

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

Maak het modelobject, dat in wezen een lockdown-container creëert die op de instantie wordt geladen en wordt gebruikt voor gevolgtrekking:

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

Een SageMaker-eindpunt maken

In deze demo gebruiken we een ml.inf2.xlarge-instantie. We moeten de VolumeSizeInGB parameters om de nodige schijfruimte te bieden om het model en de gewichten te laden. Deze parameter is van toepassing op instanties die de Amazon elastische blokwinkel (Amazon EBS) volumeopzetstuk. We kunnen de time-out voor het downloaden van het model en de gezondheidscontrole voor het opstarten van de container op een hogere waarde laten staan, waardoor de container voldoende tijd heeft om de gewichten uit Amazon S3 te halen en in de AWS Inferentia2-accelerators te laden. Voor meer details, zie CreateEndpointConfig.

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

Ten slotte maken we een SageMaker-eindpunt:

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

Roep het modeleindpunt aan

Dit is een generatief model, dus we geven de prompt door die het model gebruikt om de afbeelding te genereren. De payload is van het type JSON:

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

Benchmarking van het stabiele diffusiemodel op Inf2

We hebben een paar tests uitgevoerd om het Stable Diffusion-model te benchmarken met het gegevenstype BF 16 op Inf2, en we zijn in staat latentiecijfers af te leiden die sommige van de andere versnellers voor Stable Diffusion evenaren of zelfs overtreffen. Dit, in combinatie met de lagere kosten van AWS Inferentia2-chips, maakt dit een uiterst waardevol voorstel.

De volgende cijfers zijn afkomstig van het Stable Diffusion-model dat is geïmplementeerd op een inf2.xl-instantie. Voor meer informatie over de kosten verwijzen wij u naar Amazon EC2 Inf2-instanties.

Conclusie

In dit bericht zijn we diep ingegaan op de compilatie, optimalisatie en implementatie van het Stable Diffusion 2.1-model met behulp van Inf2-instanties. We hebben ook de implementatie van stabiele diffusiemodellen gedemonstreerd met behulp van SageMaker. Inf2-instanties leveren ook geweldige prijs-kwaliteitverhouding voor Stable Diffusion 1.5. Voor meer informatie over waarom Inf2-instanties geweldig zijn voor generatieve AI en grote taalmodellen, raadpleegt u Amazon EC2 Inf2-instanties voor goedkope, krachtige generatieve AI-inferentie zijn nu algemeen beschikbaar. Voor prestatiedetails, zie Inf2-prestaties. Bekijk meer voorbeelden op de GitHub repo.

Speciale dank aan Matthew Mcclain, Beni Hegedus, Kamran Khan, Shruti Koparkar en Qing Lan voor het beoordelen en leveren van waardevolle input.

Over de auteurs

Vivek Gangasani is een Senior Machine Learning Solutions Architect bij Amazon Web Services. Hij werkt samen met machine learning-startups om AI/ML-applicaties op AWS te bouwen en te implementeren. Momenteel richt hij zich op het leveren van oplossingen voor MLOps, ML-inferentie en low-code ML. Hij heeft aan projecten gewerkt in verschillende domeinen, waaronder natuurlijke taalverwerking en computervisie.

KC Tung is Senior Solution Architect bij AWS Annapurna Labs. Hij is gespecialiseerd in training van grote deep learning-modellen en implementatie op grote schaal in de cloud. Hij heeft een Ph.D. in moleculaire biofysica van het University of Texas Southwestern Medical Center in Dallas. Hij heeft gesproken op AWS Summits en AWS Reinvent. Tegenwoordig helpt hij klanten bij het trainen en implementeren van grote PyTorch- en TensorFlow-modellen in de AWS-cloud. Hij is de auteur van twee boeken: Leer TensorFlow Enterprise en TensorFlow 2 zakreferentie.

Rupinder Grewal is een Sr Ai/ML Specialist Solutions Architect bij AWS. Hij richt zich momenteel op het bedienen van modellen en MLOps op SageMaker. Voorafgaand aan deze functie heeft hij gewerkt als Machine Learning Engineer voor het bouwen en hosten van modellen. Naast zijn werk speelt hij graag tennis en fietst hij graag op bergpaden.

• Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
• PlatoData.Network Verticale generatieve AI. Versterk jezelf. Toegang hier.
• PlatoAiStream. Web3-intelligentie. Kennis versterkt. Toegang hier.
• PlatoESG. Automotive / EV's, carbon, CleanTech, Energie, Milieu, Zonne, Afvalbeheer. Toegang hier.
• BlockOffsets. Eigendom voor milieucompensatie moderniseren. Toegang hier.
• Bron: https://aws.amazon.com/blogs/machine-learning/maximize-stable-diffusion-performance-and-lower-inference-costs-with-aws-inferentia2/