Łączenie generowania obrazów z innymi narzędziami API
Na tej stronie
- Łączenie generowania obrazów z innymi narzędziami API
- Powierz napisanie promptu modelowi językowemu
- Ilustrowanie artykułu od A do Z
- Opisywanie obrazu w celu jego ponownego wygenerowania w innej wersji
- Przetwarzanie dużych wolumenów w partiach (batch)
- Publikacja bezpośrednio w storage
- Co utrzymuje potok przy życiu
Aktualizacja z 2 listopada 2026 — Modele obrazowe. Model
gpt-image-1, dla którego pierwotnie napisano ten kurs, został wycofany 23 października 2026. Modelegpt-image-1.5,gpt-image-1-miniorazchatgpt-image-latestprzestaną być dostępne 1 grudnia 2026. Przykłady wykorzystują obecnie modelgpt-image-2.5-sunburst, który oferuje najwyższą precyzję podczas edycji; modelgpt-image-2.5-flarejest szybszy przy standardowym generowaniu. Oba modele obsługują również ustawienia jakościxhighimax. Modele GPT Image zawsze zwracają obrazy w formacie base64: parametrresponse_formatze starszych modeli DALL·E nie jest obsługiwany i został usunięty z kodu. Źródło: Generowanie obrazów (OpenAI).
Łączenie generowania obrazów z innymi narzędziami API
Traktowane izolowanie generowanie obrazów to jedynie rzemieślnicze narzędzie: wpisujesz prompt, otrzymujesz plik. Jego prawdziwa moc ujawnia się, gdy staje się jednym z ogniw zautomatyzowanego łańcucha — gdzie model językowy pisze prompt, analiza wizyjna opisuje obraz referencyjny, a system storage publikuje wynik. Ta lekcja pokaże Ci, jak połączyć te elementy w całość.
Powierz napisanie promptu modelowi językowemu
Twoi użytkownicy czy koledzy nie piszą promptów wizualnych; tworzą briefy. Zdanie „Potrzebuję obrazu do artykułu o AI w ochronie zdrowia, futurystycznego, ale ludzkiego“ nie zawiera żadnych wskazówek dotyczących kompozycji, oświetlenia czy palety barw. Zamiast wymagać od nich nauki specjalistycznego słownictwa z poprzedniej lekcji, wpleć w proces model językowy, który zajmie się tłumaczeniem briefu na język wizualny. Nadaj mu rolę dyrektora artystycznego w wiadomości systemowej i zażądej, aby wygenerował konkretne warstwy promptu, z surowym poleceniem, by nie dodawał niczego więcej. W przeciwnym razie otrzymasz uprzejme wyjaśnienie, które i tak musiałbyś później przesłać do GPT Image.
from openai import OpenAI
import base64
client = OpenAI()
def text_to_image(brief: str, output: str):
"""
Dwuetapowy potok:
1. LLM generuje optymalny prompt wizualny
2. GPT Image tworzy obraz
"""
# Krok 1: Generowanie promptu wizualnego za pomocą LLM
completion = client.chat.completions.create(
model="gpt-5.6-luna",
messages=[
{
"role": "system",
"content": (
"Jesteś ekspertem dyrektorem artystycznym. "
"Na podstawie briefu wygeneruj szczegółowy prompt dla "
"modelu generującego obrazy. Uwzględnij: temat, kompozycję, oświetlenie, "
"styl, perspektywę, paletę kolorów. "
"Odpowiedz wyłącznie promptem, bez żadnych wyjaśnień."
)
},
{"role": "user", "content": brief}
]
)
visual_prompt = completion.choices[0].message.content
print(f"Wygenerowany prompt: {visual_prompt[:100]}...")
# Krok 2: Generowanie obrazu
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"Obraz wygenerowany: {output}")
return visual_prompt
prompt = text_to_image(
"Potrzebuję obrazu do artykułu o sztucznej inteligencji "
"w ochronie zdrowia. Futurystyczny, ale ludzki.",
"ai_health.png"
)
Ilustrowanie artykułu od A do Z
Artykuł feature wymaga obrazu tytułowego oraz jednej ilustracji do każdej sekcji. Obrazy te muszą wyglądać spójnie, nie będąc identycznymi. Funkcja illustrate_article realizuje tę logikę, wstrzykując styl do każdego promptu i powtarzając tytuł artykułu za każdym razem, co nadaje całemu zestawowi tematyczną jedność. Warto zwrócić uwagę na dwa szczegóły oszczędzające koszty: obraz tytułowy jest generowany w jakości high, ponieważ widzi go każdy i często jest udostępniany, podczas gdy ilustracje sekcji pozostają w jakości medium, gdyż wyświetlają się mniejsze i niżej na stronie. W przypadku pięciu sekcji w tym przykładzie dotyczącym AI w rekrutacji, taki kompromis obniża rachunek, nie wpływając na odbiór czytelnika.
from openai import OpenAI
import base64
import json
client = OpenAI()
def illustrate_article(title: str, sections: list[str], style: str, output_dir: str = "."):
"""
Generuje ilustrację nagłówka + po jednej dla każdej sekcji.
"""
results = []
# Obraz tytułowy (header)
header_prompt = (
f"Obraz tytułowy do artykułu pt. \"{title}\", "
f"styl {style}, kompozycja panoramiczna, "
"brak tekstu na obrazie, profesjonalny"
)
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"Nagłówek: {path}")
# Ilustracje sekcji
for i, section in enumerate(sections):
section_prompt = (
f"Ilustracja do sekcji \"{section}\" "
f"artykułu pt. \"{title}\", "
f"styl {style}, format prostokątny, "
"ilustracja koncepcyjna bez tekstu"
)
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"Sekcja {i+1} ({section[:30]}...) : {path}")
return results
illustrate_article(
title="5 sposobów, w jakie AI transformuje rekrutację",
sections=[
"Automatyczna weryfikacja CV",
"Wywiady wideo analizowane przez AI",
"Inteligentne dopasowanie kandydat-do-pracy",
"Redukcja błędów w rekrutacji",
"Spersonalizowany onboarding",
],
style="ilustracja izometryczna 3D, odcienie niebieskiego i fioletu",
output_dir="."
)
Opisywanie obrazu w celu jego ponownego wygenerowania w innej wersji
Jak uzyskać zimową wersję letniego krajobrazu, mając tylko plik, bez maski i narzędzi do edycji? Skorzystaj z języka. Model wizyjny analizuje obraz i tworzy opis na tyle precyzyjny, by mógł posłużyć jako prompt do rekonstrukcji — temat, kompozycja, oświetlenie, kolory, styl, perspektywa, nastrój. Następnie doklejasz do tego opisu swoją instrukcję modyfikacji. Model generujący otrzymuje kompletny prompt tekstowy, w którym zmieniono tylko porę roku, co pozwala uzyskać obraz spójny z oryginałem, a nie coś zupełnie unrelated. Jest to również najbardziej niezawodny sposób na odtworzenie identyfikacji wizualnej obrazu referencyjnego, którego nie możesz edytować bezpośrednio.
from openai import OpenAI
import base64
client = OpenAI()
def analyze_and_vary(image_path: str, instruction: str, output: str):
"""
1. Analizuje obraz za pomocą GPT Vision
2. Generuje wariant na podstawie analizy
"""
# Krok 1: Analiza obrazu
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": (
"Opisz ten obraz szczegółowo, aby model generujący obrazy "
"mógł go wiernie odtworzyć. Uwzględnij: temat, kompozycję, "
"oświetlenie, kolory, styl, perspektywę, nastrój. Bądź bardzo precyzyjny."
)
},
{
"type": "image_url",
"image_url": {
"url": f"data:image/png;base64,{image_b64}"
}
}
]
}
]
)
description = analysis.choices[0].message.content
print(f"Analiza: {description[:150]}...")
# Krok 2: Generowanie zmodyfikowanego wariantu
variant_prompt = f"{description}. Żądana modyfikacja: {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"Wariant wygenerowany: {output}")
analyze_and_vary(
"original_landscape.png",
"Zmień porę roku z lata na zimę, ze śniegiem na dachach i drzewach",
"winter_landscape.png"
)
Przetwarzanie dużych wolumenów w partiach (batch)
Wygenerowanie pięciu grafik produktowych szeregowo zajmuje minuty; wygenerowanie pięciuset sekwencyjnie trwa całą noc i urywa się przy pierwszej awarii sieci. Poniższa konfiguracja rozwiązuje oba problemy. Każde zadanie to samodzielny słownik zawierający jego ID, prompt, plik wyjściowy i ustawienia. Funkcja worker otacza wywołanie blokiem try, który zwraca status zamiast crashować całą partię: odrzucone generowanie nie pociąga za sobą pozostałych czterystu dziewięćdziesięciu dziewięciu zadań. ThreadPoolExecutor równolegli wykonanie, ale z celowo niskim parametrem max_workers — trzy w tym przykładzie — ponieważ wąskim gardłem nie jest Twoja maszyna, lecz limity API (rate limits). Końcowy raport zlicza sukcesy i błędy, abyś wiedział, co należy ponowić.
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:
"""Generuje pojedynczy obraz na podstawie zadania."""
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):
"""Wykonuje partię generowań z kontrolowanym równolegleniem."""
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']}")
# Raport
ok = sum(1 for r in results if r["status"] == "ok")
errors = sum(1 for r in results if r["status"] == "error")
print(f"\nZakończono: {ok} ok, {errors} błędów na {len(tasks)} zadań")
return results
# Definicja partii zadań
tasks = [
{
"id": f"product_{i}",
"prompt": f"Zdjęcie produktu e-commerce: {product}, białe tło, studio",
"output": f"batch_product_{i}.png",
"quality": "high"
}
for i, product in enumerate([
"zegarek z różowego złota",
"okulary przeciwsłoneczne lotnicze",
"pleciona bransoletka skórzana",
"pierścionek z brylantem soliter",
"naszyjnik z hodowlanych pereł",
])
]
results = batch_generation(tasks, max_parallel=3)
Publikacja bezpośrednio w storage
Zapisywanie pliku PNG na dysku maszyny uruchamiającej skrypt ma sens tylko w środowisku deweloperskim. W produkcji obraz musi trafić tam, skąd pobierze go Twoja strona, a omijanie lokalnego systemu plików staje się niepotrzebnym punktem awarii. Format b64_json idealnie nadaje się do tego celu: zdekodowane bajty są opakowywane w obiekt BytesIO i wysyłane bezpośrednio do bucketu, z jawnie określonym ContentType — bez którego przeglądarki zaproponowałyby pobranie pliku zamiast wyświetlenia obrazu. Funkcja zwraca publiczny URL, czego tak naprawdę potrzebuje Twój 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):
"""Generuje obraz i przesyła go bezpośrednio do 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"Obraz zapisany na S3: {url}")
return url
# Przykład
url = generate_and_store_s3(
"Ikona aplikacji mobilnej: otwarta książka z gwiazdami, płaski design",
"my-image-bucket",
"generated/app_icon_v1.png"
)
Co utrzymuje potok przy życiu
Pięć potoków przedstawionych w tej lekcji łączy ta sama higiena konstrukcji. Każdy krok robi jedną rzecz, co pozwala Ci wymienić sposób pisania promptów lub mechanizm storage bez dotykania reszty. Każdy krok obsługuje własne błędy; w przeciwnym razie odmowa moderacji w środku partii ściągnęłaby cały łańcuch — dokładnie temu zapobiega blok try w funkcji generate_one_image. Równoleglenie pozostaje ograniczone, aby respektować limity częstotliwości (rate limits), a w tym punkcie ostrożność kosztuje mniej niż odzyskiwanie sprawności po tymczasowym banie.
Pozostają dwa mniej widoczne, ale równie decydujące nawyki. Loguj faktycznie wysłane prompty, zwłaszcza gdy są pisane przez model językowy: bez tego logu obraz, który pokochałeś, stanie się nie do odtworzenia przy drugiej próbie. I cache’uj wyniki, gdy ten sam prompt może zostać użyty ponownie, co następna lekcja sformalizuje w kompletny system.
Teraz złóż swój własny pełny łańcuch: przyjmuje tytuł artykułu jako dane wejściowe, prosi model językowy o trzy opisy odpowiednich grafik, generuje te trzy obrazy równolegle i tworzy podsumowujący plik JSON łączący każdy prompt z jego plikiem. Będziesz wtedy mieć wszystko, czego potrzebujesz, aby zilustrować całego bloga bez ręcznej interwencji.