Skab billeder i høj kvalitet med stabile diffusionsmodeller og implementer dem omkostningseffektivt med Amazon SageMaker | Amazon Web Services

Tekst-til-billede generering er en opgave, hvor en maskinlæringsmodel (ML) genererer et billede ud fra en tekstbeskrivelse. Målet er at skabe et billede, der matcher beskrivelsen, og fanger tekstens detaljer og nuancer. Denne opgave er udfordrende, fordi den kræver, at modellen forstår tekstens semantik og syntaks og genererer fotorealistiske billeder. Der er mange praktiske anvendelser af tekst-til-billede generering i AI-fotografering, konceptkunst, bygningsarkitektur, mode, videospil, grafisk design og meget mere.

Stabil diffusion er en tekst-til-billede-model, der giver dig mulighed for at skabe billeder i høj kvalitet på få sekunder. Når realtidsinteraktion med denne type model er målet, afhænger sikringen af ​​en jævn brugeroplevelse af brugen af ​​accelereret hardware til slutninger, såsom GPU'er eller AWS Inferentia2, Amazons egen ML-inferensaccelerator. De høje omkostninger forbundet med at bruge GPU'er kræver typisk optimering af udnyttelsen af ​​den underliggende computer, i endnu højere grad, når du skal implementere forskellige arkitekturer eller personlige (finjusterede) modeller. Amazon SageMaker multi-model slutpunkter (MME'er) hjælper dig med at løse dette problem ved at hjælpe dig med at skalere tusindvis af modeller til ét slutpunkt. Ved at bruge en delt serveringsbeholder kan du hoste flere modeller på en omkostningseffektiv, skalerbar måde inden for det samme slutpunkt og endda den samme GPU.

I dette indlæg vil du lære om stabil diffusionsmodelarkitektur, forskellige typer stabile diffusionsmodeller og teknikker til at forbedre billedkvaliteten. Vi viser dig også, hvordan du implementerer stabile diffusionsmodeller omkostningseffektivt ved hjælp af SageMaker MME'er og NVIDIA Triton Inference Server.

Spørgsmål: portræt af en sød berneserhund, kunst af elke Vogelsang, 8k ultrarealistisk, trending på artstation, 4k	Prompt: arkitekturdesign af stue, 8 k ultrarealistisk, 4 k, hyperrealistisk, fokuseret, ekstreme detaljer	Spørgsmål: New Yorks skyline om natten, 8k, langskudsfotografering, unreal engine 5, filmisk, mesterværk

Stabil diffusionsarkitektur

Stable Diffusion er en tekst-til-billede open source-model, som du kan bruge til at skabe billeder af forskellige stilarter og indhold blot ved at give en tekstprompt. I forbindelse med tekst-til-billede generering er en diffusionsmodel en generativ model, som du kan bruge til at generere billeder af høj kvalitet ud fra tekstbeskrivelser. Diffusionsmodeller er en type generativ model, der kan fange de komplekse afhængigheder mellem input- og outputmodaliteternes tekst og billeder.

Følgende diagram viser en højniveauarkitektur af en stabil diffusionsmodel.

Den består af følgende nøgleelementer:

• Tekstkoder – CLIP er en transformatorbaseret tekstkodermodel, der tager inputprompttekst og konverterer den til token-indlejringer, der repræsenterer hvert ord i teksten. CLIP er trænet i et datasæt af billeder og deres billedtekster, en kombination af billedkoder og tekstkoder.
• U-Net – En U-Net-model tager token-indlejringer fra CLIP sammen med en række støjende input og producerer et støjdæmpet output. Dette sker gennem en række iterative trin, hvor hvert trin behandler en latent inputtensor og producerer en ny latent rumtensor, der bedre repræsenterer inputteksten.
• Automatisk encoder-dekoder – Denne model skaber de endelige billeder. Den tager det endelige dæmpede latente output fra U-Net-modellen og konverterer det til billeder, der repræsenterer tekstinputtet.

Typer af stabile diffusionsmodeller

I dette indlæg udforsker vi følgende præ-trænede Stable Diffusion-modeller af Stability AI fra Hugging Face-modelhubben.

stabil-diffusion-2-1-base

Brug denne model til at generere billeder baseret på en tekstprompt. Dette er en basisversion af den model, der blev trænet på LAION-5B. Modellen blev trænet på en delmængde af datasættet i stor skala LAION-5B, og hovedsageligt med engelske billedtekster. Vi bruger StableDiffusionPipeline fra diffusers bibliotek til at generere billeder fra tekstprompter. Denne model kan skabe billeder af dimension 512 x 512. Den bruger følgende parametre:

• prompt – En prompt kan være et tekstord, en sætning, sætninger eller afsnit.
• negativ_prompt – Du kan også sende en negativ prompt for at udelukke specificerede elementer fra billedgenereringsprocessen og for at forbedre kvaliteten af ​​de genererede billeder.
• vejledningsskala – En højere vejledningsskala resulterer i et billede, der er tættere relateret til prompten, på bekostning af billedkvaliteten. Hvis det er angivet, skal det være en flyder.

stabil-diffusion-2-dybde

Denne model bruges til at generere nye billeder fra eksisterende, samtidig med at formen og dybden af ​​objekterne i det originale billede bevares. Det her stable-diffusion-2-depth model er finjusteret fra stabil-diffusion-2-base, en ekstra inputkanal til at behandle den (relative) dybdeforudsigelse. Vi bruger StableDiffusionDepth2ImgPipeline fra diffusers bibliotek for at indlæse pipelinen og generere dybdebilleder. Følgende er de yderligere parametre, der er specifikke for dybdemodellen:

• billede – Det indledende billede til at betinge genereringen af ​​nye billeder.
• antal_inferens_trin (Valgfrit) – Antallet af denoising-trin. Flere trin med denoising fører normalt til et billede af højere kvalitet på bekostning af langsommere slutninger. Denne parameter er moduleret af strength.
• styrke (valgfrit) – Konceptuelt angiver dette, hvor meget referencebilledet skal transformeres. Værdien skal være mellem 0-1. image bruges som udgangspunkt, og tilføjer mere støj til den, jo større styrken er. Antallet af dæmpningstrin afhænger af mængden af ​​støj, der oprindeligt blev tilføjet. Hvornår strength er 1, vil den tilføjede støj være maksimal, og dæmpningsprocessen vil køre i det fulde antal iterationer, der er angivet i num_inference_steps. En værdi på 1 ignorerer derfor i det væsentlige image. For flere detaljer henvises til følgende kode.

stald-diffusion-2-maling

Du kan bruge denne model til brug af AI-billedgendannelse. Du kan også bruge det til at skabe nye designs og billeder ud fra meddelelserne og yderligere argumenter. Denne model er også afledt af basismodellen og har en maskegenereringsstrategi. Det specificerer masken for det originale billede, der repræsenterer segmenter, der skal ændres, og segmenter, der skal forblive uændrede. Vi bruger StableDiffusionUpscalePipeline fra diffusers bibliotek for at anvende inpaint-ændringer på det originale billede. Følgende ekstra parameter er specifik for dybdemodellen:

• mask_input – Et billede, hvor den mørklagte del forbliver uændret under billedgenerering, og den hvide del udskiftes

stabil-diffusion-x4-upscaler

Denne model er også afledt af basismodellen, der desuden er trænet på 10M undergruppen af ​​LAION, der indeholder 2048 x 2048 billeder. Som navnet antyder, kan det bruges til at opskalere billeder med lavere opløsning til højere opløsninger

Brug case oversigt

Til dette indlæg implementerer vi en AI-billedtjeneste med flere muligheder, herunder generering af nye billeder fra tekst, ændring af stilarter på eksisterende billeder, fjernelse af uønskede objekter fra billeder og opskalering af billeder i lav opløsning til højere opløsninger. Ved at bruge flere variationer af stabile diffusionsmodeller kan du løse alle disse brugssager inden for et enkelt SageMaker-slutpunkt. Dette betyder, at du bliver nødt til at hoste et stort antal modeller på en effektiv, skalerbar og omkostningseffektiv måde. I dette indlæg viser vi, hvordan man implementerer flere stabile diffusionsmodeller omkostningseffektivt ved hjælp af SageMaker MME'er og NVIDIA Triton Inference Server. Du vil lære om implementeringsdetaljerne, optimeringsteknikker og bedste praksis for at arbejde med tekst-til-billede-modeller.

Følgende tabel opsummerer de stabile diffusionsmodeller, som vi implementerer til en SageMaker MME.

Løsningsoversigt

Følgende trin er involveret i implementering af stabile diffusionsmodeller til SageMaker MME'er:

1. Brug Hugging Face-hubben til at downloade de stabile diffusionsmodeller til en lokal mappe. Dette vil downloade scheduler, text_encoder, tokenizer, unet, and vae for hver stabil diffusionsmodel i dens tilsvarende lokale mappe. Vi bruger revision="fp16" version af modellen.
2. Konfigurer NVIDIA Triton-modellageret, modelkonfigurationer og modelservicelogik model.py. Triton bruger disse artefakter til at tjene forudsigelser.
3. Pak conda-miljøet med yderligere afhængigheder og pakkemodellageret, der skal implementeres til SageMaker MME.
4. Pak modelartefakter i et NVIDIA Triton-specifikt format og upload model.tar.gz til Amazon Simple Storage Service (Amazon S3). Modellen vil blive brugt til at generere billeder.
5. Konfigurer en SageMaker-model, slutpunktskonfiguration og implementer SageMaker MME.
6. Kør inferens og send meddelelser til SageMaker-slutpunktet for at generere billeder ved hjælp af stabil diffusionsmodellen. Vi specificerer TargetModel variabel og påberåbe forskellige stabile diffusionsmodeller for at sammenligne resultaterne visuelt.

Vi har udgivet koden til at implementere denne løsningsarkitektur i GitHub repo. Følg README-instruktionerne for at komme i gang.

Server modeller med en NVIDIA Triton Inference Server Python-backend

Vi bruger en Triton Python-backend til at implementere den stabile diffusionspipeline-model til en SageMaker MME. Python-backend lader dig betjene modeller skrevet i Python af Triton Inference Server. For at bruge Python-backend skal du oprette en Python-fil model.py der har følgende struktur: Hver Python-backend kan implementere fire hovedfunktioner i 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):

