Guide complet de Nano Banana 2 Lite et Gemini Omni Flash : pipelines média en Python

Qu’est-ce que Nano Banana 2 Lite ?

Nano Banana 2 Lite (gemini-3.1-flash-lite-image) est, à ce jour, le modèle de génération d’images le plus rapide et le plus économique de Google. 

Conçu spécifiquement pour des pipelines développeurs à haut débit et des applications à fort trafic, il est optimisé pour les scénarios où la faible latence et des budgets opérationnels serrés sont des contraintes majeures.

Pour les plateformes utilisant encore l’ancien modèle de Google (gemini-2.5-flash-image), Nano Banana 2 Lite peut le remplacer directement, avec des gains immédiats en vitesse, coût et fidélité visuelle.

Indicateurs de performance clés

• Latence ultra-faible : fournit des images à partir de texte en environ 4 secondes, idéal pour le prototypage interactif et les applications temps quasi réel.
• Efficacité coût : proposé à 0,034 $ par image en résolution 1K, il abaisse nettement le coût des générations en volume.
• Qualité préservée : malgré l’accent mis sur la vitesse, le modèle respecte bien les prompts, gère la cohérence des personnages et génère un texte lisible dans l’image.

Qu’est-ce que Gemini Omni Flash ?

Gemini Omni Flash (gemini-omni-flash-preview) est le modèle économique de Google pour la génération de vidéos et le montage vidéo conversationnel.

Contrairement aux générateurs vidéo autonomes s’appuyant strictement sur des prompts textuels statiques, Omni Flash intègre le raisonnement multimodal de Gemini au cœur de la création vidéo. 

Il accepte nativement des combinaisons de textes, d’images et de vidéos, pour un contrôle programmatique de la génération vidéo avec une précision inédite.

Capacités essentielles et tarification d’Omni Flash

• Tarification compétitive : 0,10 $ par seconde de vidéo générée, au même tarif que Veo 3.1 Fast.
• Montage vidéo conversationnel : au lieu de régénérer une vidéo pour de légères retouches, les applications peuvent utiliser des instructions en langue naturelle pour affiner une séquence existante.
• Référencement multimodal : les prompts textuels peuvent être combinés à des images ou clips de référence pour garantir la cohérence visuelle et un contrôle fin des éléments de scène.
• Ancrage dans le réel : en s’appuyant sur les connaissances fondamentales de Gemini, le modèle génère des animations réalistes fondées sur la logique et la physique.
• Synchronisation texte et actions : le texte à l’écran et les incrustations graphiques peuvent être liés directement aux actions vidéo via un simple prompt.

Comment générer et configurer une clé d’API Gemini

Avant d’utiliser l’API Gemini, nous devons créer et configurer une clé d’API afin que notre code puisse communiquer avec l’API.

La méthode la plus simple est la suivante :

• Rendez-vous sur la page des clés d’API de Google AI Studio et connectez-vous.
• Cliquez sur le bouton « Create API key » en haut à droite.
• Copiez la clé d’API dans un fichier nommé .env dans le même dossier que votre code Python, au format suivant :

GEMINI_API_KEY=replace_with_api_keyPropulsé par

Remarque : l’utilisation de l’API génère des coûts. Pour l’utiliser, assurez-vous d’avoir configuré un moyen de paiement sur la page de facturation de Google AI Studio.

Comment générer des images avec Nano Banana 2 Lite en Python

Prérequis pour la génération d’images IA en Python

Avant d’écrire notre générateur d’images IA en Python, assurez-vous de disposer des outils suivants :

• Python 3.9+ est installé sur votre système.
• Clé d’API Google Gemini : une clé d’API Google Gemini valide pour authentifier les requêtes. Suivez les étapes ci-dessus pour la créer et la configurer.
• Bibliothèques Python requises : nous utiliserons le SDK officiel google-genai pour l’intégration API et Pillow pour la gestion de la sortie image.

Installez les paquets nécessaires avec pip :

pip install google-genai pillow python-dotenvPropulsé par

Étape 1 : importer les modules et charger les variables d’environnement

Créez un nouveau fichier (par ex. : generate_image.py) et ajoutez les imports suivants ainsi que le chargement de l’environnement :

import io
from dotenv import load_dotenv
from google.genai import types
from PIL import Image
from google.genai import Client

# Load environment variables from the .env file
load_dotenv()Propulsé par

Étape 2 : initialiser le client Google GenAI

Pour interagir avec le modèle Nano Banana 2 Lite, nous devons d’abord initialiser le client Google GenAI. 

Le SDK vérifie automatiquement la variable d’environnement GEMINI_API_KEY (chargée depuis le fichier .env à l’étape précédente), nous pouvons donc initialiser le client sans passer explicitement la clé dans le code.

# Initialize the Gemini API client
client = Client()Propulsé par

Étape 3 : écrire la fonction de génération d’images IA

Voici maintenant le cœur de notre script Python. Nous allons écrire une fonction dédiée, generate_image(), qui prend en entrée le client initialisé et un prompt texte.

Nano Banana 2 Lite est appelé en spécifiant model="gemini-3.1-flash-lite-image". Nous configurons la requête API pour attendre une modalité image et définissons le ratio d’aspect souhaité pour la génération IA.

def generate_image(client, prompt: str, ratio: str = "1:1") -> Image.Image | None:
    """
    Generates an AI image using the Nano Banana 2 Lite model via the Gemini API.
    """
    print(f"Generating AI image for prompt: '{prompt}'...")
    
    # 1. Call the Nano Banana 2 Lite model
    response = client.models.generate_content(
        model="gemini-3.1-flash-lite-image",
        contents=prompt,
        config=types.GenerateContentConfig(
            response_modalities=[types.Modality.IMAGE],
            image_config=types.ImageConfig(aspect_ratio=ratio),
        ),
    )
    
    # 2. Extract and convert the generated image data
    if response and response.candidates:
        for part in response.candidates[0].content.parts:
            if part.inline_data:
                # Load the bytes into a PIL Image and convert to RGB
                image = Image.open(io.BytesIO(part.inline_data.data)).convert("RGB")
                return image
                
    return NonePropulsé par

Comprendre la requête Python de génération d’image :

• response_modalities : force le modèle Google Gemini à retourner une image plutôt que du texte.
• inline_data : l’API Gemini renvoie l’image générée sous forme d’octets bruts. Nous utilisons io.BytesIO pour les encapsuler afin que Pillow (Image.open) puisse les lire comme un fichier image standard.
• image_config : nous définissons aspect_ratio à « 1:1 » (carré), mais vous pouvez l’adapter selon votre cas d’usage.

Ratios d’aspect pris en charge :

Étape 4 : exécuter le script de génération d’images Python

Assemblons le tout et demandons à Nano Banana 2 Lite de générer une image ! 

Nous allons le solliciter avec un prompt créatif, appeler la fonction show() sur l’image obtenue pour l’afficher, puis fermer le client pour libérer les ressources.

if __name__ == "__main__":
    # Define our creative prompt for the AI model
    my_prompt = "A futuristic city skyline at sunset, cyberpunk style, highly detailed"
    
    # Generate the AI image
    result_image = generate_image(client, my_prompt)
    
    # Display the resulting image
    if result_image:
        print("AI Image generated successfully!")
        result_image.show()
    else:
        print("Failed to generate AI image.")
        
    # Close the client to prevent shutdown exceptions
    client.close()Propulsé par

Voici l’image générée par Nano Banana 2 Flash :

Comme Google l’annonçait, le modèle n’a pris que quelques secondes pour générer l’image. À première vue, il paraît nettement plus rapide que tous les autres modèles que j’ai testés à ce jour.

Le script complet est disponible dans le fichier generate_image.py du dépôt de ce tutoriel.

Étendre le script à l’édition d’image

Écrivons une fonction edit_image() qui modifie une image. La seule différence dans la requête est de fournir l’image avec le prompt dans le paramètre contents sous forme de liste [image, prompt].

def edit_image(client, image: Image.Image, prompt: str, aspect_ratio: str = "1:1") -> Image.Image | None:
    """
    Edits an AI image using the Gemini 3.1 Flash Lite model via the Gemini API.
    """
    response = client.models.generate_content(
        model="gemini-3.1-flash-lite-image",
        contents=[image, prompt],
        config=types.GenerateContentConfig(
            response_modalities=[types.Modality.IMAGE],
            image_config=types.ImageConfig(aspect_ratio=aspect_ratio),
        ),
    )
    if response and response.candidates:
        for part in response.candidates[0].content.parts:
            if part.inline_data:
                return Image.open(io.BytesIO(part.inline_data.data)).convert("RGB")
    return NonePropulsé par

Tests de Nano Banana 2 Flash

Nous avons évalué les performances réelles du modèle via une série de tests ciblés. 

Ces évaluations mesurent la capacité du modèle à gérer des tâches visuelles complexes : rendu de texte lisible, respect d’un agencement spatial strict, et cohérence sur plusieurs itérations, afin de vérifier s’il tient sa promesse d’une génération fidèle à grande vitesse.

Test du rendu de texte lisible dans l’image

Test du contrôle spatial strict et respect de deux sujets

Test de prototypage rapide d’IU et précision de mise en page

Test des contrastes de matériaux complexes et de l’éclairage

Test de cohérence de personnage sur plusieurs tours

Honnêtement, je suis plutôt impressionné par les résultats pour un modèle aussi rapide. Dans le dernier exemple, le modèle a même réussi à conserver en partie la cohérence du texte du journal. 

D’après mon expérience, la cohérence est l’un des aspects les plus importants pour rendre un modèle de génération d’images vraiment utile.

Comment générer des vidéos avec Gemini Omni Flash en Python

Dans cette section, nous allons détailler la création d’un script Python pour générer des vidéos, en partant d’un simple prompt texte-vers-vidéo, puis en y intégrant des images de référence.

Contrairement à la génération d’images standard, la génération de vidéos avec Gemini Omni Flash se fait via l’API Interactions du SDK (client.interactions.create). Cet endpoint est conçu pour gérer des interactions riches, multi-tours et multimodales.

Comme les imports, la configuration des variables d’environnement et l’initialisation du client Google GenAI sont identiques à la section précédente, nous pouvons nous concentrer directement sur l’écriture des fonctions de génération vidéo.

Étape 1 : texte-vers-vidéo (prompt simple)

Pour générer une vidéo à partir d’un simple prompt texte, nous passons un bloc de texte unique à l’API Interactions. Voici une fonction Python simple pour cela :

def text_to_video(client, prompt: str, aspect_ratio: str = "16:9", duration: str = "5s"):
    """
    Generates a video from a text prompt using Gemini Omni Flash.
    """
    interaction = client.interactions.create(
        model="gemini-omni-flash-preview",
        input=[{"type": "text", "text": prompt}],
        response_format={
            "type": "video",
            "aspect_ratio": aspect_ratio,
            "duration": duration,
        },
    )
    return interactionPropulsé par

Nous pouvons appeler cette fonction et enregistrer les octets de la vidéo renvoyés dans un fichier comme suit :

if __name__ == "__main__":
    import base64

    # Define a creative video prompt
    text_prompt = """
    Generate a first person view of what daily life would look like in the year
    1000 at this location: 41.89030621184054, 12.492266126772481
    """

    # Call the video generator
    interaction = text_to_video(
        client=client,
        prompt=text_prompt,
        aspect_ratio="16:9",
        duration="5s"
    )

    # Extract and save the generated video file
    if interaction and hasattr(interaction, "output_video") and interaction.output_video:
        # Decode the base64-encoded video data returned by the API
        video_bytes = base64.b64decode(interaction.output_video.data)
        
        # Save the bytes locally as an MP4 file
        with open("videos/video.mp4", "wb") as f:
            f.write(video_bytes)
    else:
        print("Failed to generate video.")Propulsé par

Le prompt utilisé était :

Generate a first-person view of what daily life would look like in the year 1000 at this location: 41.89030621184054, 12.492266126772481Propulsé par

Cet emplacement correspond au Colisée de Rome. J’ai utilisé des coordonnées pour tester les connaissances du modèle sur le monde. Voici la vidéo générée :

En comparaison, voici ce que le modèle a généré lorsque j’ai remplacé l’an 1000 par 1980 :

Plutôt intéressant à mon avis. Consultez le fichier text_to_video.py pour voir le script complet.

Étape 2 : mettre en œuvre l’image-vers-vidéo

Pour animer une image statique ou simplement l’utiliser comme référence pour guider la génération vidéo, nous devons fournir à la fois l’image et un prompt texte au modèle.

Comme l’API Interactions attend des images encodées en base64, nous définissons d’abord une fonction utilitaire pour convertir des objets PIL Image en chaînes base64 :

import io
from PIL import Image
import base64

def _image_to_base64(img: Image.Image) -> str:
    """
    Converts a PIL Image object to a base64-encoded string.
    """
    buffered = io.BytesIO()
    img.save(buffered, format="PNG")
    return base64.b64encode(buffered.getvalue()).decode()Propulsé par

Nous pouvons maintenant écrire une fonction plus générique, generate_video(), qui gère à la fois les images en option et le prompt texte.

from google.genai import types

def generate_video(client, valid_images: list[Image.Image], animation_prompt: str, aspect_ratio: str):
    """
    Generates a commercial-quality AI video using Google's Gemini Omni Flash model.
    Supports image-to-video and text-to-video multimodal inputs using the Gemini API.
    """
    omni_inputs = []
    
    # 1. Base64 encode and append any input images
    for img in valid_images:
        img_b64 = _image_to_base64(img)
        omni_inputs.append({
            "type": "image",
            "data": img_b64,
            "mime_type": "image/png",
        })

    # 2. Append the text animation prompt
    omni_inputs.append({"type": "text", "text": animation_prompt})

    # 3. Request video generation from the interactions endpoint
    interaction = client.interactions.create(
        model="gemini-omni-flash-preview",
        input=omni_inputs,
        response_format={
            "type": "video",
            "aspect_ratio": aspect_ratio,
        },
    )
    return interactionPropulsé par

Enfin, voici comment utiliser ces fonctions pour générer une vidéo qui anime ce scarabée généré avec Gemini :

if __name__ == "__main__":
    # Load our reference image
    reference_image = Image.open("images/beetle.png").convert("RGB")

    # Describe how we want the image to be animated
    animation_prompt = """
    A detailed, close-up photograph of an iridescent biomechanical stag beetle, 
    shimmering with metallic green, blue, and violet hues, as it traverses a 
    rugged amethyst crystal formation in a subterranean grotto. 
    The cavern walls are lined with a dense matrix of glowing crystals emitting 
    deep purple, blue, and green light. The air is misty, with bioluminescent 
    flora clinging to the rock. As the camera maintains focus, the beetle 
    subtly activates a soft internal orange glow from its mandibles, begins 
    vibrating its wings, and slowly crawls upward across the crystalline 
    surface, reflecting the surrounding light.
    """

    # Call the generator with the reference image
    interaction = generate_video(
        client=client,
        valid_images=[reference_image],
        animation_prompt=animation_prompt,
        aspect_ratio="16:9"
    )

    # Extract and save the animated video
    if interaction and hasattr(interaction, "output_video") and interaction.output_video:
        video_bytes = base64.b64decode(interaction.output_video.data)
        with open("videos/video.mp4", "wb") as f:
            f.write(video_bytes)Propulsé par

Voici la vidéo générée :

Le script complet est disponible ici.

Étape 3 : mettre en œuvre l’édition vidéo avec vidéo-vers-vidéo

L’édition conversationnelle avec l’API Gemini Omni Flash est grandement facilitée par le mécanisme d’interactions. Quand nous générons une vidéo, nous obtenons un identifiant d’interaction accessible via interaction.id. 

Pour éditer une vidéo, nous fournissons un prompt et l’identifiant de l’interaction précédente. S’il s’agit de la première édition, on utilise l’identifiant de l’interaction de génération ; pour les suivantes, l’identifiant de l’édition précédente.

client.interactions.create(
        model="gemini-omni-flash-preview",
        input=edit_prompt,
        previous_interaction_id=previous_interaction_id,
)Propulsé par

