Przejdź do głównej treści
Polski— Wybierz język
Menu

Optymalizacja kosztów

Lekcja 11 z 12 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Optymalizacja kosztów
  2. Zrozumienie struktury kosztów
  3. Prototypuj w niskiej jakości, dostarczaj w wysokiej
  4. Nigdy nie płać dwa razy za ten sam obraz
  5. Dobieraj rozmiar precyzyjnie
  6. Edytuj zamiast regenerować
  7. Wiedz, gdzie idą pieniądze
  8. Od czego zacząć

Zaktualizowano 2 listopada 2026 — Modele obrazowe. Model gpt-image-1, dla którego pierwotnie napisano ten kurs, został wycofany 23 października 2026. Modele gpt-image-1.5, gpt-image-1-mini oraz chatgpt-image-latest zostaną wycofane 1 grudnia 2026. Przykłady wykorzystują obecnie model gpt-image-2.5-sunburst, który oferuje najwyższą precyzję podczas edycji; model gpt-image-2.5-flare jest szybszy przy standardowym generowaniu. Oba modele obsługują również poziomy jakości xhigh i max. Modele GPT Image zawsze zwracają obrazy w formacie base64: parametr response_format ze starszych modeli DALL·E nie jest już akceptowany i został usunięty z kodu. Źródło: Image generation (OpenAI).

Optymalizacja kosztów

W środowisku produkcyjnym generowanie obrazów przestaje być techniczną ciekawostką, a staje się pozycją budżetową. Każdy zespół produkujący kilkaset grafik miesięcznie szybko to zauważa. Pierwszą reakcją – ograniczenie użycia – jest również najmniej rozsądna. Ta lekcja omawia pięć strategii, które redukują wydatki bez kompromisów dotyczących jakości dostarczanych materiałów, ponieważ celują one w to, co odrzucasz, a nie w to, co zachowujesz.

Zrozumienie struktury kosztów

Koszty generowania zależą od trzech czynników.

CzynnikWpływ na koszt
Jakość (low, medium, high)Bezpośredni mnożnik
Rozdzielczość (1024, 1536)Większa = droższa
Liczba obrazów (n)Koszt liniowy (n × cena jednostkowa)

Te trzy czynniki mnożą się przez siebie, co wyjaśnia, dlaczego niezdyscyplinowane eksperymentowanie kosztuje rzęd wielkości więcej niż to samo badanie przeprowadzone z dyscypliną. Poniższy skrypt wymienia pięć kombinacji, z którymi najczęściej spotkasz się w produkcji. Choć dokładne kwoty zobaczysz na pulpicie nawigacyjnym OpenAI, kolejność wierszy już pokazuje skalę kompromisów.

from openai import OpenAI

client = OpenAI()

# Porównanie kosztów: ten sam prompt, różne parametry
configs = [
    {"quality": "low", "size": "1024x1024", "label": "Low / 1024"},
    {"quality": "medium", "size": "1024x1024", "label": "Medium / 1024"},
    {"quality": "high", "size": "1024x1024", "label": "High / 1024"},
    {"quality": "medium", "size": "1536x1024", "label": "Medium / 1536"},
    {"quality": "high", "size": "1536x1024", "label": "High / 1536"},
]

print("Konfiguracja          | Użycie (szacowane)")
print("-" * 50)
for config in configs:
    print(f"{config['label']:22s} | Sprawdź pulpit OpenAI")

Prototypuj w niskiej jakości, dostarczaj w wysokiej

To zdecydowanie najbardziej opłacalna strategia i najprostsza do wdrożenia. W fazie eksploracji nie oceniasz subtelności gradientu: oceniasz kompozycję, kadrowanie i ogólny nastrój, a wszystko to jest doskonale widoczne przy quality: low. Przełączenie na high ma sens tylko dla obrazu, który faktycznie zamierzasz opublikować. Poniższy przepływ pracy formalizuje tę sekwencję, produkując pięć ekonomicznych szkiców, a następnie pojedynczy render końcowy, z dodatkową korzyścią w postaci przełączenia na format poziomy (1536×1024) dla wersji ostatecznej. Przy pięciu próbach i jednym dostarczeniu, oszczędności wymienione na końcu skryptu wynoszą około 60% w porównaniu do eksploracji przeprowadzonej całkowicie w trybie high.

