Update app.py

app.py

@@ -3,7 +3,7 @@
 MelodyDeterminism - Canonical Determinism Demo (NumPy-only, CPU)
 Esteso con:
 - PRNG switch: philox (veloce, GPU-like) / sha256 (indipendente)
-- Somma softmax: kahan (precisa) / tree (pairwise, GPU-like)
+- Softmax canonica con riduzioni pairwise: max tree + sum (kahan/tree)
 - Edge test: maschere, ±inf, nan, invariance a shift, idempotenza
 - dtype selezionabile, benchmark parametrico
 """
@@ -54,7 +54,6 @@ class D:
         - sha256: indipendente da NumPy, più lento
         """
         if PRNG_MODE == "philox":
-            # Usa seed+counter come "chiave" del blocco
             return _philox_random(seed + counter, shape)
 
         # Fallback SHA256 (deterministico, ma lento)
@@ -73,21 +72,42 @@ class D:
         arr = np.array(vals, dtype=np.float64).reshape(shape)
         return arr.astype(np.float32, copy=False)
 
+    @staticmethod
+    def _tree_sum_row(vec64: np.ndarray) -> float:
+        v = np.asarray(vec64, dtype=np.float64)
+        n = v.size
+        m = 1 << (n - 1).bit_length()
+        if m != n:
+            v = np.pad(v, (0, m - n), constant_values=0.0)
+        while v.size > 1:
+            v = v[0::2] + v[1::2]
+        return float(v[0])
+
+    @staticmethod
+    def _tree_max_row(vec64: np.ndarray) -> float:
+        """Riduzione deterministica del massimo (pairwise, GPU-like)."""
+        v = np.asarray(vec64, dtype=np.float64)
+        n = v.size
+        m = 1 << (n - 1).bit_length()
+        if m != n:
+            v = np.pad(v, (0, m - n), constant_values=-np.inf)
+        while v.size > 1:
+            v = np.maximum(v[0::2], v[1::2])
+        return float(v[0])
+
     @staticmethod
     def tree_fixed_reduce(x: np.ndarray) -> np.float64:
+        """Somma pairwise deterministica su vettore intero."""
         y = np.asarray(x, dtype=np.float64).reshape(-1)
         if y.size == 0:
             return np.float64(0.0)
-        level = y.copy()
-        while level.size > 1:
-            n = level.size
-            pair_n = n // 2
-            summed = (level[:2*pair_n].reshape(pair_n, 2)).sum(axis=1, dtype=np.float64)
-            if n % 2 == 1:
-                level = np.concatenate([summed, level[-1:].astype(np.float64)], axis=0)
-            else:
-                level = summed
-        return np.float64(level[0])
+        n = y.size
+        m = 1 << (n - 1).bit_length()
+        if m != n:
+            y = np.pad(y, (0, m - n), constant_values=0.0)
+        while y.size > 1:
+            y = y[0::2] + y[1::2]
+        return np.float64(y[0])
 
     @staticmethod
     def kahan_sum(x: np.ndarray) -> np.float64:
@@ -101,23 +121,13 @@ class D:
             s = t
         return s
 
-    @staticmethod
-    def _tree_sum_row(vec64: np.ndarray) -> float:
-        v = np.asarray(vec64, dtype=np.float64)
-        n = v.size
-        m = 1 << (n - 1).bit_length()
-        if m != n:
-            v = np.pad(v, (0, m - n), constant_values=0.0)
-        while v.size > 1:
-            v = v[0::2] + v[1::2]
-        return float(v[0])
-
     @staticmethod
     def deterministic_softmax(x: np.ndarray, axis: int = -1, mask: np.ndarray = None, sum_mode: str = "kahan") -> np.ndarray:
         """
         Softmax stabile e deterministica.
-        sum_mode: 'kahan' (massima precisione) | 'tree' (pairwise GPU-like)
-        mask: True = valido, False = mascherato a -inf
+        - max pairwise (tree) per asse scelto (GPU-like)
+        - sum_mode: 'kahan' (più precisa) | 'tree' (pairwise GPU-like)
+        - mask: True = valido, False = mascherato a -inf
         """
         x64 = np.asarray(x, dtype=np.float64)
         if mask is not None:
@@ -125,16 +135,21 @@ class D:
         if axis < 0:
             axis = x64.ndim + axis
 
-        m = np.max(x64, axis=axis, keepdims=True)
+        # --- max deterministico pairwise lungo axis ---
+        x_move = np.moveaxis(x64, axis, -1)  # [..., L]
+        flatx = x_move.reshape(-1, x_move.shape[-1])
+        m_rows = np.array([D._tree_max_row(flatx[i]) for i in range(flatx.shape[0])], dtype=np.float64)
+        m = np.moveaxis(m_rows.reshape(x_move.shape[:-1] + (1,)), -1, axis)
+
         z = np.exp(x64 - m)
 
+        # --- sum deterministica (kahan/tree) lungo axis ---
         z_move = np.moveaxis(z, axis, -1)  # [..., L]
         flat = z_move.reshape(-1, z_move.shape[-1])
 
         if sum_mode == "tree":
             sums = np.array([D._tree_sum_row(flat[i]) for i in range(flat.shape[0])], dtype=np.float64)
         else:
-            # Kahan lungo l'ultima dimensione
             sums = np.zeros((flat.shape[0],), dtype=np.float64)
             comp = np.zeros((flat.shape[0],), dtype=np.float64)
             for j in range(flat.shape[-1]):
