fix(facade): quantization trained-state + rank-3 tensor training + interface-completeness guard (#1887)

* fix(facade): unblock quantization trained-state, rank-3 tensor training, and

…IAiModelBuilder.ConfigureMemoryManagement
Three blockers that prevented consumers from using the facade optimization
profile on real forecasting pipelines:

1. IAiModelBuilder<T,TInput,TOutput> was missing ConfigureMemoryManagement — it
   existed only on the concrete AiModelBuilder, so callers holding the interface
   (the normal facade surface) couldn't enable gradient checkpointing. Added to
   the interface (concrete already implements it).

2. Quantization dropped trained state. Quantizers rebuild the model from its
   parameter vector via IParameterizable.WithParameters, which for families that
   keep trained internals OUTSIDE GetParameters() (gradient-boosted trees'
   _trees/_binThresholds, etc.) produces a fresh UNTRAINED instance — so Predict
   threw "Model must be trained before making predictions" (surfaced when the
   JIT path then traced it). ApplyQuantizationIfConfigured now re-seats the
   quantized parameters onto a DeepCopy of the trained source (in-place
   SetParameters), preserving those internals across all quantizer strategies.

3. Rank-3 tensor forecasting models crashed the supervised build. The optimizer's
   "non-flat neural input" guard (which skips column-subset feature selection)
   keyed off the first layer's declared input rank, so Dense-embedding forecasters
   like PatchTST/iTransformer were misclassified as columnar and reached
   GetColumnVectors on a rank-3 [batch, seq, features] tensor → ArgumentException
   "Number of indices must match the tensor's rank." The guard now also falls
   back to the ACTUAL input rank (XTrain is a rank>2 Tensor), and GetColumnVectors
   rejects rank!=2 with a clear message. Matrix and rank-2 tensor paths untouched.

Regression tests cover all three (FacadeOptimizationBlockerTests).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* test(facade): guard IAiModelBuilder completeness + close 6 more interface gaps

Adds a reflection-based test that FAILS if any fluent method on the concrete
AiModelBuilder (one returning IAiModelBuilder for chaining) is not reachable
through IAiModelBuilder or one of its documented derived capability interfaces
(e.g. IWeightStreamingCapableBuilder). This permanently catches the class of gap
that hid ConfigureMemoryManagement — a facade method callers couldn't invoke
once a chain returned the interface.

Running it surfaced six more genuinely-missing methods, now declared on the
interface (the concrete already implemented them):
  ConfigureProfiling, ConfigureInterpretability,
  ConfigurePreprocessing(PreprocessingPipeline<T,TInput,TInput>),
  ConfigureAugmentation(AugmentationConfig<T,TInput>),
  ConfigureAutoML(IAutoMLModel<T,TInput,TOutput>),
  ConfigureDataLoader(IDataLoader<ImageView<T>, PixelBatch<T>>).

ConfigureWeightStreaming stays on IWeightStreamingCapableBuilder by design (an
opt-in-via-cast surface kept off IAiModelBuilder for binary compat); the guard
treats derived-interface methods as reachable, so it is not flagged.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* fix(facade): address review — no state-losing quant fallback, keep interface non-breaking

Resolves the four review findings on this PR:
- Quantization: on trained-state preservation failure, return no quantized model
  (skip quantization, keep the original TRAINED model) instead of falling back to
  the quantizer's untrained rebuild that would crash at predict.
- Do NOT add the seven fluent methods to IAiModelBuilder — that reverses the
  documented compat policy (adding abstract members breaks external implementers;
  the advanced ConfigureAutoML overload is explicitly noted as concrete-only).
  They stay public on the concrete builder; a NOTE records why.
- Completeness guard: accept a derived capability interface only if AiModelBuilder
  actually IMPLEMENTS it, and pin the intentional concrete-only set in an explicit
  allowlist. A new fluent method now forces a conscious choice (interface vs
  allowlist) rather than silently disappearing from the surface.
- Blocker test: assert the fluent call returns the SAME builder instance
  (Assert.Same), not merely non-null.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* fix(facade): re-throw cancellation/OOM on quant preservation; log via observability

Address review: the quantization state-preservation catch now filters to EXPECTED
failures — OperationCanceledException and OutOfMemoryException propagate instead of
being turned into a successful-looking unquantized build — and routes its warning
through the configured _accelerationLogger rather than Console.WriteLine.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* refactor(facade): all fluent Configure methods on IAiModelBuilder; guard enforces it

Reverses the concrete-only approach per maintainer direction: every fluent
AiModelBuilder method (one returning IAiModelBuilder for chaining) is now declared
on IAiModelBuilder in the standard style — ConfigureMemoryManagement,
ConfigureProfiling, ConfigureInterpretability, the PreprocessingPipeline overload
of ConfigurePreprocessing, the typed ConfigureAugmentation, the advanced
ConfigureAutoML(IAutoMLModel), the NeRF ConfigureDataLoader, and
ConfigureWeightStreaming. Breaking changes for external implementers are accepted;
the facade surface must be complete and uniform.

Removes the compat shims: the 'intentionally concrete-only' NOTEs, the
IntentionallyConcreteOnly allowlist, and the separate IWeightStreamingCapableBuilder
capability interface (WeightStreaming now lives on IAiModelBuilder like everything
else). The completeness test now fails if ANY fluent concrete method is missing
from IAiModelBuilder — no allowlist, no shortcuts.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* fix(timeseries): deepAR no longer collapses to a constant on short prediction rows

DeepARModel.PredictDistribution replaced the caller's window with a FIXED slice of
the training series whenever the row was shorter than LookbackWindow — identical
for every row — so the LSTM ran on the same input each call and the whole test
block came out as one constant value (verified: DeepAR predicted a single value
even on a trivially-predictable sine series, while DLinear on the same data
varied). Left-pad the caller's own window instead (preserving its real values,
especially the most-recent one that drives the residual skip); never overwrite it
with training data. Regression test covers the short-row / cross-sectional case;
all 58 DeepAR tests pass.

