Crea immagini di alta qualità con modelli Stable Diffusion e distribuiscile a costi contenuti con Amazon SageMaker | Servizi Web Amazon

La generazione da testo a immagine è un'attività in cui un modello di machine learning (ML) genera un'immagine da una descrizione testuale. L'obiettivo è generare un'immagine che corrisponda fedelmente alla descrizione, catturando i dettagli e le sfumature del testo. Questo compito è impegnativo perché richiede che il modello comprenda la semantica e la sintassi del testo e generi immagini fotorealistiche. Esistono molte applicazioni pratiche della generazione di testo in immagine nella fotografia AI, nella concept art, nell'architettura degli edifici, nella moda, nei videogiochi, nella progettazione grafica e molto altro.

Diffusione stabile è un modello di testo in immagine che ti consente di creare immagini di alta qualità in pochi secondi. Quando l'obiettivo è l'interazione in tempo reale con questo tipo di modello, garantire un'esperienza utente fluida dipende dall'uso di hardware accelerato per l'inferenza, come GPU o AWS Inferenziale2, l'acceleratore di inferenza ML di Amazon. I costi elevati legati all'utilizzo delle GPU in genere richiedono l'ottimizzazione dell'utilizzo del calcolo sottostante, ancora di più quando è necessario distribuire architetture diverse o modelli personalizzati (perfezionati). Amazon Sage Maker endpoint multi-modello (MME) ti aiutano a risolvere questo problema aiutandoti a ridimensionare migliaia di modelli in un unico endpoint. Utilizzando un contenitore di servizio condiviso, puoi ospitare più modelli in modo conveniente e scalabile all'interno dello stesso endpoint e persino della stessa GPU.

In questo post imparerai le architetture del modello Stable Diffusion, i diversi tipi di modelli Stable Diffusion e le tecniche per migliorare la qualità dell'immagine. Ti mostriamo anche come implementare modelli Stable Diffusion a costi contenuti utilizzando SageMaker MME e NVIDIA Triton Inference Server.

Prompt: ritratto di un simpatico cane bernese, disegno di elke Vogelsang, 8k ultra realistico, di tendenza su artstation, 4k	Prompt: progetto di architettura del soggiorno, 8k ultra realistico, 4k, iperrealistico, focalizzato, dettagli estremi	Suggerimento: skyline di New York di notte, 8k, fotografia a campo lungo, motore irreale 5, cinema, capolavoro

Architettura di diffusione stabile

Stable Diffusion è un modello open source da testo a immagine che puoi utilizzare per creare immagini di stili e contenuti diversi semplicemente fornendo un prompt di testo. Nel contesto della generazione da testo a immagine, un modello di diffusione è un modello generativo che puoi utilizzare per generare immagini di alta qualità da descrizioni testuali. I modelli di diffusione sono un tipo di modello generativo in grado di catturare le complesse dipendenze tra le modalità di input e output testo e immagini.

Il diagramma seguente mostra un'architettura di alto livello di un modello di diffusione stabile.

Si compone dei seguenti elementi chiave:

• Codificatore di testo – CLIP è un modello di codificatore di testo basato su trasformatori che prende il testo del prompt di input e lo converte in incorporamenti di token che rappresentano ogni parola nel testo. CLIP viene addestrato su un set di dati di immagini e relative didascalie, una combinazione di codificatore di immagini e codificatore di testo.
• U-Net – Un modello U-Net prende token embedding da CLIP insieme a una serie di input rumorosi e produce un output denoised. Ciò avviene attraverso una serie di passaggi iterativi, in cui ogni passaggio elabora un tensore latente di input e produce un nuovo tensore dello spazio latente che rappresenta meglio il testo di input.
• Encoder-decodificatore automatico – Questo modello crea le immagini finali. Prende l'output latente denoised finale dal modello U-Net e lo converte in immagini che rappresentano l'input di testo.

Tipi di modelli a diffusione stabile

