Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Derinkite vaizdų generavimą su kitais API įrankiais

Paskaita 10 iš 12 Atnaujinta 2026 m. lapkričio 2 d. Kūrėjas
Šiame puslapyje
  1. Derinkite vaizdų generavimą su kitais API įrankiais
  2. Leiskite kalbos modeliui parašyti užklausą
  3. Iliustruokite straipsnį nuo pradžių iki galo
  4. Aprašykite vaizdą, kad jį atkurtumėte kitaip
  5. Apdorokite didelius kiekius partijomis
  6. Skelbkite tiesiai į saugyklą
  7. Kas palaiko konvejerio stabilumą

Atnaujinimas 2026 m. lapkričio 2 d. — Vaizdų modeliai. gpt-image-1, modelis, kuriam iš pradžių buvo skirtas šis kursas, buvo nutrauktas 2026 m. spalio 23 d.. gpt-image-1.5, gpt-image-1-mini ir chatgpt-image-latest bus pašalinti 2026 m. gruodžio 1 d.. Pavyzdžiuose dabar naudojamas gpt-image-2.5-sunburst, kuris užtikrina didžiausią tikslumą redaguojant; gpt-image-2.5-flare yra greitesnis standartiniam generavimui. Abu modeliai taip pat palaiko xhigh ir max kokybės nustatymus. GPT Image modeliai visada grąžina vaizdus base64 formatu: senesnių DALL·E modelių parametras response_format nepalaikomas ir buvo pašalintas iš kodo. Šaltinis: Vaizdų generavimas (OpenAI).

Derinkite vaizdų generavimą su kitais API įrankiais

Atskirai vaizdų generavimas yra tik meistriškas įrankis: parašote užklausą ir gaunate failą. Jo tikroji galia atsiskleidžia tada, kai jis tampa vienu automatizuotos grandinės žingsniu – kalbos modeliu, kuris rašo užklausą, regos analize, aprašančia atskaitos vaizdą, arba saugykla, kuri paskelbia rezultatą. Šioje pamokoje parodysime, kaip sujungti šias dalis.

Leiskite kalbos modeliui parašyti užklausą

Jūsų naudotojai ar kolegos nerašo vizualinių užklausų; jie rašo technines užduotis. „Man reikia vaizdo straipsniui apie dirbtinį intelektą sveikatos priežiūroje, futuristinio, bet žmogiško“ neturi jokios kompozicijos, apšvietimo ar spalvų paletės. Užuot prašę jų išmokti ankstesnėje pamokoje aptartą žodyną, įterpkite kalbos modelį, kuris atliktų šį vertimą. Priskirkite jam meno vadovo vaidmenį sistemos pranešime ir reikalaukite, kad jis sugeneruotų konkrečius užklausos sluoksnius, griežtai nurodydami nieko daugiau neišvesti. Priešingu atveju gausite mandagų paaiškinimą, kurį vėliau tektų siųsti GPT Image.

from openai import OpenAI
import base64

client = OpenAI()

def text_to_image(brief: str, output: str):
    """
    Dviejų žingsnių procesas:
    1. LLM sugeneruoja optimalią vizualinę užklausą
    2. GPT Image sukuria vaizdą
    """
    # 1 žingsnis: Sugeneruoti vizualinę užklausą naudojant LLM
    completion = client.chat.completions.create(
        model="gpt-5.6-luna",
        messages=[
            {
                "role": "system",
                "content": (
                    "Esi ekspertas meno vadovas. "
                    "Remdamasis technine užduotimi, sugeneruok išsamią užklausą "
                    "vaizdų generavimo modeliui. Įtrauk: objektą, kompoziciją, apšvietimą, "
                    "stilių, perspektyvą, spalvų paletę. "
                    "Atsakyk tik užklausa, be jokių paaiškinimų."
                )
            },
            {"role": "user", "content": brief}
        ]
    )

    visual_prompt = completion.choices[0].message.content
    print(f"Sugeneruota užklausa: {visual_prompt[:100]}...")

    # 2 žingsnis: Sugeneruoti vaizdą
    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"Vaizdas sugeneruotas: {output}")
    return visual_prompt


prompt = text_to_image(
    "Man reikia vaizdo straipsniui apie dirbtinį intelektą "
    "sveikatos priežiūroje. Futuristinio, bet žmogiško.",
    "ai_health.png"
)

Iliustruokite straipsnį nuo pradžių iki galo

