Het genereren van tekst naar afbeelding is een taak waarbij een machine learning (ML)-model een afbeelding genereert op basis van een tekstuele beschrijving. Het doel is om een ​​afbeelding te genereren die nauw aansluit bij de beschrijving, waarbij de details en nuances van de tekst worden vastgelegd. Deze taak is een uitdaging omdat het model de semantiek en syntaxis van de tekst moet begrijpen en fotorealistische afbeeldingen moet genereren. Er zijn veel praktische toepassingen van het genereren van tekst naar afbeelding in AI-fotografie, conceptkunst, bouwarchitectuur, mode, videogames, grafisch ontwerp en nog veel meer.

Stabiele diffusie is een tekst-naar-afbeelding-model waarmee u binnen enkele seconden afbeeldingen van hoge kwaliteit kunt maken. Wanneer real-time interactie met dit type model het doel is, hangt het verzekeren van een soepele gebruikerservaring af van het gebruik van versnelde hardware voor inferentie, zoals GPU's of AWS Inferentie2, Amazon's eigen ML-inferentieversneller. De hoge kosten die gepaard gaan met het gebruik van GPU's vereisen meestal het optimaliseren van het gebruik van de onderliggende rekenkracht, vooral wanneer u verschillende architecturen of gepersonaliseerde (verfijnde) modellen moet implementeren. Amazon Sage Maker eindpunten met meerdere modellen (MME's) helpen u dit probleem aan te pakken door u te helpen duizenden modellen naar één eindpunt te schalen. Door een shared serving container te gebruiken, kunt u meerdere modellen op een kosteneffectieve, schaalbare manier hosten binnen hetzelfde eindpunt en zelfs dezelfde GPU.

In dit bericht leer je over Stable Diffusion-modelarchitecturen, verschillende soorten Stable Diffusion-modellen en technieken om de beeldkwaliteit te verbeteren. We laten u ook zien hoe u Stable Diffusion-modellen kosteneffectief kunt implementeren met behulp van SageMaker MME's en NVIDIA Triton Inference Server.

Prompt: portret van een schattige Berner hond, kunst door elke Vogelsang, 8k ultra realistisch, trending op artstation, 4 k	Vraag: architectuurontwerp woonkamer, 8 k ultrarealistisch, 4 k, hyperrealistisch, gefocust, extreme details	Prompt: skyline van New York 's nachts, 8k, fotografie op afstand, onwerkelijke motor 5, filmisch, meesterwerk

Stabiele Diffusion-architectuur

Stable Diffusion is een open-sourcemodel voor tekst-naar-afbeelding dat u kunt gebruiken om afbeeldingen met verschillende stijlen en inhoud te maken door simpelweg een tekstprompt op te geven. In de context van het genereren van tekst naar afbeelding is een diffusiemodel een generatief model dat u kunt gebruiken om afbeeldingen van hoge kwaliteit te genereren op basis van tekstuele beschrijvingen. Diffusiemodellen zijn een soort generatief model dat de complexe afhankelijkheden tussen de invoer- en uitvoermodaliteiten tekst en afbeeldingen kan vastleggen.

Het volgende diagram toont een architectuur op hoog niveau van een stabiel diffusiemodel.

Het bestaat uit de volgende hoofdelementen:

• Tekst-encoder - CLIP is een op transformatoren gebaseerd tekstencodermodel dat invoerprompttekst neemt en converteert naar token-inbeddingen die elk woord in de tekst vertegenwoordigen. CLIP is getraind op een dataset van afbeeldingen en hun bijschriften, een combinatie van beeld-encoder en tekst-encoder.
• U-Net - Een U-Net-model neemt token-inbeddingen van CLIP samen met een reeks luidruchtige invoer en produceert een uitvoer zonder ruis. Dit gebeurt via een reeks iteratieve stappen, waarbij elke stap een invoer latente tensor verwerkt en een nieuwe latente ruimtetensor produceert die de invoertekst beter vertegenwoordigt.
• Automatische encoder-decoder – Dit model maakt de uiteindelijke beelden. Het neemt de uiteindelijke latente output zonder ruis van het U-Net-model en zet deze om in afbeeldingen die de tekstinvoer vertegenwoordigen.

Typen stabiele diffusiemodellen

In dit bericht verkennen we de volgende vooraf getrainde Stable Diffusion-modellen door Stability AI van de Hugging Face-modelhub.

