3 méthodes pour résoudre la sortie d’images PNG de l’API Nano Banana 2 : la vérité sur la réduction des images 4K de 30 Mo à 8 Mo

Note de l'auteur : découvrez comment l'API Nano Banana 2 génère des images PNG plutôt que JPEG, et pourquoi le poids des images 4K sur AI Studio est passé de 30 Mo à 8 Mo.

Beaucoup de développeurs sont perplexes lorsqu'ils génèrent des images avec l'API Nano Banana 2 : l'API renvoie des données en base64, mais s'agit-il réellement d'un PNG ou d'un JPEG une fois enregistré ? Plus surprenant encore, pour une même résolution 4K, le poids des images générées par AI Studio a chuté de plus de 30 Mo à environ 8 Mo. Cet article décortique les mécanismes sous-jacents de l'API pour expliquer la gestion des formats et cette réduction de taille.

Valeur ajoutée : À la fin de cet article, vous saurez comment obtenir correctement un format PNG via l'API Nano Banana 2 et vous comprendrez la raison technique derrière la réduction du poids des images 4K.

Points clés sur le format de sortie image de l'API Nano Banana 2

Clarifions un fait essentiel : les données d'image renvoyées par l'API Nano Banana 2 sont encodées en base64, mais le base64 n'est qu'un mode de transport ; ce sont les octets sous-jacents qui déterminent le format réel de l'image.

Mécanisme sous-jacent de la sortie image de l'API Nano Banana 2

L'image de Nano Banana 2 (ID du modèle : gemini-3.1-flash-image-preview) est renvoyée via l'objet inlineData, avec la structure suivante :

{
  "candidates": [{
    "content": {
      "parts": [{
        "inlineData": {
          "mime_type": "image/png",
          "data": "<BASE64_IMAGE_DATA>"
        }
      }]
    }
  }]
}

Il existe ici un bug confirmé par Google (GitHub Issue #1824) : le champ mime_type dans la réponse est déclaré comme image/png, mais les données d'octets décodées peuvent être au format JPEG. Cela signifie que vous ne pouvez pas simplement faire confiance au type MIME renvoyé par l'API ; vous devez déterminer le format réel via les "magic bytes" (en-tête de fichier).

La méthode de détection est simple : l'en-tête d'un fichier JPEG est \xff\xd8, et celui d'un PNG est \x89PNG\r\n\x1a\n.

3 méthodes pour obtenir des images au format PNG avec l'API Nano Banana 2

Voici le cœur du sujet : comment vous assurer de récupérer vos images au format PNG.

Méthode 1 : Conversion côté client en Python (Recommandé pour AI Studio)

Comme l'API Gemini d'AI Studio ne prend pas en charge le contrôle du format côté serveur, la méthode la plus fiable consiste à effectuer la conversion côté client :

import base64
from PIL import Image
from io import BytesIO

# Appel de Nano Banana 2 pour générer une image
from google import genai
from google.genai import types

client = genai.Client(api_key="VOTRE_CLE_API")

response = client.models.generate_content(
    model="gemini-3.1-flash-image-preview",
    contents=["Un chat roux qui fait la sieste au soleil"],
    config=types.GenerateContentConfig(
        response_modalities=["TEXT", "IMAGE"],
        image_config=types.ImageConfig(
            image_size="4K",
            aspect_ratio="1:1"
        ),
    )
)

# Enregistrement au format PNG (quel que soit le format renvoyé par l'API)
for part in response.parts:
    if image := part.as_image():
        image.save("output.png", format="PNG")  # Forcer l'enregistrement sans perte en PNG

Le point clé est de spécifier explicitement format="PNG" dans image.save("output.png", format="PNG"). Si vous ne précisez pas le paramètre format, Pillow le déduira de l'extension du fichier — ce qui fonctionne généralement, mais une déclaration explicite est plus sûre.

import base64
from PIL import Image
from io import BytesIO

def detect_and_save(base64_data: str, output_path: str, target_format: str = "PNG"):
    """
    Détecte le format réel d'une image base64 et la convertit pour l'enregistrer

    Args:
        base64_data: données d'image encodées en base64
        output_path: chemin du fichier de sortie
        target_format: format cible (PNG/JPEG/WEBP)
    """
    image_bytes = base64.b64decode(base64_data)

    # Détection du format réel via les magic bytes
    if image_bytes[:2] == b'\xff\xd8':
        actual_format = "JPEG"
    elif image_bytes[:8] == b'\x89PNG\r\n\x1a\n':
        actual_format = "PNG"
    elif image_bytes[:4] == b'RIFF':
        actual_format = "WEBP"
    else:
        actual_format = "Inconnu"

    print(f"Format réel renvoyé par l'API : {actual_format}")
    print(f"Taille des données brutes : {len(image_bytes) / 1024 / 1024:.2f} Mo")

    # Ouverture avec Pillow et conversion vers le format cible
    img = Image.open(BytesIO(image_bytes))
    print(f"Dimensions de l'image : {img.size[0]}x{img.size[1]}")

    if target_format == "PNG":
        img.save(output_path, format="PNG", optimize=True)
    elif target_format == "JPEG":
        img.save(output_path, format="JPEG", quality=95)
    elif target_format == "WEBP":
        img.save(output_path, format="WEBP", quality=90)

    import os
    saved_size = os.path.getsize(output_path) / 1024 / 1024
    print(f"Taille du fichier après sauvegarde : {saved_size:.2f} Mo ({target_format})")

Méthode 2 : Contrôle du format côté serveur avec Vertex AI

Si vous utilisez Vertex AI pour appeler Nano Banana 2, vous pouvez spécifier directement le format de sortie dans la requête. C'est la seule méthode qui prend en charge le contrôle du format côté serveur :

import os
from google import genai
from google.genai import types
from google.genai.types import HttpOptions

os.environ["GOOGLE_CLOUD_PROJECT"] = "votre-id-de-projet"
os.environ["GOOGLE_CLOUD_LOCATION"] = "global"
os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "True"

client = genai.Client(http_options=HttpOptions(api_version="v1"))

response = client.models.generate_content(
    model="gemini-3.1-flash-image-preview",
    contents=["Un chat roux qui fait la sieste au soleil"],
    config=types.GenerateContentConfig(
        response_modalities=["TEXT", "IMAGE"],
        image_config=types.ImageConfig(
            image_size="4K",
            aspect_ratio="1:1",
            output_mime_type="image/png",         # Spécifier la sortie PNG
            # compression_quality=75,             # Valide uniquement pour JPEG, 0-100
        ),
    )
)

Méthode 3 : Traitement unifié via le service proxy API APIYI

En passant par le service proxy API APIYI, la plateforme gère automatiquement les problèmes de compatibilité de format :

import openai

client = openai.OpenAI(
    api_key="VOTRE_CLE_API",
    base_url="https://vip.apiyi.com/v1"
)

response = client.chat.completions.create(
    model="gemini-3.1-flash-image-preview",
    messages=[
        {"role": "user", "content": "Un chat roux qui fait la sieste au soleil"}
    ]
)

🎯 Conseil sur le choix du format : Choisissez PNG pour une qualité sans perte, ou JPEG pour un volume réduit (une qualité de 95 est proche du sans perte).
Nous vous recommandons de tester via la plateforme APIYI apiyi.com, qui gère uniformément la compatibilité des formats, vous évitant ainsi les tracas du décodage base64 et de la détection de format manuelle.

Comparaison des capacités de contrôle de format de l'API Nano Banana 2

C'est un point qui prête souvent à confusion pour les développeurs : les capacités de contrôle de format diffèrent totalement entre AI Studio et Vertex AI.

Comparaison des paramètres de format de l'API Nano Banana 2

Cela signifie que si vous utilisez AI Studio pour appeler Nano Banana 2, vous ne pouvez pas contrôler côté serveur si la sortie est en PNG ou JPEG. Le format renvoyé par l'API dépend du comportement par défaut des serveurs Google — un comportement qui comporte actuellement un bug (il peut renvoyer du JPEG alors qu'il prétend fournir du PNG).