Teminiam straipsniui reikia viršelio vaizdo ir po vieną iliustraciją kiekvienam skyriui. Šie vaizdai turi atrodyti darniai, bet nebūti identiški. Funkcija illustrate_article taiko šią logiką, kiekvienai užklausai iš naujo įterpdama stilių ir kartodama straipsnio pavadinimą, taip suteikdama visam rinkiniui teminį vientisumą. Verta atkreipti dėmesį į dvi išlaidas mažinančias detales: viršelis generuojamas high kokybės, nes jį mato visi ir jis dažnai dalinamasi, o skyrių iliustracijos lieka medium, nes jos rodomos mažesnės ir žemiau puslapyje. Šiame pavyzdyje apie dirbtinį intelektą samdant darbuotojus yra penki skyriai, ir šis kompromisas sumažina sąskaitą, neskaitytojui nieko nepastebint.

from openai import OpenAI
import base64
import json

client = OpenAI()

def illustrate_article(title: str, sections: list[str], style: str, output_dir: str = "."):
    """
    Sugeneruoja antraštės iliustraciją ir po vieną kiekvienam skyriui.
    """
    results = []

    # Viršelio vaizdas
    header_prompt = (
        f"Viršelio vaizdas straipsniui pavadinimu „{title}“, "
        f"{style} stiliaus, panoraminė kompozicija, "
        "jokio teksto vaizde, profesionalu"
    )

    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"Antraštė: {path}")

    # Skyrių iliustracijos
    for i, section in enumerate(sections):
        section_prompt = (
        f"Iliustracija skyriui „{section}“ "
        f"straipsnyje „{title}“, "
        f"{style} stiliaus, stačiakampio formato, "
        "konceptuali iliustracija be teksto"
    )

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

    return results


illustrate_article(
    title="5 būdai, kaip dirbtinis intelektas keičia samdą",
    sections=[
        "Automatinis CV atrankos procesas",
        "Dirbtinio intelekto analizuojami vaizdo interviu",
        "Išmanus kandidatų ir darbo vietų derinimas",
        "Samdos šališkumo mažinimas",
        "Asmeninis įvedimas į darbą",
    ],
    style="3D izometrinė iliustracija, mėlynos ir violetinės spalvos tonai",
    output_dir="."
)

Aprašykite vaizdą, kad jį atkurtumėte kitaip

Kaip gauti vasarinio kraštovaizdžio žieminę versiją, kai turite tik failą, neturite kaukės ir jokių redagavimo įrankių? Naudokite kalbą. Modelio rega analizuoja vaizdą ir sukuria tokį tikslų aprašymą, kad jis galėtų tarnauti kaip atkūrimo užklausa – objektas, kompozicija, apšvietimas, spalvos, stilius, perspektyva, nuotaika. Tada prie šio aprašymo prijungiate savo modifikavimo instrukciją. Generavimo modelis gauna pilną tekstinę užklausą, kurioje pakeistas tik metų laikas, ir jūs gaunate vaizdą, derantį su originalu, o ne kažką nesusijusio. Tai taip pat patikimiausias būdas atkurti atskaitos vaizdo, kurio negalite tiesiogiai redaguoti, vizualinį identitetą.

from openai import OpenAI
import base64

client = OpenAI()

def analyze_and_vary(image_path: str, instruction: str, output: str):
    """
    1. Analizuoja vaizdą naudojant GPT Vision
    2. Sugeneruoja variantą pagal analizę
    """
    # 1 žingsnis: Analizuoti vaizdą
    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": (
                            "Išsamiai aprašykite šį vaizdą, kad vaizdų "
                            "generavimo modelis galėtų jį tiksliai atkurti. "
                            "Įtraukite: objektą, kompoziciją, apšvietimą, spalvas, stilių, "
                            "perspektyvą, nuotaiką. Būkite labai tikslūs."
                        )
                    },
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/png;base64,{image_b64}"
                        }
                    }
                ]
            }
        ]
    )

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

    # 2 žingsnis: Sugeneruoti modifikuotą variantą
    variant_prompt = f"{description}. Prašomas pakeitimas: {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"Variantas sugeneruotas: {output}")


analyze_and_vary(
    "original_landscape.png",
    "Pakeiskite metų laiką iš vasaros į žiemą, su sniegu ant stogų ir medžių",
    "winter_landscape.png"
)

Apdorokite didelius kiekius partijomis

