Upload 8 files

.gitignore

@@ -0,0 +1 @@
+venv/

DEPLOYMENT_GUIDE.md

@@ -0,0 +1,116 @@
+# Hugging Face Spaces Deployment Guide
+
+## Steps to Deploy on Hugging Face Spaces
+
+### 1. Create a New Space
+1. Go to [Hugging Face Spaces](https://huggingface.co/new-space)
+2. Choose a name for your space (e.g., `content-classifier`)
+3. Select **Docker** as the SDK
+4. Set the space to **Public** or **Private** as needed
+5. Click **Create Space**
+
+### 2. Upload Files to Your Space
+
+You need to upload these files to your Space repository:
+
+```
+contextClassifier.onnx    # Your ONNX model
+app.py                   # FastAPI application
+requirements.txt         # Python dependencies
+Dockerfile              # Docker configuration
+README.md               # This will become the Space's README
+```
+
+### 3. Required Files Content
+
+**For the Space's README.md header, add this at the top:**
+```yaml
+---
+title: Content Classifier
+emoji: 🔍
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+license: mit
+app_port: 7860
+---
+```
+
+### 4. Deployment Process
+
+1. **Via Git (Recommended):**
+   ```bash
+   git clone https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+   cd YOUR_SPACE_NAME
+   
+   # Copy your files
+   copy contextClassifier.onnx .
+   copy app.py .
+   copy requirements.txt .
+   copy Dockerfile .
+   
+   # Commit and push
+   git add .
+   git commit -m "Add content classifier API"
+   git push
+   ```
+
+2. **Via Web Interface:**
+   - Use the **Files** tab in your Space
+   - Upload each file individually
+   - Or drag and drop all files at once
+
+### 5. Monitor Deployment
+
+1. Go to your Space URL: `https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME`
+2. Check the **Logs** tab to monitor the build process
+3. The Space will show "Building" status during deployment
+4. Once ready, you'll see the API documentation interface
+
+### 6. Access Your API
+
+Once deployed, your API will be available at:
+- **Swagger UI:** `https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space/docs`
+- **API Endpoints:**
+  - `POST /predict` - Main prediction endpoint
+  - `GET /health` - Health check
+  - `GET /model-info` - Model information
+
+### 7. Example Usage
+
+```python
+import requests
+
+# Replace with your actual Space URL
+api_url = "https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space"
+
+# Make a prediction
+response = requests.post(
+    f"{api_url}/predict",
+    json={"text": "This is a test message"}
+)
+
+print(response.json())
+```
+
+### 8. Important Notes
+
+- **Model Size:** Make sure your `contextClassifier.onnx` file is under the Space's size limit
+- **Cold Start:** The first request might take longer as the Space wakes up
+- **Logs:** Monitor the logs for any runtime errors
+- **Updates:** Any push to the repository will trigger a rebuild
+
+### 9. Troubleshooting
+
+**Common Issues:**
+- **Build Fails:** Check logs for dependency issues
+- **Model Not Found:** Ensure `contextClassifier.onnx` is in the root directory
+- **Port Issues:** Make sure the app uses port 7860
+- **Memory Issues:** Large models might exceed memory limits
+
+**Solutions:**
+- Review requirements.txt for compatible versions
+- Check model file path in app.py
+- Verify Dockerfile exposes port 7860
+- Consider model optimization for deployment

Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application files
+COPY app.py .
+COPY contextClassifier.onnx .
+
+# Expose port
+EXPOSE 7860
+
+# Run the application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,3 +1,115 @@
 ---
+title: Content Classifier
+emoji: 🔍
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
 license: mit
+app_port: 7860
 ---
+
+# Content Classifier API
+
+A FastAPI-based content classification service using an ONNX model for threat detection and sentiment analysis.
+
+## Features
+
+- Content threat classification
+- Sentiment analysis
+- RESTful API with automatic documentation
+- Health check endpoints
+- Model information endpoints
+- Docker support for easy deployment
+
+## API Endpoints
+
+- `POST /predict` - Classify text content
+- `GET /` - API status
+- `GET /health` - Health check
+- `GET /model-info` - Model information
+- `GET /docs` - Interactive API documentation (Swagger)
+
+## Installation
+
+1. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+2. Run the application:
+```bash
+python app.py
+```
+
+The API will be available at `http://localhost:8000`
+
+## Usage
+
+### Example Request
+
+```bash
+curl -X POST "http://localhost:8000/predict" \
+     -H "Content-Type: application/json" \
+     -d '{"text": "This is a sample text to classify"}'
+```
+
+### Example Response
+
+```json
+{
+    "is_threat": false,
+    "final_confidence": 0.75,
+    "threat_prediction": 0.25,
+    "sentiment_analysis": {
+        "label": "POSITIVE",
+        "score": 0.5
+    },
+    "onnx_prediction": {
+        "threat_probability": 0.25,
+        "raw_output": [[0.75, 0.25]]
+    },
+    "models_used": ["contextClassifier.onnx"],
+    "raw_predictions": {
+        "onnx": {
+            "threat_probability": 0.25,
+            "raw_output": [[0.75, 0.25]]
+        },
+        "sentiment": {
+            "label": "POSITIVE",
+            "score": 0.5
+        }
+    }
+}
+```
+
+## Docker Deployment
+
+1. Build the Docker image:
+```bash
+docker build -t content-classifier .
+```
+
+2. Run the container:
+```bash
+docker run -p 8000:8000 content-classifier
+```
+
+## Hugging Face Spaces Deployment
+
+To deploy on Hugging Face Spaces:
+
+1. Create a new Space on Hugging Face
+2. Upload all files to your Space repository
+3. The Space will automatically build and deploy
+
+## Model Requirements
+
+The ONNX model should accept text inputs and return classification predictions. You may need to adjust the preprocessing and postprocessing functions in `app.py` based on your specific model requirements.
+
+## Configuration
+
+You can modify the following in `app.py`:
+- `MODEL_PATH`: Path to your ONNX model file
+- `max_length`: Maximum text length for processing
+- Preprocessing and postprocessing logic based on your model's requirements

README_HF.md

@@ -0,0 +1,8 @@
+title: Content Classifier
+emoji: 🔍
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+license: mit
+app_port: 7860

app.py

@@ -0,0 +1,207 @@
+import os
+import numpy as np
+import onnxruntime as ort
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import uvicorn
+import json
+from typing import Dict, Any, List, Optional
+
+app = FastAPI(title="Content Classifier API", description="Content classification using ONNX model")
+
+# Model configuration
+MODEL_PATH = "contextClassifier.onnx"
+session = None
+
+class TextInput(BaseModel):
+    text: str
+    max_length: Optional[int] = 512
+
+class PredictionResponse(BaseModel):
+    is_threat: bool
+    final_confidence: float
+    threat_prediction: float
+    sentiment_analysis: Optional[Dict[str, Any]]
+    onnx_prediction: Optional[Dict[str, Any]]
+    models_used: List[str]
+    raw_predictions: Dict[str, Any]
+
+def load_model():
+    """Load the ONNX model"""
+    global session
+    try:
+        session = ort.InferenceSession(MODEL_PATH)
+        print(f"Model loaded successfully from {MODEL_PATH}")
+        print(f"Model inputs: {[input.name for input in session.get_inputs()]}")
+        print(f"Model outputs: {[output.name for output in session.get_outputs()]}")
+    except Exception as e:
+        print(f"Error loading model: {e}")
+        raise e
+
+def preprocess_text(text: str, max_length: int = 512):
+    """
+    Preprocess text for the model
+    This is a placeholder - you'll need to adjust this based on your model's requirements
+    """
+    # This is a simple tokenization example
+    # You may need to use a specific tokenizer depending on your model
+    
+    # Convert text to token IDs (this is just an example)
+    # You might need to use transformers tokenizer or similar
+    tokens = text.lower().split()[:max_length]
+    
+    # Pad or truncate to fixed length
+    if len(tokens) < max_length:
+        tokens.extend(['[PAD]'] * (max_length - len(tokens)))
+    
+    # Convert to input format expected by your model
+    # This is a placeholder - adjust based on your model's input requirements
+    input_ids = np.array([hash(token) % 30000 for token in tokens], dtype=np.int64).reshape(1, -1)
+    attention_mask = np.array([1 if token != '[PAD]' else 0 for token in tokens], dtype=np.int64).reshape(1, -1)
+    
+    return {
+        "input_ids": input_ids,
+        "attention_mask": attention_mask
+    }
+
+def postprocess_predictions(outputs, predictions_dict):
+    """
+    Process model outputs into the expected format
+    Adjust this based on your model's actual outputs
+    """
+    # This is a placeholder implementation
+    # Adjust based on your actual model outputs
+    
+    # Assuming the model outputs probabilities or logits
+    if len(outputs) > 0:
+        raw_output = outputs[0]
+        
+        # Calculate threat prediction (adjust logic as needed)
+        threat_prediction = float(raw_output[0][1]) if len(raw_output[0]) > 1 else 0.5
+        final_confidence = abs(threat_prediction - 0.5) * 2  # Scale to 0-1
+        is_threat = threat_prediction > 0.5
+        
+        predictions_dict.update({
+            "onnx": {
+                "threat_probability": threat_prediction,
+                "raw_output": raw_output.tolist()
+            }
+        })
+        
+        # Mock sentiment analysis (replace with actual logic if available)
+        sentiment_score = (threat_prediction - 0.5) * -2  # Inverse relationship
+        predictions_dict["sentiment"] = {
+            "label": "NEGATIVE" if sentiment_score < 0 else "POSITIVE",
+            "score": abs(sentiment_score)
+        }
+        
+        models_used = ["contextClassifier.onnx"]
+        
+        return {
+            "is_threat": is_threat,
+            "final_confidence": final_confidence,
+            "threat_prediction": threat_prediction,
+            "sentiment_analysis": predictions_dict.get("sentiment"),
+            "onnx_prediction": predictions_dict.get("onnx"),
+            "models_used": models_used,
+            "raw_predictions": predictions_dict
+        }
+    
+    # Fallback response
+    return {
+        "is_threat": False,
+        "final_confidence": 0.0,
+        "threat_prediction": 0.0,
+        "sentiment_analysis": None,
+        "onnx_prediction": None,
+        "models_used": [],
+        "raw_predictions": predictions_dict
+    }
+
+@app.on_event("startup")
+async def startup_event():
+    """Load model on startup"""
+    load_model()
+
+@app.get("/")
+async def root():
+    return {"message": "Content Classifier API is running", "model": MODEL_PATH}
+
+@app.post("/predict", response_model=PredictionResponse)
+async def predict(input_data: TextInput):
+    """
+    Predict content classification for the given text
+    """
+    if session is None:
+        raise HTTPException(status_code=500, detail="Model not loaded")
+    
+    try:
+        # Preprocess the text
+        model_inputs = preprocess_text(input_data.text, input_data.max_length)
+        
+        # Get input names from the model
+        input_names = [input.name for input in session.get_inputs()]
+        
+        # Prepare inputs for ONNX Runtime
+        ort_inputs = {}
+        for name in input_names:
+            if name in model_inputs:
+                ort_inputs[name] = model_inputs[name]
+            else:
+                # Handle case where expected input is not provided
+                print(f"Warning: Expected input '{name}' not found in processed inputs")
+        
+        # Run inference
+        outputs = session.run(None, ort_inputs)
+        
+        # Initialize predictions dictionary
+        predictions = {}
+        
+        # Process outputs
+        result = postprocess_predictions(outputs, predictions)
+        
+        return result
+        
+    except Exception as e:
+        print(f"Prediction error: {e}")
+        raise HTTPException(status_code=500, detail=f"Prediction failed: {str(e)}")
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "model_loaded": session is not None,
+        "model_path": MODEL_PATH
+    }
+
+@app.get("/model-info")
+async def model_info():
+    """Get model information"""
+    if session is None:
+        raise HTTPException(status_code=500, detail="Model not loaded")
+    
+    inputs = []
+    for input_meta in session.get_inputs():
+        inputs.append({
+            "name": input_meta.name,
+            "type": str(input_meta.type),
+            "shape": input_meta.shape
+        })
+    
+    outputs = []
+    for output_meta in session.get_outputs():
+        outputs.append({
+            "name": output_meta.name,
+            "type": str(output_meta.type),
+            "shape": output_meta.shape
+        })
+    
+    return {
+        "model_path": MODEL_PATH,
+        "inputs": inputs,
+        "outputs": outputs
+    }
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -0,0 +1,7 @@
+fastapi==0.104.1
+uvicorn==0.24.0
+onnxruntime==1.16.3
+numpy==1.24.3
+pydantic==2.5.0
+python-multipart==0.0.6
+requests==2.31.0

