Update app

app

@@ -1,461 +1,14 @@
-import os
-import gradio as gr
-import re
-import folium
 from fastai.vision.all import *
-from groq import Groq
-from PIL import Image
-
-# Load the trained model
+#from fastai.vision.widgets import *
+import timm
 learn = load_learner('export.pkl')
-labels = learn.dls.vocab
-
-# Initialize Groq client
-client = Groq(
-    api_key=os.environ.get("GROQ_API_KEY"),
-)
-
-def clean_bird_name(name):
-    """Clean bird name by removing numbers and special characters, and fix formatting"""
-    # Remove numbers and dots at the beginning
-    cleaned = re.sub(r'^\d+\.', '', name)
-    # Replace underscores with spaces
-    cleaned = cleaned.replace('_', ' ')
-    # Remove any remaining special characters
-    cleaned = re.sub(r'[^\w\s]', '', cleaned)
-    # Fix spacing
-    cleaned = ' '.join(cleaned.split())
-    return cleaned
-
-def get_bird_habitat_map(bird_name, check_tanzania=True):
-    """Get habitat map locations for the bird using Groq API"""
-    clean_name = clean_bird_name(bird_name)
-    
-    # First check if the bird is endemic to Tanzania
-    if check_tanzania:
-        tanzania_check_prompt = f"""
-        Is the {clean_name} bird native to or commonly found in Tanzania? 
-        Answer with ONLY "yes" or "no".
-        """
-        
-        try:
-            tanzania_check = client.chat.completions.create(
-                messages=[{"role": "user", "content": tanzania_check_prompt}],
-                model="llama-3.3-70b-versatile",
-            )
-            is_in_tanzania = "yes" in tanzania_check.choices[0].message.content.lower()
-        except:
-            # Default to showing Tanzania if we can't determine
-            is_in_tanzania = True
-    else:
-        is_in_tanzania = True
-    
-    # Now get the habitat locations
-    prompt = f"""
-    Provide a JSON array of the main habitat locations for the {clean_name} bird in the world. 
-    Return ONLY a JSON array with 3-5 entries, each containing:
-    1. "name": Location name
-    2. "lat": Latitude (numeric value)
-    3. "lon": Longitude (numeric value)
-    4. "description": Brief description of why this is a key habitat (2-3 sentences)
-    
-    Example format:
-    [
-      {{"name": "Example Location", "lat": 12.34, "lon": 56.78, "description": "Brief description"}},
-      ...
-    ]
-    
-    {'' if is_in_tanzania else 'DO NOT include any locations in Tanzania as this bird is not native to or commonly found there.'}
-    """
-    
-    try:
-        chat_completion = client.chat.completions.create(
-            messages=[
-                {
-                    "role": "user",
-                    "content": prompt,
-                }
-            ],
-            model="llama-3.3-70b-versatile",
-        )
-        response = chat_completion.choices[0].message.content
-        
-        # Extract JSON from response (in case there's additional text)
-        import json
-        import re
-        
-        # Find JSON pattern in response
-        json_match = re.search(r'\[.*\]', response, re.DOTALL)
-        if json_match:
-            locations = json.loads(json_match.group())
-        else:
-            # Fallback if JSON extraction fails
-            locations = [
-                {"name": "Primary habitat region", "lat": 0, "lon": 0, 
-                 "description": "Could not retrieve specific habitat information for this bird."}
-            ]
-        
-        return locations, is_in_tanzania
-        
-    except Exception as e:
-        return [{"name": "Error retrieving data", "lat": 0, "lon": 0, 
-                "description": "Please try again or check your connection."}], False
-
-def create_habitat_map(habitat_locations):
-    """Create a folium map with the habitat locations"""
-    # Find center point based on valid coordinates
-    valid_coords = [(loc.get("lat", 0), loc.get("lon", 0)) 
-                    for loc in habitat_locations 
-                    if loc.get("lat", 0) != 0 or loc.get("lon", 0) != 0]
-    
-    if valid_coords:
-        # Calculate the average of the coordinates
-        avg_lat = sum(lat for lat, _ in valid_coords) / len(valid_coords)
-        avg_lon = sum(lon for _, lon in valid_coords) / len(valid_coords)
-        # Create map centered on the average coordinates
-        m = folium.Map(location=[avg_lat, avg_lon], zoom_start=3)
-    else:
-        # Default world map if no valid coordinates
-        m = folium.Map(location=[20, 0], zoom_start=2)
-    
-    # Add markers for each habitat location
-    for location in habitat_locations:
-        name = location.get("name", "Unknown")
-        lat = location.get("lat", 0)
-        lon = location.get("lon", 0)
-        description = location.get("description", "No description available")
-        
-        # Skip invalid coordinates
-        if lat == 0 and lon == 0:
-            continue
-            
-        # Add marker
-        folium.Marker(
-            location=[lat, lon],
-            popup=folium.Popup(f"<b>{name}</b><br>{description}", max_width=300),
-            tooltip=name
-        ).add_to(m)
-    
-    # Save map to HTML
-    map_html = m._repr_html_()
-    return map_html
 