Penkių produkto vizualų generavimas nuosekliai trunka kelias minutes; penkių šimtų generavimas vienas po kito užtrunka visą naktį ir stringa jau prie pirmojo tinklo trikdžio. Toliau pateikta sąranka išsprendžia abi problemas. Kiekviena užduotis yra savarankiškas žodynas, turintis savo ID, užklausą, išvesties failą ir nustatymus. Darbuotojo funkcija apgaubia kvietimą bloku try, kuris grąžina būseną vietoj to, kad sustabdytų visą partiją: atmestas generavimas nebenuvilkia kitų keturių šimtų devyniasdešimt devynių. Tada ThreadPoolExecutor lygiagrečiai vykdo užduotis, tačiau sąmoningai mažina max_workers – šiame pavyzdyje trys – nes ribotuvas yra ne jūsų kompiuteris, o API kvotos. Galutinė ataskaita suskaičiuoja sėkmes ir klaidas, kad žinotumėte, ką kartoti.

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:
    """Sugeneruoja vieną vaizdą iš užduoties."""
    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):
    """Vykdo generavimo partiją su valdomu lygiagretumu."""
    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']}")

    # Ataskaita
    ok = sum(1 for r in results if r["status"] == "ok")
    errors = sum(1 for r in results if r["status"] == "error")
    print(f"\nBaigta: {ok} sėkmingai, {errors} klaidos iš {len(tasks)} užduočių")

    return results


# Apibrėžkite užduočių partiją
tasks = [
    {
        "id": f"product_{i}",
        "prompt": f"E-komercijos produkto nuotrauka: {product}, baltas fonas, studija",
        "output": f"batch_product_{i}.png",
        "quality": "high"
    }
    for i, product in enumerate([
        "rožinio aukso laikrodis",
        "aviatoriaus akiniai nuo saulės",
        "pintas odos apyrankė",
        "solitero deimanto žiedas",
        "kultivuotų perlų vėrinys",
    ])
]

results = batch_generation(tasks, max_parallel=3)

Skelbkite tiesiai į saugyklą

PNG failo rašymas į to kompiuterio diską, kuriame vykdomas scenarijus, turi prasmę tik kūrimo metu. Gamtinėje aplinkoje vaizdas turi atsidurti ten, iš kur jį pasieks jūsų svetainė, o nukrypimas per vietinę failų sistemą tampa nereikalingu gedimo tašku. Formatas b64_json puikiai tinka šiam pašalinimui: dekoduoti baitai įvyniojami į objektą BytesIO ir siunčiami tiesiai į konteinerį (bucket), nurodant aiškų ContentType – be jo naršyklės siūlytų atsisiųsti failą vietoj to, kad rodytų vaizdą. Funkcija grąžina viešąjį URL, kuris yra tai, ko iš tikrųjų reikia jūsų turinio valdymo sistemai (CMS).

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):
    """Sugeneruoja vaizdą ir tiesiogiai įkelia jį į 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"Vaizdas įsaugotas S3: {url}")
    return url


# Pavyzdys
url = generate_and_store_s3(
    "Mobiliosios programėlės piktograma: atversta knyga su žvaigždėmis, plokščias dizainas",
    "my-image-bucket",
    "generated/app_icon_v1.png"
)

Kas palaiko konvejerio stabilumą

Penki šios pamokos konvejeriai dalijasi ta pačia konstravimo higiena. Kiekvienas žingsnis atlieka vieną dalyką, leisdamas pakeisti užklausų rašymą arba saugojimą neliečiant likusios dalies. Kiekvienas žingsnis tvarko savo klaidas; kitaip moderacijos atsisakymas partijos viduryje sugriautų visą grandinę – būtent to ir neleidžia try blokas funkcijoje generate_one_image. Lygiagretumas lieka ribojamas, kad būtų laikomasi dažnio ribų, ir šiuo atžvilgiu atsargumas kainuoja mažiau nei atsigavimas po laikino uždraudimo.

Lieka du mažiau matomi, bet vienodai lemiami įpročiai. Registruokite išsiųstas užklausas, ypač kai jas rašo kalbos modelis: be šio žurnalo vaizdas, kuris jums patinka, antrojo bandymo metu taps neatkuriamas. Ir talpykloje saugokite rezultatus, kai ta pati užklausa gali pasikartoti, ką kita pamoka formalizuos į pilną sistemą.

Dabar surinkite savo pilną grandinę: ji kaip įvestį priima straipsnio pavadinimą, prašo kalbos modelio trijų susijusių vizualų aprašymų, lygiagrečiai sugeneruoja tris vaizdus ir sukuria santraukos JSON, siejantį kiekvieną užklausą su jos failu. Tada turėsite viską, ko reikia visam tinklaraščiui iliustruoti be rankinės intervencijos.