Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Optimiser les coûts

Nodarbība 11 no 12 Atjaunota 2026. gada 2. novembris Programmētājs
Šajā lapā
  1. Optimiser les coûts
  2. Comprendre la structure des coûts
  3. Prototyper en « Low », livrer en « High »
  4. Ne paie jamais deux fois pour la même image
  5. Dimensionne avec précision
  6. Éditer plutôt que régénérer
  7. Savoir où part l’argent
  8. Par où commencer

Mis à jour le 2 novembre 2026 — Modèles d’image. gpt-image-1, le modèle pour lequel ce cours a été initialement rédigé, a été arrêté le 23 octobre 2026. gpt-image-1.5, gpt-image-1-mini et chatgpt-image-latest seront retirés le 1er décembre 2026. Les exemples utilisent désormais gpt-image-2.5-sunburst, qui offre la plus grande précision pour l’édition ; gpt-image-2.5-flare est plus rapide pour la génération standard. Les deux modèles prennent également en charge les niveaux de qualité xhigh et max. Les modèles GPT Image renvoient toujours les images en base64 : le paramètre response_format des anciens modèles DALL·E n’est plus accepté et a été supprimé du code. Source : Génération d’images (OpenAI).

Optimiser les coûts

En production, la génération d’images cesse d’être une curiosité technique pour devenir une ligne budgétaire. Toute équipe produisant quelques centaines de visuels par mois le remarque rapidement. La première réaction — restreindre l’usage — est aussi la moins intelligente. Cette leçon couvre cinq stratégies qui réduisent les dépenses sans compromettre la qualité de vos livrables, car elles ciblent ce que vous jetez plutôt que ce que vous gardez.

Comprendre la structure des coûts

Les coûts de génération dépendent de trois facteurs.

FacteurImpact sur le coût
Qualité (low, medium, high)Multiplicateur direct
Résolution (1024, 1536)Plus grand = plus cher
Nombre d’images (n)Coût linéaire (n × prix unitaire)

Ces trois facteurs se multiplient entre eux, ce qui explique pourquoi une exploration indisciplinée coûte un ordre de grandeur de plus que la même exploration menée avec rigueur. Le script ci-dessous liste les cinq combinaisons que vous rencontrerez le plus souvent en production. Bien que les montants exacts apparaissent sur votre tableau de bord OpenAI, l’ordre des lignes montre déjà l’échelle des compromis.

from openai import OpenAI

client = OpenAI()

# Compare costs: same prompt, different parameters
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("Configuration         | Usage (estimated)")
print("-" * 50)
for config in configs:
    print(f"{config['label']:22s} | Check your OpenAI dashboard")

Prototyper en « Low », livrer en « High »

C’est de loin la stratégie la plus rentable et la plus simple à adopter. Durant la phase d’exploration, tu ne juges pas la finesse d’un dégradé : tu juges la composition, le cadrage et l’ambiance générale, tous parfaitement visibles avec quality: low. Passer à high n’a de sens que pour l’image que tu comptes réellement publier. Le flux de travail ci-dessous formalise cette séquence en produisant cinq brouillons économiques suivis d’un seul rendu final, avec l’avantage supplémentaire de passer au format paysage (1536×1024) pour la version définitive. Sur cinq essais et une livraison, les économies citées à la fin du script tournent autour de 60 % par rapport à une exploration menée entièrement en high.

from openai import OpenAI
import base64

client = OpenAI()

def economical_workflow(prompt: str, output: str, n_drafts: int = 5):
    """
    Two-phase workflow:
    1. Fast drafts in low quality
    2. Final render in high quality
    """
    # Phase 1: Fast exploration
    print("Phase 1: fast drafts (low quality)")
    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"  Draft {i+1}: {path}")

    # Phase 2: Final render (after human selection of the best draft)
    print("\nPhase 2: final render (high quality)")
    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"  Final render: {output}")

    # Summary: 5 low + 1 high instead of 5 high
    print(f"\nSummary: {n_drafts} low drafts + 1 final high")
    print("Estimated savings: ~60% compared to all-high exploration")


economical_workflow(
    "Illustration of a green tech campus with solar panels, architectural style",
    "campus_final.png"
)

Ne paie jamais deux fois pour la même image

Dans une application réelle, le même prompt revient bien plus souvent que tu ne le penses : un utilisateur qui actualise la page, un script de build qui relance une génération, ou une icône réutilisée sur trois pages. Chacun de ces cas constitue une facturation inutile. Le cache ci-dessous les élimine en calculant un hachage SHA-256 du triplet (prompt, taille, qualité) — les trois éléments qui déterminent le résultat facturé — et en tronquant ce hachage à seize caractères pour créer un nom de fichier gérable. Note la vérification os.path.exists : l’index peut connaître une entrée dont le fichier a été supprimé du disque ; dans ce cas, le code régénère l’image plutôt que de renvoyer un chemin mort.

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

def save_cache(cache: dict):
    """Saves the cache index."""
    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:
    """Generates an image or returns the cached result."""
    # Create a unique key based on parameters
    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 expired, regenerating...")

    # Not in cache: generate
    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"Generated and cached: {path}")
    return path


# First generation: API call
path1 = generate_with_cache("Minimalist logo for a tech startup, blue and white")
# Second identical call: served from cache
path2 = generate_with_cache("Minimalist logo for a tech startup, blue and white")

Dimensionne avec précision

Générer une vignette haute résolution qui sera affichée dans un carré de 80 pixels revient à payer un tirage d’exposition juste pour le glisser dans un portefeuille. Le remède est de cesser de laisser ce choix au bon vouloir du développeur et de le dériver plutôt de l’usage déclaré. Le dictionnaire generate_for_usage répartit les cas en trois familles : les petits formats web — vignettes et avatars — qui se contentent de low ; l’usage web standard — en-têtes de blog, publications sociales — qui appellent du medium ; et les supports où la finesse compte vraiment — bannières hero, impression A4, portfolios — qui justifient du high. Les deux appels finaux illustrent l’écart : le même chat astronaute coûte un multiple selon qu’il finisse en vignette ou en bannière de page d’accueil.

from openai import OpenAI
import base64

client = OpenAI()

def generate_for_usage(prompt: str, usage: str, output: str):
    """Automatically chooses optimal resolution and quality."""
    configs = {
        # Small web usage
        "thumbnail": {"size": "1024x1024", "quality": "low"},
        "avatar": {"size": "1024x1024", "quality": "low"},

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

        # High-quality usage
        "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"Usage {usage} ({config['quality']}/{config['size']}) → {output}")


generate_for_usage("Cute cat in an astronaut suit", "thumbnail", "cat_thumb.png")
generate_for_usage("Cute cat in an astronaut suit", "hero_banner", "cat_hero.png")

Éditer plutôt que régénérer

Le client valide la photo mais veut un ciel différent. Le réflexe naturel — relancer la génération complète avec un prompt ajusté — te fait payer une image entière et, pire, te fait perdre le reste de la composition que tout le monde avait validé. images.edit() gère cette situation pour le prix d’une édition : la fonction edit_detail construit un masque qui libère uniquement le rectangle pertinent, ici les 300 pixels de hauteur supérieurs correspondant au ciel, et le prompt décrit uniquement le contenu de cette bande. Le paysage, lui, ne bouge pas d’un pixel.

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

client = OpenAI()

# Instead of regenerating the entire image to change a detail,
# edit only the relevant area.

def edit_detail(image_path: str, zone: tuple, new_content: str, output: str):
    """
    Edits a detail in an existing image.
    zone: (x1, y1, x2, y2) of the area to modify
    """
    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"Detail edited: {output}")
    print("Cost: 1 edit instead of 1 full generation")


# Example: change just the sky of a photo
edit_detail(
    "landscape.png",
    (0, 0, 1024, 300),
    "Blue sky with some fluffy white clouds",
    "landscape_sky_edited.png"
)

Savoir où part l’argent

Les quatre stratégies précédentes supposent que tu sais ce que tu consommes, et cette visibilité ne vient pas automatiquement : le tableau de bord du fournisseur te donne un total, pas une ventilation par projet ou par qualité. Un journal local comble cet écart pour un coût de développement négligeable. log_generation ajoute une ligne horodatée pour chaque appel, en tronquant le prompt à 100 caractères pour rester lisible, et usage_report agrège ensuite le tout par niveau de qualité. Cette ventilation déclenche des décisions : si ton journal révèle que 80 % de tes images sont générées en high alors que la majorité finit sur les réseaux sociaux, tu viens de trouver ton gisement d’économies.

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):
    """Logs every generation to track costs."""
    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():
    """Displays a consumption report."""
    if not os.path.exists(USAGE_FILE):
        print("No consumption data.")
        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"Total generations: {total}")
    print(f"Breakdown by quality:")
    for q, count in sorted(by_quality.items()):
        print(f"  {q}: {count} images")


usage_report()

Par où commencer

Toutes ces stratégies n’offrent pas le même retour sur investissement, et le tableau suivant t’aide à les prioriser.

StratégieÉconomies estiméesEffort
« Low » pour le prototypage50-70 %Minimal
Cache de prompts10-30 % (si répétitif)Modéré
Résolution adaptée20-40 %Minimal
Édition vs régénération30-50 % (par modification)Modéré
Suivi des dépensesIndirect (visibilité)Modéré

Deux lignes se détachent clairement : le prototypage en low et l’adaptation de la résolution à l’usage demandent un effort minimal pour la moitié des économies possibles. Commence par là, puis ajoute la mise en cache et l’édition ciblée lorsque ton volume le justifie. Le suivi des dépenses en lui-même ne fait économiser rien directement — mais c’est lui qui te dit lesquelles des quatre autres portent réellement leurs fruits dans ton contexte spécifique.

La meilleure façon de cesser d’y penser est d’encapsuler ces règles en un point de contrôle unique. Écris un wrapper autour de client.images.generate() qui intègre la mise en cache des prompts, l’adaptation automatique de la qualité et de la résolution selon l’usage déclaré, et la journalisation de chaque appel ; lance-le ensuite sur dix générations et lis le rapport de consommation. À partir de là, toute ton équipe économise de l’argent sans avoir à se souvenir de rien.