Créer un studio vidéo IA interactif : architecture et synergie multi-modèles

Dans les sections précédentes, nous avons vu comment générer des images avec Nano Banana 2 Lite et des vidéos avec Gemini Omni Flash. Voyons maintenant comment réunir ces capacités dans une application web interactive et cohérente : un studio vidéo IA.

L’architecture du studio vidéo IA

Produire des vidéos IA de qualité suppose généralement beaucoup d’essais. Le studio vidéo IA répond à cela via un pipeline en deux étapes et multi-modèles, tirant parti des forces de deux modèles distincts :

• Création des ressources : avec Nano Banana 2 Lite, les utilisateurs génèrent rapidement des ressources et images de référence à combiner avec leurs images existantes.
• Génération vidéo : nous utilisons Gemini Omni Flash pour produire la vidéo à partir de ces assets.
• Montage vidéo : une fois la vidéo générée, nous pouvons l’éditer de manière conversationnelle.

Étape 1 : prototypage rapide avec Nano Banana 2 Lite

Dans la première étape, l’application permet de sélectionner des images de référence (images clés). Nous pouvons soit téléverser une image locale, soit en générer une à la volée. 

C’est là que Nano Banana 2 Lite excelle. 

Avec une latence inférieure à 4 secondes et un coût infime par image, il sert de bac à sable ultra-rapide. Nous pouvons prototyper en un rien de temps des dizaines de styles, compositions et sujets jusqu’à obtenir l’image clé idéale.

Étape 2 : génération multimodale avec Gemini Omni Flash

Une fois l’image de référence parfaite obtenue, nous passons à la production vidéo. 

L’image de référence et notre prompt d’animation (par ex. : mouvement de caméra, changements de lumière ou action) sont encodés en base64 et envoyés à Gemini Omni Flash via l’API Interactions du SDK. 

Gemini Omni Flash traite ces entrées et renvoie un clip vidéo haute fidélité au format paysage (16:9) ou vertical (9:16).

Voici la vidéo obtenue :

Implémentation de l’application de génération vidéo avec Streamlit

Pour l’interface, nous utilisons Streamlit, un framework Python open source très apprécié qui facilite la création d’applications web partageables pour le machine learning et la data science. 

Si vous débutez avec Streamlit ou souhaitez une piqûre de rappel, nous vous recommandons ce tutoriel Python Streamlit. 

Nous ne nous attarderons pas sur le code de l’UI Streamlit, mais sur l’architecture du pipeline de génération vidéo et les possibilités créatives offertes par la combinaison de ces deux modèles puissants.

Le script gemini_api.py contient les fonctions vues plus haut pour générer images et vidéos. L’interface utilisateur est développée avec Streamlit dans le script app.py.

Pour l’exécuter en local et expérimenter, procédez ainsi :

git clone [email protected]:fran-aubry/nano-banana-2-flash-tutorial.git
pip install -r requirement.txt
streamlit run app.pyPropulsé par

Voici un exemple de flux complet combinant une image existante d’une marque de thé imaginaire avec une image de plantation de thé générée, afin de créer un plan publicitaire pour cette boîte de thé. 

Nous éditons ensuite la vidéo à l’aide d’un prompt.

La vidéo a été accélérée au montage car la génération peut prendre quelques minutes.

Conclusion

Les promesses de vitesse avancées par Google pour son nouveau modèle Nano Banana 2 Lite sont tenues. 

Le modèle est incroyablement rapide et se rapproche d’une génération d’images quasi temps réel. Si les images produites sont de bonne qualité, elles ne sont pas révolutionnaires. L’innovation majeure du modèle réside clairement dans sa vitesse impressionnante plutôt que dans une avance spectaculaire en qualité d’image.

En duo, les modèles Gemini Omni Flash et Nano Banana 2 Lite forment un pipeline très puissant. Omni se distingue notamment par sa capacité à conserver la fidélité au matériel de référence.

Pour en savoir plus sur Nano Banana 2, consultez cet article : Nano Banana 2 : guide complet avec Python.

Pour approfondir la série Gemini Omni, je recommande Gemini Omni : un seul modèle pour le texte, l’image, l’audio et la vidéo.