Upload 10 files

Dockerfile

@@ -0,0 +1,24 @@
+# Use an official Python runtime as a parent image
+FROM python:3.11-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE 1
+ENV PYTHONUNBUFFERED 1
+
+# Set working directory
+WORKDIR /app
+
+# Install dependencies
+RUN pip install --no-cache-dir flask flask-cors flask-sqlalchemy gunicorn numpy scikit-learn
+
+# Copy the application code
+COPY . /app/
+
+# Create Models directory
+RUN mkdir -p /app/Models
+
+# Expose port 5000 for the Flask app
+EXPOSE 5000
+
+# Command to run the application using gunicorn
+CMD ["gunicorn", "--bind", "0.0.0.0:5000", "--reload", "main:app"]

Models/Text_LR.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:450f850036a2d38ffa16fdea1c215f84b53aaa0891cf1456324598be7f73d640
+size 2070402

Models/count_vect.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:86909c3f6eaf2f7b0cb9eb73f643a633348343acc9c45ac51472e6c6f06b11c6
+size 1378074

Models/transformer.pkl

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

app.py

@@ -0,0 +1,76 @@
+import os
+from flask import Flask, request, jsonify, render_template
+from flask_cors import CORS
+import logging
+from models import SentimentModel
+from utils import validate_input, setup_logging
+
+# Initialize Flask app
+app = Flask(__name__)
+CORS(app)  # Enable CORS for all routes
+app.secret_key = os.environ.get("SESSION_SECRET", "default-secret-key")
+
+# Setup logging
+setup_logging()
+
+# Initialize the sentiment model
+sentiment_model = SentimentModel()
+
+@app.errorhandler(Exception)
+def handle_error(error):
+    """Global error handler for all exceptions."""
+    logging.error(f"Error occurred: {str(error)}")
+
+    if isinstance(error, ValueError):
+        return jsonify({"error": str(error)}), 400
+
+    return jsonify({
+        "error": "An internal error occurred. Please try again later."
+    }), 500
+
+@app.route('/')
+def index():
+    """Render the main application page."""
+    return render_template('index.html')
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    """Health check endpoint."""
+    return jsonify({"status": "healthy"}), 200
+
+@app.route('/predict', methods=['POST'])
+def predict_sentiment():
+    """
+    Endpoint for sentiment prediction.
+
+    Expects JSON input with format:
+    {
+        "text": "text to analyze"
+    }
+
+    Returns:
+    {
+        "sentiment": "positive/negative",
+        "confidence": float
+    }
+    """
+    try:
+        # Get and validate input
+        data = request.get_json()
+        if not data:
+            raise ValueError("No input data provided")
+
+        text = validate_input(data)
+
+        # Get prediction
+        sentiment, confidence = sentiment_model.predict(text)
+
+        # Return response
+        return jsonify({
+            "sentiment": sentiment,
+            "confidence": confidence
+        }), 200
+
+    except Exception as e:
+        # Let the global error handler deal with it
+        raise

main.py

@@ -0,0 +1,8 @@
+from app import app
+import logging
+from utils import setup_logging
+
+if __name__ == "__main__":
+    setup_logging()
+    logging.info("Starting sentiment analysis API server")
+    app.run(host="0.0.0.0", port=5000, debug=True)

models.py

