Add AgriSagot BERT API application with demo and API endpoints

README.md

@@ -1,13 +1,57 @@
 ---
-title: Agrisagot Bert
-emoji: 🐠
-colorFrom: red
-colorTo: green
+title: AgriSagot BERT API
+emoji: 🌾
+colorFrom: green
+colorTo: yellow
 sdk: gradio
 sdk_version: 5.49.1
 app_file: app.py
 pinned: false
 license: mit
+tags:
+  - agriculture
+  - bert
+  - recommendations
+  - philippines
+  - farming
+  - crops
+  - diseases
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🌾 AgriSagot BERT Model API
+
+**Philippine Agricultural Recommendation System**
+
+This Hugging Face Space hosts the AgriSagot BERT model for generating agricultural product recommendations based on crop and disease detection.
+
+## Features
+
+- 🎯 **Crop-Disease Recommendations**: Get relevant product suggestions
+- 🔧 **API Endpoints**: Integrate with your applications
+- 📊 **Similarity Calculations**: Compare agricultural text semantically
+- 🌾 **Philippine Context**: Trained on local agricultural data
+
+## Usage
+
+### Demo Interface
+Use the web interface to test recommendations:
+1. Enter crop name (e.g., "rice", "corn", "tomato")
+2. Enter disease/pest (e.g., "blast", "borer", "aphids") 
+3. Get ranked product recommendations
+
+### API Integration
+
+**Get Text Embedding:**
+```bash
+curl -X POST https://hayme-agrisagot-bert.hf.space/api/embedding \
+  -H "Content-Type: application/json" \
+  -d '{"text": "rice blast treatment"}'
+```
+
+## Model Details
+
+- **Base Model**: BERT-base-uncased
+- **Training Data**: Philippine registered agricultural products
+- **Use Case**: Agricultural product recommendations
+- **Languages**: English
+- **License**: MIT

app.py

