Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Kombineeri pildigeneratsioon teiste API-tööriistadega

Õppetund 10 / 12 Värskendatud 2. november 2026 Arendajatele
Sellel lehel
  1. Kombineeri pildigeneratsioon teiste API-tööriistadega
  2. Lase keelemudelil kirjutada vihje
  3. Illustreeri artikkel algusest lõpuni
  4. Kirjelda pilti, et seda erinevalt uuesti genereerida
  5. Töötle suuri mahtusid partiidena
  6. Avalda otse salvestusruumi
  7. Mis hoiab torustiku töös

Uuendus 2. novembril 2026 — Pildimudelid. Mudel gpt-image-1, mille jaoks see kursus algselt kirjutati, lõpetas tegevuse 23. oktoobril 2026. Mudelid gpt-image-1.5, gpt-image-1-mini ja chatgpt-image-latest lõpetavad tegevuse 1. detsembril 2026. Näited kasutavad nüüd mudelit gpt-image-2.5-sunburst, mis pakub redigeerimisel suurimat täpsust; gpt-image-2.5-flare on tavapäraseks generatsiooniks kiirem. Mõlemad mudelid toetavad ka kvaliteedisätteid xhigh ja max. GPT Image mudelid tagastavad pildid alati base64-formaadis: vanemate DALL·E mudelite parameeter response_format ei ole toetatud ja on koodist eemaldatud. Allikas: Pildigeneratsioon (OpenAI).

Kombineeri pildigeneratsioon teiste API-tööriistadega

Iseseisvalt kasutatuna on pildigeneratsioon käsitööline vahend: kirjutad vihje (prompt) ja saad faili. Selle tegelik jõud avaldub siis, kui see muutub automatiseeritud ahela üheks lüliks – keelemudel, mis kirjutab vihje, visioonanalüüs, mis kirjeldab referentspilti, või salvestusruum, mis avaldab tulemuse. See tund näitab, kuidas need osad omavahel ühendada.

Lase keelemudelil kirjutada vihje

Sinu kasutajad või kolleegid ei kirjuta visuaalseid vihjeid; nad kirjutavad ülesandeid. „Vajan pilti artiklile tehisintellektist tervishoius, futuristlik, kuid inimlik“ ei sisalda kompositsiooni, valgustust ega värvipaletti. Selle asemel, et paluda neil õppida eelmise tunni sõnavara, lisa ahelasse keelemudel, kes teeb tõlketöö. Määra talle süsteemsõnumis kunstilise juhendaja roll ja nõua, et ta genereeriks vihje konkreetsed kihid, andes range korralduse mitte midagi muud väljastada. Vastasel juhul saad viisaka selgituse, mille peaksid seejärel ise GPT Image’ile edastama.

from openai import OpenAI
import base64

client = OpenAI()

def text_to_image(brief: str, output: str):
    """
    Kaheastmeline torustik:
    1. Keelemudel genereerib optimaalse visuaalse vihje
    2. GPT Image loob pildi
    """
    # 1. aste: Genereeri visuaalne vihje keelemudeliga
    completion = client.chat.completions.create(
        model="gpt-5.6-luna",
        messages=[
            {
                "role": "system",
                "content": (
                    "Oled kogenud kunstiline juhendaja. "
                    "Loo ülesande põhjal üksikasjalik vihje "
                    "pildigeneratsiooni mudelile. Kaasa: subjekt, kompositsioon, valgustus, "
                    "stiil, perspektiiv, värvipalett. "
                    "Vasta ainult vihjega, ilma selgitusteta."
                )
            },
            {"role": "user", "content": brief}
        ]
    )

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

    # 2. aste: Genereeri pilt
    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"Pilt genereeritud: {output}")
    return visual_prompt


prompt = text_to_image(
    "Vajan pilti artiklile tehisintellektist "
    "tervishoius. Futuristlik, kuid inimlik.",
    "ai_health.png"
)

Illustreeri artikkel algusest lõpuni

