Create app.py

app.py

@@ -66,12 +66,16 @@ class FallacyFinder:
         try:
             logger.info("Loading model: SamanthaStorm/fallacyfinder")
             self.tokenizer = AutoTokenizer.from_pretrained("SamanthaStorm/fallacyfinder")
-            self.model = AutoModelForSequenceClassification.from_pretrained("SamanthaStorm/fallacyfinder")
+            self.model = AutoModelForSequenceClassification.from_pretrained(
+                "SamanthaStorm/fallacyfinder",
+                num_labels=16  # Specify 16 fallacy classes
+            )
             self.use_model = True
             logger.info("✅ Model loaded successfully!")
         except Exception as e:
             logger.error(f"❌ Error loading model: {e}")
-            logger.info("Falling back to rule-based approach")
+            logger.error("Model loading failed - cannot continue without trained model")
+            raise e  # Stop execution if model fails to load
     
     def predict_with_rules(self, text):
         """Rule-based fallacy detection for when model isn't available"""
@@ -206,54 +210,52 @@ class FallacyFinder:
         return 'no_fallacy', 0.60, ["no_specific_patterns"]
     
     def predict_fallacy(self, text):
-        """Main prediction function"""
+        """Main prediction function using trained model only"""
         if not text.strip():
             return None, 0, "Please enter a message to analyze.", []
         
         logger.info(f"ANALYZING: '{text[:100]}{'...' if len(text) > 100 else ''}'")
         
-        if self.use_model and self.model is not None:
-            # Use trained model
-            try:
-                logger.info("Using trained model for prediction")
-                inputs = self.tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=512)
-                
-                with torch.no_grad():
-                    outputs = self.model(**inputs)
-                    predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
-                    predicted_class_id = predictions.argmax().item()
-                    confidence = predictions.max().item()
-                
-                # Log all prediction scores
-                label_keys = list(self.fallacy_labels.keys())
-                prediction_scores = {}
-                for i, label in enumerate(label_keys):
-                    score = predictions[0][i].item()
-                    prediction_scores[label] = f"{score:.3f}"
-                
-                logger.info(f"MODEL PREDICTIONS: {prediction_scores}")
-                
-                # Map to fallacy label
-                predicted_label = label_keys[predicted_class_id]
-                logger.info(f"MODEL RESULT: {predicted_label} (confidence: {confidence:.3f})")
-                
-                patterns_detected = [f"model_prediction: top_3: {sorted(prediction_scores.items(), key=lambda x: float(x[1]), reverse=True)[:3]}"]
-                
-            except Exception as e:
-                logger.error(f"Model prediction failed: {e}")
-                logger.info("Falling back to rule-based approach")
-                predicted_label, confidence, patterns_detected = self.predict_with_rules(text)
-        else:
-            # Use rule-based approach
-            logger.info("Using rule-based approach")
-            predicted_label, confidence, patterns_detected = self.predict_with_rules(text)
-        
-        fallacy_name = self.fallacy_labels[predicted_label]
-        description = self.fallacy_descriptions[predicted_label]
+        if not self.use_model or self.model is None:
+            logger.error("Trained model not available - cannot analyze")
+            return None, 0, "Model not loaded", []
         
-        logger.info(f"FINAL RESULT: {predicted_label} ({fallacy_name}) - confidence: {confidence}")
-        
-        return predicted_label, confidence, fallacy_name, description, patterns_detected
+        # Use trained model
+        try:
+            logger.info("Using trained model for prediction")
+            inputs = self.tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=512)
+            
+            with torch.no_grad():
+                outputs = self.model(**inputs)
+                predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
+                predicted_class_id = predictions.argmax().item()
+                confidence = predictions.max().item()
+            
+            # Log all prediction scores
+            label_keys = list(self.fallacy_labels.keys())
+            prediction_scores = {}
+            for i, label in enumerate(label_keys):
+                score = predictions[0][i].item()
+                prediction_scores[label] = f"{score:.3f}"
+            
+            logger.info(f"MODEL PREDICTIONS: {prediction_scores}")
+            
+            # Map to fallacy label
+            predicted_label = label_keys[predicted_class_id]
+            logger.info(f"MODEL RESULT: {predicted_label} (confidence: {confidence:.3f})")
+            
+            patterns_detected = [f"model_prediction: top_3: {sorted(prediction_scores.items(), key=lambda x: float(x[1]), reverse=True)[:3]}"]
+            
+            fallacy_name = self.fallacy_labels[predicted_label]
+            description = self.fallacy_descriptions[predicted_label]
+            
+            logger.info(f"FINAL RESULT: {predicted_label} ({fallacy_name}) - confidence: {confidence}")
+            
+            return predicted_label, confidence, fallacy_name, description, patterns_detected
+            
+        except Exception as e:
+            logger.error(f"Model prediction failed: {e}")
+            return None, 0, "Prediction failed", []
     
     def analyze_message(self, message):
         """Analyze a message and return formatted results"""
@@ -315,7 +317,8 @@ finder = FallacyFinder()
 logger.info("Fallacy Finder initialized successfully")
 
 def analyze_fallacy(message):
-    return finder.analyze_message(message)
+    result, explanation, _ = finder.analyze_message(message)  # Ignore 3rd return value
+    return result, explanation
 
 # Create the Gradio interface
 with gr.Blocks(