Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Yhdistä kuvagenerointi muihin API-työkaluihin

Oppitunti 10 / 12 Päivitetty 2. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. Yhdistä kuvagenerointi muihin API-työkaluihin
  2. Anna kielimallin kirjoittaa kehote
  3. Havainnollista artikkeli alusta loppuun
  4. Kuvaile kuva generoidaksesi sen uudelleen eri tavalla
  5. Käsittele suuria määriä erissä
  6. Julkaise suoraan tallennustilaan
  7. Mikä pitää putken pystyssä

Päivitys 2. marraskuuta 2026 — Kuvamallit. gpt-image-1, malli, jota varten tämä kurssi alun perin kirjoitettiin, poistettiin käytöstä 23. lokakuuta 2026. gpt-image-1.5, gpt-image-1-mini ja chatgpt-image-latest poistetaan käytöstä 1. joulukuuta 2026. Esimerkit käyttävät nyt mallia gpt-image-2.5-sunburst, joka tarjoaa korkeimman tarkkuuden muokkaamiseen; gpt-image-2.5-flare on nopeampi tavanomaiseen generointiin. Molemmat mallit tukevat myös laatuasetuksia xhigh ja max. GPT Image -mallit palauttavat kuvat aina base64-muodossa: vanhempien DALL·E-mallien response_format-parametria ei tueta, ja se on poistettu koodista. Lähde: Image generation (OpenAI).

Yhdistä kuvagenerointi muihin API-työkaluihin

Eristettynä kuvagenerointi on käsityökalu: kirjoitat kehotteen, saat tiedoston. Sen todellinen voima paljastuu, kun siitä tulee yksi osa automatisoitua ketjua – kielimalli, joka kirjoittaa kehotteen, visioanalyysi, joka kuvailee referenssikuvaa, tai tallennustila, joka julkaisee tuloksen. Tämä oppitunti näyttää, miten kytket nämä osat yhteen.

Anna kielimallin kirjoittaa kehote

Käyttäjäsi tai kollegasi eivät kirjoita visuaalisia kehotteita; he kirjoittavat toimeksiantoja. “Tarvitsen kuvan artikkeliin tekoälyn käytöstä terveydenhuollossa, futuristinen mutta inhimillinen” ei sisällä mitään sommittelusta, valaistuksesta tai väripaletista. Sen sijaan, että pyytäisit heitä opettelemaan edellisen oppitunnin sanastoa, lisää kielimalli hoitamaan käännös. Määritä sille taidejohtajan rooli järjestelmäviestissä ja vaadi sitä tuottamaan kehotteen erityiset kerrokset tiukoin ohjein tulostaa mitään muuta. Muuten saat kohteliaan selityksen, joka sinun pitäisi lähettää edelleen GPT Image -mallille.

from openai import OpenAI
import base64

client = OpenAI()

def text_to_image(brief: str, output: str):
    """
    Kaksivaiheinen putki:
    1. LLM generoi optimaalisen visuaalisen kehotteen
    2. GPT Image luo kuvan
    """
    # Vaihe 1: Generoi visuaalinen kehote LLM:llä
    completion = client.chat.completions.create(
        model="gpt-5.6-luna",
        messages=[
            {
                "role": "system",
                "content": (
                    "Olet asiantunteva taidejohtaja. "
                    "Luo toimeksiannon perusteella yksityiskohtainen kehote "
                    "kuvagenerointimallille. Sisällytä: aihe, sommittelu, valaistus, "
                    "tyyli, perspektiivi, väripaletti. "
                    "Vastaa vain kehotteella, ei selityksiä."
                )
            },
            {"role": "user", "content": brief}
        ]
    )

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

    # Vaihe 2: Generoi kuva
    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"Kuva generoitu: {output}")
    return visual_prompt


prompt = text_to_image(
    "Tarvitsen kuvan artikkeliin tekoälyn käytöstä "
    "terveydenhuollossa. Futuristinen mutta inhimillinen.",
    "ai_health.png"
)

Havainnollista artikkeli alusta loppuun