Põhjalik artikkel vajab kaanepilti ja üht illustratsiooni iga jaotise kohta. Need pildid peavad välja nägema ühtsed, olemata identsed. Funktsioon illustrate_article rakendab seda loogikat, süstides stiili igasse vihjesse tagasi ja korrates iga kord artikli pealkirja, mis annab kogu komplektile temaatilise ühtsuse. Kaks kulude kokkuhoiu detaili väärivad tähelepanu: kaanepilt genereeritakse kvaliteediga high, sest kõik näevad seda ja seda jagatakse sageli, samas kui jaotiste illustratsioonid jäävad kvaliteediga medium, kuna need kuvatakse lehel väiksemalt ja allpool. Selles näites tehisintellektist värbamisel on viie jaotise puhul see kompromiss arvet langetanud, ilma et lugeja midagi märkaks.

from openai import OpenAI
import base64
import json

client = OpenAI()

def illustrate_article(title: str, sections: list[str], style: str, output_dir: str = "."):
    """
    Genereerib päise illustratsiooni + ühe iga jaotise kohta.
    """
    results = []

    # Kaanepilt
    header_prompt = (
        f"Kaanepilt artiklile pealkirjaga \"{title}\", "
        f"{style} stiilis, panoraamne kompositsioon, "
        "pildil ei ole teksti, professionaalne"
    )

    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"Päis: {path}")

    # Jaotiste illustratsioonid
    for i, section in enumerate(sections):
        section_prompt = (
        f"Illustratsioon jaotisele \"{section}\" "
        f"artiklis \"{title}\", "
        f"{style} stiilis, ristkülikukujuline formaat, "
        "kontseptuaalne illustratsioon ilma tekstita"
        )

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

    return results


illustrate_article(
    title="5 viisi, kuidas tehisintellekt muudab värbamist",
    sections=[
        "CV-de automaatne sõelumine",
        "Tehisintellekti analüüsitud videointervjuud",
        "Targad kandidaadi ja töökoha sobitused",
        "Värbamise eelarvamuste vähendamine",
        "Isikupärastatud sisseelamine",
    ],
    style="3D isomeetriline illustratsioon, sinised ja violetsed toonid",
    output_dir="."
)

Kirjelda pilti, et seda erinevalt uuesti genereerida

Kuidas saada suvemaastiku talvine versioon, kui sul on ainult fail, puudub mask ja puuduvad redigeerimistööriistad? Kasuta keelt. Mudeli visioonanalüüs uurib pilti ja loob kirjelduse, mis on piisavalt täpne, et toimida rekonstrueerimisvihjena – subjekt, kompositsioon, valgustus, värvid, stiil, perspektiiv, meeleolu. Seejärel liidad sellele kirjeldusele oma muudatuskorralduse. Generatsioonimudel saab täieliku tekstilise vihje, kus on muudetud ainult aastaaega, ja tulemuseks on originaaliga kooskõlas olev pilt, mitte midagi seostamatut. See on ka kõige usaldusväärsem viis reprodutseerida referentspildi visuaalset identiteeti, mida sa ei saa otse redigeerida.

from openai import OpenAI
import base64

client = OpenAI()

def analyze_and_vary(image_path: str, instruction: str, output: str):
    """
    1. Analüüsib pilti GPT Visioniga
    2. Genereerib analüüsi põhjal variandi
    """
    # 1. aste: Analüüsi pilti
    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": (
                            "Kirjelda seda pilti üksikasjalikult, et pildi "
                            "generatsioonimudel saaks seda täpselt reprodutseerida. "
                            "Kaasa: subjekt, kompositsioon, valgustus, värvid, stiil, "
                            "perspektiiv, meeleolu. Ole väga täpne."
                        )
                    },
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/png;base64,{image_b64}"
                        }
                    }
                ]
            }
        ]
    )

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

    # 2. aste: Genereeri muudetud variant
    variant_prompt = f"{description}. Soovitud muudatus: {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 genereeritud: {output}")


analyze_and_vary(
    "original_landscape.png",
    "Muuda aastaaeg suvest talveks, lumi katustel ja puudel",
    "winter_landscape.png"
)

Töötle suuri mahtusid partiidena

