Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Optimer omkostninger

Lektion 11 af 12 Opdateret 2. november 2026 Udvikler
På denne side
  1. Optimer omkostninger
  2. Forstå omkostningsstrukturen
  3. Prototyp i lav kvalitet, lever i høj kvalitet
  4. Betal aldrig to gange for det samme billede
  5. Dimensionér præcist
  6. Rediger i stedet for at regenerere
  7. Vid hvor pengene går
  8. Hvor skal du starte?

Opdateret 2. november 2026 — Billedmodeller. gpt-image-1, modellen dette kursus oprindeligt blev skrevet til, blev afviklet 23. oktober 2026. gpt-image-1.5, gpt-image-1-mini og chatgpt-image-latest udgår 1. december 2026. Eksemplerne bruger nu gpt-image-2.5-sunburst, som tilbyder højeste præcision til redigering; gpt-image-2.5-flare er hurtigere til standardgenerering. Begge modeller understøtter også kvalitetsniveauerne xhigh og max. GPT Image-modeller returnerer altid billeder i base64: parameteren response_format fra ældre DALL·E-modeller accepteres ikke længere og er fjernet fra koden. Kilde: Image generation (OpenAI).

Optimer omkostninger

I produktion ophører billedgenerering med at være en teknisk nysgerrighed og bliver til en budgetpost. Ethvert team, der producerer nogle hundrede visuelle elementer om måneden, mærker dette hurtigt. Den første reaktion – at begrænse forbruget – er også den mindst intelligente. Denne lektion dækker fem strategier, der reducerer udgifterne uden at gå på kompromis med kvaliteten af dine leverancer, fordi de målretter det, du kasserer, frem for det, du beholder.

Forstå omkostningsstrukturen

Genereringsomkostninger afhænger af tre faktorer.

FaktorPåvirkning af omkostninger
Kvalitet (low, medium, high)Direkte multiplikator
Opløsning (1024, 1536)Større = dyrere
Antal billeder (n)Lineære omkostninger (n × enhedspris)

Disse tre faktorer ganges med hinanden, hvilket forklarer, hvorfor udisciplineret udforskning koster en størrelsesorden mere end den samme udforskning udført med disciplin. Scriptet nedenfor lister de fem kombinationer, du oftest vil støde på i produktion. Selvom nøjagtige beløb fremgår af dit OpenAI-dashboard, viser rækkefølgen af linjerne allerede skalaen på afvejningerne.

from openai import OpenAI

client = OpenAI()

# Sammenlign omkostninger: samme prompt, forskellige parametre
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("Konfiguration         | Forbrug (estimeret)")
print("-" * 50)
for config in configs:
    print(f"{config['label']:22s} | Tjek dit OpenAI-dashboard")

Prototyp i lav kvalitet, lever i høj kvalitet

Dette er langt den mest omkostningseffektive strategi, og den enkleste at adoptere. I udforskningsfasen bedømmer du ikke finessen af en gradient: du bedømmer komposition, indramning og den overordnede stemning, som alle er perfekt synlige i quality: low. Det giver kun mening at skifte til high for det billede, du faktisk har til hensigt at publicere. Workflowet nedenfor formaliserer denne sekvens ved at producere fem økonomiske udkast efterfulgt af en enkelt endelig rendering, med den ekstra fordel at skifte til liggende format (1536×1024) til den definitive version. På tværs af fem forsøg og én levering ligger besparelsen, der citeres i slutningen af scriptet, omkring 60 % sammenlignet med en udforskning udført udelukkende i high.

from openai import OpenAI
import base64

client = OpenAI()

def economical_workflow(prompt: str, output: str, n_drafts: int = 5):
    """
    Tofaset workflow:
    1. Hurtige udkast i lav kvalitet
    2. Endelig rendering i høj kvalitet
    """
    # Fase 1: Hurtig udforskning
    print("Fase 1: hurtige udkast (lav kvalitet)")
    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"  Udkast {i+1}: {path}")

    # Fase 2: Endelig rendering (efter menneskelig udvælgelse af bedste udkast)
    print("\nFase 2: endelig rendering (høj kvalitet)")
    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"  Endelig rendering: {output}")

    # Opsamling: 5 lave + 1 høj i stedet for 5 høje
    print(f"\nOpsamling: {n_drafts} lave udkast + 1 endelig høj")
    print("Estimeret besparelse: ~60 % sammenlignet med udelukkende høj udforskning")


economical_workflow(
    "Illustration af en grøn tech-campus med solpaneler, arkitektonisk stil",
    "campus_final.png"
)

Betal aldrig to gange for det samme billede

I en rigtig applikation vender den samme prompt langt oftere tilbage, end du måske tror: en bruger, der genindlæser siden, et build-script, der genkører en generering, eller et ikon, der genbruges på tre sider. Hvert af disse tilfælde er en unødvendig udgift. Cachen nedenfor eliminerer dem ved at beregne et SHA-256-hash af tripletten (prompt, størrelse, kvalitet) – de tre elementer, der bestemmer det fakturerede resultat – og afkorte dette hash til seksten tegn for at skabe et håndterbart filnavn. Bemærk kontrollen os.path.exists: indekset kan kende en post, hvis fil er blevet slettet fra disken; i så fald genererer koden billedet igen i stedet for at returnere en død sti.

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:
    """Indlæser cache-indekset."""
    if os.path.exists(CACHE_INDEX):
        with open(CACHE_INDEX, "r") as f:
            return json.load(f)
    return {}

def save_cache(cache: dict):
    """Gemmer cache-indekset."""
    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:
    """Genererer et billede eller returnerer det cachede resultat."""
    # Opret en unik nøgle baseret på parametre
    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"Cache-hit: {cached_path}")
            return cached_path
        else:
            print("Cache udløbet, genopretter...")

    # Ikke i cache: generer
    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"Genereret og cachet: {path}")
    return path