Laaja artikkeli tarvitsee kansikuvan ja yhden kuvituksen jokaiseen osioon. Näiden kuvien tulee näyttää yhtenäisiltä olematta kuitenkaan identtisiä. illustrate_article-funktio toteuttaa tämän logiikan injektoimalla tyylin uudelleen jokaiseen kehotteeseen ja toistamalla artikkelin otsikon joka kerta, mikä antaa koko sarjalle temaattisen yhtenäisyyden. Kaksi kustannuksia säästävää yksityiskohtaa ansaitsevat huomiota: kansi generoidaan high-laadulla, koska kaikki näkevät sen ja sitä jaetaan usein, kun taas osiokuvitukset pysyvät medium-tasolla, sillä ne näkyvät sivulla pienempinä ja alempana. Tässä esimerkissä tekoälyn käytöstä rekrytoinnissa viidelle osiolle tämä kompromissi leikkaa laskua ilman, että lukija huomaa mitään.

from openai import OpenAI
import base64
import json

client = OpenAI()

def illustrate_article(title: str, sections: list[str], style: str, output_dir: str = "."):
    """
    Generoi otsikkokuvituksen + yhden kuvituksen per osio.
    """
    results = []

    # Kansikuva
    header_prompt = (
        f"Kansikuva artikkelille otsikolla \"{title}\", "
        f"{style} tyyli, panoraamasommittelu, "
        "ei tekstiä kuvassa, ammattimainen"
    )

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

    # Osiokuvitukset
    for i, section in enumerate(sections):
        section_prompt = (
            f"Kuvitus osiolle \"{section}\" "
            f"artikkelissa \"{title}\", "
            f"{style} tyyli, pystysuora formaatti, "
            "käsitteellinen kuvitus ilman tekstiä"
        )

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

    return results


illustrate_article(
    title="5 tapaa, joilla tekoäly muuttaa rekrytointia",
    sections=[
        "Automaattinen CV-seulonta",
        "Tekoälyn analysoimat videohaastattelut",
        "Älykäs ehdokas-tehtäväsovitus",
        "Rekrytointiharhan vähentäminen",
        "Henkilökohtainen perehdyttäminen",
    ],
    style="3D-isometrinen kuvitus, siniset ja violetit sävyt",
    output_dir="."
)

Kuvaile kuva generoidaksesi sen uudelleen eri tavalla

Miten saat kesämaisemasta talviversion, kun sinulla on vain tiedosto, ei maskia eikä muokkaustyökaluja? Kulje kielen kautta. Mallin visio analysoi kuvan ja tuottaa kuvauksen, joka on tarpeeksi tarkka toimiakseen rekonstruktiokehotteena – aihe, sommittelu, valaistus, värit, tyyli, perspektiivi, tunnelma. Liität sitten muokkausohjeesi tähän kuvaukseen. Generointimalli vastaanottaa täydellisen tekstikehotteen, jossa vain vuodenaika on muuttunut, ja saat alkuperäisen kanssa yhteensopivan kuvan sen sijaan, että saisit jotain aiheeseen liittymätöntä. Tämä on myös luotettavin tapa toistaa sellaisen referenssikuvan visuaalinen identiteetti, jota et voi muokata suoraan.

from openai import OpenAI
import base64

client = OpenAI()

def analyze_and_vary(image_path: str, instruction: str, output: str):
    """
    1. Analysoi kuvan GPT Visiolla
    2. Generoi variantin analyysin perusteella
    """
    # Vaihe 1: Analysoi kuva
    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": (
                            "Kuvaile tämä kuva yksityiskohtaisesti, jotta kuva- "
                            "generointimalli voi toistaa sen uskollisesti. "
                            "Sisällytä: aihe, sommittelu, valaistus, värit, tyyli, "
                            "perspektiivi, tunnelma. Ole erittäin tarkka."
                        )
                    },
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/png;base64,{image_b64}"
                        }
                    }
                ]
            }
        ]
    )

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

    # Vaihe 2: Generoi muokattu variantti
    variant_prompt = f"{description}. Pyydetty muutos: {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"Variantti generoitu: {output}")


analyze_and_vary(
    "original_landscape.png",
    "Vaihda vuodenaika kesästä talveen, lunta katoilla ja puissa",
    "winter_landscape.png"
)

Käsittele suuria määriä erissä

