refactor(evaluation): extract helper methods

Author: vxa8502

src/main/java/sentiment/evaluation/CrossDomainEvaluator.java

@@ -24,6 +24,9 @@
  */
 public class CrossDomainEvaluator {
 
+    private static final ObjectMapper MAPPER = new ObjectMapper()
+            .enable(SerializationFeature.INDENT_OUTPUT);
+
     private static final String[] TRAIN_DOMAINS = {"imdb_50k", "amazon_polarity", "yelp"};
     private static final String[] TEST_DOMAINS = {"imdb_50k", "amazon_polarity", "yelp"};
     private static final String[] ALGORITHMS = {"svm", "naive_bayes", "random_forest", "logistic_regression"};
@@ -196,7 +199,7 @@ public String generateReport() {
             var best = getBestGeneralizingModel();
             if (best != null) {
                 sb.append("═══════════════════════════════════════════════════════════════\n");
-                sb.append("🏆 BEST GENERALIZING MODEL\n");
+                sb.append("BEST GENERALIZING MODEL\n");
                 sb.append("═══════════════════════════════════════════════════════════════\n");
                 sb.append(String.format("Model: %s%n", best.getKey()));
                 sb.append(String.format("Cross-Domain Avg Accuracy: %.3f%n", best.getValue()));
@@ -214,9 +217,6 @@ public String generateReport() {
          * Export to JSON
          */
         public void exportToJson(Path outputPath) throws IOException {
-            ObjectMapper mapper = new ObjectMapper();
-            mapper.enable(SerializationFeature.INDENT_OUTPUT);
-
             Map<String, Object> export = new LinkedHashMap<>();
             export.put("evaluated_at", evaluatedAt.toString());
             export.put("domains", Arrays.asList(TRAIN_DOMAINS));
@@ -261,8 +261,8 @@ public void exportToJson(Path outputPath) throws IOException {
                 export.put("best_generalizing_model", bestModel);
             }
 
-            mapper.writeValue(outputPath.toFile(), export);
-            System.out.println("✓ Cross-domain evaluation exported to: " + outputPath);
+            MAPPER.writeValue(outputPath.toFile(), export);
+            System.out.println("Cross-domain evaluation exported to: " + outputPath);
         }
     }
 
@@ -285,25 +285,25 @@ public static CrossDomainMatrix evaluateAll(
         for (String algo : ALGORITHMS) {
             Map<String, SentimentClassifier> algoModels = models.get(algo);
             if (algoModels == null) {
-                System.out.println("⚠ No models found for algorithm: " + algo);
+                System.out.println("No models found for algorithm: " + algo);
                 continue;
             }
 
             for (String trainDomain : TRAIN_DOMAINS) {
                 SentimentClassifier model = algoModels.get(trainDomain);
                 if (model == null) {
-                    System.out.println("⚠ No model found for " + algo + " trained on " + trainDomain);
+                    System.out.println("No model found for " + algo + " trained on " + trainDomain);
                     continue;
                 }
 
                 for (String testDomain : TEST_DOMAINS) {
                     currentEval++;
-                    System.out.printf("[%d/%d] Evaluating %s (trained on %s) → testing on %s%n",
+                    System.out.printf("[%d/%d] Evaluating %s (trained on %s) -> testing on %s%n",
                         currentEval, totalEvaluations, algo, trainDomain, testDomain);
 
                     List<Dataset> testData = testDatasets.get(testDomain);
                     if (testData == null) {
-                        System.out.println("  ⚠ No test data found for " + testDomain);
+                        System.out.println("  No test data found for " + testDomain);
                         continue;
                     }
 
@@ -372,7 +372,7 @@ public static CrossDomainMatrix evaluateAll(
                     );
 
                     matrix.addResult(result);
-                    System.out.printf("  ✓ Accuracy: %.3f | Brier: %.3f%s%n",
+                    System.out.printf("  Accuracy: %.3f | Brier: %.3f%s%n",
                         result.accuracy, result.brierScore,
                         result.isInDomain ? " (in-domain)" : "");
                 }
@@ -388,9 +388,6 @@ public static CrossDomainMatrix evaluateAll(
      * Uses TrainingMetadata class to ensure correct JSON structure.
      */
     private static void persistToModelMetadata(CrossDomainMatrix matrix, Path modelsDir) {
-        ObjectMapper mapper = new ObjectMapper();
-        mapper.enable(SerializationFeature.INDENT_OUTPUT);
-
         for (String algo : ALGORITHMS) {
             for (String trainDomain : TRAIN_DOMAINS) {
                 // Build metadata file path
@@ -487,14 +484,14 @@ public static void main(String[] args) {
                     if (fullData.size() > maxSamplesPerDomain) {
                         Collections.shuffle(fullData, new Random(42)); // Reproducible sampling
                         sampledData = fullData.subList(0, maxSamplesPerDomain);
-                        System.out.println("✓ Loaded " + domain + ": " + sampledData.size() + " samples (sampled from " + fullData.size() + ") from " + testFile);
+                        System.out.println("Loaded " + domain + ": " + sampledData.size() + " samples (sampled from " + fullData.size() + ") from " + testFile);
                     } else {
-                        System.out.println("✓ Loaded " + domain + ": " + sampledData.size() + " samples from " + testFile);
+                        System.out.println("Loaded " + domain + ": " + sampledData.size() + " samples from " + testFile);
                     }
 
                     testDatasets.put(domain, sampledData);
                 } else {
-                    System.out.println("⚠ Test file not found in either:");
+                    System.out.println("Test file not found in either:");
                     System.out.println("    " + processedTestFile);
                     System.out.println("    " + rawTestFile);
                 }
@@ -509,15 +506,15 @@ public static void main(String[] args) {
                 Map<String, SentimentClassifier> algoModels = sentiment.models.ModelLoader.loadAllForAlgorithm(algo);
 
                 if (algoModels.isEmpty()) {
-                    System.out.println("⚠ No models found for " + algo);
+                    System.out.println("No models found for " + algo);
                 } else {
                     models.put(algo, algoModels);
-                    System.out.println("✓ Loaded " + algoModels.size() + " " + algo + " model(s)");
+                    System.out.println("Loaded " + algoModels.size() + " " + algo + " model(s)");
                 }
             }
 
             if (models.isEmpty()) {
-                System.err.println("\n✗ No models found in " + modelsDir);
+                System.err.println("\nNo models found in " + modelsDir);
                 System.err.println("Train models first using: ./scripts/train_all_models.sh");
                 System.exit(1);
             }

src/main/java/sentiment/evaluation/FeatureImportanceAnalyzer.java

@@ -93,6 +93,22 @@ public FeatureImportanceResult analyzeFeatureImportance(
         }
     }
 
+    /**
+     * Falls back to perturbation-based feature importance extraction.
+     * This method is called when direct coefficient extraction fails for linear SVMs.
+     *
+     * @param reason the reason for falling back (logged as a warning)
+     * @param trainedData the training instances
+     * @param classifier the classifier to analyze
+     * @return feature importance map from perturbation analysis
+     */
+    private Map<String, Double> fallbackToPerturbation(
+            String reason, Instances trainedData, Classifier classifier) {
+        logger.warn("{}", reason);
+        logger.warn("Falling back to perturbation method");
+        return extractFeatureImportance(trainedData, classifier);
+    }
+
     /**
      * Detects if the classifier is a linear SVM (SMO with linear kernel or normalized poly kernel).
      *
@@ -160,15 +176,13 @@ private Map<String, Double> extractLinearSVMWeights(Instances trainedData, SMO s
             double[][][] sparseWeights = smo.sparseWeights();
 
             if (sparseIndices == null || sparseWeights == null) {
-                logger.warn("sparseIndices() or sparseWeights() returned null");
-                logger.warn("Falling back to perturbation method");
-                return extractFeatureImportance(trainedData, smo);
+                return fallbackToPerturbation(
+                        "sparseIndices() or sparseWeights() returned null", trainedData, smo);
             }
 
             if (sparseIndices.length == 0 || sparseWeights.length == 0) {
-                logger.warn("Empty sparse arrays - no classifiers found");
-                logger.warn("Falling back to perturbation method");
-                return extractFeatureImportance(trainedData, smo);
+                return fallbackToPerturbation(
+                        "Empty sparse arrays - no classifiers found", trainedData, smo);
             }
 
             logger.info("Found {} classifier(s) in SMO", sparseIndices.length);
@@ -186,9 +200,8 @@ private Map<String, Double> extractLinearSVMWeights(Instances trainedData, SMO s
             double[][] weightsForClassifier = sparseWeights[0];
 
             if (indicesForClassifier == null || weightsForClassifier == null) {
-                logger.warn("No sparse data for classifier 0");
-                logger.warn("Falling back to perturbation method");
-                return extractFeatureImportance(trainedData, smo);
+                return fallbackToPerturbation(
+                        "No sparse data for classifier 0", trainedData, smo);
             }
 
             logger.info("Classifier 0 has {} class weight vectors", indicesForClassifier.length);
@@ -214,9 +227,8 @@ private Map<String, Double> extractLinearSVMWeights(Instances trainedData, SMO s
             }
 
             if (featureIndices == null || featureWeights == null) {
-                logger.warn("No valid weight vectors found in any class");
-                logger.warn("Falling back to perturbation method");
-                return extractFeatureImportance(trainedData, smo);
+                return fallbackToPerturbation(
+                        "No valid weight vectors found in any class", trainedData, smo);
             }
 
             // Extract weights from the sparse representation
@@ -244,17 +256,17 @@ private Map<String, Double> extractLinearSVMWeights(Instances trainedData, SMO s
             logger.info("Non-zero feature weights: {} out of {}", nonZeroCount, numAttributes - 1);
 
             if (nonZeroCount == 0) {
-                logger.warn("All extracted weights are zero! This indicates a problem with coefficient extraction.");
-                logger.warn("Falling back to perturbation method");
-                return extractFeatureImportance(trainedData, smo);
+                return fallbackToPerturbation(
+                        "All extracted weights are zero! This indicates a problem with coefficient extraction.",
+                        trainedData, smo);
             }
 
             return weights;
 
         } catch (Exception e) {
             logger.error("Failed to extract linear SVM weights: {}", e.getMessage(), e);
-            logger.warn("Falling back to perturbation method");
-            return extractFeatureImportance(trainedData, smo);
+            return fallbackToPerturbation(
+                    "Exception during coefficient extraction", trainedData, smo);
         }
     }
 

src/main/java/sentiment/evaluation/StratifiedDataSplitter.java

@@ -194,6 +194,20 @@ public static List<DataSplit> stratifiedKFold(
         return cvSplits;
     }
 
+    /**
+     * Counts the number of samples per class in the given dataset.
+     *
+     * @param data the dataset to count
+     * @return a map from sentiment label to count
+     */
+    private static Map<Dataset.SentimentLabel, Long> countByClass(List<Dataset> data) {
+        if (data.isEmpty()) {
+            return Map.of();
+        }
+        return data.stream()
+                .collect(Collectors.groupingBy(Dataset::getSentiment, Collectors.counting()));
+    }
+
     /**
      * Verifies and logs that stratification preserved class distribution across splits.
      *
@@ -208,17 +222,10 @@ private static void verifyStratification(
             List<Dataset> val,
             List<Dataset> test) {
 
-        Map<Dataset.SentimentLabel, Long> origDist = original.stream()
-                .collect(Collectors.groupingBy(Dataset::getSentiment, Collectors.counting()));
-
-        Map<Dataset.SentimentLabel, Long> trainDist = train.stream()
-                .collect(Collectors.groupingBy(Dataset::getSentiment, Collectors.counting()));
-
-        Map<Dataset.SentimentLabel, Long> valDist = val.isEmpty() ? Map.of() : val.stream()
-                .collect(Collectors.groupingBy(Dataset::getSentiment, Collectors.counting()));
-
-        Map<Dataset.SentimentLabel, Long> testDist = test.stream()
-                .collect(Collectors.groupingBy(Dataset::getSentiment, Collectors.counting()));
+        Map<Dataset.SentimentLabel, Long> origDist = countByClass(original);
+        Map<Dataset.SentimentLabel, Long> trainDist = countByClass(train);
+        Map<Dataset.SentimentLabel, Long> valDist = countByClass(val);
+        Map<Dataset.SentimentLabel, Long> testDist = countByClass(test);
 
         logger.info("=== Class Distribution Verification ===");
         for (Dataset.SentimentLabel label : origDist.keySet()) {