Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Combinare la generazione di immagini con altri strumenti API

Lezione 10 di 12 Aggiornata il 2 novembre 2026 Sviluppatore
In questa pagina
  1. Combinare la generazione di immagini con altri strumenti API
  2. Far scrivere il prompt a un modello linguistico
  3. Illustrare un articolo da capo a fondo
  4. Descrivere un’immagine per rigenerarla diversamente
  5. Elaborare grandi volumi in batch
  6. Pubblicare direttamente sullo storage
  7. Cosa mantiene in piedi una pipeline

Aggiornamento 2 novembre 2026 — Modelli immagine. gpt-image-1, il modello per cui era stato originariamente scritto questo corso, è stato dismesso il 23 ottobre 2026. gpt-image-1.5, gpt-image-1-mini e chatgpt-image-latest verranno ritirati il 1° dicembre 2026. Gli esempi ora utilizzano gpt-image-2.5-sunburst, che offre la massima precisione per il fotoritocco; gpt-image-2.5-flare è più veloce per la generazione standard. Entrambi i modelli supportano anche le impostazioni di qualità xhigh e max. I modelli GPT Image restituiscono sempre le immagini in base64: il parametro response_format dei vecchi modelli DALL·E non è supportato ed è stato rimosso dal codice. Fonte: Image generation (OpenAI).

Combinare la generazione di immagini con altri strumenti API

Isolata, la generazione di immagini è uno strumento artigianale: scrivi un prompt, ottieni un file. Il suo vero potere emerge quando diventa un anello di una catena automatizzata: un modello linguistico che scrive il prompt, un’analisi visiva che descrive un’immagine di riferimento o un sistema di storage che pubblica il risultato. Questa lezione ti mostra come collegare questi pezzi.

Far scrivere il prompt a un modello linguistico

I tuoi utenti o colleghi non scrivono prompt visivi; scrivono brief. «Mi serve un’immagine per un articolo sull’IA in ambito sanitario, futuristico ma umano» non contiene composizione, illuminazione o palette. Invece di chiedere loro di imparare il vocabolario della lezione precedente, inserisci un modello linguistico per gestire la traduzione. Assegnagli il ruolo di direttore artistico nel messaggio di sistema e imponigli di produrre i livelli specifici del prompt, con istruzioni rigorose di non outputtare nient’altro. Altrimenti, riceverai una spiegazione gentile che dovrai poi inviare a GPT Image.

from openai import OpenAI
import base64

client = OpenAI()

def text_to_image(brief: str, output: str):
    """
    Pipeline in due passaggi:
    1. Un LLM genera il prompt visivo ottimale
    2. GPT Image crea l'immagine
    """
    # Passaggio 1: Generare il prompt visivo con un LLM
    completion = client.chat.completions.create(
        model="gpt-5.6-luna",
        messages=[
            {
                "role": "system",
                "content": (
                    "You are an expert art director. "
                    "Based on a brief, generate a detailed prompt for an "
                    "image generation model. Include: subject, composition, lighting, "
                    "style, perspective, color palette. "
                    "Respond only with the prompt, no explanation."
                )
            },
            {"role": "user", "content": brief}
        ]
    )

    visual_prompt = completion.choices[0].message.content
    print(f"Prompt generato: {visual_prompt[:100]}...")

    # Passaggio 2: Generare l'immagine
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=visual_prompt,
        size="1536x1024",
        quality="high",
    )

    data = base64.b64decode(response.data[0].b64_json)
    with open(output, "wb") as f:
        f.write(data)
    print(f"Immagine generata: {output}")
    return visual_prompt


prompt = text_to_image(
    "Mi serve un'immagine per un articolo sull'intelligenza artificiale "
    "in ambito sanitario. Futuristico ma umano.",
    "ai_health.png"
)

Illustrare un articolo da capo a fondo

Un articolo di approfondimento richiede un’immagine di copertina e un’illustrazione per sezione. Queste immagini devono apparire coerenti senza essere identiche. La funzione illustrate_article applica questa logica reiniettando lo stile in ogni prompt e ripetendo il titolo dell’articolo ogni volta, conferendo unità tematica all’intero set. Due dettagli per risparmiare sui costi meritano attenzione: la copertina viene generata in qualità high perché tutti la vedono e viene spesso condivisa, mentre le illustrazioni delle sezioni restano in medium dato che vengono visualizzate più piccole e in basso nella pagina. Per le cinque sezioni di questo esempio sull’IA nel recruiting, questo compromesso riduce la fattura senza che il lettore noti alcuna differenza.

from openai import OpenAI
import base64
import json

client = OpenAI()

