Fits the PCA model Computes the mean, principal components, and variance statistics for the input data # Parameters - `x` - Feature matrix with sam

Applies the activation to a pre-activation tensor `z`, returning the activated output # Parameters - `z` - Pre-activation tensor (the linear output

Predicts class labels for samples in X # Parameters - `x` - The input samples matrix where each row is a sample # Returns - `Result<Array1<f64>, E

Asserts two arrays/tensors are element-wise equal within `eps` (absolute difference) For single scalars, use approx's `assert_abs_diff_eq!` / `assert

Sets a fixed RNG seed for the random initialization path, making it reproducible (default: `None`; PCA initialization is deterministic regardless) #

Tensor of all-ones with the given flat shape

Sets the training mode if the layer is mode-dependent Lets layers that behave differently during training and inference switch between modes. Layers

Sets the weights and bias for this layer # Parameters - `weights` - Weight matrix with shape (input_dim, output_dim) - `bias` - Bias vector with sha

Computes the gradient with respect to the pre-activation input Every supported activation's derivative is expressible in terms of its own output, so

Adds a layer to the model Supports method chaining # Parameters - `layer` - The layer to add to the model # Returns - `&mut Self` - Mutable refer

Asserts two arrays are element-wise equal within `eps` (absolute difference) Use this for array comparisons. For single scalars, use approx's `assert

Build a 2-D tensor from row-major `data` with shape `(rows, cols)`

Normalize data along the specified axis using the given norm order Divides each element by the norm computed along the chosen axis, so the norm of th

Nanoseconds per call of `f`: the batch size grows until one batch takes >= 5 ms, then the minimum over three batches filters scheduler noise

Overrides the distance metric used for neighbor searches (default: Euclidean) # Parameters - `metric` - Distance metric to use (Euclidean, Manhattan

Fits the model and transforms the data Computes components and returns the projected data in a single step # Parameters - `x` - Feature matrix with

Transforms data into principal component space Projects centered data onto the fitted principal components # Parameters - `x` - Feature matrix with

Sets the SVD solver strategy (default: `SVDSolver::Full`) # Parameters - `svd_solver` - the solver strategy to use # Returns - `Self` - the update

Build a 2-D Tensor from row-major data

Build a 2-D Tensor (shape [rows, cols]) from a flat Vec (row-major)

Resolves a `random_state` into a concrete RNG (see the [module docs](self) for the rules) This is the single entry point for all randomness in the cr

Sets the eigen solver strategy (default: `EigenSolver::Dense`) # Parameters - `eigen_solver` - the solver strategy to use # Returns - `Self` - the

Configures the optimizer and loss function for the model # Parameters - `optimizer` - The optimizer to use for training - `loss` - The loss function

Validates that a weight array assigned to a layer has the shape the layer expects Layers initialize their weight arrays with the correct shape in `ne

Sets the weighting strategy for neighbor votes (default: [`WeightingStrategy::Uniform`]) # Parameters - `weighting_strategy` - uniform or distance-w

Saves the model architecture and weights to a binary file at the specified path Serializes the model structure including layer types, configurations,

Three well-separated classes in 2D (3 samples per class), centred near (1,1), (5,5) and (9,1); ~4 units apart so every solver reaches 100% accuracy

Sets the gradient computation method (default: [`TSNEMethod::BarnesHut`] for `n_components <= 3`, else [`TSNEMethod::Exact`]) # Parameters - `method

Asserts two arrays are element-wise equal within `eps` (absolute difference) For single scalars, use approx's `assert_abs_diff_eq!` / `assert_relativ

Flat tensor filled with the given constant value

A tensor of distinct, well-separated values (gap 0.5 >> eps), so max-pooling argmax positions are unambiguous and never flip under a finite-difference

Sets the embedding initialization strategy (default: [`Init::PCA`]) # Parameters - `init` - initialization strategy ([`Init::PCA`] or [`Init::Random

Returns all the weights from each layer in the model Collects the weights from all layers in the sequential model and returns them as a vector of `La

Sets the solver strategy for the LDA computation (default: `Solver::SVD`) # Parameters - `solver` - the solver to use # Returns - `Self` - the upd

Splits a dataset into training and test sets # Parameters - `x` - Feature matrix with shape (n_samples, n_features) - `y` - Target values with shape

Sets the padding mode (defaults to [`PaddingType::Valid`]) # Parameters - `padding` - Padding type (`Valid` or `Same`) # Returns - `Self` - The up

Sets the pooling strides (defaults to `pool_size`) # Parameters - `strides` - Strides of the pooling operation as (vertical stride, horizontal strid

Build a 1-D Tensor (shape [n]) from a flat Vec

Like [`check_input_gradient`] but with a weighted loss L = sum(W * output), so it is non-degenerate for softmax and zero-mean normalization layers

Computes the decision function values for samples in X # Parameters - `x` - The input samples matrix where each row is a sample # Returns - `Resul

MSE loss for `model.predict(x)` against `y`: mean((pred - y)^2) Matches MeanSquaredError::compute_loss so the comparison is like-for-like

Standardizes data to have zero mean and unit variance Subtracts the mean and divides by the standard deviation per the chosen axis, so the standardiz