In questo post, esploriamo i seguenti modelli di diffusione stabile pre-addestrati da Stability AI dall'hub del modello Hugging Face.

diffusione-stabile-2-1-base

Utilizzare questo modello per generare immagini basate su un prompt di testo. Questa è una versione base del modello su cui è stato addestrato LAION-5B. Il modello è stato addestrato su un sottoinsieme del set di dati su larga scala LAION-5B, e principalmente con didascalie in inglese. Noi usiamo StableDiffusionPipeline dal diffusers libreria per generare immagini da prompt di testo. Questo modello può creare immagini di dimensioni 512 x 512. Utilizza i seguenti parametri:

• pronto – Un prompt può essere una parola di testo, una frase, frasi o paragrafi.
• prompt_negativo – È inoltre possibile passare un prompt negativo per escludere elementi specificati dal processo di generazione dell'immagine e per migliorare la qualità delle immagini generate.
• guida_scala – Una scala di guida più alta produce un'immagine più strettamente correlata al prompt, a scapito della qualità dell'immagine. Se specificato, deve essere un float.

diffusione-stabile-2-profondità

Questo modello viene utilizzato per generare nuove immagini da quelle esistenti preservando la forma e la profondità degli oggetti nell'immagine originale. Questo stable-diffusion-2-depth model è messo a punto da diffusione-stabile-2-base, un canale di input aggiuntivo per elaborare la previsione della profondità (relativa). Noi usiamo StableDiffusionDepth2ImgPipeline dal diffusers library per caricare la pipeline e generare immagini di profondità. Di seguito sono riportati i parametri aggiuntivi specifici del modello di profondità:

• Immagine – L'immagine iniziale per condizionare la generazione di nuove immagini.
• num_inferenza_passi (facoltativo) – Il numero di passaggi di riduzione del rumore. Più passaggi di denoising di solito portano a un'immagine di qualità superiore a scapito di un'inferenza più lenta. Questo parametro è modulato da strength.
• forza (opzionale) – Concettualmente, questo indica quanto trasformare l'immagine di riferimento. Il valore deve essere compreso tra 0 e 1. image viene utilizzato come punto di partenza, aggiungendo più rumore maggiore è la forza. Il numero di fasi di riduzione del rumore dipende dalla quantità di rumore inizialmente aggiunta. Quando strength è 1, il rumore aggiunto sarà massimo e il processo di denoising verrà eseguito per l'intero numero di iterazioni specificato in num_inference_steps. Un valore di 1, quindi, essenzialmente ignora image. Per ulteriori dettagli, fare riferimento a quanto segue codice.

stabile-diffusione-2-inpittura

Puoi utilizzare questo modello per i casi d'uso di ripristino di immagini AI. Puoi anche usarlo per creare nuovi design e immagini dai prompt e argomenti aggiuntivi. Anche questo modello è derivato dal modello base e ha una strategia di generazione della maschera. Specifica la maschera dell'immagine originale per rappresentare i segmenti da modificare ei segmenti da lasciare invariati. Noi usiamo StableDiffusionUpscalePipeline dal diffusers libreria per applicare modifiche inpaint all'immagine originale. Il seguente parametro aggiuntivo è specifico del modello di profondità:

• input_maschera – Un'immagine in cui la parte oscurata rimane invariata durante la generazione dell'immagine e la parte bianca viene sostituita

stabile-diffusione-x4-upscaler

Anche questo modello è derivato dal modello base, addestrato ulteriormente sul sottoinsieme 10 M di LAION contenente immagini 2048 x 2048. Come suggerisce il nome, può essere utilizzato per eseguire l'upscaling di immagini a bassa risoluzione a risoluzioni più elevate

Panoramica dei casi d'uso