stabiele-diffusie-2-1-basis

Gebruik dit model om afbeeldingen te genereren op basis van een tekstprompt. Dit is een basisversie van het model waarop is getraind LAION-5B. Het model is getraind op een subset van de grootschalige dataset LAION-5B, en voornamelijk met Engelse onderschriften. We gebruiken StableDiffusionPipeline van het diffusers bibliotheek om afbeeldingen te genereren op basis van tekstprompts. Dit model kan afbeeldingen maken met een afmeting van 512 x 512. Het gebruikt de volgende parameters:

• prompt – Een prompt kan een tekstwoord, woordgroep, zinnen of paragrafen zijn.
• negatieve_prompt – U kunt ook een negatieve prompt doorgeven om gespecificeerde elementen uit te sluiten van het proces voor het genereren van afbeeldingen en om de kwaliteit van de gegenereerde afbeeldingen te verbeteren.
• begeleiding_schaal – Een hogere begeleidingsschaal resulteert in een beeld dat nauwer verwant is aan de prompt, ten koste van de beeldkwaliteit. Indien gespecificeerd, moet het een float zijn.

stabiele-diffusie-2-diepte

Dit model wordt gebruikt om nieuwe afbeeldingen te genereren uit bestaande afbeeldingen, terwijl de vorm en diepte van de objecten in de originele afbeelding behouden blijven. Dit stable-diffusion-2-depth model vanaf is fijn afgesteld stabiele-diffusie-2-base, een extra invoerkanaal om de (relatieve) dieptevoorspelling te verwerken. We gebruiken StableDiffusionDepth2ImgPipeline van het diffusers bibliotheek om de pijplijn te laden en dieptebeelden te genereren. Hieronder volgen de aanvullende parameters die specifiek zijn voor het dieptemodel:

• beeld – De eerste afbeelding om het genereren van nieuwe afbeeldingen te conditioneren.
• aantal_inferentie_stappen (Optioneel) – Het aantal denoising-stappen. Meer stappen voor het verwijderen van ruis leiden meestal tot een beeld van hogere kwaliteit ten koste van langzamere gevolgtrekkingen. Deze parameter wordt gemoduleerd door strength.
• sterkte (optioneel) – Conceptueel geeft dit aan hoeveel het referentiebeeld moet worden getransformeerd. De waarde moet tussen 0–1 liggen. image wordt als uitgangspunt gebruikt, waarbij meer ruis wordt toegevoegd naarmate de sterkte groter is. Het aantal ruisonderdrukkingsstappen is afhankelijk van de hoeveelheid ruis die aanvankelijk is toegevoegd. Wanneer strength 1 is, is de toegevoegde ruis maximaal en wordt het ruisverwijderingsproces uitgevoerd voor het volledige aantal iteraties dat is opgegeven in num_inference_steps. Een waarde van 1 negeert daarom in wezen image. Raadpleeg het volgende voor meer informatie code.

stabiele diffusie-2-inschildering

U kunt dit model gebruiken voor use-cases voor het herstellen van AI-afbeeldingen. U kunt het ook gebruiken om nieuwe ontwerpen en afbeeldingen te maken op basis van de prompts en aanvullende argumenten. Dit model is ook afgeleid van het basismodel en heeft een strategie voor het genereren van maskers. Het specificeert het masker van de originele afbeelding om segmenten weer te geven die moeten worden gewijzigd en segmenten die ongewijzigd moeten blijven. We gebruiken StableDiffusionUpscalePipeline van het diffusers bibliotheek om inpaint-wijzigingen toe te passen op de originele afbeelding. De volgende aanvullende parameter is specifiek voor het dieptemodel:

• masker_invoer – Een beeld waarbij het zwarte gedeelte ongewijzigd blijft tijdens het genereren van het beeld en het witte gedeelte wordt vervangen

stabiele-diffusie-x4-upscaler

Dit model is ook afgeleid van het basismodel, bovendien getraind op de 10M subset van LAION met 2048 x 2048 afbeeldingen. Zoals de naam al aangeeft, kan het worden gebruikt om afbeeldingen met een lagere resolutie op te schalen naar hogere resoluties

Gebruik case-overzicht

