L'intelligence artificielle transforme rapidement la façon dont nous créons et interagissons avec le contenu visuel. OpenAI est à l'avant-garde de cette révolution, offrant des modèles puissants capables de générer et de manipuler des images avec un réalisme et une créativité étonnants. Alors que des modèles comme DALL·E 3 et GPT-4o présentent ces capacités dans des outils destinés aux utilisateurs, OpenAI fournit également aux développeurs un accès direct à cette technologie via son API de génération d'images, utilisant souvent l'identifiant de modèle gpt-image-1.
Ce guide propose une plongée approfondie dans l'utilisation de gpt-image-1 (le nom officiel de l'API de génération d'images GPT-4o attendue). Nous explorerons le modèle sous-jacent, ses fonctionnalités puissantes, les considérations de tarification et fournirons une procédure pas à pas complète en utilisant Python. De manière cruciale, nous discuterons également de la façon dont des outils comme Apidog peuvent rationaliser le processus de développement et de test, rendant l'intégration plus fluide et plus efficace.
Vous voulez une plateforme intégrée, tout-en-un, pour que votre équipe de développeurs travaille ensemble avec une productivité maximale ?
Apidog répond à toutes vos demandes et remplace Postman à un prix beaucoup plus abordable !
Qu'est-ce que l'API de génération d'images GPT-4o (gpt-image-1) ?
Essentiellement, gpt-image-1 (API de génération d'images gpt-4o) est un service qui permet aux développeurs de créer et de modifier des images par programmation à l'aide des modèles d'IA avancés d'OpenAI. Lorsque vous interagissez avec cette API, en spécifiant gpt-image-1 (ou en laissant l'API utiliser par défaut le dernier modèle recommandé, qui correspond souvent aux capacités de GPT-4o/DALL·E 3), vous exploitez un système sophistiqué entraîné sur de vastes quantités de données textuelles et d'images.
Pourquoi utiliser l'API de génération d'images GPT-4o (gpt-image-1)
- Génération d'images haute fidélité : créez des images détaillées, cohérentes et visuellement attrayantes à partir de descriptions textuelles (invites). Le modèle excelle à comprendre les nuances des invites pour fournir des résultats précis.
- Gamme stylistique diversifiée : allez au-delà du photoréalisme. Générez des images dans différents styles comme la peinture à l'huile, l'aquarelle, le pixel art, le rendu 3D, l'art linéaire minimaliste, et bien d'autres, simplement en décrivant l'esthétique souhaitée dans votre invite.
- Édition d'images avancée (Inpainting & Outpainting) : modifiez les images existantes. Vous pouvez fournir une image et un masque (une zone transparente indiquant où les modifications doivent avoir lieu) ainsi qu'une invite pour modifier de manière transparente des parties spécifiques (inpainting) ou étendre l'image au-delà de ses bordures d'origine (outpainting, bien que généralement effectué via l'itération d'invites).
- Variations d'images : générez différentes versions d'une image d'entrée, en conservant le sujet et le style de base, mais en introduisant des variations créatives.
- Compréhension sophistiquée des invites : le modèle comprend des phrases complexes, des relations spatiales, plusieurs objets et des concepts abstraits décrits dans l'invite.
- Rendu de texte amélioré : l'une des avancées significatives est la capacité de rendre du texte lisible et contextuellement approprié dans les images générées, surmontant un obstacle majeur pour les générations précédentes de modèles d'images.
- Sécurité par conception : des systèmes de sécurité intégrés fonctionnent pour empêcher la génération de contenu nuisible, inapproprié ou violant les politiques en fonction des invites et de l'analyse des images.
Coût, latence et modération du contenu de l'API
Comprendre les facteurs qui influencent le coût et le temps de réponse est crucial lors de l'intégration de l'API gpt-image-1.
Coût et latence :
Contrairement à une simple tarification par image, le coût et la latence de gpt-image-1 sont directement proportionnels à l'effort de calcul requis, mesuré en jetons d'image. Le modèle génère d'abord des jetons d'image spécialisés représentant le contenu visuel avant de rendre l'image finale.
Le nombre de jetons d'image générés dépend des dimensions de l'image (size) et du réglage de la qualité (quality) demandés :
| Qualité | Carré (1024×1024) | Portrait (1024×1536) | Paysage (1536×1024) |
|---|---|---|---|
| Faible | 272 jetons | 408 jetons | 400 jetons |
| Moyen | 1056 jetons | 1584 jetons | 1568 jetons |
| Élevé | 4160 jetons | 6240 jetons | 6208 jetons |
Des paramètres de qualité plus élevés et des dimensions plus grandes nécessitent beaucoup plus de jetons d'image, ce qui entraîne une augmentation des coûts et potentiellement une latence plus élevée (temps de réponse plus longs).
Important : vous devez également tenir compte des jetons de texte d'entrée consommés par votre invite. Le coût total par requête est basé à la fois sur les jetons d'invite d'entrée et sur les jetons d'image générés.
Pour une tarification précise et à jour par jeton de texte et d'image, consultez toujours la page de tarification officielle d'OpenAI : https://openai.com/pricing.
Modération du contenu :
OpenAI filtre toutes les invites d'entrée et les images générées par rapport à sa politique de contenu afin de garantir la sécurité et une utilisation responsable. Lors de l'utilisation de gpt-image-1, vous avez un certain contrôle sur la rigueur de la modération via le paramètre facultatif moderation :
auto(Par défaut) : applique un filtrage standard, visant à limiter la création de certaines catégories de contenu potentiellement inappropriées pour l'âge.low: applique un filtrage moins restrictif.
Choisissez le paramètre approprié pour le contexte de votre application et votre base d'utilisateurs tout en restant conforme aux politiques d'utilisation d'OpenAI.
Comment utiliser l'API de génération d'images OpenAI (gpt-image-1)
Cette section fournit des extraits de code complets démontrant comment utiliser l'API de génération d'images OpenAI avec le modèle gpt-image-1 via la bibliothèque Python officielle openai.
Conditions préalables et configuration
Assurez-vous d'avoir un compte OpenAI et une clé API. Installez les bibliothèques requises :
pip install --upgrade openai pillow
Importez les modules nécessaires et initialisez le client (il utilise automatiquement la variable d'environnement OPENAI_API_KEY) :
import os
import base64
from io import BytesIO
from openai import OpenAI
from PIL import Image # Pour la manipulation d'images si vous gérez b64_json
# Initialiser le client
client = OpenAI()
# Assurez-vous que la clé API est définie comme variable d'environnement ou initialisez avec :
# client = OpenAI(api_key="YOUR_API_KEY")
# Recommandé : utilisez response_format='b64_json' pour une gestion directe
# Fonction d'assistance (facultatif) pour traiter les données b64_json :
def process_b64_json(b64_json_data, output_path):
try:
image_bytes = base64.b64decode(b64_json_data)
image = Image.open(BytesIO(image_bytes))
# Facultatif : redimensionner ou autre traitement
# image = image.resize((512, 512), Image.LANCZOS)
image.save(output_path) # Enregistre au format déduit de l'extension
print(f"Image enregistrée dans {output_path}")
except Exception as e:
print(f"Erreur lors du traitement de l'image : {e}")
# Créer un répertoire de sortie
os.makedirs("generated_images", exist_ok=True)
output_dir = "generated_images"
Génération d'images (client.images.generate)
Créez de nouvelles images à partir d'invites textuelles. gpt-image-1 excelle à suivre des instructions détaillées.
Génération de base :
prompt_text = """
Rendre une image réaliste de ce personnage :
Personnage extraterrestre Blobby Nom de spécification : Glorptak... [reste de l'invite détaillée du livre de recettes]
"""
try:
response = client.images.generate(
model="gpt-image-1",
prompt=prompt_text,
size="1024x1024", # Options : "1024x1024", "1024x1792", "1792x1024", "auto" (le livre de recettes mentionne également "1536x1024", "1024x1536")
quality="high", # Options : "standard", "hd" (Docs API) ou "low", "medium", "high", "auto" (Livre de recettes) - Utilisez 'hd' pour la meilleure qualité via les normes des docs API.
style="vivid", # Options : "vivid", "natural" (Facultatif, influence le réalisme/le drame)
n=1, # Nombre d'images à générer
response_format="b64_json" # Ou "url"
)
# Traiter la réponse (en utilisant la fonction d'assistance)
image_b64 = response.data[0].b64_json
output_path = os.path.join(output_dir, "glorptak.png") # Enregistrer au format PNG
process_b64_json(image_b64, output_path)
except Exception as e:
print(f"Erreur lors de la génération : {e}")
Personnalisation de la sortie :
Le livre de recettes met en évidence des paramètres supplémentaires pour affiner la sortie lors de la génération.
prompt_pixel_cat = "générer un portrait, style pixel art, d'un chat tabby gris habillé en femme blonde sur fond sombre."
try:
response = client.images.generate(
model="gpt-image-1",
prompt=prompt_pixel_cat,
size="1024x1536", # Orientation portrait
quality="low", # Paramètre de qualité inférieur (du livre de recettes)
output_format="jpeg", # Demander une sortie JPEG
output_compression=50, # Niveau de compression JPEG (0-100)
response_format="b64_json",
n=1
)
# Traiter la réponse
image_b64 = response.data[0].b64_json
output_path = os.path.join(output_dir, "pixel_cat.jpeg")
process_b64_json(image_b64, output_path)
except Exception as e:
print(f"Erreur lors de la génération personnalisée : {e}")
Arrière-plan transparent :
Utilisez output_format="png" ou "webp" et définissez background="transparent". Inclure "arrière-plan transparent" dans l'invite pourrait également déclencher cela automatiquement (selon le livre de recettes).
prompt_transparent_hat = "générer une image de style pixel art d'un chapeau de seau vert avec une plume rose sur un fond transparent."
try:
response = client.images.generate(
model="gpt-image-1",
prompt=prompt_transparent_hat,
size="1024x1024",
quality="low",
output_format="png", # Requis pour la transparence
# background="transparent", # Peut être explicitement défini
response_format="b64_json",
n=1
)
# Traiter la réponse
image_b64 = response.data[0].b64_json
output_path = os.path.join(output_dir, "hat_transparent.png")
process_b64_json(image_b64, output_path)
except Exception as e:
print(f"Erreur lors de la génération de l'image transparente : {e}")
Modification d'images (client.images.edit)
Modifiez les images existantes en fonction d'une invite. Peut combiner plusieurs images ou utiliser des masques. Nécessite que les fichiers image soient ouverts en mode de lecture binaire ('rb').
Combinaison/modification de plusieurs images (exemple du livre de recettes) :
Fournissez une liste d'objets de fichiers ouverts au paramètre image.
prompt_combine = "Combinez les images pour montrer le chat portant le chapeau tout en étant perché dans un arbre, toujours dans un style pixel art."
cat_image_path = os.path.join(output_dir, "pixel_cat.jpeg") # Supposons qu'il existe
hat_image_path = os.path.join(output_dir, "hat_transparent.png") # Supposons qu'il existe
img1_file = None
img2_file = None
try:
img1_file = open(cat_image_path, "rb")
img2_file = open(hat_image_path, "rb")
response = client.images.edit(
model="gpt-image-1",
image=[img1_file, img2_file], # Transmettez une liste d'objets de fichiers
prompt=prompt_combine, # Décrivez le résultat combiné souhaité
size="1024x1536", # Correspond à la taille de sortie souhaitée
response_format="b64_json",
n=1
)
# Traiter la réponse
image_b64 = response.data[0].b64_json
output_path = os.path.join(output_dir, "cat_with_hat.jpeg")
process_b64_json(image_b64, output_path)
except FileNotFoundError:
print("Erreur : fichier(s) image d'entrée introuvable(s).")
except Exception as e:
print(f"Erreur lors de la combinaison/modification d'images : {e}")
finally:
# IMPORTANT : fermer les fichiers
if img1_file: img1_file.close()
if img2_file: img2_file.close()
Modification avec un masque :
Fournissez une seule image de base et un fichier mask (PNG avec canal alpha). L'invite décrit l'image finale souhaitée, en tenant compte de la zone masquée.
Étape 1 : obtenir/générer un masque : vous pouvez en créer un manuellement ou utiliser l'API elle-même.
# --- Extrait : génération d'un masque N&B via l'API (du livre de recettes) ---
base_image_path = os.path.join(output_dir, "glorptak.png") # Supposons qu'il existe
mask_prompt = "générer un masque délimitant l'intégralité du personnage dans l'image, en utilisant du blanc là où se trouve le personnage et du noir pour l'arrière-plan. Renvoyer une image de la même taille que l'image d'entrée."
bw_mask_output_path = os.path.join(output_dir, "glorptak_mask_bw.png")
img_input_file = None
try:
img_input_file = open(base_image_path, "rb")
mask_gen_response = client.images.edit( # Oui, le point de terminaison d'édition peut générer des masques
model="gpt-image-1",
image=img_input_file,
prompt=mask_prompt,
size="1024x1024", # Correspond à la taille d'entrée
response_format="b64_json"
)
# Enregistrer le masque N&B généré
mask_b64 = mask_gen_response.data[0].b64_json
process_b64_json(mask_b64, bw_mask_output_path)
except Exception as e:
print(f"Erreur lors de la génération du masque : {e}")
finally:
if img_input_file: img_input_file.close()
Étape 2 : convertir le masque N&B en masque alpha (du livre de recettes) : l'API nécessite que le masque ait un canal alpha.
# --- Extrait : création d'un canal alpha pour le masque ---
bw_mask_path = os.path.join(output_dir, "glorptak_mask_bw.png") # Supposons qu'il existe
alpha_mask_path = os.path.join(output_dir, "glorptak_mask_alpha.png")
try:
mask = Image.open(bw_mask_path).convert("L") # Charger en niveaux de gris
mask_rgba = mask.convert("RGBA") # Convertir en RGBA
mask_rgba.putalpha(mask) # Utiliser l'intensité des niveaux de gris pour l'alpha
mask_rgba.save(alpha_mask_path, format="PNG") # Enregistrer au format PNG
print(f"Masque alpha enregistré dans {alpha_mask_path}")
except FileNotFoundError:
print(f"Erreur : masque N&B introuvable dans {bw_mask_path}")
except Exception as e:
print(f"Erreur lors de la création du masque alpha : {e}")
Étape 3 : effectuer une modification masquée : utilisez l'image de base et le masque alpha.
# --- Extrait : modification avec un masque alpha ---
base_image_path = os.path.join(output_dir, "glorptak.png") # Supposons qu'il existe
alpha_mask_path = os.path.join(output_dir, "glorptak_mask_alpha.png") # Supposons qu'il existe
edit_prompt_masked = "Un personnage étrange sur un fond de galaxie colorée, avec beaucoup d'étoiles et de planètes."
masked_edit_output_path = os.path.join(output_dir, "glorptak_masked_edit.jpeg")
img_input_file = None
mask_alpha_file = None
try:
img_input_file = open(base_image_path, "rb")
mask_alpha_file = open(alpha_mask_path, "rb") # Utiliser le masque avec alpha
response = client.images.edit(
model="gpt-image-1",
image=img_input_file,
mask=mask_alpha_file, # Fournir le fichier de masque alpha
prompt=edit_prompt_masked,
size="1024x1024",
response_format="b64_json",
n=1
)
# Traiter la réponse
image_b64 = response.data[0].b64_json
process_b64_json(image_b64, masked_edit_output_path)
except FileNotFoundError:
print("Erreur : fichier d'image de base ou de masque alpha introuvable.")
except Exception as e:
print(f"Erreur lors de la modification masquée : {e}")
finally:
if img_input_file: img_input_file.close()
if mask_alpha_file: mask_alpha_file.close()
Création de variations d'images (client.images.create_variation)
Générez des variations d'une image existante. Non couvert dans l'exemple du livre de recettes, mais disponible via l'API.
base_image_for_variation_path = os.path.join(output_dir, "glorptak.png") # Supposons qu'il existe
variation_output_path_template = os.path.join(output_dir, "glorptak_variation_{i}.png")
img_input_file = None
try:
img_input_file = open(base_image_for_variation_path, "rb")
response = client.images.create_variation(
model="gpt-image-1", # Spécifiez le modèle s'il est différent de la valeur par défaut (DALL-E 2)
image=img_input_file, # Objet de fichier d'image de base
n=2, # Nombre de variations à créer
size="1024x1024", # Taille souhaitée pour les variations
response_format="b64_json"
)
# Traiter plusieurs résultats si n > 1
for i, data_item in enumerate(response.data):
image_b64 = data_item.b64_json
output_path = variation_output_path_template.format(i=i+1)
process_b64_json(image_b64, output_path)
print(f"Variations générées : {len(response.data)}.")
except FileNotFoundError:
print(f"Erreur : image de base introuvable dans {base_image_for_variation_path}")
except Exception as e:
print(f"Erreur lors de la création de variations : {e}")
finally:
if img_input_file: img_input_file.close()
Ces extraits couvrent les fonctionnalités de base démontrées dans le livre de recettes et la documentation de l'API pour gpt-image-1, en utilisant la bibliothèque officielle openai. N'oubliez pas de gérer les erreurs de manière appropriée et de gérer les ressources de fichiers (fermeture des fichiers) dans votre application complète.
Personnaliser la taille, la qualité et le format de sortie de l'API gpt-image-1
L'API gpt-image-1 offre plusieurs paramètres pour affiner la sortie d'image générée en fonction de vos besoins spécifiques, notamment le format, la qualité, les dimensions et la transparence de l'arrière-plan.
Optimisez les images générées à l'aide de ces paramètres d'API gpt-image-1 :
size : dimensions de l'image. Affecte le coût des jetons et la latence.
- Options :
"1024x1024"(Carré, par défaut),"1024x1536"(Paysage),"1536x1024"(Portrait),"auto".
quality : détail du rendu et coût des jetons.
- Options :
"low","medium","high","auto"(Par défaut). ("hd"dans les documents de l'API correspond probablement à"high"). Une qualité supérieure utilise beaucoup plus de jetons.
output_format : type de fichier pour les données b64_json renvoyées.
- Options :
"png"(Par défaut, prend en charge la transparence, sans perte),"jpeg"(avec perte, pas de transparence),"webp"(moderne, prend en charge la transparence, bonne compression).
output_compression (pour jpeg/webp uniquement) : compromis qualité/taille (0=compression maximale, 100=compression minimale). Exemple : output_compression=75.
Créer une image d'arrière-plan transparente avec gpt-image-1
background : définissez sur "transparent" pour la transparence.
- Nécessite
output_format="png"ou"webp". - Fonctionne mieux avec
quality="medium"ou"high". - Mentionner "arrière-plan transparent" dans l'invite pourrait également l'activer.
Exemple : génération d'une image WebP transparente de haute qualité :
from openai import OpenAI
import base64, os
client = OpenAI()
output_dir = "generated_images"; os.makedirs(output_dir, exist_ok=True)
try:
result = client.images.generate(
model="gpt-image-1",
prompt="Icône d'art vectoriel d'une fusée stylisée, fond transparent",
size="1024x1024",
quality="high", # Qualité supérieure pour une meilleure transparence
output_format="webp", # WebP prend en charge la transparence et une bonne compression
background="transparent", # Demander explicitement la transparence
response_format="b64_json",
n=1
)
# Décoder et enregistrer
img_b64 = result.data[0].b64_json
img_bytes = base64.b64decode(img_b64)
output_path = os.path.join(output_dir, "rocket_icon.webp")
