Upload 6 files

.gitignore

@@ -0,0 +1,30 @@
+# Ignore Python cache and bytecode
+__pycache__/
+*.py[cod]
+*.so
+
+# Ignore virtual environment
+venv/
+
+# Ignore saved model files
+saved_model/
+*.safetensors
+*.pt
+*.bin
+*.ckpt
+
+# Ignore logs or runtime data
+*.log
+*.csv
+*.tmp
+*.DS_Store
+
+# Ignore Jupyter Notebook checkpoints
+.ipynb_checkpoints/
+
+# Ignore environment files if sensitive
+.env
+
+*.pyc
+*.pyo
+*.pyd

Dockerfile

@@ -0,0 +1,18 @@
+# Use a slim Python image
+FROM python:3.10-slim
+
+# Set working directory inside the container
+WORKDIR /app
+
+# Copy the requirements file and install dependencies
+COPY requirements.txt .
+RUN pip install --upgrade pip && pip install -r requirements.txt
+
+# Copy all app files to the container
+COPY . .
+
+# Expose the port the app will run on (Hugging Face requires 7860)
+EXPOSE 7860
+
+# Run the Flask app
+CMD ["python", "app.py"]

Procfile

@@ -0,0 +1 @@
+web: gunicorn app:app

app.py

@@ -0,0 +1,111 @@
+from flask import Flask, render_template, request, redirect
+import pandas as pd
+from predictor import predict_sentiment
+
+app = Flask(__name__)
+
+# 🔘 Label mapping
+LABEL_MAP = {
+    "LABEL_0": "Negative",
+    "LABEL_1": "Positive"
+}
+
+# 🔘 Root → redirect to single review page
+@app.route("/")
+def root():
+    return redirect("/sentiment-review/single")
+
+# 🔘 Single review input route
+@app.route("/sentiment-review/single", methods=["GET", "POST"])
+def single_review():
+    prediction = None
+    confidence = None
+    review = ""
+    chosen_model = None
+
+    if request.method == "POST":
+        review = request.form.get("review", "").strip()
+        if review:
+            try:
+                result = predict_sentiment(review)
+
+                raw_label = result["prediction"].get("label")
+                score = result["prediction"].get("score", 0.0)
+                chosen_model = result.get("chosen_model", "N/A")
+
+                prediction = LABEL_MAP.get(raw_label, raw_label)
+                confidence = round(float(score) * 100, 2)
+
+            except Exception as e:
+                print("❌ Single Review Processing Error:", e)
+                prediction = "Error"
+                confidence = 0.0
+                chosen_model = "N/A"
+
+    return render_template(
+        "index.html",
+        prediction=prediction,
+        confidence=confidence,
+        review=review,
+        chosen_model=chosen_model
+    )
+
+# 📁 Batch upload route
+@app.route("/sentiment-review/batch", methods=["GET", "POST"])
+def batch_review():
+    if request.method == "POST":
+        if 'csvfile' not in request.files:
+            return render_template("batch.html", error="No file part found.")
+
+        file = request.files['csvfile']
+        if not file.filename:
+            return render_template("batch.html", error="No selected file.")
+
+        if file and file.filename.endswith(".csv"):
+            try:
+                df = pd.read_csv(file, encoding="utf-8")
+                if "review" not in df.columns:
+                    return render_template("batch.html", error="CSV must have a 'review' column.")
+
+                results = []
+                for i, text in enumerate(df["review"].fillna("").tolist()):
+                    try:
+                        result = predict_sentiment(text)
+
+                        raw_label = result["prediction"].get("label")
+                        score = result["prediction"].get("score", 0.0)
+                        chosen_model = result.get("chosen_model", "N/A")
+
+                        sentiment = LABEL_MAP.get(raw_label, raw_label)
+                        confidence = round(float(score) * 100, 2)
+
+                        print(f"🧠 Review {i+1}: {text[:40]}... → {sentiment} ({confidence}%) [Model: {chosen_model}]")
+
+                        results.append({
+                            "text": text,
+                            "sentiment": sentiment,
+                            "confidence": confidence,
+                            "chosen_model": chosen_model
+                        })
+                    except Exception as inner_e:
+                        print(f"⚠️ Error processing review {i+1}: {inner_e}")
+                        results.append({
+                            "text": text,
+                            "sentiment": "Error",
+                            "confidence": 0.0,
+                            "chosen_model": "N/A"
+                        })
+
+                return render_template("batch.html", results=results)
+
+            except Exception as e:
+                print("❌ CSV Processing error:", e)
+                return render_template("batch.html", error=f"Processing error: {str(e)}")
+
+        return render_template("batch.html", error="Invalid file format. Upload .csv only.")
+
+    return render_template("batch.html")
+
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=7860, debug=True)

predictor.py

@@ -0,0 +1,44 @@
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
+import torch
+
+# ✅ Load all three models
+model_names = {
+    "label0": "SreyaDvn/savedModelLebel0",
+    "label1": "SreyaDvn/savedModelLebel1",
+    "balanced": "SreyaDvn/sentiment-model"
+}
+
+pipelines = {}
+for name, path in model_names.items():
+    tokenizer = AutoTokenizer.from_pretrained(path)
+    model = AutoModelForSequenceClassification.from_pretrained(path)
+    pipelines[name] = pipeline(
+        "text-classification",
+        model=model,
+        tokenizer=tokenizer,
+        device=0 if torch.cuda.is_available() else -1
+    )
+
+print("✅ All models loaded successfully!")
+
+
+def predict_sentiment(text: str):
+    """
+    Runs input text through all models,
+    then selects the best model by IF-ELSE logic.
+    """
+
+    results = {}
+    for name, pipe in pipelines.items():
+        out = pipe(text, truncation=True)[0]  # e.g. {'label': 'LABEL_1', 'score': 0.92}
+        results[name] = out
+
+    # ---- IF-ELSE LOGIC ----
+    # Currently: Pick the prediction with the HIGHEST confidence score
+    best_model = max(results, key=lambda k: results[k]['score'])
+
+    return {
+        "chosen_model": best_model,
+        "prediction": results[best_model],
+        "all_results": results
+    }