Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Kombiniranje ustvarjanja slik z drugimi orodji API

Lekcija 10 od 12 Posodobljeno 2. november 2026 Razvijalec
Na tej strani
  1. Kombiniranje ustvarjanja slik z drugimi orodji API
  2. Naj jezikovni model napiše poziv
  3. Ilustracija članka od začetka do konca
  4. Opis slike za njeno drugačno regeneracijo
  5. Obdelava velikih količin v serijah
  6. Neposredna objava v shrambo
  7. Kaj ohranja potek delovanja stabilnega

Posodobitev 2. novembra 2026 — modeli za slike. Model gpt-image-1, za katerega je bil ta tečaj prvotno napisan, je bil ukinjen 23. oktobra 2026. Modela gpt-image-1.5 in gpt-image-1-mini ter chatgpt-image-latest bodo upokojeni 1. decembra 2026. Primeri zdaj uporabljajo gpt-image-2.5-sunburst, ki ponuja najvišjo natančnost pri urejanju; gpt-image-2.5-flare je hitrejši za standardno ustvarjanje. Oba modela podpirata tudi nastavitvi kakovosti xhigh in max. Modeli GPT Image vedno vrnejo slike v formatu base64: parameter response_format iz starejših modelov DALL·E ni podprt in je bil odstranjen iz kode. Vir: Ustvarjanje slik (OpenAI).

Kombiniranje ustvarjanja slik z drugimi orodji API

Samo po sebi je ustvarjanje slik obrtno orodje: napišeš poziv in dobiš datoteko. Njegova prava moč pride do izraza, ko postane en korak v avtomatizirani verigi – jezikovni model, ki napiše poziv, vizualna analiza, ki opiše referenčno sliko, ali shramba, ki objavi rezultat. Ta lekcija ti pokaže, kako povezati te dele skupaj.

Naj jezikovni model napiše poziv

Tvoji uporabniki ali sodelavci ne pišejo vizualnih pozivov; pišejo briefinge. „Potrebujem sliko za članek o umetni inteligenci v zdravstvu, futuristično, a človeško” ne vsebuje ničesar o kompoziciji, osvetlitvi ali paleti. Namesto da bi od njih zahtevali učenje besedišča iz prejšnje lekcije, vstavi jezikovni model, ki bo poskrbel za prevod. Dodeli mu vlogo umetniškega direktorja v sistemskem sporočilu in zahtevaj, da proizvede specifične plasti poziva s strogimi navodili, naj ne izpiše ničesar drugega. V nasprotnem primeru boš prejel vljudno razlago, ki jo boš moral nato poslati modelu GPT Image.

from openai import OpenAI
import base64

client = OpenAI()

def text_to_image(brief: str, output: str):
    """
    Dvostopenjski potek:
    1. LLM ustvari optimalni vizualni poziv
    2. GPT Image ustvari sliko
    """
    # 1. korak: Ustvari vizualni poziv z LLM
    completion = client.chat.completions.create(
        model="gpt-5.6-luna",
        messages=[
            {
                "role": "system",
                "content": (
                    "You are an expert art director. "
                    "Based on a brief, generate a detailed prompt for an "
                    "image generation model. Include: subject, composition, lighting, "
                    "style, perspective, color palette. "
                    "Respond only with the prompt, no explanation."
                )
            },
            {"role": "user", "content": brief}
        ]
    )

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

    # 2. korak: Ustvari sliko
    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"Image generated: {output}")
    return visual_prompt


prompt = text_to_image(
    "I need an image for an article on artificial intelligence "
    "in healthcare. Futuristic but human.",
    "ai_health.png"
)

Ilustracija članka od začetka do konca

Poljudni članek potrebuje naslovno sliko in po eno ilustracijo za vsak razdelek. Te slike morajo izgledati kohezivno, ne smejo pa biti identične. Funkcija illustrate_article uporablja to logiko tako, da v vsak poziv ponovno vbrizga slog in vsakič ponovi naslov članka, kar celotnemu nizu daje tematsko enotnost. Pozornost zaslužita dve podrobnosti, ki varčujeta s stroški: naslovnica se ustvari v kakovosti high, ker jo vidijo vsi in se pogosto deli, medtem ko ilustracije razdelkov ostanejo na ravni medium, saj so na strani prikazane manjše in nižje. Pri petih razdelkih v tem primeru o AI pri zaposlovanju ta kompromis zmanjša stroške, bralec pa ne opazi razlike.

from openai import OpenAI
import base64
import json

client = OpenAI()

def illustrate_article(title: str, sections: list[str], style: str, output_dir: str = "."):
    """
    Ustvari naslovno ilustracijo in po eno za vsak razdelek.
    """
    results = []

    # Naslovna slika
    header_prompt = (
        f"Cover image for an article titled \"{title}\", "
        f"{style} style, panoramic composition, "
        "no text in the image, professional"
    )

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

    # Ilustracije razdelkov
    for i, section in enumerate(sections):
        section_prompt = (
            f"Illustration for the section \"{section}\" "
            f"of an article on \"{title}\", "
            f"{style} style, rectangular format, "
            "conceptual illustration without text"
        )

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

    return results


illustrate_article(
    title="5 Ways AI Is Transforming Recruitment",
    sections=[
        "Automatic CV Screening",
        "AI-Analyzed Video Interviews",
        "Smart Candidate-Job Matching",
        "Reducing Recruitment Bias",
        "Personalized Onboarding",
    ],
    style="3D isometric illustration, blue and violet tones",
    output_dir="."
)

Opis slike za njeno drugačno regeneracijo

