docs: Update CNN comments and add bias fix summary

- Fix stale comments: RGBD→RGB (not grayscale)
- Clarify shape transformations in inference
- Add CNN_BIAS_FIX_2026-02.md consolidating recent fixes
- Include regenerated weights with 5x5 kernel for layer 0

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

4 files changed, 394 insertions, 176 deletions

diff --git a/doc/CNN_BIAS_FIX_2026-02.md b/doc/CNN_BIAS_FIX_2026-02.md
new file mode 100644
index 0000000..26db8eb
--- /dev/null
+++ b/doc/CNN_BIAS_FIX_2026-02.md
@@ -0,0 +1,85 @@
+# CNN Bias Accumulation Fix (2026-02-11)
+
+## Problem
+Bias was being added multiple times in shader convolution loops (once per kernel position), causing mismatch between PyTorch training and WGSL inference.
+
+## Root Cause
+**Location**: `training/train_cnn.py:381, 398`
+
+When exporting weights to WGSL, bias was replicated for every kernel position. The shader loops through positions doing:
+```wgsl
+sum += dot(weights[pos], rgbd) + dot(weights[pos+1], in1);  // in1.w = 1.0
+```
+
+For 3×3 kernel (9 positions), bias added 9×. For 5×5, added 25×.
+
+## Fix
+Divide bias by `num_positions` during export:
+```python
+# Final layer (7→1)
+v1.append(f"{bias[0] / num_positions:.6f}")
+
+# Inner layers (7→4)
+v1.append(f"{bias[out_c] / num_positions:.6f}")
+```
+
+Shader accumulates bias × num_positions = original bias (correct).
+
+---
+
+## Additional Improvements
+
+### 1. RGBA Output Support
+**train_cnn.py**: Now saves 4-channel RGBA PNG preserving alpha from input:
+```python
+alpha = img_tensor[0, 3:4, :, :].permute(1, 2, 0).numpy()
+output_rgba = np.concatenate([output, alpha], axis=2)
+Image.fromarray((output_rgba * 255).astype(np.uint8), mode='RGBA')
+```
+
+Intermediate layers also save RGBA if 4-channel.
+
+### 2. Debug Hex Output
+**Both tools** support `--debug-hex` to print first 8 pixels as hex:
+```bash
+./training/train_cnn.py --infer input.png --export-only checkpoint.pth --debug-hex
+./build/cnn_test input.png output.png --debug-hex
+```
+
+Output format: `[0] 0xRRGGBBAA` for pixel-level comparison.
+
+### 3. Cleanup
+Removed sRGB/linear_png debug code from `cnn_test.cc` (simplified PNG saving).
+
+---
+
+## Files Modified
+- `training/train_cnn.py`: Bias fix, RGBA output, --debug-hex
+- `tools/cnn_test.cc`: --debug-hex, remove linear_png
+- `workspaces/main/shaders/cnn/cnn_weights_generated.wgsl`: Regenerated with fixed bias
+
+## Testing
+```bash
+# Train with fixed export
+./training/train_cnn.py --input training/input/ --target training/output/ \
+  --layers 3 --kernel_sizes 3,3,3 --epochs 5000
+
+# Generate ground truth
+./training/train_cnn.py --infer input.png --export-only checkpoint.pth \
+  --output ground_truth.png --debug-hex
+
+# Run GPU tool
+./build/cnn_test input.png tool_output.png --debug-hex
+
+# Compare hex output for first 8 pixels
+```
+
+---
+
+## Status
+✅ Bias accumulation bug fixed
+✅ RGBA output with alpha preservation
+✅ Debug hex comparison tool
+✅ Weights regenerated
+
+Commit: `8ff8c56`
diff --git a/training/train_cnn.py b/training/train_cnn.py
index c775325..4171dcb 100755
--- a/training/train_cnn.py
+++ b/training/train_cnn.py
@@ -218,7 +218,10 @@ class PatchDataset(Dataset):
 
 
 class SimpleCNN(nn.Module):
-    """CNN for RGBD→grayscale with 7-channel input (RGBD + UV + gray)"""
+    """CNN for RGBD→RGB with 7-channel input (RGBD + UV + gray)
+
+    Internally computes grayscale, expands to 3-channel RGB output.
+    """
 
     def __init__(self, num_layers=1, kernel_sizes=None):
         super(SimpleCNN, self).__init__()
@@ -272,11 +275,11 @@ class SimpleCNN(nn.Module):
             if return_intermediates:
                 intermediates.append(out.clone())
 
-        # Final layer (grayscale output)
+        # Final layer (grayscale→RGB)
         final_input = torch.cat([out, x_coords, y_coords, gray], dim=1)
-        out = self.layers[-1](final_input)  # [B,1,H,W]
+        out = self.layers[-1](final_input)  # [B,1,H,W] grayscale
         out = torch.sigmoid(out)  # Map to [0,1] with smooth gradients
-        final_out = out.expand(-1, 3, -1, -1)
+        final_out = out.expand(-1, 3, -1, -1)  # [B,3,H,W] expand to RGB
 
         if return_intermediates:
             return final_out, intermediates
@@ -777,7 +780,10 @@ def export_from_checkpoint(checkpoint_path, output_path=None):
 
 
 def infer_from_checkpoint(checkpoint_path, input_path, output_path, patch_size=32, save_intermediates=None, zero_weights=False, debug_hex=False):
-    """Run sliding-window inference to match WGSL shader behavior"""
+    """Run sliding-window inference to match WGSL shader behavior
+
+    Outputs RGBA PNG (RGB from model + alpha from input).
+    """
 
     if not os.path.exists(checkpoint_path):
         print(f"Error: Checkpoint '{checkpoint_path}' not found")
