Upload 6 files

spectral/notebooks/experiment_2_manifold_structures.ipynb

@@ -1390,10 +1390,12 @@
     "        print(f\"[PERF] AMP enabled \u2014 dtype={amp_dtype}\")\n",
     "\n",
     "    # \u2500\u2500 torch.compile \u2500\u2500\n",
+    "    # Use mode='default' (dynamo tracing) not 'reduce-overhead' (CUDA graphs)\n",
+    "    # because CUDA graphs don't support dynamic ops like torch.linalg.svd/qr/eigvalsh\n",
     "    if use_compile and hasattr(torch, 'compile'):\n",
     "        try:\n",
-    "            model = torch.compile(model, mode='reduce-overhead')\n",
-    "            print(\"[PERF] torch.compile enabled (reduce-overhead)\")\n",
+    "            model = torch.compile(model, mode='default')\n",
+    "            print(\"[PERF] torch.compile enabled (default \u2014 dynamo tracing)\")\n",
     "        except Exception as e:\n",
     "            print(f\"[PERF] torch.compile skipped: {e}\")\n",
     "\n",
@@ -1770,6 +1772,7 @@
     "        self.output_dim = self.n_patches * self.features_per_patch\n",
     "        print(f\"[GRASS] {self.n_patches} patches, k={k}, dim={self.output_dim}\")\n",
     "\n",
+    "    @torch.amp.custom_fwd(device_type='cuda', cast_inputs=torch.float32)\n",
     "    def forward(self, x):\n",
     "        B, C, H, W = x.shape\n",
     "        ps = self.patch_size\n",
@@ -1778,6 +1781,7 @@
     "        n_p = patches.shape[1]\n",
     "        # Reshape to (B*n_patches, ps*ps, C) for batched SVD\n",
     "        patches_flat = patches.reshape(B * n_p, C, ps * ps).permute(0, 2, 1)  # (B*n_p, ps*ps, C)\n",
+    "        # SVD requires FP32 \u2014 cusolver does not support BF16/FP16\n",
     "        U, S, Vh = torch.linalg.svd(patches_flat, full_matrices=False)\n",
     "        # Top-k singular values\n",
     "        sk = S[:, :self.k]  # (B*n_p, k)\n",
@@ -1836,17 +1840,18 @@
     "        self.output_dim = self.n_patches * self.features_per_patch\n",
     "        print(f\"[FLAG] {self.n_patches} patches, levels={levels}, dim={self.output_dim}\")\n",
     "\n",
+    "    @torch.amp.custom_fwd(device_type='cuda', cast_inputs=torch.float32)\n",
     "    def forward(self, x):\n",
     "        B, C, H, W = x.shape\n",
     "        ps = self.patch_size\n",
     "        patches = x.unfold(2, ps, ps).unfold(3, ps, ps)\n",
     "        n_p = patches.shape[2] * patches.shape[3]\n",
     "        patches = patches.contiguous().reshape(B * n_p, C, ps * ps)\n",
-    "        # SVD \u2014 batched: (B*n_p, C, ps*ps)\n",
+    "        # SVD \u2014 batched, FP32 (cusolver requirement)\n",
     "        if C <= ps * ps:\n",
-    "            mat = patches  # (B*n_p, C, ps*ps)\n",
+    "            mat = patches\n",
     "        else:\n",
-    "            mat = patches.transpose(1, 2)  # (B*n_p, ps*ps, C)\n",
+    "            mat = patches.transpose(1, 2)\n",
     "        U, S, Vh = torch.linalg.svd(mat, full_matrices=False)\n",
     "        # Collect features at each flag level\n",
     "        max_k = max(self.levels)\n",

spectral/notebooks/experiment_3_compact_representations.ipynb

@@ -1389,10 +1389,12 @@
     "        print(f\"[PERF] AMP enabled \u2014 dtype={amp_dtype}\")\n",
     "\n",
     "    # \u2500\u2500 torch.compile \u2500\u2500\n",
