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

Képgenerálás kombinálása más API-eszközökkel

10. lecke 12 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Képgenerálás kombinálása más API-eszközökkel
  2. Írass promptot egy nyelvi modellel
  3. Cikk illusztrálása elejétől a végéig
  4. Kép leírása az eltérő újrageneráláshoz
  5. Nagy mennyiségek feldolgozása kötegekben
  6. Közvetlen közzététel tárhelyen
  7. Mi tartja életben a folyamatot?

Frissítés: 2026. november 2. — Képmodellek. A gpt-image-1 modellt, amelyre ezt a tananyagot eredetileg írtuk, 2026. október 23-án megszüntették. A gpt-image-1.5, gpt-image-1-mini és chatgpt-image-latest modellek 2026. december 1-jén kerülnek kivonásra. A példák most a gpt-image-2.5-sunburst modellt használják, amely a legmagasabb pontosságot kínálja szerkesztéshez; a gpt-image-2.5-flare 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éter nem támogatott, és eltávolítottuk a kódból. Forrás: Képgenerálás (OpenAI).

Képgenerálás kombinálása más API-eszközökkel

Önmagában a képgenerálás csupán egy kézműves eszköz: írsz egy promptot, és kapsz egy fájlt. Az igazi ereje akkor mutatkozik meg, ha egy automatizált láncolat egyik lépésévé válik – legyen szó egy nyelvi modellről, amely megírja a promptot, egy látóelemzésről, amely leír egy referenciaképet, vagy egy tárhelyről, amely közzéteszi az eredményt. Ez a lecke bemutatja, hogyan kapcsolhatod össze ezeket az elemeket.

Írass promptot egy nyelvi modellel

A felhasználóid vagy kollégáid nem vizuális promptokat írnak, hanem briefeket. Az „Szükségem van egy képre egy cikkhez az AI-ról az egészségügyben, futurisztikus, de emberi hangulatban“ kifejezés nem tartalmaz kompozíciót, világítást vagy színpalettát. Ahelyett, hogy arra kérnéd őket, tanulják meg az előző leckében szereplő szókincset, iktass be egy nyelvi modellt, amely elvégzi ezt a fordítást. Bízd rá a művészeti vezető szerepét a rendszerüzenetben, és kötelezd, hogy a prompt specifikus rétegeit állítsa elő, szigorú utasítással, hogy mást ne adjon ki. Ellenkező esetben egy udvarias magyarázatot kapsz, amit aztán neked kellene elküldened a GPT Image-nek.

from openai import OpenAI
import base64

client = OpenAI()

def text_to_image(brief: str, output: str):
    """
    Kétlépéses folyamat:
    1. Egy LLM generálja az optimális vizuális promptot
    2. A GPT Image létrehozza a képet
    """
    # 1. lépés: Vizuális prompt generálása LLM-mel
    completion = client.chat.completions.create(
        model="gpt-5.6-luna",
        messages=[
            {
                "role": "system",
                "content": (
                    "Te egy szakértő művészeti vezető vagy. "
                    "Egy brief alapján generálj részletes promptot egy "
                    "képgeneráló modell számára. Tartalmazza: téma, kompozíció, világítás, "
                    "stílus, perspektíva, színpaletta. "
                    "Kizárólag a prompttal válaszolj, magyarázat nélkül."
                )
            },
            {"role": "user", "content": brief}
        ]
    )

    visual_prompt = completion.choices[0].message.content
    print(f"Generált prompt: {visual_prompt[:100]}...")

    # 2. lépés: Kép generálása
    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"Kép generálva: {output}")
    return visual_prompt


prompt = text_to_image(
    "Szükségem van egy képre egy cikkhez a mesterséges intelligenciáról "
    "az egészségügyben. Futurisztikus, de emberi.",
    "ai_health.png"
)

Cikk illusztrálása elejétől a végéig

