Jak zautomatyzować generowanie obrazów na dużą skalę

Najłatwiejszym sposobem na automatyzację generowania obrazów na dużą skalę bez zarządzania kilkoma różnymi interfejsami API jest oddzielenie przepływu pracy od dostawcy modelu. Umieść każde żądanie obrazu w jednej kolejce, kieruj każde zadanie do bieżącego identyfikatora modelu i wysyłaj kompatybilne żądania przez jeden klucz CometAPI oraz bazowy adres URL zgodny z OpenAI https://api.cometapi.com/v1.

Ten poradnik buduje taki pipeline w Pythonie. Przyjmuje zadania produktowe, reklamowe i contentowe z kolejki JSON Lines; wybiera model; ogranicza współbieżność; ponawia próby w przypadku przejściowych błędów; zapisuje wyniki w postaci URL lub base64; oraz rejestruje zużycie i szacowany koszt dla każdego zadania. Przykład zachowuje niezbędne elementy produkcyjne w jednym zwartym bloku, abyś mógł przetestować przepływ pracy bez zamieniania artykułu w referencję kodu.

Jak zunifikowane Image API upraszcza generowanie wsadowe

Na końcu przepływ będzie wyglądał tak:

jobs.jsonl → bounded worker pool → CometAPI /v1/images/generations → object storage → manifest.jsonl

Kolejka i warstwa magazynu pozostają po Twojej stronie. Zmiana modeli obrazów zmienia wartość model, a nie system uwierzytelniania czy główną ścieżkę żądań. To praktyczna zaleta zunifikowanego Image API: wybór modelu staje się decyzją routingu wewnątrz jednego pipeline’u zamiast oddzielnej integracji z dostawcą.

Czego potrzebujesz, aby zautomatyzować generowanie obrazów?

Potrzebujesz Pythona 3.10 lub nowszego, pakietu requests, klucza CometAPI, zapisywalnej lokalizacji wyjściowej oraz co najmniej jednego aktualnego identyfikatora modelu obrazowego.

Zainstaluj jedyną zależność:

pip install requests

Ustaw klucz na serwerze, nigdy w kodzie przeglądarkowym ani w repozytorium:

export COMETAPI_KEY="your-key"

Bazowy adres URL to https://api.cometapi.com/v1, a kompatybilne zadania tekst-na-obraz używają POST /images/generations. Przed wdrożeniem zweryfikuj każdy model w live model catalog; katalog zwraca bieżący identyfikator, obsługiwany punkt końcowy, funkcje i metadane cenowe bez wymagania nagłówka autoryzacji.

Na dzień 20 sierpnia 2026 r. katalog na żywo zawierał dwie przydatne ścieżki:

Ta tabela jest punktem wyjścia, a nie stwierdzeniem, że modele mają identyczne możliwości. Rozmiar, jakość, format, wsparcie obrazów referencyjnych i zachowanie odpowiedzi pozostają specyficzne dla modelu. Sprawdź rekord modelu i podlinkowaną dokumentację przed przekazaniem parametrów opcjonalnych.

Jak zbudować wsadowy workflow generowania obrazów w Pythonie

1. Nadaj każdemu zadaniu trwały identyfikator

Użyj jednego obiektu JSON na linię, aby kolejka, eksport bazy danych lub zadanie z arkusza kalkulacyjnego mogły zasilać tego samego worker’a:

{"id":"sku-1001","kind":"product","prompt":"Studio product photo of a ceramic coffee dripper on a warm neutral background"}
{"id":"campaign-204","kind":"ad","prompt":"Editorial summer travel image, vivid natural light, wide composition, no text"}
{"id":"blog-088","kind":"content","prompt":"Minimal illustration of a developer automating a creative workflow, no text"}

Identyfikator staje się nazwą pliku wyjściowego i kluczem manifestu. W środowisku produkcyjnym użyj go jako klucza idempotencji i pomiń identyfikatory już oznaczone jako pomyślne przed ponownym przetwarzaniem kolejki.

2. Rutuj według typu zadania, a następnie weryfikuj w katalogu na żywo