+    "    # Use mode='default' (dynamo tracing) not 'reduce-overhead' (CUDA graphs)\n",
+    "    # because CUDA graphs don't support dynamic ops like torch.linalg.svd/qr/eigvalsh\n",
     "    if use_compile and hasattr(torch, 'compile'):\n",
     "        try:\n",
-    "            model = torch.compile(model, mode='reduce-overhead')\n",
-    "            print(\"[PERF] torch.compile enabled (reduce-overhead)\")\n",
+    "            model = torch.compile(model, mode='default')\n",
+    "            print(\"[PERF] torch.compile enabled (default \u2014 dynamo tracing)\")\n",
     "        except Exception as e:\n",
     "            print(f\"[PERF] torch.compile skipped: {e}\")\n",
     "\n",

spectral/notebooks/experiment_4_invertible_transforms.ipynb

@@ -1390,10 +1390,12 @@
     "        print(f\"[PERF] AMP enabled \u2014 dtype={amp_dtype}\")\n",
     "\n",
     "    # \u2500\u2500 torch.compile \u2500\u2500\n",
+    "    # Use mode='default' (dynamo tracing) not 'reduce-overhead' (CUDA graphs)\n",
+    "    # because CUDA graphs don't support dynamic ops like torch.linalg.svd/qr/eigvalsh\n",
     "    if use_compile and hasattr(torch, 'compile'):\n",
     "        try:\n",
-    "            model = torch.compile(model, mode='reduce-overhead')\n",
-    "            print(\"[PERF] torch.compile enabled (reduce-overhead)\")\n",
+    "            model = torch.compile(model, mode='default')\n",
+    "            print(\"[PERF] torch.compile enabled (default \u2014 dynamo tracing)\")\n",
     "        except Exception as e:\n",
     "            print(f\"[PERF] torch.compile skipped: {e}\")\n",
     "\n",

spectral/notebooks/experiment_5_matrix_decompositions.ipynb

@@ -1390,10 +1390,12 @@
     "        print(f\"[PERF] AMP enabled \u2014 dtype={amp_dtype}\")\n",
     "\n",
     "    # \u2500\u2500 torch.compile \u2500\u2500\n",
+    "    # Use mode='default' (dynamo tracing) not 'reduce-overhead' (CUDA graphs)\n",
+    "    # because CUDA graphs don't support dynamic ops like torch.linalg.svd/qr/eigvalsh\n",
     "    if use_compile and hasattr(torch, 'compile'):\n",
     "        try:\n",
-    "            model = torch.compile(model, mode='reduce-overhead')\n",
-    "            print(\"[PERF] torch.compile enabled (reduce-overhead)\")\n",
+    "            model = torch.compile(model, mode='default')\n",
+    "            print(\"[PERF] torch.compile enabled (default \u2014 dynamo tracing)\")\n",
     "        except Exception as e:\n",
     "            print(f\"[PERF] torch.compile skipped: {e}\")\n",
     "\n",
@@ -1707,15 +1709,15 @@
     "        self.output_dim = n_patches * n_upper\n",
     "        print(f\"[QR] {n_patches} patches, k={k}, dim={self.output_dim}\")\n",
     "\n",
+    "    @torch.amp.custom_fwd(device_type='cuda', cast_inputs=torch.float32)\n",
     "    def forward(self, x):\n",
     "        B, C, H, W = x.shape\n",
     "        ps = self.patch_size\n",
     "        patches = x.unfold(2, ps, ps).unfold(3, ps, ps)\n",
     "        n_p = patches.shape[2] * patches.shape[3]\n",
     "        patches = patches.contiguous().reshape(B * n_p, C, ps * ps)\n",
-    "        # Batched QR: (B*n_p, ps*ps, C)\n",
+    "        # Batched QR in FP32 (cusolver requirement)\n",
     "        Q, R = torch.linalg.qr(patches.transpose(1, 2))\n",