@@ -0,0 +1,89 @@
+import pickle
+import logging
+import os
+from typing import Tuple, Any
+from pathlib import Path
+
+class SentimentModel:
+    def __init__(self):
+        self.count_vectorizer = None
+        self.tfidf_transformer = None
+        self.classifier = None
+        self._load_models()
+
+    def _load_models(self) -> None:
+        """Load all required ML models from pickle files."""
+        try:
+            # Get model path from environment or use default relative path
+            default_path = str(Path(__file__).parent / 'Models')
+            model_path = os.getenv('MODEL_PATH', default_path)
+            logging.info(f"Loading models from: {model_path}")
+
+            # Ensure the directory exists
+            if not os.path.exists(model_path):
+                raise FileNotFoundError(f"Model directory not found at: {model_path}")
+
+            model_files = {
+                'count_vectorizer': 'count_vect.pkl',
+                'tfidf_transformer': 'transformer.pkl',
+                'classifier': 'Text_LR.pkl'
+            }
+
+            for model_name, filename in model_files.items():
+                file_path = os.path.join(model_path, filename)
+                if not os.path.exists(file_path):
+                    raise FileNotFoundError(f"Model file not found: {file_path}")
+
+                with open(file_path, 'rb') as f:
+                    setattr(self, model_name, pickle.load(f))
+                logging.info(f"Successfully loaded {model_name}")
+
+        except FileNotFoundError as e:
+            logging.error(f"Model file not found: {str(e)}")
+            raise
+        except Exception as e:
+            logging.error(f"Error loading models: {str(e)}")
+            raise
+
+    def predict(self, text: str) -> Tuple[str, float]:
+        """
+        Predict sentiment for given text using the ML pipeline.
+
+        Args:
+            text: Input text for sentiment analysis
+
+        Returns:
+            Tuple containing sentiment label and confidence score
+        """
+        try:
+            if not all([self.count_vectorizer, self.tfidf_transformer, self.classifier]):
+                raise RuntimeError("Models not properly initialized")
+
+            # Transform text using CountVectorizer
+            count_features = self.count_vectorizer.transform([text])
+            logging.debug(f"Count features shape: {count_features.shape}")
+
+            # Apply TF-IDF transformation
+            tfidf_features = self.tfidf_transformer.transform(count_features)
+            logging.debug(f"TF-IDF features shape: {tfidf_features.shape}")
+
+            # Get prediction probabilities
+            probabilities = self.classifier.predict_proba(tfidf_features)[0]
+            logging.debug(f"Raw prediction probabilities: {probabilities}")
+
+            # Find the class with highest probability
+            max_prob_idx = probabilities.argmax()
+            confidence = probabilities[max_prob_idx]
+
+            # Map the prediction index to sentiment
+            # Class 2 (index 2) appears to be positive sentiment based on the logs
+            sentiment = "positive" if max_prob_idx == 2 else "negative"
+
+            logging.info(f"Prediction for text: '{text[:50]}...' -> {sentiment} (confidence: {confidence:.2f})")
+            logging.debug(f"Probabilities - Positive: {confidence:.3f}")
+
+            return sentiment, float(confidence)
+
+        except Exception as e:
+            logging.error(f"Prediction error: {str(e)}")
+            raise

pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "repl-nix-workspace"
+version = "0.1.0"
+description = "Add your description here"
+requires-python = ">=3.11"
+dependencies = [
+    "email-validator>=2.2.0",
+    "flask-cors>=5.0.1",
+    "flask>=3.1.0",
+    "flask-sqlalchemy>=3.1.1",
+    "gunicorn>=23.0.0",
+    "numpy>=2.2.4",
+    "psycopg2-binary>=2.9.10",
+    "scikit-learn>=1.6.1",
+]

templates/index.html

