Salt la conținutul principal
Română— Alege o limbă
Meniu

Combinați generarea de imagini cu alte instrumente API

Lecția 10 din 12 Actualizată 2 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Combinați generarea de imagini cu alte instrumente API
  2. Lăsați un model lingvistic să scrie promptul
  3. Ilustrați un articol cap-coadă
  4. Descrieți o imagine pentru a o regenera diferit
  5. Procesarea unor volume mari în loturi
  6. Publicarea directă în stocare
  7. Ce menține un pipeline funcțional

Actualizare 2 noiembrie 2026 — Modele de imagini. gpt-image-1, modelul pentru care a fost scris inițial acest curs, a fost întrerupt la 23 octombrie 2026. gpt-image-1.5, gpt-image-1-mini și chatgpt-image-latest vor fi retrase la 1 decembrie 2026. Exemplele folosesc acum gpt-image-2.5-sunburst, care oferă cea mai mare precizie pentru editare; gpt-image-2.5-flare este mai rapid pentru generarea standard. Ambele modele suportă, de asemenea, setările de calitate xhigh și max. Modelele GPT Image returnează întotdeauna imagini în base64: parametrul response_format de la modelele DALL·E mai vechi nu este suportat și a fost eliminat din cod. Sursă: Generarea de imagini (OpenAI).

Combinați generarea de imagini cu alte instrumente API

Luată izolat, generarea de imagini este un instrument meșteșugăresc: scrieți un prompt, obțineți un fișier. Puterea sa reală emerge atunci când devine o etapă într-un lanț automatizat—un model lingvistic ce scrie promptul, o analiză vizuală ce descrie o imagine de referință sau un sistem de stocare care publică rezultatul. Această lecție vă arată cum să interconectați aceste componente.

Lăsați un model lingvistic să scrie promptul

Utilizatorii sau colegii dumneavoastră nu scriu prompturi vizuale; ei scriu brief-uri. „Am nevoie de o imagine pentru un articol despre IA în sănătate, futurist dar uman“ nu conține nicio indicație despre compoziție, lumină sau paletă de culori. În loc să le cereți să învețe vocabularul din lecția anterioară, introduceți un model lingvistic pentru a gestiona traducerea. Atribuiți-i rolul de director artistic în mesajul de sistem și cereți-i să producă straturile specifice ale promptului, cu instrucțiuni stricte de a nu outputa nimic altceva. Altfel, veți primi o explicație politicoasă pe care apoi va trebui să o trimiteți către GPT Image.

from openai import OpenAI
import base64

client = OpenAI()

def text_to_image(brief: str, output: str):
    """
    Pipeline în doi pași:
    1. Un LLM generează promptul vizual optim
    2. GPT Image creează imaginea
    """
    # Pasul 1: Generarea promptului vizual cu 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"Generated prompt: {visual_prompt[:100]}...")

    # Pasul 2: Generarea imaginii
    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"Image generated: {output}")
    return visual_prompt


prompt = text_to_image(
    "I need an image for an article on artificial intelligence "
    "in healthcare. Futuristic but human.",
    "ai_health.png"
)

Ilustrați un articol cap-coadă

Un articol de fond necesită o imagine de copertă și o ilustrație pentru fiecare secțiune. Aceste imagini trebuie să pară coerente fără a fi identice. Funcția illustrate_article aplică această logică reinjectând stilul în fiecare prompt și repetând titlul articolului de fiecare dată, oferind întregului set o unitate tematică. Două detalii de economisire a costurilor merită atenție: coperta este generată la calitate high deoarece toată lumea o vede și este adesea distribuită, în timp ce ilustrațiile secțiunilor rămân la medium deoarece sunt afișate mai mic și mai jos pe pagină. Pentru cele cinci secțiuni din acest exemplu despre IA în recrutare, acest compromis reduce factura fără ca cititorul să observe ceva.

from openai import OpenAI
import base64
import json

client = OpenAI()

def illustrate_article(title: str, sections: list[str], style: str, output_dir: str = "."):
    """
    Generează o ilustrație de antet + una per secțiune.
    """
    results = []

    # Imagine de copertă
    header_prompt = (
        f"Cover image for an article titled \"{title}\", "
        f"{style} style, panoramic composition, "
        "no text in the image, professional"
    )

    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"Header: {path}")

    # Ilustrații pentru secțiuni
    for i, section in enumerate(sections):
        section_prompt = (
            f"Illustration for the section \"{section}\" "
            f"of an article on \"{title}\", "
            f"{style} style, rectangular format, "
            "conceptual illustration without text"
        )

        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"Section {i+1} ({section[:30]}...) : {path}")

    return results


illustrate_article(
    title="5 Ways AI Is Transforming Recruitment",
    sections=[
        "Automatic CV Screening",
        "AI-Analyzed Video Interviews",
        "Smart Candidate-Job Matching",
        "Reducing Recruitment Bias",
        "Personalized Onboarding",
    ],
    style="3D isometric illustration, blue and violet tones",
    output_dir="."
)

Descrieți o imagine pentru a o regenera diferit