Voor dit bericht zetten we een AI-beeldservice in met meerdere mogelijkheden, waaronder het genereren van nieuwe afbeeldingen uit tekst, het wijzigen van de stijlen van bestaande afbeeldingen, het verwijderen van ongewenste objecten uit afbeeldingen en het opschalen van afbeeldingen met een lage resolutie naar hogere resoluties. Door verschillende varianten van Stable Diffusion-modellen te gebruiken, kunt u al deze use-cases binnen één SageMaker-eindpunt aanpakken. Dit betekent dat u een groot aantal modellen op een performante, schaalbare en kostenefficiënte manier moet hosten. In dit bericht laten we zien hoe u meerdere Stable Diffusion-modellen kosteneffectief kunt implementeren met behulp van SageMaker MME's en NVIDIA Triton Inference Server. U leert over de implementatiedetails, optimalisatietechnieken en best practices voor het werken met tekst-naar-afbeelding-modellen.

De volgende tabel geeft een overzicht van de stabiele diffusiemodellen die we implementeren in een SageMaker MME.

Overzicht oplossingen

De volgende stappen zijn betrokken bij het implementeren van Stable Diffusion-modellen op SageMaker MME's:

1. Gebruik de Hugging Face-hub om de Stable Diffusion-modellen naar een lokale map te downloaden. Dit zal downloaden scheduler, text_encoder, tokenizer, unet, and vae voor elk Stable Diffusion-model in de bijbehorende lokale directory. Wij gebruiken de revision="fp16" versie van het model.
2. Stel de NVIDIA Triton-modelrepository, modelconfiguraties en modelservinglogica in model.py. Triton gebruikt deze artefacten om voorspellingen te doen.
3. Verpak de conda-omgeving met aanvullende afhankelijkheden en de pakketmodelrepository die moet worden geïmplementeerd in de SageMaker MME.
4. Verpak de modelartefacten in een NVIDIA Triton-specifieke indeling en upload ze model.tar.gz naar Amazon eenvoudige opslagservice (Amazone S3). Het model zal worden gebruikt voor het genereren van afbeeldingen.
5. Configureer een SageMaker-model, eindpuntconfiguratie en implementeer de SageMaker MME.
6. Voer deductie uit en stuur prompts naar het SageMaker-eindpunt om afbeeldingen te genereren met behulp van het Stable Diffusion-model. Wij specificeren de TargetModel variabel en roep verschillende Stable Diffusion-modellen op om de resultaten visueel te vergelijken.

We hebben de code gepubliceerd om deze oplossingsarchitectuur te implementeren in de GitHub repo. Volg de README-instructies om aan de slag te gaan.

Serveer modellen met een NVIDIA Triton Inference Server Python-backend

We gebruiken een Triton Python-backend om het Stable Diffusion-pijplijnmodel te implementeren in een SageMaker MME. Met de Python-backend kunt u modellen bedienen die in Python zijn geschreven door Triton Inference Server. Om de Python-backend te gebruiken, moet u een Python-bestand maken model.py dat heeft de volgende structuur: Elke Python-backend kan vier hoofdfuncties implementeren in het TritonPythonModel klasse:

import triton_python_backend_utils as pb_utils
class TritonPythonModel: """Your Python model must use the same class name. Every Python model
that is created must have "TritonPythonModel" as the class name. """
def auto_complete_config(auto_complete_model_config):
def initialize(self, args):
def execute(self, requests):
def finalize(self):

Elke Python-backend kan vier hoofdfuncties implementeren in de TritonPythonModel klasse: auto_complete_config, initialize, execute en finalize.

initialize wordt aangeroepen wanneer het model wordt geladen. Implementeren initialize is optioneel. initialize stelt u in staat om de nodige initialisaties uit te voeren voordat u gevolgtrekking uitvoert. In de initialize functie, maken we een pijplijn en laden de pijplijnen met behulp van from_pretrained controleposten. We configureren planners vanuit de configuratie van de pijplijnplanner pipe.scheduler.config. Tot slot specificeren we xformers optimalisaties om de xformer geheugen efficiënte parameter enable_xformers_memory_efficient_attention. We geven meer details over xformers verderop in dit bericht. U kunt verwijzen naar model.py van elk model om de verschillende pijplijndetails te begrijpen. Dit bestand is te vinden in het modelarchief.