# Første generering: API-kald
path1 = generate_with_cache("Minimalistisk logo til tech-startup, blå og hvid")
# Andet identisk kald: serveres fra cache
path2 = generate_with_cache("Minimalistisk logo til tech-startup, blå og hvid")

Dimensionér præcist

At generere et højopløseligt thumbnail, der skal vises i en firkant på 80 pixel, er som at betale for et udstillingsprint bare for at stikke det ned i en tegnebog. Løsningen er at stoppe med at overlade dette valg til udviklerens lune og i stedet udlede det fra den erklærede anvendelse. Ordbogen generate_for_usage opdeler tilfælde i tre familier: små webformater – thumbnails og avatarer – som klarer sig fint med low; standard webbrug – blog-overskrifter, sociale opslag – som kræver medium; og medier, hvor finesse virkelig betyder noget – hero-bannere, A4-print, porteføljer – som berettiger high. De sidste to kald illustrerer kløften: den samme astronautkat koster et multiplum afhængigt af, om den ender som et thumbnail eller et homepage-banner.

from openai import OpenAI
import base64

client = OpenAI()

def generate_for_usage(prompt: str, usage: str, output: str):
    """Vælger automatisk optimal opløsning og kvalitet."""
    configs = {
        # Lille webbrug
        "thumbnail": {"size": "1024x1024", "quality": "low"},
        "avatar": {"size": "1024x1024", "quality": "low"},

        # Standard webbrug
        "blog_header": {"size": "1536x1024", "quality": "medium"},
        "social_post": {"size": "1024x1024", "quality": "medium"},

        # Høj kvalitet brug
        "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"Brug {usage} ({config['quality']}/{config['size']}) → {output}")


generate_for_usage("Sød kat i astronautdragt", "thumbnail", "cat_thumb.png")
generate_for_usage("Sød kat i astronautdragt", "hero_banner", "cat_hero.png")

Rediger i stedet for at regenerere

Kunden godkender fotoet, men ønsker en anden himmel. Den naturlige refleks – at genkøre hele genereringen med en justeret prompt – får dig til at betale for et helt billede og, værre endnu, får dig til at miste resten af kompositionen, som alle havde godkendt. images.edit() håndterer denne situation for prisen på en redigering: funktionen edit_detail bygger en maske, der kun frigør det relevante rektangel, her de øverste 300 pixels i højden svarende til himlen, og prompten beskriver kun indholdet af den strimmel. Selve landskabet flytter sig ikke en pixel.

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

client = OpenAI()

# I stedet for at regenerere hele billedet for at ændre en detalje,
# rediger kun det relevante område.

def edit_detail(image_path: str, zone: tuple, new_content: str, output: str):
    """
    Redigerer en detalje i et eksisterende billede.
    zone: (x1, y1, x2, y2) for området der skal modificeres
    """
    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"Detalje redigeret: {output}")
    print("Omkostning: 1 redigering i stedet for 1 fuld generering")


# Eksempel: ændr kun himlen på et foto
edit_detail(
    "landscape.png",
    (0, 0, 1024, 300),
    "Blå himmel med nogle fluffy hvide skyer",
    "landscape_sky_edited.png"
)

Vid hvor pengene går

De fire tidligere strategier forudsætter, at du ved, hvad du forbruger, og denne synlighed kommer ikke automatisk: udbyderens dashboard giver dig en total, ikke en opdeling pr. projekt eller kvalitet. En lokal log udfylder dette gab for en ubetydelig udviklingsomkostning. log_generation tilføjer en tidsstemplet linje for hvert kald og afkorter prompten til 100 tegn for at forblive læsbar, og usage_report aggregerer derefter alt efter kvalitetsniveau. Denne opdeling udløser beslutninger: hvis din log afslører, at 80 % af dine billeder genereres i high, mens flertallet ender på sociale medier, har du lige fundet dit besparelsespotentiale.

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):
    """Logger hver generering for at spore omkostninger."""
    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():
    """Viser en forbrugsrapport."""
    if not os.path.exists(USAGE_FILE):
        print("Ingen forbrugsdata.")
        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"Samlede genereringer: {total}")
    print(f"Opdeling efter kvalitet:")
    for q, count in sorted(by_quality.items()):
        print(f"  {q}: {count} billeder")


usage_report()

Hvor skal du starte?

Ikke alle disse strategier giver det samme afkast for indsatsen, og følgende tabel hjælper dig med at prioritere dem.

StrategiEstimeret besparelseIndsats
Lav kvalitet til prototyping50-70 %Minimal
Prompt-caching10-30 % (hvis gentagende)Moderat
Tilpasset opløsning20-40 %Minimal
Redigering vs. regenerering30-50 % (pr. ændring)Moderat
OmkostningssporingIndirekte (synlighed)Moderat

To linjer skiller sig klart ud: prototyping i low og tilpasning af opløsning til brug kræver minimal indsats for halvdelen af de mulige besparelser. Start med dem, og tilføj derefter caching og målrettet redigering, når dit volumen berettiger det. Selve omkostningssporingen sparer intet direkte – men det er den, der fortæller dig, hvilken af de andre fire der faktisk bærer frugt i din specifikke kontekst.

Den bedste måde at stoppe med at tænke på det er at kapsle disse regler ind i et enkelt kontrolpunkt. Skriv en wrapper omkring client.images.generate(), der integrerer prompt-caching, automatisk tilpasning af kvalitet og opløsning baseret på erklæret brug, og logning af hvert kald; kør den derefter på ti genereringer og læs forbrugsrapporten. Herfra sparer hele dit team penge uden at skulle huske noget.