Per questo post, implementiamo un servizio di immagini AI con molteplici funzionalità, tra cui la generazione di nuove immagini dal testo, la modifica degli stili delle immagini esistenti, la rimozione di oggetti indesiderati dalle immagini e l'upscaling di immagini a bassa risoluzione a risoluzioni più elevate. Utilizzando diverse varianti dei modelli Stable Diffusion, puoi affrontare tutti questi casi d'uso all'interno di un singolo endpoint SageMaker. Ciò significa che dovrai ospitare un numero elevato di modelli in modo performante, scalabile ed economico. In questo post, mostriamo come implementare più modelli Stable Diffusion in modo economicamente vantaggioso utilizzando SageMaker MME e NVIDIA Triton Inference Server. Imparerai i dettagli di implementazione, le tecniche di ottimizzazione e le migliori pratiche per lavorare con i modelli di testo in immagine.

La tabella seguente riassume i modelli di diffusione stabile che distribuiamo a un MME SageMaker.

Panoramica della soluzione

I seguenti passaggi sono coinvolti nella distribuzione dei modelli Stable Diffusion alle MME SageMaker:

1. Utilizzare l'hub Hugging Face per scaricare i modelli Stable Diffusion in una directory locale. Questo verrà scaricato scheduler, text_encoder, tokenizer, unet, and vae per ogni modello di diffusione stabile nella directory locale corrispondente. Noi usiamo il revision="fp16" versione del modello.
2. Imposta il repository del modello NVIDIA Triton, le configurazioni del modello e la logica di servizio del modello model.py. Triton utilizza questi artefatti per fornire previsioni.
3. Crea un pacchetto dell'ambiente conda con dipendenze aggiuntive e il repository del modello di pacchetto da distribuire in SageMaker MME.
4. Impacchetta gli artefatti del modello in un formato specifico di NVIDIA Triton e caricali model.tar.gz a Servizio di archiviazione semplice Amazon (Amazon S3). Il modello verrà utilizzato per generare immagini.
5. Configura un modello SageMaker, la configurazione dell'endpoint e distribuisci SageMaker MME.
6. Esegui l'inferenza e invia le richieste all'endpoint SageMaker per generare immagini utilizzando il modello Stable Diffusion. Precisiamo il TargetModel variabile e richiamare diversi modelli di diffusione stabile per confrontare visivamente i risultati.

Abbiamo pubblicato il codice per implementare questa architettura di soluzione in Repository GitHub. Segui le istruzioni README per iniziare.

Servi i modelli con un back-end Python di NVIDIA Triton Inference Server

Utilizziamo un backend Triton Python per distribuire il modello di pipeline Stable Diffusion su un MME SageMaker. Il backend Python ti consente di servire modelli scritti in Python da Triton Inference Server. Per utilizzare il backend Python, devi creare un file Python model.py che ha la seguente struttura: Ogni backend Python può implementare quattro funzioni principali nel file TritonPythonModel classe:

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

Ogni backend Python può implementare quattro funzioni principali nel file TritonPythonModel classe: auto_complete_config, initialize, executee finalize.

initialize viene chiamato quando il modello viene caricato. Implementazione initialize è facoltativo. initialize consente di eseguire tutte le inizializzazioni necessarie prima di eseguire l'inferenza. Nel initialize function, creiamo una pipeline e carichiamo le pipeline usando from_pretrained posti di blocco. Configuriamo gli scheduler dalla configurazione dello scheduler della pipeline pipe.scheduler.config. Infine, specifichiamo xformers ottimizzazioni per abilitare il xformer parametro di efficienza della memoria enable_xformers_memory_efficient_attention. Forniamo maggiori dettagli su xformers più avanti in questo post. Puoi fare riferimento a model.py di ciascun modello per comprendere i diversi dettagli della pipeline. Questo file può essere trovato nel repository del modello.

Il execute La funzione viene chiamata ogni volta che viene effettuata una richiesta di inferenza. Ogni modello Python deve implementare il execute funzione. Nel execute funzione, ti viene fornito un elenco di InferenceRequest oggetti. Passiamo il prompt del testo di input alla pipeline per ottenere un'immagine dal modello. Le immagini vengono decodificate e l'immagine generata viene restituita da questa chiamata di funzione.