Viiden tuotekuvan generointi sarjassa vie minuutteja; viidensadan generointi peräkkäin vie koko yön ja kaatuu ensimmäiseen verkkohäiriöön. Alla oleva ratkaisu ratkaisee molemmat ongelmat. Jokainen tehtävä on itsenäinen sanakirja, joka sisältää sen tunnisteen, kehotteen, tulostetiedoston ja asetukset. Työntekijäfunktio käärii kutsun try-lohkoon, joka palauttaa tilan kaatamatta koko erää: hylätty generointi ei enää kaada muita neljääsataayhdeksääkymmentäyhdeksää. ThreadPoolExecutor rinnakkaistaa suorituksen, mutta tarkoituksellisen alhaisella max_workers-arvolla – tässä esimerkissä kolme – koska pullonkaula ei ole koneesi, vaan API-kiintiöt. Lopullinen raportti laskee onnistumiset ja virheet, jotta tiedät, mitä yritetään uudelleen.

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:
    """Generoi yhden kuvan tehtävän perusteella."""
    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):
    """Suorittaa generointierän hallitulla rinnakkaisuudella."""
    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']}")

    # Raportti
    ok = sum(1 for r in results if r["status"] == "ok")
    errors = sum(1 for r in results if r["status"] == "error")
    print(f"\nValmis: {ok} onnistui, {errors} virhettä yhteensä {len(tasks)} tehtävästä")

    return results


# Määritä tehtäväerä
tasks = [
    {
        "id": f"product_{i}",
        "prompt": f"Verkkokaupan tuotekuva: {product}, valkoinen tausta, studio",
        "output": f"batch_product_{i}.png",
        "quality": "high"
    }
    for i, product in enumerate([
        "ruusukultakello",
        "lentäjän aurinkolasit",
        "punosnahkaranneke",
        "solitaire-timanttisormus",
        "viljelty helminauha",
    ])
]

results = batch_generation(tasks, max_parallel=3)

Julkaise suoraan tallennustilaan

PNG-tiedoston kirjoittaminen skriptiä suorittavan koneen levylle on järkevää vain kehitysvaiheessa. Tuotannossa kuvan on päädyttävä sinne, mistä sivustosi hakee sen, ja paikallisen tiedostojärjestelmän kautta kiertäminen muodostuu tarpeettomaksi vikapisteeksi. b64_json-muoto sopii hyvin tämän poistamiseen: puretut bitit kääritään BytesIO-objektiin ja työnnetään suoraan bucketiin eksplisiittisellä ContentType-arvolla – ilman tätä selaimet tarjoaisivat latausta kuvan näyttämisen sijaan. Funktio palauttaa julkisen URL-osoitteen, jota CMS-järjestelmäsi todella tarvitsee.

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):
    """Generoi kuvan ja lataa sen suoraan S3:een."""
    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"Kuva tallennettu S3:een: {url}")
    return url


# Esimerkki
url = generate_and_store_s3(
    "Mobiilisovelluksen kuvake: avoin kirja tähtineen, litteä design",
    "my-image-bucket",
    "generated/app_icon_v1.png"
)

Mikä pitää putken pystyssä

Tämän oppitunnin viidellä putkella on sama rakennushygienia. Jokainen vaihe tekee yhden asian, jolloin voit korvata kehotteen kirjoittamisen tai tallennuksen koskematta muuhun. Jokainen vaihe käsittelee omat virheensä; muuten moderointikieltäytyminen erän keskellä kaataa koko ketjun – juuri tämän generate_one_image-funktion try-lohko estää. Rinnakkaisuus pidetään kurissa nopeusrajoitusten kunnioittamiseksi, ja tässä kohdassa varovaisuus maksaa vähemmän kuin toipuminen väliaikaisen eston jälkeen.

Jäljellä on kaksi vähemmän näkyvää, mutta yhtä ratkaisevaa tapaa. Lokita lähetetyt kehotteet, erityisesti kun kielimalli on kirjoittanut ne: ilman tätä lokia rakastamasi kuva muuttuu toistamattomaksi toisella ajokerralla. Ja välimuistita tulokset aina, kun sama kehote saattaa palata, minkä seuraava oppitunti formalisoi täydelliseksi järjestelmäksi.

Koko nyt oma täysi ketjusi: se ottaa syötteenä artikkelin otsikon, pyytää kielimallilta kolme kuvausta asiaankuuluvista visuaalisista elementeistä, generoi kolme kuvaa rinnakkain ja tuottaa yhteenveto-JSON:n, joka linkittää jokaisen kehotteen sen tiedostoon. Sinulla on sitten kaikki tarvittava koko blogin havainnollistamiseen ilman manuaalista puuttumista.