deepbox 0.1.0

package/dist/index-D9Loo1_A.d.cts

@@ -0,0 +1,2517 @@
+import { T as Tensor } from './Tensor-BQLk1ltW.cjs';
+
+/**
+ * Base type for all estimators (models) in Deepbox.
+ *
+ * This follows the scikit-learn estimator type design.
+ *
+ * @template FitParams - Type of parameters passed to fit method
+ *
+ * References:
+ * - scikit-learn API: https://scikit-learn.org/stable/developers/develop.html
+ */
+type Estimator<FitParams = void> = {
+    /**
+     * Fit the model to training data.
+     *
+     * @param X - Training features of shape (n_samples, n_features)
+     * @param y - Training targets (optional for unsupervised learning)
+     * @param params - Additional fitting parameters
+     * @returns The fitted estimator (for method chaining)
+     */
+    fit(X: Tensor, y?: Tensor, params?: FitParams): Estimator<FitParams>;
+    /**
+     * Get parameters for this estimator.
+     *
+     * @returns Object containing all parameters
+     */
+    getParams(): Record<string, unknown>;
+    /**
+     * Set parameters for this estimator.
+     *
+     * @param params - Parameters to set
+     * @returns The estimator (for method chaining)
+     */
+    setParams(params: Record<string, unknown>): Estimator<FitParams>;
+};
+/**
+ * Type for classification models.
+ *
+ * Classifiers predict discrete class labels.
+ */
+type Classifier = Estimator & {
+    /**
+     * Fit the model to training data.
+     *
+     * @param X - Training features of shape (n_samples, n_features)
+     * @param y - Training targets
+     * @returns The fitted estimator
+     */
+    fit(X: Tensor, y: Tensor): Classifier;
+    /**
+     * Predict class labels for samples in X.
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Predicted class labels of shape (n_samples,)
+     */
+    predict(X: Tensor): Tensor;
+    /**
+     * Predict class probabilities for samples in X.
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Class probabilities of shape (n_samples, n_classes)
+     */
+    predictProba(X: Tensor): Tensor;
+    /**
+     * Compute the mean accuracy on the given test data and labels.
+     *
+     * @param X - Test samples
+     * @param y - True labels
+     * @returns Mean accuracy score
+     */
+    score(X: Tensor, y: Tensor): number;
+    /** Array of unique class labels seen during fit */
+    readonly classes?: Tensor | undefined;
+};
+/**
+ * Type for regression models.
+ *
+ * Regressors predict continuous values.
+ */
+type Regressor = Estimator & {
+    /**
+     * Fit the model to training data.
+     *
+     * @param X - Training features of shape (n_samples, n_features)
+     * @param y - Training targets
+     * @returns The fitted estimator
+     */
+    fit(X: Tensor, y: Tensor): Regressor;
+    /**
+     * Predict target values for samples in X.
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Predicted values of shape (n_samples,) or (n_samples, n_targets)
+     */
+    predict(X: Tensor): Tensor;
+    /**
+     * Compute the coefficient of determination R^2 of the prediction.
+     *
+     * @param X - Test samples
+     * @param y - True target values
+     * @returns R^2 score
+     */
+    score(X: Tensor, y: Tensor): number;
+};
+/**
+ * Type for clustering models.
+ *
+ * Clusterers group similar samples together.
+ */
+type Clusterer = Estimator<void> & {
+    /**
+     * Fit the model to training data.
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @param y - Ignored (exists for compatibility)
+     * @returns The fitted estimator
+     */
+    fit(X: Tensor, y?: Tensor): Clusterer;
+    /**
+     * Predict cluster labels for samples in X.
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Cluster labels of shape (n_samples,)
+     */
+    predict(X: Tensor): Tensor;
+    /**
+     * Fit the model and predict cluster labels.
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @param y - Ignored (exists for compatibility)
+     * @returns Cluster labels of shape (n_samples,)
+     */
+    fitPredict(X: Tensor, y?: Tensor): Tensor;
+    /** Cluster centers after fitting */
+    readonly clusterCenters?: Tensor;
+    /** Labels of each point after fitting */
+    readonly labels?: Tensor;
+};
+/**
+ * Type for transformer models.
+ *
+ * Transformers modify or transform the input data.
+ */
+type Transformer = Estimator<void> & {
+    /**
+     * Fit the model to training data.
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @param y - Ignored (exists for compatibility)
+     * @returns The fitted estimator
+     */
+    fit(X: Tensor, y?: Tensor): Transformer;
+    /**
+     * Transform the input data.
+     *
+     * @param X - Data to transform
+     * @returns Transformed data
+     */
+    transform(X: Tensor): Tensor;
+    /**
+     * Fit to data, then transform it.
+     *
+     * @param X - Training data
+     * @param y - Target values (optional)
+     * @returns Transformed data
+     */
+    fitTransform(X: Tensor, y?: Tensor): Tensor;
+    /**
+     * Inverse transform the data back to original representation.
+     *
+     * @param X - Transformed data
+     * @returns Original representation
+     */
+    inverseTransform?(X: Tensor): Tensor;
+};
+/**
+ * Type for outlier/anomaly detection models.
+ */
+type OutlierDetector = Estimator<void> & {
+    /**
+     * Fit the model to training data.
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @param y - Ignored (exists for compatibility)
+     * @returns The fitted estimator
+     */
+    fit(X: Tensor, y?: Tensor): OutlierDetector;
+    /**
+     * Predict if samples are outliers or inliers.
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Labels: +1 for inliers, -1 for outliers
+     */
+    predict(X: Tensor): Tensor;
+    /**
+     * Fit the model and predict outliers.
+     *
+     * @param X - Training data
+     * @param y - Ignored
+     * @returns Labels: +1 for inliers, -1 for outliers
+     */
+    fitPredict(X: Tensor, y?: Tensor): Tensor;
+    /**
+     * Compute anomaly scores for samples.
+     *
+     * @param X - Samples to score
+     * @returns Anomaly scores (lower = more abnormal)
+     */
+    scoreSamples(X: Tensor): Tensor;
+};
+
+/**
+ * DBSCAN (Density-Based Spatial Clustering of Applications with Noise).
+ *
+ * Clusters points based on density. Points in high-density regions are
+ * grouped together, while points in low-density regions are marked as noise.
+ *
+ * **Algorithm**:
+ * 1. For each point, find all neighbors within eps distance
+ * 2. If a point has at least minSamples neighbors, it's a core point
+ * 3. Core points and their neighbors form clusters
+ * 4. Points not reachable from any core point are noise (label = -1)
+ *
+ * **Advantages**:
+ * - No need to specify number of clusters
+ * - Can find arbitrarily shaped clusters
+ * - Robust to outliers
+ *
+ * @example
+ * ```ts
+ * import { DBSCAN } from 'deepbox/ml';
+ * import { tensor } from 'deepbox/ndarray';
+ *
+ * const X = tensor([[1, 2], [2, 2], [2, 3], [8, 7], [8, 8], [25, 80]]);
+ * const dbscan = new DBSCAN({ eps: 3, minSamples: 2 });
+ * const labels = dbscan.fitPredict(X);
+ * // labels: [0, 0, 0, 1, 1, -1]  (-1 = noise)
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.cluster.DBSCAN.html | scikit-learn DBSCAN}
+ */
+declare class DBSCAN implements Clusterer {
+    private eps;
+    private minSamples;
+    private metric;
+    private labels_?;
+    private coreIndices_?;
+    private fitted;
+    constructor(options?: {
+        readonly eps?: number;
+        readonly minSamples?: number;
+        readonly metric?: "euclidean" | "manhattan";
+    });
+    /**
+     * Check if two points are neighbors (distance <= eps).
+     */
+    private isNeighbor;
+    /**
+     * Find all neighbors within eps distance.
+     */
+    private getNeighbors;
+    /**
+     * Perform DBSCAN clustering on data X.
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @param _y - Ignored (exists for API compatibility)
+     * @returns this - The fitted estimator
+     * @throws {ShapeError} If X is not 2D
+     * @throws {DataValidationError} If X contains NaN/Inf values
+     */
+    fit(X: Tensor, _y?: Tensor): this;
+    /**
+     * Predict cluster labels for samples in X.
+     *
+     * @param _X - Samples (unused)
+     * @throws {NotImplementedError} Always — DBSCAN is transductive and does not support prediction on new data
+     */
+    predict(_X: Tensor): Tensor;
+    /**
+     * Fit DBSCAN and return cluster labels.
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @param _y - Ignored (exists for API compatibility)
+     * @returns Cluster labels of shape (n_samples,). Noise points are labeled -1.
+     * @throws {ShapeError} If X is not 2D
+     * @throws {DataValidationError} If X contains NaN/Inf values
+     * @throws {NotFittedError} If fit did not produce labels (internal error)
+     */
+    fitPredict(X: Tensor, _y?: Tensor): Tensor;
+    /**
+     * Get cluster labels assigned during fitting.
+     *
+     * @returns Tensor of cluster labels. Noise points are labeled -1.
+     * @throws {NotFittedError} If the model has not been fitted
+     */
+    get labels(): Tensor;
+    /**
+     * Get indices of core samples discovered during fitting.
+     *
+     * Core samples are points with at least `minSamples` neighbors within `eps`.
+     *
+     * @returns Array of core sample indices
+     * @throws {NotFittedError} If the model has not been fitted
+     */
+    get coreIndices(): number[];
+    /**
+     * Get hyperparameters for this estimator.
+     *
+     * @returns Object containing all hyperparameters
+     */
+    getParams(): Record<string, unknown>;
+    /**
+     * Set the parameters of this estimator.
+     *
+     * @param params - Parameters to set (eps, minSamples, metric)
+     * @returns this
+     * @throws {InvalidParameterError} If any parameter value is invalid
+     */
+    setParams(params: Record<string, unknown>): this;
+}
+
+/**
+ * K-Means clustering algorithm.
+ *
+ * Partitions n samples into k clusters by minimizing the within-cluster
+ * sum of squared distances to cluster centroids.
+ *
+ * **Algorithm**: Lloyd's algorithm (iterative refinement)
+ * 1. Initialize k centroids (random or k-means++)
+ * 2. Assign each point to nearest centroid
+ * 3. Update centroids as mean of assigned points
+ * 4. Repeat until convergence or max iterations
+ *
+ * **Time Complexity**: O(n * k * i * d) where:
+ * - n = number of samples
+ * - k = number of clusters
+ * - i = number of iterations
+ * - d = number of features
+ *
+ * @example
+ * ```ts
+ * import { KMeans } from 'deepbox/ml';
+ * import { tensor } from 'deepbox/ndarray';
+ *
+ * const X = tensor([[1, 2], [1.5, 1.8], [5, 8], [8, 8], [1, 0.6], [9, 11]]);
+ * const kmeans = new KMeans({ nClusters: 2, randomState: 42 });
+ * kmeans.fit(X);
+ *
+ * const labels = kmeans.predict(X);
+ * console.log('Cluster labels:', labels);
+ * console.log('Centroids:', kmeans.clusterCenters);
+ * ```
+ *
+ * @see {@link https://en.wikipedia.org/wiki/K-means_clustering | Wikipedia: K-means}
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html | scikit-learn KMeans}
+ */
+declare class KMeans implements Clusterer {
+    private nClusters;
+    private maxIter;
+    private tol;
+    private init;
+    private randomState;
+    private clusterCenters_?;
+    private labels_?;
+    private inertia_?;
+    private nIter_?;
+    private nFeaturesIn_?;
+    private fitted;
+    /**
+     * Create a new K-Means clustering model.
+     *
+     * @param options - Configuration options
+     * @param options.nClusters - Number of clusters (default: 8)
+     * @param options.maxIter - Maximum number of iterations (default: 300)
+     * @param options.tol - Tolerance for convergence (default: 1e-4)
+     * @param options.init - Initialization method: 'random' or 'kmeans++' (default: 'kmeans++')
+     * @param options.randomState - Random seed for reproducibility
+     */
+    constructor(options?: {
+        readonly nClusters?: number;
+        readonly maxIter?: number;
+        readonly tol?: number;
+        readonly init?: "random" | "kmeans++";
+        readonly randomState?: number;
+    });
+    /**
+     * Fit K-Means clustering on training data.
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @param y - Ignored (exists for compatibility)
+     * @returns this - The fitted estimator
+     */
+    fit(X: Tensor, _y?: Tensor): this;
+    /**
+     * Predict cluster labels for samples.
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Cluster labels of shape (n_samples,)
+     */
+    predict(X: Tensor): Tensor;
+    /**
+     * Fit and predict in one step.
+     *
+     * @param X - Training data
+     * @param y - Ignored (exists for compatibility)
+     * @returns Cluster labels
+     */
+    fitPredict(X: Tensor, _y?: Tensor): Tensor;
+    /**
+     * Initialize centroids using specified method.
+     */
+    private initializeCentroids;
+    /**
+     * Assign each sample to nearest centroid.
+     */
+    private assignClusters;
+    /**
+     * Calculate inertia (sum of squared distances to centroids).
+     */
+    private calculateInertia;
+    /**
+     * Create a simple RNG for reproducibility.
+     */
+    private createRNG;
+    /**
+     * Get cluster centers.
+     */
+    get clusterCenters(): Tensor;
+    /**
+     * Get training labels.
+     */
+    get labels(): Tensor;
+    /**
+     * Get inertia (sum of squared distances to centroids).
+     */
+    get inertia(): number;
+    /**
+     * Get number of iterations run.
+     */
+    get nIter(): number;
+    /**
+     * Get hyperparameters for this estimator.
+     *
+     * @returns Object containing all hyperparameters
+     */
+    getParams(): Record<string, unknown>;
+    /**
+     * Set the parameters of this estimator.
+     *
+     * @param params - Parameters to set (nClusters, maxIter, tol, init, randomState)
+     * @returns this
+     * @throws {InvalidParameterError} If any parameter value is invalid
+     */
+    setParams(params: Record<string, unknown>): this;
+}
+
+/**
+ * Principal Component Analysis (PCA).
+ *
+ * Linear dimensionality reduction using Singular Value Decomposition (SVD)
+ * to project data to a lower dimensional space.
+ *
+ * **Algorithm**:
+ * 1. Center the data by subtracting the mean
+ * 2. Compute SVD: X = U * Σ * V^T
+ * 3. Principal components are columns of V
+ * 4. Transform data by projecting onto principal components
+ *
+ * **Time Complexity**: O(min(n*d^2, d*n^2)) where n=samples, d=features
+ *
+ * @example
+ * ```ts
+ * import { PCA } from 'deepbox/ml';
+ * import { tensor } from 'deepbox/ndarray';
+ *
+ * const X = tensor([[2.5, 2.4], [0.5, 0.7], [2.2, 2.9], [1.9, 2.2], [3.1, 3.0]]);
+ * const pca = new PCA({ nComponents: 1 });
+ * pca.fit(X);
+ *
+ * const XTransformed = pca.transform(X);
+ * console.log('Explained variance ratio:', pca.explainedVarianceRatio);
+ * ```
+ *
+ * @see {@link https://en.wikipedia.org/wiki/Principal_component_analysis | Wikipedia: PCA}
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html | scikit-learn PCA}
+ */
+declare class PCA implements Transformer {
+    private readonly nComponents?;
+    private readonly whiten;
+    private components_?;
+    private explainedVariance_?;
+    private explainedVarianceRatio_?;
+    private mean_?;
+    private nComponentsActual_?;
+    private nFeaturesIn_?;
+    private fitted;
+    /**
+     * Create a new PCA model.
+     *
+     * @param options - Configuration options
+     * @param options.nComponents - Number of components to keep (default: min(n_samples, n_features))
+     * @param options.whiten - Whether to whiten the data (default: false)
+     */
+    constructor(options?: {
+        readonly nComponents?: number;
+        readonly whiten?: boolean;
+    });
+    /**
+     * Fit PCA on training data.
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @param y - Ignored (exists for compatibility)
+     * @returns this
+     */
+    fit(X: Tensor, _y?: Tensor): this;
+    /**
+     * Transform data to principal component space.
+     *
+     * @param X - Data of shape (n_samples, n_features)
+     * @returns Transformed data of shape (n_samples, n_components)
+     */
+    transform(X: Tensor): Tensor;
+    /**
+     * Fit and transform in one step.
+     *
+     * @param X - Training data
+     * @param y - Ignored (exists for compatibility)
+     * @returns Transformed data
+     */
+    fitTransform(X: Tensor, _y?: Tensor): Tensor;
+    /**
+     * Transform data back to original space.
+     *
+     * @param X - Transformed data of shape (n_samples, n_components)
+     * @returns Reconstructed data of shape (n_samples, n_features)
+     */
+    inverseTransform(X: Tensor): Tensor;
+    /**
+     * Center data by subtracting mean.
+     */
+    private centerData;
+    /**
+     * Get principal components.
+     */
+    get components(): Tensor;
+    /**
+     * Get explained variance.
+     */
+    get explainedVariance(): Tensor;
+    /**
+     * Get explained variance ratio.
+     */
+    get explainedVarianceRatio(): Tensor;
+    /**
+     * Get hyperparameters for this estimator.
+     *
+     * @returns Object containing all hyperparameters
+     */
+    getParams(): Record<string, unknown>;
+    /**
+     * Set the parameters of this estimator.
+     *
+     * @param _params - Parameters to set
+     * @throws {NotImplementedError} Always — parameters cannot be changed after construction
+     */
+    setParams(_params: Record<string, unknown>): this;
+}
+
+/**
+ * Gradient Boosting Regressor.
+ *
+ * Builds an additive model in a forward stage-wise fashion using
+ * regression trees as weak learners. Optimizes squared error loss.
+ *
+ * **Algorithm**: Gradient Boosting with regression trees
+ * - Stage-wise additive modeling
+ * - Uses gradient of squared loss (residuals)
+ *
+ * @example
+ * ```ts
+ * import { GradientBoostingRegressor } from 'deepbox/ml';
+ * import { tensor } from 'deepbox/ndarray';
+ *
+ * const X = tensor([[1], [2], [3], [4], [5]]);
+ * const y = tensor([1.2, 2.1, 2.9, 4.0, 5.1]);
+ *
+ * const gbr = new GradientBoostingRegressor({ nEstimators: 100 });
+ * gbr.fit(X, y);
+ * const predictions = gbr.predict(X);
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingRegressor.html | scikit-learn GradientBoostingRegressor}
+ */
+declare class GradientBoostingRegressor implements Regressor {
+    /** Number of boosting stages (trees) */
+    private nEstimators;
+    /** Learning rate shrinks the contribution of each tree */
+    private learningRate;
+    /** Maximum depth of individual regression trees */
+    private maxDepth;
+    /** Minimum samples required to split */
+    private minSamplesSplit;
+    /** Array of weak learners (regression trees) */
+    private estimators;
+    /** Initial prediction (mean of targets) */
+    private initPrediction;
+    /** Number of features */
+    private nFeatures;
+    /** Whether the model has been fitted */
+    private fitted;
+    constructor(options?: {
+        readonly nEstimators?: number;
+        readonly learningRate?: number;
+        readonly maxDepth?: number;
+        readonly minSamplesSplit?: number;
+    });
+    /**
+     * Fit the gradient boosting regressor on training data.
+     *
+     * Builds an additive model by sequentially fitting regression trees
+     * to the negative gradient (residuals) of the loss function.
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @param y - Target values of shape (n_samples,)
+     * @returns this - The fitted estimator
+     * @throws {ShapeError} If X is not 2D or y is not 1D
+     * @throws {ShapeError} If X and y have different number of samples
+     * @throws {DataValidationError} If X or y contain NaN/Inf values
+     */
+    fit(X: Tensor, y: Tensor): this;
+    /**
+     * Predict target values for samples in X.
+     *
+     * Aggregates the initial prediction and the scaled contributions of all trees.
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Predicted values of shape (n_samples,)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If X has wrong dimensions or feature count
+     * @throws {DataValidationError} If X contains NaN/Inf values
+     */
+    predict(X: Tensor): Tensor;
+    /**
+     * Return the R² score on the given test data and target values.
+     *
+     * @param X - Test samples of shape (n_samples, n_features)
+     * @param y - True target values of shape (n_samples,)
+     * @returns R² score (best possible is 1.0, can be negative)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If y is not 1-dimensional or sample counts mismatch
+     * @throws {DataValidationError} If y contains NaN/Inf values
+     */
+    score(X: Tensor, y: Tensor): number;
+    /**
+     * Get hyperparameters for this estimator.
+     *
+     * @returns Object containing all hyperparameters
+     */
+    getParams(): Record<string, unknown>;
+    /**
+     * Set the parameters of this estimator.
+     *
+     * @param _params - Parameters to set
+     * @throws {NotImplementedError} Always — parameters cannot be changed after construction
+     */
+    setParams(_params: Record<string, unknown>): this;
+}
+/**
+ * Gradient Boosting Classifier.
+ *
+ * Uses gradient boosting with shallow regression trees for binary classification.
+ * Optimizes log loss (cross-entropy) using sigmoid function.
+ *
+ * @example
+ * ```ts
+ * import { GradientBoostingClassifier } from 'deepbox/ml';
+ * import { tensor } from 'deepbox/ndarray';
+ *
+ * const X = tensor([[1, 2], [2, 3], [3, 1], [4, 2]]);
+ * const y = tensor([0, 0, 1, 1]);
+ *
+ * const gbc = new GradientBoostingClassifier({ nEstimators: 100 });
+ * gbc.fit(X, y);
+ * const predictions = gbc.predict(X);
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingClassifier.html | scikit-learn GradientBoostingClassifier}
+ */
+declare class GradientBoostingClassifier implements Classifier {
+    /** Number of boosting stages */
+    private nEstimators;
+    /** Learning rate */
+    private learningRate;
+    /** Maximum depth */
+    private maxDepth;
+    /** Minimum samples to split */
+    private minSamplesSplit;
+    /** Array of weak learners */
+    private estimators;
+    /** Initial log-odds prediction */
+    private initPrediction;
+    /** Number of features */
+    private nFeatures;
+    /** Unique class labels */
+    private classLabels;
+    /** Whether fitted */
+    private fitted;
+    constructor(options?: {
+        readonly nEstimators?: number;
+        readonly learningRate?: number;
+        readonly maxDepth?: number;
+        readonly minSamplesSplit?: number;
+    });
+    /**
+     * Fit the gradient boosting classifier on training data.
+     *
+     * Builds an additive model by sequentially fitting regression trees
+     * to the pseudo-residuals (gradient of log loss).
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @param y - Target class labels of shape (n_samples,). Must contain exactly 2 classes.
+     * @returns this - The fitted estimator
+     * @throws {ShapeError} If X is not 2D or y is not 1D
+     * @throws {ShapeError} If X and y have different number of samples
+     * @throws {DataValidationError} If X or y contain NaN/Inf values
+     * @throws {InvalidParameterError} If y does not contain exactly 2 classes
+     */
+    fit(X: Tensor, y: Tensor): this;
+    /**
+     * Predict class labels for samples in X.
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Predicted class labels of shape (n_samples,)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If X has wrong dimensions or feature count
+     * @throws {DataValidationError} If X contains NaN/Inf values
+     */
+    predict(X: Tensor): Tensor;
+    /**
+     * Predict class probabilities for samples in X.
+     *
+     * Returns a matrix of shape (n_samples, 2) where columns are
+     * [P(class_0), P(class_1)].
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Class probability matrix of shape (n_samples, 2)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If X has wrong dimensions or feature count
+     * @throws {DataValidationError} If X contains NaN/Inf values
+     */
+    predictProba(X: Tensor): Tensor;
+    /**
+     * Return the mean accuracy on the given test data and labels.
+     *
+     * @param X - Test samples of shape (n_samples, n_features)
+     * @param y - True labels of shape (n_samples,)
+     * @returns Accuracy score in range [0, 1]
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If y is not 1-dimensional or sample counts mismatch
+     * @throws {DataValidationError} If y contains NaN/Inf values
+     */
+    score(X: Tensor, y: Tensor): number;
+    /**
+     * Get hyperparameters for this estimator.
+     *
+     * @returns Object containing all hyperparameters
+     */
+    getParams(): Record<string, unknown>;
+    /**
+     * Set the parameters of this estimator.
+     *
+     * @param _params - Parameters to set
+     * @throws {NotImplementedError} Always — parameters cannot be changed after construction
+     */
+    setParams(_params: Record<string, unknown>): this;
+}
+
+/**
+ * Lasso Regression (L1 Regularized Linear Regression).
+ *
+ * Lasso performs both regularization and feature selection by adding
+ * an L1 penalty that can drive coefficients exactly to zero.
+ *
+ * @example
+ * ```ts
+ * import { Lasso } from 'deepbox/ml';
+ *
+ * const model = new Lasso({ alpha: 0.1, maxIter: 1000 });
+ * model.fit(X_train, y_train);
+ *
+ * // Many coefficients will be exactly 0
+ * console.log(model.coef);
+ *
+ * const predictions = model.predict(X_test);
+ * ```
+ *
+ * @category Linear Models
+ * @implements {Regressor}
+ */
+declare class Lasso implements Regressor {
+    /** Configuration options for the Lasso regression model */
+    private options;
+    /** Model coefficients (weights) after fitting - shape (n_features,) */
+    private coef_?;
+    /** Intercept (bias) term after fitting */
+    private intercept_;
+    /** Number of features seen during fit - used for validation */
+    private nFeaturesIn_?;
+    /** Number of iterations run by coordinate descent */
+    private nIter_;
+    /** Whether the model has been fitted to data */
+    private fitted;
+    /**
+     * Create a new Lasso Regression model.
+     *
+     * @param options - Configuration options
+     * @param options.alpha - Regularization strength (default: 1.0). Must be >= 0. Controls sparsity of solution.
+     * @param options.fitIntercept - Whether to calculate the intercept (default: true)
+     * @param options.normalize - Whether to normalize features before regression (default: false)
+     * @param options.maxIter - Maximum iterations for coordinate descent (default: 1000)
+     * @param options.tol - Tolerance for convergence (default: 1e-4). Smaller = more precise but slower.
+     * @param options.warmStart - Whether to reuse previous solution as initialization (default: false)
+     * @param options.positive - Whether to force coefficients to be positive (default: false)
+     * @param options.selection - Coordinate selection: 'cyclic' (default) or 'random'
+     */
+    constructor(options?: {
+        readonly alpha?: number;
+        readonly fitIntercept?: boolean;
+        readonly normalize?: boolean;
+        readonly maxIter?: number;
+        readonly tol?: number;
+        readonly warmStart?: boolean;
+        readonly positive?: boolean;
+        readonly selection?: "cyclic" | "random";
+        readonly randomState?: number;
+    });
+    private createRNG;
+    /**
+     * Fit Lasso regression model using Coordinate Descent.
+     *
+     * Solves the L1-regularized least squares problem:
+     * minimize (1/(2*n)) ||y - Xw||² + α||w||₁
+     *
+     * **Algorithm**: Coordinate Descent with Soft Thresholding
+     * 1. Initialize coefficients (warm start if enabled)
+     * 2. For each iteration:
+     *    - For each feature (cyclic or random order):
+     *      - Compute residual correlation
+     *      - Apply soft thresholding operator
+     *      - Update predictions incrementally
+     * 3. Check convergence based on coefficient changes
+     *
+     * **Time Complexity**: O(k * n * p) where k = iterations, n = samples, p = features
+     * **Space Complexity**: O(n + p)
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @param y - Target values of shape (n_samples,)
+     * @returns this - The fitted estimator for method chaining
+     * @throws {ShapeError} If X is not 2D or y is not 1D
+     * @throws {ShapeError} If X and y have different number of samples
+     * @throws {DataValidationError} If X or y contain NaN/Inf values
+     * @throws {DataValidationError} If X or y are empty
+     * @throws {InvalidParameterError} If alpha < 0
+     */
+    fit(X: Tensor, y: Tensor): this;
+    /**
+     * Soft thresholding operator (proximal operator for L1 norm).
+     *
+     * This is the key operation in Lasso that induces sparsity.
+     *
+     * Formula:
+     * - If x > λ: return x - λ
+     * - If x < -λ: return x + λ
+     * - Otherwise: return 0
+     *
+     * Geometrically, this "shrinks" x towards zero by λ,
+     * and sets it exactly to zero if |x| ≤ λ.
+     *
+     * **Time Complexity**: O(1)
+     *
+     * @param x - Input value
+     * @param lambda - Threshold parameter (regularization strength)
+     * @returns Soft-thresholded value
+     */
+    private softThreshold;
+    /**
+     * Get the model coefficients (weights).
+     *
+     * Many coefficients will be exactly zero due to L1 regularization (sparsity).
+     *
+     * @returns Coefficient tensor of shape (n_features,)
+     * @throws {NotFittedError} If the model has not been fitted
+     */
+    get coef(): Tensor;
+    /**
+     * Get the intercept (bias term).
+     *
+     * @returns Intercept value
+     * @throws {NotFittedError} If the model has not been fitted
+     */
+    get intercept(): number;
+    /**
+     * Get the number of iterations run by coordinate descent.
+     *
+     * @returns Number of iterations until convergence
+     * @throws {NotFittedError} If the model has not been fitted
+     */
+    get nIter(): number | undefined;
+    /**
+     * Predict using the Lasso regression model.
+     *
+     * Computes predictions as: ŷ = X @ coef + intercept
+     *
+     * **Time Complexity**: O(nm) where n = samples, m = features
+     * **Space Complexity**: O(n)
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Predicted values of shape (n_samples,)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If X has wrong dimensions or feature count
+     * @throws {DataValidationError} If X contains NaN/Inf values
+     */
+    predict(X: Tensor): Tensor;
+    /**
+     * Return the R² score on the given test data and target values.
+     *
+     * @param X - Test samples of shape (n_samples, n_features)
+     * @param y - True target values of shape (n_samples,)
+     * @returns R² score (best possible is 1.0, can be negative)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If y is not 1-dimensional or sample counts mismatch
+     * @throws {DataValidationError} If y contains NaN/Inf values
+     */
+    score(X: Tensor, y: Tensor): number;
+    /**
+     * Get hyperparameters for this estimator.
+     *
+     * @returns Object containing all hyperparameters
+     */
+    getParams(): Record<string, unknown>;
+    /**
+     * Set the parameters of this estimator.
+     *
+     * @param params - Parameters to set (alpha, maxIter, tol, fitIntercept, normalize)
+     * @returns this
+     * @throws {InvalidParameterError} If any parameter value is invalid
+     */
+    setParams(params: Record<string, unknown>): this;
+}
+
+/**
+ * Ordinary Least Squares Linear Regression.
+ *
+ * Fits a linear model with coefficients w = (w1, ..., wp) to minimize
+ * the residual sum of squares between the observed targets and the
+ * targets predicted by the linear approximation.
+ *
+ * @example
+ * ```ts
+ * import { LinearRegression } from 'deepbox/ml';
+ * import { tensor } from 'deepbox/ndarray';
+ *
+ * // Create training data
+ * const X = tensor([[1, 1], [1, 2], [2, 2], [2, 3]]);
+ * const y = tensor([1, 2, 2, 3]);
+ *
+ * // Fit model
+ * const model = new LinearRegression({ fitIntercept: true });
+ * model.fit(X, y);
+ *
+ * // Make predictions
+ * const X_test = tensor([[3, 5]]);
+ * const predictions = model.predict(X_test);
+ *
+ * // Get R^2 score
+ * const score = model.score(X, y);
+ * ```
+ */
+declare class LinearRegression implements Regressor {
+    /** Model coefficients (weights) of shape (n_features,) or (n_features, n_targets) */
+    private coef_?;
+    /** Independent term (bias/intercept) in the linear model */
+    private intercept_?;
+    /** Number of features seen during fit */
+    private nFeaturesIn_?;
+    /** Whether the model has been fitted */
+    private fitted;
+    private options;
+    /**
+     * Create a new Linear Regression model.
+     *
+     * @param options - Configuration options
+     * @param options.fitIntercept - Whether to calculate the intercept (default: true)
+     * @param options.normalize - Whether to normalize features before regression (default: false)
+     * @param options.copyX - Whether to copy X or overwrite it (default: true)
+     */
+    constructor(options?: {
+        readonly fitIntercept?: boolean;
+        readonly normalize?: boolean;
+        readonly copyX?: boolean;
+    });
+    /**
+     * Fit linear model using Ordinary Least Squares.
+     *
+     * Uses SVD-based least squares solver for numerical stability.
+     * When fitIntercept is true, centers the data before fitting.
+     *
+     * **Algorithm Complexity**: O(n * p^2) where n = samples, p = features
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @param y - Target values of shape (n_samples,). Multi-output regression is not currently supported.
+     * @returns this - The fitted estimator
+     * @throws {ShapeError} If X is not 2D or y is not 1D
+     * @throws {ShapeError} If X and y have different number of samples
+     * @throws {DataValidationError} If X or y contain NaN/Inf values
+     * @throws {DataValidationError} If X or y are empty
+     */
+    fit(X: Tensor, y: Tensor): this;
+    /**
+     * Center data by subtracting the mean.
+     *
+     * @param data - Input tensor to center
+     * @param dataMean - Mean tensor to subtract
+     * @returns Centered tensor
+     */
+    private centerData;
+    private centerDataInPlace;
+    private computeL2Norm;
+    private scaleData;
+    private scaleDataInPlace;
+    private rescaleCoefs;
+    /**
+     * Predict using the linear model.
+     *
+     * Computes y_pred = X * coef_ + intercept_
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Predicted values of shape (n_samples,)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If X has wrong dimensions or feature count
+     * @throws {DataValidationError} If X contains NaN/Inf values
+     */
+    predict(X: Tensor): Tensor;
+    /**
+     * Return the coefficient of determination R^2 of the prediction.
+     *
+     * R^2 = 1 - (SS_res / SS_tot)
+     *
+     * Where:
+     * - SS_res = Σ(y_true - y_pred)^2 (residual sum of squares)
+     * - SS_tot = Σ(y_true - y_mean)^2 (total sum of squares)
+     *
+     * Best possible score is 1.0, and it can be negative (worse than random).
+     *
+     * @param X - Test samples of shape (n_samples, n_features)
+     * @param y - True target values of shape (n_samples,)
+     * @returns R² score (best possible is 1.0, can be negative)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If y is not 1-dimensional or sample counts mismatch
+     * @throws {DataValidationError} If y contains NaN/Inf values
+     */
+    score(X: Tensor, y: Tensor): number;
+    /**
+     * Get the model coefficients (weights).
+     *
+     * @returns Coefficient tensor of shape (n_features,) or (n_features, n_targets)
+     * @throws {NotFittedError} If the model has not been fitted
+     */
+    get coef(): Tensor;
+    /**
+     * Get the intercept (bias term).
+     *
+     * @returns Intercept value or tensor
+     * @throws {NotFittedError} If the model has not been fitted
+     */
+    get intercept(): Tensor | undefined;
+    /**
+     * Get parameters for this estimator.
+     *
+     * @returns Object containing all parameters
+     */
+    getParams(): Record<string, unknown>;
+    /**
+     * Set the parameters of this estimator.
+     *
+     * @param params - Parameters to set
+     * @returns this - The estimator
+     */
+    setParams(_params: Record<string, unknown>): this;
+}
+
+/**
+ * Logistic Regression (Binary and Multiclass Classification).
+ *
+ * Logistic regression uses the logistic (sigmoid) function to model
+ * the probability of class membership.
+ *
+ * @example
+ * ```ts
+ * import { LogisticRegression } from 'deepbox/ml';
+ *
+ * // Binary classification
+ * const model = new LogisticRegression({ C: 1.0, maxIter: 100 });
+ * model.fit(X_train, y_train);
+ *
+ * const predictions = model.predict(X_test);
+ * const probabilities = model.predictProba(X_test);
+ *
+ * // Multiclass classification
+ * const multiModel = new LogisticRegression({
+ *   multiClass: 'multinomial',
+ *   solver: 'lbfgs'
+ * });
+ * multiModel.fit(X_train_multi, y_train_multi);
+ * ```
+ *
+ * @category Linear Models
+ * @implements {Classifier}
+ */
+declare class LogisticRegression implements Classifier {
+    private options;
+    private coef_?;
+    private intercept_?;
+    private nFeaturesIn_?;
+    private classes_?;
+    private fitted;
+    private multiclass_;
+    /**
+     * Create a new Logistic Regression classifier.
+     *
+     * @param options - Configuration options
+     * @param options.penalty - Regularization type: 'l2' or 'none' (default: 'l2')
+     * @param options.C - Inverse regularization strength (default: 1.0). Must be > 0.
+     * @param options.tol - Tolerance for stopping criterion (default: 1e-4)
+     * @param options.maxIter - Maximum number of iterations (default: 100)
+     * @param options.fitIntercept - Whether to fit intercept (default: true)
+     * @param options.learningRate - Learning rate for gradient descent (default: 0.1)
+     * @param options.multiClass - Multiclass strategy: 'ovr' (One-vs-Rest) or 'auto' (default: 'auto')
+     */
+    constructor(options?: {
+        readonly penalty?: "l2" | "none";
+        readonly tol?: number;
+        readonly C?: number;
+        readonly fitIntercept?: boolean;
+        readonly maxIter?: number;
+        readonly learningRate?: number;
+        readonly multiClass?: "ovr" | "auto";
+    });
+    /**
+     * Numerically stable sigmoid function.
+     *
+     * Uses different formulations for positive and negative inputs
+     * to avoid overflow:
+     * - For z >= 0: σ(z) = 1 / (1 + exp(-z))
+     * - For z < 0: σ(z) = exp(z) / (1 + exp(z))
+     *
+     * @param z - Input value
+     * @returns Sigmoid output in [0, 1]
+     */
+    private sigmoid;
+    private ensureFitted;
+    private _fitBinary;
+    /**
+     * Fit logistic regression model.
+     *
+     * Uses gradient descent with L2 regularization.
+     * Supports binary and multiclass (One-vs-Rest) classification.
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @param y - Target labels of shape (n_samples,)
+     * @returns this - The fitted estimator
+     * @throws {ShapeError} If X is not 2D or y is not 1D
+     * @throws {ShapeError} If X and y have different number of samples
+     * @throws {DataValidationError} If X or y contain NaN/Inf values
+     * @throws {DataValidationError} If X or y are empty
+     * @throws {InvalidParameterError} If C <= 0 or penalty is invalid
+     */
+    fit(X: Tensor, y: Tensor): this;
+    get classes(): Tensor | undefined;
+    /**
+     * Get the model coefficients (weights).
+     *
+     * @returns Coefficient tensor of shape (n_features,)
+     * @throws {NotFittedError} If the model has not been fitted
+     */
+    get coef(): Tensor;
+    /**
+     * Get the intercept (bias term).
+     *
+     * @returns Intercept value (scalar for binary, array for multiclass)
+     * @throws {NotFittedError} If the model has not been fitted
+     */
+    get intercept(): number | number[];
+    predict(X: Tensor): Tensor;
+    /**
+     * Predict class probabilities for samples.
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Probabilities of shape (n_samples, n_classes)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If X has wrong dimensions or feature count
+     * @throws {DataValidationError} If X contains NaN/Inf values
+     */
+    predictProba(X: Tensor): Tensor;
+    /**
+     * Return the mean accuracy on the given test data and labels.
+     *
+     * @param X - Test samples of shape (n_samples, n_features)
+     * @param y - True labels of shape (n_samples,)
+     * @returns Accuracy score in range [0, 1]
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If y is not 1-dimensional or sample counts mismatch
+     * @throws {DataValidationError} If y contains NaN/Inf values
+     */
+    score(X: Tensor, y: Tensor): number;
+    /**
+     * Get hyperparameters for this estimator.
+     *
+     * @returns Object containing all hyperparameters
+     */
+    getParams(): Record<string, unknown>;
+    /**
+     * Set the parameters of this estimator.
+     *
+     * @param params - Parameters to set (maxIter, tol, C, learningRate, penalty, fitIntercept)
+     * @returns this
+     * @throws {InvalidParameterError} If any parameter value is invalid
+     */
+    setParams(params: Record<string, unknown>): this;
+}
+
+/**
+ * Ridge Regression (L2 Regularized Linear Regression).
+ *
+ * Ridge regression addresses multicollinearity by adding a penalty term
+ * (L2 regularization) to the loss function.
+ *
+ * @example
+ * ```ts
+ * import { Ridge } from 'deepbox/ml';
+ *
+ * const model = new Ridge({ alpha: 0.5 });
+ * model.fit(X_train, y_train);
+ * const predictions = model.predict(X_test);
+ * ```
+ *
+ * @category Linear Models
+ * @implements {Regressor}
+ */
+declare class Ridge implements Regressor {
+    /** Configuration options for the Ridge regression model */
+    private options;
+    /** Model coefficients (weights) after fitting - shape (n_features,) */
+    private coef_?;
+    /** Intercept (bias) term after fitting */
+    private intercept_?;
+    /** Number of features seen during fit - used for validation */
+    private nFeaturesIn_?;
+    /** Number of iterations run by the solver (for iterative solvers) */
+    private nIter_;
+    /** Whether the model has been fitted to data */
+    private fitted;
+    /**
+     * Create a new Ridge Regression model.
+     *
+     * @param options - Configuration options
+     * @param options.alpha - Regularization strength (default: 1.0). Must be >= 0.
+     * @param options.fitIntercept - Whether to calculate the intercept (default: true).
+     * @param options.normalize - Whether to normalize features before regression (default: false).
+     * @param options.solver - Solver to use (default: 'auto'). Options: 'auto', 'svd', 'cholesky', 'lsqr', 'sag'.
+     * @param options.maxIter - Maximum number of iterations for iterative solvers (default: 1000)
+     * @param options.tol - Tolerance for stopping criterion (default: 1e-4)
+     */
+    constructor(options?: {
+        readonly alpha?: number;
+        readonly fitIntercept?: boolean;
+        readonly normalize?: boolean;
+        readonly solver?: "auto" | "svd" | "cholesky" | "lsqr" | "sag";
+        readonly maxIter?: number;
+        readonly tol?: number;
+    });
+    /**
+     * Fit Ridge regression model.
+     *
+     * Solves the regularized least squares problem:
+     * minimize ||y - Xw||² + α||w||²
+     *
+     * Uses the closed-form solution:
+     * w = (X^T X + αI)^(-1) X^T y
+     *
+     * **Time Complexity**: O(n²p + p³) where n = samples, p = features
+     * **Space Complexity**: O(p²)
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @param y - Target values of shape (n_samples,)
+     * @returns this - The fitted estimator for method chaining
+     * @throws {ShapeError} If X is not 2D or y is not 1D
+     * @throws {ShapeError} If X and y have different number of samples
+     * @throws {DataValidationError} If X or y contain NaN/Inf values
+     * @throws {DataValidationError} If X or y are empty
+     * @throws {InvalidParameterError} If alpha < 0
+     */
+    fit(X: Tensor, y: Tensor): this;
+    /**
+     * Solve linear system Ax = b using Gaussian elimination with partial pivoting.
+     *
+     * This is a numerically stable method for solving dense linear systems.
+     * For Ridge regression, A = X^T X + αI is symmetric positive definite,
+     * so Cholesky decomposition would be more efficient, but Gaussian elimination
+     * is more general and still provides good numerical stability.
+     *
+     * **Algorithm**:
+     * 1. Forward elimination: Convert A to upper triangular form
+     * 2. Partial pivoting: Swap rows to avoid division by small numbers
+     * 3. Back substitution: Solve for x from bottom to top
+     *
+     * **Time Complexity**: O(n³)
+     * **Space Complexity**: O(n²)
+     *
+     * @param A - Coefficient matrix (n × n)
+     * @param b - Right-hand side vector (n × 1)
+     * @returns Solution vector x such that Ax = b
+     */
+    private solveLinearSystem;
+    private solveConjugateGradient;
+    private solveSag;
+    private rescaleCoefs;
+    /**
+     * Predict using the Ridge regression model.
+     *
+     * Computes predictions as: ŷ = X @ coef + intercept
+     *
+     * **Time Complexity**: O(nm) where n = samples, m = features
+     * **Space Complexity**: O(n)
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Predicted values of shape (n_samples,)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If X has wrong dimensions or feature count
+     * @throws {DataValidationError} If X contains NaN/Inf values
+     */
+    predict(X: Tensor): Tensor;
+    /**
+     * Return the coefficient of determination R² of the prediction.
+     *
+     * R² (R-squared) measures the proportion of variance in y explained by the model.
+     * Formula: R² = 1 - (SS_res / SS_tot)
+     *
+     * Where:
+     * - SS_res = Σ(y_true - y_pred)² (residual sum of squares)
+     * - SS_tot = Σ(y_true - y_mean)² (total sum of squares)
+     *
+     * **Interpretation**:
+     * - R² = 1: Perfect predictions
+     * - R² = 0: Model performs as well as predicting the mean
+     * - R² < 0: Model performs worse than predicting the mean
+     *
+     * **Time Complexity**: O(n) where n = number of samples
+     *
+     * @param X - Test samples of shape (n_samples, n_features)
+     * @param y - True values of shape (n_samples,)
+     * @returns R² score (best possible score is 1.0, can be negative)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If y is not 1-dimensional
+     */
+    score(X: Tensor, y: Tensor): number;
+    /**
+     * Get parameters for this estimator.
+     *
+     * Returns a copy of all hyperparameters set during construction or via setParams.
+     *
+     * @returns Object containing all parameters with their current values
+     */
+    getParams(): Record<string, unknown>;
+    /**
+     * Set the parameters of this estimator.
+     *
+     * Allows modifying hyperparameters after construction.
+     * Note: Changing parameters requires refitting the model.
+     *
+     * @param params - Dictionary of parameters to set
+     * @returns this - The estimator for method chaining
+     * @throws {TypeError} If parameter value has wrong type
+     * @throws {Error} If parameter name is unknown or value is invalid
+     */
+    setParams(params: Record<string, unknown>): this;
+    /**
+     * Get the model coefficients (weights).
+     *
+     * @returns Coefficient tensor of shape (n_features,)
+     * @throws {NotFittedError} If the model has not been fitted
+     */
+    get coef(): Tensor;
+    /**
+     * Get the intercept (bias term).
+     *
+     * @returns Intercept value
+     * @throws {NotFittedError} If the model has not been fitted
+     */
+    get intercept(): number;
+    /**
+     * Get the number of iterations run by the solver.
+     *
+     * @returns Number of iterations (undefined for direct solvers)
+     * @throws {NotFittedError} If the model has not been fitted
+     */
+    get nIter(): number | undefined;
+}
+
+/**
+ * t-Distributed Stochastic Neighbor Embedding (t-SNE).
+ *
+ * A nonlinear dimensionality reduction technique for embedding high-dimensional
+ * data into a low-dimensional space (typically 2D or 3D) for visualization.
+ *
+ * **Algorithm**: Exact t-SNE with an optional sampling-based approximation
+ * - Computes pairwise affinities in high-dimensional space using Gaussian kernel (exact)
+ * - Computes pairwise affinities in low-dimensional space using Student-t distribution
+ * - Minimizes KL divergence between the two distributions
+ *
+ * **Scalability Note**:
+ * Exact t-SNE is O(n^2) in time and memory. For large datasets, use
+ * `method: "approximate"` (sampled neighbors + negative sampling) or reduce samples.
+ *
+ * @example
+ * ```ts
+ * import { TSNE } from 'deepbox/ml';
+ * import { tensor } from 'deepbox/ndarray';
+ *
+ * const X = tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]);
+ *
+ * const tsne = new TSNE({ nComponents: 2, perplexity: 5 });
+ * const embedding = tsne.fitTransform(X);
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.manifold.TSNE.html | scikit-learn TSNE}
+ * @see van der Maaten, L.J.P.; Hinton, G.E. (2008). "Visualizing High-Dimensional Data Using t-SNE"
+ */
+declare class TSNE {
+    /** Number of dimensions in the embedding */
+    private readonly nComponents;
+    /** Perplexity parameter (related to number of nearest neighbors) */
+    private readonly perplexity;
+    /** Learning rate for gradient descent */
+    private readonly learningRate;
+    /** Number of iterations */
+    private readonly nIter;
+    /** Early exaggeration factor */
+    private readonly earlyExaggeration;
+    /** Number of iterations with early exaggeration */
+    private readonly earlyExaggerationIter;
+    /** Random seed for reproducibility */
+    private readonly randomState;
+    /** Minimum gradient norm for convergence */
+    private readonly minGradNorm;
+    /** Method for computing affinities and gradients */
+    private readonly method;
+    /** Maximum samples allowed for exact mode */
+    private readonly maxExactSamples;
+    /** Neighbor count for approximate mode */
+    private readonly approximateNeighbors;
+    /** Negative samples per point for approximate mode */
+    private readonly negativeSamples;
+    /** The embedded points after fitting */
+    private embedding;
+    /** Whether the model has been fitted */
+    private fitted;
+    constructor(options?: {
+        readonly nComponents?: number;
+        readonly perplexity?: number;
+        readonly learningRate?: number;
+        readonly nIter?: number;
+        readonly earlyExaggeration?: number;
+        readonly earlyExaggerationIter?: number;
+        readonly randomState?: number;
+        readonly minGradNorm?: number;
+        /** "exact" uses full pairwise interactions; "approximate" uses sampling for large datasets. */
+        readonly method?: "exact" | "approximate";
+        /** Maximum samples allowed in exact mode before requiring approximate. */
+        readonly maxExactSamples?: number;
+        /** Number of neighbors to sample per point in approximate mode. */
+        readonly approximateNeighbors?: number;
+        /** Number of negative samples per point in approximate mode. */
+        readonly negativeSamples?: number;
+    });
+    /**
+     * Compute pairwise squared Euclidean distances.
+     */
+    private computeDistances;
+    /**
+     * Compute squared Euclidean distance between two vectors.
+     */
+    private computeSquaredDistance;
+    /**
+     * Sample unique indices excluding a single index.
+     */
+    private sampleIndices;
+    /**
+     * Sample unique indices excluding a set of indices.
+     */
+    private sampleIndicesWithExclusions;
+    /**
+     * Compute conditional probabilities P(j|i) using binary search for sigma.
+     */
+    private computeProbabilities;
+    /**
+     * Compute sparse joint probabilities using sampled neighbors (approximate).
+     */
+    private computeProbabilitiesSparse;
+    /**
+     * Symmetrize sparse probabilities: P = (P + P^T) / (2n).
+     */
+    private symmetrizeSparse;
+    /**
+     * Initialize embedding with small random values.
+     */
+    private initializeEmbedding;
+    /**
+     * Compute Q distribution (Student-t with 1 degree of freedom).
+     */
+    private computeQ;
+    /**
+     * Compute approximate Q using sampled pairs.
+     */
+    private computeQApprox;
+    /**
+     * Compute gradients of KL divergence.
+     */
+    private computeGradients;
+    /**
+     * Compute approximate gradients of KL divergence using sampled pairs.
+     */
+    private computeGradientsApprox;
+    /**
+     * Fit the t-SNE model and return the embedding.
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @returns Low-dimensional embedding of shape (n_samples, n_components)
+     */
+    fitTransform(X: Tensor): Tensor;
+    /**
+     * Fit the model (same as fitTransform for t-SNE).
+     */
+    fit(X: Tensor): this;
+    /**
+     * Get the embedding.
+     */
+    get embeddingResult(): Tensor;
+    /**
+     * Get hyperparameters for this estimator.
+     *
+     * @returns Object containing all hyperparameters
+     */
+    getParams(): Record<string, unknown>;
+}
+
+/**
+ * Gaussian Naive Bayes classifier.
+ *
+ * Implements the Gaussian Naive Bayes algorithm for classification.
+ * Assumes features follow a Gaussian (normal) distribution.
+ *
+ * **Algorithm**:
+ * 1. Calculate mean and variance for each feature per class
+ * 2. For prediction, calculate likelihood using Gaussian PDF
+ * 3. Apply Bayes' theorem to get posterior probabilities
+ * 4. Predict class with highest posterior probability
+ *
+ * **Time Complexity**:
+ * - Training: O(n * d) where n=samples, d=features
+ * - Prediction: O(k * d) per sample where k=classes
+ *
+ * @example
+ * ```ts
+ * import { GaussianNB } from 'deepbox/ml';
+ * import { tensor } from 'deepbox/ndarray';
+ *
+ * const X = tensor([[1, 2], [2, 3], [3, 4], [4, 5]]);
+ * const y = tensor([0, 0, 1, 1]);
+ *
+ * const nb = new GaussianNB();
+ * nb.fit(X, y);
+ *
+ * const predictions = nb.predict(tensor([[2.5, 3.5]]));
+ * ```
+ *
+ * @see {@link https://en.wikipedia.org/wiki/Naive_Bayes_classifier | Wikipedia: Naive Bayes}
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.naive_bayes.GaussianNB.html | scikit-learn GaussianNB}
+ */
+declare class GaussianNB implements Classifier {
+    private readonly varSmoothing;
+    private classes_?;
+    private classPrior_?;
+    private theta_?;
+    private var_?;
+    private nFeaturesIn_?;
+    private fitted;
+    /**
+     * Create a new Gaussian Naive Bayes classifier.
+     *
+     * @param options - Configuration options
+     * @param options.varSmoothing - Portion of largest variance added to variances for stability (default: 1e-9)
+     */
+    constructor(options?: {
+        readonly varSmoothing?: number;
+    });
+    /**
+     * Fit Gaussian Naive Bayes classifier from the training set.
+     *
+     * Computes per-class mean, variance, and prior probabilities.
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @param y - Target class labels of shape (n_samples,)
+     * @returns this - The fitted estimator
+     * @throws {ShapeError} If X is not 2D or y is not 1D
+     * @throws {ShapeError} If X and y have different number of samples
+     * @throws {DataValidationError} If X or y contain NaN/Inf values
+     * @throws {DataValidationError} If zero variance encountered with varSmoothing=0
+     */
+    fit(X: Tensor, y: Tensor): this;
+    /**
+     * Predict class labels for samples in X.
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Predicted class labels of shape (n_samples,)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If X has wrong dimensions or feature count
+     * @throws {DataValidationError} If X contains NaN/Inf values
+     */
+    predict(X: Tensor): Tensor;
+    /**
+     * Predict class probabilities for samples in X.
+     *
+     * Uses Bayes' theorem with Gaussian class-conditional likelihoods.
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Class probability matrix of shape (n_samples, n_classes)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If X has wrong dimensions or feature count
+     * @throws {DataValidationError} If X contains NaN/Inf values
+     */
+    predictProba(X: Tensor): Tensor;
+    /**
+     * Return the mean accuracy on the given test data and labels.
+     *
+     * @param X - Test samples of shape (n_samples, n_features)
+     * @param y - True labels of shape (n_samples,)
+     * @returns Accuracy score in range [0, 1]
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If y is not 1-dimensional or sample counts mismatch
+     * @throws {DataValidationError} If y contains NaN/Inf values
+     */
+    score(X: Tensor, y: Tensor): number;
+    /**
+     * Get the unique class labels discovered during fitting.
+     *
+     * @returns Tensor of class labels or undefined if not fitted
+     */
+    get classes(): Tensor | undefined;
+    /**
+     * Get hyperparameters for this estimator.
+     *
+     * @returns Object containing all hyperparameters
+     */
+    getParams(): Record<string, unknown>;
+    /**
+     * Set the parameters of this estimator.
+     *
+     * @param _params - Parameters to set
+     * @throws {NotImplementedError} Always — parameters cannot be changed after construction
+     */
+    setParams(_params: Record<string, unknown>): this;
+}
+
+/**
+ * K-Nearest Neighbors base class.
+ */
+declare abstract class KNeighborsBase {
+    protected readonly nNeighbors: number;
+    protected readonly weights: "uniform" | "distance";
+    protected readonly metric: "euclidean" | "manhattan";
+    protected XTrain_?: Tensor;
+    protected yTrain_?: Tensor;
+    protected nFeaturesIn_?: number;
+    protected fitted: boolean;
+    constructor(options?: {
+        readonly nNeighbors?: number;
+        readonly weights?: "uniform" | "distance";
+        readonly metric?: "euclidean" | "manhattan";
+    });
+    protected calculateDistance(x1: number[], x2: number[]): number;
+    protected findKNearest(sample: number[]): Array<{
+        index: number;
+        distance: number;
+    }>;
+    /**
+     * Get hyperparameters for this estimator.
+     *
+     * @returns Object containing all hyperparameters
+     */
+    getParams(): Record<string, unknown>;
+    /**
+     * Set the parameters of this estimator.
+     *
+     * @param _params - Parameters to set
+     * @throws {NotImplementedError} Always — parameters cannot be changed after construction
+     */
+    setParams(_params: Record<string, unknown>): this;
+}
+/**
+ * K-Nearest Neighbors Classifier.
+ *
+ * Classification based on k nearest neighbors. Predicts class by majority vote
+ * of k nearest training samples.
+ *
+ * **Algorithm**: Instance-based learning
+ * 1. Store all training data
+ * 2. For each test sample, find k nearest training samples
+ * 3. Predict class by majority vote (or weighted vote)
+ *
+ * **Time Complexity**:
+ * - Training: O(1) (just stores data)
+ * - Prediction: O(n * d) per sample where n=training samples, d=features
+ *
+ * @example
+ * ```ts
+ * import { KNeighborsClassifier } from 'deepbox/ml';
+ * import { tensor } from 'deepbox/ndarray';
+ *
+ * const X = tensor([[0, 0], [1, 1], [2, 2], [3, 3]]);
+ * const y = tensor([0, 0, 1, 1]);
+ *
+ * const knn = new KNeighborsClassifier({ nNeighbors: 3 });
+ * knn.fit(X, y);
+ *
+ * const predictions = knn.predict(tensor([[1.5, 1.5]]));
+ * ```
+ *
+ * @see {@link https://en.wikipedia.org/wiki/K-nearest_neighbors_algorithm | Wikipedia: KNN}
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html | scikit-learn KNeighborsClassifier}
+ */
+declare class KNeighborsClassifier extends KNeighborsBase implements Classifier {
+    /**
+     * Fit the k-nearest neighbors classifier from the training set.
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @param y - Target class labels of shape (n_samples,)
+     * @returns this - The fitted estimator
+     * @throws {ShapeError} If X is not 2D or y is not 1D
+     * @throws {ShapeError} If X and y have different number of samples
+     * @throws {DataValidationError} If X or y contain NaN/Inf values
+     * @throws {InvalidParameterError} If nNeighbors > n_samples
+     */
+    fit(X: Tensor, y: Tensor): this;
+    /**
+     * Predict class labels for samples in X.
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Predicted class labels of shape (n_samples,)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If X has wrong dimensions or feature count
+     * @throws {DataValidationError} If X contains NaN/Inf values
+     */
+    predict(X: Tensor): Tensor;
+    /**
+     * Predict class probabilities for samples in X.
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Class probability matrix of shape (n_samples, n_classes)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If X has wrong dimensions or feature count
+     * @throws {DataValidationError} If X contains NaN/Inf values
+     */
+    predictProba(X: Tensor): Tensor;
+    /**
+     * Return the mean accuracy on the given test data and labels.
+     *
+     * @param X - Test samples of shape (n_samples, n_features)
+     * @param y - True labels of shape (n_samples,)
+     * @returns Accuracy score in range [0, 1]
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If y is not 1-dimensional or sample counts mismatch
+     * @throws {DataValidationError} If y contains NaN/Inf values
+     */
+    score(X: Tensor, y: Tensor): number;
+}
+/**
+ * K-Nearest Neighbors Regressor.
+ *
+ * Regression based on k nearest neighbors. Predicts value as mean (or weighted mean)
+ * of k nearest training samples.
+ *
+ * @example
+ * ```ts
+ * import { KNeighborsRegressor } from 'deepbox/ml';
+ * import { tensor } from 'deepbox/ndarray';
+ *
+ * const X = tensor([[0], [1], [2], [3]]);
+ * const y = tensor([0, 1, 4, 9]);
+ *
+ * const knn = new KNeighborsRegressor({ nNeighbors: 2 });
+ * knn.fit(X, y);
+ *
+ * const predictions = knn.predict(tensor([[1.5]]));
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsRegressor.html | scikit-learn KNeighborsRegressor}
+ */
+declare class KNeighborsRegressor extends KNeighborsBase implements Regressor {
+    /**
+     * Fit the k-nearest neighbors regressor from the training set.
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @param y - Target values of shape (n_samples,)
+     * @returns this - The fitted estimator
+     * @throws {ShapeError} If X is not 2D or y is not 1D
+     * @throws {ShapeError} If X and y have different number of samples
+     * @throws {DataValidationError} If X or y contain NaN/Inf values
+     * @throws {InvalidParameterError} If nNeighbors > n_samples
+     */
+    fit(X: Tensor, y: Tensor): this;
+    /**
+     * Predict target values for samples in X.
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Predicted values of shape (n_samples,)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If X has wrong dimensions or feature count
+     * @throws {DataValidationError} If X contains NaN/Inf values
+     */
+    predict(X: Tensor): Tensor;
+    /**
+     * Return the R² score on the given test data and target values.
+     *
+     * @param X - Test samples of shape (n_samples, n_features)
+     * @param y - True target values of shape (n_samples,)
+     * @returns R² score (best possible is 1.0, can be negative)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If y is not 1-dimensional or sample counts mismatch
+     * @throws {DataValidationError} If y contains NaN/Inf values
+     */
+    score(X: Tensor, y: Tensor): number;
+}
+
+/**
+ * Support Vector Machine (SVM) Classifier.
+ *
+ * Implements a linear SVM using sub-gradient descent on the hinge loss
+ * with L2 regularization (soft margin). Suitable for binary classification tasks.
+ *
+ * **Algorithm**: Sub-gradient descent on hinge loss (linear kernel)
+ *
+ * **Mathematical Formulation**:
+ * - Decision function: f(x) = sign(w · x + b)
+ * - Optimization: minimize (1/2)||w||² + C * Σmax(0, 1 - y_i(w · x_i + b))
+ *
+ * @example
+ * ```ts
+ * import { LinearSVC } from 'deepbox/ml';
+ * import { tensor } from 'deepbox/ndarray';
+ *
+ * const X = tensor([[1, 2], [2, 3], [3, 1], [4, 2]]);
+ * const y = tensor([0, 0, 1, 1]);
+ *
+ * const svm = new LinearSVC({ C: 1.0 });
+ * svm.fit(X, y);
+ * const predictions = svm.predict(X);
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html | scikit-learn LinearSVC}
+ */
+declare class LinearSVC implements Classifier {
+    /** Regularization parameter (inverse of regularization strength) */
+    private readonly C;
+    /** Maximum number of iterations for optimization */
+    private readonly maxIter;
+    /** Tolerance for stopping criterion */
+    private readonly tol;
+    /** Weight vector of shape (n_features,) */
+    private weights;
+    /** Bias term */
+    private bias;
+    /** Number of features seen during fit */
+    private nFeatures;
+    /** Unique class labels [0, 1] mapped from original labels */
+    private classLabels;
+    /** Whether the model has been fitted */
+    private fitted;
+    /**
+     * Create a new SVM Classifier.
+     *
+     * @param options - Configuration options
+     * @param options.C - Regularization parameter (default: 1.0). Larger C = stronger penalty on errors = harder margin.
+     * @param options.maxIter - Maximum iterations (default: 1000)
+     * @param options.tol - Convergence tolerance (default: 1e-4)
+     */
+    constructor(options?: {
+        readonly C?: number;
+        readonly maxIter?: number;
+        readonly tol?: number;
+    });
+    /**
+     * Fit the SVM classifier using sub-gradient descent.
+     *
+     * Uses a simplified hinge loss optimization with L2 regularization.
+     * Objective: minimize (1/2)||w||² + C * Σmax(0, 1 - y_i(w · x_i + b))
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @param y - Target labels of shape (n_samples,). Must contain exactly 2 classes.
+     * @returns this - The fitted estimator
+     * @throws {ShapeError} If X is not 2D or y is not 1D
+     * @throws {ShapeError} If X and y have different number of samples
+     * @throws {DataValidationError} If X or y contain NaN/Inf values
+     * @throws {InvalidParameterError} If y does not contain exactly 2 classes
+     */
+    fit(X: Tensor, y: Tensor): this;
+    /**
+     * Predict class labels for samples in X.
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Predicted labels of shape (n_samples,)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If X has wrong dimensions or feature count
+     * @throws {DataValidationError} If X contains NaN/Inf values
+     */
+    predict(X: Tensor): Tensor;
+    /**
+     * Predict class probabilities using Platt scaling approximation.
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Probability estimates of shape (n_samples, 2)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If X has wrong dimensions or feature count
+     * @throws {DataValidationError} If X contains NaN/Inf values
+     */
+    predictProba(X: Tensor): Tensor;
+    /**
+     * Return the mean accuracy on the given test data and labels.
+     *
+     * @param X - Test samples of shape (n_samples, n_features)
+     * @param y - True labels of shape (n_samples,)
+     * @returns Accuracy score in range [0, 1]
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If y is not 1-dimensional or sample counts mismatch
+     * @throws {DataValidationError} If y contains NaN/Inf values
+     */
+    score(X: Tensor, y: Tensor): number;
+    /**
+     * Get the weight vector.
+     *
+     * @returns Weight vector as tensor of shape (1, n_features)
+     * @throws {NotFittedError} If the model has not been fitted
+     */
+    get coef(): Tensor;
+    /**
+     * Get the bias term.
+     *
+     * @returns Bias value
+     * @throws {NotFittedError} If the model has not been fitted
+     */
+    get intercept(): number;
+    /**
+     * Get hyperparameters for this estimator.
+     *
+     * @returns Object containing all hyperparameters
+     */
+    getParams(): Record<string, unknown>;
+    /**
+     * Set the parameters of this estimator.
+     *
+     * @param _params - Parameters to set
+     * @throws {NotImplementedError} Always — parameters cannot be changed after construction
+     */
+    setParams(_params: Record<string, unknown>): this;
+}
+/**
+ * Support Vector Machine (SVM) Regressor.
+ *
+ * Implements epsilon-SVR (Support Vector Regression) using sub-gradient descent.
+ *
+ * @example
+ * ```ts
+ * import { LinearSVR } from 'deepbox/ml';
+ * import { tensor } from 'deepbox/ndarray';
+ *
+ * const X = tensor([[1], [2], [3], [4]]);
+ * const y = tensor([1.5, 2.5, 3.5, 4.5]);
+ *
+ * const svr = new LinearSVR({ C: 1.0, epsilon: 0.1 });
+ * svr.fit(X, y);
+ * const predictions = svr.predict(X);
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVR.html | scikit-learn LinearSVR}
+ */
+declare class LinearSVR implements Regressor {
+    /** Regularization parameter */
+    private readonly C;
+    /** Epsilon in the epsilon-SVR model */
+    private readonly epsilon;
+    /** Maximum number of iterations */
+    private readonly maxIter;
+    /** Tolerance for stopping criterion */
+    private readonly tol;
+    /** Weight vector */
+    private weights;
+    /** Bias term */
+    private bias;
+    /** Number of features */
+    private nFeatures;
+    /** Whether the model has been fitted */
+    private fitted;
+    constructor(options?: {
+        readonly C?: number;
+        readonly epsilon?: number;
+        readonly maxIter?: number;
+        readonly tol?: number;
+    });
+    /**
+     * Fit the SVR model using sub-gradient descent on epsilon-insensitive loss.
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @param y - Target values of shape (n_samples,)
+     * @returns this - The fitted estimator
+     * @throws {ShapeError} If X is not 2D or y is not 1D
+     * @throws {ShapeError} If X and y have different number of samples
+     * @throws {DataValidationError} If X or y contain NaN/Inf values
+     */
+    fit(X: Tensor, y: Tensor): this;
+    /**
+     * Predict target values for samples in X.
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Predicted values of shape (n_samples,)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If X has wrong dimensions or feature count
+     * @throws {DataValidationError} If X contains NaN/Inf values
+     */
+    predict(X: Tensor): Tensor;
+    /**
+     * Return the R² score on the given test data and target values.
+     *
+     * @param X - Test samples of shape (n_samples, n_features)
+     * @param y - True target values of shape (n_samples,)
+     * @returns R² score (best possible is 1.0, can be negative)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If y is not 1-dimensional or sample counts mismatch
+     * @throws {DataValidationError} If y contains NaN/Inf values
+     */
+    score(X: Tensor, y: Tensor): number;
+    /**
+     * Get hyperparameters for this estimator.
+     *
+     * @returns Object containing all hyperparameters
+     */
+    getParams(): Record<string, unknown>;
+    /**
+     * Set the parameters of this estimator.
+     *
+     * @param _params - Parameters to set
+     * @throws {NotImplementedError} Always — parameters cannot be changed after construction
+     */
+    setParams(_params: Record<string, unknown>): this;
+}
+
+/**
+ * Decision Tree Classifier.
+ *
+ * A non-parametric supervised learning method that learns simple decision rules
+ * inferred from the data features.
+ *
+ * **Algorithm**: CART (Classification and Regression Trees)
+ * - Uses Gini impurity for classification
+ * - Recursively splits data based on feature thresholds
+ * - Supports max_depth and min_samples_split for regularization
+ *
+ * @example
+ * ```ts
+ * import { DecisionTreeClassifier } from 'deepbox/ml';
+ * import { tensor } from 'deepbox/ndarray';
+ *
+ * const X = tensor([[1, 2], [3, 4], [5, 6], [7, 8]]);
+ * const y = tensor([0, 0, 1, 1]);
+ *
+ * const clf = new DecisionTreeClassifier({ maxDepth: 3 });
+ * clf.fit(X, y);
+ * const predictions = clf.predict(X);
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html | scikit-learn DecisionTreeClassifier}
+ */
+declare class DecisionTreeClassifier implements Classifier {
+    private maxDepth;
+    private minSamplesSplit;
+    private minSamplesLeaf;
+    private maxFeatures;
+    private randomState;
+    private tree?;
+    private nFeatures?;
+    private classLabels?;
+    private fitted;
+    constructor(options?: {
+        readonly maxDepth?: number;
+        readonly minSamplesSplit?: number;
+        readonly minSamplesLeaf?: number;
+        readonly maxFeatures?: number;
+        readonly randomState?: number;
+    });
+    private getRng;
+    /**
+     * Build a decision tree classifier from the training set (X, y).
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @param y - Target class labels of shape (n_samples,)
+     * @returns this - The fitted estimator
+     * @throws {ShapeError} If X is not 2D or y is not 1D
+     * @throws {ShapeError} If X and y have different number of samples
+     * @throws {DataValidationError} If X or y contain NaN/Inf values
+     */
+    fit(X: Tensor, y: Tensor): this;
+    private buildTree;
+    private getMajorityClass;
+    private getClassProbabilities;
+    private findBestSplit;
+    private giniFromCounts;
+    /**
+     * Predict class labels for samples in X.
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Predicted class labels of shape (n_samples,)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If X has wrong dimensions or feature count
+     * @throws {DataValidationError} If X contains NaN/Inf values
+     */
+    predict(X: Tensor): Tensor;
+    private predictSample;
+    /**
+     * Predict class probabilities for samples in X.
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Class probability matrix of shape (n_samples, n_classes)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If X has wrong dimensions or feature count
+     * @throws {DataValidationError} If X contains NaN/Inf values
+     */
+    predictProba(X: Tensor): Tensor;
+    private predictLeaf;
+    /**
+     * Return the mean accuracy on the given test data and labels.
+     *
+     * @param X - Test samples of shape (n_samples, n_features)
+     * @param y - True labels of shape (n_samples,)
+     * @returns Accuracy score in range [0, 1]
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If y is not 1-dimensional or sample counts mismatch
+     * @throws {DataValidationError} If y contains NaN/Inf values
+     */
+    score(X: Tensor, y: Tensor): number;
+    /**
+     * Get the unique class labels discovered during fitting.
+     *
+     * @returns Tensor of class labels or undefined if not fitted
+     */
+    get classes(): Tensor | undefined;
+    /**
+     * Get hyperparameters for this estimator.
+     *
+     * @returns Object containing all hyperparameters
+     */
+    getParams(): Record<string, unknown>;
+    /**
+     * Set the parameters of this estimator.
+     *
+     * @param _params - Parameters to set
+     * @throws {NotImplementedError} Always — parameters cannot be changed after construction
+     */
+    setParams(_params: Record<string, unknown>): this;
+}
+/**
+ * Decision Tree Regressor.
+ *
+ * Uses MSE reduction to find optimal splits for regression tasks.
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeRegressor.html | scikit-learn DecisionTreeRegressor}
+ */
+declare class DecisionTreeRegressor implements Regressor {
+    private maxDepth;
+    private minSamplesSplit;
+    private minSamplesLeaf;
+    private maxFeatures;
+    private randomState;
+    private tree?;
+    private nFeatures?;
+    private fitted;
+    constructor(options?: {
+        readonly maxDepth?: number;
+        readonly minSamplesSplit?: number;
+        readonly minSamplesLeaf?: number;
+        readonly maxFeatures?: number;
+        readonly randomState?: number;
+    });
+    private getRng;
+    /**
+     * Build a decision tree regressor from the training set (X, y).
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @param y - Target values of shape (n_samples,)
+     * @returns this - The fitted estimator
+     * @throws {ShapeError} If X is not 2D or y is not 1D
+     * @throws {ShapeError} If X and y have different number of samples
+     * @throws {DataValidationError} If X or y contain NaN/Inf values
+     */
+    fit(X: Tensor, y: Tensor): this;
+    private buildTree;
+    private getMean;
+    private findBestSplit;
+    /**
+     * Predict target values for samples in X.
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Predicted values of shape (n_samples,)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If X has wrong dimensions or feature count
+     * @throws {DataValidationError} If X contains NaN/Inf values
+     */
+    predict(X: Tensor): Tensor;
+    private predictSample;
+    /**
+     * Return the R² score on the given test data and target values.
+     *
+     * R² = 1 - SS_res / SS_tot.
+     *
+     * @param X - Test samples of shape (n_samples, n_features)
+     * @param y - True target values of shape (n_samples,)
+     * @returns R² score (best possible is 1.0, can be negative)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If y is not 1-dimensional or sample counts mismatch
+     * @throws {DataValidationError} If y contains NaN/Inf values
+     */
+    score(X: Tensor, y: Tensor): number;
+    /**
+     * Get hyperparameters for this estimator.
+     *
+     * @returns Object containing all hyperparameters
+     */
+    getParams(): Record<string, unknown>;
+    /**
+     * Set the parameters of this estimator.
+     *
+     * @param _params - Parameters to set
+     * @throws {NotImplementedError} Always — parameters cannot be changed after construction
+     */
+    setParams(_params: Record<string, unknown>): this;
+}
+
+/**
+ * Random Forest Classifier.
+ *
+ * An ensemble of decision trees trained on random subsets of data and features.
+ * Predictions are made by majority voting.
+ *
+ * **Algorithm**:
+ * 1. Create n_estimators bootstrap samples from training data
+ * 2. Train a decision tree on each sample with random feature subsets
+ * 3. Aggregate predictions via majority voting
+ *
+ * @example
+ * ```ts
+ * import { RandomForestClassifier } from 'deepbox/ml';
+ * import { tensor } from 'deepbox/ndarray';
+ *
+ * const clf = new RandomForestClassifier({ nEstimators: 100 });
+ * clf.fit(X_train, y_train);
+ * const predictions = clf.predict(X_test);
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html | scikit-learn RandomForestClassifier}
+ */
+declare class RandomForestClassifier implements Classifier {
+    private readonly nEstimators;
+    private readonly maxDepth;
+    private readonly minSamplesSplit;
+    private readonly minSamplesLeaf;
+    private readonly maxFeatures;
+    private readonly bootstrap;
+    private readonly randomState?;
+    private trees;
+    private classLabels?;
+    private nFeatures?;
+    private fitted;
+    constructor(options?: {
+        readonly nEstimators?: number;
+        readonly maxDepth?: number;
+        readonly minSamplesSplit?: number;
+        readonly minSamplesLeaf?: number;
+        readonly maxFeatures?: "sqrt" | "log2" | number;
+        readonly bootstrap?: boolean;
+        readonly randomState?: number;
+    });
+    private createRNG;
+    /**
+     * Fit the random forest classifier on training data.
+     *
+     * Builds an ensemble of decision trees, each trained on a bootstrapped
+     * sample with random feature subsets.
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @param y - Target class labels of shape (n_samples,)
+     * @returns this - The fitted estimator
+     * @throws {ShapeError} If X is not 2D or y is not 1D
+     * @throws {ShapeError} If X and y have different number of samples
+     * @throws {DataValidationError} If X or y contain NaN/Inf values
+     */
+    fit(X: Tensor, y: Tensor): this;
+    /**
+     * Predict class labels for samples in X.
+     *
+     * Aggregates predictions from all trees via majority voting.
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Predicted class labels of shape (n_samples,)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If X has wrong dimensions or feature count
+     * @throws {DataValidationError} If X contains NaN/Inf values
+     */
+    predict(X: Tensor): Tensor;
+    /**
+     * Predict class probabilities for samples in X.
+     *
+     * Averages the predicted class probabilities from all trees in the ensemble.
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Class probability matrix of shape (n_samples, n_classes)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If X has wrong dimensions or feature count
+     * @throws {DataValidationError} If X contains NaN/Inf values
+     */
+    predictProba(X: Tensor): Tensor;
+    /**
+     * Return the mean accuracy on the given test data and labels.
+     *
+     * @param X - Test samples of shape (n_samples, n_features)
+     * @param y - True labels of shape (n_samples,)
+     * @returns Accuracy score in range [0, 1]
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If y is not 1-dimensional or sample counts mismatch
+     * @throws {DataValidationError} If y contains NaN/Inf values
+     */
+    score(X: Tensor, y: Tensor): number;
+    /**
+     * Get the unique class labels discovered during fitting.
+     *
+     * @returns Tensor of class labels or undefined if not fitted
+     */
+    get classes(): Tensor | undefined;
+    /**
+     * Get hyperparameters for this estimator.
+     *
+     * @returns Object containing all hyperparameters
+     */
+    getParams(): Record<string, unknown>;
+    /**
+     * Set the parameters of this estimator.
+     *
+     * @param _params - Parameters to set
+     * @throws {NotImplementedError} Always — parameters cannot be changed after construction
+     */
+    setParams(_params: Record<string, unknown>): this;
+}
+/**
+ * Random Forest Regressor.
+ *
+ * An ensemble of decision tree regressors trained on random subsets of data
+ * and features. Predictions are averaged across all trees.
+ *
+ * **Algorithm**:
+ * 1. Create n_estimators bootstrap samples from training data
+ * 2. Train a decision tree on each sample with random feature subsets
+ * 3. Aggregate predictions via averaging
+ *
+ * @example
+ * ```ts
+ * import { RandomForestRegressor } from 'deepbox/ml';
+ * import { tensor } from 'deepbox/ndarray';
+ *
+ * const reg = new RandomForestRegressor({ nEstimators: 100 });
+ * reg.fit(X_train, y_train);
+ * const predictions = reg.predict(X_test);
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestRegressor.html | scikit-learn RandomForestRegressor}
+ */
+declare class RandomForestRegressor implements Regressor {
+    private readonly nEstimators;
+    private readonly maxDepth;
+    private readonly minSamplesSplit;
+    private readonly minSamplesLeaf;
+    private readonly maxFeatures;
+    private readonly bootstrap;
+    private readonly randomState?;
+    private trees;
+    private nFeatures?;
+    private fitted;
+    constructor(options?: {
+        readonly nEstimators?: number;
+        readonly maxDepth?: number;
+        readonly minSamplesSplit?: number;
+        readonly minSamplesLeaf?: number;
+        readonly maxFeatures?: "sqrt" | "log2" | number;
+        readonly bootstrap?: boolean;
+        readonly randomState?: number;
+    });
+    private createRNG;
+    /**
+     * Fit the random forest regressor on training data.
+     *
+     * Builds an ensemble of decision trees, each trained on a bootstrapped
+     * sample with random feature subsets.
+     *
+     * @param X - Training data of shape (n_samples, n_features)
+     * @param y - Target values of shape (n_samples,)
+     * @returns this - The fitted estimator
+     * @throws {ShapeError} If X is not 2D or y is not 1D
+     * @throws {ShapeError} If X and y have different number of samples
+     * @throws {DataValidationError} If X or y contain NaN/Inf values
+     */
+    fit(X: Tensor, y: Tensor): this;
+    /**
+     * Predict target values for samples in X.
+     *
+     * Averages predictions from all trees in the ensemble.
+     *
+     * @param X - Samples of shape (n_samples, n_features)
+     * @returns Predicted values of shape (n_samples,)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If X has wrong dimensions or feature count
+     * @throws {DataValidationError} If X contains NaN/Inf values
+     */
+    predict(X: Tensor): Tensor;
+    /**
+     * Return the R² score on the given test data and target values.
+     *
+     * R² = 1 - SS_res / SS_tot, where SS_res = Σ(y - ŷ)² and SS_tot = Σ(y - ȳ)².
+     *
+     * @param X - Test samples of shape (n_samples, n_features)
+     * @param y - True target values of shape (n_samples,)
+     * @returns R² score (best possible is 1.0, can be negative)
+     * @throws {NotFittedError} If the model has not been fitted
+     * @throws {ShapeError} If y is not 1-dimensional or sample counts mismatch
+     * @throws {DataValidationError} If y contains NaN/Inf values
+     */
+    score(X: Tensor, y: Tensor): number;
+    /**
+     * Get hyperparameters for this estimator.
+     *
+     * @returns Object containing all hyperparameters
+     */
+    getParams(): Record<string, unknown>;
+    /**
+     * Set the parameters of this estimator.
+     *
+     * @param _params - Parameters to set
+     * @throws {NotImplementedError} Always — parameters cannot be changed after construction
+     */
+    setParams(_params: Record<string, unknown>): this;
+}
+
+type index_Classifier = Classifier;
+type index_Clusterer = Clusterer;
+type index_DBSCAN = DBSCAN;
+declare const index_DBSCAN: typeof DBSCAN;
+type index_DecisionTreeClassifier = DecisionTreeClassifier;
+declare const index_DecisionTreeClassifier: typeof DecisionTreeClassifier;
+type index_DecisionTreeRegressor = DecisionTreeRegressor;
+declare const index_DecisionTreeRegressor: typeof DecisionTreeRegressor;
+type index_Estimator<FitParams = void> = Estimator<FitParams>;
+type index_GaussianNB = GaussianNB;
+declare const index_GaussianNB: typeof GaussianNB;
+type index_GradientBoostingClassifier = GradientBoostingClassifier;
+declare const index_GradientBoostingClassifier: typeof GradientBoostingClassifier;
+type index_GradientBoostingRegressor = GradientBoostingRegressor;
+declare const index_GradientBoostingRegressor: typeof GradientBoostingRegressor;
+type index_KMeans = KMeans;
+declare const index_KMeans: typeof KMeans;
+type index_KNeighborsClassifier = KNeighborsClassifier;
+declare const index_KNeighborsClassifier: typeof KNeighborsClassifier;
+type index_KNeighborsRegressor = KNeighborsRegressor;
+declare const index_KNeighborsRegressor: typeof KNeighborsRegressor;
+type index_Lasso = Lasso;
+declare const index_Lasso: typeof Lasso;
+type index_LinearRegression = LinearRegression;
+declare const index_LinearRegression: typeof LinearRegression;
+type index_LinearSVC = LinearSVC;
+declare const index_LinearSVC: typeof LinearSVC;
+type index_LinearSVR = LinearSVR;
+declare const index_LinearSVR: typeof LinearSVR;
+type index_LogisticRegression = LogisticRegression;
+declare const index_LogisticRegression: typeof LogisticRegression;
+type index_OutlierDetector = OutlierDetector;
+type index_PCA = PCA;
+declare const index_PCA: typeof PCA;
+type index_RandomForestClassifier = RandomForestClassifier;
+declare const index_RandomForestClassifier: typeof RandomForestClassifier;
+type index_RandomForestRegressor = RandomForestRegressor;
+declare const index_RandomForestRegressor: typeof RandomForestRegressor;
+type index_Regressor = Regressor;
+type index_Ridge = Ridge;
+declare const index_Ridge: typeof Ridge;
+type index_TSNE = TSNE;
+declare const index_TSNE: typeof TSNE;
+type index_Transformer = Transformer;
+declare namespace index {
+  export { type index_Classifier as Classifier, type index_Clusterer as Clusterer, index_DBSCAN as DBSCAN, index_DecisionTreeClassifier as DecisionTreeClassifier, index_DecisionTreeRegressor as DecisionTreeRegressor, type index_Estimator as Estimator, index_GaussianNB as GaussianNB, index_GradientBoostingClassifier as GradientBoostingClassifier, index_GradientBoostingRegressor as GradientBoostingRegressor, index_KMeans as KMeans, index_KNeighborsClassifier as KNeighborsClassifier, index_KNeighborsRegressor as KNeighborsRegressor, index_Lasso as Lasso, index_LinearRegression as LinearRegression, index_LinearSVC as LinearSVC, index_LinearSVR as LinearSVR, index_LogisticRegression as LogisticRegression, type index_OutlierDetector as OutlierDetector, index_PCA as PCA, index_RandomForestClassifier as RandomForestClassifier, index_RandomForestRegressor as RandomForestRegressor, type index_Regressor as Regressor, index_Ridge as Ridge, index_TSNE as TSNE, type index_Transformer as Transformer };
+}
+
+export { type Classifier as C, DBSCAN as D, type Estimator as E, GradientBoostingClassifier as G, KMeans as K, Lasso as L, type OutlierDetector as O, PCA as P, type Regressor as R, type Transformer as T, type Clusterer as a, GradientBoostingRegressor as b, LinearRegression as c, LogisticRegression as d, Ridge as e, TSNE as f, GaussianNB as g, KNeighborsClassifier as h, index as i, KNeighborsRegressor as j, LinearSVC as k, LinearSVR as l, DecisionTreeClassifier as m, DecisionTreeRegressor as n, RandomForestClassifier as o, RandomForestRegressor as p };