Hver Python-backend kan implementere fire hovedfunktioner i TritonPythonModel klasse: auto_complete_config, initialize, executeog finalize.

initialize kaldes, når modellen indlæses. Implementerer initialize er valgfri. initialize giver dig mulighed for at foretage de nødvendige initialiseringer, før du kører inferens. I den initialize funktion opretter vi en pipeline og indlæser pipelines vha from_pretrained kontrolpunkter. Vi konfigurerer skemalæggere fra pipeline-planlægningskonfigurationen pipe.scheduler.config. Til sidst specificerer vi xformers optimeringer for at aktivere xformer hukommelseseffektiv parameter enable_xformers_memory_efficient_attention. Vi giver flere detaljer vedr xformers senere i dette indlæg. Du kan henvise til model.py for hver model for at forstå de forskellige pipelinedetaljer. Denne fil kan findes i modellageret.

execute funktionen kaldes, når der fremsættes en slutningsanmodning. Hver Python-model skal implementere execute fungere. I execute funktion, får du en liste over InferenceRequest genstande. Vi sender inputtekstprompten til pipeline for at få et billede fra modellen. Billeder afkodes, og det genererede billede returneres fra dette funktionskald.

Vi får inputtensoren fra navnet defineret i modelkonfigurationen config.pbtxt fil. Fra slutningsanmodningen får vi prompt, negative_promptog gen_args, og afkode dem. Vi videregiver alle argumenterne til modelpipeline-objektet. Indkode billedet for at returnere de genererede billedforudsigelser. Du kan henvise til config.pbtxt fil af hver model for at forstå de forskellige pipeline detaljer. Denne fil kan findes i modellageret. Til sidst pakker vi det genererede billede ind InferenceResponse og returnere svaret.

