Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Generazione di immagini con Amazon Nova Canvas
Con il modello Amazon Nova Canvas, puoi generare immagini realistiche di qualità studio utilizzando prompt di testo. Puoi utilizzare Amazon Nova Canvas per applicazioni text-to-image di modifica delle immagini.
Amazon Nova Canvas supporta le seguenti funzionalità:
+ Text-to-image Generazione (T2I): immette un prompt di testo e genera una nuova immagine come output. L’immagine generata acquisisce i concetti descritti dal prompt di testo.
+ Condizionamento delle immagini: utilizza un’immagine di riferimento per guidare la generazione. Il modello genera un’immagine di output in linea con il layout e la composizione dell’immagine di riferimento pur seguendo il prompt di testo.
+ Contenuto guidato dai colori: puoi fornire un elenco di codici colore esadecimali insieme a un prompt. Puoi fornire un intervallo da 1 a 10 codici esadecimali. L’immagine restituita conterrà la palette di colori fornita dall’utente.
+ Variazione dell’immagine: utilizza da 1 a 5 immagini e un prompt facoltativo come input. Genera una nuova immagine che prende caratteristiche come stile, palette di colori e soggetto dalle immagini di riferimento.
+ Inpainting: utilizza un’immagine e una maschera di segmentazione come input (fornite dall’utente o da una stima del modello) e ricostruisce la regione definita della maschera. Utilizza l’inpainting per sostituire i pixel della maschera con nuovi contenuti generati.
+ Outpainting: utilizza un’immagine e una maschera di segmentazione come input (forniti dall’utente o da una stima del modello) e genera nuovi contenuti che estendono senza interruzioni la regione della maschera, sostituendo in modo efficace lo sfondo dell’immagine.
+ Rimozione dello sfondo: identifica automaticamente più oggetti nell’immagine di input e rimuove lo sfondo. L’immagine di output ha uno sfondo trasparente.
+ Coerenza del soggetto: la coerenza del soggetto si ottiene eseguendo il fine-tuning del modello con immagini di riferimento per preservare il soggetto scelto (ad esempio, animale domestico, scarpa o borsa) nelle immagini generate.
+ Provenienza dei contenuti: utilizza strumenti disponibili pubblicamente come [Content Credentials Verify](https://contentcredentials.org/verify) per verificare se un’immagine è stata generata da Amazon Nova Canvas. La verifica dovrebbe indicare che l’immagine è stata generata a meno che i metadati non siano stati rimossi.
+ Filigrana: aggiunge una filigrana invisibile a tutte le immagini generate per ridurre la diffusione di disinformazione, contribuire alla protezione del copyright e monitorare l’utilizzo dei contenuti. Il rilevamento delle filigrane è disponibile per consentire di verificare se un’immagine è stata generata da un modello Amazon Nova, che controlla se è presente questa filigrana.
| | Amazon Nova Canvas |
| --- |--- |
| ID modello | amazon. nova-canvas-v1:0 |
| Modalità di input | Testo, immagini |
| Modalità di output | Immagine |
| Lunghezza massima dei prompt | 1.024 caratteri |
| Risoluzione massima di output (attività di generazione) | 4,19 milioni di pixel (ovvero 2048x2048, 2816x1536) |
| Risoluzione massima di output (attività di editing) | Devono essere soddisfatti tutti i seguenti requisiti: 4.096 pixel sul lato più lungo Proporzioni tra 1:4 e 4:1 Numero totale di pixel pari o inferiore a 4,19 milioni |
| Tipi di immagini di input supportati | PNG, JPEG |
| Lingue supportate | Italiano |
| Regioni | Stati Uniti orientali (Virginia settentrionale), Europa (Irlanda) e Asia Pacifico (Tokyo) |
| Invocare un modello API | Sì |
| Fine-tuning | Sì |
| Throughput allocato | No |
**Topics**
+ [Generazione ed editing di immagini](image-gen-access.md)
+ [Prova virtuale](image-gen-vto.md)
+ [Stili grafici](image-gen-styles.md)
+ [Struttura di richieste e risposte per la generazione di immagini](image-gen-req-resp-structure.md)
+ [Gestione degli errori](image-gen-errors.md)
+ [Esempi di codice](image-gen-code-examples.md)
# Generazione ed editing di immagini
Amazon Nova Canvas è disponibile tramite l'[InvokeModel API](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) Bedrock e supporta i seguenti parametri di inferenza e risposte del modello durante l'esecuzione dell'inferenza del modello.
**Topics**
+ [Formato di richieste e risposte per la generazione di immagini](#image-gen-req-resp-format)
+ [Immagini di input per la generazione di immagini](#image-gen-input-images)
+ [Immagini maschera](#image-gen-masking)
+ [Risoluzioni di immagini supportate](#image-gen-resolutions)
## Formato di richieste e risposte per la generazione di immagini
Quando effettui una [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)chiamata utilizzando il modello Amazon Nova Canvas, sostituisci il `body` campo della richiesta con il formato che corrisponde al tuo caso d'uso. Tutte le attività condividono un oggetto `imageGenerationConfig`, ma ogni attività ha un oggetto di parametri specifico. Sono supportati i seguenti casi d’uso:
| Valore Tipo di attività | Campo Parametri attività | Categoria di attività | Description |
| --- | --- | --- | --- |
| TEXT\$1IMAGE con solo testo | textToImageParams | Generazione | Genera un’immagine utilizzando un prompt di testo. |
| TEXT\$1IMAGE con condizionamento dell’immagine | textToImageParams | Generazione | Fornisci un’immagine di condizionamento come input insieme a un prompt di testo per generare un’immagine che segua il layout e la composizione dell’immagine di condizionamento. |
| COLOR\$1GUIDED\$1GENERATION | colorGuidedGenerationParams | Generazione | Fornisci un elenco di valori di colore in formato esadecimale (ad esempio \$1FF9800) insieme a un messaggio di testo e un'immagine di riferimento opzionale per generare un'immagine che segua la palette di colori specificata. |
| IMAGE\$1VARIATION | imageVariationParams | Generazione | Fornisci una o più immagini di input, con o senza un prompt di testo, per influenzare l’immagine generata. Questa operazione può essere utilizzata per influenzare lo stile grafico dell’immagine generata (quando utilizzata con un prompt di testo), per generare una singola immagine (quando utilizzata con un prompt di testo) e per altri effetti e controllo creativo. |
| INPAINTING | inPaintingParams | Editing | Modifica un’immagine cambiando l’area contenuta in una regione mascherata. Questa operazione può essere utilizzata per rimuovere o sostituire elementi di un’immagine. |
| OUTPAINTING | outPaintingParams | Editing | Modifica un’immagine cambiando l’area esterna a una regione mascherata. Questa operazione può essere utilizzata per sostituire lo sfondo dietro un soggetto. |
| BACKGROUND\$1REMOVAL | backgroundRemovalParams | Editing | Rimuove automaticamente lo sfondo di qualsiasi immagine, sostituendolo con pixel trasparenti. Questa operazione può essere utile quando desideri comporre tale immagine con altri elementi in un’app di editing di immagini, in una presentazione o in un sito web in un secondo momento. Lo sfondo può anche essere facilmente modificato in un colore a tinta unita con un codice personalizzato. |
| VIRTUAL\$1TRY\$1ON | virtualTryOnParams | Editing | Fornisci un’immagine di origine e un’immagine di riferimento, sovrappone un oggetto dell’immagine di riferimento su quella di origine. Questa operazione può essere utilizzata per visualizzare abiti e accessori su diversi modelli o in pose diverse, per modificare lo stile e l’aspetto di un oggetto, un articolo o un capo di abbigliamento oppure per trasferire stili e design da un oggetto all’altro. |
## Immagini di input per la generazione di immagini
Molti tipi di attività richiedono l’inclusione di una o più immagini di input nella richiesta. Qualsiasi immagine utilizzata nella richiesta deve essere codificata come stringa Base64. In genere, le immagini possono essere in formato PNG o JPEG e devono avere una dimensione di 8 bit per canale di colore (RGB). Le immagini PNG possono contenere un canale alfa aggiuntivo, che però non deve contenere pixel trasparenti o traslucidi. Per informazioni specifiche sulle dimensioni supportate per le immagini di input, consulta la sezione [Risoluzioni di immagini supportate](#image-gen-resolutions).
Un’*immagine maschera* è un’immagine che indica l’area in base alla quale eseguire l’inpainting o l’outpainting. Questa immagine può contenere solo pixel di colore nero o bianco puro.
Per le richieste di inpainting, l’area colorata in nero è chiamata *maschera* e verrà modificata. Il resto dell’immagine maschera deve contenere solo pixel di colore bianco puro, che indicano l’area esterna alla maschera.
Per le richieste di outpainting, il modello modificherà l’area colorata di bianco.
Le immagini maschera non devono contenere pixel che non siano di colore bianco o nero puro. Se utilizzi un’immagine JPEG come maschera, deve essere compressa con una qualità del 100% per evitare di introdurre pixel non bianchi o non neri durante la compressione.
Per esempi di codifica o decodifica di un’immagine in o da una stringa Base64, consulta gli [esempi di codice](https://docs.aws.amazon.com/nova/latest/userguide/image-gen-code-examples.html).
## Immagini maschera
Nell’editing delle immagini, una maschera è un modo per definire le aree da modificare. Puoi definire la maschera in uno dei tre modi descritti di seguito:
+ `maskPrompt`: scrivi un prompt di testo in linguaggio naturale per descrivere la parte o le parti dell’immagine da mascherare.
+ `maskImage`: un’immagine in bianco e nero nella quale i pixel di colore nero puro indicano l’area all’interno della maschera e quelli di colore bianco puro indicano l’area all’esterno.
Per le richieste di inpainting, il modello modifica i pixel neri. Per le richieste di outpainting, vengono alterati i pixel bianchi.
+ `garmentBasedMask`: una maschera basata su un’immagine che definisce un’area da sostituire insieme ad alcune opzioni di stile limitate.
Puoi utilizzare uno strumento di editing per disegnare le maschere oppure crearle con un codice personalizzato. Altrimenti, utilizza il campo maskPrompt per consentire al modello di ricavare la maschera.
## Risoluzioni di immagini supportate
Puoi specificare qualsiasi risoluzione di output per un’attività di generazione purché soddisfi i seguenti requisiti:
+ Ogni lato deve avere una dimensione compresa tra 320 e 4.096 pixel, inclusi.
+ Ogni lato deve essere perfettamente divisibile per 16.
+ Le proporzioni devono essere comprese tra 1:4 e 4:1. Ciò significa che un lato non può essere più di 4 volte più lungo dell’altro.
+ Il numero totale di pixel deve essere inferiore a 4.194.304.
La maggior parte di questi limiti si applica anche alle immagini di input. Tuttavia, i lati delle immagini non devono essere perfettamente divisibili per 16.
# Prova virtuale
La *prova virtuale* è un caso d’uso di inpainting basato su immagini in cui il contenuto di un’immagine di riferimento viene sovrapposto a un’immagine di origine sulla base delle indicazioni di un’immagine maschera. Amazon Nova Canvas è stato ottimizzato per capi di abbigliamento, accessori, mobili e oggetti correlati. Il modello si applica bene anche ad altri casi, come l’aggiunta di un logo o di un testo in un’immagine.
Puoi generare fino a cinque immagini con l’API di prova virtuale. Per impostazione predefinita, viene generata una sola immagine.
Per eseguire una prova virtuale, devi fornire tre immagini:
+ *Immagine di origine*: l’immagine originale che desideri modificare. Ad esempio, può essere un’immagine, una persona o una scena in una stanza.
+ *Immagine di riferimento*: l’immagine che contiene l’articolo, l’oggetto o il capo che desideri sovrapporre all’immagine di origine. Ad esempio, può contenere una giacca, una ciotola o un divano. Per i capi di abbigliamento, l’immagine di riferimento può contenere i capi indossati o meno, nonché includere più prodotti che rappresentano componenti diversi di un outfit (come camicia, pantaloni e scarpe in un’unica immagine).
+ *Immagine maschera*: l’immagine che definisce quale parte dell’origine desideri modificare. Un’immagine maschera è un’immagine in bianco e nero utilizzata per definire l’area di origine da modificare. I pixel neri indicano l’area dell’immagine di origine da modificare, mentre quelli bianchi definiscono le aree da conservare. Puoi fornire la tua immagine maschera o lasciare che il modello ne crei una in base ad altri parametri di input forniti.
L’immagine maschera può essere restituita come parte dell’input, se specificato.
Ecco alcuni esempi di funzionamento del modello.
------
#### [ Upper body clothing ]
Le seguenti immagini mostrano un esempio di come Amazon Nova sovrappone un capo per la parte superiore del corpo su un modello.
| Immagine di origine | Immagine di riferimento | Output |
| --- |--- |--- |
| ![\[Un uomo con gli occhiali da sole che guarda a sinistra e indossa una maglia blu.\]](http://docs.aws.amazon.com/it_it/nova/latest/userguide/images/vto1_source.jpg) | ![\[Una camicia button-down color corallo.\]](http://docs.aws.amazon.com/it_it/nova/latest/userguide/images/vto1_ref.jpg) | ![\[Un uomo con gli occhiali da sole che guarda a sinistra e indossa una camicia button-down color corallo.\]](http://docs.aws.amazon.com/it_it/nova/latest/userguide/images/vto1_output.png) |
------
#### [ Couch in a room ]
Le seguenti immagini mostrano un esempio di come Amazon Nova sovrappone un divano in una stanza arredata.
| Immagine di origine | Immagine di riferimento | Output |
| --- |--- |--- |
| ![\[Un divano grigio midcentury moderno in una stanza, circondato da altre decorazioni.\]](http://docs.aws.amazon.com/it_it/nova/latest/userguide/images/vto2_source.jpg) | ![\[Un divano arancione su sfondo bianco.\]](http://docs.aws.amazon.com/it_it/nova/latest/userguide/images/vto2_ref.jpg) | ![\[Un divano arancione in una stanza, circondato da altre decorazioni.\]](http://docs.aws.amazon.com/it_it/nova/latest/userguide/images/vto2_output.png) |
------
A differenza di altri tipi di attività di Amazon Nova Canvas, la prova virtuale non supporta prompt di testo o prompt di testo negativi.
## Definizione dell’immagine maschera
Puoi fornire direttamente un’immagine maschera specificando `maskType: "IMAGE"` o consentire al modello di calcolarla automaticamente utilizzando input ausiliari come `maskType: "GARMENT"` o `maskType: "PROMPT"`.
Quando specifichi un tipo di maschera `"GARMENT"`, Amazon Nova Canvas crea una maschera sensibile ai capi di abbigliamento in base al valore del parametro di input `garmentClass` specificato. Nella maggior parte dei casi, puoi utilizzare una delle seguenti classi di abbigliamento di alto livello:
+ `"UPPER_BODY"`: crea una maschera che include l’intera lunghezza del braccio.
+ `"LOWER_BODY"`: crea una maschera che include l’intera lunghezza della gamba senza spazio tra le gambe.
+ `"FOOTWEAR"`: crea una maschera corrispondente al profilo delle scarpe presenti nell’immagine di origine.
+ `"FULL_BODY"`: crea una maschera equivalente alla combinazione di `"UPPER_BODY"` e `"LOWER_BODY"`.
Puoi utilizzare il tipo di maschera `"PROMPT"` al fine di usare il linguaggio naturale per descrivere l’elemento dell’immagine di origine da sostituire. Questa opzione è utile per gli scenari che non includono abbigliamento. Questa funzionalità utilizza la stessa capacità di mascheramento automatico presente nel tipo di attività `"INPAINTING"` tramite il parametro `maskPrompt`.
**avvertimento**
Le maschere create con il tipo `"PROMPT"` aderiranno strettamente alla forma dell’oggetto descritto. Questo aspetto può essere problematico in molti scenari, perché il prodotto che desideri aggiungere potrebbe non avere la stessa sagoma o le stesse dimensioni dell’oggetto da sostituire. Per questo motivo, l’API di prova virtuale fornisce anche un parametro `maskShape` facoltativo che può essere impostato su `"BOUNDING_BOX"`. Consigliamo di utilizzarla (è l’impostazione predefinita) nella maggior parte dei casi con il tipo di maschera `"PROMPT"`.
## Generazione di nuove pose, mani o volti
Puoi indicare al modello di mantenere o rigenerare la posa, le mani o il volto della persona presente nell’immagine di origine. Quando scegli di mantenerli, questi elementi vengono automaticamente rimossi dall’immagine maschera, a prescindere dal `maskType` scelto.
Nelle seguenti situazioni può essere opportuno mantenere posa, mani o volto:
+ Stai sviluppando un’applicazione che consente agli utenti finali di definire le proprie maschere. La conservazione di queste funzionalità impedisce agli utenti finali di includere per errore le mani o il volto nella maschera.
+ Utilizzi il parametro `maskShape: BOUNDING_BOX` ma non desideri generare nuove mani o un nuovo volto. Con `preserveFace: ON` o `preserveHands: ON`, queste funzionalità vengono automaticamente rimosse dalla maschera.
+ Utilizzi `maskType:GARMENT` e `maskShape: BOUNDING_BOX` con un modello che non è in posizione eretta. In questo caso, il riquadro di delimitazione della maschera può sovrapporsi al volto, quindi consigliamo di utilizzare `preserveFace: ON`.
Al contrario, nelle seguenti situazioni potresti voler rigenerare la posa, le mani o il volto:
+ Per i capi di abbigliamento che coprono il collo, `preserveFace: ON` può escludere una porzione abbastanza ampia del collo da avere un impatto negativo sull’output.
+ Quando la modella indossa scarpe con il tacco e l’immagine di riferimento è di scarpe basse o viceversa. In questo caso, mantenere la posa crea risultati innaturali.
+ Analogamente al punto precedente, quando si provano borse o altri accessori, la generazione di nuove pose o mani può garantire risultati più naturali.
## Indicazioni di stile
Il parametro `garmentStyling` consente di mantenere o modificare indicazioni di stile specifiche che potresti trovare in un servizio fotografico. Ad esempio, Amazon Nova Canvas può modificare lo stile di una camicia in modo che le maniche siano arrotolate o srotolate oppure può modificare la camicia in modo che sia infilata nei pantaloni o meno. Sono disponibili le seguenti opzioni:
+ `"longSleeveStyle"`: controlla se le maniche di un capo a maniche lunghe sono arrotolate o srotolate.
+ `"SLEEVE_DOWN"`: può essere applicato quando nell’immagine di origine viene indossato un capo a maniche lunghe (con maniche arrotolate o srotolate), un capo a maniche corte o un capo senza maniche.
+ `"SLEEVE_UP"`: può essere applicato quando nell’immagine di origine viene indossato un capo a maniche lunghe con le maniche arrotolate, un capo a maniche corte o senza maniche.
+ `"tuckingStyle"`: controlla se un capo per la parte superiore del corpo sembra essere infilato nei pantaloni o meno.
+ `"UNTUCKED"`: può essere applicato indipendentemente dal fatto che nell’immagine di origine sia presente un capo infilato o non infilato nei pantaloni.
+ `"TUCKED"`: può essere applicato quando nell’immagine di origine viene indossato un capo infilato nei pantaloni.
+ `"outerLayerStyle"`: controlla se un capo di abbigliamento per la parte superiore del corpo è aperto o chiuso. L’impostazione predefinita è `"CLOSED"`, adeguata per la maggior parte dei capi (come magliette e maglioni). Per i capi da indossare all’aperto, come le giacche, impostare questo valore su `"OPEN"` assicura che il capo per la parte superiore del corpo presente nell’immagine di origine venga mantenuto con sopra il nuovo capo da indossare all’aperto. L’uso del valore `"CLOSED"` con un capo da indossare all’aperto non sempre restituisce il capo chiuso. Ciò si verifica perché il valore `"CLOSED"` garantisce solamente che tutti i capi per la parte superiore del corpo nell’immagine di origine vengano sostituiti e talvolta può comportare uno strato esterno aperto con un nuovo strato inferiore visibile al di sotto.
+ `"CLOSED"`
+ `"OPEN"`
Per ulteriori informazioni, consultare i parametri `garmentStyling` nella pagina [Struttura di richieste e risposte per la generazione di immagini](image-gen-req-resp-structure.md).
## Unione di immagini
La prova virtuale consente di stabilire come le immagini vengono unite insieme per creare l’immagine finale. Puoi scegliere tra `"BALANCED"`, `"SEAMLESS"` e `"DETAILED"`. Ogni stile di fusione adotta un approccio diverso alla modalità di unione degli elementi per creare l’immagine finale, ognuno con i propri vantaggi e compromessi.
+ `"BALANCED"`: protegge i pixel non mascherati dell’immagine di origine, garantendo che rimangano accurati al 100% rispetto all’originale. In alcuni casi, sarà presente una discrepanza di colore o texture appena percepibile nell’immagine di output, che si presenta come una sorta di immagine “fantasma” della forma della maschera. È più probabile che ciò si verifichi quando nell’immagine è presente una persona di fronte a uno sfondo a tinta unita o con una texture uniforme. Per evitarlo, puoi utilizzare lo stile di fusione `"SEAMLESS"`.
+ `"SEAMLESS"`: garantisce che non vi sia mai una linea di unione evidente tra le aree mascherate e non nell’immagine finale. Il compromesso è che tutti i pixel dell’immagine cambiano leggermente e a volte i dettagli granulari vengono ridotti nelle aree non mascherate dell’immagine.
+ `"DETAILED"`: può migliorare notevolmente i dettagli granulari come loghi e testo, soprattutto quando l’area mascherata è relativamente piccola rispetto all’immagine complessiva. Il modello ottiene questo risultato eseguendo l’inpainting su una versione dell’immagine originale ben ritagliata e ad alta risoluzione che include solo l’area mascherata. In seguito, unisce il risultato all’immagine originale. Proprio come con la modalità `"BALANCED"`, a volte questo metodo può generare una linea di unione visibile.
# Stili grafici
Amazon Nova Canvas consente di generare immagini in una vasta gamma di stili predefiniti. Con il tipo di attività `"TEXT_TO_IMAGE"`, utilizza il parametro `style` per selezionare uno stile grafico predefinito. Puoi scegliere tra questi stili disponibili:
+ `"3D_ANIMATED_FAMILY_FILM"`: uno stile che richiama i film animati 3D. È caratterizzato da un rendering realistico e da personaggi con caratteristiche fisiche in stile cartone animato o esagerate. Questo stile è in grado di produrre immagini incentrare su personaggi, su oggetti oppure oggetti di scena, su ambienti o scenari sia di interni che di esterni.
+ `"DESIGN_SKETCH"`: uno stile che presenta disegni al tratto senza molti strati o riempimenti e poco raffinata. Questo stile viene utilizzato per trasmettere concetti e idee. È utile per bozzetti di moda e per il design di prodotti, nonché per schizzi architettonici.
+ `"FLAT_VECTOR_ILLUSTRATION"`: uno stile di illustrazione con colori uniformi popolare nelle comunicazioni aziendali. È utile anche per immagini di icone e clip art.
+ `"GRAPHIC_NOVEL_ILLUSTRATION"`: uno stile di illustrazione a inchiostro vivace. I personaggi non hanno caratteristiche esagerate, come in altri stili più simili ai cartoni animati.
+ `"MAXIMALISM"`: vivace, elaborato, audace e complesso con forme forti e dettagli ricchi. Questo stile può essere applicato a una vasta gamma di soggetti, come illustrazioni, fotografia, design di interni, grafica o design di packaging.
+ `"MIDCENTURY_RETRO"`: richiama le tendenze grafiche dagli anni ‘40 agli anni ‘60.
+ `"PHOTOREALISM"`: stile fotografico realistico, che include diversi repertori come fotografia stock, fotografia editoriale, fotografia giornalistica e altro ancora. Questo stile è caratterizzato da illuminazione realistica, profondità di campo e composizione adatti al repertorio. Gli esseri umani sono i soggetti più comuni, ma possono essere raffigurati anche animali, paesaggi e altri elementi naturali.
+ `"SOFT_DIGITAL_PAINTING"`: questo stile ha una finitura più definita ed è più rifinito di un bozzetto. Include ombreggiatura, tridimensionalità e texture che potrebbero non essere presenti in altri stili.
**Nota**
Amazon Nova Canvas non si limita agli stili presenti in questo elenco. Puoi ottenere molti altri stili grafici omettendo il parametro `style` e descrivendo lo stile desiderato all’interno del prompt. Facoltativamente, puoi utilizzare il parametro `negativeText` per allontanare ulteriormente le caratteristiche dello stile da risultati indesiderati.
Le seguenti immagini mostrano la stessa immagine generata in ciascuno degli stili descritti in precedenza.
## Film animato 3D per famiglie
![\[L’immagine ritrae un elefante nello stile “film animato 3D per famiglie”.\]](http://docs.aws.amazon.com/it_it/nova/latest/userguide/images/3D_ANIMATED_FAMILY_FILM.png)
## Bozzetto
![\[L’immagine ritrae un elefante nello stile “bozzetto”.\]](http://docs.aws.amazon.com/it_it/nova/latest/userguide/images/DESIGN_SKETCH.png)
## Illustrazione vettoriale piatta
![\[L’immagine ritrae un elefante nello stile “illustrazione vettoriale piatta”.\]](http://docs.aws.amazon.com/it_it/nova/latest/userguide/images/FLAT_VECTOR_ILLUSTRATION.png)
## Illustrazione di graphic novel
![\[L’immagine ritrae un elefante nello stile “illustrazione di graphic novel”.\]](http://docs.aws.amazon.com/it_it/nova/latest/userguide/images/GRAPHIC_NOVEL_ILLUSTRATION.png)
## Massimalismo
![\[L’immagine ritrae un elefante nello stile “massimalismo”.\]](http://docs.aws.amazon.com/it_it/nova/latest/userguide/images/MAXIMALISM.png)
## Retrò midcentury
![\[L’immagine ritrae un elefante nello stile “retrò midcentury”.\]](http://docs.aws.amazon.com/it_it/nova/latest/userguide/images/MIDCENTURY_RETRO.png)
## Fotorealismo
![\[L’immagine ritrae un elefante nello stile “fotorealismo”.\]](http://docs.aws.amazon.com/it_it/nova/latest/userguide/images/PHOTOREALISM.png)
## Pittura digitale delicata
![\[L’immagine ritrae un elefante nello stile “pittura digitale delicata”.\]](http://docs.aws.amazon.com/it_it/nova/latest/userguide/images/SOFT_DIGITAL_PAINTING.png)
# Struttura di richieste e risposte per la generazione di immagini
**Generazione di immagini**
I seguenti esempi presentano diversi casi d’uso di generazione di immagini. Ogni esempio fornisce una spiegazione dei campi utilizzati per la generazione di immagini.
------
#### [ Text-to-image request ]
```
{
"taskType": "TEXT_IMAGE",
"textToImageParams": {
"text": string,
"negativeText": string,
"style": "3D_ANIMATED_FAMILY_FILM" |
"DESIGN_SKETCH" | "FLAT_VECTOR_ILLUSTRATION" |
"GRAPHIC_NOVEL_ILLUSTRATION" | "MAXIMALISM" |
"MIDCENTURY_RETRO" | "PHOTOREALISM" |
"SOFT_DIGITAL_PAINTING"
},
"imageGenerationConfig": {
"width": int,
"height": int,
"quality": "standard" | "premium",
"cfgScale": float,
"seed": int,
"numberOfImages": int
}
}
```
In questa richiesta vengono utilizzati i seguenti campi `textToImageParams`:
+ `text` (obbligatorio): un prompt di testo per generare l’immagine. La lunghezza del prompt deve essere compresa tra 1 e 1.024 caratteri.
+ `negativeText` (facoltativo): un prompt di testo per definire cosa non includere nell’immagine. Questo valore deve avere una lunghezza compresa tra 1 e 1.024 caratteri.
+ `style` (facoltativo): specifica lo stile utilizzato per generare l’immagine. Per ulteriori informazioni, consulta [Stili grafici](image-gen-styles.md).
**Nota**
Evita di utilizzare parole di negazione (“no”, “non”, “senza”, ecc.) nei valori `text` e `negativeText`. Ad esempio, se non desideri che siano presenti specchi in un’immagine, non includere “no specchi” o “senza specchi” nel campo `text`, ma usa la parola “specchi” nel campo `negativeText`.
------
#### [ Text-to-image request with image conditioning ]
```
{
"taskType": "TEXT_IMAGE",
"textToImageParams": {
"conditionImage": string (Base64 encoded image),
"controlMode": "CANNY_EDGE" | "SEGMENTATION",
"controlStrength": float,
"text": string,
"negativeText": string,
"style": "3D_ANIMATED_FAMILY_FILM" |
"DESIGN_SKETCH" | "FLAT_VECTOR_ILLUSTRATION" |
"GRAPHIC_NOVEL_ILLUSTRATION" | "MAXIMALISM" |
"MIDCENTURY_RETRO" | "PHOTOREALISM" |
"SOFT_DIGITAL_PAINTING"
},
"imageGenerationConfig": {
"width": int,
"height": int,
"quality": "standard" | "premium",
"cfgScale": float,
"seed": int,
"numberOfImages": int
}
}
```
In questa richiesta vengono utilizzati i seguenti campi `textToImageParams`:
+ `conditionImage` (obbligatorio): un’immagine JPEG o PNG che determina il layout e la composizione dell’immagine generata. L’immagine deve essere formattata come stringa Base64. Consulta [Immagini di input per la generazione di immagini](image-gen-access.md#image-gen-input-images) per i requisiti aggiuntivi.
+ `controlMode` (facoltativo): specifica la modalità di condizionamento da utilizzare. Il valore predefinito è “CANNY\$1EDGE”.
+ `CANNY_EDGE`: gli elementi dell’immagine generata seguiranno con precisione i contorni evidenti, o “bordi”, dell’immagine di condizionamento.
+ `SEGMENTATION`: l’immagine di condizionamento sarà analizzata automaticamente per identificare le forme dai contorni evidenti. Questa analisi produce una maschera di segmentazione che guida la generazione e porta a un’immagine generata che segue da vicino il layout dell’immagine di condizionamento, ma lascia al modello una maggiore libertà entro i limiti di ciascuna area di contenuto.
+ `controlStrength` (facoltativo): specifica quanto simili alla `conditionImage` devono essere il layout e la composizione dell’immagine generata. L’intervallo è compreso tra 0 e 1,0 e valori più bassi introducono più casualità. Il valore predefinito è 0,7.
+ `text` (obbligatorio): un prompt di testo per generare l’immagine. La lunghezza del prompt deve essere compresa tra 1 e 1.024 caratteri.
+ `negativeText` (facoltativo): un prompt di testo per definire cosa non includere nell’immagine. Questo valore deve avere una lunghezza compresa tra 1 e 1.024 caratteri.
+ `style` (facoltativo): specifica lo stile utilizzato per generare l’immagine. Per ulteriori informazioni, consulta [Stili grafici](image-gen-styles.md).
**Nota**
Evita di utilizzare parole di negazione (“no”, “non”, “senza”, ecc.) nei valori `text` e `negativeText`. Ad esempio, se non desideri che siano presenti specchi in un’immagine, non includere “no specchi” o “senza specchi” nel campo `text`, ma usa la parola “specchi” nel campo `negativeText`.
------
#### [ Color guided image generation request ]
```
{
"taskType": "COLOR_GUIDED_GENERATION",
"colorGuidedGenerationParams": {
"colors": string[] (list of hexadecimal color values),
"referenceImage": string (Base64 encoded image),
"text": string,
"negativeText": string
},
"imageGenerationConfig": {
"width": int,
"height": int,
"quality": "standard" | "premium",
"cfgScale": float,
"seed": int,
"numberOfImages": int
}
}
```
In questa richiesta vengono utilizzati i seguenti campi `colorGuidedGenerationParams`:
+ `colors` (obbligatorio): un elenco di un massimo di 10 codici colore che definiscono la palette di colori desiderata per l’immagine. I valori devono essere espressi in valori esadecimali nel formato “\$1RRGGBB”. Ad esempio, "\$100FF00" è verde puro e «\$1 FCF2 AB» è un giallo caldo. L’elenco `colors` ha un effetto maggiore quando non viene fornita una `referenceImage`. In caso contrario, nell’output finale saranno utilizzati sia i colori nell’elenco che i colori dell’immagine di riferimento.
+ `referenceImage` (facoltativo): un’immagine JPEG o PNG da utilizzare come riferimento per soggetto e stile. I colori dell’immagine saranno inoltre inseriti nell’output finale insieme ai colori dell’elenco `colors`. Consulta la sezione [Immagini di input per la generazione di immagini](image-gen-access.md#image-gen-input-images) per i requisiti aggiuntivi.
+ `text` (obbligatorio): un prompt di testo per generare l’immagine. La lunghezza del prompt deve essere compresa tra 1 e 1.024 caratteri.
+ `negativeText` (facoltativo): un prompt di testo per definire cosa non includere nell’immagine. Questo valore deve avere una lunghezza compresa tra 1 e 1.024 caratteri.
**Nota**
Evita di utilizzare parole di negazione (“no”, “non”, “senza”, ecc.) nei valori `text` e `negativeText`. Ad esempio, se non desideri che siano presenti specchi in un’immagine, non includere “no specchi” o “senza specchi” nel campo `text`, ma usa la parola “specchi” nel campo `negativeText`.
------
#### [ Image variation request ]
```
{
"taskType": "IMAGE_VARIATION",
"imageVariationParams": {
"images": string[] (list of Base64 encoded images),
"similarityStrength": float,
"text": string,
"negativeText": string
},
"imageGenerationConfig": {
"height": int,
"width": int,
"cfgScale": float,
"seed": int,
"numberOfImages": int
}
}
```
In questa richiesta vengono utilizzati i seguenti campi `imageVariationParams`:
+ `images` (obbligatorio): un elenco di 1-5 immagini da utilizzare come riferimento. Ciascuna deve essere in formato JPEG o PNG e codificata come stringa Base64. Consulta la sezione [Immagini di input per la generazione di immagini](image-gen-access.md#image-gen-input-images) per i requisiti aggiuntivi.
+ `similarityStrength` (facoltativo): specifica quanto l’immagine generata deve essere simile alle immagini di input. I valori validi sono compresi tra 0,2-1,0 e i valori più bassi sono utilizzati per introdurre una casualità maggiore.
+ `text` (obbligatorio): un prompt di testo per generare l’immagine. La lunghezza del prompt deve essere compresa tra 1 e 1.024 caratteri. Se ometti questo campo, il modello rimuoverà gli elementi presenti all’interno dell’area mascherata e li sostituirà con una naturale estensione dello sfondo dell’immagine.
+ `negativeText` (facoltativo): un prompt di testo per definire cosa non includere nell’immagine. Questo valore deve avere una lunghezza compresa tra 1 e 1.024 caratteri.
**Nota**
Evita di utilizzare parole di negazione (“no”, “non”, “senza”, ecc.) nei valori `text` e `negativeText`. Ad esempio, se non desideri che siano presenti specchi in un’immagine, non includere “no specchi” o “senza specchi” nel campo `text`, ma usa la parola “specchi” nel campo `negativeText`.
------
**Editing di immagini**
I seguenti esempi presentano diversi casi d’uso di editing di immagini. Ogni esempio fornisce una spiegazione dei campi utilizzati per l’editing di immagini.
------
#### [ Inpainting request ]
```
{
"taskType": "INPAINTING",
"inPaintingParams": {
"image": string (Base64 encoded image),
"maskPrompt": string,
"maskImage": string (Base64 encoded image),
"text": string,
"negativeText": string
},
"imageGenerationConfig": {
"numberOfImages": int,
"quality": "standard" | "premium",
"cfgScale": float,
"seed": int
}
}
```
In questa richiesta vengono utilizzati i seguenti campi `inPaintingParams`:
+ `image` (obbligatorio): il file JPEG o PNG che desideri modificare, formattato come stringa Base64. Consulta la sezione [Immagini di input per la generazione di immagini](image-gen-access.md#image-gen-input-images) per i requisiti aggiuntivi.
+ `maskPrompt` o `maskImage` (obbligatorio): devi specificare il parametro `maskPrompt` o `maskImage`, ma non entrambi.
`maskPrompt` è un prompt di testo in linguaggio naturale che descrive le aree dell’immagine da modificare.
`maskImage` è un’immagine che definisce le aree dell’immagine da modificare. L’immagine maschera deve avere le stesse dimensioni dell’immagine di input. Le aree da modificare sono di colore nero puro, mentre quelle da ignorare sono di colore bianco puro. Non è consentito utilizzare altri colori nell’immagine maschera.
Tieni presente che le richieste di inpainting e outpainting sono opposte relativamente ai requisiti di colore per le immagini maschera.
+ `text` (obbligatorio): un prompt di testo che descrive cosa generare all’interno dell’area mascherata. La lunghezza del prompt deve essere compresa tra 1 e 1.024 caratteri. Se ometti questo campo, il modello rimuoverà gli elementi presenti all’interno dell’area mascherata e li sostituirà con una naturale estensione dello sfondo dell’immagine.
+ `negativeText` (facoltativo): un prompt di testo per definire cosa non includere nell’immagine. Questo valore deve avere una lunghezza compresa tra 1 e 1.024 caratteri.
**Nota**
Evita di utilizzare parole di negazione (“no”, “non”, “senza”, ecc.) nei valori `text` e `negativeText`. Ad esempio, se non desideri che siano presenti specchi in un’immagine, non includere “no specchi” o “senza specchi” nel campo `text`, ma usa la parola “specchi” nel campo `negativeText`.
------
#### [ Outpainting request ]
```
{
"taskType": "OUTPAINTING",
"outPaintingParams": {
"image": string (Base64 encoded image),
"maskPrompt": string,
"maskImage": string (Base64 encoded image),
"outPaintingMode": "DEFAULT" | "PRECISE",
"text": string,
"negativeText": string
},
"imageGenerationConfig": {
"numberOfImages": int,
"quality": "standard" | "premium",
"cfgScale": float,
"seed": int
}
}
```
In questa richiesta vengono utilizzati i seguenti campi `outPaintingParams`:
+ `image` (obbligatorio): il file JPEG o PNG che desideri modificare, formattato come stringa Base64. Consulta la sezione [Immagini di input per la generazione di immagini](image-gen-access.md#image-gen-input-images) per i requisiti aggiuntivi.
+ `maskPrompt` o `maskImage` (obbligatorio): devi specificare il parametro `maskPrompt` o `maskImage`, ma non entrambi.
`maskPrompt` è un prompt di testo in linguaggio naturale che descrive le aree dell’immagine da modificare.
`maskImage` è un’immagine che definisce le aree dell’immagine da modificare. L’immagine maschera deve avere le stesse dimensioni dell’immagine di input. Le aree da modificare sono di colore nero puro, mentre quelle da ignorare sono di colore bianco puro. Non è consentito utilizzare altri colori nell’immagine maschera.
Tieni presente che le richieste di inpainting e outpainting sono opposte relativamente ai requisiti di colore per le immagini maschera.
+ `outPaintingMode`: determina il modo in cui viene interpretata la maschera fornita.
Utilizza `DEFAULT` per creare una transizione fluida tra l’area mascherata e quella non mascherata. Alcuni dei pixel originali vengono utilizzati come punto di partenza per il nuovo sfondo. In genere, questa modalità produce risultati migliori quando il nuovo sfondo deve utilizzare colori simili a quello originale. Tuttavia, potresti ottenere un effetto alone se il prompt richiede un nuovo sfondo con differenze significative rispetto a quello originale.
Utilizza `PRECISE` per rispettare rigorosamente i limiti della maschera. In genere, questa modalità produce i risultati migliori quando apporti modifiche significative allo sfondo.
+ `text` (obbligatorio): un prompt di testo che descrive cosa generare all’interno dell’area mascherata. La lunghezza del prompt deve essere compresa tra 1 e 1.024 caratteri. Se ometti questo campo, il modello rimuoverà gli elementi presenti all’interno dell’area mascherata e li sostituirà con una naturale estensione dello sfondo dell’immagine.
+ `negativeText` (facoltativo): un prompt di testo per definire cosa non includere nell’immagine. Questo valore deve avere una lunghezza compresa tra 1 e 1.024 caratteri.
**Nota**
Evita di utilizzare parole di negazione (“no”, “non”, “senza”, ecc.) nei valori `text` e `negativeText`. Ad esempio, se non desideri che siano presenti specchi in un’immagine, non includere “no specchi” o “senza specchi” nel campo `text`, ma usa la parola “specchi” nel campo `negativeText`.
------
#### [ Background removal request ]
```
{
"taskType": "BACKGROUND_REMOVAL",
"backgroundRemovalParams": {
"image": string (Base64 encoded image)
}
}
```
In questa richiesta viene utilizzato il seguente campo `backgroundRemovalParams`:
+ `image` (obbligatorio): il file JPEG o PNG che desideri modificare, formattato come stringa Base64. Consulta la sezione [Immagini di input per la generazione di immagini](image-gen-access.md#image-gen-input-images) per i requisiti aggiuntivi.
L’operazione `BACKGROUND_REMOVAL` restituirà un’immagine PNG con trasparenza completa a 8 bit. Questo formato offre un isolamento uniforme e pulito degli oggetti in primo piano e semplifica la composizione dell’immagine con altri elementi in un’app di editing di immagini, in una presentazione o in un sito web. Lo sfondo può essere facilmente modificato in un colore a tinta unita utilizzando un codice personalizzato.
------
#### [ Virtual try-on ]
```
{
"taskType": "VIRTUAL_TRY_ON",
"virtualTryOnParams": {
"sourceImage": string (Base64 encoded image),
"referenceImage": string (Base64 encoded image),
"maskType": "IMAGE" | "GARMENT" | "PROMPT",
"imageBasedMask":{
"maskImage": string (Base64 encoded image),
},
"garmentBasedMask":{
"maskShape": "CONTOUR" | "BOUNDING_BOX" | "DEFAULT",
"garmentClass": "UPPER_BODY" | "LOWER_BODY" |
"FULL_BODY" | "FOOTWEAR" | "LONG_SLEEVE_SHIRT" |
"SHORT_SLEEVE_SHIRT" | "NO_SLEEVE_SHIRT" |
"OTHER_UPPER_BODY" | "LONG_PANTS" | "SHORT_PANTS" |
"OTHER_LOWER_BODY" | "LONG_DRESS" | "SHORT_DRESS" |
"FULL_BODY_OUTFIT" | "OTHER_FULL_BODY" | "SHOES" |
"BOOTS" | "OTHER_FOOTWEAR",
"garmentStyling":{
"longSleeveStyle": "SLEEVE_DOWN" | "SLEEVE_UP",
"tuckingStyle": "UNTUCKED" | "TUCKED",
"outerLayerStyle": "CLOSED" | "OPEN",
}
},
"promptBasedMask":{
"maskShape": "BOUNDING_BOX" | "CONTOUR" | "DEFAULT",
"maskPrompt": string,
},
"maskExclusions": {
"preserveBodyPose": "ON" | "OFF" | "DEFAULT",
"preserveHands": "ON" | "OFF" | "DEFAULT",
"preserveFace": "OFF" | "ON" | "DEFAULT"
},
"mergeStyle" : "BALANCED" | "SEAMLESS" | "DETAILED" ,
"returnMask": boolean,
},
"imageGenerationConfig": {
"numberOfImages": int,
"quality": "standard" | "premium",
"cfgScale": float,
"seed": int
}
}
```
In questa richiesta vengono utilizzati i seguenti campi `virtualTryOnParams`:
+ `sourceImage` (obbligatorio): il file JPEG o PNG che desideri modificare, formattato come stringa Base64. Consulta [Immagini di input per la generazione di immagini](image-gen-access.md#image-gen-input-images) per i requisiti aggiuntivi.
+ `referenceImage` (obbligatorio): il file JPEG o PNG che contiene l’oggetto che desideri sovrapporre all’immagine di origine, formattato come stringa Base64. Consulta [Immagini di input per la generazione di immagini](image-gen-access.md#image-gen-input-images) per i requisiti aggiuntivi.
+ `maskType` (obbligatorio): specifica se la maschera viene fornita come immagine, prompt o maschera per capi di abbigliamento.
+ `imageBasedMask`: obbligatorio quando `maskType` è `"IMAGE"`.
`maskImage` è un’immagine che definisce le aree dell’immagine da modificare. L’immagine maschera deve avere le stesse dimensioni dell’immagine di input. Le aree da modificare sono di colore nero puro, mentre quelle da ignorare sono di colore bianco puro. Non è consentito utilizzare altri colori nell’immagine maschera.
+ `garmentBasedMask`: obbligatorio quando `maskType` è `"GARMENT"`.
+ `maskShape` (facoltativo): definisce la forma del riquadro di delimitazione della maschera. La forma e le dimensioni del riquadro di delimitazione possono influire sul modo in cui l’immagine di riferimento viene trasferita nell’immagine di origine.
+ `garmentClass` (obbligatorio): definisce il capo di abbigliamento da trasferire. Questo parametro consente al modello di concentrarsi su parti specifiche dell’immagine di riferimento che desideri trasferire.
+ `garmentStyling`: offre indicazioni di stile al modello per determinati capi di abbigliamento. I parametri `longSleeveStyle` e `tuckingStyle` si applicano solo ai capi per la parte superiore del corpo. Il parametro `outerLayerStyle` si applica solo ai capi per la parte superiore del corpo indossati come strato esterno.
+ `promptBasedMask` (obbligatorio): obbligatorio quando `maskType` è `"PROMPT"`.
+ `maskShape` (facoltativo): definisce la forma del riquadro di delimitazione della maschera. La forma e le dimensioni del riquadro di delimitazione possono influire sul modo in cui l’immagine di riferimento viene trasferita in quella di origine.
+ `maskPrompt` (obbligatorio): un prompt di testo in linguaggio naturale che descrive le aree dell’immagine da modificare.
+ `maskExclusions` (facoltativo): quando viene rilevata una persona nell’immagine di origine, questi parametri stabiliscono se la posa del corpo, le mani e il volto devono essere mantenuti nell’immagine di output o rigenerati.
+ `mergeStyle` (facoltativo): determina la modalità di unione delle immagini di origine e di riferimento. Ogni stile di fusione adotta un approccio diverso alla modalità di unione degli elementi per creare l’immagine finale, ognuno con i propri vantaggi e compromessi.
+ `"BALANCED"`: protegge i pixel non mascherati dell’immagine di origine, garantendo che rimangano accurati al 100% rispetto all’originale. In alcuni casi, sarà presente una discrepanza di colore o texture appena percepibile nell’immagine di output, che si presenta come una sorta di immagine “fantasma” della forma della maschera. È più probabile che ciò si verifichi quando nell’immagine è presente una persona di fronte a uno sfondo a tinta unita o con una texture uniforme. Per evitarlo, puoi utilizzare lo stile di fusione `"SEAMLESS"`.
+ `"SEAMLESS"`: garantisce che non vi sia mai una linea di unione evidente tra le aree mascherate e non nell’immagine finale. Il compromesso è che questa modalità comporta una leggera modifica di tutti i pixel dell’immagine e, a volte, una riduzione dei dettagli granulari nelle aree non mascherate dell’immagine.
+ `"DETAILED"`: può migliorare notevolmente i dettagli granulari come loghi e testo, soprattutto quando l’area mascherata è relativamente piccola rispetto all’immagine complessiva. Il modello ottiene questo risultato eseguendo l’inpainting su una versione dell’immagine originale ben ritagliata e ad alta risoluzione che include solo l’area mascherata. In seguito, unisce il risultato all’immagine originale. Proprio come con la modalità `"BALANCED"`, a volte questo metodo può generare una linea di unione visibile.
+ `returnMask` (facoltativo): specifica se l’immagine maschera deve essere restituita insieme all’immagine di output.
------
**Corpo di risposta**
Il corpo della risposta conterrà uno o più campi indicati di seguito:
```
{
"images": "images": string[] (list of Base64 encoded images),
"maskImage": string (Base64 encoded image),
"error": string
}
```
+ `images`: in caso di operazione riuscita, viene restituito un elenco di stringhe codificate in Base64 che rappresentano ogni immagine generata. Tale elenco non contiene sempre lo stesso numero di immagini richiesto. Le singole immagini potrebbero essere bloccate dopo la generazione se non sono in linea con la politica di moderazione dei contenuti di AWS Responsible AI (RAI). Vengono restituite solo le immagini che rispettano la policy RAI.
+ `maskImage`: quando specifichi che l’immagine maschera deve essere restituita insieme all’output, la maschera viene restituita in questo campo.
+ `error`: se un’immagine non è in linea con la policy RAI, viene restituito questo campo. In caso contrario, questo campo viene omesso dalla risposta.
Il campo `imageGenerationConfig` è comune a tutti i tipi di attività, a eccezione di `BACKGROUND_REMOVAL`. È facoltativo e contiene i seguenti campi. Se ometti questo oggetto, vengono utilizzate le configurazioni predefinite.
+ `width` e `height` (facoltativo): definiscono le dimensioni e le proporzioni dell’immagine generata. L’impostazione predefinita di entrambi è 1.024.
Non devi fornire i valori `width` e `height` per i tipi di attività `"INPAINTING"`, `"OUTPAINTING"` o `"VIRTUAL_TRY_ON"`.
Per l’elenco completo delle risoluzioni supportate, consulta [Risoluzioni di immagini supportate](image-gen-access.md#image-gen-resolutions).
+ `quality` (facoltativo): specifica la qualità da utilizzare quando generi l’immagine, ovvero “standard” (impostazione predefinita) o “premium”.
+ `cfgScale` (facoltativo): specifica quanto rigorosamente il modello deve rispettare il prompt. I valori vanno da 1,1 a 10 (inclusi) e il valore predefinito è 6,5.
+ Valori bassi (1,1-3): maggiore libertà creativa per l’IA, risultati potenzialmente più estetici, ma con basso contrasto e meno rispettosi del prompt.
+ Valori medi (4-7): approccio equilibrato, consigliati solitamente per la maggior parte delle generazioni.
+ Valori alti (8-10): rispetto rigoroso del prompt, che può produrre risultati più precisi, ma a discapito, a volte, dell’estetica naturale e con una saturazione di colori maggiore.
+ `numberOfImages` (facoltativo): il numero di immagini da generare.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/nova/latest/userguide/image-gen-req-resp-structure.html)
+ `seed` (facoltativo): determina l’impostazione iniziale del rumore per il processo di generazione. Modificando il valore di seed e lasciando tutti gli altri parametri invariati, verrà prodotta un’immagine completamente nuova che rispetta comunque il prompt, le dimensioni e le altre impostazioni. È comune sperimentare con diversi valori di seed per trovare l’immagine perfetta.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/nova/latest/userguide/image-gen-req-resp-structure.html)
**Importante**
I parametri di risoluzione (`width` e `height`), `numberOfImages` e `quality` hanno tutti un impatto sul tempo richiesto per completare la generazione. L’ AWS SDK ha un `read_timeout` predefinito di 60 secondi, che può essere facilmente superato quando si utilizzano valori elevati per i parametri indicati in precedenza. Pertanto, si consiglia di aumentare il `read_timeout` delle chiamate di invocazione ad almeno 5 minuti (300 secondi). Gli esempi di codice dimostrano come eseguire questa operazione.
# Gestione degli errori
I principali tipi di errore da gestire nel codice dell’applicazione sono tre, ovvero errori di convalida dell’input, errori di deviazione dell’input per IA responsabile (RAI) di AWS ed errori di deviazione dell’output per RAI. Questi errori si verificano unicamente in Amazon Nova Canvas.
Gli errori di convalida dell’input si verificano quando utilizzi un valore non supportato come parametro di input. Ad esempio, un valore di larghezza non corrispondente a una delle risoluzioni supportate, un’immagine di input che supera le dimensioni massime consentite o una `maskImage` che contiene colori diversi da bianco e nero puro. Tutti gli errori di convalida dell’input sono espressi come una `ValidationException` che contiene una stringa di messaggio che descrive la causa del problema.
Gli errori di deviazione dell'input RAI si verificano quando si stabilisce che uno qualsiasi dei valori di testo o delle immagini immessi viola la politica dell'IA responsabile. AWS Questi errori sono espressi come una `ValidationException` con uno dei seguenti messaggi:
+ Messaggio di convalida per gli input di testo: “Questa richiesta è stata bloccata dai nostri filtri di contenuti. Modifica il prompt di testo per inviare una nuova richiesta”.
+ Messaggio di convalida per gli input con immagini: “Questa richiesta è stata bloccata dai nostri filtri di contenuti. Modifica l’immagine di input per inviare una nuova richiesta”.
Gli errori di deflessione dell'uscita RAI si verificano quando viene generata un'immagine, ma questa non è allineata con la politica dell'IA responsabile. AWS Quando si verifica questo tipo di errore, non viene utilizzata un’eccezione. Viene invece restituita una risposta con esito positivo, e la sua struttura contiene un campo di errore costituito da una stringa con uno dei seguenti valori:
+ Se tutte le immagini richieste violano la policy di RAI: “Tutte le immagini generate sono state bloccate dai nostri filtri di contenuti”.
+ Se alcune delle immagini richieste, ma non tutte, violano la policy di RAI: “Alcune delle immagini generate sono state bloccate dai nostri filtri di contenuti”.
# Esempi di codice
I seguenti esempi forniscono codice di esempio per diverse attività di generazione di immagini.
------
#### [ Text to image generation ]
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate an image from a text prompt with the Amazon Nova Canvas model (on demand).
"""
import base64
import io
import json
import logging
import boto3
from PIL import Image
from botocore.config import Config
from botocore.exceptions import ClientError
class ImageError(Exception):
"Custom exception for errors returned by Amazon Nova Canvas"
def __init__(self, message):
self.message = message
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_image(model_id, body):
"""
Generate an image using Amazon Nova Canvas model on demand.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
image_bytes (bytes): The image generated by the model.
"""
logger.info(
"Generating image with Amazon Nova Canvas model %s", model_id)
bedrock = boto3.client(
service_name='bedrock-runtime',
config=Config(read_timeout=300)
)
accept = "application/json"
content_type = "application/json"
response = bedrock.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=content_type
)
response_body = json.loads(response.get("body").read())
base64_image = response_body.get("images")[0]
base64_bytes = base64_image.encode('ascii')
image_bytes = base64.b64decode(base64_bytes)
finish_reason = response_body.get("error")
if finish_reason is not None:
raise ImageError(f"Image generation error. Error is {finish_reason}")
logger.info(
"Successfully generated image with Amazon Nova Canvas model %s", model_id)
return image_bytes
def main():
"""
Entrypoint for Amazon Nova Canvas example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = 'amazon.nova-canvas-v1:0'
prompt = """A photograph of a cup of coffee from the side."""
body = json.dumps({
"taskType": "TEXT_IMAGE",
"textToImageParams": {
"text": prompt
},
"imageGenerationConfig": {
"numberOfImages": 1,
"height": 1024,
"width": 1024,
"cfgScale": 8.0,
"seed": 0
}
})
try:
image_bytes = generate_image(model_id=model_id,
body=body)
image = Image.open(io.BytesIO(image_bytes))
image.show()
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred:", message)
print("A client error occured: " +
format(message))
except ImageError as err:
logger.error(err.message)
print(err.message)
else:
print(
f"Finished generating image with Amazon Nova Canvas model {model_id}.")
if __name__ == "__main__":
main()
```
------
#### [ Inpainting ]
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to use inpainting to generate an image from a source image with
the Amazon Nova Canvas model (on demand).
The example uses a mask prompt to specify the area to inpaint.
"""
import base64
import io
import json
import logging
import boto3
from PIL import Image
from botocore.config import Config
from botocore.exceptions import ClientError
class ImageError(Exception):
"Custom exception for errors returned by Amazon Nova Canvas"
def __init__(self, message):
self.message = message
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_image(model_id, body):
"""
Generate an image using Amazon Nova Canvas model on demand.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
image_bytes (bytes): The image generated by the model.
"""
logger.info(
"Generating image with Amazon Nova Canvas model %s", model_id)
bedrock = boto3.client(
service_name='bedrock-runtime',
config=Config(read_timeout=300)
)
accept = "application/json"
content_type = "application/json"
response = bedrock.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=content_type
)
response_body = json.loads(response.get("body").read())
base64_image = response_body.get("images")[0]
base64_bytes = base64_image.encode('ascii')
image_bytes = base64.b64decode(base64_bytes)
finish_reason = response_body.get("error")
if finish_reason is not None:
raise ImageError(f"Image generation error. Error is {finish_reason}")
logger.info(
"Successfully generated image with Amazon Nova Canvas model %s", model_id)
return image_bytes
def main():
"""
Entrypoint for Amazon Nova Canvas example.
"""
try:
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = 'amazon.nova-canvas-v1:0'
# Read image from file and encode it as base64 string.
with open("/path/to/image", "rb") as image_file:
input_image = base64.b64encode(image_file.read()).decode('utf8')
body = json.dumps({
"taskType": "INPAINTING",
"inPaintingParams": {
"text": "Modernize the windows of the house",
"negativeText": "bad quality, low res",
"image": input_image,
"maskPrompt": "windows"
},
"imageGenerationConfig": {
"numberOfImages": 1,
"height": 512,
"width": 512,
"cfgScale": 8.0
}
})
image_bytes = generate_image(model_id=model_id,
body=body)
image = Image.open(io.BytesIO(image_bytes))
image.show()
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
except ImageError as err:
logger.error(err.message)
print(err.message)
else:
print(
f"Finished generating image with Amazon Nova Canvas model {model_id}.")
if __name__ == "__main__":
main()
```
------
#### [ Outpainting ]
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to use outpainting to generate an image from a source image with
the Amazon Nova Canvas model (on demand).
The example uses a mask image to outpaint the original image.
"""
import base64
import io
import json
import logging
import boto3
from PIL import Image
from botocore.config import Config
from botocore.exceptions import ClientError
class ImageError(Exception):
"Custom exception for errors returned by Amazon Nova Canvas"
def __init__(self, message):
self.message = message
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_image(model_id, body):
"""
Generate an image using Amazon Nova Canvas model on demand.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
image_bytes (bytes): The image generated by the model.
"""
logger.info(
"Generating image with Amazon Nova Canvas model %s", model_id)
bedrock = boto3.client(
service_name='bedrock-runtime',
config=Config(read_timeout=300)
)
accept = "application/json"
content_type = "application/json"
response = bedrock.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=content_type
)
response_body = json.loads(response.get("body").read())
base64_image = response_body.get("images")[0]
base64_bytes = base64_image.encode('ascii')
image_bytes = base64.b64decode(base64_bytes)
finish_reason = response_body.get("error")
if finish_reason is not None:
raise ImageError(f"Image generation error. Error is {finish_reason}")
logger.info(
"Successfully generated image with Amazon Nova Canvas model %s", model_id)
return image_bytes
def main():
"""
Entrypoint for Amazon Nova Canvas example.
"""
try:
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = 'amazon.nova-canvas-v1:0'
# Read image and mask image from file and encode as base64 strings.
with open("/path/to/image", "rb") as image_file:
input_image = base64.b64encode(image_file.read()).decode('utf8')
with open("/path/to/mask_image", "rb") as mask_image_file:
input_mask_image = base64.b64encode(
mask_image_file.read()).decode('utf8')
body = json.dumps({
"taskType": "OUTPAINTING",
"outPaintingParams": {
"text": "Draw a chocolate chip cookie",
"negativeText": "bad quality, low res",
"image": input_image,
"maskImage": input_mask_image,
"outPaintingMode": "DEFAULT"
},
"imageGenerationConfig": {
"numberOfImages": 1,
"height": 512,
"width": 512,
"cfgScale": 8.0
}
}
)
image_bytes = generate_image(model_id=model_id,
body=body)
image = Image.open(io.BytesIO(image_bytes))
image.show()
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
except ImageError as err:
logger.error(err.message)
print(err.message)
else:
print(
f"Finished generating image with Amazon Nova Canvas model {model_id}.")
if __name__ == "__main__":
main()
```
------
#### [ Image variation ]
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate an image variation from a source image with the
Amazon Nova Canvas model (on demand).
"""
import base64
import io
import json
import logging
import boto3
from PIL import Image
from botocore.config import Config
from botocore.exceptions import ClientError
class ImageError(Exception):
"Custom exception for errors returned by Amazon Nova Canvas"
def __init__(self, message):
self.message = message
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_image(model_id, body):
"""
Generate an image using Amazon Nova Canvas model on demand.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
image_bytes (bytes): The image generated by the model.
"""
logger.info(
"Generating image with Amazon Nova Canvas model %s", model_id)
bedrock = boto3.client(
service_name='bedrock-runtime',
config=Config(read_timeout=300)
)
accept = "application/json"
content_type = "application/json"
response = bedrock.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=content_type
)
response_body = json.loads(response.get("body").read())
base64_image = response_body.get("images")[0]
base64_bytes = base64_image.encode('ascii')
image_bytes = base64.b64decode(base64_bytes)
finish_reason = response_body.get("error")
if finish_reason is not None:
raise ImageError(f"Image generation error. Error is {finish_reason}")
logger.info(
"Successfully generated image with Amazon Nova Canvas model %s", model_id)
return image_bytes
def main():
"""
Entrypoint for Amazon Nova Canvas example.
"""
try:
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = 'amazon.nova-canvas-v1:0'
# Read image from file and encode it as base64 string.
with open("/path/to/image", "rb") as image_file:
input_image = base64.b64encode(image_file.read()).decode('utf8')
body = json.dumps({
"taskType": "IMAGE_VARIATION",
"imageVariationParams": {
"text": "Modernize the house, photo-realistic, 8k, hdr",
"negativeText": "bad quality, low resolution, cartoon",
"images": [input_image],
"similarityStrength": 0.7, # Range: 0.2 to 1.0
},
"imageGenerationConfig": {
"numberOfImages": 1,
"height": 512,
"width": 512,
"cfgScale": 8.0
}
})
image_bytes = generate_image(model_id=model_id,
body=body)
image = Image.open(io.BytesIO(image_bytes))
image.show()
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
except ImageError as err:
logger.error(err.message)
print(err.message)
else:
print(
f"Finished generating image with Amazon Nova Canvas model {model_id}.")
if __name__ == "__main__":
main()
```
------
#### [ Image conditioning ]
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate image conditioning from a source image with the
Amazon Nova Canvas model (on demand).
"""
import base64
import io
import json
import logging
import boto3
from PIL import Image
from botocore.config import Config
from botocore.exceptions import ClientError
class ImageError(Exception):
"Custom exception for errors returned by Amazon Nova Canvas"
def __init__(self, message):
self.message = message
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_image(model_id, body):
"""
Generate an image using Amazon Nova Canvas model on demand.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
image_bytes (bytes): The image generated by the model.
"""
logger.info(
"Generating image with Amazon Nova Canvas model %s", model_id)
bedrock = boto3.client(
service_name='bedrock-runtime',
config=Config(read_timeout=300)
)
accept = "application/json"
content_type = "application/json"
response = bedrock.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=content_type
)
response_body = json.loads(response.get("body").read())
base64_image = response_body.get("images")[0]
base64_bytes = base64_image.encode('ascii')
image_bytes = base64.b64decode(base64_bytes)
finish_reason = response_body.get("error")
if finish_reason is not None:
raise ImageError(f"Image generation error. Error is {finish_reason}")
logger.info(
"Successfully generated image with Amazon Nova Canvas model %s", model_id)
return image_bytes
def main():
"""
Entrypoint for Amazon Nova Canvas example.
"""
try:
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = 'amazon.nova-canvas-v1:0'
# Read image from file and encode it as base64 string.
with open("/path/to/image", "rb") as image_file:
input_image = base64.b64encode(image_file.read()).decode('utf8')
body = json.dumps({
"taskType": "TEXT_IMAGE",
"textToImageParams": {
"text": "A robot playing soccer, anime cartoon style",
"negativeText": "bad quality, low res",
"conditionImage": input_image,
"controlMode": "CANNY_EDGE"
},
"imageGenerationConfig": {
"numberOfImages": 1,
"height": 512,
"width": 512,
"cfgScale": 8.0
}
})
image_bytes = generate_image(model_id=model_id,
body=body)
image = Image.open(io.BytesIO(image_bytes))
image.show()
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
except ImageError as err:
logger.error(err.message)
print(err.message)
else:
print(
f"Finished generating image with Amazon Nova Canvas model {model_id}.")
if __name__ == "__main__":
main()
```
------
#### [ Color guided content ]
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate an image from a source image color palette with the
Amazon Nova Canvas model (on demand).
"""
import base64
import io
import json
import logging
import boto3
from PIL import Image
from botocore.config import Config
from botocore.exceptions import ClientError
class ImageError(Exception):
"Custom exception for errors returned by Amazon Nova Canvas"
def __init__(self, message):
self.message = message
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_image(model_id, body):
"""
Generate an image using Amazon Nova Canvas model on demand.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
image_bytes (bytes): The image generated by the model.
"""
logger.info(
"Generating image with Amazon Nova Canvas model %s", model_id)
bedrock = boto3.client(
service_name='bedrock-runtime',
config=Config(read_timeout=300)
)
accept = "application/json"
content_type = "application/json"
response = bedrock.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=content_type
)
response_body = json.loads(response.get("body").read())
base64_image = response_body.get("images")[0]
base64_bytes = base64_image.encode('ascii')
image_bytes = base64.b64decode(base64_bytes)
finish_reason = response_body.get("error")
if finish_reason is not None:
raise ImageError(f"Image generation error. Error is {finish_reason}")
logger.info(
"Successfully generated image with Amazon Nova Canvas model %s", model_id)
return image_bytes
def main():
"""
Entrypoint for Amazon Nova Canvas example.
"""
try:
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = 'amazon.nova-canvas-v1:0'
# Read image from file and encode it as base64 string.
with open("/path/to/image", "rb") as image_file:
input_image = base64.b64encode(image_file.read()).decode('utf8')
body = json.dumps({
"taskType": "COLOR_GUIDED_GENERATION",
"colorGuidedGenerationParams": {
"text": "digital painting of a girl, dreamy and ethereal, pink eyes, peaceful expression, ornate frilly dress, fantasy, intricate, elegant, rainbow bubbles, highly detailed, digital painting, artstation, concept art, smooth, sharp focus, illustration",
"negativeText": "bad quality, low res",
"referenceImage": input_image,
"colors": ["#ff8080", "#ffb280", "#ffe680", "#ffe680"]
},
"imageGenerationConfig": {
"numberOfImages": 1,
"height": 512,
"width": 512,
"cfgScale": 8.0
}
})
image_bytes = generate_image(model_id=model_id,
body=body)
image = Image.open(io.BytesIO(image_bytes))
image.show()
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
except ImageError as err:
logger.error(err.message)
print(err.message)
else:
print(
f"Finished generating image with Amazon Nova Canvas model {model_id}.")
if __name__ == "__main__":
main()
```
------
#### [ Background removal ]
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate an image with background removal with the
Amazon Nova Canvas model (on demand).
"""
import base64
import io
import json
import logging
import boto3
from PIL import Image
from botocore.config import Config
from botocore.exceptions import ClientError
class ImageError(Exception):
"Custom exception for errors returned by Amazon Nova Canvas"
def __init__(self, message):
self.message = message
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_image(model_id, body):
"""
Generate an image using Amazon Nova Canvas model on demand.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
image_bytes (bytes): The image generated by the model.
"""
logger.info(
"Generating image with Amazon Nova Canvas model %s", model_id)
bedrock = boto3.client(
service_name='bedrock-runtime',
config=Config(read_timeout=300)
)
accept = "application/json"
content_type = "application/json"
response = bedrock.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=content_type
)
response_body = json.loads(response.get("body").read())
base64_image = response_body.get("images")[0]
base64_bytes = base64_image.encode('ascii')
image_bytes = base64.b64decode(base64_bytes)
finish_reason = response_body.get("error")
if finish_reason is not None:
raise ImageError(f"Image generation error. Error is {finish_reason}")
logger.info(
"Successfully generated image with Amazon Nova Canvas model %s", model_id)
return image_bytes
def main():
"""
Entrypoint for Amazon Nova Canvas example.
"""
try:
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = 'amazon.nova-canvas-v1:0'
# Read image from file and encode it as base64 string.
with open("/path/to/image", "rb") as image_file:
input_image = base64.b64encode(image_file.read()).decode('utf8')
body = json.dumps({
"taskType": "BACKGROUND_REMOVAL",
"backgroundRemovalParams": {
"image": input_image,
}
})
image_bytes = generate_image(model_id=model_id,
body=body)
image = Image.open(io.BytesIO(image_bytes))
image.show()
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
except ImageError as err:
logger.error(err.message)
print(err.message)
else:
print(
f"Finished generating image with Amazon Nova Canvas model {model_id}.")
if __name__ == "__main__":
main()
```
------