Upload app.py

2.CNN/app.py

@@ -158,9 +158,11 @@ def erode_binary_like(arr, radius=1):
 def generate_inference_variants(arr, *, fast: bool = False):
     variants = []
     if fast:
-        # Space-optimized: only cardinal shifts (4 variants)
+        # Space-optimized: cardinal shifts plus light morphology (6 variants)
         for dy, dx in ((-1, 0), (1, 0), (0, -1), (0, 1)):
             variants.append(shift_with_zero_pad(arr, dy, dx))
+        variants.append(dilate_binary_like(arr, radius=1))
+        variants.append(erode_binary_like(arr, radius=1))
         return variants
     # Full set: 8 shifts + morphology
     for dy in (-1, 0, 1):
@@ -308,17 +310,34 @@ def preprocess_image(img_input, stroke_scale: float = 1.0, *, auto_balance: bool
             clamp=(0.7, 1.4),
         )
 
-    augmented_arrays = [arr_resized, *generate_inference_variants(arr_resized, fast=IS_SPACE)]
-    augmented_standardized = [
-        (arr.reshape(TARGET_HEIGHT * TARGET_WIDTH, 1) - mean) / std_safe
-        for arr in augmented_arrays
-    ]
-
-    mean_diff = np.abs(arr_resized - mean_image)
+    # Light recentering by center-of-mass to reduce sensitivity to placement
+    mass = arr_resized
+    total_intensity = float(mass.sum())
+    arr_centered = arr_resized
+    if total_intensity > 1e-6:
+        gy, gx = np.indices(mass.shape)
+        cy = float((gy * mass).sum() / total_intensity)
+        cx = float((gx * mass).sum() / total_intensity)
+        ideal_cy = (TARGET_HEIGHT - 1) / 2.0
+        ideal_cx = (TARGET_WIDTH - 1) / 2.0
+        dy = int(np.clip(round(ideal_cy - cy), -2, 2))
+        dx = int(np.clip(round(ideal_cx - cx), -2, 2))
+        if dy != 0 or dx != 0:
+            arr_centered = shift_with_zero_pad(arr_resized, dy, dx)
+
+    augmented_arrays = [arr_centered, *generate_inference_variants(arr_centered, fast=IS_SPACE)]
+    # Standardize each variant and clip to tame outliers for stable inference
+    augmented_standardized = []
+    for arr in augmented_arrays:
+        z = (arr.reshape(TARGET_HEIGHT * TARGET_WIDTH, 1) - mean) / std_safe
+        z = np.clip(z, -8.0, 8.0)
+        augmented_standardized.append(z.astype(np.float32, copy=False))
+
+    mean_diff = np.abs(arr_centered - mean_image)
     mean_diff_uint8 = (mean_diff / (mean_diff.max() + 1e-8) * 255.0).astype(np.uint8)
 
     diagnostics = compute_diagnostics(
-        arr_resized,
+        arr_centered,
         bbox,
         original_canvas_shape,
         mean_image,
@@ -331,7 +350,7 @@ def preprocess_image(img_input, stroke_scale: float = 1.0, *, auto_balance: bool
         "mass_fraction_after": float(balanced_mass_fraction),
     }
 
-    return augmented_standardized, arr_resized, mean_diff_uint8, diagnostics
+    return augmented_standardized, arr_centered, mean_diff_uint8, diagnostics
 
 
 def compute_diagnostics(arr_float, bbox, original_shape, mean_image, standardized, std_safe):
@@ -528,9 +547,8 @@ def predict_number(left_canvas, right_canvas, stroke_scale, auto_balance):
 
     variants_matrix = np.concatenate(standardized_variants, axis=1).astype(np.float32, copy=False)
     cache, probs_matrix = forward_prop(variants_matrix, params, training=False)
-    logits_matrix = cache["Z_fc2"]
-    avg_logits = np.mean(logits_matrix, axis=1, keepdims=True)
-    probs = softmax(avg_logits)
+    # Average probabilities across variants to reduce domination by any single variant
+    probs = np.mean(probs_matrix, axis=1, keepdims=True)
 
     pred = int(get_predictions(probs)[0])