Gennemførelse finalize er valgfrit. Denne funktion giver dig mulighed for at foretage de nødvendige oprydninger, før modellen aflæses fra Triton Inference Server.

Når du arbejder med Python-backend, er det brugerens ansvar at sikre, at inputs behandles på en batch-måde, og at svar sendes tilbage i overensstemmelse hermed. For at opnå dette anbefaler vi at følge disse trin:

1. Gennemgå alle anmodninger i requests genstand for at danne en batched_input.
2. Kør slutning om batched_input.
3. Opdel resultaterne i flere InferenceResponse objekter og sammenkæde dem som svarene.

Se i Triton Python backend dokumentation or Vær vært for ML-modeller på Amazon SageMaker ved hjælp af Triton: Python-backend for flere detaljer.

NVIDIA Triton-modelopbevaring og konfiguration

Modellageret indeholder modelserveringsscriptet, modelartefakter og tokenizer-artefakter, et pakket conda-miljø (med afhængigheder, der er nødvendige for inferens), Triton-konfigurationsfilen og Python-scriptet, der bruges til inferens. Sidstnævnte er obligatorisk, når du bruger Python-backend, og du bør bruge Python-filen model.py. Lad os udforske konfigurationsfilen for inpaint Stable Diffusion-modellen og forstå de forskellige specificerede muligheder:

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" }
}

Følgende tabel forklarer de forskellige parametre og værdier:

For detaljer om modellageret og konfigurationer af andre stabile diffusionsmodeller henvises til koden i GitHub repo. Hver mappe indeholder artefakter til de specifikke stabile diffusionsmodeller.

Pak et conda-miljø og forlæng SageMaker Triton-beholderen

