Upload 3 files

app.py

@@ -0,0 +1,151 @@
+# test_preloaded_model.py
+import gradio as gr
+import pickle
+import os
+
+# --- Dependencies needed for the Class Definition ---
+from transformers import pipeline
+import torch
+
+# --- Define the Class to Hold Both Pipelines ---
+# IMPORTANT: This exact class definition MUST be present here,
+# identical to the one in save_combined_model.py, for unpickling to work.
+class CombinedAnalyzer:
+    """
+    A class to encapsulate sentiment analysis and AI text detection pipelines.
+    NOTE: This definition must match the one used when saving the .pkl file.
+    """
+    def __init__(self, sentiment_model_name="distilbert-base-uncased-finetuned-sst-2-english",
+                 detector_model_name="Hello-SimpleAI/chatgpt-detector-roberta"):
+        print("Initializing CombinedAnalyzer structure...")
+        self.device = 0 if torch.cuda.is_available() else -1
+        self.sentiment_model_name = sentiment_model_name
+        self.detector_model_name = detector_model_name
+        self.sentiment_pipeline = None
+        self.detector_pipeline = None
+        print(f"Class structure defined. Expecting pipelines for models: {sentiment_model_name}, {detector_model_name}")
+
+    def analyze(self, text):
+        """
+        Analyzes the input text for both sentiment and authenticity.
+        """
+        if not isinstance(text, str) or not text.strip():
+             return "Error: Input text cannot be empty."
+        results = []
+        # 1. Sentiment Analysis
+        if self.sentiment_pipeline and callable(self.sentiment_pipeline):
+            try:
+                sentiment_result = self.sentiment_pipeline(text)[0]
+                sentiment_label = sentiment_result['label']
+                sentiment_score = round(sentiment_result['score'] * 100, 2)
+                results.append(f"Sentiment: {sentiment_label} (Confidence: {sentiment_score}%)")
+            except Exception as e:
+                results.append(f"Sentiment Analysis Error in loaded model: {e}")
+        else:
+             results.append("Sentiment Analysis: Model not available or not callable in loaded object.")
+        # 2. AI Text Detection (Authenticity)
+        if self.detector_pipeline and callable(self.detector_pipeline):
+            try:
+                 detector_result = self.detector_pipeline(text)[0]
+                 auth_label_raw = detector_result['label']
+                 auth_score = round(detector_result['score'] * 100, 2)
+                 if auth_label_raw.lower() in ['chatgpt', 'ai', 'generated']:
+                     auth_label_display = "Likely AI-Generated"
+                 elif auth_label_raw.lower() in ['human', 'real']:
+                      auth_label_display = "Likely Human-Written"
+                 else:
+                     auth_label_display = f"Label: {auth_label_raw}"
+                 results.append(f"Authenticity: {auth_label_display} (Confidence: {auth_score}%)")
+            except Exception as e:
+                results.append(f"AI Text Detection Error in loaded model: {e}")
+        else:
+            results.append("Authenticity: AI Text Detector model not available or not callable in loaded object.")
+        return "\n".join(results)
+
+# --- Load the Model Automatically on Startup ---
+analyzer = None
+pickle_filename = "combined_analyzer.pkl"
+model_dir = "saved_model"
+pickle_filepath = os.path.join(model_dir, pickle_filename)
+model_load_error = None # Store potential loading error message
+
+print(f"Attempting to load pre-saved model from: {pickle_filepath}")
+try:
+    print("\n--- SECURITY WARNING ---")
+    print(f"Loading '{pickle_filepath}'. Unpickling data from untrusted sources is a security risk.")
+    print("Ensure this .pkl file was created by you or a trusted source.\n")
+
+    if not os.path.exists(pickle_filepath):
+        raise FileNotFoundError(f"Model file not found at {pickle_filepath}")
+    with open(pickle_filepath, 'rb') as f:
+        analyzer = pickle.load(f)
+    if not hasattr(analyzer, 'analyze') or not callable(analyzer.analyze):
+        raise TypeError("Loaded object is not a valid analyzer (missing 'analyze' method).")
+    else:
+        print("Model loaded successfully.")
+        sentiment_name = getattr(analyzer, 'sentiment_model_name', 'Unknown')
+        detector_name = getattr(analyzer, 'detector_model_name', 'Unknown')
+        print(f" -> Sentiment Model: {sentiment_name}")
+        print(f" -> Detector Model: {detector_name}")
+
+except FileNotFoundError as e:
+    model_load_error = f"ERROR loading model: {e}"
+    print(model_load_error)
+    print("Please ensure 'save_combined_model.py' was run successfully and")
+    print(f"the file '{pickle_filename}' exists in the '{model_dir}' directory.")
+except (pickle.UnpicklingError, TypeError, AttributeError) as e:
+    model_load_error = f"ERROR loading model: The pickle file might be corrupted, incompatible, or from a different version. Details: {e}"
+    print(model_load_error)
+except Exception as e:
+    model_load_error = f"An unexpected ERROR occurred during model loading: {e}"
+    print(model_load_error)
+
+# --- Define the Gradio Analysis Function ---
+def analyze_text_interface(text_input):
+    """Function called by Gradio to perform analysis using the pre-loaded model."""
+    if analyzer is None:
+        # Use the stored error message if available
+        error_msg = model_load_error or f"ERROR: The analyzer model could not be loaded from '{pickle_filepath}'."
+        return error_msg
+    if not text_input or not text_input.strip():
+        return "Please enter some text to analyze."
+    print(f"Analyzing text: '{text_input[:60]}...'")
+    try:
+        results = analyzer.analyze(text_input)
+        print("Analysis complete.")
+        return results
+    except Exception as e:
+        print(f"Error during analysis: {e}")
+        return f"An error occurred during analysis:\n{e}"
+
+# --- Build the Gradio Interface ---
+
+# **CORRECTION HERE:** Define the warning message string separately
+warning_message_text = ""
+if analyzer is None:
+    # Use newline characters safely outside the f-string expression
+    warning_message_text = "\n\n***WARNING: MODEL FAILED TO LOAD. ANALYSIS WILL NOT WORK.***"
+
+# Construct the full description string
+description_text = (
+    f"Enter text to analyze using the pre-loaded model from '{pickle_filepath}'.\n"
+    "Checks for sentiment (Positive/Negative) and predicts if text is Human-Written or AI-Generated."
+    f"{warning_message_text}" # Use the variable here
+)
+
+interface = gr.Interface(
+    fn=analyze_text_interface,
+    inputs=gr.Textbox(lines=7, label="Text to Analyze", placeholder="Enter review text here..."),
+    outputs=gr.Textbox(lines=7, label="Analysis Results", interactive=False),
+    title="Sentiment & Authenticity Analyzer",
+    description=description_text, # Use the constructed description string
+    allow_flagging='never'
+)
+
+# --- Launch the Interface ---
+if __name__ == "__main__":
+    if analyzer is None:
+        print("\n--- Interface launched, but MODEL IS NOT LOADED. Analysis will fail. ---")
+    else:
+        print("\n--- Launching Gradio Interface with pre-loaded model ---")
+    interface.launch()

requirements.txt

@@ -0,0 +1,4 @@
+transformers
+torch
+gradio
+sentencepiece

saved_model/combined_analyzer.pkl

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