Elysia Tools

Parcourez outils, exemples, explications visuelles et guides thématiques dans un espace clair.

Catégories populaires

Dossiers

Langue
ZHESPTRUFRDEEN

Elysia Tools

Navigation mobile

IA et apprentissage automatique

Exemples Gradio

Exemples de déploiement rapide de modèles d'apprentissage automatique utilisant Gradio pour créer des interfaces web interactives avec un code minimal

Exemples

Entrées de cette collection

Code sourcepythonSimple

Hello World de Base

Exemple d'introduction simple à l'interface Gradio

python
# Gradio Hello World Examples
# Quick start with basic Gradio interfaces

import gradio as gr
import time
import random

# 1. Basic Interface
def hello_world(name):
    return f"Hello, {name}! Welcome to Gradio."

# Create simple interface
iface = gr.Interface(
    fn=hello_world,
    inputs=gr.Textbox(label="Enter your name"),
    outputs=gr.Textbox(label="Greeting"),
    title="Hello World",
    description="Simple greeting interface"
)

# 2. Multiple Inputs and Outputs
def calculator(operation, num1, num2):
    """Basic calculator with multiple operations"""
    try:
        num1, num2 = float(num1), float(num2)

        if operation == "add":
            return f"Result: {num1 + num2}"
        elif operation == "subtract":
            return f"Result: {num1 - num2}"
        elif operation == "multiply":
            return f"Result: {num1 * num2}"
        elif operation == "divide":
            if num2 != 0:
                return f"Result: {num1 / num2}"
            else:
                return "Error: Cannot divide by zero"
        else:
            return "Error: Invalid operation"
    except ValueError:
        return "Error: Please enter valid numbers"

calculator_interface = gr.Interface(
    fn=calculator,
    inputs=[
        gr.Radio(
            choices=["add", "subtract", "multiply", "divide"],
            label="Operation",
            value="add"
        ),
        gr.Number(label="First Number"),
        gr.Number(label="Second Number")
    ],
    outputs=gr.Textbox(label="Result"),
    title="Simple Calculator",
    description="Perform basic arithmetic operations"
)

# 3. Image Processing Interface
def apply_filter(image, filter_type):
    """Apply basic filters to images"""
    if image is None:
        return None

    import cv2
    import numpy as np

    # Convert PIL to numpy array
    img_array = np.array(image)

    if filter_type == "grayscale":
        gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
        return cv2.cvtColor(gray, cv2.COLOR_GRAY2RGB)
    elif filter_type == "blur":
        return cv2.GaussianBlur(img_array, (15, 15), 0)
    elif filter_type == "edge detection":
        gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
        edges = cv2.Canny(gray, 100, 200)
        return cv2.cvtColor(edges, cv2.COLOR_GRAY2RGB)
    else:
        return img_array

image_interface = gr.Interface(
    fn=apply_filter,
    inputs=[
        gr.Image(label="Upload Image"),
        gr.Radio(
            choices=["none", "grayscale", "blur", "edge detection"],
            label="Filter Type",
            value="none"
        )
    ],
    outputs=gr.Image(label="Processed Image"),
    title="Basic Image Filter",
    description="Apply simple filters to your images"
)

# 4. Custom Function with Progress
def slow_function(text, progress=gr.Progress()):
    """Function that takes time with progress indication"""
    total_steps = 10
    result = ""

    for i in range(total_steps):
        time.sleep(0.1)  # Simulate work
        progress((i + 1) / total_steps, f"Processing step {i+1}/{total_steps}")
        result += f"Step {i+1}: Processing '{text}'\n"

    return result + "\nProcessing complete!"

progress_interface = gr.Interface(
    fn=slow_function,
    inputs=gr.Textbox(label="Text to Process"),
    outputs=gr.Textbox(label="Processing Result"),
    title="Progress Example",
    description="See progress tracking in action"
)

# 5. Using Blocks for More Complex Layouts
def create_blocks_demo():
    """Create a more complex interface using Blocks"""

    def process_data(name, age, country, accept_terms):
        if not accept_terms:
            return "Please accept the terms and conditions"

        return f"""
        Registration Successful!
        Name: {name}
        Age: {age}
        Country: {country}
        Timestamp: {time.strftime('%Y-%m-%d %H:%M:%S')}
        """

    with gr.Blocks(title="Complex Interface") as demo:
        gr.Markdown("# Registration Form")
        gr.Markdown("Fill out the form below to register:")

        with gr.Row():
            with gr.Column():
                name_input = gr.Textbox(label="Full Name", placeholder="Enter your name")
                age_input = gr.Number(label="Age", minimum=0, maximum=120)
            with gr.Column():
                country_input = gr.Dropdown(
                    choices=["USA", "UK", "Canada", "Australia", "Other"],
                    label="Country"
                )
                terms_checkbox = gr.Checkbox(label="I accept the terms and conditions")

        submit_btn = gr.Button("Submit", variant="primary")
        output_text = gr.Textbox(label="Result", interactive=False)

        submit_btn.click(
            process_data,
            inputs=[name_input, age_input, country_input, terms_checkbox],
            outputs=output_text
        )

    return demo

# 6. Examples Gallery
def text_sentiment(text):
    """Mock sentiment analysis"""
    positive_words = ["good", "great", "excellent", "amazing", "wonderful"]
    negative_words = ["bad", "terrible", "awful", "horrible", "worst"]

    text_lower = text.lower()
    positive_count = sum(1 for word in positive_words if word in text_lower)
    negative_count = sum(1 for word in negative_words if word in text_lower)

    if positive_count > negative_count:
        sentiment = "Positive 😊"
        score = min(0.9, 0.5 + (positive_count - negative_count) * 0.1)
    elif negative_count > positive_count:
        sentiment = "Negative 😔"
        score = max(0.1, 0.5 - (negative_count - positive_count) * 0.1)
    else:
        sentiment = "Neutral 😐"
        score = 0.5

    return {
        "sentiment": sentiment,
        "confidence": score
    }

sentiment_interface = gr.Interface(
    fn=text_sentiment,
    inputs=gr.Textbox(
        label="Enter text for sentiment analysis",
        placeholder="Type your text here...",
        lines=3
    ),
    outputs=gr.Label(label="Sentiment Analysis"),
    title="Sentiment Analysis Demo",
    description="Analyze the sentiment of your text",
    examples=[
        ["I love this product! It's absolutely amazing and works perfectly."],
        ["This is terrible. The worst experience I've ever had."],
        ["The weather is okay today, nothing special."],
        ["Great service, friendly staff, and excellent food quality!"]
    ]
)

if __name__ == "__main__":
    # Launch different interfaces
    print("Choose an interface to launch:")
    print("1. Hello World")
    print("2. Calculator")
    print("3. Image Filter")
    print("4. Progress Demo")
    print("5. Complex Form (Blocks)")
    print("6. Sentiment Analysis")

    choice = input("Enter choice (1-6): ")

    if choice == "1":
        iface.launch()
    elif choice == "2":
        calculator_interface.launch()
    elif choice == "3":
        image_interface.launch()
    elif choice == "4":
        progress_interface.launch()
    elif choice == "5":
        demo = create_blocks_demo()
        demo.launch()
    elif choice == "6":
        sentiment_interface.launch()
    else:
        print("Invalid choice. Launching Hello World...")
        iface.launch()
Code sourcepythonIntermédiaire

Interface de Classification d'Images

Créer une interface interactive pour les modèles de classification d'images

python
# Image Classification with Gradio
# Complete implementation with multiple model options

import gradio as gr
import torch
import torchvision.transforms as transforms
from PIL import Image
import numpy as np
import time
import json

# 1. Configuration and Model Setup
CLASS_LABELS = {
    'imagenet': {
        'airplane': 0, 'automobile': 1, 'bird': 2, 'cat': 3, 'deer': 4,
        'dog': 5, 'frog': 6, 'horse': 7, 'ship': 8, 'truck': 9
    },
    'custom': {
        'cat': '🐱', 'dog': '🐕', 'bird': '🐦', 'fish': '🐠', 'rabbit': '🐰',
        'hamster': '🐹', 'turtle': '🐢', 'butterfly': '🦋', 'spider': '🕷️', 'snake': '🐍'
    }
}

# 2. Image Preprocessing
def preprocess_image(image, target_size=(224, 224)):
    """Preprocess image for model input"""
    if image is None:
        return None

    # Define transforms
    transform = transforms.Compose([
        transforms.Resize(target_size),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406],
                           std=[0.229, 0.224, 0.225])
    ])

    # Convert PIL to RGB if necessary
    if image.mode != 'RGB':
        image = image.convert('RGB')

    # Apply transforms
    image_tensor = transform(image).unsqueeze(0)
    return image_tensor

# 3. Mock Model Class (Replace with actual model)
class MockImageClassifier:
    """Mock classifier for demonstration"""

    def __init__(self, model_type='custom'):
        self.model_type = model_type
        self.labels = CLASS_LABELS[model_type]

    def predict(self, image_tensor):
        """Mock prediction - replace with actual model inference"""
        time.sleep(0.5)  # Simulate processing time

        # Generate random predictions
        num_classes = len(self.labels)
        scores = np.random.dirichlet(np.ones(num_classes))

        # Create prediction dictionary
        predictions = {}
        for i, (label, _) in enumerate(self.labels.items()):
            predictions[label] = float(scores[i])

        return predictions

# 4. Classification Functions
def classify_image(image, model_type, confidence_threshold=0.1):
    """Main classification function"""
    if image is None:
        return "Please upload an image", None

    try:
        # Initialize model
        model = MockImageClassifier(model_type)

        # Preprocess image
        image_tensor = preprocess_image(image)
        if image_tensor is None:
            return "Error processing image", None

        # Get predictions
        predictions = model.predict(image_tensor)

        # Filter by confidence threshold
        filtered_predictions = {
            k: v for k, v in predictions.items()
            if v >= confidence_threshold
        }

        # Sort by confidence
        sorted_predictions = dict(
            sorted(filtered_predictions.items(), key=lambda x: x[1], reverse=True)
        )

        # Format results
        if not sorted_predictions:
            return "No confident predictions found", None

        # Create result message
        top_prediction = list(sorted_predictions.items())[0]
        result_message = f"Top prediction: {top_prediction[0]} ({top_prediction[1]:.2%} confidence)"

        # Add emojis for custom model
        if model_type == 'custom':
            top_3 = list(sorted_predictions.items())[:3]
            emoji_results = []
            for label, confidence in top_3:
                emoji = CLASS_LABELS['custom'].get(label, '🔍')
                emoji_results.append(f"{emoji} {label}: {confidence:.1%}")
            result_message += "\n\nTop 3:\n" + "\n".join(emoji_results)

        return result_message, sorted_predictions

    except Exception as e:
        return f"Error during classification: {str(e)}", None

def batch_classify(images, model_type):
    """Batch classification for multiple images"""
    if not images:
        return "No images provided", []

    results = []
    for i, image in enumerate(images):
        if image is not None:
            _, predictions = classify_image(image, model_type)
            results.append({
                'image_index': i + 1,
                'predictions': predictions or {},
                'status': 'success'
            })
        else:
            results.append({
                'image_index': i + 1,
                'predictions': {},
                'status': 'failed - no image'
            })

    summary = f"Processed {len([r for r in results if r['status'] == 'success'])}/{len(images)} images"
    return summary, results

# 5. Visualization Functions
def create_confidence_chart(predictions):
    """Create confidence visualization"""
    if not predictions:
        return None

    # Create bar chart data
    labels = list(predictions.keys())[:5]  # Top 5
    values = [predictions[label] for label in labels]

    # Return as dictionary for gr.BarPlot
    return {
        'labels': labels,
        'values': values
    }

def create_prediction_details(predictions):
    """Detailed predictions table"""
    if not predictions:
        return []

    details = []
    for label, confidence in predictions.items():
        details.append([label, f"{confidence:.2%}", "✅" if confidence > 0.5 else "⚠️"])

    return details

# 6. Interface Creation
def create_classification_interface():
    """Create the main classification interface"""

    with gr.Blocks(title="Image Classification Demo") as demo:
        gr.Markdown("# 🖼️ Image Classification Demo")
        gr.Markdown("Upload an image to classify it using different models")

        with gr.Row():
            with gr.Column(scale=2):
                # Input section
                image_input = gr.Image(
                    label="Upload Image",
                    type="pil",
                    height=300
                )

                model_choice = gr.Radio(
                    choices=["custom", "imagenet"],
                    label="Model Type",
                    value="custom"
                )

                confidence_slider = gr.Slider(
                    minimum=0.0,
                    maximum=1.0,
                    value=0.1,
                    step=0.05,
                    label="Confidence Threshold"
                )

                classify_btn = gr.Button("Classify Image", variant="primary")

            with gr.Column(scale=2):
                # Results section
                result_text = gr.Textbox(
                    label="Classification Result",
                    interactive=False,
                    lines=3
                )

                predictions_output = gr.Label(
                    label="All Predictions",
                    num_top_classes=10
                )

        with gr.Row():
            # Visualization
            confidence_chart = gr.BarPlot(
                title="Top 5 Predictions",
                x="label",
                y="confidence",
                height=300
            )

            details_table = gr.Dataframe(
                headers=["Class", "Confidence", "Status"],
                label="Detailed Results",
                datatype=["str", "str", "str"]
            )

        # Batch processing section
        with gr.Accordion("Batch Processing", open=False):
            gr.Markdown("Upload multiple images for batch classification")

            batch_images = gr.File(
                file_count="multiple",
                file_types=["image"],
                label="Upload Multiple Images"
            )

            batch_btn = gr.Button("Process Batch", variant="secondary")
            batch_result = gr.Textbox(label="Batch Result", interactive=False)

        # Example images
        gr.Examples(
            examples=[
                ["examples/cat.jpg", "custom"],
                ["examples/dog.jpg", "custom"],
                # Add more example paths as needed
            ],
            inputs=[image_input, model_choice],
            label="Example Images"
        )

        # Event handlers
        classify_btn.click(
            classify_image,
            inputs=[image_input, model_choice, confidence_slider],
            outputs=[result_text, predictions_output]
        ).then(
            create_confidence_chart,
            inputs=predictions_output,
            outputs=confidence_chart
        ).then(
            create_prediction_details,
            inputs=predictions_output,
            outputs=details_table
        )

        batch_btn.click(
            batch_classify,
            inputs=[batch_images, model_choice],
            outputs=[batch_result, details_table]
        )

    return demo

# 7. Advanced Features Interface
def create_advanced_interface():
    """Advanced interface with more features"""

    def analyze_image_properties(image):
        """Analyze image properties"""
        if image is None:
            return "No image uploaded", None

        # Get image properties
        width, height = image.size
        mode = image.mode
        format_name = image.format

        properties = f"""
        Image Properties:
        - Size: {width}x{height} pixels
        - Mode: {mode}
        - Format: {format_name}
        - Aspect Ratio: {width/height:.2f}
        """

        # Create visualization
        return properties, image

    def compare_models(image):
        """Compare multiple model predictions"""
        if image is None:
            return {}

        models = ["custom", "imagenet"]
        comparison = {}

        for model in models:
            _, predictions = classify_image(image, model)
            if predictions:
                top_pred = list(predictions.items())[0]
                comparison[f"{model}_model"] = {
                    "prediction": top_pred[0],
                    "confidence": top_pred[1]
                }

        return comparison

    with gr.Blocks(title="Advanced Image Classification") as demo:
        gr.Markdown("# 🔬 Advanced Image Analysis")

        with gr.Tabs():
            with gr.TabItem("Classification"):
                create_classification_interface()

            with gr.TabItem("Image Analysis"):
                with gr.Row():
                    img_input = gr.Image(type="pil", label="Upload Image")
                    with gr.Column():
                        props_text = gr.Textbox(label="Properties", interactive=False)
                        processed_img = gr.Image(label="Processed")

                img_input.change(
                    analyze_image_properties,
                    inputs=img_input,
                    outputs=[props_text, processed_img]
                )

            with gr.TabItem("Model Comparison"):
                comp_img = gr.Image(type="pil", label="Upload Image")
                comp_btn = gr.Button("Compare Models")
                comp_results = gr.JSON(label="Comparison Results")

                comp_btn.click(
                    compare_models,
                    inputs=comp_img,
                    outputs=comp_results
                )

    return demo

if __name__ == "__main__":
    print("Choose interface mode:")
    print("1. Basic Classification")
    print("2. Advanced Features")

    choice = input("Enter choice (1-2): ")

    if choice == "2":
        demo = create_advanced_interface()
    else:
        demo = create_classification_interface()

    demo.launch(share=True, debug=True)
Code sourcepythonIntermédiaire

Interface de Chatbot

Construire une interface interactive de chatbot

python
# Gradio Chatbot Interface
# Complete chatbot with memory, streaming, and multiple AI models

import gradio as gr
import time
import random
import json
from datetime import datetime
from typing import List, Dict, Any, Optional

# 1. Chatbot Data Models
class Message:
    """Message model for chat conversations"""

    def __init__(self, role: str, content: str, timestamp: Optional[datetime] = None):
        self.role = role  # 'user' or 'assistant'
        self.content = content
        self.timestamp = timestamp or datetime.now()

    def to_dict(self):
        return {
            "role": self.role,
            "content": self.content,
            "timestamp": self.timestamp.isoformat()
        }

class ChatHistory:
    """Manage chat conversation history"""

    def __init__(self, max_messages: int = 50):
        self.messages: List[Message] = []
        self.max_messages = max_messages

    def add_message(self, role: str, content: str):
        """Add a new message to history"""
        message = Message(role, content)
        self.messages.append(message)

        # Limit history size
        if len(self.messages) > self.max_messages:
            self.messages = self.messages[-self.max_messages:]

    def get_conversation_context(self, last_n: int = 5) -> str:
        """Get formatted conversation context"""
        recent_messages = self.messages[-last_n:]
        context = ""

        for msg in recent_messages:
            prefix = "User" if msg.role == "user" else "Assistant"
            context += f"{prefix}: {msg.content}\n"

        return context

    def clear(self):
        """Clear all messages"""
        self.messages.clear()

    def to_gradio_format(self) -> List[List[str]]:
        """Convert to Gradio chatbot format"""
        formatted = []
        for msg in self.messages:
            if msg.role == "user":
                formatted.append([msg.content, None])
            else:
                if formatted and formatted[-1][1] is None:
                    formatted[-1][1] = msg.content
                else:
                    formatted.append([None, msg.content])
        return formatted

# 2. Response Generators
class AIResponseGenerator:
    """Mock AI response generator (replace with actual AI model)"""

    def __init__(self, model_name: str = "gpt-3.5-turbo"):
        self.model_name = model_name
        self.responses = {
            "greeting": [
                "Hello! How can I help you today?",
                "Hi there! What can I do for you?",
                "Greetings! How may I assist you?"
            ],
            "weather": [
                "I don't have access to real-time weather data, but I recommend checking a weather app or website for current conditions.",
                "Weather information isn't available to me directly. Try using a weather service for accurate forecasts."
            ],
            "help": [
                "I can help you with various tasks including answering questions, providing information, and engaging in conversation. What would you like to know?",
                "I'm here to assist you! Feel free to ask questions or start a conversation about any topic."
            ],
            "default": [
                "That's an interesting question! Let me think about that...",
                "I understand what you're asking. Here's my response:",
                "Great question! Based on what I know:",
                "Let me help you with that. I think:"
            ]
        }

        # Personality traits
        self.personality = {
            "friendly": True,
            "helpful": True,
            "professional": True
        }

    def generate_response(self, message: str, context: str = "") -> str:
        """Generate AI response based on input and context"""
        message_lower = message.lower()

        # Simple keyword-based responses
        if any(word in message_lower for word in ["hello", "hi", "hey"]):
            return random.choice(self.responses["greeting"])
        elif "weather" in message_lower:
            return random.choice(self.responses["weather"])
        elif "help" in message_lower:
            return random.choice(self.responses["help"])
        else:
            # Generate contextual response
            base_response = random.choice(self.responses["default"])

            # Add some context-aware content
            if "python" in message_lower:
                base_response += " Python is a versatile programming language great for web development, data science, and automation."
            elif "gradio" in message_lower:
                base_response += " Gradio is an excellent tool for creating machine learning demos with minimal code!"
            elif "machine learning" in message_lower:
                base_response += " Machine learning is a fascinating field that's transforming how we interact with technology."

            return base_response

    def generate_streaming_response(self, message: str, context: str = ""):
        """Generate streaming response word by word"""
        response = self.generate_response(message, context)
        words = response.split()

        partial_response = ""
        for word in words:
            partial_response += word + " "
            yield partial_response
            time.sleep(0.05)  # Simulate typing delay

# 3. Chatbot Functions
def respond_to_message(
    message: str,
    history: List[List[str]],
    chat_history_obj: Dict[str, Any],
    model_choice: str,
    stream: bool = False
):
    """Main response function for the chatbot"""

    if not message.strip():
        return history, "Please enter a message."

    # Add user message to history
    chat_history_obj["messages"].append(Message("user", message))

    # Get conversation context
    conversation_context = chat_history_obj["context"].get_conversation_context()

    # Initialize response generator
    generator = AIResponseGenerator(model_choice)

    if stream:
        # Streaming response
        response_parts = []
        for partial_response in generator.generate_streaming_response(message, conversation_context):
            response_parts.append(partial_response)

            # Update history with partial response
            temp_history = chat_history_obj["context"].to_gradio_format()
            if temp_history and temp_history[-1][1] is None:
                temp_history[-1][1] = partial_response
            else:
                temp_history.append([None, partial_response])

            yield temp_history, ""

        # Add final response to history
        final_response = " ".join(response_parts)
        chat_history_obj["messages"].append(Message("assistant", final_response))
        final_history = chat_history_obj["context"].to_gradio_format()

        yield final_history, ""
    else:
        # Regular response
        response = generator.generate_response(message, conversation_context)

        # Add assistant response to history
        chat_history_obj["messages"].append(Message("assistant", response))

        # Convert to Gradio format
        gradio_history = chat_history_obj["context"].to_gradio_format()

        return gradio_history, ""

def clear_chat(chat_history_obj: Dict[str, Any]):
    """Clear chat history"""
    chat_history_obj["messages"].clear()
    chat_history_obj["context"].clear()
    return [], "Chat history cleared."

def save_chat(chat_history_obj: Dict[str, Any]):
    """Save chat history to file"""
    if not chat_history_obj["messages"]:
        return "No messages to save."

    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = f"chat_history_{timestamp}.json"

    try:
        with open(filename, 'w', encoding='utf-8') as f:
            json.dump({
                "timestamp": datetime.now().isoformat(),
                "messages": [msg.to_dict() for msg in chat_history_obj["messages"]]
            }, f, indent=2, ensure_ascii=False)

        return f"Chat saved to {filename}"
    except Exception as e:
        return f"Error saving chat: {str(e)}"

# 4. Interface Creation
def create_chatbot_interface():
    """Create the main chatbot interface"""

    # Initialize chat history
    chat_histories = {}

    def get_chat_history(session_id: str = "default"):
        """Get or create chat history for session"""
        if session_id not in chat_histories:
            chat_histories[session_id] = {
                "messages": [],
                "context": ChatHistory()
            }
        return chat_histories[session_id]

    with gr.Blocks(title="AI Chatbot", theme=gr.themes.Soft()) as demo:
        gr.Markdown("# 🤖 AI Chatbot Interface")
        gr.Markdown("Chat with an AI assistant powered by multiple models")

        # Chat interface
        with gr.Row():
            with gr.Column(scale=3):
                chatbot = gr.Chatbot(
                    label="Conversation",
                    height=400,
                    show_copy_button=True,
                    avatar_images=["👤", "🤖"]
                )

                with gr.Row():
                    msg_input = gr.Textbox(
                        label="Your Message",
                        placeholder="Type your message here...",
                        scale=4
                    )
                    send_btn = gr.Button("Send", variant="primary", scale=1)

            with gr.Column(scale=1):
                # Controls
                model_choice = gr.Dropdown(
                    choices=["gpt-3.5-turbo", "gpt-4", "claude-3", "local-model"],
                    label="AI Model",
                    value="gpt-3.5-turbo"
                )

                stream_checkbox = gr.Checkbox(
                    label="Streaming Response",
                    value=True
                )

                # Action buttons
                with gr.Row():
                    clear_btn = gr.Button("Clear", size="sm")
                    save_btn = gr.Button("Save", size="sm")

                status_output = gr.Textbox(
                    label="Status",
                    interactive=False,
                    lines=2
                )

        # Examples
        gr.Examples(
            examples=[
                ["Hello, how are you?"],
                ["What can you help me with?"],
                ["Tell me about Gradio"],
                ["How do I learn Python?"],
                ["What's the weather like today?"]
            ],
            inputs=msg_input,
            label="Example Messages"
        )

        # Statistics
        with gr.Accordion("Chat Statistics", open=False):
            stats_text = gr.Textbox(
                label="Session Stats",
                interactive=False,
                value="No messages yet..."
            )

        # Event handlers
        def user_input(user_message, history, model, stream_enabled):
            """Handle user input"""
            chat_history = get_chat_history()

            # Create response generator function
            def response_generator():
                return respond_to_message(
                    user_message,
                    history,
                    chat_history,
                    model,
                    stream_enabled
                )

            return response_generator()

        def update_stats():
            """Update chat statistics"""
            chat_history = get_chat_history()
            messages = chat_history["messages"]
            user_msgs = [m for m in messages if m.role == "user"]
            ai_msgs = [m for m in messages if m.role == "assistant"]

            return f"""
            Total Messages: {len(messages)}
            User Messages: {len(user_msgs)}
            AI Responses: {len(ai_msgs)}
            Session Started: {messages[0].timestamp.strftime('%H:%M:%S') if messages else 'N/A'}
            """

        # Connect events
        msg_input.submit(
            user_input,
            inputs=[msg_input, chatbot, model_choice, stream_checkbox],
            outputs=[chatbot, status_output]
        )

        send_btn.click(
            user_input,
            inputs=[msg_input, chatbot, model_choice, stream_checkbox],
            outputs=[chatbot, status_output]
        ).then(
            lambda: "",  # Clear input
            outputs=[msg_input]
        ).then(
            update_stats,
            outputs=[stats_text]
        )

        clear_btn.click(
            lambda: (clear_chat(get_chat_history()), ""),
            outputs=[chatbot, status_output]
        ).then(
            update_stats,
            outputs=[stats_text]
        )

        save_btn.click(
            lambda: save_chat(get_chat_history()),
            outputs=[status_output]
        )

    return demo

# 5. Multi-Chat Interface
def create_multi_chat_interface():
    """Interface with multiple chat rooms"""

    with gr.Blocks(title="Multi-Room Chatbot") as demo:
        gr.Markdown("# 🏢 Multi-Room Chat System")

        with gr.Tabs():
            with gr.TabItem("General Chat"):
                create_chatbot_interface()

            with gr.TabItem("Technical Support"):
                gr.Markdown("### Technical Support Assistant")
                gr.Markdown("Specialized for technical questions and troubleshooting")
                # Create specialized chatbot here
                gr.Textbox("Technical support chat coming soon...", interactive=False)

            with gr.TabItem("Creative Writing"):
                gr.Markdown("### Creative Writing Partner")
                gr.Markdown("Help with stories, poems, and creative content")
                # Create creative writing chatbot here
                gr.Textbox("Creative writing assistant coming soon...", interactive=False)

    return demo

if __name__ == "__main__":
    print("Choose chatbot mode:")
    print("1. Single Chat Interface")
    print("2. Multi-Room Chat")

    choice = input("Enter choice (1-2): ")

    if choice == "2":
        demo = create_multi_chat_interface()
    else:
        demo = create_chatbot_interface()

    demo.launch(share=True, debug=True)
Code sourcepythonComplexe

Visualisation de Données

Intégrer des graphiques et composants de visualisation de données

python
# Gradio Data Visualization Dashboard
# Complete dashboard with interactive charts and real-time updates

import gradio as gr
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import plotly.graph_objects as go
import plotly.express as px
import time
import json
from datetime import datetime, timedelta
import random

# 1. Data Generation Functions
def generate_sales_data(days=30):
    """Generate sample sales data"""
    dates = pd.date_range(end=datetime.now(), periods=days)
    data = {
        'date': dates,
        'sales': np.random.normal(1000, 200, days) + np.sin(range(days)) * 100,
        'customers': np.random.poisson(50, days),
        'revenue': np.random.normal(5000, 1000, days),
        'category': np.random.choice(['Electronics', 'Clothing', 'Food', 'Books'], days)
    }
    return pd.DataFrame(data)

def generate_realtime_data():
    """Generate real-time data point"""
    return {
        'timestamp': datetime.now(),
        'value': random.gauss(100, 15),
        'category': random.choice(['A', 'B', 'C']),
        'status': random.choice(['active', 'inactive'])
    }

# 2. Chart Creation Functions
def create_line_chart(data):
    """Create interactive line chart"""
    if data.empty:
        return None

    fig = px.line(
        data,
        x='date',
        y='sales',
        title='Sales Trend Over Time',
        labels={'sales': 'Sales Amount', 'date': 'Date'}
    )

    fig.update_layout(
        hovermode='x unified',
        showlegend=True,
        height=400
    )

    return fig

def create_bar_chart(data):
    """Create category-wise bar chart"""
    if data.empty:
        return None

    category_data = data.groupby('category').agg({
        'sales': 'sum',
        'customers': 'sum'
    }).reset_index()

    fig = go.Figure()

    fig.add_trace(go.Bar(
        x=category_data['category'],
        y=category_data['sales'],
        name='Total Sales',
        marker_color='lightblue'
    ))

    fig.add_trace(go.Bar(
        x=category_data['category'],
        y=category_data['customers'],
        name='Total Customers',
        marker_color='lightgreen',
        yaxis='y2'
    ))

    fig.update_layout(
        title='Sales and Customers by Category',
        xaxis_title='Category',
        yaxis_title='Sales',
        yaxis2=dict(
            title='Customers',
            overlaying='y',
            side='right'
        ),
        barmode='group',
        height=400
    )

    return fig

def create_scatter_plot(data):
    """Create scatter plot"""
    if data.empty:
        return None

    fig = px.scatter(
        data,
        x='customers',
        y='revenue',
        color='category',
        size='sales',
        title='Customers vs Revenue by Category',
        hover_data=['date']
    )

    fig.update_layout(height=400)
    return fig

def create_pie_chart(data):
    """Create pie chart for category distribution"""
    if data.empty:
        return None

    category_counts = data['category'].value_counts()

    fig = go.Figure(data=[go.Pie(
        labels=category_counts.index,
        values=category_counts.values,
        hole=0.3,
        textinfo='label+percent+value'
    )])

    fig.update_layout(
        title='Sales Distribution by Category',
        height=400
    )

    return fig

def create_heatmap(data):
    """Create correlation heatmap"""
    if data.empty:
        return None

    # Create correlation matrix
    numeric_cols = ['sales', 'customers', 'revenue']
    corr_matrix = data[numeric_cols].corr()

    fig = go.Figure(data=go.Heatmap(
        z=corr_matrix.values,
        x=corr_matrix.columns,
        y=corr_matrix.columns,
        colorscale='RdBu',
        zmid=0,
        text=corr_matrix.values,
        texttemplate="%{text:.2f}",
        textfont={"size": 10}
    ))

    fig.update_layout(
        title='Correlation Matrix',
        height=300
    )

    return fig

def create_realtime_chart(history_data):
    """Create real-time updating chart"""
    if not history_data:
        return go.Figure()

    df = pd.DataFrame(history_data)

    fig = go.Figure()

    # Add main value line
    fig.add_trace(go.Scatter(
        x=df['timestamp'],
        y=df['value'],
        mode='lines+markers',
        name='Value',
        line=dict(color='blue', width=2)
    ))

    # Add moving average
    if len(df) > 5:
        df['moving_avg'] = df['value'].rolling(window=5).mean()
        fig.add_trace(go.Scatter(
            x=df['timestamp'],
            y=df['moving_avg'],
            mode='lines',
            name='Moving Avg',
            line=dict(color='red', width=2, dash='dash')
        ))

    fig.update_layout(
        title='Real-time Data Stream',
        xaxis_title='Time',
        yaxis_title='Value',
        height=300,
        showlegend=True
    )

    return fig

# 3. Dashboard Functions
def update_dashboard(date_range, category_filter):
    """Update all dashboard charts"""
    # Generate or filter data
    if date_range == "Last 7 days":
        days = 7
    elif date_range == "Last 30 days":
        days = 30
    else:
        days = 90

    data = generate_sales_data(days)

    # Apply category filter
    if category_filter != "All":
        data = data[data['category'] == category_filter]

    # Create charts
    line_chart = create_line_chart(data)
    bar_chart = create_bar_chart(data)
    scatter_plot = create_scatter_plot(data)
    pie_chart = create_pie_chart(data)
    heatmap = create_heatmap(data)

    # Calculate statistics
    stats = calculate_statistics(data)

    return line_chart, bar_chart, scatter_plot, pie_chart, heatmap, stats

def calculate_statistics(data):
    """Calculate dashboard statistics"""
    if data.empty:
        return "No data available"

    stats = {
        'Total Sales': f"${data['sales'].sum():,.2f}",
        'Avg Daily Sales': f"${data['sales'].mean():,.2f}",
        'Total Customers': f"{data['customers'].sum():,}",
        'Avg Revenue': f"${data['revenue'].mean():,.2f}",
        'Best Category': data.groupby('category')['sales'].sum().idxmax(),
        'Peak Day': data.loc[data['sales'].idxmax(), 'date'].strftime('%Y-%m-%d')
    }

    stats_text = "📊 Dashboard Statistics\n\n"
    for key, value in stats.items():
        stats_text += f"**{key}:** {value}\n"

    return stats_text

def update_realtime_data(history_data):
    """Update real-time data"""
    new_data = generate_realtime_data()
    history_data.append(new_data)

    # Keep only last 20 points
    if len(history_data) > 20:
        history_data = history_data[-20:]

    chart = create_realtime_chart(history_data)

    return chart, history_data

# 4. Main Dashboard Interface
def create_dashboard():
    """Create the main dashboard interface"""

    # Initialize real-time data
    realtime_data = []

    with gr.Blocks(title="Data Visualization Dashboard", theme=gr.themes.Soft()) as demo:
        gr.Markdown("# 📈 Data Visualization Dashboard")
        gr.Markdown("Interactive dashboard with real-time updates and multiple chart types")

        # Controls
        with gr.Row():
            date_range = gr.Dropdown(
                choices=["Last 7 days", "Last 30 days", "Last 90 days"],
                label="Time Period",
                value="Last 30 days"
            )

            category_filter = gr.Dropdown(
                choices=["All", "Electronics", "Clothing", "Food", "Books"],
                label="Category Filter",
                value="All"
            )

            refresh_btn = gr.Button("Refresh Data", variant="primary")

        # Statistics
        with gr.Row():
            stats_display = gr.Markdown("📊 Loading statistics...")

        # Charts Grid
        with gr.Row():
            with gr.Column():
                line_chart = gr.Plot(label="Sales Trend")
            with gr.Column():
                bar_chart = gr.Plot(label="Category Analysis")

        with gr.Row():
            with gr.Column():
                scatter_plot = gr.Plot(label="Performance Analysis")
            with gr.Column():
                pie_chart = gr.Plot(label="Distribution")

        # Correlation and Real-time
        with gr.Row():
            with gr.Column():
                heatmap = gr.Plot(label="Correlation Matrix")
            with gr.Column():
                realtime_chart = gr.Plot(label="Real-time Data")

                realtime_refresh = gr.Button("Update Real-time", variant="secondary")

        # Data Table
        with gr.Accordion("Raw Data", open=False):
            data_table = gr.Dataframe(
                label="Sales Data",
                datatype=["date", "number", "number", "number", "str"]
            )

        # Export functionality
        with gr.Row():
            export_btn = gr.Button("Export to CSV", variant="secondary")
            export_status = gr.Textbox(label="Export Status", interactive=False)

        # Event handlers
        def refresh_dashboard(date_range, category_filter):
            """Refresh all dashboard components"""
            line, bar, scatter, pie, heat, stats = update_dashboard(date_range, category_filter)

            # Get sample data for table
            if date_range == "Last 7 days":
                days = 7
            elif date_range == "Last 30 days":
                days = 30
            else:
                days = 90

            sample_data = generate_sales_data(days)
            if category_filter != "All":
                sample_data = sample_data[sample_data['category'] == category_filter]

            return line, bar, scatter, pie, heat, stats, sample_data.head(10)

        def update_realtime():
            """Update real-time chart"""
            nonlocal realtime_data
            chart, realtime_data = update_realtime_data(realtime_data)
            return chart

        def export_data(date_range, category_filter):
            """Export data to CSV"""
            try:
                if date_range == "Last 7 days":
                    days = 7
                elif date_range == "Last 30 days":
                    days = 30
                else:
                    days = 90

                data = generate_sales_data(days)
                if category_filter != "All":
                    data = data[data['category'] == category_filter]

                filename = f"sales_data_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
                data.to_csv(filename, index=False)

                return f"Data exported to {filename}"
            except Exception as e:
                return f"Export failed: {str(e)}"

        # Connect events
        refresh_btn.click(
            refresh_dashboard,
            inputs=[date_range, category_filter],
            outputs=[line_chart, bar_chart, scatter_plot, pie_chart, heatmap, stats_display, data_table]
        )

        date_range.change(
            refresh_dashboard,
            inputs=[date_range, category_filter],
            outputs=[line_chart, bar_chart, scatter_plot, pie_chart, heatmap, stats_display, data_table]
        )

        category_filter.change(
            refresh_dashboard,
            inputs=[date_range, category_filter],
            outputs=[line_chart, bar_chart, scatter_plot, pie_chart, heatmap, stats_display, data_table]
        )

        realtime_refresh.click(
            update_realtime,
            outputs=[realtime_chart]
        )

        export_btn.click(
            export_data,
            inputs=[date_range, category_filter],
            outputs=[export_status]
        )

        # Initial load
        demo.load(
            refresh_dashboard,
            inputs=[date_range, category_filter],
            outputs=[line_chart, bar_chart, scatter_plot, pie_chart, heatmap, stats_display, data_table]
        )

    return demo

# 5. Advanced Analytics Dashboard
def create_analytics_dashboard():
    """Advanced dashboard with ML insights"""

    def predict_trends(data):
        """Simple trend prediction"""
        if data.empty:
            return "No data for prediction"

        # Simple linear regression for trend
        x = np.arange(len(data))
        y = data['sales'].values

        # Calculate trend
        trend = np.polyfit(x, y, 1)
        slope = trend[0]

        if slope > 0:
            return "📈 **Upward Trend**: Sales are increasing over time"
        elif slope < 0:
            return "📉 **Downward Trend**: Sales are decreasing over time"
        else:
            return "➡️ **Stable**: Sales are relatively stable"

    def detect_anomalies(data):
        """Detect anomalies in sales data"""
        if data.empty:
            return []

        # Simple anomaly detection using z-score
        sales_mean = data['sales'].mean()
        sales_std = data['sales'].std()

        anomalies = data[abs(data['sales'] - sales_mean) > 2 * sales_std]

        return [
            f"Anomaly on {row['date'].strftime('%Y-%m-%d')}: Sales ${row['sales']:.2f}"
            for _, row in anomalies.iterrows()
        ]

    with gr.Blocks(title="Advanced Analytics Dashboard") as demo:
        gr.Markdown("# 🔬 Advanced Analytics Dashboard")

        with gr.Tabs():
            with gr.TabItem("Overview"):
                create_dashboard()

            with gr.TabItem("Predictions"):
                gr.Markdown("## Sales Trend Analysis")

                prediction_date_range = gr.Dropdown(
                    choices=["Last 7 days", "Last 30 days", "Last 90 days"],
                    label="Analysis Period",
                    value="Last 30 days"
                )

                predict_btn = gr.Button("Analyze Trends", variant="primary")

                trend_result = gr.Markdown("Click analyze to see predictions...")

                anomaly_output = gr.JSON(label="Anomaly Detection")

                predict_btn.click(
                    lambda period: (
                        predict_trends(generate_sales_data(7 if "7" in period else 30 if "30" in period else 90)),
                        detect_anomalies(generate_sales_data(7 if "7" in period else 30 if "30" in period else 90))
                    ),
                    inputs=[prediction_date_range],
                    outputs=[trend_result, anomaly_output]
                )

    return demo

