Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Variációk és iterációk

5. lecke 12 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Variációk és iterációk
  2. Ugyanazon koncepció variációinak generálása
  3. Variációk a prompt módosításával
  4. Iteráció a prompt finomításával
  5. Automatizált iterációs folyamat (Pipeline)
  6. Variációk összehasonlítása egy katalógusban
  7. Az iteráció fegyelme

Frissítve: 2026. november 2. — Képmodellek. A gpt-image-1 modellt, amelyre ezt a tananyagot eredetileg írtuk, 2026. október 23-án megszüntették. Továbbá a gpt-image-1.5, gpt-image-1-mini és a chatgpt-image-latest modellek is kivezetésre kerülnek 2026. december 1-jén. A példák most a gpt-image-2.5-sunburst modellt használják, amely a legnagyobb pontosságot kínálja szerkesztéshez; a gpt-image-2.5-flare pedig gyorsabb az általános generálásnál. Mindkét modell támogatja az xhigh és max minőségi beállításokat is. A GPT Image modellek mindig base64 formátumban adják vissza a képeket: a régebbi DALL·E modellekből ismert response_format paramétert már nem fogadják el, és eltávolítottuk a kódból. Forrás: Képgenerálás (OpenAI).

Variációk és iterációk

Ritka, hogy első próbálkozásra tökéletes képet kapj. A valódi munka a variációk generálásából, összehasonlításából, majd a prompt (utasítás) fokozatos szigorításából áll, amíg el nem éred a kívánt eredményt. Ez a lecke három eszközt ad a kezedbe ehhez a módszerhez: variáció újrafuttatással, variáció a prompt módosításával, valamint iteráció egymást követő finomítással.

Ugyanazon koncepció variációinak generálása

A legegyszerűbb módszer, ha ugyanazzal a prompttal újra lefuttatod a generálást: a GPT Image minden alkalommal eltérő eredményt produkál. Ez a felfedezés kezdeti szakaszában hasznos, amikor még nem tudod pontosan, mit keresel, és látni szeretnéd egy ötlet lehetséges értelmezéseinek széles skáláját.

from openai import OpenAI
import base64

client = OpenAI()

def generate_variations(prompt: str, n_variations: int, prefix: str):
    """Generate several independent variations of the same prompt."""
    paths = []
    for i in range(n_variations):
        response = client.images.generate(
            model="gpt-image-2.5-sunburst",
            prompt=prompt,
            size="1024x1024",
            quality="medium",
        )

        path = f"{prefix}_v{i+1}.png"
        data = base64.b64decode(response.data[0].b64_json)
        with open(path, "wb") as f:
            f.write(data)
        paths.append(path)
        print(f"Variation {i+1} saved: {path}")

    return paths


variations = generate_variations(
    prompt="Illustration of a gardener robot watering flowers, childish and colorful style",
    n_variations=5,
    prefix="gardener_robot"
)

Variációk a prompt módosításával

Míg az előző megközelítés a véletlenszerűségre hagyatkozik, addig ez a módszer kontrollt ad a kezedbe. Rögzítesz egy változatlan tárgyat – jelen esetben egy gőzölgő kávésbögrét egy faasztalon –, és csak egyetlen dimenziót módosítasz: a hangulatot. Az így kapott öt eredmény összehasonlíthatóvá válik, hiszen pontosan tudod, mi különbözteti meg őket egymástól. Ez a különbség az öt próbálkozás és egy tudatos kísérlet között.

from openai import OpenAI
import base64

client = OpenAI()

base_prompt = "Steaming coffee cup on a wooden table"

moods = [
    "soft morning light, warm tones",
    "Parisian café vibe, black and white",
    "pop art style, saturated colors",
    "Scandinavian minimalist, white background",
    "cozy winter atmosphere, bokeh string lights",
]

for i, mood in enumerate(moods):
    prompt = f"{base_prompt}, {mood}"
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size="1024x1024",
        quality="medium",
    )

    path = f"cafe_mood_{i+1}.png"
    data = base64.b64decode(response.data[0].b64_json)
    with open(path, "wb") as f:
        f.write(data)
    print(f"Mood: {mood[:30]}... → {path}")

Iteráció a prompt finomításával

Ha az eredmény nem kielégítő, a helyes reakció nem az, hogy újra lefuttatod a generálást és a szerencsében bízol, hanem hogy hozzáadod a hiányzó korlátozást. Az alábbi sorozat ezt a fejlődést mutatja be egy kidolgozott példán: a „Egy fintech startup logója“ semmit sem mond a modellnek; a második iteráció korlátozza a színek számát és a hátteret; a harmadik megnevezi a vizuális metaforát és a palettát; a negyedik pedig egészen a hex kódokig és a vonalvastagságig megy le. Minden körrel szűkül a lehetséges eredmények tere, és nő a reprodukálhatóság.

from openai import OpenAI
import base64

client = OpenAI()

iterations = [
    # Iteration 1: base prompt
    "A logo for a fintech startup",

    # Iteration 2: adding visual constraints
    "A logo for a fintech startup, minimalist design, maximum two colors, transparent background",

    # Iteration 3: style precision
    (
        "Minimalist logo for a fintech startup, abstract geometric icon "
        "evoking growth, navy blue and emerald green palette, no text, vector style"
    ),

    # Iteration 4: fine adjustments
    (
        "Minimalist logo for a fintech startup, abstract geometric icon: "
        "two interlocking arrows forming a diamond, navy blue (#1B2A4A) and "
        "emerald green (#2ECC71), 2px thin stroke, white background, sharp vector render, centered"
    ),
]

