Update app.py

app.py

@@ -119,72 +119,87 @@ def gaussian_kernel(length=12, sigma=1.2):
     kern = kern / kern.sum()
     return kern
 
-def smooth_monthly_probs(raw_probs, alpha=ALPHA, sigma=SMOOTH_SIGMA, min_curve_prob=MIN_CURVE_PROB):
+def smooth_monthly_probs_preserve_magnitude(raw_probs,
+                                            alpha=ALPHA,
+                                            sigma=SMOOTH_SIGMA,
+                                            min_curve_prob=MIN_CURVE_PROB):
     """
-    Robust smoothing + contrast stretch for raw monthly ML probabilities.
-
-    raw_probs: list/array length 12, values expected in [0,100]
-    Returns: list length 12, percentages summing to ~100
+    Convert raw_probs (0..100) -> two arrays:
+      - monthly_scores: absolute smoothed scores scaled to 0..100 (preserves magnitude)
+      - monthly_perc: normalized percentages summing to 100 (for plotting)
+    Steps:
+      1. scale to 0..1
+      2. tiny contrast-stretch so differences matter
+      3. apply exponent alpha to emphasize peaks
+      4. circular gaussian smoothing
+      5. monthly_scores: scale smoothed values so max -> 100
+      6. monthly_perc: normalize the same smoothed values to sum -> 100
     """
-    a = np.asarray(raw_probs, dtype=float) / 100.0  # scale to 0-1
+    a = np.asarray(raw_probs, dtype=float) / 100.0  # 0..1
 
-    # If all zeros => return uniform (but avoid strict uniform by small floor)
+    # Guard: if all zeros, return uniform small floor
     if a.sum() == 0 or np.allclose(a, 0.0):
-        base = np.ones_like(a) * (min_curve_prob / 100.0)
-        base = base / base.sum()
-        return (base * 100.0).round(3).tolist()
+        uniform = np.ones(12) * (min_curve_prob / 100.0)
+        monthly_scores = (uniform / uniform.max()) * 100.0
+        monthly_perc = (uniform / uniform.sum()) * 100.0
+        return monthly_perc.tolist(), monthly_scores.tolist()
 
-    # contrast stretch (min-max), but avoid tiny denominator
+    # Contrast stretch (min-max) to amplify differences
     amin = float(a.min())
     amax = float(a.max())
     rng = amax - amin
-    if rng < 1e-4:
-        # values almost identical -> amplify relative differences using sqrt of original
-        a_cs = np.sqrt(a)
-        a_cs = a_cs - a_cs.min()
-        rng2 = a_cs.max() - a_cs.min()
-        if rng2 <= 1e-8:
-            a_cs = np.ones_like(a) / len(a)
+    if rng < 1e-6:
+        a_cs = a - amin
+        if a_cs.max() <= 1e-12:
+            a_cs = np.ones_like(a) * 1e-6
         else:
-            a_cs = a_cs / rng2
+            a_cs = a_cs / (a_cs.max() + 1e-12)
     else:
         a_cs = (a - amin) / (rng + 1e-12)
 
-    # small floor to avoid zeros everywhere
+    # floor tiny values (avoid zero everywhere)
     floor = min_curve_prob / 100.0
-    a_cs = np.clip(a_cs, floor * 0.001, None)
+    a_cs = np.clip(a_cs, floor * 1e-3, 1.0)
 
-    # apply sharpening exponent
+    # sharpen peaks
     if alpha != 1.0:
         a_sh = np.power(a_cs, alpha)
     else:
         a_sh = a_cs
 
-    # circular pad and gaussian smooth
+    # circular pad and gaussian kernel
     sigma = float(max(0.6, sigma))
     pad = max(3, int(round(3 * sigma)))
     padded = np.concatenate([a_sh[-pad:], a_sh, a_sh[:pad]])
     kern_range = np.arange(-pad, pad + 1)
     kern = np.exp(-0.5 * (kern_range / sigma) ** 2)
     kern = kern / kern.sum()
-    smoothed = np.convolve(padded, kern, mode="same")
+    smoothed = np.convolve(padded, kern, mode='same')
     center = smoothed[pad:pad+12]
     center = np.clip(center, 0.0, None)
 
+    # monthly_perc: normalized to sum 100 for plotting
     if center.sum() <= 0:
-        center = np.ones_like(center) / len(center)
-
-    # Normalize & to percentages
+        center = np.ones_like(center)
     norm = center / center.sum()
-    perc = (norm * 100.0)
-    # tiny rounding
-    perc = np.round(perc, 3)
-    # final safety: ensure sum ~= 100
-    s = float(perc.sum())
-    if abs(s - 100.0) > 0.001 and s > 0:
-        perc = perc * (100.0 / s)
-
-    return perc.tolist()
+    monthly_perc = (norm * 100.0).round(3)
+
+    # monthly_scores: scale by max to 0..100 (preserve magnitude)
+    maxv = float(center.max())
+    if maxv <= 0:
+        monthly_scores = np.ones_like(center) * (min_curve_prob)
+    else:
+        monthly_scores = (center / maxv) * 100.0
+    monthly_scores = np.round(monthly_scores, 3)
+
+    # final safety normalization
+    s = float(monthly_perc.sum())
+    if s <= 0:
+        monthly_perc = np.ones(12) * (100.0 / 12.0)
+    else:
+        monthly_perc = monthly_perc * (100.0 / monthly_perc.sum())
+
+    return monthly_perc.tolist(), monthly_scores.tolist()
 
 def is_bell_shaped(perc_list):
     """