-    "        # Upper triangle of R: R is (B*n_p, C, C), take upper tri\n",
     "        k = self.k\n",
     "        triu_idx = torch.triu_indices(k, k)\n",
     "        upper = R[:, triu_idx[0], triu_idx[1]]  # (B*n_p, k*(k+1)/2)\n",
@@ -1762,15 +1764,15 @@
     "        self.output_dim = n_patches * n_eig * 2  # eigenvalues + phases\n",
     "        print(f\"[SCHUR] {n_patches} patches, n_eig={n_eig}, dim={self.output_dim}\")\n",
     "\n",
+    "    @torch.amp.custom_fwd(device_type='cuda', cast_inputs=torch.float32)\n",
     "    def forward(self, x):\n",
     "        B, C, H, W = x.shape\n",
     "        ps = self.patch_size\n",
     "        patches = x.unfold(2, ps, ps).unfold(3, ps, ps)\n",
     "        n_p = patches.shape[2] * patches.shape[3]\n",
     "        patches = patches.contiguous().reshape(B * n_p, C, ps * ps)\n",
-    "        # Batched covariance: (B*n_p, C, C)\n",
+    "        # Batched covariance in FP32 (cusolver requirement)\n",
     "        cov = torch.bmm(patches, patches.transpose(1, 2)) / (ps * ps)\n",
-    "        # Batched eigenvalues: (B*n_p, C)\n",
     "        eigvals = torch.linalg.eigvalsh(cov)\n",
     "        # Top n_eig eigenvalues (eigvalsh returns ascending, so take last n_eig)\n",
     "        top = eigvals[:, -self.n_eig:]  # (B*n_p, n_eig)\n",

spectral/notebooks/experiment_6_losses_and_anchors.ipynb

@@ -1392,10 +1392,12 @@
     "        print(f\"[PERF] AMP enabled \u2014 dtype={amp_dtype}\")\n",
     "\n",
     "    # \u2500\u2500 torch.compile \u2500\u2500\n",
+    "    # Use mode='default' (dynamo tracing) not 'reduce-overhead' (CUDA graphs)\n",
+    "    # because CUDA graphs don't support dynamic ops like torch.linalg.svd/qr/eigvalsh\n",
     "    if use_compile and hasattr(torch, 'compile'):\n",
     "        try:\n",
-    "            model = torch.compile(model, mode='reduce-overhead')\n",
-    "            print(\"[PERF] torch.compile enabled (reduce-overhead)\")\n",
+    "            model = torch.compile(model, mode='default')\n",
+    "            print(\"[PERF] torch.compile enabled (default \u2014 dynamo tracing)\")\n",
     "        except Exception as e:\n",
     "            print(f\"[PERF] torch.compile skipped: {e}\")\n",
     "\n",

spectral/notebooks/experiment_7_composite_pipelines.ipynb

@@ -1390,10 +1390,12 @@
     "        print(f\"[PERF] AMP enabled \u2014 dtype={amp_dtype}\")\n",
     "\n",
     "    # \u2500\u2500 torch.compile \u2500\u2500\n",
+    "    # Use mode='default' (dynamo tracing) not 'reduce-overhead' (CUDA graphs)\n",
+    "    # because CUDA graphs don't support dynamic ops like torch.linalg.svd/qr/eigvalsh\n",
     "    if use_compile and hasattr(torch, 'compile'):\n",
     "        try:\n",
-    "            model = torch.compile(model, mode='reduce-overhead')\n",
-    "            print(\"[PERF] torch.compile enabled (reduce-overhead)\")\n",
+    "            model = torch.compile(model, mode='default')\n",
+    "            print(\"[PERF] torch.compile enabled (default \u2014 dynamo tracing)\")\n",
     "        except Exception as e:\n",
     "            print(f\"[PERF] torch.compile skipped: {e}\")\n",
     "\n",