De execute functie wordt aangeroepen wanneer een deductieverzoek wordt gedaan. Elk Python-model moet de execute functie. In de execute functie, krijgt u een lijst met InferenceRequest voorwerpen. We geven de invoertekstprompt door aan de pijplijn om een ​​afbeelding van het model te krijgen. Afbeeldingen worden gedecodeerd en de gegenereerde afbeelding wordt geretourneerd door deze functieaanroep.

We halen de invoertensor uit de naam die is gedefinieerd in de modelconfiguratie config.pbtxt bestand. Van het gevolgtrekkingsverzoek krijgen we prompt, negative_prompt en gen_argsen decodeer ze. We geven alle argumenten door aan het modelpijplijnobject. Codeer de afbeelding om de gegenereerde afbeeldingsvoorspellingen te retourneren. U kunt verwijzen naar de config.pbtxt bestand van elk model om de verschillende pijplijndetails te begrijpen. Dit bestand is te vinden in het modelarchief. Ten slotte wikkelen we de gegenereerde afbeelding in InferenceResponse en geef het antwoord terug.

Uitvoering finalize is optioneel. Met deze functie kunt u eventuele opschoningen uitvoeren voordat het model wordt verwijderd uit Triton Inference Server.

Wanneer u met de Python-backend werkt, is het de verantwoordelijkheid van de gebruiker om ervoor te zorgen dat de invoer batchgewijs wordt verwerkt en dat de antwoorden dienovereenkomstig worden teruggestuurd. Om dit te bereiken, raden we aan om de volgende stappen te volgen:

1. Doorloop alle verzoeken in de requests bezwaar om een ​​te vormen batched_input.
2. Voer inferentie uit op de batched_input.
3. Splits de resultaten op in meerdere InferenceResponse objecten en voeg ze samen als de antwoorden.

Verwijs naar de Triton Python-backend-documentatie or Host ML-modellen op Amazon SageMaker met Triton: Python-backend voor meer details.

NVIDIA Triton-modelrepository en configuratie

De modelrepository bevat het modelservingscript, modelartefacten en tokenizerartefacten, een verpakte conda-omgeving (met afhankelijkheden die nodig zijn voor inferentie), het Triton-configuratiebestand en het Python-script dat wordt gebruikt voor inferentie. Dit laatste is verplicht wanneer u de Python-backend gebruikt en u moet het Python-bestand gebruiken model.py. Laten we het configuratiebestand van het inpaint Stable Diffusion-model verkennen en de verschillende gespecificeerde opties begrijpen:

name: "sd_inpaint"
backend: "python"
max_batch_size: 8
input [ { name: "prompt" data_type: TYPE_STRING dims: [ -1 ] }, { name: "negative_prompt" data_type: TYPE_STRING dims: [ -1 ] optional: true }, { name: "image" data_type: TYPE_STRING dims: [ -1 ] }, { name: "mask_image" data_type: TYPE_STRING dims: [ -1 ] }, { name: "gen_args" data_type: TYPE_STRING dims: [ -1 ] optional: true }
]
output [ { name: "generated_image" data_type: TYPE_STRING dims: [ -1 ] }
]
instance_group [ { kind: KIND_GPU }
]
parameters: { key: "EXECUTION_ENV_PATH", value: {string_value: "/tmp/conda/sd_env.tar.gz" }
}

In de volgende tabel worden de verschillende parameters en waarden uitgelegd:

Voor details over de modelrepository en configuraties van andere Stable Diffusion-modellen raadpleegt u de code in de GitHub repo. Elke directory bevat artefacten voor de specifieke Stable Diffusion-modellen.

Verpak een conda-omgeving en breid de SageMaker Triton-container uit

SageMaker NVIDIA Triton-containerafbeeldingen bevatten geen bibliotheken zoals transformer, accelerate, and diffusers om Stable Diffusion-modellen in te zetten en te bedienen. Met Triton kunt u echter extra afhankelijkheden toevoegen met behulp van conda-pakket. Laten we beginnen met het maken van de conda-omgeving met de nodige afhankelijkheden die worden beschreven in de environment.yml -bestand en maak een tar-modelartefact sd_env.tar.gz bestand met de conda-omgeving met daarin geïnstalleerde afhankelijkheden. Voer het volgende YML-bestand uit om een conda-pack artefact en kopieer het artefact naar de lokale map van waaruit het naar Amazon S3 zal worden geüpload. Houd er rekening mee dat we de conda-artefacten uploaden als een van de modellen in de MME en dit model aanroepen om de conda-omgeving in te stellen in de SageMaker-hosting-ML-instantie.

