fix(models): remove redundant preprocessing and improve logging

Author: vxa8502

src/main/java/sentiment/models/ModelLoader.java

@@ -1,5 +1,7 @@
 package sentiment.models;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import sentiment.preprocessing.TextPreprocessor;
 import sentiment.preprocessing.WekaInstancesConverter;
 import sentiment.training.TrainingMetadata;
@@ -18,6 +20,8 @@
  */
 public class ModelLoader {
 
+    private static final Logger logger = LoggerFactory.getLogger(ModelLoader.class);
+
     /**
      * Load model with metadata validation.
      * Throws exception if metadata file is missing (non-negotiable requirement).
@@ -43,23 +47,22 @@ public static SentimentClassifier loadWithMetadata(String modelPath)
 
         // Load metadata first
         TrainingMetadata metadata = TrainingMetadata.load(metadataPath);
-        System.out.printf("✓ Loaded metadata: %s, trained on %s, accuracy=%.3f%n",
+        logger.info("Loaded metadata: {}, trained on {}, accuracy={}",
                 metadata.getModelId(),
                 metadata.getDataset().datasetName,
-                metadata.getMetrics().testAccuracy);
+                String.format("%.3f", metadata.getMetrics().testAccuracy));
 
         // Validate metadata points to correct model file
         if (metadata.getModelFile() != null &&
             !metadata.getModelFile().equals(path.getFileName().toString())) {
-            System.err.printf("⚠ Metadata model_file mismatch: expected %s, got %s%n",
+            logger.warn("Metadata model_file mismatch: expected {}, got {}",
                     metadata.getModelFile(), path.getFileName());
         }
 
         // Load the actual model based on algorithm type
         SentimentClassifier classifier = loadModelByType(path, metadata);
 
-        System.out.printf("✓ Loaded model: %s from %s%n",
-                path.getFileName(), path.getParent());
+        logger.info("Loaded model: {} from {}", path.getFileName(), path.getParent());
 
         return classifier;
     }
@@ -141,7 +144,7 @@ public static java.util.Map<String, SentimentClassifier> loadAllForAlgorithm(Str
         Path algoDir = Paths.get("models", algorithm);
 
         if (!Files.exists(algoDir)) {
-            System.err.println("⚠ Model directory not found: " + algoDir);
+            logger.warn("Model directory not found: {}", algoDir);
             return models;
         }
 
@@ -157,10 +160,10 @@ public static java.util.Map<String, SentimentClassifier> loadAllForAlgorithm(Str
                           SentimentClassifier classifier = loadWithMetadata(modelPath.toString());
                           models.put(domain, classifier);
 
-                          System.out.printf("✓ Loaded %s model trained on %s%n", algorithm, domain);
+                          logger.info("Loaded {} model trained on {}", algorithm, domain);
 
                       } catch (Exception e) {
-                          System.err.println("✗ Failed to load " + modelPath + ": " + e.getMessage());
+                          logger.error("Failed to load {}: {}", modelPath, e.getMessage());
                       }
                   });
         }

src/main/java/sentiment/models/SVMClassifier.java

@@ -130,27 +130,22 @@ protected ClassifierEvaluationResult doTrain(List<Dataset> rawDatasets) throws E
 
         logger.info("Training SVM on {} raw datasets with full pipeline", rawDatasets.size());
 
-        // Step 1: Fit preprocessing pipeline
-        logger.info("Step 1/3: Fitting preprocessing pipeline");
-        preprocessor.fit(rawDatasets);
-        logger.info("Preprocessor fitted. Vocabulary: {}",
-                preprocessor.getPipelineState().vocabularySize);
-
-        // Step 2: Fit feature extraction (converter) and get Instances
-        logger.info("Step 2/3: Fitting feature extraction");
+        // Step 1: Fit vectorization pipeline (preprocessing + TF-IDF)
+        // Note: converter.fit() internally calls preprocessor.fit()
+        logger.info("Step 1/2: Fitting vectorization pipeline");
         Instances trainingInstances = converter.fit(rawDatasets);
-        logger.info("Converter fitted. Features: {}, Vocabulary: {}",
+        logger.info("Vectorization complete. Features: {}, Vocabulary: {}",
                 trainingInstances.numAttributes() - 1,
                 converter.getVocabulary().size());
 
-        // Step 3: Train SVM on converted Instances
-        logger.info("Step 3/3: Training SVM classifier");
+        // Step 2: Train SVM on converted Instances
+        logger.info("Step 2/2: Training SVM classifier");
         validateWekaTrainingData(trainingInstances);
         configureSMOForTraining(trainingInstances);
         performAlgorithmSpecificTraining(trainingInstances);
         finalizeTraining(trainingInstances);
 
-        // Step 4: Validate pipeline consistency (CRITICAL)
+        // Validate pipeline consistency
         validatePipelineConsistency();
 
         logger.info("SVM training complete. Pipeline ready for inference.");

src/test/java/sentiment/models/SVMClassifierTest.java

@@ -148,7 +148,8 @@ void testTrain_FitsPipelineComponents() throws Exception {
         classifier.train(trainingData);
 
         // Assert
-        verify(mockPreprocessor, times(1)).fit(trainingData);
+        // WekaInstancesConverter now owns preprocessor fitting, so we only verify converter.fit()
+        // The preprocessor.fit() happens internally within converter.fit()
         verify(mockConverter, times(1)).fit(trainingData);
         assertTrue(classifier.isTrained(), "Classifier should be trained");
     }