-def format_bird_info(raw_info):
-    """Improve the formatting of bird information"""
-    # Add proper line breaks between sections and ensure consistent heading levels
-    formatted = raw_info
-    
-    # Fix heading levels (make all main sections h3)
-    formatted = re.sub(r'#+\s+NOT TYPICALLY FOUND IN TANZANIA', 
-                        '<div class="alert alert-warning"><strong>⚠️ NOT TYPICALLY FOUND IN TANZANIA</strong></div>', 
-                        formatted)
-    
-    # Replace markdown headings with HTML headings for better control
-    formatted = re.sub(r'#+\s+(.*)', r'<h3>\1</h3>', formatted)
-    
-    # Add paragraph tags for better spacing
-    formatted = re.sub(r'\n\*\s+(.*)', r'<p>• \1</p>', formatted)
-    formatted = re.sub(r'\n([^<\n].*)', r'<p>\1</p>', formatted)
-    
-    # Remove any duplicate paragraph tags
-    formatted = formatted.replace('<p><p>', '<p>')
-    formatted = formatted.replace('</p></p>', '</p>')
-    
-    return formatted
 
-def get_bird_info(bird_name):
-    """Get detailed information about a bird using Groq API"""
-    clean_name = clean_bird_name(bird_name)
-    
-    prompt = f"""
-    Provide detailed information about the {clean_name} bird, including:
-    1. Physical characteristics and appearance
-    2. Habitat and distribution
-    3. Diet and behavior
-    4. Migration patterns (emphasize if this pattern has changed in recent years due to climate change)
-    5. Conservation status
-    
-    If this bird is not commonly found in Tanzania, explicitly flag that this bird is "NOT TYPICALLY FOUND IN TANZANIA" at the beginning of your response and explain why its presence might be unusual.
-    
-    Format your response in markdown for better readability.
-    """
-    
-    try:
-        chat_completion = client.chat.completions.create(
-            messages=[
-                {
-                    "role": "user",
-                    "content": prompt,
-                }
-            ],
-            model="llama-3.3-70b-versatile",
-        )
-        return chat_completion.choices[0].message.content
-    except Exception as e:
-        return f"Error fetching information: {str(e)}"
-
-def predict_and_get_info(img):
-    """Predict bird species and get detailed information"""
-    # Process the image
+labels = learn.dls.vocab
+def predict(img):
     img = PILImage.create(img)