%%writefile environment.yml
name: mme_env
dependencies: - python=3.8 - pip - pip: - numpy - torch --extra-index-url https://download.pytorch.org/whl/cu118 - accelerate - transformers - diffusers - xformers - conda-pack !conda env create -f environment.yml –force

Upload modelartefacten naar Amazon S3

SageMaker verwacht dat het .tar.gz-bestand dat elke Triton-modelrepository bevat, wordt gehost op het multi-model eindpunt. Daarom maken we een tar-artefact met inhoud uit de Triton-modelrepository. We kunnen deze S3-bucket gebruiken om duizenden modelartefacten te hosten, en de SageMaker MME zal modellen van deze locatie gebruiken om dynamisch een groot aantal modellen te laden en te bedienen. We slaan alle Stable Diffusion-modellen op in deze Amazon S3-locatie.

Implementeer de SageMaker MME

In deze sectie doorlopen we de stappen om de SageMaker MME te implementeren door de containerspecificatie, het SageMaker-model en de eindpuntconfiguraties te definiëren.

Definieer de serveercontainer

Definieer in de containerdefinitie de ModelDataUrl om de S3-directory op te geven die alle modellen bevat die de SageMaker MME zal gebruiken om voorspellingen te laden en te leveren. Set Mode naar MultiModel om aan te geven dat SageMaker het eindpunt zal maken met de MME-containerspecificaties. We stellen de container in met een afbeelding die de implementatie van MME's met GPU ondersteunt. Zien Ondersteunde algoritmen, frameworks en instances voor meer details.

We zien alle drie de modelartefacten in de volgende Amazon S3 ModelDataUrl locatie:

container = {"Image": mme_triton_image_uri, "ModelDataUrl": model_data_url, "Mode": "MultiModel"}

Maak een MME-object

We gebruiken de SageMaker Boto3-client om het model te maken met behulp van de maak_model API. We geven de containerdefinitie door aan de API voor het maken van een model, samen met: ModelName en ExecutionRoleArn:

create_model_response = sm_client.create_model( ModelName=sm_model_name, ExecutionRoleArn=role, PrimaryContainer=container
)

Definieer configuraties voor de MME

Maak een MME-configuratie met behulp van de create_endpoint_config Boto3-API. Specificeer een versnelde GPU-computinginstantie in InstanceType (we gebruiken hetzelfde instantietype dat we gebruiken om onze SageMaker-notebook te hosten). We raden aan om uw eindpunten te configureren met ten minste twee instanties met real-life use cases. Hierdoor kan SageMaker een zeer beschikbare reeks voorspellingen bieden voor meerdere beschikbaarheidszones voor de modellen.

create_endpoint_config_response = sm_client.create_endpoint_config( EndpointConfigName=endpoint_config_name, ProductionVariants=[ { "InstanceType": instance_type, "InitialVariantWeight": 1, "InitialInstanceCount": 1, "ModelName": sm_model_name, "VariantName": "AllTraffic", } ],
)

Maak een MME

Gebruik de voorgaande eindpuntconfiguratie om een ​​nieuw SageMaker-eindpunt te maken en wacht tot de implementatie is voltooid:

create_endpoint_response = sm_client.create_endpoint( EndpointName=endpoint_name, EndpointConfigName=endpoint_config_name
)

De status verandert in InService wanneer de implementatie is gelukt.

Genereer afbeeldingen met behulp van verschillende versies van Stable Diffusion-modellen

Laten we beginnen met het aanroepen van het basismodel met een prompt en het ophalen van de gegenereerde afbeelding. We geven de invoer door aan het basismodel met prompt, negative_prompt, and gen_args als woordenboek. We stellen het gegevenstype en de vorm van elk invoeritem in het woordenboek in en geven het als invoer door aan het model.

inputs = dict(prompt = "Infinity pool on top of a high rise overlooking Central Park", negative_prompt = "blur,low detail, low quality", gen_args = json.dumps(dict(num_inference_steps=50, guidance_scale=8))
)
payload = { "inputs": [{"name": name, "shape": [1,1], "datatype": "BYTES", "data": [data]} for name, data in inputs.items()]
}
response = runtime_sm_client.invoke_endpoint( EndpointName=endpoint_name, ContentType="application/octet-stream", Body=json.dumps(payload), TargetModel="sd_base.tar.gz", )
output = json.loads(response["Body"].read().decode("utf8"))["outputs"]
decode_image(output[0]["data"][0])