NOTE (follow-up): TrainCore trains autoregressively on the target series y and
ignores x. That is consistent with DeepAR's univariate paradigm but mismatches the
x-rows-as-windows contract DLinear/NBEATS use, so a caller passing a feature matrix
gets varying-but-covariate-blind forecasts. Reconciling that contract (covariate
support, or documenting DeepAR as univariate-on-y) is a separate design change.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* fix(regression): numerically condition MultipleRegression against near-collinear designs

Normal equations square the condition number, so a near-collinear design yields a
severely ill-conditioned X'X. Cholesky still SUCCEEDS on it (positive-definite,
just ill-conditioned) and returns absurd blown-up coefficients — huge but FINITE,
so the NaN/Infinity guard in SolveSystem never trips — producing ~1e10 predictions
on normal-scale data. Add a tiny Tikhonov diagonal-loading scaled to the matrix's
own diagonal (1e-9 * mean-diagonal): negligible for well-conditioned problems
(below solver noise; all 46 existing MultipleRegression tests unchanged) yet enough
to bound the blow-up. Regression test drives a near-duplicate-column design.

This is the upstream root fix for the ~1e10 spikes the Ooples RL-observation path
was clamping defensively.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: ooples

src/AiModelBuilder.Internals.cs

@@ -1879,6 +1879,33 @@ private static int TryInjectMonteCarloDropoutLayers(
         var quantizedModel = quantizer.Quantize(model, internalConfig);
         var quantizedParameters = InterfaceGuard.Parameterizable(quantizedModel).GetParameters();
 
+        // Preserve trained state through quantization. Quantizers rebuild the model from its parameter vector
+        // (IParameterizable.WithParameters), which for model families that keep trained state OUTSIDE
+        // GetParameters() — e.g. gradient-boosted trees' tree ensembles and bin thresholds — drops those
+        // internals, leaving the quantized model UNTRAINED so its Predict throws "Model must be trained before
+        // making predictions" (surfaced when a downstream consumer such as the JIT path then traces it). Re-seat
+        // the quantized parameters onto a full DeepCopy of the trained source, which keeps those internals, and
+        // apply the parameters in-place (SetParameters) rather than rebuilding.
+        try
+        {
+            var trainedQuantized = model.DeepCopy();
+            InterfaceGuard.Parameterizable(trainedQuantized).SetParameters(quantizedParameters);
+            quantizedModel = trainedQuantized;
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException && ex is not OutOfMemoryException)
+        {
+            // Preserving trained state failed for an EXPECTED reason (e.g. a model that can't round-trip via
+            // DeepCopy/SetParameters). Do NOT fall back to the quantizer's rebuilt model — for families that keep
+            // trained internals outside the parameter vector it is UNTRAINED and would throw at predict time (the
+            // exact defect this path fixes). Skip quantization so the caller keeps the original trained,
+            // unquantized model rather than a landmine. Cancellation and out-of-memory are NOT expected here and
+            // propagate so they aren't silently turned into a successful-looking build.
+            _accelerationLogger?.Invoke(
+                $"[AiDotNet] Quantization skipped: could not preserve trained state ({ex.GetType().Name}: {ex.Message}); " +
+                "keeping the original trained model.");
+            return (null, null);
+        }
+
         // Calculate actual quantized size based on bit width
         // For sub-byte quantization (4-bit), we need to account for packing
         long quantizedSizeBytes = ((long)quantizedParameters.Length * internalConfig.EffectiveBitWidth + 7) / 8;

src/AiModelBuilder.cs

@@ -132,7 +132,7 @@ namespace AiDotNet;
 /// modelRegistry.TransitionStage(modelVersion.ModelId, modelVersion.Version, ModelStage.Production);
 /// </code>
 /// </remarks>
-public partial class AiModelBuilder<T, TInput, TOutput> : IAiModelBuilder<T, TInput, TOutput>, IWeightStreamingCapableBuilder<T, TInput, TOutput>, AiDotNet.Configuration.IConfiguredView<T, TInput, TOutput>
+public partial class AiModelBuilder<T, TInput, TOutput> : IAiModelBuilder<T, TInput, TOutput>, AiDotNet.Configuration.IConfiguredView<T, TInput, TOutput>
 {
     private static IEngine Engine => AiDotNetEngine.Current;
 

src/Helpers/ModelHelper.cs

@@ -228,9 +228,15 @@ public static List<Vector<T>> GetColumnVectors(TInput input, int[] indices)
         }
         else if (input is Tensor<T> tensor)
         {
-            if (tensor.Shape.Length < 2)
+            if (tensor.Shape.Length != 2)
             {
-                throw new ArgumentException("Tensor must have at least 2 dimensions to extract columns");
+                // Column extraction indexes axis 1 with a 2-index accessor, so it is only defined for a rank-2
+                // tensor. A rank>2 (e.g. [batch, seq, features]) input reaching here means a "non-flat" model
+                // was misclassified as columnar upstream — fail with a clear message instead of the cryptic
+                // "Number of indices must match the tensor's rank" from the tensor accessor.
+                throw new ArgumentException(
+                    $"Column extraction requires a rank-2 tensor; got rank {tensor.Shape.Length} " +
+                    $"(shape {string.Join("×", tensor._shape)}).");
             }
 
             var result = new List<Vector<T>>();

src/Interfaces/IAiModelBuilder.cs

@@ -1,5 +1,7 @@
 using AiDotNet.Agentic.Tools;
+using AiDotNet.Augmentation;
 using AiDotNet.Clustering.Interfaces;
+using AiDotNet.NeuralRadianceFields.Data;
 using AiDotNet.Configuration;
 using AiDotNet.Deployment.Configuration;
 using AiDotNet.DistributedTraining;
@@ -913,12 +915,6 @@ IAiModelBuilder<T, TInput, TOutput> ConfigurePipelineParallelism(
     /// </remarks>
     IAiModelBuilder<T, TInput, TOutput> ConfigureAutoML(AutoMLOptions<T, TInput, TOutput>? options = null);
 
-    // NOTE: The advanced ConfigureAutoML(IAutoMLModel<T,TInput,TOutput>) overload is intentionally
-    // NOT part of this interface. Adding it would be a breaking change for every external
-    // IAiModelBuilder<T,TInput,TOutput> implementer. It remains a public method on the concrete
-    // AiModelBuilder<T,TInput,TOutput>, which is also what the generated YAML applier targets
-    // (it dispatches against the concrete builder type, not this interface).
-
     /// <summary>
     /// Configures reinforcement learning options for training an RL agent.
     /// </summary>
@@ -1179,13 +1175,6 @@ IAiModelBuilder<T, TInput, TOutput> ConfigureKnowledgeDistillation(
     /// <returns>The builder instance for method chaining.</returns>
     IAiModelBuilder<T, TInput, TOutput> ConfigureTelemetry(TelemetryConfig? config = null);
 
-    // ConfigureWeightStreaming intentionally lives on
-    // IWeightStreamingCapableBuilder<T, TInput, TOutput> (declared at the
-    // bottom of this file) instead of on IAiModelBuilder<T, TInput, TOutput>,
-    // so adding it does not break external implementers of IAiModelBuilder.
-    // The concrete AiModelBuilder<T, TInput, TOutput> implements both
-    // interfaces, so existing fluent call sites continue to compile.
-
     /// <summary>
     /// Controls GPU backend diagnostic output visibility and routing.
     /// Exposes all three controls from github.com/ooples/AiDotNet#1122:
@@ -1450,6 +1439,80 @@ IAiModelBuilder<T, TInput, TOutput> ConfigureJitCompilation(
     /// </remarks>
     IAiModelBuilder<T, TInput, TOutput> ConfigureMixedPrecision(MixedPrecisionConfig? config = null);
 
+    /// <summary>
+    /// Configures training memory management — gradient checkpointing and activation pooling — so large models
+    /// (e.g. deep transformers) can train within a bounded activation-memory budget.
+    /// </summary>
+    /// <param name="configuration">The training-memory configuration (presets such as
+    /// <c>TrainingMemoryConfig.ForTransformers()</c> or <c>MemoryEfficient()</c>); <c>null</c> applies the defaults.</param>
+    /// <returns>The builder instance for method chaining.</returns>
+    /// <remarks>
+    /// <b>For Beginners:</b> deep models store the intermediate results of every layer during training so they
+    /// can compute gradients. Gradient checkpointing trades a little extra compute to recompute some of those
+    /// instead of holding them all in memory, which lets a bigger model fit on the same hardware.
+    /// </remarks>
+    IAiModelBuilder<T, TInput, TOutput> ConfigureMemoryManagement(Training.Memory.TrainingMemoryConfig? configuration = null);
+
+    /// <summary>
+    /// Configures Float16/Int8 weight streaming so very large models can run without holding all weights in
+    /// memory at once.
+    /// </summary>
+    /// <param name="config">The weight-streaming configuration; <c>null</c> applies the defaults.</param>
+    /// <returns>The builder instance for method chaining.</returns>
+    IAiModelBuilder<T, TInput, TOutput> ConfigureWeightStreaming(WeightStreamingConfig? config = null);
+
+    /// <summary>
+    /// Configures a runtime profiling pass over the build/inference path to capture timing and resource usage.
+    /// </summary>
+    /// <param name="config">The profiling configuration; <c>null</c> applies the defaults.</param>
+    /// <returns>The builder instance for method chaining.</returns>
+    IAiModelBuilder<T, TInput, TOutput> ConfigureProfiling(ProfilingConfig? config = null);
+
+    /// <summary>
+    /// Configures model interpretability — feature attribution and explanations — on the built result.
+    /// </summary>
+    /// <param name="options">The interpretability options; <c>null</c> applies the defaults.</param>
+    /// <returns>The builder instance for method chaining.</returns>
+    /// <remarks>
+    /// <b>For Beginners:</b> interpretability tools tell you WHY the model made a prediction — which inputs
+    /// mattered most — instead of treating it as an opaque box.
+    /// </remarks>
+    IAiModelBuilder<T, TInput, TOutput> ConfigureInterpretability(InterpretabilityOptions? options = null);
+
+    /// <summary>
+    /// Configures the preprocessing stage directly from a prebuilt
+    /// <see cref="PreprocessingPipeline{T,TInput,TInput}"/> (the overload for callers that already assembled one).
+    /// </summary>
+    /// <param name="pipeline">The preprocessing pipeline; <c>null</c> applies the defaults.</param>
+    /// <returns>The builder instance for method chaining.</returns>
+    IAiModelBuilder<T, TInput, TOutput> ConfigurePreprocessing(PreprocessingPipeline<T, TInput, TInput>? pipeline = null);
+
+    /// <summary>
+    /// Configures training-time data augmentation with a type-parameterized augmentation configuration.
+    /// </summary>
+    /// <param name="config">The augmentation configuration.</param>
+    /// <returns>The builder instance for method chaining.</returns>
+    /// <remarks>
+    /// <b>For Beginners:</b> augmentation makes extra, slightly-varied copies of your training data (e.g.
+    /// jittered or shifted) so the model sees more variety and generalizes better.
+    /// </remarks>
+    IAiModelBuilder<T, TInput, TOutput> ConfigureAugmentation(AugmentationConfig<T, TInput>? config);
+
+    /// <summary>
+    /// Configures AutoML with a caller-supplied AutoML model implementation (the advanced overload; the
+    /// <see cref="ConfigureAutoML(AutoMLOptions{T,TInput,TOutput})"/> overload takes a budget preset instead).
+    /// </summary>
+    /// <param name="autoMLModel">The AutoML model that drives architecture/hyperparameter search.</param>
+    /// <returns>The builder instance for method chaining.</returns>
+    IAiModelBuilder<T, TInput, TOutput> ConfigureAutoML(IAutoMLModel<T, TInput, TOutput> autoMLModel);
+
+    /// <summary>
+    /// Configures the Neural Radiance Field image-view / pixel-batch data loader (the overload for NeRF pipelines).
+    /// </summary>
+    /// <param name="dataLoader">The image-view / pixel-batch data loader.</param>
+    /// <returns>The builder instance for method chaining.</returns>
+    IAiModelBuilder<T, TInput, TOutput> ConfigureDataLoader(IDataLoader<ImageView<T>, PixelBatch<T>> dataLoader);
+
     /// <summary>
     /// Configures advanced reasoning capabilities for the model using Chain-of-Thought, Tree-of-Thoughts, and Self-Consistency strategies.
     /// </summary>
@@ -2323,28 +2386,3 @@ IAiModelBuilder<T, TInput, TOutput> ConfigureQueryStrategy(
     IAiModelBuilder<T, TInput, TOutput> ConfigureSimilarityMetric(RetrievalAugmentedGeneration.VectorSearch.ISimilarityMetric<T> metric);
 
 }
-
-/// <summary>
-/// Optional companion interface for builders that support PaLM-E-scale weight
-/// streaming. Kept separate from <see cref="IAiModelBuilder{T, TInput, TOutput}"/>
-/// so the introduction of <see cref="ConfigureWeightStreaming"/> does NOT
-/// break external implementers of <c>IAiModelBuilder</c>. Cast a builder to
-/// this interface (or use the concrete <see cref="AiModelBuilder{T, TInput, TOutput}"/>)
-/// to opt into the streaming control surface.
-/// </summary>
-public interface IWeightStreamingCapableBuilder<T, TInput, TOutput> : IAiModelBuilder<T, TInput, TOutput>
-{
-    /// <summary>
-    /// Configures weight streaming behaviour for the model under
-    /// construction. See the doc block on
-    /// <see cref="AiDotNet.AiModelBuilder{T, TInput, TOutput}.ConfigureWeightStreaming"/>
-    /// for the full behavioural contract — this declaration is the binding
-    /// surface callers should invoke through when they want to remain
-    /// abstract over the builder type.
-    /// </summary>
-    /// <param name="config">The streaming configuration. Pass null to
-    /// reset to default auto-detect behaviour; pass a populated config
-    /// to override.</param>
-    /// <returns>The builder instance for method chaining.</returns>
-    IAiModelBuilder<T, TInput, TOutput> ConfigureWeightStreaming(WeightStreamingConfig? config = null);
-}

src/Optimizers/OptimizerBase.cs

@@ -603,7 +603,14 @@ private OptimizationStepData<T, TInput, TOutput> PrepareAndEvaluateSolutionCore(
         // vector, so column-subset feature selection doesn't apply. They use all features
         // and skip data subsetting entirely (Step 4 below). Fixes #1468.
         int totalFeatures = InputHelper<T, TInput>.GetInputSize(inputData.XTrain);
-        bool hasNonFlatInput = HasNonFlatNeuralInput(solution);
+        // "Non-flat" = the input is a spatial/sequence tensor, so column-subset feature selection doesn't apply.
+        // HasNonFlatNeuralInput inspects the first layer's declared input rank, which misses Dense-embedding
+        // forecasters (PatchTST/iTransformer start with a Dense patch/variate embedding, so their first-layer
+        // rank is 1) even though they consume a rank-3 [batch, seq, features] tensor. Fall back to the ACTUAL
+        // input rank so any rank>2 tensor input skips column extraction (which would otherwise index axis 1 of a
+        // rank-3 tensor and throw). Matrix inputs and rank-2 tensors are unaffected.
+        bool hasNonFlatInput = HasNonFlatNeuralInput(solution)
+            || (inputData.XTrain is Tensor<T> nonFlatTensor && nonFlatTensor.Shape.Length > 2);
         List<int> selectedFeaturesIndices;
 
         if (!InterfaceGuard.Parameterizable(solution).SupportsParameterInitialization

src/Regression/MultipleRegression.cs

@@ -112,6 +112,7 @@ public override void Train(Matrix<T> x, Vector<T> y)
             x = x.AddConstantColumn(NumOps.One);
         var xTx = x.Transpose().Multiply(x);
         var regularizedXTx = xTx.Add(Regularization.Regularize(xTx));
+        ApplyNumericalConditioning(regularizedXTx);
         var xTy = x.Transpose().Multiply(y);
         var solution = SolveSystem(regularizedXTx, xTy);
         if (Options.UseIntercept)
@@ -125,6 +126,43 @@ public override void Train(Matrix<T> x, Vector<T> y)
         }
     }
 
+    /// <summary>
+    /// Adds a tiny Tikhonov diagonal-loading (ridge) to the normal-equations matrix for NUMERICAL CONDITIONING.
+    /// Normal equations square the condition number, so a near-collinear design yields a severely ill-conditioned
+    /// X'X. Cholesky still succeeds on it (it is positive-definite, just ill-conditioned) and returns absurd,
+    /// blown-up coefficients — huge but FINITE, so the NaN/Infinity guard in SolveSystem never trips and the
+    /// prediction explodes (e.g. ~1e10). The ridge is scaled to the matrix's own diagonal magnitude, so it is
+    /// negligible for well-conditioned problems (below solver noise) yet bounds the blow-up for collinear ones.
+    /// </summary>
+    private void ApplyNumericalConditioning(Matrix<T> matrix)
+    {
+        var n = matrix.Rows;
+        if (n == 0)
+        {
+            return;
+        }
+
+        var trace = NumOps.Zero;
+        for (var i = 0; i < n; i++)
+        {
+            trace = NumOps.Add(trace, matrix[i, i]);
+        }
+
+        // ridge = 1e-9 * mean(diagonal), with a tiny absolute floor for a degenerate (zero-diagonal) matrix.
+        var meanDiag = NumOps.Divide(trace, NumOps.FromDouble(n));
+        var ridge = NumOps.Multiply(NumOps.FromDouble(1e-9), meanDiag);
+        var floor = NumOps.FromDouble(1e-12);
+        if (NumOps.LessThanOrEquals(ridge, floor))
+        {
+            ridge = floor;
+        }
+
+        for (var i = 0; i < n; i++)
+        {
+            matrix[i, i] = NumOps.Add(matrix[i, i], ridge);
+        }
+    }
+
     /// <summary>
     /// Creates a new instance of the Multiple Regression model with the same configuration.
     /// </summary>

src/TimeSeries/DeepARModel.cs

@@ -465,13 +465,26 @@ public override T PredictSingle(Vector<T> input)
     /// </summary>
     private (T mean, T scale) PredictDistribution(Vector<T> input)
     {
-        // If the window is shorter than the lookback, pad from the training tail.
-        if (input.Length < _options.LookbackWindow && _trainingSeries.Length >= _options.LookbackWindow)
+        // If the window is shorter than the lookback, LEFT-PAD it with its own first value while keeping the
+        // caller's real values (in particular the most-recent one, which drives the residual skip at the head).
+        // NOTE: this previously replaced the window with a fixed slice of the TRAINING tail — identical for every
+        // row — so the LSTM ran on the same input each call and emitted one constant prediction for the whole
+        // test block. Never overwrite the caller's window with training data.
+        if (input.Length < _options.LookbackWindow)
         {
             var lb = new Vector<T>(_options.LookbackWindow);
-            int start = _trainingSeries.Length - _options.LookbackWindow;
-            for (int j = 0; j < _options.LookbackWindow; j++)
-                lb[j] = _trainingSeries[start + j];
+            int pad = _options.LookbackWindow - input.Length;
+            T fill = input.Length > 0 ? input[0] : NumOps.Zero;
+            for (int j = 0; j < pad; j++)
+            {
+                lb[j] = fill;
+            }
+
+            for (int j = 0; j < input.Length; j++)
+            {
+                lb[pad + j] = input[j];
+            }
+
             input = lb;
         }