Combiner génération d'images avec d'autres outils API
Combiner génération d’images avec d’autres outils API
La puissance de GPT Image se multiplie quand vous le combinez avec d’autres API et outils. Cette leçon vous montre comment créer des pipelines qui intègrent la génération d’images dans des workflows plus larges : génération de texte, analyse d’images, traitement automatisé.
Pipeline texte vers image
Utilisez un modèle de langage pour générer le prompt optimal, puis GPT Image pour créer le visuel :
from openai import OpenAI
import base64
client = OpenAI()
def texte_vers_image(brief: str, output: str):
"""
Pipeline en deux étapes :
1. Un LLM génère le prompt visuel optimal
2. GPT Image crée l'image
"""
# Étape 1 : générer le prompt visuel avec un LLM
completion = client.chat.completions.create(
model="gpt-4o-mini",
messages=[
{
"role": "system",
"content": (
"Tu es un expert en direction artistique. "
"À partir d'un brief, génère un prompt détaillé pour un modèle "
"de génération d'images. Inclus : sujet, composition, éclairage, "
"style, perspective, palette de couleurs. "
"Réponds uniquement avec le prompt, sans explication."
)
},
{"role": "user", "content": brief}
]
)
prompt_visuel = completion.choices[0].message.content
print(f"Prompt généré : {prompt_visuel[:100]}...")
# Étape 2 : générer l'image
response = client.images.generate(
model="gpt-image-1",
prompt=prompt_visuel,
size="1536x1024",
quality="high",
response_format="b64_json"
)
data = base64.b64decode(response.data[0].b64_json)
with open(output, "wb") as f:
f.write(data)
print(f"Image générée : {output}")
return prompt_visuel
prompt = texte_vers_image(
"J'ai besoin d'une image pour un article sur l'intelligence artificielle "
"dans la santé. Ton futuriste mais humain.",
"ia_sante.png"
)Pipeline article de blog complet
Générez automatiquement les illustrations pour un article :
from openai import OpenAI
import base64
import json
client = OpenAI()
def illustrer_article(titre: str, sections: list[str], style: str, output_dir: str = "."):
"""
Génère une illustration de header + une par section.
"""
resultats = []
# Image de couverture
header_prompt = (
f"Image de couverture pour un article intitulé \"{titre}\", "
f"style {style}, composition panoramique, "
"pas de texte dans l'image, professionnel"
)
response = client.images.generate(
model="gpt-image-1",
prompt=header_prompt,
size="1536x1024",
quality="high",
response_format="b64_json"
)
path = f"{output_dir}/header.png"
data = base64.b64decode(response.data[0].b64_json)
with open(path, "wb") as f:
f.write(data)
resultats.append({"type": "header", "path": path})
print(f"Header : {path}")
# Illustrations par section
for i, section in enumerate(sections):
section_prompt = (
f"Illustration pour la section \"{section}\" "
f"d'un article sur \"{titre}\", "
f"style {style}, format rectangulaire, "
"illustration conceptuelle sans texte"
)
response = client.images.generate(
model="gpt-image-1",
prompt=section_prompt,
size="1536x1024",
quality="medium",
response_format="b64_json"
)
path = f"{output_dir}/section_{i+1}.png"
data = base64.b64decode(response.data[0].b64_json)
with open(path, "wb") as f:
f.write(data)
resultats.append({"type": f"section_{i+1}", "section": section, "path": path})
print(f"Section {i+1} ({section[:30]}...) : {path}")
return resultats
illustrer_article(
titre="5 manières dont l'IA transforme le recrutement",
sections=[
"Tri automatique des CV",
"Entretiens vidéo analysés par IA",
"Matching candidat-poste intelligent",
"Réduction des biais de recrutement",
"Onboarding personnalisé",
],
style="illustration isométrique 3D, tons bleus et violets",
output_dir="."
)Combiner vision et génération
Utilisez la vision de GPT pour analyser une image, puis GPT Image pour en créer une variante :
from openai import OpenAI
import base64
client = OpenAI()
def analyser_et_varier(image_path: str, instruction: str, output: str):
"""
1. Analyse une image avec GPT vision
2. Génère une variante basée sur l'analyse
"""
# Étape 1 : analyser l'image
with open(image_path, "rb") as f:
image_b64 = base64.b64encode(f.read()).decode()
analysis = client.chat.completions.create(
model="gpt-4o-mini",
messages=[
{
"role": "user",
"content": [
{
"type": "text",
"text": (
"Décris cette image en détail pour qu'un modèle de "
"génération d'images puisse la reproduire fidèlement. "
"Inclus : sujet, composition, éclairage, couleurs, style, "
"perspective, ambiance. Sois très précis."
)
},
{
"type": "image_url",
"image_url": {
"url": f"data:image/png;base64,{image_b64}"
}
}
]
}
]
)
description = analysis.choices[0].message.content
print(f"Analyse : {description[:150]}...")
# Étape 2 : générer une variante modifiée
prompt_variante = f"{description}. Modification demandée : {instruction}"
response = client.images.generate(
model="gpt-image-1",
prompt=prompt_variante,
size="1024x1024",
quality="high",
response_format="b64_json"
)
data = base64.b64decode(response.data[0].b64_json)
with open(output, "wb") as f:
f.write(data)
print(f"Variante générée : {output}")
analyser_et_varier(
"paysage_original.png",
"Changer la saison de l'été à l'hiver, avec de la neige sur les toits et les arbres",
"paysage_hiver.png"
)Génération en masse avec traitement par lots
Pour les gros volumes, structurez vos générations en lots :
from openai import OpenAI
import base64
import json
import time
from concurrent.futures import ThreadPoolExecutor, as_completed
client = OpenAI()
def generer_une_image(tache: dict) -> dict:
"""Génère une seule image à partir d'une tâche."""
try:
response = client.images.generate(
model="gpt-image-1",
prompt=tache["prompt"],
size=tache.get("size", "1024x1024"),
quality=tache.get("quality", "medium"),
response_format="b64_json"
)
data = base64.b64decode(response.data[0].b64_json)
with open(tache["output"], "wb") as f:
f.write(data)
return {"id": tache["id"], "status": "ok", "path": tache["output"]}
except Exception as e:
return {"id": tache["id"], "status": "erreur", "erreur": str(e)}
def generation_par_lots(taches: list[dict], max_parallele: int = 3):
"""Exécute un lot de générations avec parallélisme contrôlé."""
resultats = []
with ThreadPoolExecutor(max_workers=max_parallele) as executor:
futures = {
executor.submit(generer_une_image, tache): tache
for tache in taches
}
for future in as_completed(futures):
resultat = future.result()
resultats.append(resultat)
status = resultat["status"]
print(f" [{status}] {resultat['id']}")
# Rapport
ok = sum(1 for r in resultats if r["status"] == "ok")
erreurs = sum(1 for r in resultats if r["status"] == "erreur")
print(f"\nTerminé : {ok} ok, {erreurs} erreurs sur {len(taches)} tâches")
return resultats
# Définir un lot de tâches
taches = [
{
"id": f"produit_{i}",
"prompt": f"Photo produit e-commerce : {produit}, fond blanc, studio",
"output": f"batch_produit_{i}.png",
"quality": "high"
}
for i, produit in enumerate([
"montre en or rose",
"lunettes de soleil aviateur",
"bracelet en cuir tressé",
"bague solitaire diamant",
"collier perles de culture",
])
]
resultats = generation_par_lots(taches, max_parallele=3)Intégration avec le stockage cloud
Envoyez directement les images générées vers un service de stockage :
from openai import OpenAI
import base64
import boto3
from io import BytesIO
client = OpenAI()
def generer_et_stocker_s3(prompt: str, bucket: str, key: str):
"""Génère une image et l'envoie directement sur S3."""
response = client.images.generate(
model="gpt-image-1",
prompt=prompt,
size="1024x1024",
quality="high",
response_format="b64_json"
)
image_data = base64.b64decode(response.data[0].b64_json)
s3 = boto3.client("s3")
s3.upload_fileobj(
BytesIO(image_data),
bucket,
key,
ExtraArgs={"ContentType": "image/png"}
)
url = f"https://{bucket}.s3.amazonaws.com/{key}"
print(f"Image stockée sur S3 : {url}")
return url
# Exemple
url = generer_et_stocker_s3(
"Icône d'application mobile : livre ouvert avec des étoiles, flat design",
"mon-bucket-images",
"generated/app_icon_v1.png"
)Bonnes pratiques d’intégration
- Séparez les responsabilités : chaque étape du pipeline fait une seule chose
- Gérez les erreurs à chaque étape pour éviter les échecs en cascade
- Limitez le parallélisme pour respecter les rate limits de l’API
- Loguez les prompts utilisés pour pouvoir reproduire les résultats
- Cachez les résultats quand le même prompt est réutilisé
Exercice pratique
Créez un pipeline complet qui :
- Prend un titre d’article en entrée
- Utilise un LLM pour générer 3 descriptions de visuels pertinents
- Génère les 3 images en parallèle
- Produit un fichier JSON récapitulatif avec les prompts et chemins des fichiers