Prompt: overloopzwembad bovenop een hoogbouw met uitzicht op Central Park

Door met dit beeld te werken, kunnen we het aanpassen met het veelzijdige Stable Diffusion-dieptemodel. We kunnen bijvoorbeeld de stijl van de afbeelding veranderen in een olieverfschilderij, of de omgeving veranderen van Central Park in Yellowstone National Park door simpelweg de originele afbeelding door te geven samen met een prompt die de veranderingen beschrijft die we zouden willen zien.

We roepen het dieptemodel aan door te specificeren sd_depth.tar.gz in de TargetModel van de invoke_endpoint functie oproep. Let in de uitvoer op hoe de oriëntatie van de originele afbeelding behouden blijft, maar bijvoorbeeld de gebouwen in NYC zijn getransformeerd in rotsformaties met dezelfde vorm.

inputs = dict(prompt = "highly detailed oil painting of an inifinity pool overlooking central park", image=image, gen_args = json.dumps(dict(num_inference_steps=50, strength=0.9)) )
payload = { "inputs": [{"name": name, "shape": [1,1], "datatype": "BYTES", "data": [data]} for name, data in inputs.items()]
}
response = runtime_sm_client.invoke_endpoint( EndpointName=endpoint_name, ContentType="application/octet-stream", Body=json.dumps(payload), TargetModel="sd_depth.tar.gz", )
output = json.loads(response["Body"].read().decode("utf8"))["outputs"]
print("original image")
display(original_image)
print("generated image")
display(decode_image(output[0]["data"][0]))

Originele afbeelding	Olieverf	Yellowstone-park

Een ander bruikbaar model is Stable Diffusion inpainting, waarmee we bepaalde delen van de afbeelding kunnen verwijderen. Stel dat u de boom in de volgende voorbeeldafbeelding wilt verwijderen. We kunnen dit doen door het inpaint-model aan te roepen sd_inpaint.tar.gz. Om de boom te verwijderen, moeten we een mask_image, wat aangeeft welke gebieden van de afbeelding moeten worden behouden en welke moeten worden ingevuld. Het zwarte pixelgedeelte van de maskerafbeelding geeft de gebieden aan die ongewijzigd moeten blijven, en de witte pixels geven aan wat moet worden vervangen.

image = encode_image(original_image).decode("utf8")
mask_image = encode_image(Image.open("sample_images/bertrand-gabioud-mask.png")).decode("utf8")
inputs = dict(prompt = "building, facade, paint, windows", image=image, mask_image=mask_image, negative_prompt = "tree, obstruction, sky, clouds", gen_args = json.dumps(dict(num_inference_steps=50, guidance_scale=10)) )
payload = { "inputs": [{"name": name, "shape": [1,1], "datatype": "BYTES", "data": [data]} for name, data in inputs.items()]
}
response = runtime_sm_client.invoke_endpoint( EndpointName=endpoint_name, ContentType="application/octet-stream", Body=json.dumps(payload), TargetModel="sd_inpaint.tar.gz", )
output = json.loads(response["Body"].read().decode("utf8"))["outputs"]
decode_image(output[0]["data"][0])

Originele afbeelding	Masker afbeelding	Afbeelding inkleuren

In ons laatste voorbeeld verkleinen we de originele afbeelding die eerder is gegenereerd van de resolutie van 512 x 512 naar 128 x 128. Vervolgens roepen we het Stable Diffusion upscaler-model op om de afbeelding weer op te schalen naar 512 x 512. We gebruiken dezelfde prompt om op te schalen de afbeelding als wat we gebruikten om de eerste afbeelding te genereren. Hoewel het niet nodig is, helpt het geven van een prompt die de afbeelding beschrijft, bij het begeleiden van het opschalingsproces en zou dit tot betere resultaten moeten leiden.