@@ -819,14 +825,12 @@ def infer_from_checkpoint(checkpoint_path, input_path, output_path, patch_size=3
         if save_intermediates:
             output_tensor, intermediates = model(img_tensor, return_intermediates=True)
         else:
-            output_tensor = model(img_tensor)  # [1,3,H,W]
-
-    # Convert to numpy
-    output = output_tensor.squeeze(0).permute(1, 2, 0).numpy()
+            output_tensor = model(img_tensor)  # [1,3,H,W] RGB
 
-    # Append alpha channel from input
-    alpha = img_tensor[0, 3:4, :, :].permute(1, 2, 0).numpy()  # [H,W,1]
-    output_rgba = np.concatenate([output, alpha], axis=2)  # [H,W,4]
+    # Convert to numpy and append alpha
+    output = output_tensor.squeeze(0).permute(1, 2, 0).numpy()  # [H,W,3] RGB
+    alpha = img_tensor[0, 3:4, :, :].permute(1, 2, 0).numpy()  # [H,W,1] alpha from input
+    output_rgba = np.concatenate([output, alpha], axis=2)  # [H,W,4] RGBA
 
     # Debug: print first 8 pixels as hex
     if debug_hex:
diff --git a/workspaces/main/shaders/cnn/cnn_layer.wgsl b/workspaces/main/shaders/cnn/cnn_layer.wgsl
index e629cb2..cbd1686 100644
--- a/workspaces/main/shaders/cnn/cnn_layer.wgsl
+++ b/workspaces/main/shaders/cnn/cnn_layer.wgsl
@@ -8,6 +8,7 @@
 #include "common_uniforms"
 #include "cnn_activation"
 #include "cnn_conv3x3"
+#include "cnn_conv5x5"
 #include "cnn_weights_generated"
 
 struct CNNLayerParams {
@@ -37,7 +38,7 @@ struct CNNLayerParams {
 
     // Layer 0: 7→4 (RGBD output, normalizes [0,1] input)
     if (params.layer_index == 0) {
-        result = cnn_conv3x3_7to4_src(txt, smplr, uv, uniforms.resolution, weights_layer0);
+        result = cnn_conv5x5_7to4_src(txt, smplr, uv, uniforms.resolution, weights_layer0);
         result = cnn_tanh(result);
     }
     else if (params.layer_index == 1) {
diff --git a/workspaces/main/shaders/cnn/cnn_weights_generated.wgsl b/workspaces/main/shaders/cnn/cnn_weights_generated.wgsl
index 89b5a06..6f551ba 100644
--- a/workspaces/main/shaders/cnn/cnn_weights_generated.wgsl
+++ b/workspaces/main/shaders/cnn/cnn_weights_generated.wgsl
@@ -1,174 +1,302 @@
 // Auto-generated CNN weights (vec4-optimized)
 // DO NOT EDIT - Generated by train_cnn.py
 
-const weights_layer0: array<vec4<f32>, 72> = array(
-  vec4<f32>(-0.064365, 0.036971, -0.002396, 0.109771),
-  vec4<f32>(-0.072773, -0.119603, -0.123951, 0.030367),
-  vec4<f32>(-0.236017, 0.095366, -0.091895, 0.268624),
-  vec4<f32>(-0.079571, 0.007580, -0.058172, 0.018995),
-  vec4<f32>(0.112710, 0.131221, 0.168938, -0.119702),
-  vec4<f32>(0.007403, -0.219214, 0.131916, 0.000668),
-  vec4<f32>(-0.221084, -0.054396, 0.055713, 0.150345),
-  vec4<f32>(0.032674, 0.016578, 0.033386, 0.028899),
-  vec4<f32>(0.169524, 0.374150, 0.225601, 0.213908),
-  vec4<f32>(-0.137716, -0.103676, 0.367652, 0.030367),
-  vec4<f32>(0.115163, 0.324975, 0.177730, 0.235134),
-  vec4<f32>(0.027009, -0.008278, 0.299946, 0.018995),
-  vec4<f32>(-0.011976, -0.130614, 0.041849, -0.063980),
-  vec4<f32>(-0.098651, -0.113425, -0.001081, 0.000668),
-  vec4<f32>(0.078393, 0.067415, 0.032002, 0.036014),
-  vec4<f32>(0.024718, -0.130110, 0.077101, 0.028899),
-  vec4<f32>(0.218265, 0.276989, 0.397049, 0.167719),
-  vec4<f32>(0.103226, -0.044606, 0.215080, 0.030367),
-  vec4<f32>(-0.039886, 0.070243, 0.398847, 0.200997),
-  vec4<f32>(0.065451, 0.010958, 0.123146, 0.018995),
-  vec4<f32>(-0.137112, -0.237932, -0.104421, 0.001620),
-  vec4<f32>(-0.124844, -0.134461, -0.069051, 0.000668),
-  vec4<f32>(0.208783, 0.066374, 0.311512, 0.247299),
-  vec4<f32>(0.050053, 0.085183, 0.228604, 0.028899),
-  vec4<f32>(0.026044, -0.080923, -0.109507, 0.237600),
-  vec4<f32>(-0.110202, 0.117810, -0.098755, 0.030367),
-  vec4<f32>(-0.105352, -0.026309, 0.015819, 0.201850),
-  vec4<f32>(0.071904, -0.018016, -0.059729, 0.018995),
-  vec4<f32>(0.184291, -0.040453, -0.005354, -0.180611),
-  vec4<f32>(0.048572, -0.114292, 0.055505, 0.000668),
-  vec4<f32>(-0.188638, -0.003004, -0.117432, 0.148765),
-  vec4<f32>(-0.014862, -0.119666, -0.033349, 0.028899),
-  vec4<f32>(0.062853, 0.098261, 0.253355, 0.213134),
-  vec4<f32>(-0.115418, 0.123752, 0.108521, 0.030367),
-  vec4<f32>(0.341238, 0.300137, 0.254389, 0.272310),
-  vec4<f32>(0.004007, 0.063720, 0.191673, 0.018995),
-  vec4<f32>(0.068615, -0.206535, -0.003347, -0.135647),
-  vec4<f32>(0.067868, -0.211995, -0.024734, 0.000668),
-  vec4<f32>(0.251922, 0.099100, 0.270495, 0.051887),
-  vec4<f32>(-0.006790, 0.086298, 0.195115, 0.028899),
-  vec4<f32>(0.142018, 0.148073, 0.222099, 0.154902),
-  vec4<f32>(0.127208, 0.015852, 0.117386, 0.030367),
-  vec4<f32>(0.225823, 0.268716, 0.337170, 0.085034),
-  vec4<f32>(-0.019814, -0.022082, 0.102247, 0.018995),
-  vec4<f32>(-0.033797, -0.054259, -0.045772, -0.171449),
-  vec4<f32>(-0.088982, -0.147155, -0.081125, 0.000668),
-  vec4<f32>(0.143216, 0.161192, 0.085559, 0.114788),
-  vec4<f32>(0.019867, -0.094182, 0.070013, 0.028899),
-  vec4<f32>(-0.132244, -0.208928, -0.233332, 0.166794),
-  vec4<f32>(0.009434, 0.046124, -0.176356, 0.030367),
-  vec4<f32>(-0.262216, -0.289356, -0.361782, 0.204387),
-  vec4<f32>(-0.049280, -0.054182, -0.178049, 0.018995),
-  vec4<f32>(0.289035, 0.027330, 0.288493, -0.185146),
-  vec4<f32>(-0.078621, -0.097178, 0.092377, 0.000668),
-  vec4<f32>(-0.149584, -0.037569, -0.080982, 0.130455),
-  vec4<f32>(0.048648, -0.020057, -0.104357, 0.028899),
-  vec4<f32>(0.069915, -0.044736, -0.214734, 0.125458),
-  vec4<f32>(0.080929, -0.040713, -0.096242, 0.030367),
-  vec4<f32>(0.125697, 0.169932, -0.069403, 0.099432),
-  vec4<f32>(-0.097684, 0.046785, 0.010933, 0.018995),
-  vec4<f32>(0.123145, 0.053711, 0.183947, -0.086836),
-  vec4<f32>(-0.121956, -0.181722, 0.100617, 0.000668),
-  vec4<f32>(0.027013, 0.153177, 0.023556, 0.151352),
-  vec4<f32>(-0.154991, -0.001818, 0.136445, 0.028899),
-  vec4<f32>(-0.036641, -0.003436, -0.066425, 0.123169),
-  vec4<f32>(-0.038525, -0.054057, 0.067107, 0.030367),
-  vec4<f32>(0.008664, -0.173642, 0.053332, 0.226703),
-  vec4<f32>(-0.079667, -0.041206, -0.013324, 0.018995),
-  vec4<f32>(-0.120826, -0.216758, -0.047136, -0.029416),
-  vec4<f32>(-0.175910, -0.127141, 0.025666, 0.000668),
-  vec4<f32>(0.033025, -0.033796, -0.034294, 0.249376),
-  vec4<f32>(0.045212, 0.018668, -0.083031, 0.028899)
+const weights_layer0: array<vec4<f32>, 200> = array(
+  vec4<f32>(-0.063697, 0.075597, 0.072073, 0.003765),
+  vec4<f32>(-0.016491, -0.020343, 0.023524, -0.002660),
+  vec4<f32>(0.255867, 0.171781, 0.167310, 0.038280),
+  vec4<f32>(0.005305, -0.003731, 0.183877, -0.002158),
+  vec4<f32>(-0.104892, 0.022080, 0.038634, 0.036787),
+  vec4<f32>(-0.127645, -0.027863, -0.074438, -0.000240),
+  vec4<f32>(-0.044034, 0.021796, 0.141211, -0.058556),
+  vec4<f32>(0.068445, -0.050091, -0.002840, -0.003178),
+  vec4<f32>(-0.071989, 0.082649, 0.024375, -0.069581),
+  vec4<f32>(0.037888, 0.086288, 0.058454, -0.002660),
+  vec4<f32>(0.015849, 0.087634, 0.077245, -0.067285),
+  vec4<f32>(-0.023774, -0.018202, 0.097903, -0.002158),
+  vec4<f32>(-0.015025, 0.058213, 0.031566, 0.037657),
+  vec4<f32>(-0.135223, -0.086553, 0.047248, -0.000240),
+  vec4<f32>(-0.058489, -0.062162, 0.028169, -0.056962),
+  vec4<f32>(-0.011917, 0.009442, -0.143639, -0.003178),
+  vec4<f32>(-0.093802, -0.009066, 0.104268, -0.068038),
+  vec4<f32>(-0.051183, 0.051597, -0.017211, -0.002660),
+  vec4<f32>(0.056502, 0.003606, 0.000171, -0.048265),
+  vec4<f32>(-0.061067, 0.054975, 0.117790, -0.002158),
+  vec4<f32>(-0.000083, 0.041386, 0.050329, -0.028857),
+  vec4<f32>(0.006214, -0.089710, 0.070819, -0.000240),
+  vec4<f32>(-0.120964, -0.110842, 0.053558, -0.098845),
+  vec4<f32>(-0.056907, 0.027159, -0.116205, -0.003178),
+  vec4<f32>(-0.075143, 0.036620, 0.069865, -0.093711),
+  vec4<f32>(0.033423, 0.083446, 0.024261, -0.002660),
+  vec4<f32>(0.051622, 0.055194, 0.077300, -0.074366),
+  vec4<f32>(-0.044153, 0.050577, 0.105924, -0.002158),
+  vec4<f32>(-0.142657, -0.040118, 0.016634, 0.023381),
+  vec4<f32>(-0.025123, -0.097128, -0.000171, -0.000240),
+  vec4<f32>(-0.054192, -0.051463, 0.130193, -0.121685),
+  vec4<f32>(0.077872, 0.015138, -0.072825, -0.003178),
+  vec4<f32>(-0.147973, 0.040198, -0.045853, -0.119821),
+  vec4<f32>(-0.022102, 0.086499, 0.058063, -0.002660),
+  vec4<f32>(0.087361, 0.167184, 0.040052, -0.039853),
+  vec4<f32>(0.090438, -0.059009, 0.211201, -0.002158),
+  vec4<f32>(-0.091578, -0.033326, -0.039688, -0.039717),
+  vec4<f32>(-0.102818, -0.062554, -0.001115, -0.000240),
+  vec4<f32>(0.038411, 0.013361, 0.094830, -0.102496),
+  vec4<f32>(-0.006277, -0.062021, 0.031586, -0.003178),
+  vec4<f32>(-0.131289, 0.030066, -0.013701, -0.009941),
+  vec4<f32>(-0.031407, -0.037349, 0.088197, -0.002660),
+  vec4<f32>(0.047743, -0.022480, 0.044730, 0.017998),
+  vec4<f32>(0.029273, 0.021401, 0.000588, -0.002158),
+  vec4<f32>(-0.178682, -0.026781, 0.084032, -0.069342),
+  vec4<f32>(-0.073403, -0.020325, 0.025173, -0.000240),
+  vec4<f32>(-0.172231, -0.079048, 0.114447, -0.016277),
+  vec4<f32>(-0.040965, -0.092504, -0.107407, -0.003178),
+  vec4<f32>(-0.139195, 0.069049, 0.017427, 0.000271),
+  vec4<f32>(0.048512, 0.039932, 0.086631, -0.002660),
+  vec4<f32>(-0.309409, -0.282288, -0.143824, 0.047162),
+  vec4<f32>(-0.059465, 0.014637, -0.208080, -0.002158),
+  vec4<f32>(0.007868, 0.052691, 0.107955, 0.063464),
+  vec4<f32>(-0.104325, -0.040388, -0.034308, -0.000240),
+  vec4<f32>(-0.098578, -0.076321, 0.015785, -0.026484),
+  vec4<f32>(0.000542, 0.027009, -0.109028, -0.003178),
+  vec4<f32>(-0.109960, 0.067291, 0.131306, -0.122227),
+  vec4<f32>(0.021658, 0.062205, 0.029903, -0.002660),
+  vec4<f32>(-0.237980, -0.222056, -0.256292, 0.044240),
+  vec4<f32>(0.003289, 0.004431, -0.284933, -0.002158),
+  vec4<f32>(-0.007706, 0.020983, -0.009174, -0.040574),
+  vec4<f32>(-0.113634, -0.044837, 0.123861, -0.000240),
+  vec4<f32>(-0.088317, -0.195801, 0.010967, -0.002928),
+  vec4<f32>(0.006492, 0.018396, -0.147446, -0.003178),
+  vec4<f32>(-0.145148, 0.010611, -0.020286, -0.012031),
+  vec4<f32>(0.019353, -0.035173, 0.033487, -0.002660),
+  vec4<f32>(-0.109877, -0.175249, 0.010969, 0.050448),
+  vec4<f32>(0.056999, 0.023554, -0.092490, -0.002158),
+  vec4<f32>(-0.006082, 0.027532, -0.041032, -0.083553),
+  vec4<f32>(-0.086010, -0.080774, -0.030674, -0.000240),
+  vec4<f32>(-0.184554, -0.093322, 0.047928, -0.057210),
+  vec4<f32>(-0.056401, -0.019764, -0.180310, -0.003178),
+  vec4<f32>(-0.044627, 0.007457, 0.064415, -0.039308),
+  vec4<f32>(-0.025262, -0.008777, 0.007609, -0.002660),
+  vec4<f32>(-0.002843, 0.026643, 0.100820, -0.032261),
+  vec4<f32>(0.037021, -0.064543, 0.100996, -0.002158),
+  vec4<f32>(-0.041950, -0.055663, 0.000796, -0.041514),
+  vec4<f32>(-0.020780, -0.121693, 0.026435, -0.000240),
+  vec4<f32>(-0.039144, -0.103222, 0.038986, -0.116571),
+  vec4<f32>(0.055550, -0.029033, -0.015919, -0.003178),
+  vec4<f32>(-0.005170, 0.015502, 0.027653, -0.021102),
+  vec4<f32>(0.088718, 0.043567, 0.001377, -0.002660),
+  vec4<f32>(-0.009611, -0.092747, 0.016215, 0.002006),
+  vec4<f32>(-0.045472, 0.020188, -0.141264, -0.002158),
+  vec4<f32>(-0.074906, -0.064147, 0.096033, 0.032076),
+  vec4<f32>(-0.048310, -0.047609, -0.023732, -0.000240),
+  vec4<f32>(-0.175532, -0.098637, 0.043413, -0.102518),
+  vec4<f32>(-0.053294, -0.041611, -0.025571, -0.003178),
+  vec4<f32>(-0.021860, 0.065264, 0.142234, -0.023046),
+  vec4<f32>(0.048905, -0.030150, 0.034562, -0.002660),
+  vec4<f32>(-0.333632, -0.325954, -0.195164, -0.037566),
+  vec4<f32>(0.006389, -0.015083, -0.272611, -0.002158),
+  vec4<f32>(-0.018022, 0.084032, 0.116643, -0.048211),
+  vec4<f32>(0.001240, -0.109991, 0.047202, -0.000240),
+  vec4<f32>(-0.148646, -0.134839, -0.035322, -0.100221),
+  vec4<f32>(0.027406, -0.010109, -0.134081, -0.003178),
+  vec4<f32>(-0.097329, 0.118817, 0.110483, -0.069382),
+  vec4<f32>(0.076678, 0.008008, -0.028981, -0.002660),
+  vec4<f32>(-0.377723, -0.345100, -0.287633, 0.037975),
+  vec4<f32>(0.002311, 0.045485, -0.430335, -0.002158),
+  vec4<f32>(-0.052491, 0.065795, 0.089758, -0.053011),
+  vec4<f32>(-0.128085, -0.080482, 0.073512, -0.000240),
+  vec4<f32>(-0.260024, -0.212793, -0.000735, -0.029204),
+  vec4<f32>(0.019989, -0.067884, -0.159537, -0.003178),
+  vec4<f32>(-0.015479, -0.016007, -0.017023, -0.121168),
+  vec4<f32>(0.077153, -0.004463, -0.040013, -0.002660),
+  vec4<f32>(-0.227940, -0.186361, -0.217520, -0.007339),
+  vec4<f32>(0.055505, -0.082422, -0.306623, -0.002158),
+  vec4<f32>(-0.069216, 0.025390, 0.115682, 0.003998),
+  vec4<f32>(0.003658, 0.005020, -0.030552, -0.000240),
+  vec4<f32>(-0.098989, -0.184700, -0.022792, -0.103414),
+  vec4<f32>(0.049262, 0.049013, -0.128087, -0.003178),
+  vec4<f32>(-0.058554, -0.003729, 0.058846, -0.085285),
+  vec4<f32>(-0.035445, -0.019361, -0.052863, -0.002660),
+  vec4<f32>(0.083422, 0.091406, -0.036251, -0.056327),
+  vec4<f32>(0.024325, 0.050197, -0.039827, -0.002158),
+  vec4<f32>(-0.109939, -0.003565, -0.011907, 0.029464),
+  vec4<f32>(-0.086083, -0.069154, -0.014363, -0.000240),
+  vec4<f32>(-0.124019, -0.084706, 0.009848, -0.010163),
+  vec4<f32>(0.057308, -0.026932, -0.081104, -0.003178),
+  vec4<f32>(-0.110101, 0.041306, 0.084147, -0.124628),
+  vec4<f32>(0.041361, -0.027283, 0.043425, -0.002660),
+  vec4<f32>(0.069842, 0.001562, 0.028766, 0.031793),
+  vec4<f32>(-0.002425, -0.081313, 0.052750, -0.002158),
+  vec4<f32>(-0.153072, 0.053884, -0.049888, -0.071672),
+  vec4<f32>(-0.032800, -0.092275, -0.013350, -0.000240),
+  vec4<f32>(-0.058804, -0.066881, 0.042647, -0.117655),
+  vec4<f32>(-0.006964, 0.025245, -0.037709, -0.003178),
+  vec4<f32>(-0.013743, 0.028460, 0.038643, 0.002846),
+  vec4<f32>(-0.054501, 0.052237, 0.085796, -0.002660),
+  vec4<f32>(-0.190596, -0.175290, -0.125767, -0.086448),
+  vec4<f32>(-0.038734, 0.043720, -0.223417, -0.002158),
+  vec4<f32>(-0.070644, 0.031216, 0.108074, -0.008384),
+  vec4<f32>(-0.017921, -0.106933, 0.022512, -0.000240),
+  vec4<f32>(-0.164841, -0.210442, -0.013075, -0.116213),
+  vec4<f32>(-0.003837, -0.033905, -0.069654, -0.003178),
+  vec4<f32>(-0.018835, 0.005613, 0.045342, -0.080079),
+  vec4<f32>(0.025648, -0.004767, 0.007781, -0.002660),
+  vec4<f32>(-0.348398, -0.252983, -0.157734, -0.073816),
+  vec4<f32>(0.020139, 0.000464, -0.288106, -0.002158),
+  vec4<f32>(-0.029596, 0.107651, 0.076904, -0.019014),
+  vec4<f32>(-0.109976, -0.087190, 0.002392, -0.000240),
+  vec4<f32>(-0.166818, -0.172017, -0.039810, -0.056316),
+  vec4<f32>(0.041083, -0.004783, -0.232198, -0.003178),
+  vec4<f32>(-0.094779, -0.017904, 0.068023, -0.094256),
+  vec4<f32>(0.034150, 0.051404, 0.040876, -0.002660),
+  vec4<f32>(-0.148501, -0.181694, -0.026094, -0.093760),
+  vec4<f32>(0.022603, -0.037887, -0.084341, -0.002158),
+  vec4<f32>(-0.098837, -0.025000, 0.038907, 0.036795),
+  vec4<f32>(-0.006058, -0.129751, 0.097099, -0.000240),
+  vec4<f32>(-0.199423, -0.139937, -0.051632, -0.121129),
+  vec4<f32>(-0.057040, -0.069452, -0.156847, -0.003178),
+  vec4<f32>(-0.062180, -0.025182, 0.097598, -0.114684),
+  vec4<f32>(0.044143, -0.033892, 0.061136, -0.002660),
+  vec4<f32>(0.183328, 0.039865, 0.122797, 0.024494),
+  vec4<f32>(-0.008148, -0.026139, 0.111109, -0.002158),
+  vec4<f32>(-0.074979, 0.031629, -0.046256, -0.075427),
+  vec4<f32>(-0.096641, -0.032357, 0.017125, -0.000240),
+  vec4<f32>(-0.138202, -0.021292, 0.064264, -0.007920),
+  vec4<f32>(-0.001949, 0.038345, -0.076910, -0.003178),
+  vec4<f32>(-0.120645, 0.076473, 0.094956, -0.031807),
+  vec4<f32>(-0.040214, -0.080621, -0.033018, -0.002660),
+  vec4<f32>(0.237077, 0.159636, 0.173947, -0.021071),
+  vec4<f32>(0.025396, 0.027951, 0.211648, -0.002158),
+  vec4<f32>(-0.043910, -0.071438, -0.033957, -0.010684),
+  vec4<f32>(-0.028202, -0.138960, -0.035507, -0.000240),
+  vec4<f32>(-0.067218, -0.049291, 0.118526, -0.051231),
+  vec4<f32>(-0.015773, -0.043131, -0.102149, -0.003178),
+  vec4<f32>(-0.116426, 0.071179, 0.128713, -0.066136),
+  vec4<f32>(-0.001616, 0.004815, 0.011809, -0.002660),
+  vec4<f32>(0.040222, 0.054596, 0.009854, -0.031067),
+  vec4<f32>(-0.061482, -0.025609, 0.108516, -0.002158),
+  vec4<f32>(-0.121747, 0.074633, 0.001488, 0.001438),
+  vec4<f32>(-0.093486, -0.048488, -0.060187, -0.000240),
+  vec4<f32>(-0.086223, -0.119723, 0.009241, -0.088159),
+  vec4<f32>(0.085580, -0.010730, -0.091353, -0.003178),
+  vec4<f32>(-0.151426, 0.098420, 0.006069, -0.125885),
+  vec4<f32>(-0.046058, -0.072590, -0.009358, -0.002660),
+  vec4<f32>(-0.015770, -0.054706, 0.087011, 0.032169),
+  vec4<f32>(0.035956, 0.046402, 0.044666, -0.002158),
+  vec4<f32>(-0.022348, -0.028960, 0.067758, -0.018345),
+  vec4<f32>(-0.012387, -0.047907, 0.029429, -0.000240),
+  vec4<f32>(-0.150195, -0.032752, 0.026359, -0.076354),
+  vec4<f32>(-0.017055, -0.011478, -0.079514, -0.003178),
+  vec4<f32>(-0.089903, 0.060436, -0.004510, -0.068032),
+  vec4<f32>(-0.008137, -0.036009, 0.027795, -0.002660),
+  vec4<f32>(0.072970, 0.089424, 0.109268, -0.090907),
+  vec4<f32>(-0.036855, -0.030546, 0.049232, -0.002158),
+  vec4<f32>(-0.135938, -0.021615, 0.072019, -0.047977),
+  vec4<f32>(-0.094139, -0.126788, -0.048610, -0.000240),
+  vec4<f32>(-0.026014, -0.049925, 0.107261, -0.000811),
+  vec4<f32>(0.022140, 0.054370, -0.052305, -0.003178),
+  vec4<f32>(-0.136951, -0.034499, 0.108512, 0.017190),
+  vec4<f32>(-0.085810, -0.010209, -0.019581, -0.002660),
+  vec4<f32>(0.143194, 0.078820, 0.048983, 0.003718),
+  vec4<f32>(-0.028938, 0.057260, 0.148278, -0.002158),
+  vec4<f32>(-0.099794, -0.018127, 0.008651, 0.043635),
+  vec4<f32>(-0.010949, -0.013601, -0.092105, -0.000240),
+  vec4<f32>(-0.065650, -0.030568, 0.094407, -0.103005),
+  vec4<f32>(-0.060091, 0.003796, -0.069641, -0.003178)
 );
 
 const weights_layer1: array<vec4<f32>, 72> = array(
-  vec4<f32>(0.254979, 0.244192, -0.324097, 0.193675),
-  vec4<f32>(-0.216693, -0.037426, 0.137290, 0.013792),
-  vec4<f32>(-0.237225, -0.270981, 0.141186, -0.200254),
-  vec4<f32>(0.112698, -0.065897, -0.043789, -0.001900),
-  vec4<f32>(-0.003851, 0.048306, -0.180819, 0.001167),
-  vec4<f32>(-0.096826, -0.121978, 0.068031, 0.017312),
-  vec4<f32>(-0.020896, -0.321049, 0.236152, -0.117393),
-  vec4<f32>(0.166722, 0.114709, -0.040971, -0.003923),
-  vec4<f32>(0.086793, 0.348764, -0.262425, 0.388516),
-  vec4<f32>(-0.003484, 0.049151, 0.089976, 0.013792),
-  vec4<f32>(-0.080785, -0.197224, 0.172738, -0.199285),
-  vec4<f32>(-0.056783, -0.079022, 0.002687, -0.001900),
-  vec4<f32>(0.230001, 0.195060, -0.237831, 0.213528),
-  vec4<f32>(0.010828, -0.175885, 0.075520, 0.017312),
-  vec4<f32>(-0.048712, -0.175662, 0.176246, -0.067224),
-  vec4<f32>(-0.048118, 0.067163, -0.114919, -0.003923),
-  vec4<f32>(0.134012, 0.106994, -0.240137, 0.317381),
-  vec4<f32>(-0.209563, 0.027607, 0.150277, 0.013792),
-  vec4<f32>(0.009538, -0.103125, 0.068209, -0.046492),
-  vec4<f32>(0.007195, -0.039193, -0.100942, -0.001900),
-  vec4<f32>(0.052864, 0.280180, -0.209586, 0.237769),
-  vec4<f32>(0.023231, 0.038595, -0.071840, 0.017312),
-  vec4<f32>(-0.141548, -0.233184, 0.023925, -0.019451),
-  vec4<f32>(0.067484, 0.057416, 0.051800, -0.003923),
-  vec4<f32>(0.087521, 0.214685, -0.282225, 0.424372),
-  vec4<f32>(-0.056052, -0.156497, 0.023169, 0.013792),
-  vec4<f32>(-0.258638, -0.149771, 0.183942, -0.260751),
-  vec4<f32>(0.148103, 0.129853, 0.012112, -0.001900),
-  vec4<f32>(0.010897, 0.133480, -0.192718, 0.252913),
-  vec4<f32>(-0.088200, -0.138182, -0.005718, 0.017312),
-  vec4<f32>(-0.209273, -0.180554, 0.232975, -0.064025),
-  vec4<f32>(0.040287, -0.104819, 0.049971, -0.003923),
-  vec4<f32>(0.107734, 0.238235, -0.326000, 0.247477),
-  vec4<f32>(-0.181079, -0.113835, 0.103895, 0.013792),
-  vec4<f32>(-0.101286, -0.185177, 0.277056, -0.084833),
-  vec4<f32>(0.106763, 0.107663, -0.073146, -0.001900),
-  vec4<f32>(-0.005552, 0.177759, -0.029719, 0.060847),
-  vec4<f32>(0.161847, -0.061512, 0.132996, 0.017312),
-  vec4<f32>(-0.257929, -0.377618, 0.130284, -0.159584),
-  vec4<f32>(0.093874, -0.134273, -0.030173, -0.003923),
-  vec4<f32>(0.214204, 0.298440, -0.217456, 0.215751),
-  vec4<f32>(-0.122887, -0.152684, 0.125991, 0.013792),
-  vec4<f32>(-0.183399, -0.242007, 0.076115, -0.234678),
-  vec4<f32>(0.097245, 0.104651, 0.037698, -0.001900),
-  vec4<f32>(0.119585, 0.291845, -0.081658, 0.209448),
-  vec4<f32>(0.205421, -0.010635, -0.016784, 0.017312),
-  vec4<f32>(-0.097006, -0.123679, 0.222243, -0.211022),
-  vec4<f32>(0.092569, -0.032077, -0.082684, -0.003923),
-  vec4<f32>(0.225746, 0.263205, -0.388231, 0.342453),
-  vec4<f32>(-0.002536, 0.050069, 0.130625, 0.013792),
-  vec4<f32>(-0.238043, -0.051000, 0.113924, -0.204495),
-  vec4<f32>(0.020115, -0.106413, 0.127491, -0.001900),
-  vec4<f32>(0.194054, 0.126466, -0.102551, 0.263437),
-  vec4<f32>(-0.072873, 0.018799, -0.015787, 0.017312),
-  vec4<f32>(-0.042832, -0.173311, 0.147956, -0.126879),
-  vec4<f32>(0.128747, -0.134294, 0.111303, -0.003923),
-  vec4<f32>(0.243550, 0.288997, -0.250508, 0.252519),
-  vec4<f32>(-0.089251, -0.111297, 0.112490, 0.013792),
-  vec4<f32>(-0.223589, -0.095261, 0.145935, -0.139099),
-  vec4<f32>(0.156093, -0.096579, -0.006812, -0.001900),
-  vec4<f32>(0.005154, 0.251212, -0.107685, 0.143674),
-  vec4<f32>(-0.017334, -0.082075, 0.088612, 0.017312),
-  vec4<f32>(-0.199050, -0.333849, 0.219760, -0.079489),
-  vec4<f32>(0.127082, 0.103959, -0.133810, -0.003923),
-  vec4<f32>(0.297919, 0.254741, -0.134594, 0.088785),
-  vec4<f32>(-0.095642, -0.044997, 0.167123, 0.013792),
-  vec4<f32>(-0.004141, -0.243894, 0.176584, -0.157082),
-  vec4<f32>(0.068545, -0.112190, -0.117632, -0.001900),
-  vec4<f32>(0.045947, 0.055152, -0.161696, 0.018504),
-  vec4<f32>(0.197872, 0.018991, -0.106403, 0.017312),
-  vec4<f32>(-0.190943, -0.075032, 0.069981, -0.145124),
-  vec4<f32>(0.012619, 0.059838, -0.139603, -0.003923)
+  vec4<f32>(-0.111300, 0.179988, -0.062663, 0.061283),
+  vec4<f32>(-0.129565, -0.038250, 0.030218, 0.011305),
+  vec4<f32>(-0.169525, 0.054469, -0.086771, 0.153689),
+  vec4<f32>(-0.148870, 0.044639, -0.144370, -0.003501),
+  vec4<f32>(0.103885, -0.061993, 0.120641, -0.175970),
+  vec4<f32>(0.088250, 0.126269, 0.073829, 0.002715),
+  vec4<f32>(-0.011900, -0.099074, 0.020732, -0.160845),
+  vec4<f32>(-0.017101, -0.022551, 0.147173, -0.012887),
+  vec4<f32>(0.061818, 0.307288, -0.035523, 0.104974),
+  vec4<f32>(0.028991, -0.068476, 0.049124, 0.011305),
+  vec4<f32>(-0.219347, 0.075629, -0.011402, 0.039528),
+  vec4<f32>(-0.143927, 0.090994, 0.011908, -0.003501),
+  vec4<f32>(-0.011068, -0.242697, 0.047950, -0.237441),
+  vec4<f32>(-0.115238, 0.088746, 0.220130, 0.002715),
+  vec4<f32>(-0.037267, -0.178245, 0.090156, 0.004407),
+  vec4<f32>(-0.061568, -0.006591, -0.071337, -0.012887),
+  vec4<f32>(-0.145354, 0.247036, -0.028697, 0.116387),
+  vec4<f32>(0.049237, -0.060245, -0.081079, 0.011305),
+  vec4<f32>(-0.174962, 0.090218, -0.104057, 0.010172),
+  vec4<f32>(0.079751, -0.011012, 0.007596, -0.003501),
+  vec4<f32>(0.027690, -0.234100, 0.113760, -0.097029),
+  vec4<f32>(0.041023, 0.014642, 0.114447, 0.002715),
+  vec4<f32>(0.158784, 0.031636, -0.079122, -0.109976),
+  vec4<f32>(-0.072500, 0.023157, -0.046755, -0.012887),
+  vec4<f32>(0.013803, 0.092474, -0.001693, 0.183026),
+  vec4<f32>(-0.125946, -0.031316, -0.143884, 0.011305),
+  vec4<f32>(-0.121506, 0.004353, -0.158128, 0.045948),
+  vec4<f32>(-0.062435, 0.127158, 0.014538, -0.003501),
+  vec4<f32>(0.040551, -0.293101, -0.008423, 0.003132),
+  vec4<f32>(-0.091097, -0.010485, 0.015698, 0.002715),
+  vec4<f32>(0.141366, 0.029283, 0.078463, -0.138398),
+  vec4<f32>(-0.011756, -0.003586, 0.093599, -0.012887),
+  vec4<f32>(-0.047838, 0.332608, -0.040415, 0.113442),
+  vec4<f32>(0.047320, -0.083815, -0.193297, 0.011305),
+  vec4<f32>(0.009395, 0.150041, -0.164841, -0.010595),
+  vec4<f32>(-0.003120, 0.041768, -0.022312, -0.003501),
+  vec4<f32>(0.153414, -0.483877, 0.027543, -0.128364),
+  vec4<f32>(0.073278, -0.073777, 0.056988, 0.002715),
+  vec4<f32>(0.189253, -0.191657, -0.063098, 0.001237),
+  vec4<f32>(0.149191, -0.058555, 0.028820, -0.012887),
+  vec4<f32>(-0.016164, 0.226607, 0.074957, 0.025479),
+  vec4<f32>(-0.002376, -0.111827, -0.051682, 0.011305),
+  vec4<f32>(-0.048812, 0.089271, 0.054752, 0.026435),
+  vec4<f32>(-0.151279, -0.118070, 0.002317, -0.003501),
+  vec4<f32>(0.183921, -0.443623, 0.020614, -0.086463),
+  vec4<f32>(0.112205, 0.107158, 0.010596, 0.002715),
+  vec4<f32>(0.176441, -0.011633, 0.143096, 0.052081),
+  vec4<f32>(0.064382, 0.002594, -0.014855, -0.012887),
+  vec4<f32>(0.042707, -0.005497, 0.041100, 0.090720),
+  vec4<f32>(-0.070393, -0.031079, -0.147248, 0.011305),
+  vec4<f32>(-0.210105, -0.076573, 0.008268, -0.081899),
+  vec4<f32>(0.045166, 0.048676, -0.085024, -0.003501),
+  vec4<f32>(0.193255, -0.090670, -0.047522, -0.037380),
+  vec4<f32>(-0.071527, -0.050514, -0.053537, 0.002715),
+  vec4<f32>(0.066582, -0.077699, 0.050853, -0.041915),
+  vec4<f32>(-0.050763, 0.038935, 0.055684, -0.012887),
+  vec4<f32>(0.084452, 0.110940, -0.161886, 0.063339),
+  vec4<f32>(-0.040771, -0.005006, -0.027991, 0.011305),
+  vec4<f32>(-0.108366, 0.005150, -0.157536, -0.058761),
+  vec4<f32>(-0.049530, -0.067842, -0.065819, -0.003501),
+  vec4<f32>(-0.025406, -0.171920, -0.039322, -0.212615),
+  vec4<f32>(0.033416, -0.076773, 0.124133, 0.002715),
+  vec4<f32>(0.169898, 0.048856, 0.118878, -0.069478),
+  vec4<f32>(0.050061, 0.008831, -0.084925, -0.012887),
+  vec4<f32>(-0.074426, -0.016317, -0.043268, 0.128168),
+  vec4<f32>(-0.101404, -0.103024, -0.130285, 0.011305),
+  vec4<f32>(-0.118552, -0.004382, 0.015605, 0.104632),
+  vec4<f32>(-0.101354, 0.014364, 0.000556, -0.003501),
+  vec4<f32>(0.087569, -0.182623, -0.071826, -0.177235),
+  vec4<f32>(0.098524, 0.023910, 0.109113, 0.002715),
+  vec4<f32>(0.102561, 0.025303, -0.041295, -0.103003),
+  vec4<f32>(-0.022860, 0.006854, -0.063332, -0.012887)
 );
 
 const weights_layer2: array<vec4<f32>, 18> = array(
-  vec4<f32>(0.245902, -0.217970, 0.056291, -0.070807),
-  vec4<f32>(0.016448, -0.018901, -0.124061, -0.004665),
-  vec4<f32>(0.031777, -0.024354, 0.057418, -0.191855),
-  vec4<f32>(0.066501, -0.005719, 0.060455, -0.004665),
-  vec4<f32>(0.152728, -0.171275, 0.042248, -0.104487),
-  vec4<f32>(0.080702, -0.084644, 0.121606, -0.004665),
-  vec4<f32>(0.250396, -0.225428, 0.240979, -0.069204),
-  vec4<f32>(-0.025812, -0.029050, 0.050136, -0.004665),
-  vec4<f32>(0.042793, -0.011392, 0.222963, -0.241601),
-  vec4<f32>(-0.134324, -0.071387, 0.108891, -0.004665),
-  vec4<f32>(0.130457, -0.123356, 0.002928, -0.122289),
-  vec4<f32>(-0.059852, -0.166258, -0.062116, -0.004665),
-  vec4<f32>(0.171512, -0.030577, 0.234602, -0.193894),
-  vec4<f32>(-0.020420, -0.071602, -0.056219, -0.004665),
-  vec4<f32>(0.242776, -0.138304, 0.220627, -0.012853),
-  vec4<f32>(0.020668, -0.104949, -0.013328, -0.004665),
-  vec4<f32>(0.013987, -0.195309, 0.083045, -0.189454),
-  vec4<f32>(0.028755, -0.036818, 0.045813, -0.004665)
+  vec4<f32>(-0.041135, -0.105957, 0.040282, 0.039236),
+  vec4<f32>(-0.029214, -0.016568, 0.045032, -0.004521),
+  vec4<f32>(-0.041263, -0.040699, 0.003398, 0.139836),
+  vec4<f32>(0.038987, 0.060792, 0.099677, -0.004521),
+  vec4<f32>(-0.090320, -0.197101, 0.148843, 0.191315),
+  vec4<f32>(0.037999, 0.050964, -0.028362, -0.004521),
+  vec4<f32>(0.009794, 0.035681, 0.205626, -0.012895),
+  vec4<f32>(-0.078717, 0.093512, 0.144963, -0.004521),
+  vec4<f32>(-0.150205, -0.065667, 0.167757, -0.041286),
+  vec4<f32>(-0.063287, 0.098870, -0.012293, -0.004521),
+  vec4<f32>(-0.136732, -0.186343, 0.153279, 0.118431),
+  vec4<f32>(0.037954, -0.076341, 0.079348, -0.004521),
+  vec4<f32>(-0.177352, -0.067423, 0.067748, 0.169459),
+  vec4<f32>(0.081802, 0.048535, 0.102561, -0.004521),
+  vec4<f32>(-0.051314, -0.088203, 0.155402, 0.071094),
+  vec4<f32>(-0.034513, -0.108946, 0.135973, -0.004521),
+  vec4<f32>(-0.206675, -0.195382, 0.073164, 0.211539),
+  vec4<f32>(-0.050079, -0.117446, 0.058298, -0.004521)
 );