Gradio

pip install gradio

# Create a virtual environment
python3.12 -m venv .venv # 3.13 is not ready for all ai projects yet, so I stick with 3.12 for now

# Activate the environment (macOS/Linux)
source .venv/bin/activate

# Install Gradio
pip install gradio

# For plotting capabilities
pip install "gradio[plots]"

# For audio processing
pip install "gradio[audio]"

# For all optional dependencies
pip install "gradio[all]"

pip install gradio-client

python3.12 -m venv .venv
source .venv/bin/activate
pip install 'gradio[all]' torch

ollama pull moondream

# main.py
import gradio as gr
import requests
import json
from PIL import Image
import io
import base64


# Function to encode the image to base64
def encode_image(image):
    buffered = io.BytesIO()
    image.save(buffered, format="PNG")
    return base64.b64encode(buffered.getvalue()).decode("utf-8")


# Define the classification function
def classify_image(image):
    # Encode the image to base64
    base64_image = encode_image(image)

    # Prepare the request to Ollama API
    api_url = "http://localhost:11434/api/generate"
    payload = {
        "model": "moondream",
        "prompt": "Describe this image in detail and identify what's in it.",
        "stream": False,
        "images": [base64_image],
    }

    # Make the API call
    try:
        response = requests.post(api_url, json=payload)
        response.raise_for_status()  # Raise an exception for HTTP errors

        # Parse the response
        result = response.json()
        description = result.get("response", "No description available")

        # Return the description
        return description
    except requests.exceptions.RequestException as e:
        return f"Error: {str(e)}"


# Create the Gradio interface
demo = gr.Interface(
    fn=classify_image,
    inputs=gr.Image(type="pil"),
    outputs=gr.Textbox(label="Image Description"),
    title="Image Analysis with Ollama moondream2",
    description="Upload an image to analyze it with the LLaVA model via Ollama.",
    examples=[
        [
            "https://ridermagazine.com/wp-content/uploads/2019/08/2020-Aprilia-RS-660-3qtr.jpg"
        ],
        [
            "https://upload.wikimedia.org/wikipedia/commons/thumb/1/15/Cat_August_2010-4.jpg/1200px-Cat_August_2010-4.jpg"
        ],
    ],
    article="This demo uses the LLaVA model through Ollama to analyze and describe images. Make sure you have Ollama running locally with the LLaVA model installed (`ollama pull llava`).",
)

# Launch the app
if __name__ == "__main__":
    demo.launch()

import gradio as gr
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# Load model and tokenizer
model_name = "NousResearch/Meta--Llama-3-8B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

# Define chat function
def chat(message, history):
    # Format the conversation history for the model
    messages = []
    for user_msg, assistant_msg in history:
        messages.append({"role": "user", "content": user_msg})
        messages.append({"role": "assistant", "content": assistant_msg})
    messages.append({"role": "user", "content": message})

    # Convert to model input format
    prompt = tokenizer.apply_chat_template(
        messages,
        tokenize=False,
        add_generation_prompt=True
    )

    # Tokenize
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

    # Generate response
    outputs = model.generate(
        inputs.input_ids,
        max_new_tokens=512,
        temperature=0.7,
        top_p=0.9,
        do_sample=True,
        eos_token_id=tokenizer.eos_token_id,
    )

    # Decode response
    response = tokenizer.decode(outputs[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)

    return response

# Create the Gradio app with Blocks
with gr.Blocks(css="footer {visibility: hidden}") as demo:
    gr.Markdown("# 🤖 Llama 3 Chatbot")

    with gr.Row():
        with gr.Column(scale=4):
            chatbot = gr.Chatbot(height=600)
            msg = gr.Textbox(
                placeholder="Type your message here...",
                container=False,
                scale=7,
            )
            submit = gr.Button("Send", variant="primary", scale=1)

        with gr.Column(scale=1):
            gr.Markdown("### Settings")
            clear = gr.Button("Clear Conversation")

    # Set up event handlers
    msg_submit = msg.submit(
        chat,
        [msg, chatbot],
        [chatbot],
        queue=True
    ).then(
        lambda: "",
        None,
        [msg]
    )

    submit.click(
        chat,
        [msg, chatbot],
        [chatbot],
        queue=True
    ).then(
        lambda: "",
        None,
        [msg]
    )

    clear.click(lambda: None, None, chatbot, queue=False)

# Launch the app
if __name__ == "__main__":
    demo.launch()