SageMaker NVIDIA Triton containerbilleder indeholder ikke biblioteker som f.eks transformer, accelerate, and diffusers at implementere og betjene stabile diffusionsmodeller. Triton giver dig dog mulighed for at bringe yderligere afhængigheder vha conda-pakke. Lad os starte med at skabe conda-miljøet med de nødvendige afhængigheder beskrevet i environment.yml fil og opret en tjæremodelartefakt sd_env.tar.gz fil, der indeholder conda-miljøet med afhængigheder installeret i det. Kør følgende YML-fil for at oprette en conda-pack artefakt og kopier artefakten til den lokale mappe, hvorfra den vil blive uploadet til Amazon S3. Bemærk, at vi vil uploade conda-artefakterne som en af ​​modellerne i MME og påberåbe denne model for at opsætte conda-miljøet i SageMaker-hosting ML-instansen.

%%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 modelartefakter til Amazon S3

SageMaker forventer, at .tar.gz-filen, der indeholder hvert Triton-modellager, er hostet på multi-model-slutpunktet. Derfor opretter vi en tjæreartefakt med indhold fra Triton-modellageret. Vi kan bruge denne S3-spand til at være vært for tusindvis af modelartefakter, og SageMaker MME vil bruge modeller fra denne placering til dynamisk at indlæse og betjene et stort antal modeller. Vi opbevarer alle stabile diffusionsmodeller på denne Amazon S3-placering.

Implementer SageMaker MME

I dette afsnit gennemgår vi trinene til at implementere SageMaker MME ved at definere containerspecifikationer, SageMaker-model og slutpunktskonfigurationer.

Definer serveringsbeholderen

I containerdefinitionen skal du definere ModelDataUrl for at angive S3-biblioteket, der indeholder alle de modeller, som SageMaker MME vil bruge til at indlæse og betjene forudsigelser. Sæt Mode til MultiModel for at angive, at SageMaker vil oprette slutpunktet med MME-beholderspecifikationerne. Vi indstiller beholderen med et billede, der understøtter implementering af MME'er med GPU. Se Understøttede algoritmer, rammer og instanser for flere detaljer.

Vi ser alle tre modelartefakter i den følgende Amazon S3 ModelDataUrl placering:

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

Opret et MME-objekt

Vi bruger SageMaker Boto3-klienten til at skabe modellen ved hjælp af skabe_model API. Vi videregiver containerdefinitionen til skabe model API sammen med ModelName , ExecutionRoleArn:

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

Definer konfigurationer for MME

Opret en MME-konfiguration ved hjælp af create_endpoint_config Boto3 API. Angiv en accelereret GPU-beregningsinstans i InstanceType (vi bruger den samme instanstype, som vi bruger til at være vært for vores SageMaker notesbog). Vi anbefaler at konfigurere dine slutpunkter med mindst to forekomster med virkelige use cases. Dette giver SageMaker mulighed for at levere et meget tilgængeligt sæt forudsigelser på tværs af flere tilgængelighedszoner for modellerne.

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

Opret en MME

Brug den foregående slutpunktskonfiguration til at oprette et nyt SageMaker-slutpunkt og vent på, at implementeringen er færdig:

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

Status ændres til InService når implementeringen er vellykket.

Generer billeder ved hjælp af forskellige versioner af stabile diffusionsmodeller

Lad os starte med at påkalde basismodellen med en prompt og få det genererede billede. Vi videregiver inputs til basismodellen med prompt, negative_prompt, and gen_args som en ordbog. Vi indstiller datatypen og formen for hvert inputelement i ordbogen og sender det som input til modellen.

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

Spørgsmål: Infinity-pool på toppen af ​​et højhus med udsigt over Central Park

Ved at arbejde med dette billede kan vi ændre det med den alsidige stabile diffusionsdybdemodel. For eksempel kan vi ændre stilen på billedet til et oliemaleri, eller ændre indstillingen fra Central Park til Yellowstone National Park ved blot at sende det originale billede sammen med en prompt, der beskriver de ændringer, vi gerne vil se.

Vi påberåber os dybdemodellen ved at specificere sd_depth.tar.gz i TargetModel af invoke_endpoint funktionskald. Læg mærke til i udgangene, hvordan orienteringen af ​​det originale billede er bevaret, men for et eksempel er NYC-bygningerne blevet omdannet til klippeformationer af samme form.

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

Originalbillede	Oliemaleri	Yellowstone Park