Otteniamo il tensore di input dal nome definito nella configurazione del modello config.pbtxt file. Dalla richiesta di inferenza, otteniamo prompt, negative_prompte gen_args, e decodificarli. Passiamo tutti gli argomenti all'oggetto pipeline del modello. Codifica l'immagine per restituire le previsioni dell'immagine generate. Puoi fare riferimento al config.pbtxt file di ciascun modello per comprendere i diversi dettagli della pipeline. Questo file può essere trovato nel repository del modello. Infine, avvolgiamo l'immagine generata InferenceResponse e restituire la risposta.

Implementazione finalize è facoltativo. Questa funzione consente di eseguire tutte le operazioni di pulizia necessarie prima che il modello venga scaricato da Triton Inference Server.

Quando si lavora con il back-end Python, è responsabilità dell'utente garantire che gli input vengano elaborati in modo batch e che le risposte vengano restituite di conseguenza. Per raggiungere questo obiettivo, ti consigliamo di seguire questi passaggi:

1. Passa in rassegna tutte le richieste nel file requests oggetto per formare a batched_input.
2. Eseguire l'inferenza sul batched_input.
3. Dividi i risultati in più InferenceResponse oggetti e concatenarli come risposte.

Fare riferimento a Documentazione back-end di Triton Python or Ospita modelli ML su Amazon SageMaker utilizzando Triton: backend Python per ulteriori dettagli.

Repository e configurazione del modello NVIDIA Triton