Viie tootepildi genereerimine jada kaupa võtab minuteid; viiesaja pildi järjestikune genereerimine võtab kogu öö ja katkeb esimese võrguhäire korral. Allpool toodud lahendus lahendab mõlemad probleemid. Iga ülesanne on iseseisev sõnastik, mis kannab oma ID-d, vihjet, väljundfaili ja sätteid. Töötleja funktsioon pakendab väljakutse try-plokki, mis tagastab oleku selle asemel, et kogu partii kokku lasta: tagasilükatud generatsioon ei tõmba kaasa ülejäänud neljasada üheksakümmend üheksat. ThreadPoolExecutor seejärel paralleliseerib täitmise, kuid tahtlikult madala max_workers väärtusega – selles näites kolm –, sest kitsaskoht pole sinu masin, vaid API kvoodid. Lõpparuanne loeb õnnestumised ja vead, et teaksid, mida uuesti proovida.

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:
    """Genereerib ühe pildi ülesandest."""
    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):
    """Teostab genereerimise partii kontrollitud paralleelsusega."""
    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']}")

    # Aruanne
    ok = sum(1 for r in results if r["status"] == "ok")
    errors = sum(1 for r in results if r["status"] == "error")
    print(f"\nLõpetatud: {ok} õnnestus, {errors} viga kokku {len(tasks)} ülesandest")

    return results


# Määratle ülesannete partii
tasks = [
    {
        "id": f"product_{i}",
        "prompt": f"E-kauba tootefoto: {product}, valge taust, stuudio",
        "output": f"batch_product_{i}.png",
        "quality": "high"
    }
    for i, product in enumerate([
        "roosa kulla käekell",
        "lenduri päikeseprillid",
        "palmikutud nahast käevõru",
        "sõrmus ühe teemantiga",
        "kultiveeritud pärlite kaelakee",
    ])
]

results = batch_generation(tasks, max_parallel=3)

Avalda otse salvestusruumi

PNG-faili kirjutamine skripti käitava masina kettale on mõttekas ainult arendusetapis. Tootmises peab pilt jõudma kohta, kust sinu sait selle hangib, ja kohalikku failisüsteemi kaudu ringi tegemine muutub ebavajalikuks tõrkeallikaks. Formaadi b64_json sobib selleks eemaldamiseks hästi: dekodeeritud baidid pakendatakse BytesIO objekti ja surutakse otse salvestusruumi (bucket), määrates selgesõnaliselt ContentType – ilma selleta pakuvad brauserid faili allalaadimist pildi kuvamise asemel. Funktsioon tagastab avaliku URL-i, mida sinu sisuhaldussüsteem tegelikult vajab.

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):
    """Genereerib pildi ja laeb selle otse S3-i."""
    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"Pilt salvestatud S3-i: {url}")
    return url


# Näide
url = generate_and_store_s3(
    "Mobiilirakenduse ikoon: avatud raamat tähtedega, lame disain",
    "my-image-bucket",
    "generated/app_icon_v1.png"
)

Mis hoiab torustiku töös

Selle tunni viiel torustikul on sama ehitushügieen. Iga aste teeb ühte asja, võimaldades sul asendada vihje kirjutamist või salvestamist ülejäänut puutumata jätmise hinnaga. Iga aste haldab oma vigu; vastasel juhul toob mõõdukuse keeldumine partii keskel kogu ahela kokku – just seda takistab try plokk funktsioonis generate_one_image. Paralleelsus jääb piiratuks, et austada kiirusepiiranguid, ja selles osas maksab ettevaatus vähem kui taastumine ajutise keelu järel.

Kaks vähem nähtavat, kuid sama otsustavat harjumust on veel. Logi tegelikult saadetud vihjed, eriti kui need on kirjutanud keelemudel: ilma selle logita muutub pilt, mida armastad, teisel korral taasesitamatuks. Ja vahemällu salvesta tulemused iga kord, kui sama vihje võib tagasi tulla, mille järgmine tund vormistab terviklikuks süsteemiks.

Nüüd pane kokku oma täielik ahel: see võtab sisendiks artikli pealkirja, küsib keelemudelilt kolme asjakohase visuaali kirjeldust, genereerib kolm pilti paralleelselt ja loob kokkuvõtliku JSON-i, mis seob iga vihje selle failiga. Seejärel on sul kõik vajalik, et illustreerida tervet blogi ilma manuaalse sekkumiseta.