Comparaison du volume selon le format de l'API Nano Banana 2

Pour une même image générée par IA en 4K (4096×4096), les différences de volume sont énormes :

Le PNG est un format sans perte, la taille du fichier reflète directement la complexité des informations de l'image (valeur d'entropie). Plus l'image est détaillée et texturée, plus le fichier PNG sera volumineux. C'est une base essentielle pour comprendre les variations de volume des images 4K.

Astuce : Si votre scénario d'application ne nécessite pas de canal de transparence, le JPEG avec une qualité de 95 est visuellement presque indiscernable du PNG, mais son volume ne représente qu'un quart à un tiers de celui du PNG. Via la plateforme APIYI apiyi.com, vous pouvez rapidement comparer les différences de rendu entre les deux formats dans des scénarios réels.

La vérité sur la réduction de taille des images 4K de l'API Nano Banana 2

C'est la question qui préoccupe le plus les utilisateurs : pourquoi, à résolution 4K identique, les images Nano Banana 2 générées par AI Studio sont-elles passées de plus de 30 Mo à environ 8 Mo ?

Le changement de taille des images de l'API Nano Banana 2 n'est pas un problème de format

Éliminons d'abord une idée reçue : ce n'est pas une conversion de PNG vers JPEG qui explique cette réduction. Si vous vérifiez les magic bytes, vous constaterez que le format des données renvoyées n'a pas changé.