low_res_image = output_image.resize((128, 128))
inputs = dict(prompt = "Infinity pool on top of a high rise overlooking Central Park", image=encode_image(low_res_image).decode("utf8")
) payload = { "inputs": [{"name": name, "shape": [1,1], "datatype": "BYTES", "data": [data]} for name, data in inputs.items()]
} response = runtime_sm_client.invoke_endpoint( EndpointName=endpoint_name, ContentType="application/octet-stream", Body=json.dumps(payload), TargetModel="sd_upscale.tar.gz", )
output = json.loads(response["Body"].read().decode("utf8"))["outputs"]
upscaled_image = decode_image(output[0]["data"][0])

Afbeelding met lage resolutie	Opgeschaald beeld

Hoewel de opgeschaalde afbeelding niet zo gedetailleerd is als het origineel, is het een duidelijke verbetering ten opzichte van de afbeelding met lage resolutie.

Optimaliseer voor geheugen en snelheid

De xformers bibliotheek is een manier om het genereren van afbeeldingen te versnellen. Deze optimalisatie is alleen beschikbaar voor NVIDIA GPU's. Het versnelt het genereren van afbeeldingen en verlaagt het VRAM-gebruik. Wij hebben gebruik gemaakt van de xformers bibliotheek voor geheugen-efficiënte aandacht en snelheid. Wanneer de enable_xformers_memory_efficient_attention optie is ingeschakeld, zou u een lager GPU-geheugengebruik en een mogelijke versnelling op het moment van inferentie moeten waarnemen.

Clean Up

Volg de instructies in het opschoongedeelte van het notitieblok om het gedeelte met resources van deze blog te verwijderen om onnodige kosten te voorkomen. Refereren Amazon SageMaker-prijzen voor meer informatie over de kosten van de inferentie-exemplaren.

Conclusie

In dit bericht hebben we Stable Diffusion-modellen besproken en hoe u verschillende versies van Stable Diffusion-modellen kosteneffectief kunt implementeren met behulp van SageMaker-eindpunten met meerdere modellen. U kunt deze benadering gebruiken om een ​​tool voor het genereren en bewerken van afbeeldingen voor makers te bouwen. Bekijk de codevoorbeelden in de GitHub repo om aan de slag te gaan en ons te laten weten over de coole generatieve AI-tool die je bouwt.

Over de auteurs

Simon Zamarin is een AI / ML Solutions Architect die zich voornamelijk richt op het helpen van klanten om waarde uit hun data-assets te halen. In zijn vrije tijd brengt Simon graag tijd door met familie, leest hij sci-fi en werkt hij aan verschillende doe-het-zelfprojecten.

Vikram Elango is Sr. AI/ML Specialist Solutions Architect bij AWS, gevestigd in Virginia, VS. Hij richt zich momenteel op generatieve AI, LLM's, prompt engineering, optimalisatie van grote modellen en het opschalen van ML binnen ondernemingen. Vikram helpt klanten uit de financiële en verzekeringssector met ontwerp en architectuur om ML-applicaties op schaal te bouwen en te implementeren. In zijn vrije tijd houdt hij van reizen, wandelen, koken en kamperen met zijn gezin.

Joao Moura is een AI/ML Specialist Solutions Architect bij AWS, gevestigd in Spanje. Hij helpt klanten met deep learning modeltraining en inferentie-optimalisatie, en meer in het algemeen bij het bouwen van grootschalige ML-platforms op AWS. Hij is ook een actief voorstander van ML-gespecialiseerde hardware en low-code ML-oplossingen.

Saurabh Trikande is Senior Product Manager voor Amazon SageMaker Inference. Hij heeft een passie voor het werken met klanten en wordt gemotiveerd door het doel om machine learning te democratiseren. Hij richt zich op kernuitdagingen met betrekking tot het inzetten van complexe ML-applicaties, multi-tenant ML-modellen, kostenoptimalisaties en het toegankelijker maken van de inzet van deep learning-modellen. In zijn vrije tijd houdt Saurabh van wandelen, leren over innovatieve technologieën, TechCrunch volgen en tijd doorbrengen met zijn gezin.

• Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
• PlatoAiStream. Web3 gegevensintelligentie. Kennis versterkt. Toegang hier.
• De toekomst slaan met Adryenn Ashley. Toegang hier.
• Koop en verkoop aandelen in PRE-IPO-bedrijven met PREIPO®. Toegang hier.
• Bron: https://aws.amazon.com/blogs/machine-learning/create-high-quality-images-with-stable-diffusion-models-and-deploy-them-cost-efficiently-with-amazon-sagemaker/