for i, prompt in enumerate(iterations):
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size="1024x1024",
        quality="high",
    )

    path = f"logo_iteration_{i+1}.png"
    data = base64.b64decode(response.data[0].b64_json)
    with open(path, "wb") as f:
        f.write(data)
    print(f"Iteration {i+1}: {prompt[:60]}...")
    print(f"  → {path}\n")

Automatizált iterációs folyamat (Pipeline)

Egy kicsit hosszabb projektnél az emberi memória nem elég: tizenöt kép után már nem tudod, melyik prompt melyik eredményt hozta létre. Az alábbi folyamat (pipeline) körökbe szervezi a munkát, körönként több variációt generál, nyomon követhetően nevezi el a fájlokat, és egy JSON-fájlban tárolja a promptok teljes történetét. Ez a történeti fájl teszi értékessé a rendszert: lehetővé teszi, hogy visszalépj, és az egyik projektből a másikba építkezz.

from openai import OpenAI
import base64
import json

client = OpenAI()

def iteration_pipeline(brief: str, n_rounds: int = 3, n_per_round: int = 3):
    """
    Iteration pipeline: generates several variants per round,
    keeps a history of prompts and results.
    """
    history = []
    current_prompt = brief

    for round_num in range(1, n_rounds + 1):
        print(f"\n{'='*50}")
        print(f"ROUND {round_num} — Prompt: {current_prompt[:80]}...")
        print(f"{'='*50}")

        round_images = []
        for i in range(n_per_round):
            response = client.images.generate(
                model="gpt-image-2.5-sunburst",
                prompt=current_prompt,
                size="1024x1024",
                quality="medium",
            )

            path = f"pipeline_r{round_num}_v{i+1}.png"
            data = base64.b64decode(response.data[0].b64_json)
            with open(path, "wb") as f:
                f.write(data)
            round_images.append(path)
            print(f"  Variant {i+1}: {path}")

        history.append({
            "round": round_num,
            "prompt": current_prompt,
            "images": round_images
        })

        # Refine the prompt for the next round
        if round_num < n_rounds:
            current_prompt += ", more details, better composition"

    # Save the history
    with open("pipeline_history.json", "w") as f:
        json.dump(history, f, indent=2, ensure_ascii=False)

    print(f"\nHistory saved: pipeline_history.json")
    return history


iteration_pipeline(
    brief="Illustration of an independent bookstore seen from outside, autumn evening, Ghibli style",
    n_rounds=3,
    n_per_round=3
)

Variációk összehasonlítása egy katalógusban

Ha egyesével nyitsz meg kilenc PNG-fájlt egy képnézegetőben, az nem teszi lehetővé a komoly összehasonlítást. Ehelyett generálj egy HTML-oldalt, amely egymás mellett jeleníti meg őket, a képeket base64-ben kódolva, így a fájl önmagában is működőképes, és változatlan formában megosztható egy ügyféllel vagy művészeti vezetővel.

import base64
from pathlib import Path
from glob import glob

def generate_catalog(images: list[str], title: str, output: str = "catalog.html"):
    """Create an HTML page with all images side by side."""
    html_parts = [
        '<!DOCTYPE html><html><head><meta charset="utf-8">',
        f'<title>{title}</title>',
        '<style>',
        'body { background: #111; color: #fff; font-family: sans-serif; padding: 2rem; }',
        '.grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(300px, 1fr)); gap: 1rem; }',
        '.card { background: #222; border-radius: 8px; overflow: hidden; }',
        '.card img { width: 100%; display: block; }',
        '.card p { padding: 0.5rem 1rem; font-size: 0.85rem; color: #aaa; }',
        '</style></head><body>',
        f'<h1>{title}</h1><div class="grid">',
    ]

    for img_path in images:
        with open(img_path, "rb") as f:
            b64 = base64.b64encode(f.read()).decode()
        html_parts.append(f'<div class="card">')
        html_parts.append(f'<img src="data:image/png;base64,{b64}" />')
        html_parts.append(f'<p>{Path(img_path).name}</p></div>')

    html_parts.append('</div></body></html>')

    with open(output, "w") as f:
        f.write("\n".join(html_parts))
    print(f"Catalog generated: {output}")


images = sorted(glob("pipeline_r*_v*.png"))
generate_catalog(images, "Variations — Ghibli Bookstore")

Az iteráció fegyelme

Néhány alapelv választja el a produktív iterációt a költséges próbálgatástól. Egyszerre csak egy paramétert módosíts, különben sosem fogod tudni, melyik javította az eredményt. Vezess naplót a promptjaidról és a generálásokról, ahogy a fenti folyamat is teszi, hogy építkezhess a tapasztalatokból, ahelyett, hogy minden projektet elölről kezdenél. A felfedezési szakasz teljes ideje alatt dolgozz quality: low beállítással, és csak a végső renderelésnél válts high minőségre, különben feleslegesen fizetsz sokat olyan képekért, amelyeket végül kidobsz. Ha csupán gyors diverzitásra van szükséged, részesítsd előnyben az n paraméterrel történő egyetlen hívást a kérések ciklusával szemben. Végül pedig nevezd el leíró jelleggel a fájljaidat: ez az első napon apróságnak tűnhet, de kétszáz kép után döntő fontosságúvá válik.

Most alkalmazd ezt a teljes szekvenciát egy általad választott témára – legyen az logó, illusztráció vagy termékfotó. Generálj három variációt egy kezdeti prompttal, finomítsd ezt a promptot az eredmények fényében, generálj három új variációt, majd készítsd el a hat képet összehasonlító HTML-katalógust.