Nota do autor: Uma análise profunda dos motivos técnicos pelos quais o Nano Banana Pro não suporta o parâmetro seed, além de soluções práticas para quando você quer replicar um efeito específico em lote.
Um feedback real de usuário: "Eu alterei a imagem e o resultado ficou ótimo, agora eu queria gerar várias outras com esse exato efeito, como eu faço? Porque cada vez que gera sai diferente." Este é um ponto de dor típico ao fazer geração em lote (image-to-image) com o Nano Banana Pro. Tentar usar a imagem que você gostou como imagem de referência não resolve o problema — e o motivo é simples: o Nano Banana Pro oficialmente não suporta o parâmetro seed, o que significa que cada geração é um processo de inferência aleatório totalmente novo.
Valor central: Este artigo vai direto ao ponto. Primeiro, explicamos por que não existe o seed e por que a imagem de referência não é suficiente; depois, apresentamos 5 alternativas eficazes para ajudar você a replicar resultados satisfatórios mesmo sem o seed.
Vamos esclarecer: Por que o Nano Banana Pro não tem Seed?
Visão geral dos parâmetros oficiais
O generationConfig do Nano Banana Pro (gemini-3-pro-image-preview) suporta os seguintes parâmetros:
| Nome do parâmetro | Função | Valor de exemplo |
|---|---|---|
responseModalities |
Especifica o tipo de saída | ["IMAGE"] |
resolution |
Resolução da imagem | "1K" / "2K" / "4K" |
aspectRatio |
Proporção (Aspect Ratio) | "16:9" / "1:1" / "2:3" |
candidateCount |
Quantidade de candidatos gerados simultaneamente | 1 (fixo em 1 para geração de imagem) |
temperature |
Aleatoriedade da parte de texto (não afeta a imagem) | 1.0 (padrão recomendado) |
Parâmetro seed: Não está na lista, não é suportado oficialmente.
Tentar passar o seed no código resultará em erro diretamente:
# ❌ Isso causará um erro: Unknown field 'seed' in GenerationConfig
response = model.generate_content(
prompt,
generation_config=genai.GenerationConfig(
response_modalities=["IMAGE"],
seed=42 # ← Erro! O parâmetro não é suportado oficialmente
)
)
Gemini Image API vs. Imagen API: Dois serviços diferentes
Muita gente encontra na documentação oficial do Google que o parâmetro seed realmente existe, mas aquilo se refere à Imagen API (serviço de geração de imagem no Vertex AI), não ao Nano Banana Pro:
| Item de comparação | Nano Banana Pro | Imagen API (Vertex AI) |
|---|---|---|
| ID do Modelo | gemini-3-pro-image-preview |
imagen-3.0-generate-002 |
| Suporte a Seed | ❌ Não suportado | ✅ Suportado (parâmetro seed) |
| Endpoint da API | Google Generative AI | Vertex AI |
| SDK de chamada | google-generativeai |
google-cloud-aiplatform |
| Qualidade da imagem | Realismo de ponta, forte renderização de texto | Alta qualidade, estilos diversos |
| Preço (APIYI) | $0.05 / imagem | Precificação separada |
Conclusão: Se você realmente precisa de reprodutibilidade via seed, deve mudar para a Imagen API em vez de tentar usar parâmetros inexistentes no Nano Banana Pro. Intermediários de terceiros, como a APIYI, não suportam a Imagen API; essa API só pode ser usada com a KEY oficial.
Por que imagens de referência também não são suficientes?
Inserir um resultado satisfatório como imagem de referência novamente é a ideia mais intuitiva, mas o efeito real é "médio". O motivo fundamental é:
O Nano Banana Pro entende a imagem de referência como uma "referência de estilo" e não como um "modelo de cópia". Quando você faz o upload de uma imagem de referência e diz "deixe esta imagem um pouco mais escura", o modelo:
- Analisa o estilo geral, a composição e o conteúdo da imagem de referência.
- Reinterpreta o comando "deixe um pouco mais escuro".
- Gera uma nova imagem do zero que atenda ao comando.
Esse processo tem aleatoriedade toda vez, então "um pouco mais escuro" pode resultar em uma redução de brilho de 15% (exatamente o que você queria) na primeira vez, 50% na segunda e um estilo completamente diferente na terceira.
5 alternativas: da mais direta à mais radical
Esquema 1: Comandos quantificados com precisão (efeito imediato)
Cenário do problema: "Deixe a imagem um pouco mais escura" → O resultado às vezes fica escuro demais, outras vezes quase não muda.
A causa raiz é que "um pouco" é muito vago. O Nano Banana Pro não consegue garantir que entenderá "um pouco" da mesma forma todas as vezes. A solução é substituir descrições vagas por valores numéricos:
❌ Comando vago:
"Make this image slightly darker"
"Deixe a imagem um pouco mais escura"
✅ Comando quantificado:
"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."
Exemplos de escrita quantificada para ajustes comuns:
Ajuste de brilho:
"brightness at 85% of original" (reduzir 15%)
"increase brightness by 10%, keep contrast" (aumentar brilho em 10%)
Ajuste de tom:
"add a very subtle warm orange tint, color shift about 10%"
"slight cool blue cast, saturation unchanged"
Intensidade de estilo:
"apply film grain texture at 20% opacity, barely noticeable"
"add very subtle vignette at corners, 15% strength"
💡 Dica chave: Use termos limitadores no comando como "approximately X%", "not exceeding Y%", "subtle/barely noticeable" para definir claramente as fronteiras da mudança para o modelo.
Esquema 2: Resultado satisfatório + Combinação de comandos precisos (recomendação principal)
Apenas enviar uma imagem de referência pode ter resultados instáveis, mas a combinação de imagem de referência + comando quantificado funciona muito melhor:
import google.generativeai as genai
import base64
genai.configure(
api_key="YOUR_APIYI_KEY",
client_options={"api_endpoint": "vip.apiyi.com"} # APIYI $0.05/次
)
model = genai.GenerativeModel("gemini-3-pro-image-preview")
def apply_consistent_effect(
source_image_path: str, # 要处理的新图
approved_result_path: str, # 第一次满意的结果（作为风格参考）
effect_description: str, # 精准量化的效果描述
output_path: str
) -> str:
"""
将满意的效果复现到新图上
使用参考图 + 精准量化提示词双重锚定
"""
# 读取两张图
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
# 使用示例
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（APIYI apiyi.com）
🚀 Sugestão de teste: Este método eleva a consistência de "totalmente aleatória" para "provavelmente dentro do esperado", mas ainda não é 100%. Recomenda-se gerar 2 a 3 variantes por lote (usar
candidateCountpode causar erro, então faça múltiplas chamadas) e escolher manualmente a melhor. O baixo custo de $0,05 por vez na APIYI torna essa amostragem múltipla viável.
Esquema 3: Amostragem múltipla + Filtragem em lote (ideal para cenários em massa)
A solução mais pragmática para o cenário atual: gerar de 3 a 5 variantes para cada nova imagem e filtrar a mais próxima manualmente ou por programa.
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/次
)
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:
"""对同一张图生成 n 个变体，供筛选"""
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" 变体 {i+1} 失败: {e}")
return None
# 并发生成多个变体
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):
"""批量处理多张图，每张生成多个变体"""
for img_path in image_list:
print(f"\n处理: {img_path}")
variants = await generate_variants(img_path, n_variants)
cost = len(variants) * 0.05
print(f" 生成 {len(variants)} 个变体，成本 ${cost:.2f}（APIYI）")
print(f" 文件: {variants}")
print(f" → 请人工选出最满意的变体")
# 示例：处理 5 张图，每张生成 3 个变体
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张图 × 3个变体 = 15次调用，APIYI总成本 $0.75
Estimativa de custo:
| Escala | Nº de Variantes | Total de Chamadas | Custo na APIYI |
|---|---|---|---|
| 10 imagens | 3 por imagem | 30 vezes | $1.50 |
| 50 imagens | 3 por imagem | 150 vezes | $7.50 |
| 100 imagens | 2 por imagem | 200 vezes | $10.00 |
Esquema 4: Mudar para modelos que suportam Seed (solução definitiva)
Se o seu negócio realmente exige reprodutibilidade precisa, a solução mais radical é mudar para um modelo que suporte nativamente o parâmetro seed:
Imagen API (Vertex AI) — Também do Google, suporta seed:
from google.cloud import aiplatform
from vertexai.preview.vision_models import ImageGenerationModel
# Imagen API 支持 seed 参数
model = ImageGenerationModel.from_pretrained("imagen-3.0-generate-002")
response = model.generate_images(
prompt="your prompt here",
seed=42, # ✅ 官方支持！
number_of_images=1,
add_watermark=False # 使用 seed 时必须关闭水印
)
# 相同 seed + 相同 prompt → 相同结果（高可复现）
Stable Diffusion / Flux — Ecossistema completo de seed:
# 通过 APIYI apiyi.com 接入 Flux，支持 seed
import requests
response = requests.post(
"https://vip.apiyi.com/v1/images/generations",
headers={"Authorization": "Bearer YOUR_APIYI_KEY"},
json={
"model": "flux-dev", # 或 flux-schnell
"prompt": "your prompt",
"seed": 12345, # ✅ 完整 seed 支持
"width": 1024,
"height": 1024
}
)
# 锁定 seed → 批量生成完全一致的基础图
Esquema 5: Pós-processamento de imagem (maior precisão e estabilidade)
Se a sua necessidade é aplicar um ajuste fixo de brilho/tom em lote (como escurecer tudo em 15%), usar geração por IA não é a melhor escolha — o pós-processamento de imagem tradicional é a ferramenta correta:
from PIL import Image, ImageEnhance
import os
def batch_darken(input_dir: str, output_dir: str, brightness_factor: float = 0.85):
"""
精确批量调整亮度
brightness_factor: 0.85 = 降低15%，完全可复现，零随机性
"""
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)
# 精确控制亮度，每次结果完全一致
darkened = enhancer.enhance(brightness_factor)
darkened.save(os.path.join(output_dir, filename))
print(f"✓ {filename} → 亮度 {brightness_factor*100:.0f}%")
# 批量处理，零 API 成本，100% 可复现
batch_darken("input_images/", "darkened_output/", brightness_factor=0.85)
Comparação de cenários de aplicação:
| Tipo de ajuste | Ferramenta recomendada | Motivo |
|---|---|---|
| Brilho/Contraste/Saturação uniforme | PIL / Processamento em lote Photoshop | Preciso, reprodutível, custo zero |
| Filtro de tom uniforme (Quente/Frio) | PIL / Filtros LUT | 100% de consistência |
| Transferência de estilo complexa (Troca de fundo/objeto) | Nano Banana Pro | Onde está o verdadeiro valor da IA |
| Reprodução precisa com variações criativas | Imagen API (com seed) | Equilibra qualidade e consistência |
🎯 O conselho mais sincero: Se você quer apenas "escurecer a imagem em 15%" em massa, use o
ImageEnhance.Brightnessdo PIL. É custo zero, 100% consistente e resolvido com uma linha de código. O valor da geração de imagens por IA está na compreensão de conteúdo complexo e na geração criativa, não em ajustes paramétricos precisos.
Comparação de Suporte a Seed em Modelos de Imagem de IA
| Modelo | Suporte a Seed | Estabilidade de Reprodução | Observações |
|---|---|---|---|
| Nano Banana Pro | ❌ Não suportado | Baixa, aleatório a cada vez | Imagens de referência + comandos podem melhorar parcialmente |
| Imagen API | ✅ Suporte oficial | Alta | Reproduzível com o mesmo seed e comando |
| Stable Diffusion | ✅ Suporte completo | Muito alta | Ecossistema de código aberto, auto-hospedado ou na nuvem |
| Flux Dev/Pro | ✅ Suportado | Alta | Forte realismo, acessível via API |
| Midjourney | ✅ parâmetro --seed |
Média (nível de referência) | Estilos semelhantes com o mesmo seed, mas não idênticos |
| DALL-E 3 | ❌ Não suportado | Baixa | Limitações semelhantes ao Nano Banana Pro |
💡 Sugestão da plataforma: Através do APIYI (apiyi.com), você pode acessar de forma unificada o Nano Banana Pro, Flux, Stable Diffusion e vários outros modelos de imagem. Use a mesma chave de API para alternar entre modelos, facilitando a escolha flexível dependendo da sua necessidade de usar ou não um seed.
