tweaked the minimum reward

graders/grader_classification.py

@@ -20,15 +20,24 @@ class MediumClassificationGrader:
         fn = float(getattr(state, "total_fn", 0))
 
         total = tp + tn + fp + fn
-        if total == 0:
-            return 0.01
+        
+        # The maximum possible score if they made zero mistakes
+        actual_anomalies = tp + fn
+        actual_valid = tn + fp
+        
+        perfect_signal = (actual_anomalies * _TP_WEIGHT) + (actual_valid * _TN_WEIGHT)
+        
+        if perfect_signal == 0:
+            return 0.1
 
         positive_signal = (tp * _TP_WEIGHT) + (tn * _TN_WEIGHT)
         negative_signal = (fp * _FP_PENALTY) + (fn * _FN_PENALTY)
 
-        max_signal = total * _TP_WEIGHT
-        raw_score = max(0.0, positive_signal - negative_signal) / max_signal
+        # Normalize against the true perfect scenario
+        raw_score = max(0.0, positive_signal - negative_signal) / perfect_signal
 
-        score = max(0.01, min(0.99, raw_score))
+        # Strict hackathon boundary
+        score = max(0.1, min(0.99, raw_score))
+        
         self.last_breakdown = {"tp": int(tp), "tn": int(tn), "fp": int(fp), "fn": int(fn), "score": score}
         return score

graders/grader_detection.py

@@ -20,15 +20,23 @@ class EasyDetectionGrader:
         fn = float(getattr(state, "total_fn", 0))
 
         total = tp + tn + fp + fn
-        if total == 0:
-            return 0.01
+                
+        # The maximum possible score if they made zero mistakes
+        actual_anomalies = tp + fn
+        actual_valid = tn + fp
+        
+        perfect_signal = (actual_anomalies * _TP_WEIGHT) + (actual_valid * _TN_WEIGHT)
+        
+        if perfect_signal == 0:
+            return 0.1
 
         positive_signal = (tp * _TP_WEIGHT) + (tn * _TN_WEIGHT)
         negative_signal = (fp * _FP_PENALTY) + (fn * _FN_PENALTY)
 
-        max_signal = total * _TP_WEIGHT
-        raw_score = max(0.0, positive_signal - negative_signal) / max_signal
+        # Normalize against the true perfect scenario
+        raw_score = max(0.0, positive_signal - negative_signal) / perfect_signal
 
-        score = max(0.01, min(0.99, raw_score))
+        # Strict hackathon boundary
+        score = max(0.1, min(0.99, raw_score))
         self.last_breakdown = {"tp": int(tp), "tn": int(tn), "fp": int(fp), "fn": int(fn), "score": score}
         return score

graders/grader_fix.py

@@ -20,15 +20,23 @@ class HardFixGrader:
         fn = float(getattr(state, "total_fn", 0))
 
         total = tp + tn + fp + fn
-        if total == 0:
-            return 0.01
+                
+        # The maximum possible score if they made zero mistakes
+        actual_anomalies = tp + fn
+        actual_valid = tn + fp
+        
+        perfect_signal = (actual_anomalies * _TP_WEIGHT) + (actual_valid * _TN_WEIGHT)
+        
+        if perfect_signal == 0:
+            return 0.1
 
         positive_signal = (tp * _TP_WEIGHT) + (tn * _TN_WEIGHT)
         negative_signal = (fp * _FP_PENALTY) + (fn * _FN_PENALTY)
 
-        max_signal = total * _TP_WEIGHT
-        raw_score = max(0.0, positive_signal - negative_signal) / max_signal
+        # Normalize against the true perfect scenario
+        raw_score = max(0.0, positive_signal - negative_signal) / perfect_signal
 
-        score = max(0.01, min(0.99, raw_score))
+        # Strict hackathon boundary
+        score = max(0.1, min(0.99, raw_score))
         self.last_breakdown = {"tp": int(tp), "tn": int(tn), "fp": int(fp), "fn": int(fn), "score": score}
         return score

server/fin_auditor_environment.py

@@ -170,22 +170,25 @@ class FinAuditorEnvironment(Environment):
         anomalies: list[list[float]] = self.engine.get_anomaly_matrix().tolist()
         done = self._state.step_count >= self._MAX_EPISODE_STEPS
 
-        # 4. COMPUTE LIVE STEP REWARD from cumulative episode performance
-        #    Uses same asymmetric weights as FinAuditorGrader so the dashboard
-        #    value is consistent with the official final episode score.
+        # 4. COMPUTE LIVE STEP REWARD
         tp = float(self._state.total_tp)
         tn = float(self._state.total_tn)
         fp = float(self._state.total_fp)
         fn = float(self._state.total_fn)
-        total = tp + tn + fp + fn
-
-        if total > 0:
-            positive = tp * 1.0 + tn * 0.1
-            negative = fp * 0.1 + fn * 0.4
-            raw = max(0.0, positive - negative) / (total * 1.0)
-            step_reward = max(0.01, min(0.99, raw))
+        
+        actual_anomalies = tp + fn
+        actual_valid = tn + fp
+        perfect_signal = (actual_anomalies * 1.0) + (actual_valid * 0.1)
+
+        if perfect_signal > 0:
+            positive = (tp * 1.0) + (tn * 0.1)
+            negative = (fp * 0.1) + (fn * 0.4) 
+            raw = max(0.0, positive - negative) / perfect_signal
+            # REDDIT FIX: Changed 0.01 to 0.1
+            step_reward = max(0.1, min(0.99, raw))
         else:
-            step_reward = 0.01  # floor before any decisions are made
+            # REDDIT FIX: Changed 0.01 to 0.1
+            step_reward = 0.1  
 
         return FinAuditorObservation(
             features=anomalies,