def illustrate_article(title: str, sections: list[str], style: str, output_dir: str = "."):
    """
    Genera un'illustrazione di intestazione + una per sezione.
    """
    results = []

    # Immagine di copertina
    header_prompt = (
        f"Immagine di copertina per un articolo intitolato \"{title}\", "
        f"stile {style}, composizione panoramica, "
        "nessun testo nell'immagine, professionale"
    )

    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=header_prompt,
        size="1536x1024",
        quality="high",
    )

    path = f"{output_dir}/header.png"
    data = base64.b64decode(response.data[0].b64_json)
    with open(path, "wb") as f:
        f.write(data)
    results.append({"type": "header", "path": path})
    print(f"Intestazione: {path}")

    # Illustrazioni delle sezioni
    for i, section in enumerate(sections):
        section_prompt = (
            f"Illustrazione per la sezione \"{section}\" "
            f"di un articolo su \"{title}\", "
            f"stile {style}, formato rettangolare, "
            "illustrazione concettuale senza testo"
        )

        response = client.images.generate(
            model="gpt-image-2.5-sunburst",
            prompt=section_prompt,
            size="1536x1024",
            quality="medium",
        )

        path = f"{output_dir}/section_{i+1}.png"
        data = base64.b64decode(response.data[0].b64_json)
        with open(path, "wb") as f:
            f.write(data)
        results.append({"type": f"section_{i+1}", "section": section, "path": path})
        print(f"Sezione {i+1} ({section[:30]}...) : {path}")

    return results


illustrate_article(
    title="5 Modi in cui l'IA sta trasformando il Recruiting",
    sections=[
        "Screening automatico dei CV",
        "Colloqui video analizzati dall'IA",
        "Matching intelligente Candidato-Lavoro",
        "Riduzione dei bias nel recruiting",
        "Onboarding personalizzato",
    ],
    style="Illustrazione isometrica 3D, toni blu e violetti",
    output_dir="."
)

Descrivere un’immagine per rigenerarla diversamente

Come ottenere una versione invernale di un paesaggio estivo quando hai solo il file, nessuna maschera e nessuno strumento di editing? Passa attraverso il linguaggio. La visione del modello analizza l’immagine e produce una descrizione abbastanza precisa da servire come prompt di ricostruzione: soggetto, composizione, illuminazione, colori, stile, prospettiva, atmosfera. Concateni poi la tua istruzione di modifica a questa descrizione. Il modello di generazione riceve un prompt testuale completo in cui è cambiata solo la stagione, e ottieni un’immagine coerente con l’originale piuttosto che qualcosa di scollegato. Questo è anche il modo più affidabile per riprodurre l’identità visiva di un’immagine di riferimento che non puoi modificare direttamente.

from openai import OpenAI
import base64

client = OpenAI()

def analyze_and_vary(image_path: str, instruction: str, output: str):
    """
    1. Analizza un'immagine con GPT Vision
    2. Genera una variante basata sull'analisi
    """
    # Passaggio 1: Analizzare l'immagine
    with open(image_path, "rb") as f:
        image_b64 = base64.b64encode(f.read()).decode()

    analysis = client.chat.completions.create(
        model="gpt-5.6-luna",
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": (
                            "Describe this image in detail so an image "
                            "generation model can reproduce it faithfully. "
                            "Include: subject, composition, lighting, colors, style, "
                            "perspective, mood. Be very precise."
                        )
                    },
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/png;base64,{image_b64}"
                        }
                    }
                ]
            }
        ]
    )

    description = analysis.choices[0].message.content
    print(f"Analisi: {description[:150]}...")

    # Passaggio 2: Generare una variante modificata
    variant_prompt = f"{description}. Modifica richiesta: {instruction}"

    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=variant_prompt,
        size="1024x1024",
        quality="high",
    )

    data = base64.b64decode(response.data[0].b64_json)
    with open(output, "wb") as f:
        f.write(data)
    print(f"Variante generata: {output}")


analyze_and_vary(
    "original_landscape.png",
    "Cambia la stagione da estate a inverno, con neve sui tetti e sugli alberi",
    "winter_landscape.png"
)

Elaborare grandi volumi in batch

Generare cinque visual di prodotto in serie richiede minuti; generarne cinquecento in sequenza richiede tutta la notte e si blocca al primo intoppo di rete. La configurazione seguente risolve entrambi i problemi. Ogni task è un dizionario autonomo che trasporta il proprio ID, prompt, file di output e impostazioni. La funzione worker avvolge la chiamata in un blocco try che restituisce uno stato invece di far crollare l’intero batch: una generazione rifiutata non trascina giù anche le altre quattrocentonovantanove. Il ThreadPoolExecutor parallelizza quindi l’esecuzione, ma con un max_workers volutamente basso — tre in questo esempio — perché il collo di bottiglia non è la tua macchina, sono le quote API. Il report finale conta successi e fallimenti così sai cosa ritentare.