@@ -0,0 +1,128 @@
+<!DOCTYPE html>
+<html lang="en" data-bs-theme="dark">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Sentiment Analysis</title>
+    <link href="https://cdn.replit.com/agent/bootstrap-agent-dark-theme.min.css" rel="stylesheet">
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.7.2/font/bootstrap-icons.css" rel="stylesheet">
+</head>
+<body>
+    <div class="container py-5">
+        <div class="row justify-content-center">
+            <div class="col-md-8">
+                <div class="card shadow-sm">
+                    <div class="card-body">
+                        <h1 class="card-title text-center mb-4">
+                            <i class="bi bi-emoji-smile me-2"></i>
+                            Sentiment Analysis
+                        </h1>
+                        
+                        <div class="alert alert-info mb-4" role="alert">
+                            <i class="bi bi-info-circle me-2"></i>
+                            Enter your text below to analyze its sentiment. Our AI model will determine if the text expresses a positive or negative sentiment.
+                        </div>
+
+                        <form id="sentimentForm" class="mb-4">
+                            <div class="mb-3">
+                                <label for="textInput" class="form-label">Text to Analyze</label>
+                                <textarea 
+                                    class="form-control" 
+                                    id="textInput" 
+                                    rows="4" 
+                                    placeholder="Enter your text here..."
+                                    required></textarea>
+                            </div>
+                            <div class="d-grid">
+                                <button type="submit" class="btn btn-primary" id="analyzeBtn">
+                                    <span class="spinner-border spinner-border-sm d-none me-2" role="status" aria-hidden="true"></span>
+                                    Analyze Sentiment
+                                </button>
+                            </div>
+                        </form>
+
+                        <div id="result" class="card d-none">
+                            <div class="card-body text-center">
+                                <h5 class="card-title mb-3">Analysis Result</h5>
+                                <div class="result-content">
+                                    <i class="bi bi-emoji-smile-fill result-icon fs-1 mb-3"></i>
+                                    <p class="result-text fs-4 mb-0"></p>
+                                    <p class="confidence-text text-muted mt-2"></p>
+                                </div>
+                            </div>
+                        </div>
+
+                        <div id="errorAlert" class="alert alert-danger d-none" role="alert">
+                            <i class="bi bi-exclamation-triangle me-2"></i>
+                            <span class="error-message"></span>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        document.addEventListener('DOMContentLoaded', () => {
+            const form = document.getElementById('sentimentForm');
+            const analyzeBtn = document.getElementById('analyzeBtn');
+            const spinner = analyzeBtn.querySelector('.spinner-border');
+            const resultCard = document.getElementById('result');
+            const resultIcon = resultCard.querySelector('.result-icon');
+            const resultText = resultCard.querySelector('.result-text');
+            const confidenceText = resultCard.querySelector('.confidence-text');
+            const errorAlert = document.getElementById('errorAlert');
+            const errorMessage = errorAlert.querySelector('.error-message');
+
+            form.addEventListener('submit', async (e) => {
+                e.preventDefault();
+                
+                // Reset previous results
+                resultCard.classList.add('d-none');
+                errorAlert.classList.add('d-none');
+                
+                // Show loading state
+                analyzeBtn.disabled = true;
+                spinner.classList.remove('d-none');
+                
+                try {
+                    const text = document.getElementById('textInput').value.trim();
+                    
+                    if (!text) {
+                        throw new Error('Please enter some text to analyze.');
+                    }
+                    
+                    const response = await fetch('/predict', {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
+                        body: JSON.stringify({ text }),
+                    });
+                    
+                    if (!response.ok) {
+                        const error = await response.json();
+                        throw new Error(error.error || 'Failed to analyze sentiment.');
+                    }
+                    
+                    const result = await response.json();
+                    
+                    // Update result display
+                    resultIcon.className = `bi ${result.sentiment === 'positive' ? 'bi-emoji-smile-fill' : 'bi-emoji-frown-fill'} result-icon fs-1 mb-3`;
+                    resultText.textContent = `${result.sentiment.charAt(0).toUpperCase() + result.sentiment.slice(1)} Sentiment`;
+                    confidenceText.textContent = `Confidence: ${Math.round(result.confidence * 100)}%`;
+                    resultCard.classList.remove('d-none');
+                    
+                } catch (error) {
+                    errorMessage.textContent = error.message;
+                    errorAlert.classList.remove('d-none');
+                } finally {
+                    // Reset loading state
+                    analyzeBtn.disabled = false;
+                    spinner.classList.add('d-none');
+                }
+            });
+        });
+    </script>
+</body>
+</html>

utils.py

@@ -0,0 +1,38 @@
+from typing import Dict, Any
+import logging
+
+def validate_input(data: Dict[str, Any]) -> str:
+    """
+    Validate the input data for sentiment analysis.
+    
+    Args:
+        data: Dictionary containing the input data
+        
+    Returns:
+        Validated text string
+        
+    Raises:
+        ValueError: If validation fails
+    """
+    if not isinstance(data, dict):
+        raise ValueError("Input must be a JSON object")
+        
+    if 'text' not in data:
+        raise ValueError("Missing 'text' field in input")
+        
+    text = data.get('text')
+    
+    if not isinstance(text, str):
+        raise ValueError("Text must be a string")
+        
+    if not text.strip():
+        raise ValueError("Text cannot be empty")
+        
+    return text.strip()
+
+def setup_logging() -> None:
+    """Configure logging for the application."""
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )