Gradio¶

import gradio as gr
print(gr.__version__)

import gradio as gr

def greet(name):
    return f"Hello, {name}! Welcome to Gradio."

# Create the interface
demo = gr.Interface(
    fn=greet,              # The function to wrap
    inputs="text",         # Input type
    outputs="text",        # Output type
    title="Simple Greeter",
    description="Enter your name to receive a greeting."
)

# Launch the app
demo.launch()

gr.Interface(
    fn=your_function,       # Required: The function to call
    inputs=input_components, # Required: Input component(s)
    outputs=output_components, # Required: Output component(s)
    title="App Title",      # Optional: Display title
    description="Description", # Optional: Help text
    examples=[["example1"], ["example2"]]  # Optional: Example inputs
)

import gradio as gr

def summarize_text(text, max_length, style):
    """
    A placeholder summarization function.
    In practice, you would connect this to an LLM.
    """
    # Simulate summarization
    word_count = len(text.split())
    summary = f"[{style} summary of {word_count} words, max {max_length} words]"

    # In real use, you would call an API or model here:
    # from transformers import pipeline
    # summarizer = pipeline("summarization")
    # result = summarizer(text, max_length=max_length)

    return summary

demo = gr.Interface(
    fn=summarize_text,
    inputs=[
        gr.Textbox(
            label="Text to Summarize",
            placeholder="Paste your article, paper abstract, or document here...",
            lines=10
        ),
        gr.Slider(
            minimum=50,
            maximum=500,
            value=150,
            step=10,
            label="Maximum Summary Length (words)"
        ),
        gr.Dropdown(
            choices=["Brief", "Detailed", "Technical", "Simplified"],
            value="Brief",
            label="Summary Style"
        )
    ],
    outputs=gr.Textbox(label="Summary", lines=5),
    title="Academic Text Summarizer",
    description="Paste text from papers, articles, or documents to generate a summary.",
    examples=[
        ["Machine learning is a subset of artificial intelligence that enables systems to learn and improve from experience without being explicitly programmed.", 100, "Brief"],
    ]
)

demo.launch()

import gradio as gr
from transformers import pipeline

# Load a pre-trained image classification model from Hugging Face
# See https://huggingface.co/models?pipeline_tag=image-classification
classifier = pipeline("image-classification", model="google/vit-base-patch16-224")

def classify_image(image):
    """Classify an uploaded image and return top predictions."""
    if image is None:
        return "Please upload an image."

    # Run classification
    predictions = classifier(image)

    # Format results
    results = "\n".join([
        f"{pred['label']}: {pred['score']:.2%}"
        for pred in predictions[:5]
    ])

    return results

demo = gr.Interface(
    fn=classify_image,
    inputs=gr.Image(type="pil", label="Upload an Image"),
    outputs=gr.Textbox(label="Classification Results", lines=6),
    title="Image Classifier",
    description="Upload an image to classify its contents using a Vision Transformer model from Hugging Face.",
    examples=[
        ["https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg"]
    ]
)

demo.launch()

import gradio as gr
from transformers import pipeline

# Load a question-answering model
qa_model = pipeline("question-answering", model="deepset/roberta-base-squad2")

def answer_question(context, question):
    """Answer a question based on the provided context."""
    if not context or not question:
        return "Please provide both context and a question."

    result = qa_model(question=question, context=context)

    answer = result['answer']
    confidence = result['score']

    return f"**Answer:** {answer}\n\n**Confidence:** {confidence:.2%}"

demo = gr.Interface(
    fn=answer_question,
    inputs=[
        gr.Textbox(
            label="Context",
            placeholder="Paste the text passage that contains the answer...",
            lines=8
        ),
        gr.Textbox(
            label="Question",
            placeholder="Ask a question about the text above..."
        )
    ],
    outputs=gr.Markdown(label="Answer"),
    title="Research Document Q&A",
    description="Paste a passage from a paper or document, then ask questions about it.",
    examples=[
        [
            "The transformer architecture was introduced in the paper 'Attention Is All You Need' by Vaswani et al. in 2017. It revolutionized natural language processing by replacing recurrent neural networks with self-attention mechanisms, enabling much faster training through parallelization.",
            "When was the transformer architecture introduced?"
        ],
        [
            "CRISPR-Cas9 is a genome editing technology that allows scientists to make precise changes to DNA. It works by using a guide RNA to direct the Cas9 enzyme to a specific location in the genome, where it makes a cut. The cell's natural repair mechanisms then make the desired edit.",
            "How does CRISPR-Cas9 work?"
        ]
    ]
)

demo.launch()

import gradio as gr

def analyze_data(file, analysis_type):
    """Placeholder for data analysis function."""
    if file is None:
        return "Please upload a file.", None

    # In practice, you would process the file here
    # import pandas as pd
    # df = pd.read_csv(file.name)

    summary = f"Analysis type: {analysis_type}\nFile uploaded successfully."

    # Generate a placeholder plot
    import matplotlib.pyplot as plt
    import numpy as np

    fig, ax = plt.subplots()
    x = np.linspace(0, 10, 100)
    ax.plot(x, np.sin(x), label='Sample Data')
    ax.set_xlabel('X axis')
    ax.set_ylabel('Y axis')
    ax.set_title(f'{analysis_type} Results')
    ax.legend()

    return summary, fig

# Create a more complex layout with Blocks
with gr.Blocks(title="Research Data Analyzer") as demo:
    gr.Markdown("# Research Data Analyzer")
    gr.Markdown("Upload your data file and select an analysis type.")

    with gr.Row():
        with gr.Column(scale=1):
            file_input = gr.File(label="Upload Data File (CSV, Excel)")
            analysis_dropdown = gr.Dropdown(
                choices=["Descriptive Statistics", "Correlation Analysis",
                         "Trend Analysis", "Outlier Detection"],
                label="Analysis Type",
                value="Descriptive Statistics"
            )
            analyze_btn = gr.Button("Run Analysis", variant="primary")

        with gr.Column(scale=2):
            output_text = gr.Textbox(label="Analysis Summary", lines=5)
            output_plot = gr.Plot(label="Visualization")

    analyze_btn.click(
        fn=analyze_data,
        inputs=[file_input, analysis_dropdown],
        outputs=[output_text, output_plot]
    )

demo.launch()

import gradio as gr
from huggingface_hub import InferenceClient

# Initialize the client (requires HF_TOKEN environment variable or explicit token)
# See the Hugging Face documentation for setting up authentication:
# https://huggingface.co/docs/huggingface_hub/quick-start#authentication
client = InferenceClient()

def chat_with_model(message, history, system_prompt, model_name):
    """Chat with a Hugging Face model via the Inference API."""

    messages = [{"role": "system", "content": system_prompt}]

    # Add conversation history
    for human, assistant in history:
        messages.append({"role": "user", "content": human})
        messages.append({"role": "assistant", "content": assistant})

    # Add current message
    messages.append({"role": "user", "content": message})

    # Generate response
    response = client.chat_completion(
        model=model_name,
        messages=messages,
        max_tokens=500,
        temperature=0.7
    )

    return response.choices[0].message.content

demo = gr.ChatInterface(
    fn=chat_with_model,
    additional_inputs=[
        gr.Textbox(
            value="You are a helpful research assistant specializing in academic writing.",
            label="System Prompt",
            lines=2
        ),
        gr.Dropdown(
            choices=[
                "meta-llama/Llama-3.2-3B-Instruct",
                "mistralai/Mistral-7B-Instruct-v0.3",
                "Qwen/Qwen2.5-7B-Instruct"
            ],
            value="meta-llama/Llama-3.2-3B-Instruct",
            label="Model"
        )
    ],
    title="Research Assistant Chatbot",
    description="Chat with open-source LLMs from Hugging Face. Select a model and customize the system prompt."
)

demo.launch()

import gradio as gr
import requests
import json

def chat_with_ollama(message, history, model_name):
    """Chat with a local Ollama model."""

    # Build conversation context
    full_prompt = ""
    for human, assistant in history:
        full_prompt += f"User: {human}\nAssistant: {assistant}\n"
    full_prompt += f"User: {message}\nAssistant:"

    # Call Ollama API
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model_name,
            "prompt": full_prompt,
            "stream": False
        }
    )

    if response.status_code == 200:
        return response.json()["response"]
    else:
        return f"Error: {response.status_code}"

demo = gr.ChatInterface(
    fn=chat_with_ollama,
    additional_inputs=[
        gr.Dropdown(
            choices=["llama3.2", "mistral", "qwen2.5", "deepseek-r1:8b"],
            value="llama3.2",
            label="Local Model (Ollama)"
        )
    ],
    title="Local AI Chat",
    description="Chat with AI models running locally on your machine via Ollama."
)

demo.launch()

demo.launch(share=True)