Cum obțineți o versiune de iarnă a unui peisaj de vară când aveți doar fișierul, fără mască și fără instrumente de editare? Treceți prin limbaj. Viziunea modelului analizează imaginea și produce o descriere suficient de precisă pentru a servi drept prompt de reconstrucție—subiect, compoziție, lumină, culori, stil, perspectivă, atmosferă. Apoi concatenați instrucțiunea de modificare la această descriere. Modelul de generare primește un prompt textual complet în care doar anotimpul s-a schimbat, iar dumneavoastră obțineți o imagine coerentă cu originalul, nu ceva nelegat. Aceasta este, de asemenea, cea mai fiabilă metodă de a reproduce identitatea vizuală a unei imagini de referință pe care nu o puteți edita direct.

from openai import OpenAI
import base64

client = OpenAI()

def analyze_and_vary(image_path: str, instruction: str, output: str):
    """
    1. Analizează o imagine cu GPT Vision
    2. Generează o variantă bazată pe analiză
    """
    # Pasul 1: Analiza imaginii
    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"Analysis: {description[:150]}...")

    # Pasul 2: Generarea unei variante modificate
    variant_prompt = f"{description}. Requested modification: {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"Variant generated: {output}")


analyze_and_vary(
    "original_landscape.png",
    "Change the season from summer to winter, with snow on roofs and trees",
    "winter_landscape.png"
)

Procesarea unor volume mari în loturi

Generarea a cinci vizuale de produs în serie durează minute; generarea a cinci sute secvențial durează toată noaptea și se blochează la prima problemă de rețea. Configurația de mai jos rezolvă ambele probleme. Fiecare sarcină este un dicționar autonom care conține ID-ul său, promptul, fișierul de ieșire și setările. Funcția worker încadrează apelul într-un bloc try care returnează un status în loc să blocheze întregul lot: o generare respinsă nu mai trage după sine celelalte patru sute nouăzeci și nouă. ThreadPoolExecutor paralelizează apoi execuția, dar cu un max_workers deliberat scăzut—trei în acest exemplu—deoarece gâtul de sticlă nu este mașina dumneavoastră, ci cotele API. Raportul final numără succesele și erorile, astfel încât să știți ce trebuie reluat.

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:
    """Generează o singură imagine dintr-o sarcină."""
    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):
    """Execută un lot de generări cu paralelism controlat."""
    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']}")

    # Raport
    ok = sum(1 for r in results if r["status"] == "ok")
    errors = sum(1 for r in results if r["status"] == "error")
    print(f"\nFinished: {ok} ok, {errors} errors out of {len(tasks)} tasks")

    return results


# Definirea unui lot de sarcini
tasks = [
    {
        "id": f"product_{i}",
        "prompt": f"E-commerce product photo: {product}, white background, studio",
        "output": f"batch_product_{i}.png",
        "quality": "high"
    }
    for i, product in enumerate([
        "rose gold watch",
        "aviator sunglasses",
        "braided leather bracelet",
        "solitaire diamond ring",
        "cultured pearl necklace",
    ])
]

results = batch_generation(tasks, max_parallel=3)

Publicarea directă în stocare

Scrierea PNG-ului pe discul mașinii care rulează scriptul are sens doar în dezvoltare. În producție, imaginea trebuie să ajungă acolo de unde site-ul dumneavoastră o va prelua, iar ocolirea prin sistemul de fișiere local devine un punct de eșec inutil. Formatul b64_json se pretează bine la această eliminare: octeții decodați sunt înveliți într-un obiect BytesIO și împinși direct în bucket, cu un ContentType explicit—fără de care browserele ar oferi descărcarea în loc să afișeze imaginea. Funcția returnează URL-ul public, ceea ce are nevoie de fapt CMS-ul dumneavoastră.

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):
    """Generează o imagine și o încarcă direct în 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"Image stored on S3: {url}")
    return url


# Exemplu
url = generate_and_store_s3(
    "Mobile app icon: open book with stars, flat design",
    "my-image-bucket",
    "generated/app_icon_v1.png"
)

Ce menține un pipeline funcțional

Cele cinci pipeline-uri din această lecție împărtășesc aceeași igienă de construcție. Fiecare pas face un singur lucru, permițându-vă să înlocuiți scrierea promptului sau stocarea fără a atinge restul. Fiecare pas își gestionează propriile erori; altfel, un refuz de moderare la mijlocul unui lot ar doborî întregul lanț—exact ceea ce previne blocul try din generate_one_image. Paralelismul rămâne limitat pentru a respecta limitele de rată, iar în acest punct, prudența costă mai puțin decât recuperarea după o interzicere temporară.

Două obiceiuri mai puțin vizibile, dar la fel de decisive, rămân. Înregistrați în jurnal (log) prompturile trimise efectiv, în special când sunt scrise de un model lingvistic: fără acest jurnal, o imagine pe care o apreciați devine ireproductibilă la a doua rulare. Și stocați în cache rezultatele ori de câte ori același prompt ar putea reveni, ceea ce lecția următoare va formaliza într-un sistem complet.

Acum asamblați propriul lanț complet: acesta primește un titlu de articol ca intrare, cere unui model lingvistic trei descrieri ale vizualelor relevante, generează cele trei imagini în paralel și produce un JSON rezumat care leagă fiecare prompt de fișierul său. Veți avea apoi tot ce este necesar pentru a ilustra un întreg blog fără intervenție manuală.