Upload 9 files

.gitignore

@@ -0,0 +1,60 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db

DEPLOYMENT.md

@@ -0,0 +1,129 @@
+# Hugging Face Space Deployment Guide
+
+## 🚀 How to Deploy Your Sentiment Analysis API to Hugging Face Spaces
+
+### Step 1: Create a Hugging Face Account
+1. Go to [https://huggingface.co](https://huggingface.co)
+2. Sign up for a free account if you don't have one
+
+### Step 2: Create a New Space
+1. Go to [https://huggingface.co/new-space](https://huggingface.co/new-space)
+2. Fill in the details:
+   - **Space name**: `sentiment-analysis-api` (or your preferred name)
+   - **License**: MIT
+   - **SDK**: Docker
+   - **Hardware**: CPU Basic (free tier)
+
+### Step 3: Upload Your Files
+Upload all the files from this directory to your new Space:
+- `app.py` - FastAPI application
+- `sentiment.pkl` - Your trained model
+- `requirements.txt` - Python dependencies
+- `Dockerfile` - Docker configuration
+- `README.md` - Documentation
+- `index.html` - Simple web interface (optional)
+
+### Step 4: Your Space Will Auto-Deploy
+- Hugging Face will automatically build and deploy your Docker container
+- The build process takes 5-10 minutes
+- You can monitor the build logs in the Space dashboard
+
+### Step 5: Access Your API
+Once deployed, your API will be available at:
+- **API Base URL**: `https://YOUR_USERNAME-sentiment-analysis-api.hf.space`
+- **Interactive Docs**: `https://YOUR_USERNAME-sentiment-analysis-api.hf.space/docs`
+- **Simple Interface**: `https://YOUR_USERNAME-sentiment-analysis-api.hf.space` (if you uploaded index.html)
+
+## 🧪 Testing Locally First
+
+Before deploying, test your API locally:
+
+1. **Install dependencies**:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+2. **Run the API**:
+   ```bash
+   python app.py
+   ```
+
+3. **Test the endpoints**:
+   - Visit `http://localhost:7860/docs` for interactive API docs
+   - Run `python test_api.py` to test all endpoints
+   - Visit `http://localhost:7860` for the simple web interface
+
+## 📋 API Endpoints
+
+### POST `/predict`
+```json
+{
+  "text": "I love this product!"
+}
+```
+Response:
+```json
+{
+  "prediction": 1,
+  "confidence": 0.95,
+  "sentiment": "positive"
+}
+```
+
+### POST `/predict_proba`
+```json
+{
+  "text": "This is terrible"
+}
+```
+Response:
+```json
+{
+  "probabilities": [0.85, 0.15],
+  "prediction": 0,
+  "sentiment": "negative"
+}
+```
+
+### POST `/batch_predict`
+```json
+["I love it!", "This is bad", "It's okay"]
+```
+
+## 🔧 Customization
+
+### If your model requires text preprocessing:
+Edit the `app.py` file in the prediction functions to add your preprocessing steps:
+
+```python
+# Add preprocessing before model.predict()
+def preprocess_text(text):
+    # Add your preprocessing logic here
+    # e.g., tokenization, vectorization, etc.
+    return processed_text
+
+# In the prediction functions:
+processed_text = preprocess_text(input_data.text)
+prediction = model.predict([processed_text])[0]
+```
+
+### To change the port or host:
+Modify the last line in `app.py`:
+```python
+uvicorn.run(app, host="0.0.0.0", port=8000)  # Change port as needed
+```
+
+## 🆘 Troubleshooting
+
+1. **Model loading errors**: Ensure `sentiment.pkl` is in the same directory
+2. **Dependency issues**: Check that all required packages are in `requirements.txt`
+3. **Memory issues**: Your model might be too large for the free tier (upgrade to paid tier)
+4. **Preprocessing errors**: Make sure your text preprocessing matches your training pipeline
+
+## 💡 Next Steps
+
+- Add authentication for production use
+- Implement rate limiting
+- Add logging and monitoring
+- Create more sophisticated web interface
+- Add model versioning

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.9
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . /code
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,65 @@
----
-title: Sentiment Classifier
-emoji: 📈
-colorFrom: gray
-colorTo: pink
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Sentiment Analysis API
+emoji: 😊
+colorFrom: blue
+colorTo: green
+sdk: docker
+pinned: false
+license: mit
+---
+
+# Sentiment Analysis API
+
+A FastAPI-based sentiment analysis service that predicts sentiment (positive/negative) from text input.
+
+## Features
+
+- **Sentiment Prediction**: Get integer predictions (0 for negative, 1 for positive)
+- **Probability Scores**: Get prediction probabilities for both classes
+- **Batch Processing**: Analyze multiple texts at once
+- **Interactive API**: Swagger UI documentation available at `/docs`
+
+## API Endpoints
+
+### `/predict`
+- **Method**: POST
+- **Input**: JSON with `text` field
+- **Output**: Prediction, confidence score, and sentiment label
+
+### `/predict_proba`
+- **Method**: POST  
+- **Input**: JSON with `text` field
+- **Output**: Probability array, prediction, and sentiment label
+
+### `/batch_predict`
+- **Method**: POST
+- **Input**: Array of text strings
+- **Output**: Results for all input texts
+
+## Usage Example
+
+```python
+import requests
+
+# Single prediction
+response = requests.post(
+    "https://your-space-url/predict",
+    json={"text": "I love this movie!"}
+)
+print(response.json())
+# Output: {"prediction": 1, "confidence": 0.95, "sentiment": "positive"}
+
+# Probability prediction
+response = requests.post(
+    "https://your-space-url/predict_proba", 
+    json={"text": "This is terrible"}
+)
+print(response.json())
+# Output: {"probabilities": [0.85, 0.15], "prediction": 0, "sentiment": "negative"}
+```
+
+## Local Development
+
+1. Install dependencies: `pip install -r requirements.txt`
+2. Run the app: `python app.py`
+3. Visit `http://localhost:7860/docs` for interactive API documentation

app.py

@@ -0,0 +1,130 @@
+import pickle
+import numpy as np
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import Dict, List
+import uvicorn
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Sentiment Analysis API",
+    description="A sentiment analysis model that predicts sentiment (positive/negative) from text",
+    version="1.0.0"
+)
+
+# Load the model
+try:
+    with open("sentiment.pkl", "rb") as f:
+        model = pickle.load(f)
+except FileNotFoundError:
+    raise Exception("sentiment.pkl not found. Please ensure the model file is in the correct location.")
+
+# Pydantic models for request/response
+class TextInput(BaseModel):
+    text: str
+
+class PredictionResponse(BaseModel):
+    prediction: int
+    confidence: float
+    sentiment: str
+
+class ProbabilityResponse(BaseModel):
+    probabilities: List[float]
+    prediction: int
+    sentiment: str
+
+@app.get("/")
+async def root():
+    return {
+        "message": "Sentiment Analysis API",
+        "endpoints": {
+            "/predict": "Get sentiment prediction (0 or 1)",
+            "/predict_proba": "Get prediction probabilities",
+            "/health": "Check API health"
+        }
+    }
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy", "model_loaded": True}
+
+@app.post("/predict", response_model=PredictionResponse)
+async def predict_sentiment(input_data: TextInput):
+    """
+    Predict sentiment from text input.
+    Returns integer prediction (0 for negative, 1 for positive).
+    """
+    try:
+        # Convert text to the format expected by your model
+        # Note: You may need to preprocess the text depending on your model's requirements
+        text_data = [input_data.text]
+        
+        # Get prediction
+        prediction = model.predict(text_data)[0]
+        
+        # Get probabilities to calculate confidence
+        probabilities = model.predict_proba(text_data)[0]
+        confidence = float(max(probabilities))
+        
+        # Convert prediction to sentiment label
+        sentiment = "positive" if prediction == 1 else "negative"
+        
+        return PredictionResponse(
+            prediction=int(prediction),
+            confidence=confidence,
+            sentiment=sentiment
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Prediction failed: {str(e)}")
+
+@app.post("/predict_proba", response_model=ProbabilityResponse)
+async def predict_probabilities(input_data: TextInput):
+    """
+    Get prediction probabilities for sentiment analysis.
+    Returns probability arrays with shape (n_samples, 2).
+    """
+    try:
+        # Convert text to the format expected by your model
+        text_data = [input_data.text]
+        
+        # Get probabilities
+        probabilities = model.predict_proba(text_data)[0]
+        prediction = model.predict(text_data)[0]
+        
+        # Convert prediction to sentiment label
+        sentiment = "positive" if prediction == 1 else "negative"
+        
+        return ProbabilityResponse(
+            probabilities=probabilities.tolist(),
+            prediction=int(prediction),
+            sentiment=sentiment
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Probability prediction failed: {str(e)}")
+
+@app.post("/batch_predict")
+async def batch_predict(texts: List[str]):
+    """
+    Predict sentiment for multiple texts at once.
+    """
+    try:
+        predictions = model.predict(texts)
+        probabilities = model.predict_proba(texts)
+        
+        results = []
+        for i, text in enumerate(texts):
+            sentiment = "positive" if predictions[i] == 1 else "negative"
+            results.append({
+                "text": text,
+                "prediction": int(predictions[i]),
+                "probabilities": probabilities[i].tolist(),
+                "sentiment": sentiment,
+                "confidence": float(max(probabilities[i]))
+            })
+        
+        return {"results": results}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Batch prediction failed: {str(e)}")
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)

index.html

@@ -0,0 +1,175 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Sentiment Analysis</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            max-width: 800px;
+            margin: 0 auto;
+            padding: 20px;
+            background-color: #f5f5f5;
+        }
+        .container {
+            background-color: white;
+            padding: 30px;
+            border-radius: 10px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+        }
+        h1 {
+            color: #333;
+            text-align: center;
+            margin-bottom: 30px;
+        }
+        textarea {
+            width: 100%;
+            min-height: 120px;
+            padding: 15px;
+            border: 2px solid #ddd;
+            border-radius: 5px;
+            font-size: 16px;
+            resize: vertical;
+        }
+        button {
+            background-color: #007bff;
+            color: white;
+            padding: 12px 24px;
+            border: none;
+            border-radius: 5px;
+            cursor: pointer;
+            font-size: 16px;
+            margin: 10px 5px;
+        }
+        button:hover {
+            background-color: #0056b3;
+        }
+        .result {
+            margin-top: 20px;
+            padding: 15px;
+            border-radius: 5px;
+            font-weight: bold;
+        }
+        .positive {
+            background-color: #d4edda;
+            color: #155724;
+            border: 1px solid #c3e6cb;
+        }
+        .negative {
+            background-color: #f8d7da;
+            color: #721c24;
+            border: 1px solid #f5c6cb;
+        }
+        .confidence {
+            margin-top: 10px;
+            font-size: 14px;
+        }
+        .api-info {
+            margin-top: 30px;
+            padding: 20px;
+            background-color: #e9ecef;
+            border-radius: 5px;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>🎭 Sentiment Analysis</h1>
+        <p>Enter your text below to analyze its sentiment:</p>
+        
+        <textarea id="textInput" placeholder="Type your text here...">I love this new product! It's amazing and works perfectly.</textarea>
+        
+        <div style="text-align: center;">
+            <button onclick="predictSentiment()">Predict Sentiment</button>
+            <button onclick="getProbabilities()">Get Probabilities</button>
+        </div>
+        
+        <div id="result"></div>
+        
+        <div class="api-info">
+            <h3>API Endpoints:</h3>
+            <ul>
+                <li><strong>/predict</strong> - Get sentiment prediction (0 or 1)</li>
+                <li><strong>/predict_proba</strong> - Get prediction probabilities</li>
+                <li><strong>/docs</strong> - Interactive API documentation</li>
+            </ul>
+        </div>
+    </div>
+
+    <script>
+        async function predictSentiment() {
+            const text = document.getElementById('textInput').value;
+            if (!text.trim()) {
+                alert('Please enter some text');
+                return;
+            }
+
+            try {
+                const response = await fetch('/predict', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ text: text })
+                });
+
+                const result = await response.json();
+                displayResult(result, 'prediction');
+            } catch (error) {
+                console.error('Error:', error);
+                displayError('Error making prediction');
+            }
+        }
+
+        async function getProbabilities() {
+            const text = document.getElementById('textInput').value;
+            if (!text.trim()) {
+                alert('Please enter some text');
+                return;
+            }
+
+            try {
+                const response = await fetch('/predict_proba', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ text: text })
+                });
+
+                const result = await response.json();
+                displayResult(result, 'probability');
+            } catch (error) {
+                console.error('Error:', error);
+                displayError('Error getting probabilities');
+            }
+        }
+
+        function displayResult(result, type) {
+            const resultDiv = document.getElementById('result');
+            const sentimentClass = result.sentiment === 'positive' ? 'positive' : 'negative';
+            
+            let html = `<div class="result ${sentimentClass}">
+                <div>Sentiment: ${result.sentiment.toUpperCase()} (${result.prediction})</div>`;
+            
+            if (type === 'prediction') {
+                html += `<div class="confidence">Confidence: ${(result.confidence * 100).toFixed(1)}%</div>`;
+            } else if (type === 'probability') {
+                html += `<div class="confidence">
+                    Probabilities: Negative ${(result.probabilities[0] * 100).toFixed(1)}%, 
+                    Positive ${(result.probabilities[1] * 100).toFixed(1)}%
+                </div>`;
+            }
+            
+            html += `</div>`;
+            resultDiv.innerHTML = html;
+        }
+
+        function displayError(message) {
+            const resultDiv = document.getElementById('result');
+            resultDiv.innerHTML = `<div class="result" style="background-color: #f8d7da; color: #721c24;">${message}</div>`;
+        }
+    </script>
+</body>
+</html>

requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+pydantic==2.5.0
+numpy==1.24.3
+scikit-learn==1.3.0
+python-multipart==0.0.6

sentiment.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:83e4eacef6ebc4ac101fdb74d36654ec1e74e1918b883089ffb75e993be69bf9
+size 248173794

test_api.py

@@ -0,0 +1,71 @@
+import requests
+import json
+
+# Test the API endpoints
+base_url = "http://localhost:7860"
+
+def test_api():
+    # Test data
+    test_texts = [
+        "I love this product! It's amazing!",
+        "This is terrible and disappointing.",
+        "It's okay, nothing special.",
+        "Best purchase ever! Highly recommend!"
+    ]
+    
+    print("🧪 Testing Sentiment Analysis API")
+    print("=" * 50)
+    
+    # Test single prediction
+    print("\n📊 Testing /predict endpoint:")
+    for text in test_texts[:2]:
+        try:
+            response = requests.post(
+                f"{base_url}/predict",
+                json={"text": text}
+            )
+            result = response.json()
+            print(f"Text: '{text}'")
+            print(f"Prediction: {result['prediction']} ({result['sentiment']})")
+            print(f"Confidence: {result['confidence']:.2%}")
+            print("-" * 30)
+        except Exception as e:
+            print(f"Error testing '{text}': {e}")
+    
+    # Test probability prediction
+    print("\n📈 Testing /predict_proba endpoint:")
+    test_text = test_texts[0]
+    try:
+        response = requests.post(
+            f"{base_url}/predict_proba",
+            json={"text": test_text}
+        )
+        result = response.json()
+        print(f"Text: '{test_text}'")
+        print(f"Probabilities: {result['probabilities']}")
+        print(f"Prediction: {result['prediction']} ({result['sentiment']})")
+        print("-" * 30)
+    except Exception as e:
+        print(f"Error testing probabilities: {e}")
+    
+    # Test batch prediction
+    print("\n📦 Testing /batch_predict endpoint:")
+    try:
+        response = requests.post(
+            f"{base_url}/batch_predict",
+            json=test_texts
+        )
+        results = response.json()
+        for result in results['results']:
+            print(f"Text: '{result['text']}'")
+            print(f"Sentiment: {result['sentiment']} (confidence: {result['confidence']:.2%})")
+            print("-" * 30)
+    except Exception as e:
+        print(f"Error testing batch prediction: {e}")
+
+if __name__ == "__main__":
+    print("Make sure to start the API server first with: python app.py")
+    print("Then run this test script.")
+    
+    # Uncomment the line below to run tests (make sure API is running first)
+    # test_api()