Kombineeri pildigeneratsioon teiste API-tööriistadega
Sellel lehel
Uuendus 2. novembril 2026 — Pildimudelid. Mudel
gpt-image-1, mille jaoks see kursus algselt kirjutati, lõpetas tegevuse 23. oktoobril 2026. Mudelidgpt-image-1.5,gpt-image-1-minijachatgpt-image-latestlõpetavad tegevuse 1. detsembril 2026. Näited kasutavad nüüd mudelitgpt-image-2.5-sunburst, mis pakub redigeerimisel suurimat täpsust;gpt-image-2.5-flareon tavapäraseks generatsiooniks kiirem. Mõlemad mudelid toetavad ka kvaliteedisätteidxhighjamax. GPT Image mudelid tagastavad pildid alati base64-formaadis: vanemate DALL·E mudelite parameeterresponse_formatei 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.