Egy jellemző cikkhez szükség van egy címlapképre és minden szakaszhoz egy-egy illusztrációra. Ezeknek a képeknek összetartozónak kell lenniük anélkül, hogy azonosak lennének. Az illustrate_article függvény ezt a logikát alkalmazza úgy, hogy minden promptba visszailleszti a stílust, és minden alkalommal megismétli a cikk címét, ezzel tematikus egységet teremtve a teljes készletnek. Két költségcsökkentő részletre érdemes figyelni: a címlapkép high minőségben készül, mert mindenki látja, és gyakran megosztják, míg a szakaszillusztrációk medium minőségűek maradnak, mivel kisebb méretben és alacsonyabban jelennek meg az oldalon. Az AI toborzásról szóló példa öt szakasza esetén ez a kompromisszum csökkenti a költségeket anélkül, hogy az olvasó bármit is észrevenne.

from openai import OpenAI
import base64
import json

client = OpenAI()

def illustrate_article(title: str, sections: list[str], style: str, output_dir: str = "."):
    """
    Generál egy fejlécillusztrációt és egyet minden szakaszhoz.
    """
    results = []

    # Címlapkép
    header_prompt = (
        f"Címlapkép egy \"{title}\" című cikkhez, "
        f"{style} stílusban, panorámás kompozíció, "
        "nincs szöveg a képen, professzionális"
    )

    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"Fejléc: {path}")

    # Szakaszillusztrációk
    for i, section in enumerate(sections):
        section_prompt = (
        f"Illusztráció a \"{section}\" szakaszhoz "
        f"a \"{title}\" című cikkben, "
        f"{style} stílusban, téglalap alakú formátum, "
        "koncepcionális illusztráció szöveg nélkül"
        )

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

    return results


illustrate_article(
    title="5 mód, ahogy az AI átalakítja a toborzást",
    sections=[
        "Automatikus önéletrajz-szűrés",
        "AI-elemzett videointerjúk",
        "Okos jelölt-állás párosítás",
        "Toborzási torzítások csökkentése",
        "Személyre szabott beillesztés",
    ],
    style="3D izometrikus illusztráció, kék és ibolya tónusok",
    output_dir="."
)

Kép leírása az eltérő újrageneráláshoz

Hogyan kapsz egy nyári táj téli változatát, ha csak a fájlod van meg, maszkod nincs, és nincsenek szerkesztőeszközeid? Használd a nyelvet. A modell látóelemzése elemzi a képet, és olyan pontos leírást készít, amely alkalmas rekonstrukciós promptként való használatra – téma, kompozíció, világítás, színek, stílus, perspektíva, hangulat. Ezután hozzáfűzöd a módosítási utasításodat ehhez a leíráshoz. A generáló modell egy teljes szöveges promptot kap, ahol csak az évszak változott, és így az eredetivel koherens képet kapsz, nem pedig valami teljesen idegent. Ez a legmegbízhatóbb módszer arra is, hogy reprodukáld egy olyan referenciakép vizuális identitását, amelyet nem tudsz közvetlenül szerkeszteni.

from openai import OpenAI
import base64

client = OpenAI()

def analyze_and_vary(image_path: str, instruction: str, output: str):
    """
    1. Elemzi a képet a GPT Visionnel
    2. Generál egy variánst az elemzés alapján
    """
    # 1. lépés: Kép elemzése
    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": (
                            "Írd le részletesen ezt a képet úgy, hogy egy kép-"
                            "generáló modell hűen reprodukálni tudja. "
                            "Tartalmazza: téma, kompozíció, világítás, színek, stílus, "
                            "perspektíva, hangulat. Legyél nagyon pontos."
                        )
                    },
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/png;base64,{image_b64}"
                        }
                    }
                ]
            }
        ]
    )

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

    # 2. lépés: Módosított variáns generálása
    variant_prompt = f"{description}. Kért módosítás: {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"Variáns generálva: {output}")


analyze_and_vary(
    "original_landscape.png",
    "Változtasd az évszakot nyárról télre, hóval a tetőkön és fákon",
    "winter_landscape.png"
)

Nagy mennyiségek feldolgozása kötegekben