-    
-    # Get prediction
-    pred, pred_idx, probs = learn.predict(img)
-    
-    # Get top 5 predictions (or all if less than 5)
-    num_classes = min(5, len(labels))
-    top_indices = probs.argsort(descending=True)[:num_classes]
-    top_probs = probs[top_indices]
-    top_labels = [labels[i] for i in top_indices]
-    
-    # Format as dictionary with cleaned names for display
-    prediction_results = {clean_bird_name(top_labels[i]): float(top_probs[i]) for i in range(num_classes)}
-    
-    # Get top prediction (original format for info retrieval)
-    top_bird = str(pred)
-    # Also keep a clean version for display
-    clean_top_bird = clean_bird_name(top_bird)
-    
-    # Get habitat locations and create map
-    habitat_locations, is_in_tanzania = get_bird_habitat_map(top_bird)
-    habitat_map_html = create_habitat_map(habitat_locations)
-    
-    # Get detailed information about the top predicted bird
-    bird_info = get_bird_info(top_bird)
-    formatted_info = format_bird_info(bird_info)
-    
-    # Create combined info with map at the top and properly formatted information
-    custom_css = """
-    <style>
-    .bird-container {
-        font-family: Arial, sans-serif;
-        padding: 10px;
-    }
-    .map-container {
-        height: 400px;
-        width: 100%;
-        border: 1px solid #ddd;
-        border-radius: 8px;
-        overflow: hidden;
-        margin-bottom: 20px;
-    }
-    .info-container {
-        line-height: 1.6;
-    }
-    .info-container h3 {
-        margin-top: 20px;
-        margin-bottom: 10px;
-        color: #2c3e50;
-        border-bottom: 1px solid #eee;
-        padding-bottom: 5px;
-    }
-    .info-container p {
-        margin-bottom: 10px;
-    }
-    .alert {
-        padding: 10px;
-        margin-bottom: 15px;
-        border-radius: 4px;
-    }
-    .alert-warning {
-        background-color: #fcf8e3;
-        border: 1px solid #faebcc;
-        color: #8a6d3b;
-    }
-    </style>
-    """
-    
-    combined_info = f"""
-    {custom_css}
-    <div class="bird-container">
-        <h2>Natural Habitat Map for {clean_top_bird}</h2>
-        <div class="map-container">
-            {habitat_map_html}
-        </div>
-        
-        <div class="info-container">
-            <h2>Detailed Information</h2>
-            {formatted_info}
-        </div>
-    </div>
-    """
-    
-    return prediction_results, combined_info, clean_top_bird
-
-def follow_up_question(question, bird_name):
-    """Allow researchers to ask follow-up questions about the identified bird"""
-    if not question.strip() or not bird_name:
-        return "Please identify a bird first and ask a specific question about it."
-    
-    prompt = f"""
-    The researcher is asking about the {bird_name} bird: "{question}"
-    
-    Provide a detailed, scientific answer focusing on accurate ornithological information. 
-    If the question relates to Tanzania or climate change impacts, emphasize those aspects in your response.
-    
-    IMPORTANT: Do not repeat basic introductory information about the bird that would have already been provided in a general description.
-    Do not start your answer with phrases like "Introduction to the {bird_name}" or similar repetitive headers.
-    Directly answer the specific question asked.
-    
-    Format your response in markdown for better readability.
-    """
-    
-    try:
-        chat_completion = client.chat.completions.create(
-            messages=[
-                {
-                    "role": "user",
-                    "content": prompt,
-                }
-            ],
-            model="llama-3.3-70b-versatile",
-        )
-        return chat_completion.choices[0].message.content
-    except Exception as e:
-        return f"Error fetching information: {str(e)}"
+    pred,pred_idx,probs = learn.predict(img)
+    return {labels[i]: float(probs[i]) for i in range(len(labels))}
 
