Note de l'auteur : Analyse approfondie des raisons techniques pour lesquelles Nano Banana Pro ne supporte pas le paramètre seed, et des alternatives concrètes et réalisables lorsque vous êtes satisfait d'un résultat et que vous souhaitez le reproduire par lots.
Un retour utilisateur réel : "J'ai généré une image par modification, je suis très satisfait du résultat et je voudrais en créer plusieurs autres exactement avec le même effet. Comment faire ? Parce qu'à chaque fois, le résultat est un peu différent." C'est un point de douleur typique lors de l'utilisation de Nano Banana Pro pour la génération d'images par lots. Même en insérant l'image qui vous plaît comme image de référence, le résultat reste incohérent — la raison est simple : Nano Banana Pro ne supporte pas officiellement le paramètre seed, chaque génération est un tout nouveau processus d'inférence aléatoire.
Valeur ajoutée : Cet article ne tourne pas autour du pot. Il explique d'abord clairement pourquoi il n'y a pas de seed et pourquoi l'image de référence ne suffit pas, puis propose 5 alternatives efficaces pour vous aider à reproduire au mieux un effet satisfaisant sans seed.
Commençons par mettre les choses au clair : pourquoi Nano Banana Pro n'a pas de Seed ?
Aperçu des paramètres officiels
La configuration generationConfig de Nano Banana Pro (gemini-3-pro-image-preview) prend en charge les paramètres suivants :
| Nom du paramètre | Rôle | Valeur d'exemple |
|---|---|---|
responseModalities |
Spécifie le type de sortie | ["IMAGE"] |
resolution |
Résolution de l'image | "1K" / "2K" / "4K" |
aspectRatio |
Rapport d'aspect | "16:9" / "1:1" / "2:3" |
candidateCount |
Nombre de variantes générées simultanément | 1 (fixe pour la génération d'images) |
temperature |
Aléatoire pour la partie textuelle (n'affecte pas l'image) | 1.0 (recommandé par défaut) |
Paramètre seed : absent de la liste, non supporté officiellement.
Tenter de passer un seed dans le code provoquera directement une erreur :
# ❌ Cela générera une erreur : Unknown field 'seed' in GenerationConfig
response = model.generate_content(
prompt,
generation_config=genai.GenerationConfig(
response_modalities=["IMAGE"],
seed=42 # ← Erreur ! Ce paramètre n'est pas supporté officiellement
)
)
Gemini Image API vs Imagen API : deux services distincts
Beaucoup de gens trouvent le paramètre seed dans la documentation officielle de Google, mais il s'agit de l'API Imagen (le service de génération d'images sur Vertex AI), pas de Nano Banana Pro :
| Point de comparaison | Nano Banana Pro | API Imagen (Vertex AI) |
|---|---|---|
| ID du modèle | gemini-3-pro-image-preview |
imagen-3.0-generate-002 |
| Support du Seed | ❌ Non supporté | ✅ Supporté (paramètre seed) |
| Point de terminaison API | Google Generative AI | Vertex AI |
| SDK d'appel | google-generativeai |
google-cloud-aiplatform |
| Qualité d'image | Réalisme de pointe, excellent rendu de texte | Haute qualité, styles variés |
| Prix (APIYI) | 0,05 $/image | Tarification distincte |
Conclusion : Si vous avez absolument besoin de la reproductibilité via un seed, vous devriez passer à l'API Imagen au lieu de chercher un paramètre inexistant sur Nano Banana Pro. Les plateformes tierces comme APIYI ne supportent pas l'API Imagen ; cette API n'est utilisable qu'avec une clé officielle (KEY).
Pourquoi l'image de référence ne suffit-elle pas ?
L'idée la plus intuitive est d'utiliser un résultat satisfaisant comme image de référence pour une nouvelle génération, mais le résultat est souvent "moyen". La raison fondamentale est la suivante :
Nano Banana Pro interprète l'image de référence comme une "référence de style" et non comme un "modèle à copier". Lorsque vous téléchargez une image de référence et dites "rends cette image un peu plus sombre", le modèle va :
- Analyser le style général, la composition et le contenu de l'image de référence.
- Réinterpréter l'invite "un peu plus sombre".
- Générer une toute nouvelle image à partir de zéro qui correspond à l'instruction.
Ce processus comporte une part d'aléatoire à chaque fois. Ainsi, "un peu plus sombre" peut correspondre exactement à la baisse de luminosité de 15 % que vous espériez la première fois, devenir une baisse de 50 % la deuxième, et un style totalement différent la troisième.
5 alternatives : de la plus directe à la plus radicale
Option 1 : Quantification précise des invites (l'effet le plus immédiat)
Problématique : "Rendre l'image un peu plus sombre" → Le résultat est parfois trop noir, parfois trop clair.
La cause fondamentale est que "un peu" est trop vague. Nano Banana Pro ne peut pas garantir une compréhension constante de ce "un peu" à chaque fois. La solution consiste à remplacer les descriptions floues par des valeurs numériques :
❌ Invite floue :
"Make this image slightly darker"
"Rendre l'image un peu plus sombre"
✅ Invite quantifiée :
"Apply a subtle darkening effect equivalent to reducing brightness by
approximately 15-20%. The image should feel slightly moodier but all
details must remain clearly visible. Do NOT go dark. The result should
be close to: brightness 85% of original, contrast unchanged."
Exemples de rédaction quantifiée pour les ajustements courants :
Ajustement de la luminosité :
"brightness at 85% of original" (réduction de 15 %)
"increase brightness by 10%, keep contrast" (augmentation de 10 %)
Ajustement de la teinte :
"add a very subtle warm orange tint, color shift about 10%"
"slight cool blue cast, saturation unchanged"
Intensité du style :
"apply film grain texture at 20% opacity, barely noticeable"
"add very subtle vignette at corners, 15% strength"
💡 Astuce clé : Utilisez dans vos invites des termes de limitation de degré comme "approximately X%", "not exceeding Y%", "subtle/barely noticeable" pour indiquer clairement au modèle les limites de l'amplitude du changement.
Option 2 : Résultat satisfaisant + Combinaison d'invites précises (le choix recommandé)
Le simple fait de télécharger une image de référence donne des résultats instables, mais la combinaison image de référence + invite quantifiée fonctionne beaucoup mieux :
import google.generativeai as genai
import base64
genai.configure(
api_key="YOUR_APIYI_KEY",
client_options={"api_endpoint": "vip.apiyi.com"} # APIYI 0,05 $ / appel
)
model = genai.GenerativeModel("gemini-3-pro-image-preview")
def apply_consistent_effect(
source_image_path: str, # Nouvelle image à traiter
approved_result_path: str, # Premier résultat satisfaisant (comme référence de style)
effect_description: str, # Description de l'effet précisément quantifiée
output_path: str
) -> str:
"""
Reproduit un effet satisfaisant sur une nouvelle image
Utilise un double ancrage : image de référence + invite quantifiée
"""
# Lecture des deux images
with open(source_image_path, "rb") as f:
source_data = base64.b64encode(f.read()).decode()
with open(approved_result_path, "rb") as f:
approved_data = base64.b64encode(f.read()).decode()
prompt = f"""
I have two reference images:
- Image 1 (source): The new image I want to process
- Image 2 (approved result): A previous edit I was very happy with
Please apply the SAME effect from Image 2 to Image 1.
The effect is: {effect_description}
Critical instructions:
- The degree of change should match Image 2 EXACTLY
- Do not over-apply the effect
- Keep all other image properties unchanged
- If unsure about intensity, err on the side of LESS change
"""
response = model.generate_content(
[
{"inline_data": {"mime_type": "image/jpeg", "data": source_data}},
{"inline_data": {"mime_type": "image/jpeg", "data": approved_data}},
prompt
],
generation_config=genai.GenerationConfig(
response_modalities=["IMAGE"],
resolution="4K",
aspect_ratio="1:1"
)
)
for part in response.candidates[0].content.parts:
if part.inline_data and part.inline_data.mime_type.startswith("image/"):
with open(output_path, "wb") as f:
f.write(base64.b64decode(part.inline_data.data))
return output_path
return None
# Exemple d'utilisation
result = apply_consistent_effect(
source_image_path="new_product_photo.jpg",
approved_result_path="approved_dark_edit.jpg",
effect_description="subtle darkening, brightness reduced by approximately 15-20%, "
"image should be slightly moodier but all details clearly visible",
output_path="output_consistent.png"
)
# 0,05 $ par passage (APIYI apiyi.com)
🚀 Conseil pratique : Cette méthode fait passer la cohérence de "totalement aléatoire" à "probablement conforme aux attentes", mais ce n'est toujours pas du 100 %. Il est conseillé de générer 2 à 3 variantes par lot (l'utilisation de
candidateCountpouvant échouer, il faut multiplier les appels). Le faible coût de 0,05 $ par appel sur APIYI rend cet échantillonnage multiple viable.
Option 3 : Échantillonnage multiple + Filtrage par lot (idéal pour les scénarios de masse)
C'est l'approche la plus pragmatique actuellement : générer 3 à 5 variantes pour chaque nouvelle image, puis filtrer manuellement ou par programme la plus proche.
import asyncio
import base64
import os
import google.generativeai as genai
genai.configure(
api_key="YOUR_APIYI_KEY",
client_options={"api_endpoint": "vip.apiyi.com"} # APIYI 0,05 $ / appel
)
model = genai.GenerativeModel("gemini-3-pro-image-preview")
EFFECT_PROMPT = """
Apply subtle darkening effect:
- Brightness: approximately 85% of original (reduce by ~15%)
- Mood: slightly darker, more atmospheric
- Details: all elements must remain clearly visible
- Do NOT: make it too dark, change colors dramatically, lose details
This is a subtle, refined adjustment - less is more.
"""
async def generate_variants(image_path: str, n_variants: int = 3) -> list:
"""Génère n variantes pour une même image pour sélection"""
with open(image_path, "rb") as f:
img_data = base64.b64encode(f.read()).decode()
async def one_call(i: int) -> str:
output = image_path.replace(".jpg", f"_v{i+1}.png")
loop = asyncio.get_event_loop()
try:
response = await loop.run_in_executor(None, lambda: model.generate_content(
[{"inline_data": {"mime_type": "image/jpeg", "data": img_data}},
EFFECT_PROMPT],
generation_config=genai.GenerationConfig(
response_modalities=["IMAGE"],
resolution="4K"
)
))
for part in response.candidates[0].content.parts:
if part.inline_data:
with open(output, "wb") as f:
f.write(base64.b64decode(part.inline_data.data))
return output
except Exception as e:
print(f" Variante {i+1} échouée : {e}")
return None
# Génération concurrente de plusieurs variantes
results = await asyncio.gather(*[one_call(i) for i in range(n_variants)])
return [r for r in results if r]
async def batch_process(image_list: list, n_variants: int = 3):
"""Traitement par lot de plusieurs images, avec plusieurs variantes pour chacune"""
for img_path in image_list:
print(f"\nTraitement : {img_path}")
variants = await generate_variants(img_path, n_variants)
cost = len(variants) * 0.05
print(f" Généré {len(variants)} variantes, coût {cost:.2f} $ (APIYI)")
print(f" Fichiers : {variants}")
print(f" → Veuillez choisir manuellement la variante la plus satisfaisante")
# Exemple : traiter 5 images, générer 3 variantes pour chacune
images = ["photo_01.jpg", "photo_02.jpg", "photo_03.jpg", "photo_04.jpg", "photo_05.jpg"]
asyncio.run(batch_process(images, n_variants=3))
# 5 images × 3 variantes = 15 appels, coût total APIYI 0,75 $
Estimation des coûts :
| Échelle | Nb de variantes | Total d'appels | Coût APIYI |
|---|---|---|---|
| 10 images | 3 par image | 30 fois | 1,50 $ |
| 50 images | 3 par image | 150 fois | 7,50 $ |
| 100 images | 2 par image | 200 fois | 10,00 $ |
Option 4 : Passer à un modèle supportant le Seed (la solution radicale)
Si votre activité nécessite une reproductibilité exacte, la solution la plus radicale est de passer à un modèle qui supporte nativement le seed :
Imagen API (Vertex AI) — Également de Google, supporte le seed :
from google.cloud import aiplatform
from vertexai.preview.vision_models import ImageGenerationModel
# L'API Imagen supporte le paramètre seed
model = ImageGenerationModel.from_pretrained("imagen-3.0-generate-002")
response = model.generate_images(
prompt="your prompt here",
seed=42, # ✅ Support officiel !
number_of_images=1,
add_watermark=False # Le filigrane doit être désactivé lors de l'utilisation du seed
)
# Même seed + même invite → même résultat (haute reproductibilité)
Stable Diffusion / Flux — Écosystème complet de seed :
# Accès à Flux via APIYI (apiyi.com), supporte le seed
import requests
response = requests.post(
"https://vip.apiyi.com/v1/images/generations",
headers={"Authorization": "Bearer YOUR_APIYI_KEY"},
json={
"model": "flux-dev", # ou flux-schnell
"prompt": "your prompt",
"seed": 12345, # ✅ Support complet du seed
"width": 1024,
"height": 1024
}
)
# Verrouiller le seed → génération par lot d'images de base parfaitement identiques
Option 5 : Post-traitement d'image (précision maximale, stabilité totale)
Si votre besoin est de réaliser des ajustements fixes de luminosité ou de teinte sur un lot d'images (par exemple, assombrir uniformément de 15 %), l'utilisation d'un Grand modèle de langage pour la génération n'est pas le choix optimal. Le post-traitement d'image classique est l'outil approprié :
from PIL import Image, ImageEnhance
import os
def batch_darken(input_dir: str, output_dir: str, brightness_factor: float = 0.85):
"""
Ajustement précis de la luminosité par lot
brightness_factor : 0.85 = réduction de 15 %, totalement reproductible, zéro aléatoire
"""
os.makedirs(output_dir, exist_ok=True)
files = [f for f in os.listdir(input_dir) if f.lower().endswith(('.jpg', '.png', '.webp'))]
for filename in files:
img = Image.open(os.path.join(input_dir, filename))
enhancer = ImageEnhance.Brightness(img)
# Contrôle précis de la luminosité, résultat identique à chaque fois
darkened = enhancer.enhance(brightness_factor)
darkened.save(os.path.join(output_dir, filename))
print(f"✓ {filename} → Luminosité {brightness_factor*100:.0f}%")
# Traitement par lot, coût API nul, reproductibilité 100 %
batch_darken("input_images/", "darkened_output/", brightness_factor=0.85)
Comparaison des scénarios d'utilisation :
| Type d'ajustement | Outil recommandé | Raison |
|---|---|---|
| Luminosité/Contraste/Saturation uniforme | PIL / Traitement par lot Photoshop | Précis, reproductible, coût nul |
| Filtres de teinte uniformes (Chaud/Froid) | PIL / Filtres LUT | Cohérence à 100 % |
| Transfert de style complexe (Changement de décor/sujet) | Nano Banana Pro | C'est là que réside la vraie valeur de l'IA |
| Reproduction précise avec variations créatives | Imagen API (avec seed) | Allie qualité et cohérence |
🎯 Le conseil le plus honnête : Si vous voulez simplement "assombrir des images de 15 %" en masse, utilisez
ImageEnhance.Brightnessde PIL. C'est gratuit, 100 % cohérent et se règle en une ligne de code. La valeur de la génération d'images par IA réside dans la compréhension de contenus complexes et la création, pas dans les ajustements paramétriques précis.
Comparaison du support des Seeds pour les principaux modèles d'IA génératrice d'images
| Modèle | Support du Seed | Stabilité de reproduction | Remarques |
|---|---|---|---|
| Nano Banana Pro | ❌ Non supporté | Faible, aléatoire à chaque fois | L'image de référence + l'invite peuvent améliorer partiellement les choses |
| Imagen API | ✅ Support officiel | Élevée | Reproductible avec le même seed et la même invite |
| Stable Diffusion | ✅ Support complet | Très élevée | Écosystème open-source, auto-hébergé ou cloud |
| Flux Dev/Pro | ✅ Supporté | Élevée | Fort réalisme, accessible via API |
| Midjourney | ✅ Paramètre --seed |
Moyenne (niveau de référence) | Style similaire avec le même seed, mais pas identique |
| DALL-E 3 | ❌ Non supporté | Faible | Limitations similaires à Nano Banana Pro |
💡 Conseil de plateforme : Via APIYI (apiyi.com), vous pouvez accéder de manière centralisée à plusieurs modèles d'images tels que Nano Banana Pro, Flux et Stable Diffusion. Utilisez une seule clé API pour basculer entre les modèles, ce qui facilite le choix flexible selon vos besoins en matière de seed.
FAQ
Q1 : Existe-t-il un moyen de « hacker » un effet de seed sur Nano Banana Pro ?
Il n'existe pas de véritable méthode de "hack". Certaines plateformes tierces (comme fal.ai) ajoutent un paramètre seed dans leur couche d'encapsulation API, mais cela ne contrôle que le caractère aléatoire au niveau de leur plateforme. Ce n'est pas l'équivalent du seed natif de Google Gemini pour la génération d'images — en réalité, l'impact sur la reproductibilité de l'image finale est très limité.
La combinaison la plus proche d'un "effet seed" est la suivante : invite quantifiée avec précision + résultat satisfaisant comme image de référence + filtrage par échantillonnage multiple. Cette combinaison permet de faire passer la cohérence d'un hasard total à une probabilité de réussite d'environ 60-70 %, mais ce ne sera jamais du 100 %.
Si votre flux de travail exige une reproductibilité stricte, il est recommandé de passer à l'API Imagen. Via APIYI (apiyi.com), vous pouvez accéder simultanément à plusieurs services pour effectuer des tests comparatifs.
Q2 : Je souhaite reproduire en masse un effet « légèrement plus sombre », quelle est la méthode la plus rapide ?
Tout dépend de la nature du "sombre" :
- S'il s'agit uniquement d'un ajustement de luminosité/exposition : utilisez directement un traitement par lot avec Python PIL
ImageEnhance.Brightness(img).enhance(0.85). 10 lignes de code, coût nul, cohérence à 100 %. - S'il s'agit de style, d'ambiance ou de génération de contenu par IA (par exemple, "ton sombre tout en donnant un aspect plus cinématographique à l'arrière-plan") : utilisez la solution 2 (image de référence + invite quantifiée). Passez par des appels groupés via APIYI (apiyi.com) à 0,05 $ l'unité, générez 2-3 variantes, puis choisissez manuellement la plus proche.
Q3 : Nano Banana Pro supportera-t-il le paramètre seed à l’avenir ?
Il n'y a aucune annonce officielle pour le moment. Si l'on regarde la feuille de route des produits Google, l'API Imagen est le service dédié à la génération d'images précise et contrôlable (incluant le seed), tandis que la génération d'images Gemini est davantage orientée vers la "création de haute qualité". Leurs positionnements sont différents ; la possibilité que Nano Banana Pro intègre le seed à l'avenir existe, mais reste incertaine.
Vous pouvez suivre le blog officiel de Google AI (blog.google/technology/google-deepmind) et le changelog de l'API Gemini (ai.google.dev/gemini-api/docs/changelog) pour les dernières actualités. En cas de mise à jour, nous publierons immédiatement les guides d'utilisation correspondants sur APIYI (apiyi.com).
Résumé
Il faut accepter le fait que Nano Banana Pro ne supporte pas le paramètre seed. Voici 5 alternatives à choisir selon votre scénario :
- Invite quantifiée avec précision : remplacez les descriptions floues comme "un petit peu" par des valeurs numériques, l'effet est immédiat.
- Image de référence + invite quantifiée : deux entrées d'image (image source + résultat satisfaisant) pour décrire précisément le degré de l'effet à reproduire.
- Filtrage par échantillonnage multiple : générez 2-3 variantes pour chaque image. Le coût est faible sur APIYI (0,05 $/itération), ce qui permet de choisir manuellement la plus proche.
- Passer à l'API Imagen / Flux : si votre activité a des exigences de reproductibilité strictes, utilisez des modèles qui supportent nativement le seed.
- Post-traitement PIL : s'il ne s'agit que d'ajustements fixes de luminosité ou de teinte, l'IA n'est pas l'outil optimal ; PIL sera plus précis.
Il n'y a pas de solution miracle, choisissez l'option la plus adaptée à votre situation. Le faible coût de l'échantillonnage multiple (0,05 $ par itération) rend la stratégie de "sélection par essais et erreurs" tout à fait viable sur la plateforme APIYI (apiyi.com), alors qu'elle coûterait 5 fois plus cher au prix officiel (0,24 $ par itération).
Ressources
-
Documentation des paramètres de génération d'images de l'API Google Gemini
- Lien :
ai.google.dev/gemini-api/docs/image-generation - Description : Liste officielle des paramètres pris en charge par generationConfig, confirmant l'absence du champ seed.
- Lien :
-
Documentation de l'API Vertex AI Imagen (avec support du seed)
- Lien :
cloud.google.com/vertex-ai/generative-ai/docs/image/generate-images - Description : Utilisation et limitations du paramètre seed dans l'API Imagen.
- Lien :
-
Gemini Python SDK GitHub Issue #536
- Lien :
github.com/google-gemini/deprecated-generative-ai-python/issues/536 - Description : Discussion au sein de la communauté confirmant que le paramètre seed n'est pas pris en charge pour la génération d'images avec Gemini.
- Lien :
-
Accès multi-modèles sur la plateforme APIYI
- Lien :
docs.apiyi.com - Description : Instructions d'accès unifiées pour Nano Banana Pro / Imagen / Flux.
- Lien :
Auteur : Équipe technique
Échanges techniques : Vous rencontrez des problèmes de cohérence similaires lors de générations d'images par lots ? N'hésitez pas à en discuter dans l'espace commentaires. Pour plus de retours d'expérience concrets sur la génération d'images par IA, vous pouvez visiter la communauté technique d'APIYI sur apiyi.com.
