Complete history cleanup and model removal

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

DEPLOYMENT_GUIDE.md

@@ -0,0 +1,285 @@
+# Hugging Face Spaces Deployment Guide
+
+## Quick Start for Download-at-Runtime
+
+This guide walks you through deploying your WASH CFM Topic Classifier to Hugging Face Spaces using the Download-at-Runtime strategy.
+
+## Prerequisites
+
+1. ✅ Your model files are ready (`.safetensors`, config files, tokenizer files)
+2. ✅ You have a Hugging Face account
+3. ✅ You've created a public model repository on Hugging Face Hub
+
+## Step 1: Upload Model to Hugging Face Hub
+
+### 1.1 Create Model Repository
+
+1. Go to [huggingface.co/new](https://huggingface.co/new)
+2. Select **"Model"** tab
+3. Repository name: `wash-cfm-classifier` (or your preferred name)
+4. Make it **Public** (required for Spaces)
+5. Click **"Create a new model"**
+
+### 1.2 Upload Model Files
+
+Upload these files to your repository:
+
+```
+📁 wash-cfm-classifier/
+├── model.safetensors          (~400-500MB)
+├── config.json                (~1KB)
+├── tokenizer.json            (~2-3MB)
+├── tokenizer_config.json     (~1KB)
+└── special_tokens_map.json   (~1KB)
+```
+
+**Methods to upload:**
+- **Web Interface**: Drag and drop files
+- **Git LFS**: For command-line users
+- **Python Script**: Use `huggingface_hub` library
+
+### 1.3 Add Model Card (Optional but Recommended)
+
+Create a `README.md` in your repository:
+
+```markdown
+# WASH CFM Topic Classifier
+
+A fine-tuned ModernBERT model for classifying WASH (Water, Sanitation, and Hygiene) feedback into topic categories.
+
+## Usage
+
+```python
+from transformers import pipeline
+
+classifier = pipeline("text-classification", 
+                     model="your-username/wash-cfm-classifier")
+result = classifier("The water pump is broken")
+```
+
+## Model Details
+
+- **Base Model**: modernbert-large
+- **Fine-tuned on**: WASH CFM feedback data
+- **Task**: Multi-label text classification
+- **Labels**: [Add your actual labels]
+```
+
+## Step 2: Update Your Application Code
+
+### 2.1 Configuration
+
+In `app.py`, update the configuration section:
+
+```python
+# CONFIGURATION SECTION
+HF_REPO_ID = "your-username/wash-cfm-classifier"  # ← Replace with your repo
+HF_MODEL_CACHE_DIR = "./model_cache"  # Cache directory
+```
+
+### 2.2 Verify Dependencies
+
+Ensure `requirements.txt` includes:
+
+```txt
+huggingface_hub>=0.16.0
+torch>=2.0.0
+transformers>=4.30.0
+gradio>=4.0.0
+```
+
+## Step 3: Create Hugging Face Space
+
+### 3.1 Create New Space
+
+1. Go to [huggingface.co/spaces](https://huggingface.co/spaces)
+2. Click **"Create new Space"**
+3. Fill in details:
+   - **Space name**: `wash-cfm-classifier` (or your choice)
+   - **License**: `apache-2.0` (or your preference)
+   - **Hardware**: `CPU basic` (sufficient for this model)
+   - **Visibility**: `Public`
+
+### 3.2 Choose SDK
+
+Select **"Gradio"** as your SDK.
+
+### 3.3 Upload Files
+
+Upload these files to your Space repository:
+
+```
+📁 wash-cfm-classifier-space/
+├── app.py                    # Your main application
+├── requirements.txt          # Dependencies
+├── README.md                 # Space documentation
+└── .gitattributes           # Optional: for large file handling
+```
+
+## Step 4: Space Configuration
+
+### 4.1 Hardware Recommendations
+
+For your model size (~500MB):
+
+- **CPU Basic**: ✅ Sufficient (free tier)
+- **CPU Upgrade**: ⚡ Faster inference
+- **GPU**: 🚀 Only if needed for larger models
+
+### 4.2 Environment Variables (Optional)
+
+In Space Settings → Environment, add:
+
+```
+HF_HOME=/tmp/.cache/huggingface
+TRANSFORMERS_CACHE=/tmp/.cache/transformers
+```
+
+This ensures cache directories have sufficient space.
+
+### 4.3 Build Logs
+
+Monitor the **"Logs"** tab for:
+- ✅ Successful dependency installation
+- ✅ Model download progress
+- ✅ Application startup
+
+## Step 5: Testing and Validation
+
+### 5.1 First Run
+
+The first run will:
+1. **Install dependencies** (~2-3 minutes)
+2. **Download model** (~1-2 minutes, depending on connection)
+3. **Start application** (~30 seconds)
+
+**Expected timeline**: 5-7 minutes for first successful run.
+
+### 5.2 Subsequent Runs
+
+After caching:
+- **Startup time**: ~10-15 seconds
+- **Prediction time**: <1 second per request
+
+### 5.3 Verification Checklist
+
+- [ ] Space builds successfully (green ✅ in status)
+- [ ] Model downloads without errors
+- [ ] Web interface loads
+- [ ] Sample predictions work
+- [ ] Performance is acceptable
+
+## Step 6: Optimization and Monitoring
+
+### 6.1 Performance Monitoring
+
+Monitor these metrics:
+- **Build time**: First deployment duration
+- **Download time**: Model download duration
+- **Inference time**: Response latency
+- **Memory usage**: RAM consumption
+
+### 6.2 Common Issues and Solutions
+
+#### Issue: "Model download timeout"
+```bash
+# Solution: Use faster hardware tier or optimize cache
+HF_MODEL_CACHE_DIR = "/tmp/model_cache"
+```
+
+#### Issue: "Out of memory"
+```bash
+# Solution: Use smaller hardware or optimize model loading
+device = torch.device("cpu")  # Force CPU if GPU memory insufficient
+```
+
+#### Issue: "Repository not found"
+```python
+# Solution: Verify repository ID and visibility
+HF_REPO_ID = "exact-username/exact-repo-name"  # Case sensitive
+```
+
+### 6.3 Space Management
+
+**Regular maintenance:**
+- Monitor disk usage in cache directory
+- Update model versions by changing repository revision
+- Scale hardware based on usage patterns
+
+**Version updates:**
+- Update model in your Hub repository
+- Space automatically uses latest version (or specify revision)
+
+## Step 7: Production Considerations
+
+### 7.1 Security
+
+- ✅ Use public repositories for Spaces
+- ✅ Validate model integrity
+- ✅ Implement proper error handling
+- ✅ Monitor for unusual access patterns
+
+### 7.2 Reliability
+
+- ✅ Implement retry logic for downloads
+- ✅ Add fallback mechanisms
+- ✅ Monitor network connectivity
+- ✅ Set up alerts for failures
+
+### 7.3 Scalability
+
+- **Multiple Spaces**: Same model, different interfaces
+- **Load Balancing**: Distribute across multiple hardware tiers
+- **Caching Strategy**: Optimize for your usage patterns
+
+## Troubleshooting Guide
+
+### Build Failures
+
+| Error | Solution |
+|-------|----------|
+| `pip install failed` | Check requirements.txt syntax |
+| `torch install failed` | Verify Python version compatibility |
+| `Memory limit exceeded` | Reduce model size or upgrade hardware |
+
+### Runtime Failures
+
+| Error | Solution |
+|-------|----------|
+| `Download interrupted` | Network issues - will auto-resume |
+| `Model not found` | Verify repository ID and visibility |
+| `CUDA out of memory` | Use CPU fallback or upgrade hardware |
+
+### Performance Issues
+
+| Issue | Solution |
+|-------|----------|
+| Slow first run | Normal - model download required |
+| High memory usage | Consider hardware upgrade |
+| Slow predictions | Optimize model or upgrade hardware |
+
+## Success Metrics
+
+Your deployment is successful when:
+
+- ✅ Space builds without errors
+- ✅ Model downloads and loads successfully
+- ✅ Web interface is responsive
+- ✅ Predictions are accurate and fast
+- ✅ Resource usage is within limits
+
+## Next Steps
+
+1. **Monitor Performance**: Track usage and optimize as needed
+2. **User Feedback**: Collect feedback and iterate
+3. **Feature Updates**: Add new features or model improvements
+4. **Scaling**: Consider multiple spaces or hardware upgrades
+
+---
+
+**🎉 Congratulations!** Your WASH CFM Topic Classifier is now deployed to Hugging Face Spaces with Download-at-Runtime functionality, bypassing the 1GB storage limit while maintaining excellent performance.
+
+For additional help, consult:
+- [Hugging Face Spaces Documentation](https://huggingface.co/docs/spaces)
+- [huggingface_hub Documentation](https://huggingface.co/docs/huggingface_hub)
+- [Community Forum](https://discuss.huggingface.co/)

HF_DOWNLOAD_STRATEGY.md

@@ -0,0 +1,272 @@
+# Hugging Face Download-at-Runtime Strategy
+
+## Overview
+
+This document explains how to implement a "Download at Runtime" strategy for your WASH CFM Topic Classifier model using `huggingface_hub`. This approach allows you to bypass the 1GB storage limit in Hugging Face Spaces by hosting your model in a separate Hugging Face repository and downloading it at runtime.
+
+## Why Use Download-at-Runtime?
+
+1. **Space Constraint Resolution**: Hugging Face Spaces have a 1GB storage limit for uploaded files
+2. **Model Reusability**: Host your model once and reuse it across multiple applications
+3. **Version Control**: Leverage Hugging Face's built-in version control for model updates
+4. **Efficient Caching**: Models are cached locally after first download
+5. **Scalability**: Easy to update models without redeploying the entire Space
+
+## Implementation Details
+
+### Key Components
+
+#### 1. Dependencies
+The implementation requires `huggingface_hub>=0.16.0` added to your requirements:
+
+```txt
+huggingface_hub>=0.16.0
+```
+
+#### 2. Configuration
+Configure your Hugging Face repository details at the top of `app.py`:
+
+```python
+# CONFIGURATION SECTION
+HF_REPO_ID = "your-username/wash-cfm-classifier"  # Your model repository
+HF_MODEL_CACHE_DIR = "./model_cache"  # Local cache directory
+```
+
+#### 3. Download Function
+The core download logic uses `snapshot_download()` from `huggingface_hub`:
+
+```python
+from huggingface_hub import snapshot_download
+
+model_path = snapshot_download(
+    repo_id=HF_REPO_ID,
+    cache_dir=HF_MODEL_CACHE_DIR,
+    resume_download=True,      # Resume interrupted downloads
+    local_files_only=False     # Force download if not cached
+)
+```
+
+### Key Features
+
+1. **Intelligent Caching**: 
+   - Models are cached in `HF_MODEL_CACHE_DIR`
+   - Subsequent runs use cached versions
+   - No repeated downloads
+
+2. **Resume Capability**: 
+   - `resume_download=True` handles interrupted downloads
+   - Useful for large models and unstable connections
+
+3. **Error Handling**: 
+   - Comprehensive error messages for troubleshooting
+   - Network connectivity checks
+   - Repository access validation
+
+4. **Performance Optimization**:
+   - LRU caching prevents model reloading
+   - Device-aware inference (CPU/GPU/MPS)
+
+## Step-by-Step Implementation
+
+### Step 1: Upload Your Model to Hugging Face
+
+1. **Create a Hugging Face Account** (if you don't have one)
+2. **Create a New Model Repository**:
+   - Go to https://huggingface.co/new
+   - Name it appropriately (e.g., `your-username/wash-cfm-classifier`)
+   - Make it **Public** (required for Spaces)
+   - Upload your model files:
+     - `model.safetensors`
+     - `config.json`
+     - `tokenizer.json`
+     - `tokenizer_config.json`
+     - `special_tokens_map.json`
+
+### Step 2: Update Configuration
+
+Edit the configuration section in `app.py`:
+
+```python
+HF_REPO_ID = "your-username/wash-cfm-classifier"  # Replace with your actual repo
+```
+
+### Step 3: Install Dependencies
+
+Add to your `requirements.txt`:
+
+```txt
+huggingface_hub>=0.16.0
+```
+
+### Step 4: Deploy to Hugging Face Space
+
+1. **Create or update your Hugging Face Space**
+2. **Upload your modified files** (app.py with download logic)
+3. **The Space will automatically**:
+   - Install dependencies from requirements.txt
+   - Download the model on first run
+   - Cache it for subsequent runs
+
+## How It Works
+
+### First Run
+```
+1. User accesses the Space
+2. app.py imports huggingface_hub
+3. load_model() function calls snapshot_download()
+4. Model downloads from Hugging Face Hub (~500MB)
+5. Model loads into memory
+6. First prediction takes longer (download + load time)
+```
+
+### Subsequent Runs
+```
+1. User accesses the Space
+2. load_model() function checks cache
+3. Model loads from local cache (~5-10 seconds)
+4. Predictions are fast
+```
+
+## Benefits vs Local Storage
+
+| Aspect | Local Storage | Download-at-Runtime |
+|--------|---------------|---------------------|
+| **Initial Load Time** | Instant | 30-60 seconds (first run) |
+| **Subsequent Runs** | Instant | Fast (cached) |
+| **Space Usage** | Counts toward 1GB limit | Minimal (just cache) |
+| **Model Updates** | Manual reupload | Automatic from repo |
+| **Scalability** | Limited by Space size | Unlimited |
+
+## Troubleshooting
+
+### Common Issues and Solutions
+
+1. **Repository Not Found**
+   ```
+   Error: Repository 'username/repo-name' not found
+   Solution: Verify repo ID and ensure repository is public
+   ```
+
+2. **Download Timeout**
+   ```
+   Error: Download interrupted
+   Solution: The resume_download=True handles this automatically
+   ```
+
+3. **Authentication Issues**
+   ```
+   Error: Access denied
+   Solution: Ensure repository is public or use access tokens
+   ```
+
+4. **Disk Space**
+   ```
+   Error: No space left on device
+   Solution: Clean cache or use external storage
+   ```
+
+### Debug Commands
+
+To test your setup locally:
+
+```python
+from huggingface_hub import snapshot_download
+
+# Test download
+path = snapshot_download(
+    repo_id="your-username/wash-cfm-classifier",
+    cache_dir="./test_cache"
+)
+print(f"Model downloaded to: {path}")
+```
+
+## Advanced Options
+
+### 1. Progressive Loading
+For very large models, consider loading components separately:
+
+```python
+from huggingface_hub import hf_hub_download
+
+# Download individual files
+config_path = hf_hub_download(
+    repo_id=HF_REPO_ID,
+    filename="config.json",
+    cache_dir=HF_MODEL_CACHE_DIR
+)
+```
+
+### 2. Custom Cache Location
+Use persistent storage for Hugging Face Spaces:
+
+```python
+# Use /tmp or mounted storage for better persistence
+HF_MODEL_CACHE_DIR = "/tmp/model_cache"
+```
+
+### 3. Model Versioning
+Pin specific model versions:
+
+```python
+from huggingface_hub import snapshot_download
+
+model_path = snapshot_download(
+    repo_id=HF_REPO_ID,
+    revision="v1.0",  # Specific version
+    cache_dir=HF_MODEL_CACHE_DIR
+)
+```
+
+## Performance Considerations
+
+### First Run Optimization
+- **Download Time**: 30-60 seconds for ~500MB model
+- **Load Time**: 10-15 seconds for model initialization
+- **Total**: ~1-2 minutes for first prediction
+
+### Cached Run Performance
+- **Load Time**: 5-10 seconds (from cache)
+- **Prediction**: <1 second per inference
+
+### Memory Usage
+- **Model Loading**: ~2-3GB RAM during inference
+- **Cached Storage**: ~500MB disk space
+- **Peak Usage**: Higher during initial download
+
+## Best Practices
+
+1. **Repository Setup**:
+   - Use clear, descriptive repository names
+   - Include model cards (README.md) with usage instructions
+   - Tag releases for version control
+
+2. **Error Handling**:
+   - Implement graceful fallbacks
+   - Provide clear error messages to users
+   - Log download progress for debugging
+
+3. **User Experience**:
+   - Show download progress indicators
+   - Cache models efficiently
+   - Handle network failures gracefully
+
+4. **Security**:
+   - Use public repositories for Spaces
+   - Validate model integrity
+   - Implement proper access controls
+
+## Conclusion
+
+The Download-at-Runtime strategy successfully addresses the Hugging Face Spaces 1GB limit by:
+
+✅ **Eliminating storage constraints**  
+✅ **Enabling model reuse across applications**  
+✅ **Providing efficient caching mechanisms**  
+✅ **Maintaining good performance after initial setup**  
+✅ **Offering built-in version control**
+
+This approach is ideal for production applications where model size exceeds Space limits but network connectivity is reliable.
+
+---
+
+*For questions or issues, refer to the [huggingface_hub documentation](https://huggingface.co/docs/huggingface_hub/index) or create an issue in your repository.*

Pipfile

@@ -0,0 +1,16 @@
+[[source]]
+url = "https://pypi.org/simple"
+verify_ssl = true
+name = "pypi"
+
+[packages]
+torch = ">=2.0.0"
+transformers = ">=4.30.0"
+gradio = ">=4.0.0"
+huggingface-hub = "*"
+
+[dev-packages]
+
+[requires]
+python_version = "3.11"
+python_full_version = "3.11.4"

README.md

@@ -0,0 +1,98 @@
+---
+title: Cfm Topic Classifier
+emoji: 😻
+colorFrom: green
+colorTo: green
+sdk: gradio
+sdk_version: 6.2.0
+app_file: app.py
+pinned: false
+short_description: ModernBERT encoder model fine-tuned on CFM topics
+---
+
+# 💧 WASH CFM Topic Classifier
+
+A Gradio web application for classifying WASH (Water, Sanitation, and Hygiene) feedback into relevant topic categories using a fine-tuned ModernBERT model.
+
+## Features
+
+- **Topic Classification**: Automatically classifies WASH feedback into relevant topic categories
+- **ModernBERT Integration**: Uses a fine-tuned ModernBERT-large model for accurate classification
+- **Multi-Device Support**: Automatically detects and utilizes the best available device:
+  - Apple Silicon (MPS)
+  - NVIDIA GPU (CUDA)
+  - CPU fallback
+- **Top-K Predictions**: Shows the top 2 most probable topics with confidence scores
+- **Interactive Interface**: User-friendly Gradio interface with real-time classification
+- **Input Validation**: Validates input and provides helpful error messages
+
+## Installation
+
+1. Clone or download this repository
+2. Install the required dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+3. Ensure the model files are available in the `./wash_cfm_classifier/` directory
+
+## Usage
+
+1. Run the application:
+
+```bash
+python app.py
+```
+
+2. Open your web browser and navigate to `http://localhost:7860`
+
+3. Enter WASH feedback text in the input box (e.g., "The water pump in our area has been broken for 3 days...")
+
+4. Click "Submit" to get topic predictions with confidence scores
+
+5. Use the "Clear" button to reset the interface
+
+## Requirements
+
+- Python 3.7+
+- torch>=2.0.0
+- transformers>=4.30.0  
+- gradio>=4.0.0
+
+## Technical Details
+
+- **Model**: Fine-tuned ModernBERT-large for sequence classification
+- **Framework**: Gradio for web interface
+- **Device Support**: Automatic device detection (MPS/CUDA/CPU)
+- **Caching**: LRU cache for model loading to improve performance
+- **Output Format**: HTML-formatted results with confidence percentages
+
+## Example Input/Output
+
+**Input**: "The water pump in our area has been broken for 3 days and we need access to clean water"
+
+**Output**: 
+1. **Water Supply** - Confidence: 95.2%
+2. **Infrastructure** - Confidence: 87.1%
+
+## Error Handling
+
+- Validates empty or whitespace-only input
+- Handles missing model files gracefully
+- Provides detailed error messages for troubleshooting
+
+## Configuration
+
+- **Server Address**: `0.0.0.0` (all interfaces)
+- **Port**: `7860`
+- **Model Path**: `./wash_cfm_classifier/`
+- **Top-K Predictions**: `2`
+
+## License
+
+UNICEF WASH Cluster CFM System
+
+---
+
+*Powered by ModernBERT-large | UNICEF WASH Cluster CFM System*

app.py

@@ -0,0 +1,297 @@
+"""
+WASH CFM Topic Classification Gradio Application
+
+This application provides a user interface for classifying WASH (Water, Sanitation,
+and Hygiene) feedback using a fine-tuned ModernBERT model.
+
+This is a Gradio implementation with identical functionality to wash_cfm_app.py.
+"""
+
+import gradio as gr
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
+from huggingface_hub import snapshot_download, hf_hub_download
+import functools
+import os
+import tempfile
+
+# ================================
+# CONFIGURATION SECTION
+# ================================
+# Replace these with your actual Hugging Face repository details
+HF_REPO_ID = "ibagur/wash_cfm_classifier"  # Your Hugging Face repository
+HF_MODEL_CACHE_DIR = "/tmp/model_cache"  # Cache directory (using /tmp for better Space compatibility)
+# ================================
+
+
+@functools.lru_cache(maxsize=1)
+def load_model():
+    """
+    Load the pre-trained WASH CFM classifier model from Hugging Face Hub and create a pipeline.
+    Downloads the model at runtime if not already cached locally.
+    Uses LRU cache to avoid reloading on every interaction.
+
+    Returns:
+        pipeline: Hugging Face transformers pipeline for text classification
+    """
+    print(f"Downloading model from Hugging Face Hub: {HF_REPO_ID}")
+    print("This may take a few minutes on first run...")
+    
+    try:
+        # Download the entire model repository to cache
+        # This is more efficient than downloading individual files
+        model_path = snapshot_download(
+            repo_id=HF_REPO_ID,
+            cache_dir=HF_MODEL_CACHE_DIR,
+            resume_download=True,  # Resume if download was interrupted
+            local_files_only=False  # Force download if not in cache
+        )
+        
+        print(f"Model downloaded successfully to: {model_path}")
+        
+        # Load tokenizer and model from the downloaded path
+        tokenizer = AutoTokenizer.from_pretrained(model_path)
+        model = AutoModelForSequenceClassification.from_pretrained(model_path)
+
+        # Set to evaluation mode
+        model.eval()
+
+        # Check what device we're using (including Apple Silicon MPS support)
+        if torch.backends.mps.is_available():
+            device = torch.device("mps")  # Apple Silicon
+        elif torch.cuda.is_available():
+            device = torch.device("cuda")  # NVIDIA GPU
+        else:
+            device = torch.device("cpu")  # CPU fallback
+
+        print(f"Using device: {device}")
+
+        model.to(device)
+
+        # Create pipeline for easy inference
+        classifier = pipeline(
+            'text-classification',
+            model=model,
+            tokenizer=tokenizer,
+            device=device
+        )
+
+        return classifier
+        
+    except Exception as e:
+        print(f"Error downloading model: {str(e)}")
+        print("\nTroubleshooting steps:")
+        print("1. Check that your repository ID is correct")
+        print("2. Ensure the repository is public or you have proper access")
+        print("3. Check your internet connection")
+        print("4. Verify the repository exists on Hugging Face Hub")
+        raise
+
+
+def predict_topics(text, classifier, top_k=2):
+    """
+    Predict the top-k most probable topics for the given text using the pipeline.
+
+    Args:
+        text (str): Input feedback text
+        classifier: Hugging Face transformers pipeline
+        top_k (int): Number of top predictions to return
+
+    Returns:
+        list: List of tuples (topic_name, probability)
+    """
+    # Use pipeline for prediction - it handles all the complexity internally
+    predictions = classifier(text, top_k=top_k)
+    
+    # Convert pipeline results to our format
+    results = [(pred['label'], pred['score']) for pred in predictions]
+    
+    return results
+
+
+def classify_feedback(text):
+    """
+    Main classification handler for Gradio interface.
+
+    Args:
+        text (str): Input WASH feedback text
+
+    Returns:
+        str: HTML formatted prediction results
+    """
+    # Validate input
+    if not text or not text.strip():
+        return """
+        <div style="
+            background-color: #fff3cd;
+            color: #856404;
+            padding: 15px;
+            border-radius: 8px;
+            border-left: 4px solid #ffc107;
+            font-weight: 500;
+        ">
+            ⚠️ Please enter some feedback text.
+        </div>
+        """
+
+    try:
+        # Load classifier pipeline (cached)
+        classifier = load_model()
+
+        # Get predictions
+        predictions = predict_topics(
+            text,
+            classifier,
+            top_k=2
+        )
+
+        # Format results as HTML
+        html_output = """
+        <div style="margin-top: 10px;">
+            <h3 style="color: #333; margin-bottom: 15px;">📊 Predicted Topics</h3>
+        """
+
+        for i, (topic, probability) in enumerate(predictions, 1):
+            # Add prediction box with fixed color
+            html_output += f"""
+            <div style="
+                background-color: #009999;
+                color: #ffffff;
+                padding: 15px;
+                border-radius: 8px;
+                margin-bottom: 10px;
+                font-weight: 500;
+            ">
+                <div style="font-size: 16px; margin-bottom: 5px;">
+                    {i}. {topic}
+                </div>
+                <div style="font-size: 14px; opacity: 0.9;">
+                    Confidence: {probability:.1%}
+                </div>
+            </div>
+            """
+
+        html_output += "</div>"
+        return html_output
+
+    except FileNotFoundError:
+        return """
+        <div style="
+            background-color: #f8d7da;
+            color: #721c24;
+            padding: 15px;
+            border-radius: 8px;
+            border-left: 4px solid #dc3545;
+        ">
+            <strong>❌ Error loading model</strong><br>
+            Could not download or access the model from Hugging Face Hub.<br>
+            Please check your internet connection and repository configuration.
+        </div>
+        """
+    except Exception as e:
+        return f"""
+        <div style="
+            background-color: #f8d7da;
+            color: #721c24;
+            padding: 15px;
+            border-radius: 8px;
+            border-left: 4px solid #dc3545;
+        ">
+            <strong>❌ Error during prediction:</strong><br>
+            {str(e)}
+        </div>
+        """
+
+
+def clear_inputs():
+    """
+    Clear both input and output fields.
+
+    Returns:
+        tuple: Empty strings for textbox and output
+    """
+    return "", ""
+
+
+def create_interface():
+    """
+    Create and configure the Gradio interface.
+
+    Returns:
+        gr.Blocks: Configured Gradio interface
+    """
+    with gr.Blocks(
+        title="WASH CFM Topic Classifier",
+        theme=gr.themes.Soft()
+    ) as demo:
+        # Header
+        gr.Markdown("""
+        # 💧 WASH CFM Topic Classifier
+
+        This application classifies WASH (Water, Sanitation, and Hygiene) feedback
+        into relevant topic categories using a fine-tuned ModernBERT model.
+
+        **Enter your feedback below and click Submit.**
+        """)
+
+        # Input section
+        input_textbox = gr.Textbox(
+            label="Enter WASH feedback:",
+            placeholder="Example: The water pump in our area has been broken for 3 days...",
+            lines=6,
+            interactive=True
+        )
+
+        # Button row
+        with gr.Row():
+            submit_btn = gr.Button("➜ Submit", variant="primary", scale=2)
+            clear_btn = gr.Button("🗑️ Clear", scale=1)
+
+        # Output section
+        output_html = gr.HTML(label="Results")
+
+        # Footer
+        gr.Markdown("""
+        ---
+        <div style="text-align: center; color: #666; font-size: 12px;">
+            Powered by ModernBERT-large | UNICEF WASH Cluster CFM System
+        </div>
+        """)
+
+        # Event handlers
+        submit_btn.click(
+            fn=classify_feedback,
+            inputs=input_textbox,
+            outputs=output_html
+        )
+
+        input_textbox.submit(
+            fn=classify_feedback,
+            inputs=input_textbox,
+            outputs=output_html
+        )
+
+        clear_btn.click(
+            fn=clear_inputs,
+            inputs=None,
+            outputs=[input_textbox, output_html]
+        )
+
+    return demo
+
+
+def main():
+    """
+    Main function to launch the Gradio application.
+    """
+    demo = create_interface()
+
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,9 @@
+# WASH CFM Topic Classification Gradio Application Dependencies
+
+# Core ML and NLP libraries
+torch>=2.0.0
+transformers>=4.30.0
+huggingface_hub>=0.16.0
+
+# Web UI framework
+gradio>=4.0.0