Build the canonical 2-blob + 1-noise dataset used throughout these tests Rows 0..=3 are blob A near (0,0), rows 4..=7 are blob B near (10,10), and ro

Sets the convergence tolerance (default: `1e-3`) # Errors - `Error::InvalidParameter` - If `tol` is non-positive or not finite

Validates that input shape matches expected shape

Sets the maximum number of iterations (default: `300`) # Errors - `Error::InvalidParameter` - If `max_iter` is 0

Collinear data: 5 points on y = 2x, rank-1 with first PC along [1/sqrt(5), 2/sqrt(5)] and sigma_1 = sqrt(50) = 5*sqrt(2)

Forward pass for windowed pooling (`MaxPooling{1,2,3}D` / `AveragePooling{1,2,3}D`) `pool` and `strides` are the per-spatial-axis window sizes and st

Enables or disables the bin-seeding initialization strategy (default: `false`) Setting this to `true` can speed up fitting on large datasets

Sets whether to assign every point to a cluster, including potential noise (default: `true`)

Enables L1 or L2 regularization to prevent overfitting (default: no regularization) # Parameters - `regularization` - the regularization variant and

Fits the model to the training data and then predicts labels for the same data A convenience method that runs `fit` followed by `predict` # Paramete

Build 3 tight, well-separated blobs of 5 points each, centred at (0,0), (10,0), (5,10) with per-coordinate offset in [-0.05, +0.05] Inter-blob separa

A tiny linearly-separable binary dataset; feature 0 is 0.x for class 0 and 1.x for class 1, so any default-param tree reaches zero training error

y_true=[0,1,2,2,1], y_pred=[0,2,2,2,1] -> matrix (row=true, col=pred) [[1,0,0],[0,1,1],[0,0,2]]

Performs validation checks on the input data matrices Validates that: - The input data matrix is not empty - The input data does not contain NaN or i

Save `model` to `path`, load into a fresh model built by `make_fresh`, and return it

Collects a `usize` label array into a contiguous `Vec`, tolerating non-contiguous views

Two well-separated unit blobs of 5 points each, near (0,0) and (20,20); with bandwidth=2.0 every intra-blob point sits inside the kernel window

Sets the axis (or axes) along which to normalize Defaults to [`LayerNormalizationAxis::Default`] (the last dimension). Changing the axis re-sizes the

Compares `layer.backward(ones)` against a central finite-difference estimate of d sum(output)/dx

Linearly separable 2-feature dataset in the +1/-1 label domain Class +1 sits in the upper-right quadrant, class -1 in the lower-left, so a large-marg

Helper: build a Tensor from a flat Vec and shape

Build a 2D Tensor from row-major data

Validates a feature matrix passed to a `predict`-style method Performs the three checks every estimator needs before predicting, with a single consis

Compares analytic parameter gradients (from `layer.parameters()` after `backward(ones)`) against a central finite-difference estimate of d sum(output)

Return (x, y) for a perfectly linearly-separable 2-feature problem split by the boundary x1=0 (class 0 at negative x1, class 1 at positive x1)

Estimates a bandwidth to use with the MeanShift algorithm The bandwidth is estimated from the pairwise distances between a subset of points # Parame

Exposes the 3 fused trainable tensors (kernel, recurrent kernel, bias) and their gradients as flat [`ParamGrad`] slices for the optimizer to update R

Sets the fused weights for this GRU layer # Parameters - `kernel` - Fused input kernel with shape (input_dim, 3 * units), gate column blocks in the

Forward pass for global pooling (`GlobalMaxPooling{1,2,3}D` / `GlobalAveragePooling{1,2,3}D`) Reduces every spatial dimension to one value per channe

Helper: build a Tensor from a flat Vec and shape

Sets the shrinkage strategy for covariance estimation (default: no shrinkage) # Parameters - `shrinkage` - the shrinkage strategy # Returns - `Ok(

Sets the pooling stride (defaults to `pool_size`) # Parameters - `stride` - Stride of the pooling operation # Returns - `Result<Self, Error>` - Th

Helper: assert a tensor's elements (logical order) match `expected` within `tol`

Small deterministic dataset for general fitting tests (8 samples x 2 features)

Permutes the `axes` to the trailing positions and merges them into a single axis, returning the transformed contiguous tensor plus the permutation and

Predicts class probabilities for multiple samples (classification only) # Parameters - `x` - Feature matrix as a 2D array # Returns - `Result<Arra

Computes the entropy (in nats) of a partition from its cluster sizes: `H = -sum_i p_i * ln(p_i)`

Fit a default (L2) LinearSVC on the separable dataset with enough iterations that convergence is expected, returning the trained model

Fixed, deterministic (x, y) pair for a tiny 1-input -> 1-output regression Target y = 2*x over 4 samples; with identity weights (w=1, b=0) the initia

Computes the Receiver Operating Characteristic (ROC) curve Returns `(fpr, tpr, thresholds)`: the false-positive rate and true-positive rate at each d

Small valid dataset (6 points, 2 features); perplexity=2.0 < 6 passes the n_samples guard

Build a 2-D Tensor (ArrayD<f32>) from a row-major `data` vec with shape `(rows, cols)`

Zero-mean data with different variance per axis: PCs are the standard basis with sigma_1 = sqrt(32) > sigma_2 = sqrt(8)