Kako dobiti zimsko različico poletne pokrajine, ko imaš na voljo le datoteko, brez maske in brez orodij za urejanje? Preko jezika. Vizija modela analizira sliko in ustvari opis, ki je dovolj natančen, da služi kot poziv za rekonstrukcijo – subjekt, kompozicija, osvetlitev, barve, slog, perspektiva, razpoloženje. Temu opisu nato dodaš svoje navodilo za spremembo. Model za ustvarjanje prejme popoln besedni poziv, kjer se je spremenila le letna doba, in dobiš sliko, ki je koherentna z izvirnikom, namesto nekaj nepovezanega. To je tudi najbolj zanesljiv način za reprodukcijo vizualne identitete referenčne slike, ki je ne moreš neposredno urejati.

from openai import OpenAI
import base64

client = OpenAI()

def analyze_and_vary(image_path: str, instruction: str, output: str):
    """
    1. Analizira sliko z GPT Vision
    2. Ustvari varianto na podlagi analize
    """
    # 1. korak: Analiziraj sliko
    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": (
                            "Describe this image in detail so an image "
                            "generation model can reproduce it faithfully. "
                            "Include: subject, composition, lighting, colors, style, "
                            "perspective, mood. Be very precise."
                        )
                    },
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/png;base64,{image_b64}"
                        }
                    }
                ]
            }
        ]
    )

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

    # 2. korak: Ustvari spremenjeno varianto
    variant_prompt = f"{description}. Requested modification: {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 generated: {output}")


analyze_and_vary(
    "original_landscape.png",
    "Change the season from summer to winter, with snow on roofs and trees",
    "winter_landscape.png"
)

Obdelava velikih količin v serijah

Ustvarjanje petih vizualizacij izdelkov zaporedoma traja minute; ustvarjanje petsto zaporedoma traja vso noč in se ustavi ob prvi omrežni težavi. Spodnja nastavitev reši obe težavi. Vsaka naloga je samostojen slovar, ki nosi svoj ID, poziv, izhodno datoteko in nastavitve. Funkcija delavca ovije klic v blok try, ki vrne status namesto, da bi sesul celotno serijo: zavrnjeno ustvarjanje ne potegne dol ostalih štiristo devetindevetdesetih. ThreadPoolExecutor nato vzporedi izvajanje, vendar z namerno nizkim max_workers – v tem primeru tremi – ker ozko grlo ni tvoj računalnik, temveč kvote API-ja. Končno poročilo prešteje uspehe in napake, da veš, kaj je treba ponoviti.

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:
    """Ustvari eno sliko iz naloge."""
    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):
    """Izvede serijo ustvarjanj z nadzorovano vzporednostjo."""
    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']}")

    # Poročilo
    ok = sum(1 for r in results if r["status"] == "ok")
    errors = sum(1 for r in results if r["status"] == "error")
    print(f"\nFinished: {ok} ok, {errors} errors out of {len(tasks)} tasks")

    return results


# Definiraj serijo nalog
tasks = [
    {
        "id": f"product_{i}",
        "prompt": f"E-commerce product photo: {product}, white background, studio",
        "output": f"batch_product_{i}.png",
        "quality": "high"
    }
    for i, product in enumerate([
        "rose gold watch",
        "aviator sunglasses",
        "braided leather bracelet",
        "solitaire diamond ring",
        "cultured pearl necklace",
    ])
]

results = batch_generation(tasks, max_parallel=3)

Neposredna objava v shrambo

Zapisovanje PNG na disk stroja, ki izvaja skripto, ima smisel le med razvojem. V proizvodnem okolju mora slika pristati tam, kjer jo bo tvoja spletna stran pridobila, obhod prek lokalnega datotečnega sistema pa postane nepotrebna točka odpovedi. Format b64_json se za to odstranitev dobro obnese: dekodirani bajti so oviti v objekt BytesIO in neposredno potisnjeni v vsebnik (bucket) z eksplicitnim ContentType – brez tega bi brskalniki ponudili prenos namesto prikaza slike. Funkcija vrne javni URL, kar je tisto, kar tvoj CMS dejansko potrebuje.

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):
    """Ustvari sliko in jo neposredno naloži v 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"Image stored on S3: {url}")
    return url


# Primer
url = generate_and_store_s3(
    "Mobile app icon: open book with stars, flat design",
    "my-image-bucket",
    "generated/app_icon_v1.png"
)

Kaj ohranja potek delovanja stabilnega

Pet potekov delovanja v tej lekciji si deli isto higieno gradnje. Vsak korak opravi eno stvar, kar ti omogoča zamenjavo pisanja pozivov ali shranjevanja, ne da bi se dotaknil ostalega. Vsak korak obravnava svoje napake; v nasprotnem primeru bi zavrnitev zaradi moderacije sredi serije sesula celotno verigo – točno to preprečuje try v generate_one_image. Vzporednost ostaja omejena, da se spoštujejo omejitve hitrosti, in pri tej točki previdnost stane manj kot obnovitev po začasnem bloku.

Ostaneta še dve manj vidni, a enako odločilni navadi. Beleži dejansko poslane pozive, še posebej, ko jih napiše jezikovni model: brez tega dnevnika slika, ki ti je všeč, ob drugem zagonu postane nereproduciabilna. In predpomni rezultate, kadar se lahko vrne isti poziv, kar bo naslednja lekcija formalizirala v popoln sistem.

Zdaj sestavi svojo lastno celotno verigo: kot vhod vzame naslov članka, od jezikovnega modela zahteva tri opise ustreznih vizualizacij, vzporedno ustvari tri slike in proizvede povzetek JSON, ki povezuje vsak poziv z njegovo datoteko. Nato boš imel vse potrebno za ilustracijo celotnega bloga brez ročnega posredovanja.