La véritable raison est que Google a ajusté les paramètres de calcul du modèle côté serveur, ce qui a réduit la complexité informationnelle (valeur d'entropie) des images générées. Trois mécanismes sont en cause :

Raison 1 : Réduction du nombre d'étapes d'inférence (cause principale)

Lorsqu'un modèle de diffusion génère une image, il passe par plusieurs cycles d'itération de débruitage. Le nombre d'étapes de débruitage détermine directement la richesse des détails de l'image :

• Avant : Utilisation probable de 50 à 100 étapes d'itération, produisant des images aux textures riches et aux détails fins.
• Maintenant : Réduction probable à 20-40 étapes ; l'image est globalement nette, mais les détails locaux et la complexité des textures sont en baisse.

Moins d'étapes de débruitage → moins de détails de texture → baisse de l'entropie de l'information → taille plus petite après compression PNG sans perte.

Ce n'est pas aussi simple qu'une "baisse de qualité" — à l'œil nu, la composition globale et les couleurs peuvent sembler similaires, mais en zoomant au niveau du pixel, on remarque que les micro-textures et les dégradés de couleurs sont moins fins qu'auparavant.

Raison 2 : Optimisation du prétraitement côté serveur

Après la génération et avant l'encodage en PNG, Google a probablement ajouté un léger traitement de débruitage et de simplification des couleurs :

• Une suppression subtile du bruit réduit les détails à haute fréquence.
• Une réduction des niveaux de dégradés de couleurs diminue la finesse des transitions chromatiques.
• Ces traitements rendent la compression PNG plus efficace (plus de pixels similaires, donc un meilleur taux de compression).

Raison 3 : Ajustement de la précision en virgule flottante

L'inférence du modèle est peut-être passée du FP32 (virgule flottante 32 bits) au FP16 (virgule flottante 16 bits) :

• La précision de calcul du FP16 est moitié moindre que celle du FP32, et la consommation GPU est également fortement réduite.
• Cette baisse de précision rend les dégradés de couleurs moins fluides, ce qui se traduit finalement par une réduction du poids du fichier PNG.

Chronologie de l'évolution de la taille des images de l'API Nano Banana 2

Conclusion clé : Il s'agit d'un compromis fait par Google pour équilibrer le nombre d'utilisateurs et la qualité de service pendant la période de pénurie de capacité TPU. La résolution (nombre de pixels) reste la même, mais la densité d'information (quantité d'informations uniques par pixel) a diminué. Les utilisateurs ne peuvent pas restaurer la qualité de 30 Mo via les paramètres de l'API.

🎯 Conseils pratiques : Si vous exigez une qualité de détail extrêmement élevée, vous pouvez essayer : 1) d'utiliser le paramètre compressionQuality=100 de Vertex AI ; 2) d'insister sur les exigences de détails et de textures dans votre invite ; 3) de générer en 2K puis d'utiliser un modèle de super-résolution pour passer au 4K.
Via APIYI (apiyi.com), vous pouvez tester simultanément les effets de différentes combinaisons de paramètres pour trouver le meilleur équilibre qualité-poids.

Foire aux questions

Résumé

Points clés pour le contrôle du format de sortie d'image avec l'API Nano Banana 2 :

1. AI Studio ne prend pas en charge le contrôle du format côté serveur : vous devez décoder le base64 côté client, puis utiliser Pillow pour enregistrer explicitement le fichier au format PNG, tout en vérifiant les "magic bytes" pour confirmer le format réel.
2. Vertex AI prend en charge outputMimeType : vous pouvez spécifier directement image/png ou image/jpeg dans la requête, ainsi que la qualité de compression JPEG.
3. La réduction de taille des images 4K est liée à un ajustement de la puissance de calcul : le passage de 30 Mo à 8 Mo n'est pas dû à un changement de format, mais à une réduction par Google du nombre d'étapes d'inférence et de la précision en virgule flottante, ce qui diminue l'entropie de l'information. Les utilisateurs ne peuvent pas restaurer la qualité via des paramètres.

En comprenant ces mécanismes sous-jacents, vous pourrez choisir la stratégie d'enregistrement la plus adaptée à vos besoins.

Nous vous recommandons d'utiliser APIYI (apiyi.com) pour tester rapidement les effets des différents formats et paramètres. La plateforme offre des crédits gratuits, une interface unifiée et prend en charge les multiples méthodes d'invocation du modèle Nano Banana 2.

📚 Références

1. Documentation de développement pour la génération d'images Gemini : Référence officielle de l'API, incluant les explications des paramètres ImageConfig.

   • Lien : ai.google.dev/gemini-api/docs/image-generation
   • Note : Pour comprendre les paramètres et les limitations lors d'un appel via AI Studio.

2. Référence Vertex AI ImageOutputOptions : Documentation complète des paramètres de contrôle de format pour Vertex AI.

   • Lien : docs.cloud.google.com/vertex-ai/generative-ai/docs/reference/rest/Shared.Types/ImageOutputOptions
   • Note : Contient des explications détaillées sur mimeType et compressionQuality.

3. GitHub Issue #1824 – Incohérence du type MIME : Rapport de bug concernant une API annonçant du PNG mais renvoyant du JPEG.

   • Lien : github.com/googleapis/python-genai/issues/1824
   • Note : Pour comprendre les détails techniques et les solutions de contournement de ce problème connu.

4. Centre de documentation APIYI : Guide de contrôle de format pour l'invocation de Nano Banana 2 via une interface unifiée.

   • Lien : docs.apiyi.com
   • Note : Idéal pour les développeurs souhaitant simplifier le processus de traitement des formats.

Auteur : Équipe technique APIYI
Échanges techniques : N'hésitez pas à discuter dans la section commentaires. Pour plus de ressources, consultez le centre de documentation APIYI sur docs.apiyi.com.