Create app.py

app.py

@@ -0,0 +1,208 @@
+import gradio as gr
+import torch
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+from PIL import Image
+import requests
+from io import BytesIO
+import datetime
+import random
+
+# Load a pretrained model from Hugging Face Hub
+model_name = "google/vit-base-patch16-224"  # You can replace this with a food-specific model
+processor = AutoImageProcessor.from_pretrained(model_name)
+model = AutoModelForImageClassification.from_pretrained(model_name)
+
+# Map model outputs to food categories (this would need adjustment based on your specific model)
+food_categories = {
+    0: "fresh_fruits",
+    1: "fresh_vegetables", 
+    2: "spoiled_fruits",
+    3: "spoiled_vegetables",
+    4: "dairy",
+    5: "bakery",
+    6: "meat",
+    7: "other"
+}
+
+# Recipe database
+def get_recipes(food_category, freshness):
+    recipes = {
+        'fresh_fruits': {
+            'fresh': ["Fresh Fruit Salad", "Fruit Smoothie", "Fruit Parfait"],
+            'moderate': ["Baked Fruits", "Fruit Compote", "Fruit Crumble"],
+            'aging': ["Fruit Jam", "Fruit Puree", "Infused Water"],
+            'spoiled': ["Compost", "Dispose responsibly"]
+        },
+        'fresh_vegetables': {
+            'fresh': ["Fresh Salad", "Vegetable Stir-fry", "Crudités"],
+            'moderate': ["Roasted Vegetables", "Vegetable Soup", "Steamed Vegetables"],
+            'aging': ["Vegetable Stock", "Compost", "Puree for Soups"],
+            'spoiled': ["Compost", "Dispose responsibly"]
+        },
+        'dairy': {
+            'fresh': ["Yogurt Parfait", "Cheese Plate", "Milk-based Smoothie"],
+            'moderate': ["Yogurt Marinade", "Pancakes", "Custard"],
+            'aging': ["Yogurt Cheese", "Baking buttermilk", "Cultured butter"],
+            'spoiled': ["Dispose responsibly", "Not recommended for consumption"]
+        },
+        'bakery': {
+            'fresh': ["Fresh Bread with Olive Oil", "Sandwiches", "Bread with Soup"],
+            'moderate': ["Croutons", "Bread Pudding", "French Toast"],
+            'aging': ["Bread Crumbs", "Bread-based Stuffing", "Bread Salad"],
+            'spoiled': ["Compost", "Bird Feed", "Dispose responsibly"]
+        },
+        'meat': {
+            'fresh': ["Grilled Meat", "Stew", "Stir-fry"],
+            'moderate': ["Slow-cooked Dish", "Meat Sauce", "Pot Pie"],
+            'aging': ["Not recommended for consumption", "Dispose responsibly"],
+            'spoiled': ["Dispose responsibly", "Not safe for consumption"]
+        },
+        'other': {
+            'fresh': ["Use soon", "Store properly"],
+            'moderate': ["Consider using in cooked dishes", "Check for signs of spoilage"],
+            'aging': ["Compost if possible", "Dispose responsibly"],
+            'spoiled': ["Dispose responsibly", "Not safe for consumption"]
+        }
+    }
+    
+    return recipes.get(food_category, {}).get(freshness, ["No recipes available"])
+
+# Waste log
+waste_log = []
+
+def predict_image(image):
+    # Preprocess the image
+    inputs = processor(images=image, return_tensors="pt")
+    
+    # Make prediction
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+        predicted_class_idx = logits.argmax(-1).item()
+        
+        # Get confidence scores
+        probabilities = torch.nn.functional.softmax(logits, dim=1)[0]
+        confidence_score = probabilities[predicted_class_idx].item()
+    
+    # Map to food category (this is a simplification - you'd need to adjust based on your model)
+    food_category = food_categories.get(predicted_class_idx % len(food_categories), "other")
+    
+    # Determine freshness based on confidence and category (this is a heuristic)
+    if confidence_score > 0.8:
+        freshness = 'fresh'
+        days_remaining = random.randint(3, 7)
+    elif confidence_score > 0.5:
+        freshness = 'moderate'
+        days_remaining = random.randint(1, 3)
+    else:
+        freshness = 'aging'
+        days_remaining = random.randint(0, 1)
+    
+    # Special handling for categories that might indicate spoilage
+    if 'spoiled' in food_category:
+        freshness = 'spoiled'
+        days_remaining = 0
+    
+    # Get recipe suggestions
+    recipes = get_recipes(food_category, freshness)
+    
+    # Format results
+    result_html = f"""
+    <div style='padding: 10px; border-radius: 5px; background-color: #f0f8ff; margin-bottom: 10px;'>
+        <h3>Analysis Results</h3>
+        <p><b>Category:</b> {food_category.replace('_', ' ').title()}</p>
+        <p><b>Freshness:</b> {freshness.title()}</p>
+        <p><b>Confidence:</b> {confidence_score*100:.1f}%</p>
+        <p><b>Days Remaining:</b> {days_remaining}</p>
+    </div>
+    """
+    
+    # Format recipes
+    recipes_html = "<h3>Recipe Suggestions</h3><ul>"
+    for recipe in recipes:
+        recipes_html += f"<li>{recipe}</li>"
+    recipes_html += "</ul>"
+    
+    # Environmental impact
+    impact_html = f"""
+    <div style='padding: 10px; border-radius: 5px; background-color: #e8f5e9; margin-top: 10px;'>
+        <h3>Environmental Impact</h3>
+        <p>By properly managing this {food_category.replace('_', ' ')}, you could save approximately {random.uniform(0.1, 0.5):.2f} kg CO2 emissions.</p>
+        <p>Consider composting if the food is no longer edible.</p>
+    </div>
+    """
+    
+    # Add to waste log
+    waste_log.append({
+        "item": food_category.replace('_', ' ').title(),
+        "category": food_category,
+        "date": datetime.datetime.now().strftime("%Y-%m-%d"),
+        "freshness": freshness,
+        "action": "analyzed",
+        "confidence": f"{confidence_score*100:.1f}%"
+    })
+    
+    return result_html + recipes_html + impact_html
+
+def update_waste_log():
+    if not waste_log:
+        return "<h3>No waste entries yet. Upload an image to get started!</h3>"
+    
+    log_html = "<h3>Recent Waste Log</h3><table style='width:100%; border-collapse: collapse;'>"
+    log_html += "<tr style='background-color: #f2f2f2;'><th>Item</th><th>Category</th><th>Date</th><th>Freshness</th><th>Confidence</th></tr>"
+    
+    for entry in waste_log[-5:]:  # Show last 5 entries
+        log_html += f"<tr><td>{entry['item']}</td><td>{entry['category']}</td><td>{entry['date']}</td><td>{entry['freshness']}</td><td>{entry['confidence']}</td></tr>"
+    
+    log_html += "</table>"
+    
+    # Statistics
+    fresh_count = sum(1 for entry in waste_log if entry['freshness'] == 'fresh')
+    moderate_count = sum(1 for entry in waste_log if entry['freshness'] == 'moderate')
+    aging_count = sum(1 for entry in waste_log if entry['freshness'] == 'aging')
+    spoiled_count = sum(1 for entry in waste_log if entry['freshness'] == 'spoiled')
+    
+    stats_html = f"""
+    <div style='margin-top: 20px;'>
+        <h3>Waste Statistics</h3>
+        <p>Fresh Items: {fresh_count}</p>
+        <p>Moderate Freshness: {moderate_count}</p>
+        <p>Aging Items: {aging_count}</p>
+        <p>Spoiled Items: {spoiled_count}</p>
+    </div>
+    """
+    
+    return log_html + stats_html
+
+# Create Gradio interface
+with gr.Blocks(title="Food Waste Manager", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🍃 Smart Food Waste Manager")
+    gr.Markdown("Upload an image of food to analyze its freshness and get recipe suggestions to reduce waste!")
+    
+    with gr.Row():
+        with gr.Column():
+            image_input = gr.Image(label="Upload Food Image", type="pil")
+            analyze_btn = gr.Button("Analyze Food", variant="primary")
+        
+        with gr.Column():
+            analysis_output = gr.HTML(label="Analysis Results")
+    
+    with gr.Row():
+        waste_log_output = gr.HTML()
+    
+    # Set up event handlers
+    analyze_btn.click(
+        fn=predict_image,
+        inputs=image_input,
+        outputs=analysis_output
+    ).then(
+        fn=update_waste_log,
+        inputs=None,
+        outputs=waste_log_output
+    )
+    
+    # Initialize waste log
+    demo.load(update_waste_log, None, waste_log_output)
+
+if __name__ == "__main__":
+    demo.launch()