@@ -0,0 +1,208 @@
+import gradio as gr
+from transformers import AutoTokenizer, AutoModel
+import torch
+import numpy as np
+from sklearn.metrics.pairwise import cosine_similarity
+import json
+
+class AgriSagotBERT:
+    def __init__(self):
+        """Load AgriSagot BERT model"""
+        print("🔄 Loading AgriSagot BERT model...")
+        
+        try:
+            self.tokenizer = AutoTokenizer.from_pretrained('Hayme/agrisago-bert')
+            self.model = AutoModel.from_pretrained('Hayme/agrisago-bert')
+            self.model.eval()
+            print("✅ AgriSagot BERT loaded successfully!")
+        except Exception as e:
+            print(f"⚠️ Custom model failed: {e}")
+            print("🔄 Using fallback model...")
+            self.tokenizer = AutoTokenizer.from_pretrained('sentence-transformers/all-MiniLM-L6-v2')
+            self.model = AutoModel.from_pretrained('sentence-transformers/all-MiniLM-L6-v2')
+            self.model.eval()
+    
+    def get_embedding(self, text):
+        """Get embedding for text"""
+        inputs = self.tokenizer(
+            text, 
+            return_tensors='pt', 
+            padding=True, 
+            truncation=True, 
+            max_length=512
+        )
+        
+        with torch.no_grad():
+            outputs = self.model(**inputs)
+            embedding = outputs.last_hidden_state.mean(dim=1)
+        
+        return embedding.numpy().tolist()[0]
+    
+    def calculate_similarity(self, text1, text2):
+        """Calculate similarity between two texts"""
+        emb1 = np.array(self.get_embedding(text1)).reshape(1, -1)
+        emb2 = np.array(self.get_embedding(text2)).reshape(1, -1)
+        similarity = cosine_similarity(emb1, emb2)[0][0]
+        return float(similarity)
+
+# Initialize model
+bert_model = AgriSagotBERT()
+
+def get_embedding_api(text):
+    """API endpoint for getting embeddings"""
+    try:
+        embedding = bert_model.get_embedding(text)
+        return {
+            "embedding": embedding,
+            "dimension": len(embedding),
+            "success": True
+        }
+    except Exception as e:
+        return {
+            "error": str(e),
+            "success": False
+        }
+
+def calculate_similarity_api(text1, text2):
+    """API endpoint for calculating similarity"""
+    try:
+        similarity = bert_model.calculate_similarity(text1, text2)
+        return {
+            "similarity": similarity,
+            "text1": text1,
+            "text2": text2,
+            "success": True
+        }
+    except Exception as e:
+        return {
+            "error": str(e),
+            "success": False
+        }
+
+def demo_recommendations(crop, disease):
+    """Demo function showing recommendations"""
+    query = f"{crop} {disease} treatment"
+    
+    # Sample products (in real app, this comes from Firebase)
+    products = [
+        "WARDOG 2.5 EC Insecticide for rice pest control",
+        "WARDEN 2.5 EC Cypermethrin insecticide for crops", 
+        "XPressmethrin 5EC Cypermethrin fungicide treatment",
+        "Chix Insecticide 1Liter for farm pest control",
+        "Honda Tractor equipment for rice farming",
+        "Spray equipment for pesticide application"
+    ]
+    
+    results = []
+    query_emb = np.array(bert_model.get_embedding(query)).reshape(1, -1)
+    
+    for product in products:
+        product_emb = np.array(bert_model.get_embedding(product)).reshape(1, -1)
+        similarity = cosine_similarity(query_emb, product_emb)[0][0]
+        results.append((product, float(similarity)))
+    
+    # Sort by similarity
+    results.sort(key=lambda x: x[1], reverse=True)
+    
+    # Format output
+    output = f"🌾 Query: {query}\n\n"
+    output += "🎯 Recommendations (sorted by relevance):\n"
+    output += "="*50 + "\n"
+    
+    for i, (product, score) in enumerate(results, 1):
+        output += f"{i}. {product}\n"
+        output += f"   Similarity: {score:.4f}\n\n"
+    
+    return output
+
+# Create Gradio interface
+with gr.Blocks(title="AgriSagot BERT API", theme=gr.themes.Soft()) as app:
+    gr.Markdown("""
+    # 🌾 AgriSagot BERT Model API
+    **Philippine Agricultural Recommendation System**
+    
+    This Space hosts the AgriSagot BERT model for generating agricultural product recommendations.
+    """)
+    
+    with gr.Tabs():
+        # Demo Tab
+        with gr.TabItem("🎯 Recommendation Demo"):
+            gr.Markdown("### Test the recommendation system")
+            
+            with gr.Row():
+                crop_input = gr.Textbox(
+                    label="Crop",
+                    placeholder="e.g., rice, corn, tomato",
+                    value="rice"
+                )
+                disease_input = gr.Textbox(
+                    label="Disease/Pest", 
+                    placeholder="e.g., blast, borer, aphids",
+                    value="blast"
+                )
+            
+            demo_btn = gr.Button("Get Recommendations", variant="primary")
+            demo_output = gr.Textbox(
+                label="Recommendations",
+                lines=15,
+                max_lines=20
+            )
+            
+            demo_btn.click(
+                demo_recommendations,
+                inputs=[crop_input, disease_input],
+                outputs=demo_output
+            )
+        
+        # API Tab
+        with gr.TabItem("🔧 API Endpoints"):
+            gr.Markdown("""
+            ### API Usage for Your Application
+            
+            **Get Embedding:**
+            ```bash
+            curl -X POST https://your-space-name.hf.space/api/embedding \\
+              -H "Content-Type: application/json" \\
+              -d '{"text": "rice blast treatment"}'
+            ```
+            
+            **Calculate Similarity:**
+            ```bash
+            curl -X POST https://your-space-name.hf.space/api/similarity \\
+              -H "Content-Type: application/json" \\
+              -d '{"text1": "rice blast", "text2": "fungicide treatment"}'
+            ```
+            """)
+            
+            with gr.Row():
+                api_text = gr.Textbox(
+                    label="Text for Embedding",
+                    placeholder="Enter text to get embedding"
+                )
+                api_btn = gr.Button("Get Embedding")
+                api_output = gr.JSON(label="API Response")
+            
+            api_btn.click(
+                get_embedding_api,
+                inputs=api_text,
+                outputs=api_output
+            )
+            
+            with gr.Row():
+                sim_text1 = gr.Textbox(label="Text 1", placeholder="First text")
+                sim_text2 = gr.Textbox(label="Text 2", placeholder="Second text")
+                
+            sim_btn = gr.Button("Calculate Similarity")
+            sim_output = gr.JSON(label="Similarity Result")
+            
+            sim_btn.click(
+                calculate_similarity_api,
+                inputs=[sim_text1, sim_text2],
+                outputs=sim_output
+            )
+
+# Add API routes
+app.queue()
+
+if __name__ == "__main__":
+    app.launch()

requirements.txt

@@ -0,0 +1,6 @@
+torch
+transformers
+gradio
+numpy
+scikit-learn
+requests