Derinkite vaizdų generavimą su kitais API įrankiais
Šiame puslapyje
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-miniirchatgpt-image-latestbus pašalinti 2026 m. gruodžio 1 d.. Pavyzdžiuose dabar naudojamasgpt-image-2.5-sunburst, kuris užtikrina didžiausią tikslumą redaguojant;gpt-image-2.5-flareyra greitesnis standartiniam generavimui. Abu modeliai taip pat palaikoxhighirmaxkokybės nustatymus. GPT Image modeliai visada grąžina vaizdus base64 formatu: senesnių DALL·E modelių parametrasresponse_formatnepalaikomas 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.