test_api.py

@@ -0,0 +1,57 @@
+import requests
+import json
+
+# Test the API
+base_url = "http://localhost:7860"
+
+def test_api():
+    # Test root endpoint
+    print("Testing root endpoint...")
+    try:
+        response = requests.get(f"{base_url}/")
+        print(f"Root: {response.status_code} - {response.json()}")
+    except Exception as e:
+        print(f"Root endpoint error: {e}")
+    
+    # Test health endpoint
+    print("\nTesting health endpoint...")
+    try:
+        response = requests.get(f"{base_url}/health")
+        print(f"Health: {response.status_code} - {response.json()}")
+    except Exception as e:
+        print(f"Health endpoint error: {e}")
+    
+    # Test model info endpoint
+    print("\nTesting model info endpoint...")
+    try:
+        response = requests.get(f"{base_url}/model-info")
+        print(f"Model Info: {response.status_code} - {response.json()}")
+    except Exception as e:
+        print(f"Model info endpoint error: {e}")
+    
+    # Test prediction endpoint
+    print("\nTesting prediction endpoint...")
+    test_texts = [
+        "This is a normal, safe message.",
+        "I will harm you and your family!",
+        "Hello, how are you doing today?",
+        "This product is amazing, I love it!"
+    ]
+    
+    for text in test_texts:
+        try:
+            payload = {"text": text}
+            response = requests.post(f"{base_url}/predict", json=payload)
+            if response.status_code == 200:
+                result = response.json()
+                print(f"\nText: '{text}'")
+                print(f"Is Threat: {result['is_threat']}")
+                print(f"Confidence: {result['final_confidence']:.3f}")
+                print(f"Threat Prediction: {result['threat_prediction']:.3f}")
+            else:
+                print(f"Error {response.status_code}: {response.text}")
+        except Exception as e:
+            print(f"Prediction error for '{text}': {e}")
+
+if __name__ == "__main__":
+    test_api()