@@ -154,10 +169,10 @@ class D:
     def deterministic_categorical(logits: np.ndarray, num_samples: int, seed: int, sum_mode: str = "kahan") -> np.ndarray:
         """
         Sampling deterministico (vectorizzato):
-        - softmax canonica (sum_mode: kahan/tree)
+        - softmax canonica (max tree, sum kahan/tree)
         - CDF una volta
         - U in blocco con PRNG dichiarativo (philox/sha256)
-        - searchsorted(..., 'left') ⇒ tie-break deterministico
+        - searchsorted(..., 'left') ⇒ tie-break deterministico (min indice)
         """
         x = np.asarray(logits, dtype=np.float64)
         single = False
@@ -167,9 +182,13 @@ class D:
         B, V = x.shape
 
         probs = D.deterministic_softmax(x, axis=-1, sum_mode=sum_mode).astype(np.float64)
-        cdf = np.cumsum(probs, axis=-1); cdf[:, -1] = 1.0
+        cdf = np.cumsum(probs, axis=-1)
+        # clamp robusto per chiusura [0,1]
+        np.clip(cdf, 0.0, 1.0, out=cdf)
+        cdf[:, -1] = 1.0
 
         U = D.counter_prng(seed, 0, (B, num_samples)).astype(np.float64)
+        # tie-break deterministico: side='left'
         idx_rows = [np.searchsorted(cdf[b], U[b], side="left") for b in range(B)]
         out = np.stack(idx_rows, axis=0).astype(np.int64, copy=False)
         if single:
@@ -284,7 +303,7 @@ def run_full_suite(seed: int, n: int, v: int, dtype: str, sum_mode: str) -> Dict
         "shape": [n, v],
         "dtype": dtype,
         "prng": PRNG_MODE,
-        "note": "NumPy-only canonical ops; philox/sha256 PRNG selectable; softmax sum kahan/tree.",
+        "note": "NumPy-only canonical ops; philox/sha256 PRNG; softmax max/sum pairwise deterministici.",
     }
     return rep
 
@@ -294,31 +313,26 @@ def run_edge_softmax(seed: int, n: int, v: int, dtype: str, sum_mode: str) -> Di
     """
     rng = np.random.default_rng(seed)
     x = rng.standard_normal((n, v)).astype(np.float64)
-    # Inserisci estremi
+    # Estremi nella prima riga
     x[0, 0] = np.inf
     x[0, 1] = -np.inf
     x[0, 2] = np.nan
-    # Mask: valida ~80%
+    # Mask: ~80% valido
     mask = rng.random((n, v)) > 0.2
-    # Cast finale
     x = x.astype(np.float32 if dtype == "float32" else np.float64, copy=False)
 
-    # Softmax canonical con maschera
     p1 = D.deterministic_softmax(x, axis=-1, mask=mask, sum_mode=sum_mode)
-    # Invariance a shift
+    # invariance a shift
     c = 123.456
     p2 = D.deterministic_softmax(x + c, axis=-1, mask=mask, sum_mode=sum_mode)
     inv_shift = bool(np.allclose(p1, p2))
-    # Idempotenza (applicare due volte non cambia)
+    # idempotenza
     p3 = D.deterministic_softmax(p1, axis=-1, mask=np.ones_like(p1, dtype=bool), sum_mode=sum_mode)
     idempotent = bool(np.allclose(p1, p3))
-    # Somma a 1
-    sums = np.sum(p1, axis=-1)
-    conserve = bool(np.allclose(sums, 1.0))
-
+    # conserva probabilità
+    conserve = bool(np.allclose(np.sum(p1, axis=-1), 1.0))
     return {
-        "sum_mode": sum_mode,
-        "dtype": dtype,
+        "sum_mode": sum_mode, "dtype": dtype,
         "mask_ratio": float(np.mean(mask)),
         "invariance_shift": inv_shift,
         "idempotent": idempotent,
@@ -517,7 +531,7 @@ def run_benchmark_and_save(dtype: str, sum_mode: str, prng_choice: str):
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown("# MelodyDeterminism - Canonical Determinism Demo (NumPy / CPU)")
     gr.Markdown(
-        "Deterministic ops: reduce (Kahan/Tree), softmax canonica, sampling RNG dichiarativo. "
+        "Deterministic ops: reduce (Kahan/Tree), softmax canonica (max tree + sum kahan/tree), sampling RNG dichiarativo. "
         "PRNG: Philox (GPU-like) o SHA256 (indipendente). Edge: maschera, ±inf, nan, shift, idempotenza. "
         "Benchmark parametrico con overhead%."
     )
@@ -541,7 +555,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
                     n = gr.Slider(1, 256, step=1, value=8, label="Rows / Batch (n)")
                     v = gr.Slider(2, 4096, step=1, value=32, label="Width / Vocab (v)")
                     dtype = gr.Radio(["float32","float64"], value="float32", label="dtype")
-                    sum_mode = gr.Radio(["kahan","tree"], value="kahan", label="Softmax sum")
+                    sum_mode = gr.Radio(["kahan","tree"], value="tree", label="Softmax sum")  # default GPU-like
                     prng_choice = gr.Radio(["philox","sha256"], value="philox", label="PRNG")
                     run_btn = gr.Button("Run")
 
@@ -558,7 +572,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         with gr.Tab("Benchmark"):
             gr.Markdown("Confronto standard vs deterministico (sampling) con le scelte sotto.")
             dtype_b = gr.Radio(["float32","float64"], value="float32", label="dtype")
-            sum_mode_b = gr.Radio(["kahan","tree"], value="kahan", label="Softmax sum")
+            sum_mode_b = gr.Radio(["kahan","tree"], value="tree", label="Softmax sum")  # default GPU-like
             prng_b = gr.Radio(["philox","sha256"], value="philox", label="PRNG")
             bench_btn = gr.Button("Esegui benchmark")
             bench_table = gr.Dataframe(