En anden nyttig model er Stable Diffusion inpainting, som vi kan bruge til at fjerne visse dele af billedet. Lad os sige, at du vil fjerne træet i følgende eksempelbillede. Det kan vi gøre ved at påberåbe os inpaint-modellen sd_inpaint.tar.gz. For at fjerne træet skal vi passere en mask_image, som angiver, hvilke områder af billedet, der skal bevares, og hvilke der skal udfyldes. Den sorte pixeldel af maskebilledet angiver de områder, der skal forblive uændrede, og de hvide pixels angiver, hvad der skal erstattes.

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

Originalbillede	Maske billede	Inpaint billede

I vores sidste eksempel reducerer vi det originale billede, der blev genereret tidligere, fra dets 512 x 512 opløsning til 128 x 128. Vi kalder derefter opskaleringsmodellen Stable Diffusion for at opskalere billedet tilbage til 512 x 512. Vi bruger den samme prompt til at opskalere billedet som det, vi brugte til at generere det oprindelige billede. Selvom det ikke er nødvendigt, hjælper det at give en prompt, der beskriver billedet, vejlede opskaleringsprocessen og bør føre til bedre resultater.

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

Billede i lav opløsning	Opskaleret billede

Selvom det opskalerede billede ikke er så detaljeret som originalen, er det en markant forbedring i forhold til lavopløsningsbilledet.

Optimer til hukommelse og hastighed

xformers bibliotek er en måde at fremskynde billedgenerering. Denne optimering er kun tilgængelig for NVIDIA GPU'er. Det fremskynder billedgenerering og sænker VRAM-brug. Vi har brugt xformers bibliotek for hukommelseseffektiv opmærksomhed og hastighed. Når enable_xformers_memory_efficient_attention indstillingen er aktiveret, bør du observere lavere GPU-hukommelsesbrug og en potentiel fremskyndelse på inferenstidspunktet.

Clean Up

Følg instruktionerne i oprydningssektionen af ​​notesbogen for at slette den ressourceklarerede del af denne blog for at undgå unødvendige gebyrer. Henvise Amazon SageMaker-priser for detaljer om omkostningerne ved slutningstilfældene.

Konklusion

I dette indlæg diskuterede vi stabile diffusionsmodeller, og hvordan du kan implementere forskellige versioner af stabile diffusionsmodeller omkostningseffektivt ved hjælp af SageMaker multi-model slutpunkter. Du kan bruge denne tilgang til at bygge et billedgenererings- og redigeringsværktøj til skaberen. Tjek kodeeksemplerne i GitHub repo for at komme i gang og fortælle os om det seje generative AI-værktøj, du bygger.

Om forfatterne

Simon Zamarin er en AI/ML Solutions Architect, hvis hovedfokus er at hjælpe kunder med at udvinde værdi fra deres dataaktiver. I sin fritid nyder Simon at bruge tid med familien, læse sci-fi og arbejde på forskellige DIY-husprojekter.

Vikram Elango er en Sr. AI/ML Specialist Solutions Architect hos AWS, baseret i Virginia, USA. Han er i øjeblikket fokuseret på generativ AI, LLM'er, prompt engineering, optimering af store modelslutninger og skalering af ML på tværs af virksomheder. Vikram hjælper finans- og forsikringsbranchens kunder med design og arkitektur til at bygge og implementere ML-applikationer i stor skala. I sin fritid nyder han at rejse, vandre, lave mad og campere med sin familie.

João Moura er AI/ML Specialist Solutions Architect hos AWS, baseret i Spanien. Han hjælper kunder med dyb læringsmodeltræning og inferensoptimering og mere bredt opbygning af store ML-platforme på AWS. Han er også en aktiv fortaler for ML-specialiseret hardware og lavkode ML-løsninger.

Saurabh Trikande er Senior Product Manager for Amazon SageMaker Inference. Han brænder for at arbejde med kunder og er motiveret af målet om at demokratisere machine learning. Han fokuserer på kerneudfordringer relateret til implementering af komplekse ML-applikationer, multi-tenant ML-modeller, omkostningsoptimeringer og at gøre implementering af deep learning-modeller mere tilgængelig. I sin fritid nyder Saurabh at vandre, lære om innovative teknologier, følge TechCrunch og tilbringe tid med sin familie.

• SEO Powered Content & PR Distribution. Bliv forstærket i dag.
• PlatoAiStream. Web3 Data Intelligence. Viden forstærket. Adgang her.
• Udmøntning af fremtiden med Adryenn Ashley. Adgang her.
• Køb og sælg aktier i PRE-IPO-virksomheder med PREIPO®. Adgang her.
• Kilde: https://aws.amazon.com/blogs/machine-learning/create-high-quality-images-with-stable-diffusion-models-and-deploy-them-cost-efficiently-with-amazon-sagemaker/