Update app.py

app.py

@@ -1,349 +1,380 @@
-#!/usr/bin/env python
-
 import os
+import random
+import uuid
+import json
+import time
+import asyncio
 import re
-import tempfile
-from collections.abc import Iterator
 from threading import Thread
 
-import cv2
 import gradio as gr
 import spaces
 import torch
-from loguru import logger
+import numpy as np
 from PIL import Image
-from transformers import AutoProcessor, Gemma3ForConditionalGeneration, TextIteratorStreamer
-
-model_id = os.getenv("MODEL_ID", "google/gemma-3-12b-it")
-processor = AutoProcessor.from_pretrained(model_id, padding_side="left")
-model = Gemma3ForConditionalGeneration.from_pretrained(
-    model_id, device_map="auto", torch_dtype=torch.bfloat16, attn_implementation="eager"
+import cv2
+import translators as ts
+
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    TextIteratorStreamer,
+    Qwen2VLForConditionalGeneration,
+    AutoProcessor,
 )
-
-MAX_NUM_IMAGES = int(os.getenv("MAX_NUM_IMAGES", "5"))
-
-
-def count_files_in_new_message(paths: list[str]) -> tuple[int, int]:
-    image_count = 0
-    video_count = 0
-    for path in paths:
-        if path.endswith(".mp4"):
-            video_count += 1
-        else:
-            image_count += 1
-    return image_count, video_count
-
-
-def count_files_in_history(history: list[dict]) -> tuple[int, int]:
-    image_count = 0
-    video_count = 0
-    for item in history:
-        if item["role"] != "user" or isinstance(item["content"], str):
-            continue
-        if item["content"][0].endswith(".mp4"):
-            video_count += 1
-        else:
-            image_count += 1
-    return image_count, video_count
-
-
-def validate_media_constraints(message: dict, history: list[dict]) -> bool:
-    new_image_count, new_video_count = count_files_in_new_message(message["files"])
-    history_image_count, history_video_count = count_files_in_history(history)
-    image_count = history_image_count + new_image_count
-    video_count = history_video_count + new_video_count
-    if video_count > 1:
-        gr.Warning("Only one video is supported.")
-        return False
-    if video_count == 1:
-        if image_count > 0:
-            gr.Warning("Mixing images and videos is not allowed.")
-            return False
-        if "<image>" in message["text"]:
-            gr.Warning("Using <image> tags with video files is not supported.")
-            return False
-        # TODO: Add frame count validation for videos similar to image count limits  # noqa: FIX002, TD002, TD003
-    if video_count == 0 and image_count > MAX_NUM_IMAGES:
-        gr.Warning(f"You can upload up to {MAX_NUM_IMAGES} images.")
-        return False
-    if "<image>" in message["text"] and message["text"].count("<image>") != new_image_count:
-        gr.Warning("The number of <image> tags in the text does not match the number of images.")
-        return False
-    return True
-
-
-def downsample_video(video_path: str) -> list[tuple[Image.Image, float]]:
+from transformers.image_utils import load_image
+
+# Constants
+MAX_MAX_NEW_TOKENS = 2048
+DEFAULT_MAX_NEW_TOKENS = 1024
+MAX_INPUT_TOKEN_LENGTH = int(os.getenv("MAX_INPUT_TOKEN_LENGTH", "4096"))
+MAX_SEED = np.iinfo(np.int32).max
+
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+# Helper function to return a progress bar HTML snippet.
+def progress_bar_html(label: str) -> str:
+    return f'''
+<div style="display: flex; align-items: center;">
+    <span style="margin-right: 10px; font-size: 14px;">{label}</span>
+    <div style="width: 110px; height: 5px; background-color: #F0FFF0; border-radius: 2px; overflow: hidden;">
+        <div style="width: 100%; height: 100%; background-color: #00FF00 ; animation: loading 1.5s linear infinite;"></div>
+    </div>
+</div>
+<style>
+@keyframes loading {{
+    0% {{ transform: translateX(-100%); }}
+    100% {{ transform: translateX(100%); }}
+}}
+</style>
+    '''
+
+# TEXT MODEL - Utiliser Napoleon 4B au lieu de FastThink
+model_id = "baconnier/Napoleon_4B_V0.0" 
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+model = AutoModelForCausalLM.from_pretrained(
+    model_id,
+    device_map="auto",
+    torch_dtype=torch.bfloat16,
+)
+model.eval()
+
+# MULTIMODAL (OCR) MODELS - Garder Qwen2-VL pour OCR
+MODEL_ID_VL = "prithivMLmods/Qwen2-VL-OCR-2B-Instruct" 
+processor = AutoProcessor.from_pretrained(MODEL_ID_VL, trust_remote_code=True)
+model_m = Qwen2VLForConditionalGeneration.from_pretrained(
+    MODEL_ID_VL,
+    trust_remote_code=True,
+    torch_dtype=torch.float16
+).to("cuda").eval()
+
+def clean_chat_history(chat_history):
+    cleaned = []
+    for msg in chat_history:
+        if isinstance(msg, dict) and isinstance(msg.get("content"), str):
+            cleaned.append(msg)
+    return cleaned
+
+bad_words = json.loads(os.getenv('BAD_WORDS', "[]"))
+bad_words_negative = json.loads(os.getenv('BAD_WORDS_NEGATIVE', "[]"))
+default_negative = os.getenv("default_negative", "")
+
+def check_text(prompt, negative=""):
+    for i in bad_words:
+        if i in prompt:
+            return True
+    for i in bad_words_negative:
+        if i in negative:
+            return True
+    return False
+
+def randomize_seed_fn(seed: int, randomize_seed: bool) -> int:
+    if randomize_seed:
+        seed = random.randint(0, MAX_SEED)
+    return seed
+
+CACHE_EXAMPLES = torch.cuda.is_available() and os.getenv("CACHE_EXAMPLES", "0") == "1"
+MAX_IMAGE_SIZE = int(os.getenv("MAX_IMAGE_SIZE", "2048"))
+USE_TORCH_COMPILE = os.getenv("USE_TORCH_COMPILE", "0") == "1"
+ENABLE_CPU_OFFLOAD = os.getenv("ENABLE_CPU_OFFLOAD", "0") == "1"
+
+dtype = torch.float16 if device.type == "cuda" else torch.float32
+
+# NAPOLEON 4B MULTIMODAL MODEL - Remplacer Gemma3 par Napoleon
+napoleon_model_id = "baconnier/Napoleon_4B_V0.0"
+napoleon_model = AutoModelForCausalLM.from_pretrained(
+    napoleon_model_id, device_map="auto", torch_dtype=torch.bfloat16
+).eval()
+napoleon_processor = AutoProcessor.from_pretrained(napoleon_model_id)
+
+# Fonction de traduction
+def translate_text(text, target_lang="fr", source_lang="auto"):
+    try:
+        return ts.deepl(text, from_language=source_lang, to_language=target_lang)
+    except:
+        try:
+            return ts.google(text, from_language=source_lang, to_language=target_lang)
+        except:
+            return text  # Retourner le texte original en cas d'échec
+
+# VIDEO PROCESSING HELPER
+def downsample_video(video_path):
     vidcap = cv2.VideoCapture(video_path)
-    fps = vidcap.get(cv2.CAP_PROP_FPS)
     total_frames = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))
-
-    frame_interval = int(fps / 3)
+    fps = vidcap.get(cv2.CAP_PROP_FPS)
     frames = []
-
-    for i in range(0, total_frames, frame_interval):
+    # Sample 10 evenly spaced frames.
+    frame_indices = np.linspace(0, total_frames - 1, 10, dtype=int)
+    for i in frame_indices:
         vidcap.set(cv2.CAP_PROP_POS_FRAMES, i)
         success, image = vidcap.read()
         if success:
+            # Convert from BGR to RGB and then to PIL Image.
             image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
             pil_image = Image.fromarray(image)
             timestamp = round(i / fps, 2)
             frames.append((pil_image, timestamp))
-
     vidcap.release()
     return frames
 
-
-def process_video(video_path: str) -> list[dict]:
-    content = []
-    frames = downsample_video(video_path)
-    for frame in frames:
-        pil_image, timestamp = frame
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as temp_file:
-            pil_image.save(temp_file.name)
-            content.append({"type": "text", "text": f"Frame {timestamp}:"})
-            content.append({"type": "image", "url": temp_file.name})
-    logger.debug(f"{content=}")
-    return content
-
-
-def process_interleaved_images(message: dict) -> list[dict]:
-    logger.debug(f"{message['files']=}")
-    parts = re.split(r"(<image>)", message["text"])
-    logger.debug(f"{parts=}")
-
-    content = []
-    image_index = 0
-    for part in parts:
-        logger.debug(f"{part=}")
-        if part == "<image>":
-            content.append({"type": "image", "url": message["files"][image_index]})
-            logger.debug(f"file: {message['files'][image_index]}")
-            image_index += 1
-        elif part.strip():
-            content.append({"type": "text", "text": part.strip()})
-        elif isinstance(part, str) and part != "<image>":
-            content.append({"type": "text", "text": part})
-    logger.debug(f"{content=}")
-    return content
-
-
-def process_new_user_message(message: dict) -> list[dict]:
-    if not message["files"]:
-        return [{"type": "text", "text": message["text"]}]
-
-    if message["files"][0].endswith(".mp4"):
-        return [{"type": "text", "text": message["text"]}, *process_video(message["files"][0])]
-
-    if "<image>" in message["text"]:
-        return process_interleaved_images(message)
-
-    return [
-        {"type": "text", "text": message["text"]},
-        *[{"type": "image", "url": path} for path in message["files"]],
-    ]
-
-
-def process_history(history: list[dict]) -> list[dict]:
-    messages = []
-    current_user_content: list[dict] = []
-    for item in history:
-        if item["role"] == "assistant":
-            if current_user_content:
-                messages.append({"role": "user", "content": current_user_content})
-                current_user_content = []
-            messages.append({"role": "assistant", "content": [{"type": "text", "text": item["content"]}]})
+# MAIN GENERATION FUNCTION
+@spaces.GPU
+def generate(
+    input_dict: dict,
+    chat_history: list[dict],
+    max_new_tokens: int = DEFAULT_MAX_NEW_TOKENS,
+    temperature: float = 0.6,
+    top_p: float = 0.9,
+    top_k: int = 50,
+    repetition_penalty: float = 1.2,
+):
+    text = input_dict["text"]
+    files = input_dict.get("files", [])
+
+    lower_text = text.lower().strip()
+
+    # NAPOLEON 4B TEXT & MULTIMODAL (image) Branch
+    if lower_text.startswith("@napoleon"):
+        # Remove the napoleon flag from the prompt.
+        prompt_clean = re.sub(r"@napoleon", "", text, flags=re.IGNORECASE).strip().strip('"')
+        
+        # Traduire en français si le texte n'est pas déjà en français
+        prompt_clean_fr = translate_text(prompt_clean, target_lang="fr")
+        
+        if files:
+            # If image files are provided, load them.
+            images = [load_image(f) for f in files]
+            messages = [{
+                "role": "user",
+                "content": [
+                    *[{"type": "image", "image": image} for image in images],
+                    {"type": "text", "text": prompt_clean_fr},
+                ]
+            }]
         else:
-            content = item["content"]
-            if isinstance(content, str):
-                current_user_content.append({"type": "text", "text": content})
-            else:
-                current_user_content.append({"type": "image", "url": content[0]})
-    return messages
-
-
-@spaces.GPU(duration=120)
-def run(message: dict, history: list[dict], system_prompt: str = "", max_new_tokens: int = 512) -> Iterator[str]:
-    if not validate_media_constraints(message, history):
-        yield ""
+            messages = [
+                {"role": "system", "content": [{"type": "text", "text": "Vous êtes un assistant utile qui parle français."}]},
+                {"role": "user", "content": [{"type": "text", "text": prompt_clean_fr}]}
+            ]
+        
+        inputs = napoleon_processor.apply_chat_template(
+            messages, add_generation_prompt=True, tokenize=True,
+            return_dict=True, return_tensors="pt"
+        ).to(napoleon_model.device, dtype=torch.bfloat16)
+        
+        streamer = TextIteratorStreamer(
+            napoleon_processor.tokenizer, timeout=20.0, skip_prompt=True, skip_special_tokens=True
+        )
+        
+        generation_kwargs = {
+            **inputs,
+            "streamer": streamer,
+            "max_new_tokens": max_new_tokens,
+            "do_sample": True,
+            "temperature": temperature,
+            "top_p": top_p,
+            "top_k": top_k,
+            "repetition_penalty": repetition_penalty,
+        }
+        
+        thread = Thread(target=napoleon_model.generate, kwargs=generation_kwargs)
+        thread.start()
+        
+        buffer = ""
+        yield progress_bar_html("Traitement avec Napoleon 4B")
+        for new_text in streamer:
+            buffer += new_text
+            time.sleep(0.01)
+            yield buffer
         return
 
-    messages = []
-    if system_prompt:
-        messages.append({"role": "system", "content": [{"type": "text", "text": system_prompt}]})
-    messages.extend(process_history(history))
-    messages.append({"role": "user", "content": process_new_user_message(message)})
-
-    inputs = processor.apply_chat_template(
-        messages,
-        add_generation_prompt=True,
-        tokenize=True,
-        return_dict=True,
-        return_tensors="pt",
-    ).to(device=model.device, dtype=torch.bfloat16)
-
-    streamer = TextIteratorStreamer(processor, timeout=30.0, skip_prompt=True, skip_special_tokens=True)
-    generate_kwargs = dict(
-        inputs,
-        streamer=streamer,
-        max_new_tokens=max_new_tokens,
-    )
-    t = Thread(target=model.generate, kwargs=generate_kwargs)
-    t.start()
-
-    output = ""
-    for delta in streamer:
-        output += delta
-        yield output
-
-
-examples = [
-    [
-        {
-            "text": "I need to be in Japan for 10 days, going to Tokyo, Kyoto and Osaka. Think about number of attractions in each of them and allocate number of days to each city. Make public transport recommendations.",
-            "files": [],
-        }
-    ],
-    [
-        {
-            "text": "Write the matplotlib code to generate the same bar chart.",
-            "files": ["assets/additional-examples/barchart.png"],
-        }
-    ],
-    [
-        {
-            "text": "What is odd about this video?",
-            "files": ["assets/additional-examples/tmp.mp4"],
-        }
-    ],
-    [
-        {
-            "text": "I already have this supplement <image> and I want to buy this one <image>. Any warnings I should know about?",
-            "files": ["assets/additional-examples/pill1.png", "assets/additional-examples/pill2.png"],
-        }
-    ],
-    [
-        {
-            "text": "Write a poem inspired by the visual elements of the images.",
-            "files": ["assets/sample-images/06-1.png", "assets/sample-images/06-2.png"],
-        }
-    ],
-    [
-        {
-            "text": "Compose a short musical piece inspired by the visual elements of the images.",
-            "files": [
-                "assets/sample-images/07-1.png",
-                "assets/sample-images/07-2.png",
-                "assets/sample-images/07-3.png",
-                "assets/sample-images/07-4.png",
-            ],
-        }
-    ],
-    [
-        {
-            "text": "Write a short story about what might have happened in this house.",
-            "files": ["assets/sample-images/08.png"],
-        }
-    ],
-    [
-        {
-            "text": "Create a short story based on the sequence of images.",
-            "files": [
-                "assets/sample-images/09-1.png",
-                "assets/sample-images/09-2.png",
-                "assets/sample-images/09-3.png",
-                "assets/sample-images/09-4.png",
-                "assets/sample-images/09-5.png",
-            ],
-        }
-    ],
-    [
-        {
-            "text": "Describe the creatures that would live in this world.",
-            "files": ["assets/sample-images/10.png"],
-        }
-    ],
-    [
-        {
-            "text": "Read text in the image.",
-            "files": ["assets/additional-examples/1.png"],
-        }
-    ],
-    [
-        {
-            "text": "When is this ticket dated and how much did it cost?",
-            "files": ["assets/additional-examples/2.png"],
-        }
-    ],
-    [
-        {
-            "text": "Read the text in the image into markdown.",
-            "files": ["assets/additional-examples/3.png"],
-        }
-    ],
-    [
-        {
-            "text": "Evaluate this integral.",
-            "files": ["assets/additional-examples/4.png"],
-        }
-    ],
-    [
-        {
-            "text": "caption this image",
-            "files": ["assets/sample-images/01.png"],
-        }
-    ],
-    [
-        {
-            "text": "What's the sign says?",
-            "files": ["assets/sample-images/02.png"],
-        }
-    ],
-    [
-        {
-            "text": "Compare and contrast the two images.",
-            "files": ["assets/sample-images/03.png"],
-        }
-    ],
-    [
-        {
-            "text": "List all the objects in the image and their colors.",
-            "files": ["assets/sample-images/04.png"],
+    # NAPOLEON 4B VIDEO Branch
+    if lower_text.startswith("@video"):
+        # Remove the video flag from the prompt.
+        prompt_clean = re.sub(r"@video", "", text, flags=re.IGNORECASE).strip().strip('"')
+        
+        # Traduire en français si le texte n'est pas déjà en français
+        prompt_clean_fr = translate_text(prompt_clean, target_lang="fr")
+        
+        if files:
+            # Assume the first file is a video.
+            video_path = files[0]
+            frames = downsample_video(video_path)
+            
+            messages = [
+                {"role": "system", "content": [{"type": "text", "text": "Vous êtes un assistant utile qui parle français."}]},
+                {"role": "user", "content": [{"type": "text", "text": prompt_clean_fr}]}
+            ]
+            
+            # Append each frame as an image with a timestamp label.
+            for frame in frames:
+                image, timestamp = frame
+                image_path = f"video_frame_{uuid.uuid4().hex}.png"
+                image.save(image_path)
+                messages[1]["content"].append({"type": "text", "text": f"Image à {timestamp}s:"})
+                messages[1]["content"].append({"type": "image", "url": image_path})
+        else:
+            messages = [
+                {"role": "system", "content": [{"type": "text", "text": "Vous êtes un assistant utile qui parle français."}]},
+                {"role": "user", "content": [{"type": "text", "text": prompt_clean_fr}]}
+            ]
+            
+        inputs = napoleon_processor.apply_chat_template(
+            messages, add_generation_prompt=True, tokenize=True,
+            return_dict=True, return_tensors="pt"
+        ).to(napoleon_model.device, dtype=torch.bfloat16)
+        
+        streamer = TextIteratorStreamer(
+            napoleon_processor.tokenizer, timeout=20.0, skip_prompt=True, skip_special_tokens=True
+        )
+        
+        generation_kwargs = {
+            **inputs,
+            "streamer": streamer,
+            "max_new_tokens": max_new_tokens,
+            "do_sample": True,
+            "temperature": temperature,
+            "top_p": top_p,
+            "top_k": top_k,
+            "repetition_penalty": repetition_penalty,
         }
-    ],
-    [
-        {
-            "text": "Describe the atmosphere of the scene.",
-            "files": ["assets/sample-images/05.png"],
+        
+        thread = Thread(target=napoleon_model.generate, kwargs=generation_kwargs)
+        thread.start()
+        
+        buffer = ""
+        yield progress_bar_html("Traitement vidéo avec Napoleon 4B")
+        for new_text in streamer:
+            buffer += new_text
+            time.sleep(0.01)
+            yield buffer
+        return
+
+    # Otherwise, handle text/chat generation.
+    conversation = clean_chat_history(chat_history)
+    conversation.append({"role": "user", "content": text})
+    
+    if files:
+        images = [load_image(image) for image in files] if len(files) > 1 else [load_image(files[0])]
+        messages = [{
+            "role": "user",
+            "content": [
+                *[{"type": "image", "image": image} for image in images],
+                {"type": "text", "text": text},
+            ]
+        }]
+        prompt = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+        inputs = processor(text=[prompt], images=images, return_tensors="pt", padding=True).to("cuda")
+        streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)
+        generation_kwargs = {**inputs, "streamer": streamer, "max_new_tokens": max_new_tokens}
+        thread = Thread(target=model_m.generate, kwargs=generation_kwargs)
+        thread.start()
+
+        buffer = ""
+        yield progress_bar_html("Traitement avec Qwen2VL OCR")
+        for new_text in streamer:
+            buffer += new_text
+            buffer = buffer.replace("<|im_end|>", "")
+            time.sleep(0.01)
+            yield buffer
+    else:
+        # Traduire le texte en français pour Napoleon
+        text_fr = translate_text(text, target_lang="fr")
+        conversation_fr = clean_chat_history(chat_history)
+        conversation_fr.append({"role": "user", "content": text_fr})
+        
+        input_ids = tokenizer.apply_chat_template(conversation_fr, add_generation_prompt=True, return_tensors="pt")
+        if input_ids.shape[1] > MAX_INPUT_TOKEN_LENGTH:
+            input_ids = input_ids[:, -MAX_INPUT_TOKEN_LENGTH:]
+            gr.Warning(f"Texte d'entrée tronqué car plus long que {MAX_INPUT_TOKEN_LENGTH} tokens.")
+        
+        input_ids = input_ids.to(model.device)
+        streamer = TextIteratorStreamer(tokenizer, timeout=20.0, skip_prompt=True, skip_special_tokens=True)
+        
+        generation_kwargs = {
+            "input_ids": input_ids,
+            "streamer": streamer,
+            "max_new_tokens": max_new_tokens,
+            "do_sample": True,
+            "top_p": top_p,
+            "top_k": top_k,
+            "temperature": temperature,
+            "num_beams": 1,
+            "repetition_penalty": repetition_penalty,
         }
-    ],
-]
+        
+        t = Thread(target=model.generate, kwargs=generation_kwargs)
+        t.start()
 
-DESCRIPTION = """\
-<img src='https://huggingface.co/spaces/huggingface-projects/gemma-3-12b-it/resolve/main/assets/logo.png' id='logo' />
+        outputs = []
+        for new_text in streamer:
+            outputs.append(new_text)
+            yield "".join(outputs)
 
-This is a demo of Gemma 3 12B it, a vision language model with outstanding performance on a wide range of tasks.
-You can upload images, interleaved images and videos. Note that video input only supports single-turn conversation and mp4 input.
-"""
+        final_response = "".join(outputs)
+        yield final_response
 
 demo = gr.ChatInterface(
-    fn=run,
-    type="messages",
-    chatbot=gr.Chatbot(type="messages", scale=1, allow_tags=["image"]),
-    textbox=gr.MultimodalTextbox(file_types=["image", ".mp4"], file_count="multiple", autofocus=True),
-    multimodal=True,
+    fn=generate,
     additional_inputs=[
-        gr.Textbox(label="System Prompt", value="You are a helpful assistant."),
-        gr.Slider(label="Max New Tokens", minimum=100, maximum=2000, step=10, value=700),
+        gr.Slider(label="Nombre maximum de tokens", minimum=1, maximum=MAX_MAX_NEW_TOKENS, step=1, value=DEFAULT_MAX_NEW_TOKENS),
+        gr.Slider(label="Température", minimum=0.1, maximum=4.0, step=0.1, value=0.6),
+        gr.Slider(label="Top-p (échantillonnage nucleus)", minimum=0.05, maximum=1.0, step=0.05, value=0.9),
+        gr.Slider(label="Top-k", minimum=1, maximum=1000, step=1, value=50),
+        gr.Slider(label="Pénalité de répétition", minimum=1.0, maximum=2.0, step=0.05, value=1.2),
+    ],
+    examples=[
+        [
+            {
+                "text": "@napoleon Créez une histoire courte basée sur les images.",
+                "files": [
+                    "examples/1111.jpg",
+                    "examples/2222.jpg",
+                    "examples/3333.jpg",
+                ],
+            }
+        ],
+        [{"text": "@napoleon Expliquez cette image", "files": ["examples/3.jpg"]}],
+        [{"text": "@video Expliquez le contenu de cette publicité", "files": ["examples/videoplayback.mp4"]}],
+        [{"text": "@napoleon Quel personnage de film est-ce?", "files": ["examples/9999.jpg"]}],
+        ["@napoleon Expliquez la température critique d'une substance"],
+        [{"text": "@napoleon Transcription de cette lettre", "files": ["examples/222.png"]}],
+        [{"text": "@video Expliquez le contenu de la vidéo en détail", "files": ["examples/breakfast.mp4"]}],
+        [{"text": "@video Décrivez la vidéo", "files": ["examples/Missing.mp4"]}],
+        [{"text": "@video Expliquez ce qui se passe dans cette vidéo", "files": ["examples/oreo.mp4"]}],
+        [{"text": "@video Résumez les événements de cette vidéo", "files": ["examples/sky.mp4"]}],
+        [{"text": "@video Qu'y a-t-il dans cette vidéo?", "files": ["examples/redlight.mp4"]}],
+        ["Programme Python pour la rotation de tableau"],
+        ["@napoleon Expliquez la température critique d'une substance"]
     ],
-    stop_btn=False,
-    title="Gemma 3 12B IT",
-    description=DESCRIPTION,
-    examples=examples,
-    run_examples_on_click=False,
     cache_examples=False,
-    css_paths="style.css",
-    delete_cache=(1800, 1800),
+    type="messages",
+    description="# **Napoleon 4B `@napoleon pour le multimodal, @video pour la compréhension vidéo`**",
+    fill_height=True,
+    textbox=gr.MultimodalTextbox(label="Saisir votre question", file_types=["image", "video"], file_count="multiple", placeholder="Utilisez @napoleon pour le multimodal, @video pour l'analyse vidéo !"),
+    stop_btn="Arrêter la génération",
+    multimodal=True,
 )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.queue(max_size=20).launch(share=True)