Przykład mapuje prace produktowe na gpt-image-2 oraz prace reklamowe lub contentowe na doubao-seedream-4-5-251128. Zadanie może nadpisać ten wybór własnym polem model. Przy starcie worker pobiera publiczny katalog i odrzuca identyfikator, który nie jest już wymieniony.

To bezpieczniejsze niż twarde kodowanie specyficznego dla dostawcy SDK w całej aplikacji. Możesz zmienić trasę w jednym mapowaniu po ocenie jakości, opóźnień i ceny dla własnych promptów.

3. Ogranicz współbieżność zamiast uruchamiać cały wsad

Worker startuje z czterema równoległymi żądaniami. Ta liczba to zachowawcze ustawienie aplikacji, a nie uniwersalny limit usługi. Zmierz opóźnienia i odpowiedzi 429 dla swojego konta, a następnie celowo podnoś lub obniżaj MAX_WORKERS.

Tylko odpowiedzi 408, 429 oraz 5xx są ponawiane z wykładniczym backoffem i jitterem. Błędy uwierzytelniania, nieprawidłowe identyfikatory modeli i nieobsługiwane parametry kończą się natychmiast, ponieważ ponawianie tego samego błędnego żądania tylko dodaje opóźnienie.

4. Znormalizuj wynik przed zapisaniem

Modele obrazowe nie zawsze zwracają ten sam „kontener”. Udokumentowana odpowiedź GPT Image zawiera data[0].b64_json; inne kompatybilne modele mogą zwrócić data[0].url. Worker obsługuje oba przypadki, zapisuje obraz do pliku tymczasowego i zmienia jego nazwę dopiero po pomyślnym pobraniu lub dekodowaniu.

W produkcji zastąp lokalny katalog output/ przez S3, R2, GCS lub inny magazyn obiektowy. Nie traktuj URL-a hostowanego przez dostawcę jako trwałego magazynu, chyba że jego polityka retencji to wyraźnie przewiduje.

5. Rejestruj użycie, próby i szacowany koszt

Każdy wynik staje się zwartym wierszem manifestu z identyfikatorem zadania, modelem, zapisaną ścieżką, statusem oraz szacowanym kosztem w USD, gdy katalog na żywo dostarcza wystarczających danych cenowych. Nieudane zadania zachowują błąd zamiast znikać ze wsadu.

Kompletny skrypt Pythona do wsadowego generowania obrazów

Zapisz poniższy plik jako batch_image_pipeline.py, umieść kolejkę obok jako jobs.jsonl i uruchom python3 batch_image_pipeline.py.

import base64, json, os, random, time
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
import requests

BASE_URL = "https://api.cometapi.com/v1"
KEY = os.environ["COMETAPI_KEY"]
WORKERS = int(os.getenv("MAX_WORKERS", "4"))
OUT = Path("output")
ROUTES = {
    "product": "gpt-image-2",
    "ad": "doubao-seedream-4-5-251128",
    "content": "doubao-seedream-4-5-251128",
}

catalog = requests.get("https://api.cometapi.com/api/models", timeout=30)
catalog.raise_for_status()
CATALOG = {model["id"]: model for model in catalog.json()["data"]}

def generate(job):
    model = job.get("model", ROUTES[job["kind"]])
    if model not in CATALOG:
        raise ValueError(f"Unknown model: {model}")
    payload = {"model": model, "prompt": job["prompt"], "n": 1}
    if model == "gpt-image-2":
        payload.update(quality="low", size="1024x1024", output_format="jpeg")

    for attempt in range(4):
        response = requests.post(
            f"{BASE_URL}/images/generations",
            headers={"Authorization": f"Bearer {KEY}"},
            json=payload,
            timeout=180,
        )
        if response.status_code not in {408, 429} and response.status_code < 500:
            break
        time.sleep(2**attempt + random.random())
    response.raise_for_status()
    body = response.json()
    item = body["data"][0]

    if item.get("b64_json"):
        data = base64.b64decode(item["b64_json"])
        extension = body.get("output_format", "png")
    else:
        download = requests.get(item["url"], timeout=120)
        download.raise_for_status()
        data = download.content
        extension = {"image/png": "png", "image/webp": "webp"}.get(
            download.headers.get("content-type"), "jpg"
        )
    path = OUT / f"{job['id']}.{extension}"
    path.write_bytes(data)

    price, usage = CATALOG[model].get("pricing") or {}, body.get("usage", {})
    cost = price.get("per_request")
    if cost is None and price.get("input") is not None:
        cost = (usage.get("input_tokens", 0) * price["input"] +
                usage.get("output_tokens", 0) * price["output"]) / 1_000_000
    return {"id": job["id"], "model": model, "path": str(path),
            "estimated_usd": cost * price.get("ratio", 1) if cost is not None else None}

