feat: Refactor experiments and update report

README.md

@@ -10,14 +10,14 @@ app_file: app.py
 pinned: false
 ---
 
-# SVD vs CNN: Mechanistic Analysis of Manifold Alignment on MNIST
+# Why Does SVD Turn a "3" into an "8"? Linear vs. Non-linear Manifolds on MNIST
 
 [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/ymlin105/Coconut-MNIST) [![Full Report](https://img.shields.io/badge/📖_Read-Full_Report-blue)](./docs/REPORT.md)
 
 While it is a known theoretical property that linear dimensionality reduction (SVD) acts as a low-pass filter, this project provides a **concrete, visual, and quantitative mechanistic explanation** of how this property manifests in neural network classification—specifically, why linear subspaces consistently force a "3" to collapse into an "8".
 
 <p align="center">
-  <img src="./docs/research_results/fig_06_explainability.png" width="600" alt="Mechanistic Analysis of SVD Inductive Bias">
+  <img src="./docs/research_results/fig_04_explainability.png" width="600" alt="Mechanistic Analysis: SVD Blind Spot">
 </p>
 
 By mapping the exact decision boundaries where linear global variance models fail and non-linear topological models (CNNs) succeed, I empirically validate the **inherent trade-offs** of linear denoising in high-stakes domains like medical imaging or satellite data—where a linear filter might suppress critical diagnostic features to minimize noise variance.
@@ -93,7 +93,7 @@ streamlit run app.py
 ### Project Structure
 ```
 ├── src/               Core modules (CNN, SVD layer) + Experimental Utils
-├── experiments/       Theme-based scripts (01 Diagnosis, 02 Analysis, 03 Robustness)
+├── experiments/       Sequential scripts (01 Diagnosis, 02 Proof, 03 Boundaries)
 ├── docs/              Full report (REPORT.md) + figures
 ├── models/            Pretrained checkpoints
 ├── run_all_experiments.sh  One-click reproduction script

app.py

@@ -144,7 +144,13 @@ def get_reconstruction(svd_model, img_flat):
     recons = svd_model.inverse_transform(svd_model.transform(flat))
     if mean is not None:
         recons = recons + mean
-    return torch.clamp(torch.tensor(recons).float(), 0, 1).view(28, 28)
+    
+    # Monitor truncation ratio
+    out_of_range = (recons < 0) | (recons > 1)
+    clamp_ratio = np.mean(out_of_range)
+    
+    recons_tensor = torch.clamp(torch.tensor(recons).float(), 0, 1).view(28, 28)
+    return recons_tensor, clamp_ratio
 
 
 # --- UI Sidebar ---
@@ -161,6 +167,14 @@ with st.sidebar:
     )
     if noise_mode:
         st.success("SVD Denoising Active")
+    
+    st.markdown("---")
+    st.subheader("Model Calibration")
+    temp_scaling = st.slider(
+        "Softmax Temperature (T)", 
+        0.1, 5.0, 1.0, 0.1,
+        help="Higher T = smoother transitions (less over-confident), Lower T = sharper 'snaps'."
+    )
 
 
 # --- Initialization ---
@@ -204,11 +218,11 @@ with tab1:
     img_s = X_flat[np.where(y_orig == start_digit)[0][0]]
     img_e = X_flat[np.where(y_orig == end_digit)[0][0]]
     img_interp = (1 - alpha) * img_s + alpha * img_e
-    img_svd = get_reconstruction(svd_model, img_interp)
+    img_svd, clamp_ratio = get_reconstruction(svd_model, img_interp)
 
     with torch.no_grad():
         logits = cnn_model(img_interp.view(1, 1, 28, 28))
-        probs = torch.softmax(logits, dim=1)
+        probs = torch.softmax(logits / temp_scaling, dim=1)
         conf, pred = torch.max(probs, 1)
 
     # Visual Display
@@ -219,11 +233,35 @@ with tab1:
     with v2:
         st.markdown("**SVD Reconstruction**")
         st.image(img_svd.numpy(), width=150)
+        st.caption(f"Truncation: {clamp_ratio:.1%}")
     with v3:
         st.markdown(f"**CNN Prediction: {pred.item()}**")
         st.progress(conf.item(), text=f"Confidence: {conf.item():.1%}")
         st.caption("Note: CNN 'snaps' at the topological midpoint, not a smooth transition.")
 
+    # --- Confidence Curve Visualization ---
+    alphas_curve = np.linspace(0, 1, 21)
+    curve_probs = []
+    
+    with torch.no_grad():
+        for a in alphas_curve:
+            img_a = (1 - a) * img_s + a * img_e
+            logits_a = cnn_model(img_a.view(1, 1, 28, 28))
+            probs_a = torch.softmax(logits_a / temp_scaling, dim=1)
+            # Probability of being the "end_digit"
+            curve_probs.append(probs_a[0, end_digit].item())
+            
+    st.markdown("---")
+    st.markdown(f"#### Confidence Snap: Probability of '{end_digit}'")
+    
+    df_curve = pd.DataFrame({
+        "alpha": alphas_curve,
+        "Probability": curve_probs
+    }).set_index("alpha")
+    
+    st.line_chart(df_curve, height=200)
+    st.caption(f"The vertical 'snap' in this curve highlights the non-linear decision boundary. Even as the pixels fade linearly, the CNN's internal representation jumps once a topological threshold is crossed.")
+
 
 # --- Tab 2: Robustness (The SVD Advantage) ---
 with tab2:
@@ -237,12 +275,12 @@ with tab2:
     
     img_clean = X_flat[np.where(y_orig == noise_digit)[0][0]]
     img_noisy = torch.clamp(img_clean + torch.randn_like(img_clean) * sigma, 0, 1)
-    img_denoised = get_reconstruction(svd_model, img_noisy)
+    img_denoised, clamp_ratio_robust = get_reconstruction(svd_model, img_noisy)
 
     with col2:
         res1, res2 = st.columns(2)
         res1.image(img_noisy.view(28, 28).numpy(), caption="Noisy Input", width=150)
-        res2.image(img_denoised.numpy(), caption="SVD Subspace Projection", width=150)
+        res2.image(img_denoised.numpy(), caption=f"SVD Projection (Trunc: {clamp_ratio_robust:.1%})", width=150)
         
     st.markdown("---")
     st.markdown("#### Accuracy Breakdown at This Noise Level")
@@ -257,8 +295,10 @@ with tab2:
         results = data["results"]
 
         def interp(model_name: str, s: float) -> float:
+            # Robust boundary treatment for floating point sigma
+            s_clipped = np.clip(s, levels.min(), levels.max())
             vals = np.array(results[model_name], dtype=float)
-            return float(np.interp(s, levels, vals))
+            return float(np.interp(s_clipped, levels, vals))
 
         acc_svd = interp("SVD", sigma)
         acc_cnn = interp("CNN", sigma)
@@ -334,7 +374,8 @@ with tab3:
             )
             fig_svd.update_layout(
                 margin=dict(l=20, r=20, b=40, t=20), 
-                showlegend=False,
+                showlegend=True,
+                legend=dict(orientation="h", yanchor="top", y=-0.15, xanchor="center", x=0.5),
                 xaxis_title="Component 1",
                 yaxis_title="Component 2"
             )
@@ -353,7 +394,8 @@ with tab3:
             )
             fig_umap.update_layout(
                 margin=dict(l=20, r=20, b=40, t=20), 
-                showlegend=False,
+                showlegend=True,
+                legend=dict(orientation="h", yanchor="top", y=-0.15, xanchor="center", x=0.5),
                 xaxis_title="UMAP 1",
                 yaxis_title="UMAP 2"
             )
@@ -421,7 +463,7 @@ with tab4:
             if add_noise:
                 img_sample = torch.clamp(img_sample + torch.randn_like(img_sample) * noise_sigma, 0, 1)
             
-            img_svd_sample = get_reconstruction(svd_model, img_sample)
+            img_svd_sample, clamp_ratio_lab = get_reconstruction(svd_model, img_sample)
             
             if noise_mode:
                 cnn_input = img_svd_sample.view(1, 1, 28, 28)
@@ -429,7 +471,7 @@ with tab4:
                 cnn_input = img_sample.view(1, 1, 28, 28)
             
             with torch.no_grad():
-                probs = torch.softmax(cnn_model(cnn_input), dim=1)
+                probs = torch.softmax(cnn_model(cnn_input) / temp_scaling, dim=1)
                 conf, pred = torch.max(probs, 1)
             
             r1, r2, r3 = st.columns(3)
@@ -441,6 +483,7 @@ with tab4:
             with r2:
                 st.markdown("**SVD Projection**")
                 st.image(img_svd_sample.numpy(), width=120)
+                st.caption(f"Truncation: {clamp_ratio_lab:.1%}")
             
             with r3:
                 st.markdown(f"**Prediction: {pred.item()}**")
@@ -454,6 +497,7 @@ with tab4:
     
     else:  # Draw Digit
         st.info("Draw a digit in the box below. SVD and CNN will analyze it in real-time.")
+        st.caption("*Tip: Draw the digit large and centered for best results.*")
         
         col_canvas, col_preview = st.columns([1, 1])
         
@@ -481,7 +525,7 @@ with tab4:
                 img_tensor = torch.tensor(img_resized, dtype=torch.float32) / 255.0
                 
                 img_flat_up = img_tensor.view(1, 784)
-                img_svd_up = get_reconstruction(svd_model, img_flat_up)
+                img_svd_up, clamp_ratio_draw = get_reconstruction(svd_model, img_flat_up)
                 
                 if noise_mode:
                     cnn_input = img_svd_up.view(1, 1, 28, 28)
@@ -489,7 +533,7 @@ with tab4:
                     cnn_input = img_tensor.view(1, 1, 28, 28)
                 
                 with torch.no_grad():
-                    probs = torch.softmax(cnn_model(cnn_input), dim=1)
+                    probs = torch.softmax(cnn_model(cnn_input) / temp_scaling, dim=1)
                     conf, pred = torch.max(probs, 1)
                 
                 with col_preview:
@@ -503,6 +547,7 @@ with tab4:
                     with r1:
                         st.markdown("**SVD View**")
                         st.image(img_svd_up.numpy(), width=100)
+                        st.caption(f"Truncation: {clamp_ratio_draw:.1%}")
                     with r2:
                         if noise_mode:
                             st.caption("Using SVD Denoised Input")

docs/REPORT.md

@@ -1,125 +1,129 @@
-# Mechanistic Analysis of Linear vs. Non-linear Manifolds on MNIST: A Validation of Inductive Biases
+# Why Does SVD Turn a "3" into an "8"? A Mechanistic Comparison of Linear vs. Non-linear Manifolds
 
-While linear dimensionality reduction (SVD) is a standard low-pass filter, its failure modes in classification are often described as "accuracy drops" without mechanistic explanation. This report provides a concrete, visual, and quantitative analysis of how linear subspaces consistently force a "3" to collapse into an "8". By mapping the exact decision boundaries where global variance models fail and non-linear topological models (CNNs) succeed, we empirically validate the inherent trade-offs of linear denoising in classification tasks.
+Why do linear models fail at tasks that seem trivial to a human or a simple neural network? While it is a known property that linear dimensionality reduction (SVD) acts as a low-pass filter, this report provides a **concrete, visual, and mechanistic explanation** of how this manifests in classification—specifically, why linear subspaces force a "3" to collapse into an "8".
+
+By mapping the decision boundaries where linear global variance models fail and non-linear topological models (CNNs) succeed, we validate the **inherent trade-offs** of linear denoising in high-stakes domains like medical imaging or satellite data—where a linear filter might suppress critical diagnostic features to minimize noise variance.
+
+---
+
+## TL;DR: The 15-Second Summary
+
+- **The Problem (The Variance Trap):** SVD prioritizes global pixel energy. In a '3', the tiny gap that distinguishes it from an '8' has very low variance, so SVD deletes it as "noise."
+- **The Mechanism:** Linear models see **Global Energy** (the overall silhouette), while CNNs see **Local Topology** (the gap). SVD literally "welds" the ends of a '3' together to minimize reconstruction error.
+- **The Solution & Boundary: We built a Hybrid SVD→CNN pipeline.** While SVD fails as a standalone classifier, it works as a powerful **low-pass filter** and defensive shield against high noise ($\sigma=0.7$), provided the data isn't too texture-rich (like Fashion-MNIST).
 
 ---
 
-## I. Executive Summary
+## The Investigative Approach
 
-- **The Variance Trap**: SVD-like methods behave as global low-pass filters that prioritize high-energy shared structures over local discriminative cues. In digits like '3', the critical topological gap has low pixel variance and is thus suppressed as "noise."
-- **Quantitative Manifold Collapse**: We demonstrate that linear projection **more than doubles the classification error rate (+130% relative increase)** on ambiguous pairs, providing "iron-clad" proof that SVD intrinsically destroys discriminative manifold information.
-- **Operational Boundary**: A Hybrid SVD→CNN pipeline provides significant robustness gains in high-noise environments ($\sigma=0.7$) but fails on texture-rich data (Fashion-MNIST), defining its scope as a specialized shape-driven filter.
+```text
+Diagnosis                  Mechanism                   Solution & Boundary
+─────────────────────      ─────────────────────        ─────────────────────
+SVD fails on 3 vs 8   →   Why? Grad-CAM + UMAP    →   Hybrid SVD→CNN pipeline
+(The Variance Trap)        (Global vs. Local)          + Texture stress test
+```
 
 ---
 
-## II. The Phenomenon: Linear Subspace Failure on Digit Manifolds
+## 1. Diagnosis: The "3 vs 8" Failure Mode
 
-Linear dimensionality reduction (SVD) on full MNIST yields an accuracy of 88.12%. However, this aggregate metric masks a systematic failure mode: digits with high pixel-wise overlap (3/8, 5/3, 4/9) exhibit catastrophic confusion.
+Aggregate accuracy metrics often hide the real story. While SVD achieves 88.1% accuracy on MNIST, it systematically fails on digits with high pixel overlap.
 
-### Spectral Diagnosis: Variance vs. Discrimination
-Applying SVD to the isolated '3 vs 8' subset reveals that the first 10 principal components (eigen-digits) capture 49.2% of the total variance. 
+### The Variance Trap
+Linear dimensionality reduction (SVD) treats classification like a reconstruction problem. It looks for the directions of maximum variance (total pixel brightness). In the cluster of 3s and 8s, the shared "8-like" outline contains the most energy. The small gap that makes a '3' unique is mathematically ignored.
 
 <p align="center">
-  <img src="research_results/fig_02_svd_confusion.png" alt="Fig 1: Confusion matrix for Global SVD" width="350" />
-  <img src="research_results/fig_03_eigen_digits.png" alt="Fig 3: Eigen-digits" width="350" />
+  <img src="research_results/fig_01_svd_confusion.png" alt="SVD Confusion Matrix" width="350" />
+  <img src="research_results/fig_02_eigen_digits.png" alt="SVD Eigen-digits" width="350" />
   <br>
-  <em>Figure 1 & 2: SVD confusion matrix and the resulting eigen-digits. The principal components emphasize the shared circular energy common to both digits (the "8-like" outline), while attenuating the discriminative gap of the '3' as low-variance residual.</em>
+  <em><strong>Figure 1 & 2:</strong> SVD concentrates its errors on ambiguous pairs. The first few "eigen-digits" capture the shared circular structure, smoothing over the critical discriminative gap.</em>
 </p>
 
-This identifies the **Variance-Discrimination Paradox**: SVD optimizes for reconstruction (global energy) rather than separation (local topology). Since the "8-like" silhouette contains more pixel variance than the tiny gap in a '3', the linear model "hallucinates" a closed loop to minimize reconstruction error.
-
 ---
 
-## III. Mechanistic Proof: Global Variance vs. Local Topology
+## 2. Mechanism: Global Energy vs. Local Topology
 
-To confirm that the failure is intrinsic to the linear projection method, we contrast SVD with a small CNN and a non-linear manifold mapping (UMAP).
+To understand *why* this happens, we compared how a CNN (non-linear) and SVD (linear) "see" the same image.
 
-### 1. Dynamic Snap vs. The Variance Trap
-We observed class responses while smoothly interpolating a '3' into an '8'. 
+### Linear Hallucination
+When we interpolate a '3' into an '8', the CNN shows a sharp "snap" in confidence—it recognizes a topological boundary. In contrast, SVD's reconstruction error peaks at the midpoint because it's trying to fit a "linear bridge" between two distinct manifolds.
 
 <p align="center">
-  <img src="research_results/fig_05_interpolation.png" alt="Fig 5: Decision Boundary Interpolation" width="700" />
+  <img src="research_results/fig_03_interpolation.png" alt="Decision Boundary Interpolation" width="700" />
   <br>
-  <em>Figure 3: CNN class probability (light blue) vs SVD reconstruction error (deep blue). The CNN's sharp "snap" indicates a learned topological boundary, while the SVD's U-shaped error dip at the midpoint proves it treats blurred, overlapping superpositions as higher-fidelity matches than the original digits.</em>
+  <em><strong>Figure 3:</strong> CNN probability vs. Manifold Distance. The CNN's sharp boundary persists, while SVD creates "ghost" images at the midpoint that don't belong to either digit.</em>
 </p>
 
-### 2. Static Attention and Hallucination
-Grad-CAM heatmaps confirm that the CNN focuses exclusively on the **topological gap**. In contrast, SVD reconstruction forcibly closes this gap to satisfy global energy constraints, effectively "reconstructing" a phantom 8.
+### Local Topology: The Gap is the Signal
+Grad-CAM heatmaps confirm that a CNN focuses exclusively on the **topological gap**. SVD, however, reconstructs a phantom loop. The linear model is "blind" to the gap because it optimizes for global pixel coincidence rather than shape continuity.
 
 <p align="center">
-  <img src="research_results/fig_06_explainability.png" alt="Fig 6: Grad-CAM vs SVD Inductive Bias" width="700" />
+  <img src="research_results/fig_04_explainability.png" alt="Grad-CAM vs SVD" width="700" />
   <br>
-  <em>Figure 4: Grad-CAM attention (center) vs. SVD reconstruction (right). CNN attention on the gap confirms it classifies by shape discontinuity; SVD's hallucination proves it classifies by global pixel coincidence.</em>
+  <em><strong>Figure 4:</strong> CNN attention (center) vs. SVD reconstruction (right). CNNs classify by shape discontinuity; SVD "hallucinates" a loop to satisfy energy constraints.</em>
 </p>
 
-### 3. Quantifying Manifold Collapse
-We use the internal accuracy of a $k$-Nearest Neighbors ($k$-NN, $k=5$) classifier as a strict benchmark for local neighborhood integrity.
-
-* **Raw 784D Pixel Space: 98.7% Accuracy (1.3% Error Rate).**
-* **SVD 10D Subspace: 97.0% Accuracy (3.0% Error Rate).**
-
-The error rate **more than doubles (+130% relative increase)** after linear projection. This provides iron-clad proof that SVD structurally forces distinct local neighborhoods of 3s and 8s to overlap, destroying information that is physically present in the pixels.
+### Quantifying Manifold Collapse
+Using $k$-NN as a benchmark, we measured the damage:
+- **Raw Pixel Space:** 98.7% Accuracy
+- **SVD Subspace:** 97.0% Accuracy
+This **130% relative increase in error** proves that SVD physically crushes the separation between 3s and 8s.
 
 <p align="center">
-  <img src="research_results/fig_08_manifold_collapse.png" alt="Figure 5: Manifold Comparison" width="600"/>
+  <img src="research_results/fig_05_manifold_collapse.png" alt="Manifold Comparison" width="600"/>
   <br>
-  <em>Figure 5: Side-by-side manifold contrast. SVD (left) collapses boundaries to maximize variance, while UMAP (right) preserves the manifold separation required for high-accuracy discrimination.</em>
+  <em><strong>Figure 5:</strong> SVD (left) collapses boundaries to maximize variance, whereas UMAP (right) preserves the topological separation required for high accuracy.</em>
 </p>
 
 ---
 
-## IV. Operational Boundaries: High-Noise Defense and Texture Limits
+## 3. Solution: Success on Low-Rank Manifolds (MNIST)
 
-While SVD fails as a standalone discriminator, its low-pass filtering property provides a powerful inductive bias in high-noise environments.
+If SVD is so bad at discriminating, why use it? Because its "Variance Trap" is a perfect **Low-Pass Filter**.
 
-### 1. SVD as a Data-Adapted Denoising Filter
-In environments with heavy Gaussian noise ($\sigma=0.7$), a standalone CNN collapses to 30.4% accuracy. However, a **Hybrid SVD→CNN** pipeline maintains **65.3% accuracy**, outperforming both the pure CNN and naive Gaussian blurring.
+In high-noise environments ($\sigma=0.7$), a raw CNN's accuracy drops to **30.1%**. A **Hybrid SVD→CNN** pipeline, however, maintains **65.5%** accuracy. By discarding low-variance dimensions, SVD acts as a "data-adapted shield," stripping away random Gaussian noise before it reaches the classifier. 
+
+However, this shield has a **blind spot**: if the noise is carefully aligned with the data's principal components (**Fig 7**), SVD preserves the noise rather than filtering it, making the model even more vulnerable than a raw CNN.
 
 <p align="center">
-  <img src="research_results/fig_robustness_mnist.png" alt="Fig 10: Hybrid Robustness" width="500" />
+  <img src="research_results/fig_06_robustness_mnist_gaussian.png" alt="Hybrid Robustness" width="450" />
+  <img src="research_results/fig_07_robustness_mnist_svd_aligned.png" alt="Subspace Risk" width="450" />
   <br>
-  <em>Figure 6: Robustness gain on MNIST. SVD reconstruction acts as a data-adapted filter, discarding destructive high-frequency noise before CNN feature extraction.</em>
+  <em><strong>Figure 6 & 7:</strong> SVD dominates under random noise (left) but becomes a liability if the noise is "aligned" with the data subspace (right), proving the defense is narrow-band.</em>
 </p>
 
-### 2. The Texture Breakdown (Fashion-MNIST)
-The defense fails on **Fashion-MNIST**, where accuracy collapses from 91% (CNN) to 67% (Hybrid). Unlike digits, fashion items (Shirts vs Pullovers) rely on high-frequency textures (buttons, collars). SVD's global silhouette objective suppresses these critical textures, defining the **physical limit** of linear denoising.
+---
+
+## 4. Boundary: Failure on Texture-Rich Manifolds (Fashion-MNIST)
+
+The SVD defense only works when the objects are simple silhouettes. On **Fashion-MNIST**, the strategy collapses.
+
+Items like Shirts and Pullovers aren't distinguished by global outlines, but by **high-frequency textures** (buttons, zippers, collar stitching). SVD's low-pass bias treats these textures as noise and deletes them. Accuracy drops from 91% (CNN) to 67% (Hybrid), defining the physical limit of linear denoising.
 
 <p align="center">
-  <img src="research_results/fig_robustness_fashion.png" alt="Fig 11: Fashion-MNIST Robustness" width="500" />
+  <img src="research_results/fig_08_robustness_fashion.png" alt="Fashion texture collapse" width="500" />
   <br>
-  <em>Figure 7: Texture collapse on Fashion-MNIST. Unlike digits, fashion items rely on high-frequency details that SVD's low-pass bias catastrophically suppresses, leading to poor robustness compared to direct CNN classification.</em>
+  <em><strong>Figure 8:</strong> On texture-rich data, SVD's "low-pass filter" becomes a "detail-destroyer," failing to preserve the features needed for non-linear models to succeed.</em>
 </p>
 
 ---
 
 ## Conclusion
-This investigation proves that SVD's reliance on global variance conflates discriminative local features with noise. While this serves as an effective low-pass filter for shape-dominated data (MNIST) under extreme corruption, it systematically degrades the manifold boundaries required for precise non-linear classification.
 
----
+This study proves that SVD's fundamental bias toward **Global Variance** makes it a poor standalone classifier but a specialized defensive tool. It excels at denoising simple manifolds but fails catastrophically when locally discriminative details (like a gap in a '3' or a button on a shirt) are suppressed in favor of global energy.
 
-## Appendix: Implementation & Technical Details
+---
 
-### A. Training & Reproducibility
-- **Trainer**: Adam optimizer ($lr=10^{-3}$, batch size 64) with stratified 80/20 train/val splits.
-- **Denoising**: All SVD components use explicit mean-centering and a rank of $k=20$.
-- **Early Stopping**: Early stopping with a patience of 3 monitored on validation accuracy prevented overfitting, typically converging in 5-8 epochs.
+## Appendix: Technical Details
 
+### A. Learning Curves
+Convergence was typically reached within 5-8 epochs using the Adam optimizer.
 <p align="center">
-  <img src="research_results/fig_14_learning_curves.png" alt="Figure A1: Learning Curves" width="450" />
-  <br>
-  <em>Figure A1: Standardized learning curves showing convergence and early-stopping preservation.</em>
+  <img src="research_results/fig_09_learning_curves.png" alt="Learning Curves" width="450" />
 </p>
 
-### B. Per-Class Metrics & SVD Failure Clusters
-SVD failure is concentrated in specific clusters with high energy overlap:
-- **Digit 5 (81.3% F1)**: Systematic confusion with digit 3 due to similar stroke energy.
-- **Digit 9 (83.6% F1)**: Confusion with 4 due to loop vs. open-top similarity.
-
+### B. Per-Class F1 Comparisons
+SVD failures are consistently clustered in "Ambiguity Zones" (3 vs 8, 5 vs 3, 4 vs 9), where pixel-wise overlap is highest.
 <p align="center">
-  <img src="research_results/fig_19_per_class_metrics_comparison.png" alt="Figure A2: F1-Score Comparison" width="800" />
-  <br>
-  <em>Figure A2: Side-by-side per-class comparison highlighting SVD's failure regions.</em>
+  <img src="research_results/fig_10_per_class_metrics_comparison.png" alt="F1 Comparison" width="800" />
 </p>
-
-### C. Grad-CAM Implementation Note
-To ensure accurate saliency mapping, we utilized `register_full_backward_hook` to capture complete gradient tensors from the intermediate convolutional layers, avoiding the gradient-drop issues found in legacy PyTorch hooks.

experiments/01_phenomenon_diagnosis.py

@@ -43,7 +43,7 @@ def run_svd_analysis(X_train, y_train, X_test, y_test):
     # 3. Visualization: Confusion Matrix & Eigen-digits
     viz.plot_confusion_matrix(
         y_test, y_pred, list(range(10)), 
-        'fig_02_svd_confusion.png', 
+        'fig_01_svd_confusion.png', 
         f'SVD Confusion Matrix (Acc={acc:.2f})', 
         viz.COLOR_SVD
     )
@@ -52,7 +52,7 @@ def run_svd_analysis(X_train, y_train, X_test, y_test):
     viz.plot_multi_image_grid(
         [c.reshape(28, 28) for c in svd_20.components_[:10]], 
         component_titles, 2, 5, 
-        'fig_03_eigen_digits.png', 
+        'fig_02_eigen_digits.png', 
         'Global SVD Eigen-digits'
     )
 

experiments/{02_mechanistic_analysis.py → 02_mechanistic_proof.py}

@@ -8,7 +8,7 @@ import torch
 import torch.nn as nn
 import numpy as np
 from sklearn.decomposition import TruncatedSVD
-from sklearn.neighbors import KNeighborsClassifier
+from sklearn.neighbors import KNeighborsClassifier, NearestNeighbors
 from sklearn.metrics import accuracy_score
 
 from src import config, utils, viz, exp_utils
@@ -31,30 +31,36 @@ def run_interpolation_analysis(device):
     img_3, img_8 = X_test[idx_3], X_test[idx_8]
     
     alphas = np.linspace(0, 1, 11)
-    probs_8, rec_errors = [], []
+    probs_dict = {f'T={t:.1f}': [] for t in [1.0, 2.0, 5.0]}
+    rec_errors, manifold_dists = [], []
+    
+    # Fit Nearest Neighbors on Training set to measure distance to manifold
+    X_train, y_train = utils.load_data_split(dataset_name="mnist", train=True, digits=[3, 8], flatten=True)
+    nn_manifold = NearestNeighbors(n_neighbors=1, metric='euclidean').fit(X_train.numpy())
     
     for alpha in alphas:
         img_interp = (1 - alpha) * img_3 + alpha * img_8
-        # CNN Probability of class 1 (Digit 8)
-        with torch.no_grad():
-            logits = cnn(img_interp.unsqueeze(0).to(device))
-            # Note: We use index 8 from full model or index 1 if it was binary
-            # Here we assume full model but we load 3v8 subset. 
-            # If model is 10-class, we need to pick actual digit indices.
-            # Let's check model output size.
-            out_dim = logits.shape[1]
-            if out_dim == 10:
-                p = torch.softmax(logits, dim=1)[0, 8].item()
-            else:
-                p = torch.softmax(logits, dim=1)[0, 1].item()
-            probs_8.append(p)
+        for t_str, p_list in probs_dict.items():
+            temp = float(t_str.split('=')[1])
+            with torch.no_grad():
+                logits = cnn(img_interp.unsqueeze(0).to(device))
+                out_dim = logits.shape[1]
+                if out_dim == 10:
+                    p = torch.softmax(logits / temp, dim=1)[0, 8].item()
+                else:
+                    p = torch.softmax(logits / temp, dim=1)[0, 1].item()
+                p_list.append(p)
         
         # SVD Reconstruction Error
         flat = img_interp.view(1, -1).numpy()
         rec = svd.inverse_transform(svd.transform(flat - mean)) + mean
         rec_errors.append(np.linalg.norm(flat - rec))
         
-    viz.plot_interpolation_dynamics(alphas, probs_8, rec_errors, 'fig_05_interpolation.png')
+        # Distance to Real Manifold (784D)
+        dist, _ = nn_manifold.kneighbors(flat)
+        manifold_dists.append(dist[0][0])
+        
+    viz.plot_interpolation_dynamics(alphas, probs_dict, rec_errors, 'fig_03_interpolation.png', manifold_distances=manifold_dists)
 
 def run_quantifying_manifold_collapse():
     print("\n--- Running Experiment 7: Quantifying Manifold Collapse ---")
@@ -83,7 +89,7 @@ def run_quantifying_manifold_collapse():
         import umap
         reducer = umap.UMAP(n_neighbors=15, min_dist=0.1, n_components=2, random_state=42)
         X_umap = reducer.fit_transform(X_test_np)
-        viz.plot_manifold_comparison(X_test_svd, X_umap, y_test_np, acc_svd, acc_raw, 'fig_08_manifold_collapse.png')
+        viz.plot_manifold_comparison(X_test_svd, X_umap, y_test_np, acc_svd, acc_raw, 'fig_05_manifold_collapse.png')
     except Exception as e:
         print(f"Warning: Manifold visualization failed: {e}")
     

experiments/{run_robustness_test.py → 03_operational_boundaries.py}

@@ -15,6 +15,7 @@ def run_experiment(args):
     print(f"\n--- Running Robustness Test: {args.dataset.upper()} ---")
     
     # 1. Load Data and Models
+    X_train, y_train = utils.load_data_split(dataset_name=args.dataset, train=True)
     X_test, y_test = utils.load_data_split(dataset_name=args.dataset, train=False)
     _, cnn = utils.load_models(dataset_name=args.dataset)
     
@@ -22,9 +23,9 @@ def run_experiment(args):
         return
 
     # 2. Fit SVD Baseline and Build Hybrid Model
-    print("Fitting SVD Baseline...")
-    X_test_flat = X_test.view(X_test.size(0), -1).numpy()
-    svd_pipe = exp_utils.fit_svd_baseline(X_test_flat, y_test.numpy(), n_components=20)
+    print("Fitting SVD Baseline on Training Data...")
+    X_train_flat = X_train.view(X_train.size(0), -1).numpy()
+    svd_pipe = exp_utils.fit_svd_baseline(X_train_flat, y_train.numpy(), n_components=20)
     
     svd = svd_pipe.named_steps['svd']
     scaler = svd_pipe.named_steps['scaler']
@@ -37,8 +38,14 @@ def run_experiment(args):
     results = {'CNN': [], 'SVD': [], 'Hybrid': []}
 
     # 4. Evaluation Loop
+    noise_label = 'Gaussian' if args.noise_type == 'gaussian' else 'SVD-Aligned'
+    print(f"Noise Type: {noise_label}")
+    
     for sigma in sigmas:
-        X_noisy = exp_utils.add_gaussian_noise(X_test, sigma)
+        if args.noise_type == "svd_aligned":
+            X_noisy = exp_utils.add_svd_aligned_noise(X_test, sigma, svd.components_)
+        else:
+            X_noisy = exp_utils.add_gaussian_noise(X_test, sigma)
         
         results['CNN'].append(exp_utils.evaluate_classifier(cnn, X_noisy, y_test, device))
         results['SVD'].append(exp_utils.evaluate_classifier(svd_pipe, X_noisy, y_test, is_pytorch=False))
@@ -47,17 +54,26 @@ def run_experiment(args):
         print(f"σ={sigma:.1f} | CNN: {results['CNN'][-1]:.4f} | SVD: {results['SVD'][-1]:.4f} | Hybrid: {results['Hybrid'][-1]:.4f}")
 
     # 5. Visualization
+    # Map to new sequential names
+    if args.dataset == "mnist" and args.noise_type == "gaussian":
+        filename = "fig_06_robustness_mnist_gaussian.png"
+    elif args.dataset == "mnist" and args.noise_type == "svd_aligned":
+        filename = "fig_07_robustness_mnist_svd_aligned.png"
+    elif args.dataset == "fashion":
+        filename = "fig_08_robustness_fashion.png"
+    else:
+        filename = f'fig_robustness_{args.dataset}_{args.noise_type}.png'
+
     viz.plot_robustness_curves(
-        x_values=sigmas,
-        results_dict=results,
-        x_label='Gaussian Noise Level (σ)',
-        title=f'Robustness Analysis: {args.dataset.upper()}',
-        filename=f'fig_robustness_{args.dataset}.png'
+        sigmas, results, f'{noise_label} Noise Level (σ)',
+        f'Robustness Analysis ({noise_label}): {args.dataset.upper()}',
+        filename
     )
 
 def main():
     parser = argparse.ArgumentParser(description="Unified Robustness Evaluation")
     parser.add_argument("--dataset", choices=["mnist", "fashion"], default="mnist", help="Dataset to evaluate.")
+    parser.add_argument("--noise_type", choices=["gaussian", "svd_aligned"], default="gaussian", help="Type of noise to apply.")
     args = parser.parse_args()
     run_experiment(args)
 

experiments/{appendix_learning_curves.py → 04_appendix_learning_curves.py}

@@ -9,7 +9,7 @@ from src import config, viz
 
 def main():
     experiments = [
-        ('cnn_10class_history.pkl', 'MNIST 10-class CNN Training', 'fig_14_learning_curves.png'),
+        ('cnn_10class_history.pkl', 'MNIST 10-class CNN Training', 'fig_09_learning_curves.png'),
         ('cnn_fashion_history.pkl', 'Fashion-MNIST CNN Training', 'fig_15_learning_curves_fashion.png')
     ]
     

experiments/{appendix_per_class_metrics.py → 05_appendix_per_class_metrics.py}

@@ -30,7 +30,10 @@ def main():
         y_preds_dict['CNN'] = cnn(X_test.to(device)).argmax(dim=1).cpu().numpy()
     
     # SVD+LR Predictions
-    y_preds_dict['SVD+LR'] = svd_pipe.predict(X_test_flat)
+    print("Fitting SVD Baseline (10-class)...")
+    X_train_full, y_train_full = utils.load_data_split(dataset_name="mnist", train=True, flatten=True)
+    svd_pipe_fitted = exp_utils.fit_svd_baseline(X_train_full.numpy(), y_train_full.numpy(), n_components=20)
+    y_preds_dict['SVD+LR'] = svd_pipe_fitted.predict(X_test_flat)
 
     # 2. Print Metrics Report
     from sklearn.metrics import recall_score, precision_score, f1_score
@@ -45,7 +48,7 @@ def main():
     viz.plot_per_class_comparison(
         y_test_np, 
         y_preds_dict, 
-        'fig_19_per_class_metrics_comparison.png'
+        'fig_10_per_class_metrics_comparison.png'
     )
     print("Appendix B Completed.")
 

run_all_experiments.sh

@@ -4,16 +4,16 @@
 set -e
 
 echo "=== 1. Phenomenon Diagnosis (Global SVD & CNN Baseline) ==="
-python experiments/01_phenomenon_diagnosis.py
+python -m experiments.01_phenomenon_diagnosis
 
 echo "=== 2. Mechanistic Analysis (Interpolation, Explainability, etc.) ==="
-python experiments/02_mechanistic_analysis.py
+python -m experiments.02_mechanistic_proof
 
 echo "=== 3. Robustness and Boundary Tests (MNIST) ==="
-python experiments/run_robustness_test.py --dataset mnist
+python -m experiments.03_operational_boundaries --dataset mnist
 
 echo "=== 4. Robustness and Boundary Tests (Fashion-MNIST) ==="
-python experiments/run_robustness_test.py --dataset fashion
+python -m experiments.03_operational_boundaries --dataset fashion
 
 echo "=========================================================="
 echo "All experiments completed successfully."

run_migration.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+# This script performs the renaming of scripts and figures, and updates references in the code and report.
+# Run this from the project root: /Users/ymlin/Downloads/003-Study/137-Projects/01-mnist-linear-vs-nonlinear
+
+echo "Starting migration..."
+
+# 1. Rename Scripts
+echo "Renaming scripts..."
+mv experiments/01_exp_diagnosis.py experiments/01_phenomenon_diagnosis.py
+mv experiments/02_mechanistic_analysis.py experiments/02_mechanistic_proof.py
+mv experiments/run_robustness_test.py experiments/03_operational_boundaries.py
+mv experiments/appendix_learning_curves.py experiments/04_appendix_learning_curves.py
+mv experiments/appendix_per_class_metrics.py experiments/05_appendix_per_class_metrics.py
+
+# 2. Rename Figures
+echo "Renaming figures..."
+cd docs/research_results || exit
+mv fig_02_svd_confusion.png fig_01_svd_confusion.png
+mv fig_03_eigen_digits.png fig_02_eigen_digits.png
+mv fig_05_interpolation.png fig_03_interpolation.png
+mv fig_06_explainability.png fig_04_explainability.png
+mv fig_08_manifold_collapse.png fig_05_manifold_collapse.png
+mv fig_robustness_mnist_gaussian.png fig_06_robustness_mnist_gaussian.png
+mv fig_robustness_mnist_svd_aligned.png fig_07_robustness_mnist_svd_aligned.png
+mv fig_robustness_fashion.png fig_08_robustness_fashion.png
+mv fig_14_learning_curves.png fig_09_learning_curves.png
+mv fig_19_per_class_metrics_comparison.png fig_10_per_class_metrics_comparison.png
+cd ../..
+
+# 3. Update Python Scripts (Using sed for macOS)
+echo "Updating Python scripts..."
+
+# 01_phenomenon_diagnosis.py
+sed -i '' 's/fig_02_svd_confusion.png/fig_01_svd_confusion.png/g' experiments/01_phenomenon_diagnosis.py
+sed -i '' 's/fig_03_eigen_digits.png/fig_02_eigen_digits.png/g' experiments/01_phenomenon_diagnosis.py
+sed -i '' 's/fig_04_cnn_confusion.png/fig_01b_cnn_confusion.png/g' experiments/01_phenomenon_diagnosis.py
+
+# 02_mechanistic_proof.py
+sed -i '' 's/fig_05_interpolation.png/fig_03_interpolation.png/g' experiments/02_mechanistic_proof.py
+sed -i '' 's/fig_06_explainability.png/fig_04_explainability.png/g' experiments/02_mechanistic_proof.py
+sed -i '' 's/fig_08_manifold_collapse.png/fig_05_manifold_collapse.png/g' experiments/02_mechanistic_proof.py
+
+# 03_operational_boundaries.py
+sed -i '' 's/fig_robustness_mnist_gaussian.png/fig_06_robustness_mnist_gaussian.png/g' experiments/03_operational_boundaries.py
+sed -i '' 's/fig_robustness_mnist_svd_aligned.png/fig_07_robustness_mnist_svd_aligned.png/g' experiments/03_operational_boundaries.py
+sed -i '' 's/fig_robustness_fashion.png/fig_08_robustness_fashion.png/g' experiments/03_operational_boundaries.py
+
+# 04_appendix_learning_curves.py
+sed -i '' 's/fig_14_learning_curves.png/fig_09_learning_curves.png/g' experiments/04_appendix_learning_curves.py
+
+# 05_appendix_per_class_metrics.py
+sed -i '' 's/fig_19_per_class_metrics_comparison.png/fig_10_per_class_metrics_comparison.png/g' experiments/05_appendix_per_class_metrics.py
+
+# 4. Update Report (Using sed for macOS)
+echo "Updating REPORT.md..."
+sed -i '' 's/fig_02_svd_confusion.png/fig_01_svd_confusion.png/g' docs/REPORT.md
+sed -i '' 's/fig_03_eigen_digits.png/fig_02_eigen_digits.png/g' docs/REPORT.md
+sed -i '' 's/fig_05_interpolation.png/fig_03_interpolation.png/g' docs/REPORT.md
+sed -i '' 's/fig_06_explainability.png/fig_04_explainability.png/g' docs/REPORT.md
+sed -i '' 's/fig_08_manifold_collapse.png/fig_05_manifold_collapse.png/g' docs/REPORT.md
+sed -i '' 's/fig_robustness_mnist_gaussian.png/fig_06_robustness_mnist_gaussian.png/g' docs/REPORT.md
+sed -i '' 's/fig_robustness_mnist_svd_aligned.png/fig_07_robustness_mnist_svd_aligned.png/g' docs/REPORT.md
+sed -i '' 's/fig_robustness_fashion.png/fig_08_robustness_fashion.png/g' docs/REPORT.md
+sed -i '' 's/fig_14_learning_curves.png/fig_09_learning_curves.png/g' docs/REPORT.md
+sed -i '' 's/fig_19_per_class_metrics_comparison.png/fig_10_per_class_metrics_comparison.png/g' docs/REPORT.md
+
+echo "Migration completed successfully!"

src/exp_utils.py

@@ -10,7 +10,7 @@ from sklearn.preprocessing import StandardScaler
 def fit_svd_baseline(X_train, y_train, n_components=20):
     """Fits a linear baseline (SVD + Logistic Regression) on the fly."""
     pipeline = Pipeline([
-        ('scaler', StandardScaler()),
+        ('scaler', StandardScaler(with_std=False)),
         ('svd', TruncatedSVD(n_components=n_components, random_state=42)),
         ('logistic', LogisticRegression(max_iter=1000))
     ])
@@ -30,6 +30,40 @@ def add_gaussian_noise(X, sigma):
         noise = np.random.randn(*X.shape) * sigma
         return np.clip(X + noise, 0, 1)
 
+def add_svd_aligned_noise(X, sigma, components):
+    """
+    Adds noise that is projected onto the SVD components, living entirely
+    within the 'signal' subspace.
+    """
+    if sigma <= 0: return X
+    is_tensor = torch.is_tensor(X)
+    
+    # Flatten if needed
+    orig_shape = list(X.shape)
+    if is_tensor:
+        X_flat = X.cpu().numpy().reshape(orig_shape[0], -1)
+        components_np = components.cpu().numpy() if torch.is_tensor(components) else components
+    else:
+        X_flat = X.reshape(orig_shape[0], -1)
+        components_np = components
+    
+    # 1. Generate random Gaussian noise in full dimensionality
+    noise = np.random.randn(*X_flat.shape) * sigma
+    
+    # 2. Project noise onto components (V_k)
+    # V_k (components_np) is assumed to be (k, 784)
+    # Projection P = V_k^T @ V_k
+    projected_noise = (noise @ components_np.T) @ components_np
+    
+    # 3. Add back and clip
+    X_noisy = X_flat + projected_noise
+    X_noisy = np.clip(X_noisy, 0, 1)
+    
+    if is_tensor:
+        return torch.from_numpy(X_noisy).float().view(orig_shape)
+    else:
+        return X_noisy.reshape(orig_shape)
+
 def add_blur(X, kernel_size):
     """Unified blur for torch Tensors (4D: B, C, H, W)."""
     if kernel_size <= 1: 

src/hybrid_model.py

@@ -29,6 +29,11 @@ class SVDProjectionLayer(nn.Module):
     def forward(self, x):
         b = x.size(0)
         x_rec = (x.view(b, -1) - self.mean) @ self.V_k.T @ self.V_k + self.mean
+        
+        # Monitor truncation ratio (percentage of pixels outside [0, 1])
+        out_of_range = (x_rec < 0) | (x_rec > 1)
+        self.last_clamp_ratio = out_of_range.float().mean().item()
+        
         return torch.clamp(x_rec, 0, 1).view(b, 1, 28, 28)
 
 class HybridSVDCNN(nn.Module):

src/viz.py

@@ -81,20 +81,36 @@ def plot_singular_spectrum(singular_values, cumulative_variance, filename):
     fig.legend(loc="upper right", bbox_to_anchor=(1,1), bbox_transform=ax1.transAxes)
     save_fig(filename)
 
-def plot_interpolation_dynamics(alphas, probs_8, rec_errors, filename):
-    """Visualizes the CNN response vs SVD reconstruction error during interpolation."""
+def plot_interpolation_dynamics(alphas, probs_dict, rec_errors, filename, manifold_distances=None):
+    """Visualizes the CNN response vs SVD reconstruction error and manifold distance."""
     setup_style()
-    plt.figure(figsize=(10, 6))
-    
-    plt.plot(alphas, probs_8, color=COLOR_CNN, label='CNN Prob(8) [Topology]', marker='o', linewidth=2)
-    plt.plot(alphas, rec_errors, color=COLOR_SVD, label='SVD Rec Error [Global Variance]', marker='s', linewidth=2)
+    fig, ax1 = plt.subplots(figsize=(10, 6))
     
-    plt.axvline(x=0.5, color='#4C566A', linestyle='--', alpha=0.5, label='Ambiguity Mid-point')
-    plt.title('Mechanistic Dynamics: Interpolation vs. SVD Error', fontsize=14, fontweight='bold', pad=15)
-    plt.xlabel('Alpha (0=Digit 3, 1=Digit 8)', fontsize=12)
-    plt.ylabel('Metric Value', fontsize=12)
-    plt.legend()
-    plt.grid(True)
+    # Support both single list and dict of labels->probs
+    if isinstance(probs_dict, list):
+        probs_dict = {'CNN Prob(8)': probs_dict}
+    
+    styles = ['-', '--', ':', '-.']
+    for i, (label, probs) in enumerate(probs_dict.items()):
+        ax1.plot(alphas, probs, label=label, marker='o' if i==0 else None, 
+                 linestyle=styles[i % len(styles)], linewidth=2)
+    
+    ax1.plot(alphas, rec_errors, color=COLOR_SVD, label='SVD Rec Error', marker='s', linewidth=2, alpha=0.6)
+    ax1.set_xlabel('Alpha (0=Digit 3, 1=Digit 8)', fontsize=12)
+    ax1.set_ylabel('CNN Prob / Rec Error', fontsize=12)
+    
+    if manifold_distances is not None:
+        ax2 = ax1.twinx()
+        ax2.plot(alphas, manifold_distances, color="#D08770", label='Manifold Distance', marker='^', linestyle='--', linewidth=2)
+        ax2.set_ylabel('Dist to Nearest Neighbor', color="#D08770", fontsize=12)
+        ax2.tick_params(axis='y', labelcolor="#D08770")
+        fig.legend(loc="upper right", bbox_to_anchor=(0.9, 0.9), bbox_transform=ax1.transAxes)
+    else:
+        ax1.legend()
+
+    plt.title('Mechanistic Dynamics: Snap Analysis with Temperature Scaling', fontsize=14, fontweight='bold', pad=15)
+    ax1.axvline(x=0.5, color='#4C566A', linestyle='--', alpha=0.5, label='Ambiguity Mid-point')
+    ax1.grid(True)
     save_fig(filename)
 
 def plot_manifold_comparison(X_svd, X_umap, y, acc_svd, acc_raw, filename):
@@ -126,7 +142,7 @@ def plot_manifold_comparison(X_svd, X_umap, y, acc_svd, acc_raw, filename):
 def plot_learning_curves(history, title, filename):
     """Standardized plotter for training history (loss and accuracy)."""
     setup_style()
-    epochs = range(1, len(history['train_loss']) + 1)
+    # Calculate epochs separately for loss and accuracy
     fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
     
     # Nord palette for curves
@@ -134,8 +150,10 @@ def plot_learning_curves(history, title, filename):
     COLOR_VAL = "#D08770" # Nord 12 (Orange)
     
     # Loss Plot
-    ax1.plot(epochs, history['train_loss'], label='Train', color=COLOR_TRAIN, marker='o', markersize=4, linewidth=1.5)
-    ax1.plot(epochs, history['val_loss'], label='Val', color=COLOR_VAL, marker='s', markersize=4, linewidth=1.5)
+    if len(history.get('train_loss', [])) > 0:
+        epochs_loss = range(1, len(history['train_loss']) + 1)
+        ax1.plot(epochs_loss, history['train_loss'], label='Train', color=COLOR_TRAIN, marker='o', markersize=4, linewidth=1.5)
+        ax1.plot(epochs_loss, history['val_loss'], label='Val', color=COLOR_VAL, marker='s', markersize=4, linewidth=1.5)
     ax1.set_title('Loss Dynamics', fontsize=12, fontweight='bold')
     ax1.set_xlabel('Epoch')
     ax1.set_ylabel('Loss')
@@ -143,8 +161,10 @@ def plot_learning_curves(history, title, filename):
     ax1.grid(True)
     
     # Accuracy Plot
-    ax2.plot(epochs, history['train_acc'], label='Train', color=COLOR_TRAIN, marker='o', markersize=4, linewidth=1.5)
-    ax2.plot(epochs, history['val_acc'], label='Val', color=COLOR_VAL, marker='s', markersize=4, linewidth=1.5)
+    if len(history.get('train_acc', [])) > 0:
+        epochs_acc = range(1, len(history['train_acc']) + 1)
+        ax2.plot(epochs_acc, history['train_acc'], label='Train', color=COLOR_TRAIN, marker='o', markersize=4, linewidth=1.5)
+        ax2.plot(epochs_acc, history['val_acc'], label='Val', color=COLOR_VAL, marker='s', markersize=4, linewidth=1.5)
     ax2.set_title('Accuracy Dynamics', fontsize=12, fontweight='bold')
     ax2.set_xlabel('Epoch')
     ax2.set_ylabel('Accuracy')