Optimer omkostninger
På denne side
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-miniogchatgpt-image-latestudgår 1. december 2026. Eksemplerne bruger nugpt-image-2.5-sunburst, som tilbyder højeste præcision til redigering;gpt-image-2.5-flareer hurtigere til standardgenerering. Begge modeller understøtter også kvalitetsniveauernexhighogmax. GPT Image-modeller returnerer altid billeder i base64: parameterenresponse_formatfra æ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.
| Faktor | På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.
| Strategi | Estimeret besparelse | Indsats |
|---|---|---|
| Lav kvalitet til prototyping | 50-70 % | Minimal |
| Prompt-caching | 10-30 % (hvis gentagende) | Moderat |
| Tilpasset opløsning | 20-40 % | Minimal |
| Redigering vs. regenerering | 30-50 % (pr. ændring) | Moderat |
| Omkostningssporing | Indirekte (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.