deepbox 0.1.0

package/dist/index-DuCxd-8d.d.ts

@@ -0,0 +1,837 @@
+import { T as Tensor } from './Tensor-g8mUClel.js';
+import { C as CSRMatrix } from './CSRMatrix-KzNt6QpS.js';
+
+/**
+ * Type representing a category value that can be a string, number, or bigint.
+ * Used for categorical encoding operations.
+ */
+type Category = number | string | bigint;
+type CategoriesOption = "auto" | ReadonlyArray<ReadonlyArray<Category>>;
+/**
+ * Encode target labels with value between 0 and n_classes-1.
+ *
+ * This transformer encodes categorical labels (strings or numbers) into integers
+ * in the range [0, n_classes-1]. It maintains a mapping of unique classes to
+ * their integer representations and can reverse the transformation.
+ *
+ * **Time Complexity:**
+ * - fit: O(n) where n is the number of samples
+ * - transform: O(n) with O(1) lookup per sample
+ * - inverseTransform: O(n)
+ *
+ * **Space Complexity:** O(k) where k is the number of unique classes
+ *
+ * @example
+ * ```js
+ * import { LabelEncoder } from 'deepbox/preprocess';
+ * import { tensor } from 'deepbox/ndarray';
+ *
+ * const y = tensor(['cat', 'dog', 'cat', 'bird']);
+ * const encoder = new LabelEncoder();
+ * encoder.fit(y);
+ * const yEncoded = encoder.transform(y);  // [1, 2, 1, 0]
+ * const yDecoded = encoder.inverseTransform(yEncoded); // ['cat', 'dog', 'cat', 'bird']
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.LabelEncoder.html | Scikit-learn LabelEncoder}
+ */
+declare class LabelEncoder {
+    /** Indicates whether the encoder has been fitted to data */
+    private fitted;
+    /** Array of unique classes found during fitting, sorted for consistency */
+    private classes_?;
+    /** Map from class value to encoded integer index for O(1) lookup */
+    private classToIndex_?;
+    /**
+     * Fit label encoder to a set of labels.
+     * Extracts unique classes and creates an index mapping.
+     *
+     * @param y - Target labels (1D tensor of strings or numbers)
+     * @returns this - Returns self for method chaining
+     * @throws {InvalidParameterError} If y is empty
+     */
+    fit(y: Tensor): this;
+    /**
+     * Transform labels to normalized encoding.
+     * Each unique label is mapped to an integer in [0, n_classes-1].
+     *
+     * @param y - Target labels to encode (1D tensor)
+     * @returns Encoded labels as integer tensor
+     * @throws {NotFittedError} If encoder is not fitted
+     * @throws {InvalidParameterError} If y contains labels not seen during fit
+     */
+    transform(y: Tensor): Tensor;
+    /**
+     * Fit label encoder and return encoded labels in one step.
+     * Convenience method equivalent to calling fit(y).transform(y).
+     *
+     * @param y - Target labels (1D tensor)
+     * @returns Encoded labels as integer tensor
+     */
+    fitTransform(y: Tensor): Tensor;
+    /**
+     * Transform integer labels back to original encoding.
+     * Reverses the encoding performed by transform().
+     *
+     * @param y - Encoded labels (1D integer tensor)
+     * @returns Original labels (strings or numbers)
+     * @throws {NotFittedError} If encoder is not fitted
+     * @throws {InvalidParameterError} If y contains invalid indices
+     */
+    inverseTransform(y: Tensor): Tensor;
+}
+/**
+ * Encode categorical features as one-hot numeric array.
+ *
+ * This encoder transforms categorical features into a binary one-hot encoding.
+ * Each categorical feature with n unique values is transformed into n binary features,
+ * with only one active (set to 1) per sample.
+ *
+ * **Time Complexity:**
+ * - fit: O(n*m) where n is samples, m is features
+ * - transform: O(n*m*k) where k is average categories per feature
+ * - Sparse mode is more efficient for high-cardinality features
+ *
+ * **Space Complexity:**
+ * - Dense: O(n * sum(k_i)) where k_i is unique categories for feature i
+ * - Sparse: O(nnz) where nnz is number of non-zero elements
+ *
+ * @example
+ * ```js
+ * const X = tensor([['red', 'S'], ['blue', 'M'], ['red', 'L']]);
+ * const encoder = new OneHotEncoder({ sparse: false });
+ * encoder.fit(X);
+ * const encoded = encoder.transform(X);
+ * // Result: [[1,0,1,0,0], [0,1,0,1,0], [1,0,0,0,1]]
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OneHotEncoder.html | Scikit-learn OneHotEncoder}
+ */
+declare class OneHotEncoder {
+    /** Indicates whether the encoder has been fitted to data */
+    private fitted;
+    /** Array of unique categories for each feature */
+    private categories_?;
+    /** Maps from category value to index for each feature (for O(1) lookup) */
+    private categoryToIndex_?;
+    /** Whether to return sparse matrix (CSR) or dense array */
+    private sparse;
+    /** How to handle unknown categories during transform */
+    private handleUnknown;
+    /** Drop policy to avoid collinearity */
+    private drop;
+    /** Per-feature dropped category index */
+    private dropIndices_?;
+    /** Categories configuration */
+    private categoriesOption;
+    /**
+     * Creates a new OneHotEncoder instance.
+     *
+     * @param options - Configuration options
+     * @param options.sparse - If true, returns CSRMatrix; if false, returns dense Tensor (default: false)
+     * @param options.sparseOutput - Alias for sparse (default: false)
+     * @param options.handleUnknown - How to handle unknown categories (default: "error")
+     * @param options.drop - If set, drops the first or binary category per feature
+     * @param options.categories - "auto" or explicit category list per feature
+     */
+    constructor(options?: {
+        sparse?: boolean;
+        sparseOutput?: boolean;
+        handleUnknown?: "error" | "ignore";
+        drop?: "first" | "if_binary" | null;
+        categories?: CategoriesOption;
+    });
+    /**
+     * Fit OneHotEncoder to X.
+     * Learns the unique categories for each feature.
+     *
+     * @param X - Training data (2D tensor of categorical features)
+     * @returns this - Returns self for method chaining
+     * @throws {ShapeError} If X is not a 2D tensor
+     * @throws {InvalidParameterError} If X is empty
+     */
+    fit(X: Tensor): this;
+    /**
+     * Transform X using one-hot encoding.
+     * Each categorical value is converted to a binary vector.
+     *
+     * @param X - Data to transform (2D tensor)
+     * @returns Encoded data as dense Tensor or sparse CSRMatrix
+     * @throws {NotFittedError} If encoder is not fitted
+     * @throws {InvalidParameterError} If X contains unknown categories
+     */
+    transform(X: Tensor): Tensor | CSRMatrix;
+    fitTransform(X: Tensor): Tensor | CSRMatrix;
+    inverseTransform(X: Tensor | CSRMatrix): Tensor;
+}
+/**
+ * Encode categorical features as integer array.
+ *
+ * This encoder transforms categorical features into ordinal integers.
+ * Each feature's categories are mapped to integers [0, n_categories-1]
+ * based on their sorted order. Unlike OneHotEncoder, this maintains
+ * a single column per feature.
+ *
+ * **Time Complexity:**
+ * - fit: O(n*m*log(k)) where n=samples, m=features, k=avg categories
+ * - transform: O(n*m*log(k)) due to indexOf lookup
+ *
+ * **Space Complexity:** O(m*k) where m=features, k=avg categories per feature
+ *
+ * @example
+ * ```js
+ * const X = tensor([['low', 'red'], ['high', 'blue'], ['medium', 'red']]);
+ * const encoder = new OrdinalEncoder();
+ * encoder.fit(X);
+ * const encoded = encoder.transform(X);
+ * // Result: [[1, 1], [0, 0], [2, 1]] (alphabetically sorted)
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OrdinalEncoder.html | Scikit-learn OrdinalEncoder}
+ */
+declare class OrdinalEncoder {
+    /** Indicates whether the encoder has been fitted to data */
+    private fitted;
+    /** Array of unique categories for each feature, sorted */
+    private categories_?;
+    /** Maps from category value to index for each feature (for O(1) lookup) */
+    private categoryToIndex_?;
+    /** How to handle unknown categories during transform */
+    private handleUnknown;
+    /** Value used for unknown categories when handleUnknown = "useEncodedValue" */
+    private unknownValue;
+    /** Categories configuration */
+    private categoriesOption;
+    /**
+     * Creates a new OrdinalEncoder instance.
+     *
+     * @param options - Configuration options
+     * @param options.handleUnknown - How to handle unknown categories
+     * @param options.unknownValue - Encoded value for unknown categories when handleUnknown="useEncodedValue"
+     * @param options.categories - "auto" or explicit categories per feature
+     */
+    constructor(options?: {
+        handleUnknown?: "error" | "useEncodedValue";
+        unknownValue?: number;
+        categories?: CategoriesOption;
+    });
+    /**
+     * Fit OrdinalEncoder to X.
+     * Learns the unique categories for each feature and their ordering.
+     *
+     * @param X - Training data (2D tensor of categorical features)
+     * @returns this - Returns self for method chaining
+     * @throws {InvalidParameterError} If X is empty
+     */
+    fit(X: Tensor): this;
+    /**
+     * Transform X using ordinal encoding.
+     * Each category is mapped to its index in the sorted categories array.
+     *
+     * @param X - Data to transform (2D tensor)
+     * @returns Encoded data with integer values
+     * @throws {NotFittedError} If encoder is not fitted
+     * @throws {InvalidParameterError} If X contains unknown categories
+     */
+    transform(X: Tensor): Tensor;
+    /**
+     * Fit encoder and transform X in one step.
+     * Convenience method equivalent to calling fit(X).transform(X).
+     *
+     * @param X - Training data (2D tensor)
+     * @returns Encoded data
+     */
+    fitTransform(X: Tensor): Tensor;
+    /**
+     * Transform ordinal integers back to original categories.
+     * Reverses the encoding performed by transform().
+     *
+     * @param X - Encoded data (2D integer tensor)
+     * @returns Original categorical data
+     * @throws {NotFittedError} If encoder is not fitted
+     * @throws {InvalidParameterError} If X contains invalid indices
+     */
+    inverseTransform(X: Tensor): Tensor;
+}
+/**
+ * Binarize labels in a one-vs-all fashion.
+ *
+ * This transformer creates a binary matrix representation of labels where
+ * each class gets its own column. For multi-class problems, this creates
+ * a one-hot encoding of the labels.
+ *
+ * **Time Complexity:**
+ * - fit: O(n) where n is the number of samples
+ * - transform: O(n*k) where k is the number of classes
+ *
+ * **Space Complexity:** O(n*k) for the output matrix
+ *
+ * @example
+ * ```js
+ * const y = tensor([0, 1, 2, 0, 1]);
+ * const binarizer = new LabelBinarizer();
+ * const yBin = binarizer.fitTransform(y);
+ * // Result shape: [5, 3] with one-hot encoding
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.LabelBinarizer.html | Scikit-learn LabelBinarizer}
+ */
+declare class LabelBinarizer {
+    /** Indicates whether the binarizer has been fitted to data */
+    private fitted;
+    /** Array of unique classes found during fitting, sorted */
+    private classes_?;
+    /** Map from class value to index for O(1) lookups */
+    private classToIndex_?;
+    /** Value used for positive class */
+    private posLabel;
+    /** Value used for negative class */
+    private negLabel;
+    /** Whether to return sparse matrix output */
+    private sparse;
+    /**
+     * Creates a new LabelBinarizer instance.
+     *
+     * @param options - Configuration options
+     * @param options.posLabel - Value for positive class (default: 1)
+     * @param options.negLabel - Value for negative class (default: 0)
+     * @param options.sparse - If true, returns CSRMatrix (default: false)
+     * @param options.sparseOutput - Alias for sparse (default: false)
+     */
+    constructor(options?: {
+        posLabel?: number;
+        negLabel?: number;
+        sparse?: boolean;
+        sparseOutput?: boolean;
+    });
+    /**
+     * Fit label binarizer to a set of labels.
+     * Learns the unique classes present in the data.
+     *
+     * @param y - Target labels (1D tensor)
+     * @returns this - Returns self for method chaining
+     * @throws {InvalidParameterError} If y is empty
+     */
+    fit(y: Tensor): this;
+    /**
+     * Transform labels to binary matrix.
+     * Each label is converted to a binary vector with a single 1.
+     *
+     * @param y - Labels to transform (1D tensor)
+     * @returns Binary matrix (Tensor or CSRMatrix) with shape [n_samples, n_classes]
+     * @throws {NotFittedError} If binarizer is not fitted
+     * @throws {InvalidParameterError} If y contains unknown labels
+     */
+    transform(y: Tensor): Tensor | CSRMatrix;
+    /**
+     * Fit binarizer and transform labels in one step.
+     * Convenience method equivalent to calling fit(y).transform(y).
+     *
+     * @param y - Target labels (1D tensor)
+     * @returns Binary matrix (Tensor or CSRMatrix)
+     */
+    fitTransform(y: Tensor): Tensor | CSRMatrix;
+    /**
+     * Transform binary matrix back to labels.
+     * Finds the column with maximum value for each row.
+     *
+     * @param Y - Binary matrix (2D tensor or CSRMatrix)
+     * @returns Original labels (1D tensor)
+     * @throws {NotFittedError} If binarizer is not fitted
+     * @throws {InvalidParameterError} If Y has invalid shape
+     */
+    inverseTransform(Y: Tensor | CSRMatrix): Tensor;
+}
+/**
+ * Transform multi-label classification data to binary format.
+ *
+ * This transformer handles multi-label classification where each sample
+ * can belong to multiple classes simultaneously. It creates a binary
+ * matrix where each column represents a class and multiple columns can
+ * be active (set to 1) for a single sample.
+ *
+ * **Time Complexity:**
+ * - fit: O(n*k) where n is samples, k is avg labels per sample
+ * - transform: O(n*k*c) where c is total unique classes
+ *
+ * **Space Complexity:** O(n*c) for the output matrix
+ *
+ * @example
+ * ```js
+ * const y = [['sci-fi', 'action'], ['comedy'], ['action', 'drama']];
+ * const binarizer = new MultiLabelBinarizer();
+ * const yBin = binarizer.fitTransform(y);
+ * // Each row can have multiple 1s
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MultiLabelBinarizer.html | Scikit-learn MultiLabelBinarizer}
+ */
+declare class MultiLabelBinarizer {
+    /** Indicates whether the binarizer has been fitted to data */
+    private fitted;
+    /** Array of all unique classes found across all samples, sorted */
+    private classes_?;
+    /** Map from class value to index for O(1) lookups */
+    private classToIndex_?;
+    /** Whether to return sparse matrix (CSR) or dense array */
+    private sparse;
+    /** Optional explicit class ordering */
+    private classesOption?;
+    /**
+     * Creates a new MultiLabelBinarizer instance.
+     *
+     * @param options - Configuration options
+     * @param options.sparse - If true, returns CSRMatrix; if false, returns dense Tensor (default: false)
+     * @param options.sparseOutput - Alias for sparse (default: false)
+     * @param options.classes - Explicit class ordering to use instead of sorting
+     */
+    constructor(options?: {
+        sparse?: boolean;
+        sparseOutput?: boolean;
+        classes?: ReadonlyArray<Category>;
+    });
+    /**
+     * Fit multi-label binarizer to label sets.
+     * Learns all unique classes present across all samples.
+     *
+     * @param y - Array of label sets, where each element is an array of string/number/bigint labels
+     * @returns this - Returns self for method chaining
+     * @throws {InvalidParameterError} If y is empty
+     */
+    fit(y: ReadonlyArray<ReadonlyArray<Category>>): this;
+    /**
+     * Transform label sets to binary matrix.
+     * Each sample can have multiple active (1) columns.
+     *
+     * @param y - Array of label sets to transform (string/number/bigint labels)
+     * @returns Binary matrix (Tensor or CSRMatrix) with shape [n_samples, n_classes]
+     * @throws {NotFittedError} If binarizer is not fitted
+     * @throws {InvalidParameterError} If y contains unknown labels
+     */
+    transform(y: ReadonlyArray<ReadonlyArray<Category>>): Tensor | CSRMatrix;
+    /**
+     * Fit binarizer and transform label sets in one step.
+     * Convenience method equivalent to calling fit(y).transform(y).
+     *
+     * @param y - Array of label sets (string/number/bigint labels)
+     * @returns Binary matrix (Tensor or CSRMatrix)
+     */
+    fitTransform(y: ReadonlyArray<ReadonlyArray<Category>>): Tensor | CSRMatrix;
+    /**
+     * Transform binary matrix back to label sets.
+     * Finds all active (1) columns for each row.
+     *
+     * @param Y - Binary matrix (Tensor or CSRMatrix)
+     * @returns Array of label sets, one per sample
+     * @throws {NotFittedError} If binarizer is not fitted
+     * @throws {InvalidParameterError} If Y has invalid shape
+     */
+    inverseTransform(Y: Tensor | CSRMatrix): Category[][];
+}
+
+/**
+ * Standardize features by removing mean and scaling to unit variance.
+ *
+ * **Formula**: z = (x - μ) / σ
+ *
+ * **Attributes** (after fitting):
+ * - `mean_`: Mean of each feature
+ * - `scale_`: Standard deviation of each feature
+ *
+ * @example
+ * ```js
+ * import { StandardScaler } from 'deepbox/preprocess';
+ * import { tensor } from 'deepbox/ndarray';
+ *
+ * const X = tensor([[1, 2], [3, 4], [5, 6]]);
+ * const scaler = new StandardScaler();
+ * scaler.fit(X);
+ * const XScaled = scaler.transform(X);
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html | Scikit-learn StandardScaler}
+ */
+declare class StandardScaler {
+    private fitted;
+    private mean_;
+    private scale_;
+    private withMean;
+    private withStd;
+    /**
+     * Creates a new StandardScaler.
+     *
+     * @param options - Configuration options
+     * @param options.withMean - Center data before scaling (default: true)
+     * @param options.withStd - Scale data to unit variance (default: true)
+     * @param options.copy - Accepted for API parity; transforms are always out-of-place (default: true)
+     */
+    constructor(options?: {
+        withMean?: boolean;
+        withStd?: boolean;
+        copy?: boolean;
+    });
+    fit(X: Tensor): this;
+    transform(X: Tensor): Tensor;
+    fitTransform(X: Tensor): Tensor;
+    inverseTransform(X: Tensor): Tensor;
+}
+/**
+ * Scale features to a range [min, max].
+ *
+ * **Formula**: X_scaled = (X - X.min) / (X.max - X.min) * (max - min) + min
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MinMaxScaler.html | Scikit-learn MinMaxScaler}
+ */
+declare class MinMaxScaler {
+    private fitted;
+    private dataMin_?;
+    private dataMax_?;
+    private featureRange;
+    private clip;
+    /**
+     * Creates a new MinMaxScaler.
+     *
+     * @param options - Configuration options
+     * @param options.featureRange - Desired feature range [min, max] (default: [0, 1])
+     * @param options.clip - Clip transformed values to featureRange (default: false)
+     * @param options.copy - Accepted for API parity; transforms are always out-of-place (default: true)
+     */
+    constructor(options?: {
+        featureRange?: [number, number];
+        clip?: boolean;
+        copy?: boolean;
+    });
+    fit(X: Tensor): this;
+    transform(X: Tensor): Tensor;
+    fitTransform(X: Tensor): Tensor;
+    inverseTransform(X: Tensor): Tensor;
+}
+/**
+ * Scale features by maximum absolute value.
+ *
+ * Scales to range [-1, 1]. Suitable for data that is already centered at zero.
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MaxAbsScaler.html | Scikit-learn MaxAbsScaler}
+ */
+declare class MaxAbsScaler {
+    private fitted;
+    private maxAbs_?;
+    /**
+     * Creates a new MaxAbsScaler.
+     *
+     * @param options - Configuration options
+     * @param options.copy - Accepted for API parity; transforms are always out-of-place (default: true)
+     */
+    constructor(options?: {
+        copy?: boolean;
+    });
+    fit(X: Tensor): this;
+    transform(X: Tensor): Tensor;
+    fitTransform(X: Tensor): Tensor;
+    inverseTransform(X: Tensor): Tensor;
+}
+/**
+ * Robust scaler using median and IQR.
+ *
+ * Robust to outliers.
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.RobustScaler.html | Scikit-learn RobustScaler}
+ */
+declare class RobustScaler {
+    private fitted;
+    private center_;
+    private scale_;
+    private withCentering;
+    private withScaling;
+    private quantileRange;
+    private unitVariance;
+    /**
+     * Creates a new RobustScaler.
+     *
+     * @param options - Configuration options
+     * @param options.withCentering - Center data using median (default: true)
+     * @param options.withScaling - Scale data using IQR (default: true)
+     * @param options.quantileRange - Quantile range for IQR as percentiles (default: [25, 75])
+     * @param options.unitVariance - Scale so that features have unit variance under normality (default: false)
+     * @param options.copy - Accepted for API parity; transforms are always out-of-place (default: true)
+     */
+    constructor(options?: {
+        withCentering?: boolean;
+        withScaling?: boolean;
+        quantileRange?: [number, number];
+        unitVariance?: boolean;
+        copy?: boolean;
+    });
+    fit(X: Tensor): this;
+    transform(X: Tensor): Tensor;
+    fitTransform(X: Tensor): Tensor;
+    inverseTransform(X: Tensor): Tensor;
+}
+/**
+ * Normalize samples to unit norm.
+ *
+ * Scales each sample (row) to have unit norm.
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.Normalizer.html | Scikit-learn Normalizer}
+ */
+declare class Normalizer {
+    private norm;
+    /**
+     * Creates a new Normalizer.
+     *
+     * @param options - Configuration options
+     * @param options.norm - Norm to use (default: "l2")
+     * @param options.copy - Accepted for API parity; transforms are always out-of-place (default: true)
+     */
+    constructor(options?: {
+        norm?: "l1" | "l2" | "max";
+        copy?: boolean;
+    });
+    fit(_X: Tensor): this;
+    transform(X: Tensor): Tensor;
+    fitTransform(X: Tensor): Tensor;
+}
+/**
+ * Transform features using quantiles.
+ *
+ * Maps to uniform or normal distribution.
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.QuantileTransformer.html | Scikit-learn QuantileTransformer}
+ */
+declare class QuantileTransformer {
+    private fitted;
+    private nQuantiles;
+    private outputDistribution;
+    private quantiles_?;
+    private subsample;
+    private randomState;
+    /**
+     * Creates a new QuantileTransformer.
+     *
+     * @param options - Configuration options
+     * @param options.nQuantiles - Number of quantiles to use (default: 1000)
+     * @param options.outputDistribution - "uniform" or "normal" (default: "uniform")
+     * @param options.subsample - Subsample size for quantile estimation (default: use all samples)
+     * @param options.randomState - Seed for subsampling reproducibility
+     * @param options.copy - Accepted for API parity; transforms are always out-of-place (default: true)
+     */
+    constructor(options?: {
+        nQuantiles?: number;
+        outputDistribution?: "uniform" | "normal";
+        subsample?: number;
+        randomState?: number;
+        copy?: boolean;
+    });
+    fit(X: Tensor): this;
+    transform(X: Tensor): Tensor;
+    /**
+     * Inverse transform data back to the original feature space.
+     *
+     * If `outputDistribution="normal"`, values are first mapped back to uniform
+     * quantiles before being projected into the original data distribution.
+     *
+     * @param X - Transformed data (2D tensor)
+     * @returns Data in the original feature space
+     * @throws {NotFittedError} If transformer is not fitted
+     */
+    inverseTransform(X: Tensor): Tensor;
+    private erf;
+    private normalCdf;
+    private erfInv;
+    private interpolateFromSorted;
+    private mapValueToQuantile;
+    private mapQuantileToValue;
+    fitTransform(X: Tensor): Tensor;
+}
+/**
+ * Apply power transform to make data more Gaussian-like.
+ *
+ * Supports Box-Cox and Yeo-Johnson transforms, with optional standardization.
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.PowerTransformer.html | Scikit-learn PowerTransformer}
+ */
+declare class PowerTransformer {
+    private fitted;
+    private method;
+    private lambdas_;
+    private standardize;
+    private mean_;
+    private scale_;
+    /**
+     * Creates a new PowerTransformer.
+     *
+     * @param options - Configuration options
+     * @param options.method - "box-cox" or "yeo-johnson" (default: "yeo-johnson")
+     * @param options.standardize - Whether to standardize transformed features (default: false)
+     * @param options.copy - Accepted for API parity; transforms are always out-of-place (default: true)
+     */
+    constructor(options?: {
+        method?: "box-cox" | "yeo-johnson";
+        standardize?: boolean;
+        copy?: boolean;
+    });
+    fit(X: Tensor): this;
+    transform(X: Tensor): Tensor;
+    /**
+     * Inverse transform data back to the original feature space.
+     * If `standardize=true`, de-standardizes before applying the inverse power transform.
+     *
+     * @param X - Transformed data (2D tensor)
+     * @returns Data in the original feature space
+     * @throws {NotFittedError} If transformer is not fitted
+     */
+    inverseTransform(X: Tensor): Tensor;
+    private boxCoxTransformValue;
+    private yeoJohnsonTransformValue;
+    private boxCoxInverseValue;
+    private yeoJohnsonInverseValue;
+    private logLikelihood;
+    private optimizeLambda;
+    fitTransform(X: Tensor): Tensor;
+}
+
+/**
+ * Split arrays into random train and test subsets.
+ *
+ * @param X - Feature matrix (2D tensor)
+ * @param y - Optional target labels (1D tensor)
+ * @param options - Split configuration options
+ * @param options.testSize - Proportion or absolute number of test samples
+ * @param options.trainSize - Proportion or absolute number of train samples
+ * @param options.randomState - Random seed
+ * @param options.shuffle - Whether to shuffle data before splitting
+ * @param options.stratify - If not undefined, data is split in stratified fashion using this as class labels
+ *
+ * @example
+ * ```js
+ * import { trainTestSplit } from 'deepbox/preprocess';
+ * import { tensor } from 'deepbox/ndarray';
+ *
+ * const X = tensor([[1, 2], [3, 4], [5, 6], [7, 8]]);
+ * const y = tensor([0, 1, 0, 1]);
+ * const [XTrain, XTest, yTrain, yTest] = trainTestSplit(X, y, { testSize: 0.25 });
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html | Scikit-learn train_test_split}
+ */
+declare function trainTestSplit(X: Tensor, y?: Tensor, options?: {
+    testSize?: number;
+    trainSize?: number;
+    randomState?: number;
+    shuffle?: boolean;
+    stratify?: Tensor;
+}): Tensor[];
+/**
+ * K-Folds cross-validator.
+ *
+ * Provides train/test indices to split data in train/test sets.
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.KFold.html | Scikit-learn KFold}
+ */
+declare class KFold {
+    private nSplits;
+    private shuffle;
+    private randomState;
+    constructor(options?: {
+        nSplits?: number;
+        shuffle?: boolean;
+        randomState?: number;
+    });
+    split(X: Tensor): Array<[number[], number[]]>;
+    getNSplits(): number;
+}
+/**
+ * Stratified K-Folds cross-validator.
+ *
+ * Provides train/test indices while preserving class distribution.
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.StratifiedKFold.html | Scikit-learn StratifiedKFold}
+ */
+declare class StratifiedKFold {
+    private nSplits;
+    private shuffle;
+    private randomState;
+    constructor(options?: {
+        nSplits?: number;
+        shuffle?: boolean;
+        randomState?: number;
+    });
+    split(X: Tensor, y: Tensor): Array<[number[], number[]]>;
+    getNSplits(): number;
+}
+/**
+ * Group K-Fold cross-validator.
+ *
+ * Ensures same group is not in both train and test.
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GroupKFold.html | Scikit-learn GroupKFold}
+ */
+declare class GroupKFold {
+    private nSplits;
+    constructor(options?: {
+        nSplits?: number;
+    });
+    split(X: Tensor, _y: Tensor | undefined, groups: Tensor): Array<[number[], number[]]>;
+    getNSplits(): number;
+}
+/**
+ * Leave-One-Out cross-validator.
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.LeaveOneOut.html | Scikit-learn LeaveOneOut}
+ */
+declare class LeaveOneOut {
+    split(X: Tensor): Array<[number[], number[]]>;
+    getNSplits(X: Tensor): number;
+}
+/**
+ * Leave-P-Out cross-validator.
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.LeavePOut.html | Scikit-learn LeavePOut}
+ */
+declare class LeavePOut {
+    private p;
+    constructor(p: number);
+    split(X: Tensor): Array<[number[], number[]]>;
+    getNSplits(X: Tensor): number;
+}
+
+type index_GroupKFold = GroupKFold;
+declare const index_GroupKFold: typeof GroupKFold;
+type index_KFold = KFold;
+declare const index_KFold: typeof KFold;
+type index_LabelBinarizer = LabelBinarizer;
+declare const index_LabelBinarizer: typeof LabelBinarizer;
+type index_LabelEncoder = LabelEncoder;
+declare const index_LabelEncoder: typeof LabelEncoder;
+type index_LeaveOneOut = LeaveOneOut;
+declare const index_LeaveOneOut: typeof LeaveOneOut;
+type index_LeavePOut = LeavePOut;
+declare const index_LeavePOut: typeof LeavePOut;
+type index_MaxAbsScaler = MaxAbsScaler;
+declare const index_MaxAbsScaler: typeof MaxAbsScaler;
+type index_MinMaxScaler = MinMaxScaler;
+declare const index_MinMaxScaler: typeof MinMaxScaler;
+type index_MultiLabelBinarizer = MultiLabelBinarizer;
+declare const index_MultiLabelBinarizer: typeof MultiLabelBinarizer;
+type index_Normalizer = Normalizer;
+declare const index_Normalizer: typeof Normalizer;
+type index_OneHotEncoder = OneHotEncoder;
+declare const index_OneHotEncoder: typeof OneHotEncoder;
+type index_OrdinalEncoder = OrdinalEncoder;
+declare const index_OrdinalEncoder: typeof OrdinalEncoder;
+type index_PowerTransformer = PowerTransformer;
+declare const index_PowerTransformer: typeof PowerTransformer;
+type index_QuantileTransformer = QuantileTransformer;
+declare const index_QuantileTransformer: typeof QuantileTransformer;
+type index_RobustScaler = RobustScaler;
+declare const index_RobustScaler: typeof RobustScaler;
+type index_StandardScaler = StandardScaler;
+declare const index_StandardScaler: typeof StandardScaler;
+type index_StratifiedKFold = StratifiedKFold;
+declare const index_StratifiedKFold: typeof StratifiedKFold;
+declare const index_trainTestSplit: typeof trainTestSplit;
+declare namespace index {
+  export { index_GroupKFold as GroupKFold, index_KFold as KFold, index_LabelBinarizer as LabelBinarizer, index_LabelEncoder as LabelEncoder, index_LeaveOneOut as LeaveOneOut, index_LeavePOut as LeavePOut, index_MaxAbsScaler as MaxAbsScaler, index_MinMaxScaler as MinMaxScaler, index_MultiLabelBinarizer as MultiLabelBinarizer, index_Normalizer as Normalizer, index_OneHotEncoder as OneHotEncoder, index_OrdinalEncoder as OrdinalEncoder, index_PowerTransformer as PowerTransformer, index_QuantileTransformer as QuantileTransformer, index_RobustScaler as RobustScaler, index_StandardScaler as StandardScaler, index_StratifiedKFold as StratifiedKFold, index_trainTestSplit as trainTestSplit };
+}
+
+export { GroupKFold as G, KFold as K, LabelBinarizer as L, MultiLabelBinarizer as M, Normalizer as N, OneHotEncoder as O, PowerTransformer as P, QuantileTransformer as Q, RobustScaler as R, StandardScaler as S, LabelEncoder as a, OrdinalEncoder as b, MaxAbsScaler as c, MinMaxScaler as d, LeaveOneOut as e, LeavePOut as f, StratifiedKFold as g, index as i, trainTestSplit as t };