Il repository del modello contiene lo script di servizio del modello, gli artefatti del modello e gli artefatti del tokenizer, un ambiente conda in pacchetto (con le dipendenze necessarie per l'inferenza), il file di configurazione di Triton e lo script Python utilizzato per l'inferenza. Quest'ultimo è obbligatorio quando usi il backend Python e dovresti usare il file Python model.py. Esploriamo il file di configurazione del modello inpaint Stable Diffusion e comprendiamo le diverse opzioni specificate:

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

La tabella seguente spiega i vari parametri e valori:

Per i dettagli sul repository di modelli e le configurazioni di altri modelli Stable Diffusion, fare riferimento al codice nel file Repository GitHub. Ogni directory contiene artefatti per i modelli di diffusione stabile specifici.

Creare un pacchetto di un ambiente conda ed estendere il contenitore SageMaker Triton

Le immagini del contenitore SageMaker NVIDIA Triton non contengono librerie come transformer, accelerate, and diffusers per implementare e servire modelli di diffusione stabile. Tuttavia, Triton ti consente di portare dipendenze aggiuntive utilizzando pacchetto conda. Iniziamo creando l'ambiente conda con le dipendenze necessarie delineate nel file environment.yml file e creare un artefatto del modello tar sd_env.tar.gz file contenente l'ambiente conda con le dipendenze installate al suo interno. Eseguire il seguente file YML per creare un file conda-pack artefatto e copia l'artefatto nella directory locale da dove verrà caricato in Amazon S3. Tieni presente che caricheremo gli artefatti conda come uno dei modelli nell'MME e invocheremo questo modello per configurare l'ambiente conda nell'istanza ML che ospita SageMaker.

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

Carica gli artefatti del modello su Amazon S3

SageMaker prevede che il file .tar.gz contenente ogni repository di modelli Triton sia ospitato sull'endpoint multi-modello. Pertanto, creiamo un artefatto tar con contenuto dal repository del modello Triton. Possiamo utilizzare questo bucket S3 per ospitare migliaia di artefatti del modello e SageMaker MME utilizzerà i modelli da questa posizione per caricare e servire in modo dinamico un gran numero di modelli. Conserviamo tutti i modelli Stable Diffusion in questa posizione Amazon S3.

Distribuisci SageMaker MME

In questa sezione, esaminiamo i passaggi per distribuire SageMaker MME definendo le specifiche del contenitore, il modello SageMaker e le configurazioni degli endpoint.

Definisci il contenitore di servizio

Nella definizione del contenitore, definire il ModelDataUrl per specificare la directory S3 che contiene tutti i modelli che SageMaker MME utilizzerà per caricare e fornire previsioni. Impostato Mode a MultiModel per indicare che SageMaker creerà l'endpoint con le specifiche del contenitore MME. Impostiamo il contenitore con un'immagine che supporti la distribuzione di MME con GPU. Vedere Algoritmi, framework e istanze supportati per ulteriori dettagli.

Vediamo tutti e tre gli artefatti del modello nel seguente Amazon S3 ModelDataUrl posizione:

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

Creare un oggetto MME

Utilizziamo il client SageMaker Boto3 per creare il modello utilizzando il file crea_modello API. Passiamo la definizione del contenitore all'API di creazione del modello insieme a ModelName ed ExecutionRoleArn:

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

Definire le configurazioni per MME

Creare una configurazione MME utilizzando il file create_endpoint_config API Boto3. Specificare un'istanza di elaborazione GPU accelerata in InstanceType (usiamo lo stesso tipo di istanza che stiamo utilizzando per ospitare il nostro notebook SageMaker). Ti consigliamo di configurare i tuoi endpoint con almeno due istanze con casi d'uso reali. Ciò consente a SageMaker di fornire un set di previsioni altamente disponibili su più zone di disponibilità per i modelli.

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

Crea un MME

Utilizza la configurazione dell'endpoint precedente per creare un nuovo endpoint SageMaker e attendi il completamento della distribuzione:

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

Lo stato cambierà in InService quando la distribuzione ha esito positivo.

Genera immagini utilizzando diverse versioni dei modelli Stable Diffusion

Iniziamo richiamando il modello base con un prompt e ottenendo l'immagine generata. Passiamo gli input al modello base con prompt, negative_prompt, and gen_args come dizionario. Impostiamo il tipo di dati e la forma di ciascun elemento di input nel dizionario e lo passiamo come input al modello.

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

Suggerimento: piscina a sfioro in cima a un grattacielo con vista su Central Park

Lavorando con questa immagine, possiamo modificarla con il versatile modello di profondità Stable Diffusion. Ad esempio, possiamo cambiare lo stile dell'immagine in un dipinto a olio o cambiare l'ambientazione da Central Park a Yellowstone National Park semplicemente passando l'immagine originale insieme a un prompt che descrive i cambiamenti che vorremmo vedere.

Invochiamo il modello di profondità specificando sd_depth.tar.gz nel TargetModel della invoke_endpoint chiamata di funzione. Negli output, notate come viene preservato l'orientamento dell'immagine originale, ma per esempio, gli edifici di New York sono stati trasformati in formazioni rocciose della stessa forma.

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

Immagine originale	Pittura ad olio	Parco di Yellowstone

Un altro modello utile è l'inpainting Stable Diffusion, che possiamo usare per rimuovere alcune parti dell'immagine. Diciamo che vuoi rimuovere l'albero nella seguente immagine di esempio. Possiamo farlo invocando il modello inpaint sd_inpaint.tar.gz. Per rimuovere l'albero, dobbiamo passare a mask_image, che indica quali aree dell'immagine devono essere mantenute e quali devono essere riempite. La porzione di pixel neri dell'immagine della maschera indica le aree che devono rimanere invariate, mentre i pixel bianchi indicano cosa deve essere sostituito.

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

Immagine originale	Immagine della maschera	Inpaint immagine

Nel nostro esempio finale, ridimensioniamo l'immagine originale che è stata generata in precedenza dalla sua risoluzione 512 x 512 a 128 x 128. Quindi invochiamo il modello di upscaler Stable Diffusion per eseguire l'upscaling dell'immagine a 512 x 512. Usiamo lo stesso prompt per eseguire l'upscaling l'immagine come ciò che abbiamo usato per generare l'immagine iniziale. Sebbene non sia necessario, fornire un prompt che descriva l'immagine aiuta a guidare il processo di upscaling e dovrebbe portare a risultati migliori.

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

Immagine a bassa risoluzione	Immagine ingrandita

Sebbene l'immagine ingrandita non sia dettagliata come l'originale, è un netto miglioramento rispetto a quella a bassa risoluzione.

Ottimizza per memoria e velocità

Il xformers library è un modo per velocizzare la generazione delle immagini. Questa ottimizzazione è disponibile solo per le GPU NVIDIA. Accelera la generazione di immagini e riduce l'utilizzo della VRAM. Abbiamo usato il xformers libreria per attenzione e velocità efficienti in termini di memoria. Quando il enable_xformers_memory_efficient_attention l'opzione è abilitata, dovresti osservare un minore utilizzo della memoria della GPU e un potenziale aumento della velocità al momento dell'inferenza.

Ripulire

Segui le istruzioni nella sezione di pulizia del blocco appunti per eliminare la parte di questo blog di cui è stato eseguito il provisioning delle risorse per evitare addebiti non necessari. Fare riferimento Prezzi di Amazon SageMaker per i dettagli il costo delle istanze di inferenza.

Conclusione

In questo post, abbiamo discusso dei modelli Stable Diffusion e di come implementare diverse versioni dei modelli Stable Diffusion in modo conveniente utilizzando gli endpoint multi-modello SageMaker. Puoi utilizzare questo approccio per creare uno strumento di generazione e modifica delle immagini del creatore. Controlla gli esempi di codice nel file Repository GitHub per iniziare e facci sapere del fantastico strumento di intelligenza artificiale generativa che crei.

Informazioni sugli autori

Simone Zamarin è un architetto di soluzioni AI / ML il cui obiettivo principale è aiutare i clienti a estrarre valore dalle loro risorse di dati. Nel tempo libero, Simon ama passare il tempo con la famiglia, leggere fantascienza e lavorare a vari progetti di case fai da te.

Vikram Elango è Sr. AI/ML Specialist Solutions Architect presso AWS, con sede in Virginia, USA. Attualmente si occupa di intelligenza artificiale generativa, LLM, ingegneria rapida, ottimizzazione dell'inferenza di modelli di grandi dimensioni e scalabilità del machine learning tra le aziende. Vikram aiuta i clienti del settore finanziario e assicurativo con design e architettura a creare e distribuire applicazioni ML su larga scala. Nel tempo libero ama viaggiare, fare escursioni, cucinare e fare campeggio con la sua famiglia.

João Moura è AI/ML Specialist Solutions Architect presso AWS, con sede in Spagna. Aiuta i clienti con la formazione del modello di deep learning e l'ottimizzazione dell'inferenza e, più in generale, nella creazione di piattaforme ML su larga scala su AWS. È anche un sostenitore attivo dell'hardware specializzato in ML e delle soluzioni ML low-code.

Saurabh Trikande è un Senior Product Manager per Amazon SageMaker Inference. È appassionato di lavorare con i clienti ed è motivato dall'obiettivo di democratizzare l'apprendimento automatico. Si concentra sulle sfide principali relative all'implementazione di applicazioni ML complesse, modelli ML multi-tenant, ottimizzazioni dei costi e rendere più accessibile l'implementazione di modelli di deep learning. Nel tempo libero, Saurabh ama fare escursioni, conoscere tecnologie innovative, seguire TechCrunch e trascorrere del tempo con la sua famiglia.

• Distribuzione di contenuti basati su SEO e PR. Ricevi amplificazione oggi.
• PlatoAiStream. Intelligenza dei dati Web3. Conoscenza amplificata. Accedi qui.
• Coniare il futuro con Adryenn Ashley. Accedi qui.
• Acquista e vendi azioni in società PRE-IPO con PREIPO®. Accedi qui.
• Fonte: https://aws.amazon.com/blogs/machine-learning/create-high-quality-images-with-stable-diffusion-models-and-deploy-them-cost-efficiently-with-amazon-sagemaker/