Öt termékvizuál sorozatos generálása perceket vesz igénybe; ötszáz egymás után történő generálása egész éjszakát emészt fel, és az első hálózati akadozásnál megszakad. Az alábbi beállítás mindkét problémát megoldja. Minden feladat egy önálló szótár, amely tartalmazza az azonosítóját, a promptot, a kimeneti fájlt és a beállításokat. A worker függvény egy try blokkba csomagolja a hívást, amely státuszt ad vissza a teljes köteg összeomlása helyett: egy elutasított generálás nem viszi magával a másik négyszázkilencvenkilencet is. A ThreadPoolExecutor ezután párhuzamosítja a végrehajtást, de szándékosan alacsony max_workers értékkel – ebben a példában hárommal –, mert a szűk keresztmetszet nem a géped, hanem az API-kvóták. A végső jelentés megszámolja a sikereket és a hibákat, hogy tudd, mit kell újrapróbálnod.

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:
    """Generál egy egyetlen képet egy feladat alapján."""
    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):
    """Végrehajt egy generálási köteget szabályozott párhuzamosítással."""
    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']}")

    # Jelentés
    ok = sum(1 for r in results if r["status"] == "ok")
    errors = sum(1 for r in results if r["status"] == "error")
    print(f"\nBefejezve: {ok} siker, {errors} hiba a {len(tasks)} feladatból")

    return results


# Feladatköteg definiálása
tasks = [
    {
        "id": f"product_{i}",
        "prompt": f"E-kereskedelmi termékfotó: {product}, fehér háttér, stúdió",
        "output": f"batch_product_{i}.png",
        "quality": "high"
    }
    for i, product in enumerate([
        "rózsaszín arany óra",
        "repülős napszemüveg",
        "fonott bőr karkötő",
        "szoliter gyémántgyűrű",
        "tenyésztett gyöngy nyaklánc",
    ])
]

results = batch_generation(tasks, max_parallel=3)

Közvetlen közzététel tárhelyen

A PNG fájl írása annak a gépnek a lemezére, amelyen a szkript fut, csak fejlesztés során van értelme. Éles környezetben a képnek oda kell kerülnie, ahonnan az oldalad lekéri, és a helyi fájlrendszeren való áthaladás felesleges hibalehetőséggé válik. A b64_json formátum jól illik ehhez a kivonáshoz: a dekódolt bájtokat egy BytesIO objektumba csomagoljuk, és közvetlenül feltöltjük a bucketbe, egy explicit ContentType megadásával – ami nélkül a böngészők letöltést ajánlanának fel a kép megjelenítése helyett. A függvény visszaadja a nyilvános URL-t, amire a CMS-ednek valójában szüksége van.

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):
    """Generál egy képet, és közvetlenül feltölti az S3-ra."""
    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"Kép tárolva az S3-on: {url}")
    return url


# Példa
url = generate_and_store_s3(
    "Mobilalkalmazás ikon: nyitott könyv csillagokkal, lapos design",
    "my-image-bucket",
    "generated/app_icon_v1.png"
)

Mi tartja életben a folyamatot?

Ebben a leckében az öt folyamat ugyanazt a konstrukciós higiéniát követi. Minden lépés egyetlen dolgot csinál, lehetővé téve, hogy a promptírást vagy a tárolást kicseréld anélkül, hogy a többit érintened. Minden lépés kezeli a saját hibáit; ellenkező esetben egy moderációs elutasítás a köteg közepén az egész láncolatot magával rántja – pontosan ezt előzi meg a try blokk a generate_one_image függvényben. A párhuzamosítás korlátozott marad a sebességkorlátok tiszteletben tartása érdekében, és ezen a ponton az óvatosság olcsóbb, mint a helyreállítás egy ideiglenes tiltás után.

Két kevésbé látható, de ugyanolyan döntő szokás marad. Naplózd a ténylegesen elküldött promptokat, különösen akkor, ha egy nyelvi modell írta őket: e napló nélkül egy kép, amit szeretsz, a második futtatásnál reprodukálhatatlanná válik. És gyorsítótárazd az eredményeket, amikor ugyanaz a prompt újra előfordulhat, amit a következő lecke egy teljes rendszerré formalizál.

Most állítsd össze a saját teljes láncolatodat: bemenetként egy cikkcímet fogad, megkér egy nyelvi modellt három releváns vizuális leírásra, párhuzamosan generálja a három képet, és előállít egy összefoglaló JSON-t, amely minden promptot összekapcsol a megfelelő fájllal. Ezután minden adott lesz ahhoz, hogy manuális beavatkozás nélkül illusztrálj egy teljes blogot.