Apvieno attēlu ģenerēšanu ar citiem API rīkiem
Šajā lapā
Atjauninājums: 2026. gada 2. novembris — Attēlu modeļi.
gpt-image-1, modelis, kuram sākotnēji bija paredzēts šis kurss, tika pārtraukts 2026. gada 23. oktobrī.gpt-image-1.5,gpt-image-1-miniunchatgpt-image-latesttiks izslēgti 2026. gada 1. decembrī. Piemēros tagad tiek izmantotsgpt-image-2.5-sunburst, kas nodrošina augstāko precizitāti rediģēšanai;gpt-image-2.5-flareir ātrāks standarta ģenerēšanai. Abi modeļi atbalsta arīxhighunmaxkvalitātes iestatījumus. GPT Image modeļi vienmēr atgriež attēlus base64 formātā: vecāku DALL·E modeļu parametrsresponse_formatnetiek atbalstīts un ir izņemts no koda. Avots: Attēlu ģenerēšana (OpenAI).
Apvieno attēlu ģenerēšanu ar citiem API rīkiem
Atsevišķi attēlu ģenerēšana ir tikai amatniecisks rīks: tu uzraksti promptu un saņem failu. Tā īstais spēks atklājas, kad tā kļūst par vienu posmu automatizētā ķēdē — valodas modelis, kas raksta promptu, redzes analīze, kas apraksta atsauces attēlu, vai krātuve, kas publicē rezultātu. Šī nodarbība parāda, kā savienot šīs daļas vienotā veselumā.
Liec valodas modelim uzrakstīt promptu
Tavi lietotāji vai kolēģi neraksta vizuālos promptus; viņi raksta uzdevumus. „Man vajag attēlu rakstam par mākslīgo intelektu veselības aprūpē, futūristisku, bet cilvēcīgu” nesatur nekādu kompozīciju, apgaismojumu vai paleti. Tā vietā, lai liktu viņiem apgūt iepriekšējā nodarbībā minēto vārdu krājumu, iekļauj valodas modeli, kas veic šo tulkošanu. Piešķir tam mākslinieciskā vadītāja lomu sistēmas ziņojumā un pieprasi, lai tas ģenerē konkrētās prompta slāņa detaļas, ar stingru norādi neko citu neatbildēt. Pretējā gadījumā tu saņemsi pieklājīgu skaidrojumu, kas pēc tam būtu jāsūta tālāk uz GPT Image.
from openai import OpenAI
import base64
client = OpenAI()
def text_to_image(brief: str, output: str):
"""
Divu posmu caurule:
1. LLM ģenerē optimālo vizuālo promptu
2. GPT Image izveido attēlu
"""
# 1. posms: Ģenerē vizuālo promptu, izmantojot LLM
completion = client.chat.completions.create(
model="gpt-5.6-luna",
messages=[
{
"role": "system",
"content": (
"Tu esi eksperts mākslinieciskais vadītājs. "
"Pamatojoties uz uzdevumu, ģenerē detalizētu promptu "
"attēlu ģenerēšanas modelim. Iekļauj: subjektu, kompozīciju, apgaismojumu, "
"stilu, perspektīvu, krāsu paleti. "
"Atbildi tikai ar promptu, bez skaidrojumiem."
)
},
{"role": "user", "content": brief}
]
)
visual_prompt = completion.choices[0].message.content
print(f"Ģenerēts prompts: {visual_prompt[:100]}...")
# 2. posms: Ģenerē attēlu
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"Attēls ģenerēts: {output}")
return visual_prompt
prompt = text_to_image(
"Man vajag attēlu rakstam par mākslīgo intelektu "
"veselības aprūpē. Futūristisku, bet cilvēcīgu.",
"ai_health.png"
)
Ilustrē rakstu no sākuma līdz beigām
Plašam rakstam ir nepieciešams vāka attēls un viena ilustrācija katrai nodaļai. Šiem attēliem ir jāizskatās saskaņoti, bet tie nedrīkst būt identiski. Funkcija illustrate_article īsteno šo loģiku, atkārtoti ievietojot stilu katrā promptā un katru reizi atkārtojot raksta nosaukumu, tādējādi piešķirot visai kopai tematisku vienotību. Divas izmaksas taupošas detaļas ir pelnījušas uzmanību: vāks tiek ģenerēts ar high kvalitāti, jo to redz visi un tas bieži tiek koplietots, savukārt nodaļu ilustrācijas paliek medium līmenī, jo tās lapā tiek attēlotas mazākas un zemāk. Piecām nodaļām šajā piemērā par mākslīgo intelektu darbā pieņemšanā šis kompromiss samazina rēķinu, lasītājam neko nemanot.
from openai import OpenAI
import base64
import json
client = OpenAI()
def illustrate_article(title: str, sections: list[str], style: str, output_dir: str = "."):
"""
Ģenerē galvenes ilustrāciju + vienu katrai nodaļai.
"""
results = []
# Vāka attēls
header_prompt = (
f"Vāka attēls rakstam ar nosaukumu \"{title}\", "
f"{style} stilā, panorāmiska kompozīcija, "
"bez teksta attēlā, profesionāls"
)
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"Galvene: {path}")
# Nodaļu ilustrācijas
for i, section in enumerate(sections):
section_prompt = (
f"Ilustrācija nodaļai \"{section}\" "
f"rakstā par \"{title}\", "
f"{style} stilā, taisnstūra formāts, "
"konceptuāla ilustrācija bez teksta"
)
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"Nodaļa {i+1} ({section[:30]}...) : {path}")
return results
illustrate_article(
title="5 veidi, kā mākslīgais intelekts maina darbā pieņemšanu",
sections=[
"Automātiska CV atlase",
"Mākslīgā intelekta analizētas video intervijas",
"Vieda kandidātu un darba vietu saskaņošana",
"Darbā pieņemšanas aizspriedumu mazināšana",
"Personalizēta iepazīšanās ar darbu",
],
style="3D izometriskā ilustrācija, zili un violeti toņi",
output_dir="."
)
Apraksti attēlu, lai to ģenerētu citādāk
Kā iegūt vasaras ainavas ziemas versiju, ja tev ir tikai fails, bez maskas un bez rediģēšanas rīkiem? Izmanto valodu. Modeļa redze analizē attēlu un rada tik precīzu aprakstu, ka tas kalpo kā rekonstrukcijas prompts — subjekts, kompozīcija, apgaismojums, krāsas, stils, perspektīva, noskaņa. Pēc tam tu pievieno šim aprakstam savu modificēšanas instrukciju. Ģenerēšanas modelis saņem pilnu teksta promptu, kurā mainīta ir tikai gadalaika daļa, un tu iegūsti attēlu, kas ir saskaņots ar oriģinālu, nevis kaut ko nesakarīgu. Tas ir arī uzticamākais veids, kā reproducēt atsauces attēla vizuālo identitāti, kuru nevari rediģēt tieši.
from openai import OpenAI
import base64
client = OpenAI()
def analyze_and_vary(image_path: str, instruction: str, output: str):
"""
1. Analizē attēlu, izmantojot GPT Vision
2. Ģenerē variantu, pamatojoties uz analīzi
"""
# 1. posms: Analizē attēlu
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": (
"Apraksti šo attēlu detalizēti, lai attēlu "
"ģenerēšanas modelis to varētu precīzi reproducēt. "
"Iekļauj: subjektu, kompozīciju, apgaismojumu, krāsas, stilu, "
"perspektīvu, noskaņu. Esi ļoti precīzs."
)
},
{
"type": "image_url",
"image_url": {
"url": f"data:image/png;base64,{image_b64}"
}
}
]
}
]
)
description = analysis.choices[0].message.content
print(f"Analīze: {description[:150]}...")
# 2. posms: Ģenerē modificētu variantu
variant_prompt = f"{description}. Pieprasītā modifikācija: {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"Variants ģenerēts: {output}")
analyze_and_vary(
"original_landscape.png",
"Maini gadalaiku no vasaras uz ziemu, ar sniegu uz jumtiem un kokiem",
"winter_landscape.png"
)
Apstrādā lielus apjomus partijās
Piecu produktu vizuālu ģenerēšana virknē aizņem minūtes; piecu simtu ģenerēšana secīgi aizņem visu nakti un apstājas pie pirmās tīkla kļūmes. Tālāk aprakstītā iestatīšana atrisina abas problēmas. Katrs uzdevums ir pašpietiekama vārdnīca, kas nes savu ID, promptu, izvades failu un iestatījumus. Strādnieka funkcija ietver izsaukumu try blokā, kas atgriež statusu, nevis sabojā visu partiju: noraidīta ģenerēšana vairs nenogāž pārējos četrus simtus deviņdesmit deviņus. ThreadPoolExecutor tad paralelizē izpildi, bet ar apzināti zemu max_workers vērtību — šajā piemērā trīs —, jo pudeles kakls nav tavs dators, bet gan API kvotas. Nobeiguma ziņojums saskaita veiksmes un kļūdas, lai zinātu, ko atkārtot.
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:
"""Ģenerē vienu attēlu no uzdevuma."""
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):
"""Izpilda ģenerēšanas partiju ar kontrolētu paralelismu."""
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']}")
# Ziņojums
ok = sum(1 for r in results if r["status"] == "ok")
errors = sum(1 for r in results if r["status"] == "error")
print(f"\nPabeigts: {ok} veiksmīgi, {errors} kļūdas no {len(tasks)} uzdevumiem")
return results
# Definē uzdevumu partiju
tasks = [
{
"id": f"product_{i}",
"prompt": f"E-komercijas produkta foto: {product}, balts fons, studija",
"output": f"batch_product_{i}.png",
"quality": "high"
}
for i, product in enumerate([
"rozā zelta pulkstenis",
"aviatoru saulesbrilles",
"pināta ādas aproce",
"solitēra dimanta gredzens",
"kultivētu pērļu kaklarota",
])
]
results = batch_generation(tasks, max_parallel=3)
Publicē tieši krātuvē
PNG faila rakstīšana tajā datorā, kurā tiek palaists skripts, ir jēga tikai izstrādes vidē. Produkcijā attēlam ir jānonāk tur, no kurienes tava vietne to paņems, un novirzīšanās caur lokālo failu sistēmu kļūst par lieku kļūmes punktu. Formāts b64_json ir piemērots šai noņemšanai: dekodētie baiti tiek ietīti BytesIO objektā un nosūtīti tieši uz konteineru (bucket), norādot eksplicītu ContentType — bez tā pārlūkprogrammas piedāvātu lejupielādi, nevis attēlotu attēlu. Funkcija atgriež publisko URL, kas ir tas, kas tavai CMS sistēmai patiesībā ir nepieciešams.
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):
"""Ģenerē attēlu un augšupielādē to tieši uz 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"Attēls saglabāts S3: {url}")
return url
# Piemērs
url = generate_and_store_s3(
"Mobilās lietotnes ikona: atvērta grāmata ar zvaigznēm, plakans dizains",
"my-image-bucket",
"generated/app_icon_v1.png"
)
Kas notur cauruli darbībā
Piecas šīs nodarbības caurules dalās vienādā konstruēšanas higiēnā. Katrs solis dara vienu lietu, ļaujot aizstāt promptu rakstīšanu vai krātuvi, nepieskaroties pārējam. Katrs solis apstrādā savas kļūdas; pretējā gadījumā moderācijas atteikums partijas vidū nogāž visu ķēdi — tieši to novērš try bloks funkcijā generate_one_image. Paralelisms tiek turēts ierobežots, lai ievērotu ātruma limitus, un šajā ziņā piesardzība maksā mazāk nekā atjaunošana pēc pagaidu aizlieguma.
Paliek divi mazāk redzami, bet tikpat izšķiroši ieradumi. Reģistrē faktiski nosūtītos promptus, it īpaši, ja tos raksta valodas modelis: bez šī žurnāla attēls, kas tev patīk, kļūst neatkārtojams otrajā reizē. Un kešo rezultātus, kad vien tas pats prompts varētu atkārtoties, ko nākamā nodarbība formalizē pilnīgā sistēmā.
Tagad saliec savu pilno ķēdi: tā kā ievadi saņem raksta nosaukumu, lūdz valodas modelim trīs atbilstošu vizuālo aprakstu variantus, ģenerē trīs attēlus paralēli un izveido kopsavilkuma JSON, kas saista katru promptu ar tā failu. Tad tev būs viss nepieciešamais, lai ilustrētu veselu emuāru bez manuālas iejaukšanās.