from openai import OpenAI
import base64
import json
import time
from concurrent.futures import ThreadPoolExecutor, as_completed

client = OpenAI()

def generate_one_image(task: dict) -> dict:
    """Genera una singola immagine da un task."""
    try:
        response = client.images.generate(
            model="gpt-image-2.5-sunburst",
            prompt=task["prompt"],
            size=task.get("size", "1024x1024"),
            quality=task.get("quality", "medium"),
        )

        data = base64.b64decode(response.data[0].b64_json)
        with open(task["output"], "wb") as f:
            f.write(data)

        return {"id": task["id"], "status": "ok", "path": task["output"]}

    except Exception as e:
        return {"id": task["id"], "status": "error", "error": str(e)}


def batch_generation(tasks: list[dict], max_parallel: int = 3):
    """Esegue un batch di generazioni con parallelismo controllato."""
    results = []

    with ThreadPoolExecutor(max_workers=max_parallel) as executor:
        futures = {
            executor.submit(generate_one_image, task): task
            for task in tasks
        }

        for future in as_completed(futures):
            result = future.result()
            results.append(result)
            status = result["status"]
            print(f"  [{status}] {result['id']}")

    # Report
    ok = sum(1 for r in results if r["status"] == "ok")
    errors = sum(1 for r in results if r["status"] == "error")
    print(f"\nTerminato: {ok} ok, {errors} errori su {len(tasks)} task")

    return results


# Definire un batch di task
tasks = [
    {
        "id": f"product_{i}",
        "prompt": f"Foto prodotto e-commerce: {product}, sfondo bianco, studio",
        "output": f"batch_product_{i}.png",
        "quality": "high"
    }
    for i, product in enumerate([
        "orologio oro rosa",
        "occhiali da sole aviator",
        "bracciale in pelle intrecciata",
        "anello con diamante solitario",
        "collana di perle coltivate",
    ])
]

results = batch_generation(tasks, max_parallel=3)

Pubblicare direttamente sullo storage

Scrivere il PNG sul disco della macchina che esegue lo script ha senso solo in sviluppo. In produzione, l’immagine deve atterrare dove il tuo sito la recupererà, e deviare attraverso il file system locale diventa un punto di guasto inutile. Il formato b64_json si presta bene a questa rimozione: i byte decodificati vengono avvolti in un oggetto BytesIO e spinti direttamente nel bucket, con un ContentType esplicito — senza il quale i browser offrirebbero un download invece di visualizzare l’immagine. La funzione restituisce l’URL pubblico, che è ciò di cui il tuo CMS ha effettivamente bisogno.

from openai import OpenAI
import base64
import boto3
from io import BytesIO

client = OpenAI()

def generate_and_store_s3(prompt: str, bucket: str, key: str):
    """Genera un'immagine e la carica direttamente su S3."""
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size="1024x1024",
        quality="high",
    )

    image_data = base64.b64decode(response.data[0].b64_json)

    s3 = boto3.client("s3")
    s3.upload_fileobj(
        BytesIO(image_data),
        bucket,
        key,
        ExtraArgs={"ContentType": "image/png"}
    )

    url = f"https://{bucket}.s3.amazonaws.com/{key}"
    print(f"Immagine archiviata su S3: {url}")
    return url


# Esempio
url = generate_and_store_s3(
    "Icona app mobile: libro aperto con stelle, flat design",
    "my-image-bucket",
    "generated/app_icon_v1.png"
)

Cosa mantiene in piedi una pipeline

Le cinque pipeline di questa lezione condividono la stessa igiene costruttiva. Ogni passaggio fa una cosa sola, permettendoti di sostituire la scrittura del prompt o lo storage senza toccare il resto. Ogni passaggio gestisce i propri errori; altrimenti, un rifiuto di moderazione nel mezzo di un batch abbatte l’intera catena — è esattamente ciò che il try in generate_one_image previene. Il parallelismo rimane limitato per rispettare i rate limit, e su questo punto, la cautela costa meno del recupero dopo un ban temporaneo.

Restano due abitudini meno visibili ma altrettanto decisive. Registra i prompt effettivamente inviati, specialmente quando scritti da un modello linguistico: senza questo log, un’immagine che ami diventa irriproducibile alla seconda esecuzione. E cached i risultati ogni volta che lo stesso prompt potrebbe tornare, cosa che la prossima lezione formalizzerà in un sistema completo.

Ora assembla la tua catena completa: prende in input il titolo di un articolo, chiede a un modello linguistico tre descrizioni di visual pertinenti, genera le tre immagini in parallelo e produce un JSON riassuntivo che collega ogni prompt al suo file. Avrai allora tutto il necessario per illustrare un intero blog senza intervento manuale.