perf: replace scalar column-extraction matmul with Engine.TensorMatMul

DevNetDetector: 2 hidden layers now use Engine.TensorMatMul + Engine.ReLU
instead of per-column DotProduct loops with manual ReLU.

NBEATSDetector: ForwardFC helper replaced with single
Engine.TensorMatMul + Engine.TensorBroadcastAdd call.

AnomalyTransformerDetector: feed-forward sublayer now uses
Engine.TensorMatMul for both layers + Engine.ReLU, replacing
scalar multiply-accumulate and column-extraction loops.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ooples

src/AnomalyDetection/NeuralNetwork/DevNetDetector.cs

@@ -393,27 +393,19 @@ private T Forward(Vector<T> x)
             throw new InvalidOperationException("Weights not initialized.");
         }
 
-        // Layer 1
-        var h1 = new Vector<T>(_hiddenDim);
-        for (int j = 0; j < _hiddenDim; j++)
-        {
-            T sum = b1[j];
-            var wCol = new Vector<T>(_inputDim);
-            for (int ii = 0; ii < _inputDim; ii++) wCol[ii] = w1[ii, j];
-            sum = NumOps.Add(sum, Engine.DotProduct(x, wCol));
-            h1[j] = NumOps.GreaterThan(sum, NumOps.Zero) ? sum : NumOps.Zero;
-        }
-
-        // Layer 2 — reuse wCol for hidden dim
-        var h2 = new Vector<T>(_hiddenDim);
-        var wColH = new Vector<T>(_hiddenDim);
-        for (int j = 0; j < _hiddenDim; j++)
-        {
-            T sum = b2[j];
-            for (int ii = 0; ii < _hiddenDim; ii++) wColH[ii] = w2[ii, j];
-            sum = NumOps.Add(sum, Engine.DotProduct(h1, wColH));
-            h2[j] = NumOps.GreaterThan(sum, NumOps.Zero) ? sum : NumOps.Zero;
-        }
+        // Layer 1: h1 = ReLU(x @ W1 + b1)  (SIMD via Engine)
+        var xTensor = Tensor<T>.FromVector(x).Reshape(1, _inputDim);
+        var h1Pre = Engine.TensorBroadcastAdd(
+            Engine.TensorMatMul(xTensor, Tensor<T>.FromMatrix(w1)),
+            Tensor<T>.FromVector(b1).Reshape(1, _hiddenDim));
+        var h1 = Engine.ReLU(h1Pre.Reshape(_hiddenDim).ToVector());
+
+        // Layer 2: h2 = ReLU(h1 @ W2 + b2)  (SIMD via Engine)
+        var h1Tensor = Tensor<T>.FromVector(h1).Reshape(1, _hiddenDim);
+        var h2Pre = Engine.TensorBroadcastAdd(
+            Engine.TensorMatMul(h1Tensor, Tensor<T>.FromMatrix(w2)),
+            Tensor<T>.FromVector(b2).Reshape(1, _hiddenDim));
+        var h2 = Engine.ReLU(h2Pre.Reshape(_hiddenDim).ToVector());
 
         // Output layer (linear)
         T score = b3[0];

src/AnomalyDetection/TimeSeries/AnomalyTransformerDetector.cs

@@ -1052,29 +1052,31 @@ private Matrix<T> FeedForward(Matrix<T> x)
         var h = new Vector<T>(ffDim);
         var wCol = new Vector<T>(ffDim);
 
+        var w1Tensor = Tensor<T>.FromMatrix(W1);
+        var b1Tensor = Tensor<T>.FromVector(b1).Reshape(1, ffDim);
+        var w2Tensor = Tensor<T>.FromMatrix(W2);
+        var b2Tensor = Tensor<T>.FromVector(b2).Reshape(1, _modelDim);
+
         for (int t = 0; t < seqLen; t++)
         {
-            // First layer with ReLU
-            for (int j = 0; j < ffDim; j++)
-            {
-                T sum = b1[j];
-                for (int i = 0; i < _modelDim; i++)
-                {
-                    sum = NumOps.Add(sum, NumOps.Multiply(x[t, i], W1[i, j]));
-                }
-                // ReLU
-                h[j] = NumOps.GreaterThan(sum, NumOps.Zero) ? sum : NumOps.Zero;
-            }
-
-            // Second layer with residual connection
+            // Extract row as vector for SIMD
+            var xRow = new Vector<T>(_modelDim);
+            for (int i = 0; i < _modelDim; i++) xRow[i] = x[t, i];
+            var xTensor = Tensor<T>.FromVector(xRow).Reshape(1, _modelDim);
+
+            // Layer 1: h = ReLU(x @ W1 + b1)  (SIMD via Engine)
+            var h1Pre = Engine.TensorBroadcastAdd(
+                Engine.TensorMatMul(xTensor, w1Tensor), b1Tensor);
+            var hVec = Engine.ReLU(h1Pre.Reshape(ffDim).ToVector());
+
+            // Layer 2: out = h @ W2 + b2  (SIMD via Engine)
+            var hTensor = Tensor<T>.FromVector(hVec).Reshape(1, ffDim);
+            var l2Out = Engine.TensorBroadcastAdd(
+                Engine.TensorMatMul(hTensor, w2Tensor), b2Tensor).Reshape(_modelDim).ToVector();
+
+            // Residual connection
             for (int j = 0; j < _modelDim; j++)
-            {
-                T sum = b2[j];
-                for (int ii = 0; ii < ffDim; ii++) wCol[ii] = W2[ii, j];
-                sum = NumOps.Add(sum, Engine.DotProduct(h, wCol));
-                // Residual connection
-                output[t, j] = NumOps.Add(sum, x[t, j]);
-            }
+                output[t, j] = NumOps.Add(l2Out[j], x[t, j]);
         }
 
         return output;

src/AnomalyDetection/TimeSeries/NBEATSDetector.cs

@@ -857,17 +857,13 @@ private class BlockGradients
 
     private Vector<T> ForwardFC(Vector<T> input, Matrix<T> W, Vector<T> b)
     {
+        // SIMD: output = input @ W + b via Engine.TensorMatMul
         int outputSize = W.Columns;
-        var output = new Vector<T>(outputSize);
-        var wCol = new Vector<T>(input.Length);
-
-        for (int j = 0; j < outputSize; j++)
-        {
-            for (int i = 0; i < input.Length; i++) wCol[i] = W[i, j];
-            output[j] = NumOps.Add(b[j], Engine.DotProduct(input, wCol));
-        }
-
-        return output;
+        var inputTensor = Tensor<T>.FromVector(input).Reshape(1, input.Length);
+        var result = Engine.TensorBroadcastAdd(
+            Engine.TensorMatMul(inputTensor, Tensor<T>.FromMatrix(W)),
+            Tensor<T>.FromVector(b).Reshape(1, outputSize));
+        return result.Reshape(outputSize).ToVector();
     }
 
     private Vector<T> ForwardFCNoOffset(Vector<T> input, Matrix<T> W, int outputSize)