Nota del autor: Análisis profundo de las razones técnicas por las que Nano Banana Pro no admite el parámetro seed, y qué alternativas prácticas existen cuando estás satisfecho con un resultado y quieres replicarlo en masa.
Un comentario real de un usuario: "He generado una imagen modificada y estoy encantado con el resultado. Quiero generar varias más exactamente con ese mismo efecto, ¿cómo lo hago? Es que cada vez que genero algo, sale distinto". Este es un punto de dolor típico al usar Nano Banana Pro para la generación masiva de imagen a imagen (Img2Img). Aunque pongas la imagen que te gusta como imagen de referencia, el resultado sigue siendo inconsistente. La razón es sencilla: Nano Banana Pro no admite oficialmente el parámetro seed, por lo que cada generación es un proceso de inferencia aleatorio completamente nuevo.
Valor principal: Este artículo no se anda con rodeos. Primero explicamos por qué no hay seed y por qué la imagen de referencia no es suficiente, y luego ofrecemos 5 alternativas efectivas para ayudarte a replicar resultados satisfactorios lo mejor posible sin depender del seed.
Primero aclaremos esto: ¿Por qué Nano Banana Pro no tiene Seed?
Resumen de parámetros oficiales
La generationConfig de Nano Banana Pro (gemini-3-pro-image-preview) admite los siguientes parámetros:
| Nombre del parámetro | Función | Valor de ejemplo |
|---|---|---|
responseModalities |
Especificar tipo de salida | ["IMAGE"] |
resolution |
Resolución de imagen | "1K" / "2K" / "4K" |
aspectRatio |
Relación de aspecto | "16:9" / "1:1" / "2:3" |
candidateCount |
Cantidad de candidatos generados simultáneamente | 1 (fijo en 1 para generación de imágenes) |
temperature |
Aleatoriedad de la parte de texto (no afecta a la imagen) | 1.0 (valor recomendado por defecto) |
Parámetro seed: No está en la lista, no cuenta con soporte oficial.
Si intentas pasar el parámetro seed en el código, obtendrás un error directamente:
# ❌ Esto dará error: Unknown field 'seed' in GenerationConfig
response = model.generate_content(
prompt,
generation_config=genai.GenerationConfig(
response_modalities=["IMAGE"],
seed=42 # ← ¡Error! El parámetro no es compatible oficialmente
)
)
Gemini Image API vs. Imagen API: Dos servicios diferentes
Mucha gente encuentra en la documentación oficial de Google que el parámetro seed sí existe, pero eso es para la Imagen API (el servicio de generación de imágenes en Vertex AI), no para Nano Banana Pro:
| Ítem de comparación | Nano Banana Pro | Imagen API (Vertex AI) |
|---|---|---|
| ID del modelo | gemini-3-pro-image-preview |
imagen-3.0-generate-002 |
| Soporte de Seed | ❌ No compatible | ✅ Compatible (parámetro seed) |
| Endpoint de la API | Google Generative AI | Vertex AI |
| SDK de llamada | google-generativeai |
google-cloud-aiplatform |
| Calidad de imagen | Realismo de primer nivel, excelente renderizado de texto | Alta calidad, estilos variados |
| Precio (APIYI) | $0.05 / imagen | Precio por separado |
Conclusión: Si necesitas obligatoriamente la reproducibilidad del
seed, deberías cambiar a la Imagen API en lugar de perder el tiempo con parámetros inexistentes en Nano Banana Pro. Los intermediarios de terceros como APIYI no admiten la Imagen API; esta API solo se puede utilizar con la KEY oficial del sitio.
¿Por qué las imágenes de referencia tampoco son suficientes?
Usar un resultado satisfactorio como imagen de referencia para una nueva entrada es la idea más intuitiva, pero el efecto real es "regular". La razón fundamental es:
Nano Banana Pro interpreta la imagen de referencia como una "referencia de estilo" y no como una "plantilla de copia". Cuando subes una imagen de referencia y dices "haz esta imagen un poco más oscura", el modelo:
- Analiza el estilo general, la composición y el contenido de la imagen de referencia.
- Reinterpreta la instrucción "hazla un poco más oscura".
- Genera una nueva imagen desde cero que cumpla con la instrucción.
Este proceso tiene aleatoriedad cada vez, por lo que "un poco más oscura" podría ser una reducción del 15% de brillo que te guste la primera vez, un 50% la segunda, o un estilo completamente diferente la tercera.
5 alternativas: de la más directa a la más radical
Opción 1: Cuantificación precisa de las indicaciones (el efecto más inmediato)
Escenario del problema: "Haz la imagen un poquito más oscura" → El resultado a veces es demasiado oscuro y otras veces demasiado claro.
La causa raíz es que "un poquito" es demasiado vago. Nano Banana Pro no puede garantizar que su comprensión de "un poquito" sea consistente cada vez. La solución es sustituir las descripciones vagas por valores numéricos:
❌ Indicación vaga:
"Make this image slightly darker"
"Haz la imagen un poco más oscura"
✅ Indicación cuantificada:
"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."
Formas de escribir cuantificaciones para ajustes comunes:
Ajuste de brillo:
"brightness at 85% of original" (reducir un 15%)
"increase brightness by 10%, keep contrast" (aumentar brillo un 10%)
Ajuste de tono:
"add a very subtle warm orange tint, color shift about 10%"
"slight cool blue cast, saturation unchanged"
Intensidad del estilo:
"apply film grain texture at 20% opacity, barely noticeable"
"add very subtle vignette at corners, 15% strength"
💡 Truco clave: Utiliza modificadores de grado en tus indicaciones como "approximately X%", "not exceeding Y%", "subtle/barely noticeable" para indicarle claramente al modelo los límites de la magnitud del cambio.
Opción 2: Resultado satisfactorio + combinación de indicaciones precisas (la opción recomendada)
Subir solo una imagen de referencia suele dar resultados inestables, pero la combinación de imagen de referencia + indicación cuantificada funciona mucho mejor:
import google.generativeai as genai
import base64
genai.configure(
api_key="YOUR_APIYI_KEY",
client_options={"api_endpoint": "vip.apiyi.com"} # APIYI $0.05/uso
)
model = genai.GenerativeModel("gemini-3-pro-image-preview")
def apply_consistent_effect(
source_image_path: str, # Nueva imagen a procesar
approved_result_path: str, # Primer resultado satisfactorio (como referencia de estilo)
effect_description: str, # Descripción del efecto cuantificada con precisión
output_path: str
) -> str:
"""
Reproduce un efecto satisfactorio en una nueva imagen
Utiliza un doble anclaje: imagen de referencia + indicación cuantificada
"""
# Leer ambas imágenes
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
# Ejemplo de uso
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"
)
# Cada uso cuesta $0.05 (APIYI apiyi.com)
🚀 Sugerencia tras pruebas: Este método eleva la consistencia de "totalmente aleatoria" a "con alta probabilidad de cumplir las expectativas", aunque todavía no es del 100%. Se recomienda generar 2-3 variantes por lote (usar
candidateCountdará error, hay que hacer varias llamadas) y elegir manualmente la más cercana; el bajo costo de $0.05 por uso en APIYI hace que el muestreo múltiple sea viable.
Opción 3: Muestreo múltiple + filtrado por lotes (ideal para escenarios masivos)
La solución más práctica en el panorama actual: generar de 3 a 5 variantes para cada imagen nueva y filtrar manual o programáticamente la más cercana.
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/uso
)
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:
"""Genera n variantes de la misma imagen para filtrar"""
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} fallida: {e}")
return None
# Generar múltiples variantes de forma concurrente
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):
"""Procesar varias imágenes por lotes, generando múltiples variantes de cada una"""
for img_path in image_list:
print(f"\nProcesando: {img_path}")
variants = await generate_variants(img_path, n_variants)
cost = len(variants) * 0.05
print(f" Generadas {len(variants)} variantes, costo ${cost:.2f} (APIYI)")
print(f" Archivos: {variants}")
print(f" → Por favor, seleccione manualmente la variante más satisfactoria")
# Ejemplo: procesar 5 imágenes, generando 3 variantes de cada una
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 imágenes × 3 variantes = 15 llamadas, costo total en APIYI $0.75
Estimación de costos:
| Escala | Nº de variantes | Total de llamadas | Costo en APIYI |
|---|---|---|---|
| 10 imágenes | 3 por imagen | 30 veces | $1.50 |
| 50 imágenes | 3 por imagen | 150 veces | $7.50 |
| 100 imágenes | 2 por imagen | 200 veces | $10.00 |
Opción 4: Cambiar a un modelo que soporte Seed (la solución definitiva)
Si tu negocio requiere una reproducibilidad exacta, la solución más radical es cambiar a un modelo que soporte nativamente el parámetro seed:
Imagen API (Vertex AI) — También de Google, pero soporta seed:
from google.cloud import aiplatform
from vertexai.preview.vision_models import ImageGenerationModel
# Imagen API soporta el parámetro seed
model = ImageGenerationModel.from_pretrained("imagen-3.0-generate-002")
response = model.generate_images(
prompt="your prompt here",
seed=42, # ✅ ¡Soporte oficial!
number_of_images=1,
add_watermark=False # Al usar seed es obligatorio desactivar la marca de agua
)
# Mismo seed + misma indicación → Mismo resultado (alta reproducibilidad)
Stable Diffusion / Flux — Ecosistema completo de seed:
# Acceso a Flux a través de APIYI apiyi.com, con soporte para seed
import requests
response = requests.post(
"https://vip.apiyi.com/v1/images/generations",
headers={"Authorization": "Bearer YOUR_APIYI_KEY"},
json={
"model": "flux-dev", # o flux-schnell
"prompt": "your prompt",
"seed": 12345, # ✅ Soporte completo de seed
"width": 1024,
"height": 1024
}
)
# Bloquear el seed → Generación por lotes de imágenes base totalmente consistentes
Opción 5: Post-procesamiento de imagen (máxima precisión y estabilidad)
Si tu necesidad es aplicar un ajuste fijo de brillo o tono a un lote de imágenes (por ejemplo, oscurecer todas un 15%), la generación por IA no es la mejor opción para este tipo de tareas: el post-procesamiento de imagen tradicional es la herramienta correcta:
from PIL import Image, ImageEnhance
import os
def batch_darken(input_dir: str, output_dir: str, brightness_factor: float = 0.85):
"""
Ajuste preciso de brillo por lotes
brightness_factor: 0.85 = reducir 15%, totalmente reproducible, cero aleatoriedad
"""
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)
# Control preciso del brillo, el resultado es idéntico cada vez
darkened = enhancer.enhance(brightness_factor)
darkened.save(os.path.join(output_dir, filename))
print(f"✓ {filename} → Brillo {brightness_factor*100:.0f}%")
# Procesamiento por lotes, cero costo de API, 100% reproducible
batch_darken("input_images/", "darkened_output/", brightness_factor=0.85)
Comparativa de casos de uso:
| Tipo de ajuste | Herramienta recomendada | Razón |
|---|---|---|
| Brillo/Contraste/Saturación uniforme | PIL / Procesamiento por lotes de Photoshop | Preciso, reproducible, costo cero |
| Filtros de tono uniformes (cálido/frío) | PIL / Filtros LUT | 100% de consistencia |
| Transferencia de estilo compleja (cambio de fondo/sujeto) | Nano Banana Pro | Donde reside el verdadero valor de la IA |
| Reproducción precisa con variaciones creativas | Imagen API (con seed) | Equilibrio entre calidad y consistencia |
🎯 El consejo más honesto: Si solo quieres "oscurecer las imágenes un 15%" de forma masiva, usa
ImageEnhance.Brightnessde PIL. Es gratis, 100% consistente y se hace con una línea de código. El valor de la generación de imágenes por IA reside en la comprensión compleja del contenido y la generación creativa, no en los ajustes paramétricos precisos.
Comparativa de soporte de Seed en modelos de imagen de IA populares
| Modelo | Soporte de Seed | Estabilidad de replicación | Notas |
|---|---|---|---|
| Nano Banana Pro | ❌ No soportado | Baja, aleatorio cada vez | Se puede mejorar parcialmente con imágenes de referencia e indicaciones |
| Imagen API | ✅ Soporte oficial | Alta | Replicable con el mismo seed e indicación |
| Stable Diffusion | ✅ Soporte completo | Muy alta | Ecosistema de código abierto, para despliegue local o en la nube |
| Flux Dev/Pro | ✅ Soportado | Alta | Gran realismo, accesible mediante API |
| Midjourney | ✅ Parámetro --seed |
Media (nivel de referencia) | Estilos similares con el mismo seed, pero no idénticos |
| DALL-E 3 | ❌ No soportado | Baja | Limitaciones similares a las de Nano Banana Pro |
💡 Sugerencia de la plataforma: A través de APIYI (apiyi.com) puedes acceder de forma unificada a varios modelos de imagen como Nano Banana Pro, Flux y Stable Diffusion. Usa una sola API Key para alternar entre modelos, lo que te permite elegir con flexibilidad según necesites usar seeds o no.