def safe_generate(job):
    try:
        return {"status": "success", **generate(job)}
    except Exception as error:
        return {"id": job["id"], "status": "failed", "error": str(error)}

OUT.mkdir(exist_ok=True)
jobs = [json.loads(line) for line in Path("jobs.jsonl").read_text().splitlines() if line]
with ThreadPoolExecutor(max_workers=WORKERS) as pool:
    results = list(pool.map(safe_generate, jobs))
with (OUT / "manifest.jsonl").open("w") as manifest:
    manifest.writelines(json.dumps(result) + "\n" for result in results)

Skrypt używa bieżącego katalogu w czasie działania, podczas gdy dwa rezerwowe mapowania to przykłady zweryfikowane 20 sierpnia 2026 r. Sprawdź je ponownie przed publikacją lub wdrożeniem kodu w innej dacie.

Jak przetestować wsadowy workflow generowania obrazów

Zacznij od jednego zadania i jednego worker’a:

MAX_WORKERS=1 python3 batch_image_pipeline.py

Pomyślna odpowiedź GPT Image ma następującą strukturę:

{
  "created": 1776841943,
  "output_format": "jpeg",
  "quality": "low",
  "size": "1024x1024",
  "usage": {
    "input_tokens": 16,
    "output_tokens": 208,
    "total_tokens": 224
  },
  "data": [{"b64_json": "<base64-image-data>"}]
}

Worker dekoduje obraz, zapisuje output/<job-id>.jpeg i dodaje wiersz sukcesu do output/manifest.jsonl. Jeśli model zwróci URL, worker pobiera go i zapisuje lokalną ścieżkę w tym samym formacie manifestu.

Kod został sprawdzony składniowo lokalnie. Wywołanie generowania na żywo nadal wymaga Twojego klucza CometAPI, więc uruchom test dymny z jednym zadaniem, zanim zwiększysz współbieżność.

Ile kosztuje wsadowe generowanie obrazów?

Cennik musi być oznaczony znacznikiem czasu, ponieważ stawki modeli się zmieniają. Na dzień 20 sierpnia 2026 r. live CometAPI model catalog zwracał poniższe pola ceny bazowej oraz współczynnik rozliczeniowy 0.8:

• gpt-image-2: 5 USD za 1M tokenów wejściowych i 30 USD za 1M tokenów wyjściowych; zastosowanie wymienionego współczynnika daje efektywne stawki 4 i 24 USD za 1M tokenów.
• doubao-seedream-4-5-251128: 0,04 USD za żądanie; zastosowanie wymienionego współczynnika daje 0,032 USD za żądanie.

CometAPI pricing guide wyjaśnia rozliczanie oparte na tokenach dla modeli z oficjalnym cennikiem oraz rozliczanie per wywołanie dla modeli wycenianych na żądanie. Skrypt odczytuje katalog przy uruchomieniu i stosuje tę samą zasadę:

token cost = ratio × (input tokens × input rate + output tokens × output rate) / 1,000,000

request cost = ratio × per-request price

Na przykład udokumentowana powyżej odpowiedź GPT Image raportuje 16 tokenów wejściowych i 208 tokenów wyjściowych. Używając wartości katalogu z 20 sierpnia, ten ilustracyjny wynik szacuje się na około 0,005056 USD. Rzeczywisty koszt zmienia się wraz z modelem, jakością, rozmiarem, promptem, ponowieniami i użyciem raportowanym w odpowiedzi. Traktuj odpowiedź API i panel użycia konta jako podstawę rozliczeń, a nie stałe założenie kosztu na obraz.

Uwzględnij także nieudane prace. Ponowienie po niepotwierdzonym timeout’cie może wytworzyć drugi płatny wynik, a technicznie udany obraz, który nie przejdzie weryfikacji, nadal zużywa budżet. Śledź zarówno koszt API, jak i współczynnik akceptacji:

effective cost per accepted image = total batch spend / approved images

Typowe błędy Image API i jak je naprawić

Nie ponawiaj każdego błędu. Trwałe żądanie 400 pozostanie nieprawidłowe, a nieograniczona pętla ponowień 429 może zamienić skok ruchu w zaległości.

Najlepsze praktyki dla produkcyjnego generowania obrazów na skalę

Przejdź z JSON Lines na trwałą kolejkę, gdy używasz wielu workerów. Ustaw czas widoczności (visibility timeout) dłuższy niż maksymalny czas generowania, potwierdzaj zadanie dopiero po zapisaniu obrazu i manifestu, a wyczerpane zadania wysyłaj do kolejki dead-letter do weryfikacji.

Trzymaj opcjonalne sterowanie w konfiguracji specyficznej dla modelu. Wspólny payload powinien zawierać tylko pola wspólne, takie jak model, prompt i n: 1; dodawaj quality, size lub output_format dopiero po potwierdzeniu ich w dokumentacji wybranego modelu. Jeśli dodasz routing awaryjny, wybierz model obsługujący to samo zadanie i zbuduj payload dla tego modelu zamiast bezrefleksyjnie odtwarzać opcje specyficzne dla dostawcy.

Przechowuj klucz API w menedżerze sekretów, ograniczaj wejście promptów, skanuj generowane zasoby zgodnie z polityką i nie umieszczaj URL-i dostawcy w długoterminowych rekordach produktów. Loguj identyfikator zadania, identyfikator modelu, opóźnienie, liczbę prób, zużycie, ścieżkę zapisu, wynik przeglądu i datę migawki katalogu. Te pola pozwalają porównywać modele po koszcie zaakceptowanego obrazu, a nie tylko po cenie nagłówkowej.

Na koniec ustaw ograniczenia budżetowe: maksymalny rozmiar wsadu, limit ponowień na zadanie, dzienny alert wydatków oraz warunek zatrzymania przy spadku współczynnika akceptacji. Skalowanie słabego promptu szybciej nie jest optymalizacją.

FAQ dotyczące automatyzacji generowania obrazów na skalę

Jaki jest najprostszy sposób na automatyzację generowania obrazów na skalę bez zarządzania wieloma API?

Użyj jednej kolejki i jednego przepływu magazynowania, a następnie wysyłaj kompatybilne żądania obrazów przez jeden klucz CometAPI i https://api.cometapi.com/v1/images/generations. Zmieniaj identyfikator modelu w warstwie routingu zamiast utrzymywać osobne uwierzytelnianie i SDK dostawców.

Czy mogę wysłać jedno żądanie i poprosić kilka modeli obrazowych o jednoczesne generowanie?

Przykład wysyła jeden model na zadanie. Fan-out to kwestia workflow aplikacji: zduplikuj zadanie z odrębnymi identyfikatorami i wartościami modelu, a następnie porównaj zapisane wyniki. Dzięki temu koszt i status przeglądu są przypisane do każdego modelu.

Jakiej współbieżności używać?

Nie ma uniwersalnej liczby dla każdego konta i modelu. Zacznij od małej, ograniczonej puli, np. czterech workerów, monitoruj opóźnienia i odpowiedzi 429, a następnie dostrajaj na podstawie danych.

Czy powinienem przechowywać zwrócony URL czy sam obraz?

Przechowuj obraz we własnym magazynie obiektowym. Zwrócony URL może być tymczasowy, podczas gdy modele GPT Image mogą zwracać treść base64 zamiast URL-a.

Jak wybrać najtańszy model?

Oblicz koszt na zaakceptowany obraz, a nie tylko cenę za wywołanie. Uwzględnij opłaty tokenowe lub za żądanie, ponowienia, nieudane pobrania, odrzucone zasoby, postprocessing i recenzję manualną. Sprawdź live model catalog w dniu publikacji lub wdrożenia.

Gdzie zweryfikować punkt końcowy i format odpowiedzi?

Użyj CometAPI Quick Start, model catalog documentation, image generation reference oraz pricing guide.