-# Function to add custom JavaScript for camera switching
-def create_camera_switch_js():
-    return """
-    function switchCamera() {
-        // Get all video elements
-        const videoElements = document.querySelectorAll('video');
-        
-        if (videoElements.length > 0) {
-            const video = videoElements[0];
-            
-            // Stop all tracks on the current stream
-            if (video.srcObject) {
-                const tracks = video.srcObject.getTracks();
-                tracks.forEach(track => track.stop());
-            }
-            
-            // Try to determine current camera type
-            let usingFrontCamera = true;
-            if (window.currentCamera === 'environment') {
-                usingFrontCamera = false;
-            }
-            
-            // Set the new camera type
-            const facingMode = usingFrontCamera ? 'environment' : 'user';
-            window.currentCamera = facingMode;
-            
-            // Request new video stream with the different camera
-            navigator.mediaDevices.getUserMedia({
-                video: { facingMode: facingMode }
-            })
-            .then(function(stream) {
-                video.srcObject = stream;
-                // Play the video
-                video.play();
-            })
-            .catch(function(err) {
-                console.error('Error accessing the camera: ' + err);
-            });
-        } else {
-            console.warn('No video elements found.');
-        }
-    }
-    """
-
-# Create the Gradio interface
-with gr.Blocks(theme=gr.themes.Soft()) as app:
-    gr.Markdown("# Bird Species Identification for Researchers")
-    gr.Markdown("Upload an image to identify bird species and get detailed information relevant to research in Tanzania and climate change studies.")
-    
-    # Store the current bird for context
-    current_bird = gr.State("")
-    
-    # Add custom JavaScript for camera switching
-    app.load(None, None, None, _js=create_camera_switch_js())
-    
-    # Main identification section
-    with gr.Row():
-        with gr.Column(scale=1):
-            input_image = gr.Image(
-                type="pil", 
-                label="Upload Bird Image",
-                source="webcam",  # Enable webcam
-            )
-            camera_toggle = gr.Button("Switch Camera")
-            submit_btn = gr.Button("Identify Bird", variant="primary")
-        
-        with gr.Column(scale=2):
-            prediction_output = gr.Label(label="Top 5 Predictions", num_top_classes=5)
-            bird_info_output = gr.HTML(label="Bird Information")
-    
-    # Clear divider
-    gr.Markdown("---")
-    
-    # Follow-up question section with improved UI
-    gr.Markdown("## Research Questions")
-    
-    conversation_history = gr.Markdown("")
-    
-    with gr.Row():
-        follow_up_input = gr.Textbox(
-            label="Ask a question about this bird", 
-            placeholder="Example: How has climate change affected this bird's migration pattern?",
-            lines=2
-        )
-    
-    with gr.Row():
-        follow_up_btn = gr.Button("Submit Question", variant="primary")
-        clear_btn = gr.Button("Clear Conversation")
-    
-    # Set up event handlers
-    def process_image(img):
-        if img is None:
-            return None, "Please upload an image", "", ""
-        
-        try:
-            pred_results, info, clean_bird_name = predict_and_get_info(img)
-            return pred_results, info, clean_bird_name, ""
-        except Exception as e:
-            return None, f"Error processing image: {str(e)}", "", ""
-    
-    def update_conversation(question, bird_name, history):
-        if not question.strip():
-            return history
-        
-        answer = follow_up_question(question, bird_name)
-        
-        # Format the conversation with clear separation
-        new_exchange = f"""
-### Question:
-{question}
-### Answer:
-{answer}
----
-"""
-        updated_history = new_exchange + history
-        return updated_history
-    
-    def clear_conversation_history():
-        return ""
-    
-    submit_btn.click(
-        process_image,
-        inputs=[input_image],
-        outputs=[prediction_output, bird_info_output, current_bird, conversation_history]
-    )
-    
-    follow_up_btn.click(
-        update_conversation,
-        inputs=[follow_up_input, current_bird, conversation_history],
-        outputs=[conversation_history]
-    ).then(
-        lambda: "", 
-        outputs=follow_up_input
-    )
-    
-    clear_btn.click(
-        clear_conversation_history,
-        outputs=[conversation_history]
-    )
-    
-    # Call the JavaScript function when the camera toggle button is clicked
-    camera_toggle.click(None, None, None, _js="switchCamera")
-
-# Launch the app
-app.launch(share=True)
+import gradio as gr
+gr.Interface(fn=predict, inputs=gr.Image(), outputs=gr.Label(num_top_classes=3)).launch(share=True)