Update app.py

app.py

@@ -30,8 +30,8 @@ SCALER_FILE = Path("mil_scaler.joblib")
 FEATURES_FILE = Path("mil_features.joblib")
 PHENO_FILE = Path("phenologythingy.csv")
 SPECIES_STATS_FILE = Path("species_stats.csv")
-MIN_BLOOM_THRESHOLD = float(os.environ.get("MIN_BLOOM_THRESHOLD", 40.0))  # minimum probability to predict species
-MIN_PEAK_FOR_BELL = float(os.environ.get("MIN_PEAK_FOR_BELL", 60.0)) 
+MIN_BLOOM_THRESHOLD = float(os.environ.get("MIN_BLOOM_THRESHOLD", 20.0))  # minimum probability to predict species
+MIN_PEAK_FOR_BELL = float(os.environ.get("MIN_PEAK_FOR_BELL", 25.0)) 
 
 ELEV_IMAGE_ID = "USGS/SRTMGL1_003"
 BUFFER_METERS = int(os.environ.get("BUFFER_METERS", 200))
@@ -119,40 +119,71 @@ 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):
+def smooth_monthly_probs(raw_probs, alpha=ALPHA, sigma=SMOOTH_SIGMA, min_curve_prob=MIN_CURVE_PROB):
     """
-    raw_probs: length-12 array of ML probabilities in [0,100]
-    Steps:
-      1. scale to [0,1]
-      2. apply exponent alpha to sharpen
-      3. pad circularly then convolve with gaussian kernel
-      4. normalize to sum to 1 and return percentages (0-100)
+    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
     """
-    a = np.asarray(raw_probs, dtype=float) / 100.0
-    # apply floor to avoid all zeros
-    if a.sum() == 0:
-        a = np.ones_like(a) * (MIN_CURVE_PROB / 100.0)
-    # sharpen
+    a = np.asarray(raw_probs, dtype=float) / 100.0  # scale to 0-1
+
+    # If all zeros => return uniform (but avoid strict uniform by 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()
+
+    # contrast stretch (min-max), but avoid tiny denominator
+    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)
+        else:
+            a_cs = a_cs / rng2
+    else:
+        a_cs = (a - amin) / (rng + 1e-12)
+
+    # small floor to avoid zeros everywhere
+    floor = min_curve_prob / 100.0
+    a_cs = np.clip(a_cs, floor * 0.001, None)
+
+    # apply sharpening exponent
     if alpha != 1.0:
-        a = np.power(a, alpha)
-    # circular padding for smoothing wrap-around months
-    pad = int(max(6, 3 * sigma))
-    padded = np.concatenate([a[-pad:], a, a[:pad]])
-    # build kernel centered
-    xs = np.arange(-pad, pad + len(a) + pad)  # not used directly
+        a_sh = np.power(a_cs, alpha)
+    else:
+        a_sh = a_cs
+
+    # circular pad and gaussian smooth
+    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')
-    # extract center portion
+    smoothed = np.convolve(padded, kern, mode="same")
     center = smoothed[pad:pad+12]
-    # clip small negatives or tiny numbers
     center = np.clip(center, 0.0, None)
-    if center.sum() == 0:
+
+    if center.sum() <= 0:
         center = np.ones_like(center) / len(center)
-    # normalize to percentages
+
+    # Normalize & to percentages
     norm = center / center.sum()
-    perc = (norm * 100.0).round(3)
+    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()
 
 def is_bell_shaped(perc_list):
@@ -746,8 +777,12 @@ async def predict_bloom(req: BloomPredictionRequest):
         for mr in monthly_results
     ], dtype=float)
 
+    print("DEBUG raw_probs (months 1..12):", raw_probs.tolist())
+    print("DEBUG raw_probs stats -> min, max, mean:", float(raw_probs.min()), float(raw_probs.max()), float(raw_probs.mean()))
+    
     # Compute smoothed curve
     monthly_perc = smooth_monthly_probs(raw_probs.tolist(), alpha=ALPHA, sigma=SMOOTH_SIGMA)
+    print("DEBUG monthly_perc:", monthly_perc)
     monthly_curve = {i+1: float(monthly_perc[i]) for i in range(12)}
     
     # Check bell shape