from openai import OpenAI
import base64

client = OpenAI()

def economical_workflow(prompt: str, output: str, n_drafts: int = 5):
    """
    Przepływ dwufazowy:
    1. Szybkie szkice w niskiej jakości
    2. Render końcowy w wysokiej jakości
    """
    # Faza 1: Szybka eksploracja
    print("Faza 1: szybkie szkice (niska jakość)")
    drafts = []
    for i in range(n_drafts):
        response = client.images.generate(
            model="gpt-image-2.5-sunburst",
            prompt=prompt,
            size="1024x1024",
            quality="low",
        )

        path = f"draft_{i+1}.png"
        data = base64.b64decode(response.data[0].b64_json)
        with open(path, "wb") as f:
            f.write(data)
        drafts.append(path)
        print(f"  Szkic {i+1}: {path}")

    # Faza 2: Render końcowy (po ręcznym wyborze najlepszego szkicu)
    print("\nFaza 2: render końcowy (wysoka jakość)")
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size="1536x1024",
        quality="high",
    )

    data = base64.b64decode(response.data[0].b64_json)
    with open(output, "wb") as f:
        f.write(data)
    print(f"  Render końcowy: {output}")

    # Podsumowanie: 5 niskiej jakości + 1 wysokiej zamiast 5 wysokiej
    print(f"\nPodsumowanie: {n_drafts} szkiców niskiej jakości + 1 końcowy wysokiej")
    print("Szacowane oszczędności: ~60% w porównaniu do eksploracji całkowicie wysokiej jakości")


economical_workflow(
    "Ilustracja kampusu zielonych technologii z panelami słonecznymi, styl architektoniczny",
    "campus_final.png"
)

Nigdy nie płać dwa razy za ten sam obraz

W rzeczywistej aplikacji ten sam prompt pojawia się znacznie częściej, niż mogłoby się wydawać: użytkownik odświeżający stronę, skrypt budowania ponownie uruchamiający generowanie lub ikona używana na trzech podstronach. Każdy z tych przypadków to niepotrzebna opłata. Poniższy mechanizm cache eliminuje je, obliczając hash SHA-256 z trójki (prompt, rozmiar, jakość) – trzech elementów determinujących wynik podlegający opłacie – i skraca ten hash do szesnastu znaków, aby utworzyć zarządzalną nazwę pliku. Zwróć uwagę na sprawdzenie os.path.exists: indeks może znać wpis, którego plik został usunięty z dysku; w takim przypadku kod regeneruje obraz, zamiast zwracać ścieżkę do nieistniejącego pliku.

import hashlib
import json
import os
from openai import OpenAI
import base64

client = OpenAI()

CACHE_DIR = "image_cache"
CACHE_INDEX = os.path.join(CACHE_DIR, "index.json")

def load_cache() -> dict:
    """Ładuje indeks cache."""
    if os.path.exists(CACHE_INDEX):
        with open(CACHE_INDEX, "r") as f:
            return json.load(f)
    return {}

def save_cache(cache: dict):
    """Zapisuje indeks cache."""
    os.makedirs(CACHE_DIR, exist_ok=True)
    with open(CACHE_INDEX, "w") as f:
        json.dump(cache, f, indent=2, ensure_ascii=False)

def generate_with_cache(
    prompt: str,
    size: str = "1024x1024",
    quality: str = "medium"
) -> str:
    """Generuje obraz lub zwraca wynik z cache."""
    # Tworzenie unikalnego klucza na podstawie parametrów
    key_data = f"{prompt}|{size}|{quality}"
    cache_key = hashlib.sha256(key_data.encode()).hexdigest()[:16]

    cache = load_cache()

    if cache_key in cache:
        cached_path = cache[cache_key]["path"]
        if os.path.exists(cached_path):
            print(f"Trafienie w cache: {cached_path}")
            return cached_path
        else:
            print("Cache wygasł, regenerowanie...")

    # Nie ma w cache: generuj
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size=size,
        quality=quality,
    )

    path = os.path.join(CACHE_DIR, f"{cache_key}.png")
    os.makedirs(CACHE_DIR, exist_ok=True)
    data = base64.b64decode(response.data[0].b64_json)
    with open(path, "wb") as f:
        f.write(data)

    cache[cache_key] = {
        "prompt": prompt[:100],
        "size": size,
        "quality": quality,
        "path": path
    }
    save_cache(cache)

    print(f"Wygenerowano i zapisano w cache: {path}")
    return path


# Pierwsze generowanie: wywołanie API
path1 = generate_with_cache("Minimalistyczne logo dla startupu technologicznego, niebieskie i białe")
# Drugie identyczne wywołanie: obsłużone z cache
path2 = generate_with_cache("Minimalistyczne logo dla startupu technologicznego, niebieskie i białe")

Dobieraj rozmiar precyzyjnie

Generowanie miniatury w wysokiej rozdzielczości, która będzie wyświetlana w kwadracie 80 pikseli, to jak płacenie za wydruk wystawowy tylko po to, by wsunąć go do portfela. Rozwiązaniem jest zaprzestanie pozostawiania tego wyboru widzimisię programisty i zamiast tego wyprowadzenie go z zadeklarowanego zastosowania. Słownik generate_for_usage dzieli przypadki na trzy rodziny: małe formaty sieciowe – miniatury i awatary – które wystarczająco dobrze wyglądają w low; standardowe zastosowania sieciowe – nagłówki blogów, posty w mediach społecznościowych – które wymagają medium; oraz media, w których subtelność naprawdę ma znaczenie – banery hero, druk A4, portfolio – które uzasadniają high. Ostatnie dwa wywołania ilustrują różnicę: ten sam kot w skafandrze astronauty kosztuje wielokrotnie więcej w zależności od tego, czy skończy jako miniatura, czy jako baner na stronie głównej.

from openai import OpenAI
import base64

client = OpenAI()

def generate_for_usage(prompt: str, usage: str, output: str):
    """Automatycznie wybiera optymalną rozdzielczość i jakość."""
    configs = {
        # Małe zastosowania sieciowe
        "thumbnail": {"size": "1024x1024", "quality": "low"},
        "avatar": {"size": "1024x1024", "quality": "low"},

        # Standardowe zastosowania sieciowe
        "blog_header": {"size": "1536x1024", "quality": "medium"},
        "social_post": {"size": "1024x1024", "quality": "medium"},

        # Zastosowania wysokiej jakości
        "hero_banner": {"size": "1536x1024", "quality": "high"},
        "print_a4": {"size": "1024x1536", "quality": "high"},
        "portfolio": {"size": "1024x1024", "quality": "high"},
    }

    config = configs.get(usage, {"size": "1024x1024", "quality": "medium"})

    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size=config["size"],
        quality=config["quality"],
    )

    data = base64.b64decode(response.data[0].b64_json)
    with open(output, "wb") as f:
        f.write(data)
    print(f"Zastosowanie {usage} ({config['quality']}/{config['size']}) → {output}")


generate_for_usage("Słodki kot w stroju astronauty", "thumbnail", "cat_thumb.png")
generate_for_usage("Słodki kot w stroju astronauty", "hero_banner", "cat_hero.png")

Edytuj zamiast regenerować

Klient akceptuje zdjęcie, ale chce innego nieba. Naturalnym odruchem – ponowne uruchomienie pełnego generowania z dostosowanym promptem – sprawia, że płacisz za cały obraz i, co gorsza, tracisz resztę kompozycji, którą wszyscy już zaakceptowali. Funkcja images.edit() rozwiązuje tę sytuację za cenę edycji: funkcja edit_detail buduje maskę, która uwalnia tylko odpowiedni prostokąt, tutaj górne 300 pikseli wysokości odpowiadające niebu, a prompt opisuje tylko zawartość tego pasa. Sam krajobraz nie przesuwa się ani o piksel.

import base64
from openai import OpenAI
from PIL import Image, ImageDraw

client = OpenAI()

# Zamiast regenerować cały obraz, aby zmienić detal,
# edytuj tylko odpowiedni obszar.

def edit_detail(image_path: str, zone: tuple, new_content: str, output: str):
    """
    Edytuje detal w istniejącym obrazie.
    zone: (x1, y1, x2, y2) obszaru do modyfikacji
    """
    source = Image.open(image_path)
    mask = Image.new("RGBA", source.size, (0, 0, 0, 255))
    draw = ImageDraw.Draw(mask)
    draw.rectangle(zone, fill=(0, 0, 0, 0))
    mask.save("temp_mask.png")

    response = client.images.edit(
        model="gpt-image-2.5-sunburst",
        image=open(image_path, "rb"),
        mask=open("temp_mask.png", "rb"),
        prompt=new_content
    )

    with open(output, "wb") as f:
        f.write(base64.b64decode(response.data[0].b64_json))
    print(f"Edycja detalu: {output}")
    print("Koszt: 1 edycja zamiast 1 pełnego generowania")


# Przykład: zmiana tylko nieba na zdjęciu
edit_detail(
    "landscape.png",
    (0, 0, 1024, 300),
    "Błękitne niebo z kilkoma puszystymi białymi chmurami",
    "landscape_sky_edited.png"
)

Wiedz, gdzie idą pieniądze

Cztery poprzednie strategie zakładają, że wiesz, co konsumujesz, a ta widoczność nie przychodzi automatycznie: pulpit dostawcy daje ci sumę, a nie podział na projekt czy jakość. Lokalny log wypełnia tę lukę przy znikomym koszcie deweloperskim. log_generation dodaje wiersz z datą i godziną dla każdego wywołania, skracając prompt do 100 znaków, aby pozostał czytelny, a usage_report agreguje następnie wszystko według poziomu jakości. Ten podział wyzwala decyzje: jeśli twój log ujawnia, że 80% twoich obrazów jest generowanych w high, podczas gdy większość trafia na posty w mediach społecznościowych, właśnie znalazłeś swoje źródło oszczędności.

import json
import os
from datetime import datetime

USAGE_FILE = "image_usage_log.json"

def log_generation(prompt: str, size: str, quality: str, n: int = 1):
    """Loguje każde generowanie w celu śledzenia kosztów."""
    if os.path.exists(USAGE_FILE):
        with open(USAGE_FILE, "r") as f:
            log = json.load(f)
    else:
        log = []

    entry = {
        "timestamp": datetime.now().isoformat(),
        "prompt": prompt[:100],
        "size": size,
        "quality": quality,
        "n_images": n,
    }

    log.append(entry)

    with open(USAGE_FILE, "w") as f:
        json.dump(log, f, indent=2, ensure_ascii=False)


def usage_report():
    """Wyświetla raport zużycia."""
    if not os.path.exists(USAGE_FILE):
        print("Brak danych o zużyciu.")
        return

    with open(USAGE_FILE, "r") as f:
        log = json.load(f)

    total = len(log)
    by_quality = {}
    for entry in log:
        q = entry["quality"]
        by_quality[q] = by_quality.get(q, 0) + entry["n_images"]

    print(f"Łączna liczba generowań: {total}")
    print(f"Podział według jakości:")
    for q, count in sorted(by_quality.items()):
        print(f"  {q}: {count} obrazów")


usage_report()

Od czego zacząć

Nie wszystkie te strategie oferują taki sam zwrot z wysiłku, a poniższa tabela pomaga ustalić priorytety.

StrategiaSzacowane oszczędnościWysiłek
Niska jakość do prototypowania50–70%Minimalny
Cache promptów10–30% (jeśli powtarzalne)Umiarkowany
Dostosowana rozdzielczość20–40%Minimalny
Edycja zamiast regenerowania30–50% (na modyfikację)Umiarkowany
Śledzenie wydatkówPośrednie (widoczność)Umiarkowany

Dwa wiersze wyraźnie się wyróżniają: prototypowanie w low i dostosowywanie rozdzielczości do zastosowania wymagają minimalnego wysiłku za połowę możliwych oszczędności. Zacznij od nich, a następnie dodaj cache i celowaną edycję, gdy twoja skala produkcji to uzasadni. Samo śledzenie wydatków niczego bezpośrednio nie oszczędza – ale to ono mówi ci, która z pozostałych czterech strategii faktycznie przynosi owoce w twoim konkretnym kontekście.

Najlepszym sposobem, aby przestać o tym myśleć, jest zamknięcie tych reguł w jednym punkcie kontrolnym. Napisz wrapper wokół client.images.generate(), który integruje cache promptów, automatyczne dostosowanie jakości i rozdzielczości na podstawie zadeklarowanego zastosowania oraz logowanie każdego wywołania; następnie uruchom go na dziesięciu generowaniach i przeczytaj raport zużycia. Od tego momentu cały twój zespół oszczędza pieniądze, nie musząc o niczym pamiętać.