if __name__ == "__main__":
    print("Choose dashboard type:")
    print("1. Standard Dashboard")
    print("2. Advanced Analytics")

    choice = input("Enter choice (1-2): ")

    if choice == "2":
        demo = create_analytics_dashboard()
    else:
        demo = create_dashboard()

    demo.launch(share=True, debug=True)

Outils

Outils souvent utilisés avec cet exemple

Associé

Collections d’exemples associées

Associé

Dossiers associés

Guide d'utilisation de l'outil

Contexte pour comprendre cette collection d’exemples

Titre

Exemples Gradio

Description

Exemples de déploiement rapide de modèles d'apprentissage automatique utilisant Gradio pour créer des interfaces web interactives avec un code minimal

Aperçu

Exemples de déploiement rapide de modèles d'apprentissage automatique utilisant Gradio pour créer des interfaces web interactives avec un code minimal

Quand l’utiliser

  • Use this sample set when you want reference inputs for Exemples Gradio.
  • Use it to preview output formats and compare related sample variants.

Fonctionnement

  1. 1Open a sample entry to inspect the prepared example payload or asset.
  2. 2Compare it with related tools to understand how the workflow connects.

Cas d’usage

  • Hello World de Base
  • Interface de Classification d'Images
  • Interface de Chatbot
  • Visualisation de Données

FAQ

What is included in Exemples Gradio?

This page includes curated sample entries, related tools, and neighboring sample collections for Exemples Gradio.

Dossier

Révision stylistique et remise de Markdown anglais et chinois

Examinez clichés et répétitions d’un brouillon Markdown anglais ou chinois, préservez faits et citations, vérifiez modifications et liens et remettez une source approuvée avec son registre.

Dossier

Vérification des recommandations par entité sur HN et livraison du classement

Transformez un export autorisé de commentaires HN en recommandations traçables : gardez le contexte, distinguez éloges, critiques et intentions de lecture, puis révisez doublons et votes.

Dossier

Vérifier les codecs avec perte et la livraison d’un master audio

Testez un master terminé par encodage avec perte, examinez crêtes et sonie après décodage, ajustez seulement si nécessaire et vérifiez le fichier final MP3, AAC ou Opus.

Dossier

Définir une période de reporting ISO 8601 et sa semaine fiscale

Transformez une date de départ et une durée convenue en échéance calculée au calendrier, avec semaine ISO et trimestre fiscal vérifiables.

Accueil
Outils3201
Exemples593
Visualisations465
Visionneuses de fichiers103
Dossiers233
Étiquettes333
Images, audio et vidéo657

Outils de traitement, conversion et optimisation d’images, d’audio et de vidéo

Maths, dates et finance644

Calculateurs, outils numériques, logique de dates, statistiques et finance

Design et couleur297

Outils de couleur, mise en page, graphisme, style visuel et assistance design

Texte et rédaction209

Outils de rédaction, nettoyage, formatage, extraction et analyse de texte

Développement et Web193

Utilitaires développeur, réseau, débogage Web et assistants d’automatisation

Conversion et encodage175

Outils de conversion de formats, fichiers, archives, unités et encodages

Examen des sources FLAC/WAV et transmission des preuves
Revue et livraison d’un module de jeu promotionnel auto-hébergé
Relecture d'un lot de codes Stripe et contrôle préalable à l'importation
Tri technique des photos et transmission des candidates à la retouche
Structurer une capture d'interface, la relire et la transmettre au développement

© 2026 Elysia Tools. Tous droits réservés.

DocumentationTarifsÀ proposConditions d'utilisationPolitique de confidentialitéCookiesContact

AI Tools

Âge & genre AI

Estime l'âge et le genre pour chaque visage détecté

AI Tools

Aligner & rogner les visages AI

Détecte, aligne et rogne les visages en images séparées (ZIP si plusieurs)

AI Tools

Descripteurs faciaux AI

Génère des embeddings 128D pour chaque visage détecté

AI Tools

Détection de visages AI

Détecte les visages et renvoie les coordonnées des boîtes

AI Tools

Expressions faciales AI

Classe les expressions par visage (neutre/joyeux/triste/colère/peur/dégoût/surprise)

AI Tools

Points clés du visage AI

Détecte 68 points faciaux et retourne leurs coordonnées

AI Tools

Reconnaissance faciale (galerie)

Construit une galerie étiquetée puis reconnaît les visages dans une image cible

AI Tools

Détecteur de Contenu d'Image NSFW

Détecteur de sécurité de contenu d'image alimenté par l'IA utilisant NSFWJS avec analyse de secours, supportant GIF/Animated WebP/APNG et JPEG/PNG/WEBP.

Médias

Exemples SVG

Exemples de graphiques vectoriels évolutifs (SVG) démontrant diverses fonctionnalités et techniques SVG

IA/ML

Exemples de Déploiement Hugging Face

Exemples de déploiement de modèles Hugging Face incluant Transformers, Diffusers et applications Gradio avec Docker et déploiement cloud

IA et apprentissage automatique

Exemples OpenAI API

Exemples complets de l'API OpenAI incluant les modèles GPT, la génération d'images DALL-E, le traitement audio Whisper et les appels de fonctions

Documents

Exemples PDF

Exemples PDF generes par les outils du 2026-02-01 au 2026-02-10

Médias

Exemples de Codes QR

Images de codes QR d'exemple pour tester les outils de lecture et de génération de codes QR

Médias

Exemples de Fichiers Photo Camera RAW

Collection telechargeable de fichiers photo camera RAW couvrant Sony ARW/SRF/SR2, Canon CR2/CR3/CRW, Adobe DNG, Nikon NEF/NRW, Fuji RAF, Olympus ORF, Panasonic RW2, Leica RAW/DNG et un fichier binaire RAW generique pour tester les workflows d envoi et de conversion.