deepbox 0.1.0

package/dist/index-9oQx1HgV.d.cts

@@ -0,0 +1,1180 @@
+import { T as Tensor } from './Tensor-BQLk1ltW.cjs';
+
+/**
+ * Calculates the accuracy classification score.
+ *
+ * Accuracy is the fraction of predictions that match the true labels.
+ * It's the most intuitive performance measure but can be misleading
+ * for imbalanced datasets.
+ *
+ * **Formula**: accuracy = (correct predictions) / (total predictions)
+ *
+ * **Time Complexity**: O(n) where n is the number of samples
+ * **Space Complexity**: O(1)
+ *
+ * @param yTrue - Ground truth (correct) target values
+ * @param yPred - Estimated targets as returned by a classifier
+ * @returns Accuracy score in range [0, 1], where 1 is perfect accuracy
+ *
+ * @throws {ShapeError} If yTrue and yPred have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If yTrue and yPred use incompatible label types
+ * @throws {DataValidationError} If numeric labels contain NaN or infinite values
+ *
+ * @example
+ * ```ts
+ * import { accuracy, tensor } from 'deepbox/core';
+ *
+ * const yTrue = tensor([0, 1, 1, 0, 1]);
+ * const yPred = tensor([0, 1, 0, 0, 1]);
+ * const acc = accuracy(yTrue, yPred); // 0.8 (4 out of 5 correct)
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.accuracy_score.html | Scikit-learn accuracy_score}
+ */
+declare function accuracy(yTrue: Tensor, yPred: Tensor): number;
+/**
+ * Calculates the precision classification score.
+ *
+ * Precision is the ratio of true positives to all positive predictions.
+ * It answers: "Of all samples predicted as positive, how many are actually positive?"
+ * High precision means low false positive rate.
+ *
+ * **Formula**: precision = TP / (TP + FP)
+ *
+ * **Time Complexity**: O(n) for binary, O(n*k) for multiclass where k is number of classes
+ * **Space Complexity**: O(k) for multiclass
+ *
+ * @param yTrue - Ground truth (correct) target values
+ * @param yPred - Estimated targets as returned by a classifier
+ * @param average - Averaging strategy: 'binary', 'micro', 'macro', 'weighted', or null
+ *   - 'binary': Calculate metrics for positive class only (default)
+ *   - 'micro': Calculate metrics globally by counting total TP, FP, FN
+ *   - 'macro': Calculate metrics for each class, return unweighted mean
+ *   - 'weighted': Calculate metrics for each class, return weighted mean by support
+ *   - null: Return array of scores for each class
+ * @returns Precision score(s) in range [0, 1]
+ *
+ * @throws {ShapeError} If yTrue and yPred have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If labels are not numeric (string or bigint)
+ * @throws {DataValidationError} If labels contain NaN or infinite values
+ * @throws {InvalidParameterError} If average is invalid or binary labels are not in {0,1}
+ *
+ * @example
+ * ```ts
+ * import { precision, tensor } from 'deepbox/core';
+ *
+ * // Binary classification
+ * const yTrue = tensor([0, 1, 1, 0, 1]);
+ * const yPred = tensor([0, 1, 0, 0, 1]);
+ * const prec = precision(yTrue, yPred); // 1.0 (2 TP, 0 FP)
+ *
+ * // Multiclass
+ * const yTrueMulti = tensor([0, 1, 2, 0, 1, 2]);
+ * const yPredMulti = tensor([0, 2, 1, 0, 0, 1]);
+ * const precMacro = precision(yTrueMulti, yPredMulti, 'macro');
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_score.html | Scikit-learn precision_score}
+ */
+declare function precision(yTrue: Tensor, yPred: Tensor): number;
+declare function precision(yTrue: Tensor, yPred: Tensor, average: "binary" | "micro" | "macro" | "weighted"): number;
+declare function precision(yTrue: Tensor, yPred: Tensor, average: null): number[];
+/**
+ * Calculates the recall classification score (sensitivity, true positive rate).
+ *
+ * Recall is the ratio of true positives to all actual positive samples.
+ * It answers: "Of all actual positive samples, how many did we correctly identify?"
+ * High recall means low false negative rate.
+ *
+ * **Formula**: recall = TP / (TP + FN)
+ *
+ * **Time Complexity**: O(n) for binary, O(n*k) for multiclass where k is number of classes
+ * **Space Complexity**: O(k) for multiclass
+ *
+ * @param yTrue - Ground truth (correct) target values
+ * @param yPred - Estimated targets as returned by a classifier
+ * @param average - Averaging strategy: 'binary', 'micro', 'macro', 'weighted', or null
+ * @returns Recall score(s) in range [0, 1]
+ *
+ * @throws {ShapeError} If yTrue and yPred have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If labels are not numeric (string or bigint)
+ * @throws {DataValidationError} If labels contain NaN or infinite values
+ * @throws {InvalidParameterError} If average is invalid or binary labels are not in {0,1}
+ *
+ * @example
+ * ```ts
+ * import { recall, tensor } from 'deepbox/core';
+ *
+ * const yTrue = tensor([0, 1, 1, 0, 1]);
+ * const yPred = tensor([0, 1, 0, 0, 1]);
+ * const rec = recall(yTrue, yPred); // 0.667 (2 out of 3 positives found)
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.recall_score.html | Scikit-learn recall_score}
+ */
+declare function recall(yTrue: Tensor, yPred: Tensor): number;
+declare function recall(yTrue: Tensor, yPred: Tensor, average: "binary" | "micro" | "macro" | "weighted"): number;
+declare function recall(yTrue: Tensor, yPred: Tensor, average: null): number[];
+/**
+ * Calculates the F1 score (harmonic mean of precision and recall).
+ *
+ * F1 score is the harmonic mean of precision and recall, providing a single
+ * metric that balances both concerns. It's especially useful when you need
+ * to balance false positives and false negatives.
+ *
+ * **Formula**: F1 = 2 * (precision * recall) / (precision + recall)
+ *
+ * **Time Complexity**: O(n) for binary, O(n*k) for multiclass
+ * **Space Complexity**: O(k) for multiclass
+ *
+ * @param yTrue - Ground truth (correct) target values
+ * @param yPred - Estimated targets as returned by a classifier
+ * @param average - Averaging strategy: 'binary', 'micro', 'macro', 'weighted', or null
+ * @returns F1 score(s) in range [0, 1]
+ *
+ * @throws {ShapeError} If yTrue and yPred have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If labels are not numeric (string or bigint)
+ * @throws {DataValidationError} If labels contain NaN or infinite values
+ * @throws {InvalidParameterError} If average is invalid or binary labels are not in {0,1}
+ *
+ * @example
+ * ```ts
+ * import { f1Score, tensor } from 'deepbox/core';
+ *
+ * const yTrue = tensor([0, 1, 1, 0, 1]);
+ * const yPred = tensor([0, 1, 0, 0, 1]);
+ * const f1 = f1Score(yTrue, yPred); // 0.8
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html | Scikit-learn f1_score}
+ */
+declare function f1Score(yTrue: Tensor, yPred: Tensor): number;
+declare function f1Score(yTrue: Tensor, yPred: Tensor, average: "binary" | "micro" | "macro" | "weighted"): number;
+declare function f1Score(yTrue: Tensor, yPred: Tensor, average: null): number[];
+/**
+ * Calculates the F-beta score.
+ *
+ * F-beta score is a weighted harmonic mean of precision and recall, where
+ * beta controls the trade-off between precision and recall.
+ * - beta < 1: More weight on precision
+ * - beta = 1: Equal weight (equivalent to F1 score)
+ * - beta > 1: More weight on recall
+ *
+ * **Formula**: F_beta = (1 + beta²) * (precision * recall) / (beta² * precision + recall)
+ *
+ * **Time Complexity**: O(n) for binary, O(n*k) for multiclass
+ * **Space Complexity**: O(k) for multiclass
+ *
+ * @param yTrue - Ground truth (correct) target values
+ * @param yPred - Estimated targets as returned by a classifier
+ * @param beta - Weight of recall vs precision (beta > 1 favors recall, beta < 1 favors precision)
+ * @param average - Averaging strategy: 'binary', 'micro', 'macro', 'weighted', or null
+ * @returns F-beta score(s) in range [0, 1]
+ *
+ * @throws {ShapeError} If yTrue and yPred have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If labels are not numeric (string or bigint)
+ * @throws {DataValidationError} If labels contain NaN or infinite values
+ *
+ * @example
+ * ```ts
+ * import { fbetaScore, tensor } from 'deepbox/core';
+ *
+ * const yTrue = tensor([0, 1, 1, 0, 1]);
+ * const yPred = tensor([0, 1, 0, 0, 1]);
+ * const fb2 = fbetaScore(yTrue, yPred, 2); // Favors recall
+ * const fb05 = fbetaScore(yTrue, yPred, 0.5); // Favors precision
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.fbeta_score.html | Scikit-learn fbeta_score}
+ */
+declare function fbetaScore(yTrue: Tensor, yPred: Tensor, beta: number): number;
+declare function fbetaScore(yTrue: Tensor, yPred: Tensor, beta: number, average: "binary" | "micro" | "macro" | "weighted"): number;
+declare function fbetaScore(yTrue: Tensor, yPred: Tensor, beta: number, average: null): number[];
+/**
+ * Computes the confusion matrix to evaluate classification accuracy.
+ *
+ * A confusion matrix is a table showing the counts of correct and incorrect
+ * predictions broken down by each class. Rows represent true labels,
+ * columns represent predicted labels.
+ *
+ * **Time Complexity**: O(n + k²) where n is number of samples, k is number of classes
+ * **Space Complexity**: O(k²)
+ *
+ * @param yTrue - Ground truth (correct) target values
+ * @param yPred - Estimated targets as returned by a classifier
+ * @returns Confusion matrix as a 2D tensor of shape [n_classes, n_classes]
+ *
+ * @throws {ShapeError} If yTrue and yPred have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If labels are not numeric (string or bigint)
+ * @throws {DataValidationError} If labels contain NaN or infinite values
+ *
+ * @example
+ * ```ts
+ * import { confusionMatrix, tensor } from 'deepbox/core';
+ *
+ * const yTrue = tensor([0, 1, 1, 0, 1]);
+ * const yPred = tensor([0, 1, 0, 0, 1]);
+ * const cm = confusionMatrix(yTrue, yPred);
+ * // [[2, 0],
+ * //  [1, 2]]
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.confusion_matrix.html | Scikit-learn confusion_matrix}
+ */
+declare function confusionMatrix(yTrue: Tensor, yPred: Tensor): Tensor;
+/**
+ * Generates a text classification report showing main classification metrics.
+ *
+ * Provides a comprehensive summary including precision, recall, F1-score,
+ * and accuracy for the classification task.
+ *
+ * **Time Complexity**: O(n * k) where n is the number of samples and k is the number of classes
+ * **Space Complexity**: O(k) where k is the number of classes
+ *
+ * @param yTrue - Ground truth (correct) binary target values (0 or 1)
+ * @param yPred - Estimated binary targets as returned by a classifier (0 or 1)
+ * @returns Formatted string report with per-class and aggregate classification metrics
+ *
+ * @throws {ShapeError} If yTrue and yPred have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If labels are not numeric (string or int64)
+ * @throws {DataValidationError} If labels contain NaN or infinite values
+ * @throws {InvalidParameterError} If labels are not binary (0 or 1)
+ *
+ * @example
+ * ```ts
+ * import { classificationReport, tensor } from 'deepbox/core';
+ *
+ * const yTrue = tensor([0, 1, 1, 0, 1]);
+ * const yPred = tensor([0, 1, 0, 0, 1]);
+ * console.log(classificationReport(yTrue, yPred));
+ * // Classification Report:
+ * //   Precision: 1.0000
+ * //   Recall:    0.6667
+ * //   F1-Score:  0.8000
+ * //   Accuracy:  0.8000
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.classification_report.html | Scikit-learn classification_report}
+ */
+declare function classificationReport(yTrue: Tensor, yPred: Tensor): string;
+/**
+ * ROC curve data.
+ *
+ * Computes Receiver Operating Characteristic (ROC) curve for binary classification.
+ * The ROC curve shows the trade-off between true positive rate and false positive rate
+ * at various threshold settings.
+ *
+ * **Returns**: [fpr, tpr, thresholds]
+ * - fpr: False positive rates
+ * - tpr: True positive rates
+ * - thresholds: Decision thresholds (in descending order)
+ *
+ * **Edge Cases**:
+ * - Returns empty tensors if yTrue contains only one class
+ * - Handles tied scores by grouping them at the same threshold
+ *
+ * @param yTrue - Ground truth binary labels (must be 0 or 1)
+ * @param yScore - Target scores (higher score = more likely positive class)
+ * @returns Tuple of [fpr, tpr, thresholds] tensors
+ *
+ * @throws {ShapeError} If yTrue and yScore have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If inputs are not numeric (string or int64)
+ * @throws {InvalidParameterError} If yTrue contains non-binary values
+ * @throws {DataValidationError} If inputs contain NaN or infinite values
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_curve.html | Scikit-learn roc_curve}
+ */
+declare function rocCurve(yTrue: Tensor, yScore: Tensor): [Tensor, Tensor, Tensor];
+/**
+ * Area Under ROC Curve (AUC-ROC).
+ *
+ * Computes the Area Under the Receiver Operating Characteristic Curve.
+ * AUC represents the probability that a randomly chosen positive sample
+ * is ranked higher than a randomly chosen negative sample.
+ *
+ * **Range**: [0, 1], where 1 is perfect and 0.5 is random.
+ *
+ * **Time Complexity**: O(n log n) due to sorting
+ * **Space Complexity**: O(n)
+ *
+ * @param yTrue - Ground truth binary labels (must be 0 or 1)
+ * @param yScore - Target scores (higher score = more likely positive class)
+ * @returns AUC score in range [0, 1], or 0.5 if ROC curve cannot be computed
+ *
+ * @throws {ShapeError} If yTrue and yScore have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If inputs are not numeric (string or int64)
+ * @throws {InvalidParameterError} If yTrue contains non-binary values
+ * @throws {DataValidationError} If inputs contain NaN or infinite values
+ *
+ * @example
+ * ```ts
+ * import { rocAucScore, tensor } from 'deepbox/metrics';
+ *
+ * const yTrue = tensor([0, 0, 1, 1]);
+ * const yScore = tensor([0.1, 0.4, 0.35, 0.8]);
+ * const auc = rocAucScore(yTrue, yScore); // ~0.75
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_auc_score.html | Scikit-learn roc_auc_score}
+ */
+declare function rocAucScore(yTrue: Tensor, yScore: Tensor): number;
+/**
+ * Precision-Recall curve.
+ *
+ * Computes precision-recall pairs for different probability thresholds.
+ * Useful for evaluating classifiers on imbalanced datasets where ROC curves
+ * may be overly optimistic.
+ *
+ * **Returns**: [precision, recall, thresholds] as a tuple of tensors
+ * - precision: Precision values at each threshold
+ * - recall: Recall values at each threshold
+ * - thresholds: Decision thresholds (in descending order)
+ *
+ * **Time Complexity**: O(n log n) due to sorting
+ * **Space Complexity**: O(n)
+ *
+ * @param yTrue - Ground truth binary labels (0 or 1)
+ * @param yScore - Target scores (higher score = more likely positive class)
+ * @returns Tuple of [precision, recall, thresholds] tensors
+ *
+ * @throws {ShapeError} If yTrue and yScore have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If inputs are not numeric (string or int64)
+ * @throws {InvalidParameterError} If yTrue contains non-binary values
+ * @throws {DataValidationError} If inputs contain NaN or infinite values
+ *
+ * @example
+ * ```ts
+ * import { precisionRecallCurve, tensor } from 'deepbox/metrics';
+ *
+ * const yTrue = tensor([0, 0, 1, 1]);
+ * const yScore = tensor([0.1, 0.4, 0.35, 0.8]);
+ * const [prec, rec, thresh] = precisionRecallCurve(yTrue, yScore);
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_recall_curve.html | Scikit-learn precision_recall_curve}
+ */
+declare function precisionRecallCurve(yTrue: Tensor, yScore: Tensor): [Tensor, Tensor, Tensor];
+/**
+ * Average precision score.
+ *
+ * Computes the average precision (AP) from prediction scores. AP summarizes
+ * a precision-recall curve as the weighted mean of precisions achieved at
+ * each threshold, with the increase in recall from the previous threshold
+ * used as the weight.
+ *
+ * **Range**: [0, 1], where 1 is perfect.
+ *
+ * **Time Complexity**: O(n log n) due to sorting
+ * **Space Complexity**: O(n)
+ *
+ * @param yTrue - Ground truth binary labels (0 or 1)
+ * @param yScore - Target scores (higher score = more likely positive class)
+ * @returns Average precision score in range [0, 1]
+ *
+ * @throws {ShapeError} If yTrue and yScore have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If inputs are not numeric (string or int64)
+ * @throws {InvalidParameterError} If yTrue contains non-binary values
+ * @throws {DataValidationError} If inputs contain NaN or infinite values
+ *
+ * @example
+ * ```ts
+ * import { averagePrecisionScore, tensor } from 'deepbox/metrics';
+ *
+ * const yTrue = tensor([0, 0, 1, 1]);
+ * const yScore = tensor([0.1, 0.4, 0.35, 0.8]);
+ * const ap = averagePrecisionScore(yTrue, yScore);
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.average_precision_score.html | Scikit-learn average_precision_score}
+ */
+declare function averagePrecisionScore(yTrue: Tensor, yScore: Tensor): number;
+/**
+ * Log loss (logistic loss, cross-entropy loss).
+ *
+ * Measures the performance of a classification model where the prediction is a probability
+ * value between 0 and 1. Lower log loss indicates better predictions.
+ *
+ * **Formula**: -1/n * Σ(y_true * log(y_pred) + (1 - y_true) * log(1 - y_pred))
+ *
+ * **Edge Cases**:
+ * - Predictions are clipped to [1e-15, 1-1e-15] to avoid log(0)
+ * - Returns 0 for empty inputs
+ *
+ * @param yTrue - Ground truth binary labels (0 or 1)
+ * @param yPred - Predicted probabilities (must be in range [0, 1])
+ * @returns Log loss value (lower is better, 0 is perfect)
+ *
+ * @throws {ShapeError} If yTrue and yPred have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If inputs are not numeric (string or int64)
+ * @throws {InvalidParameterError} If yTrue is not binary or yPred is outside [0, 1]
+ * @throws {DataValidationError} If inputs contain NaN or infinite values
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.log_loss.html | Scikit-learn log_loss}
+ */
+declare function logLoss(yTrue: Tensor, yPred: Tensor): number;
+/**
+ * Hamming loss.
+ *
+ * Computes the fraction of labels that are incorrectly predicted.
+ * For binary classification, this equals 1 - accuracy.
+ *
+ * **Formula**: hamming_loss = (incorrect predictions) / (total predictions)
+ *
+ * **Range**: [0, 1], where 0 is perfect.
+ *
+ * **Time Complexity**: O(n)
+ * **Space Complexity**: O(1)
+ *
+ * @param yTrue - Ground truth target values
+ * @param yPred - Estimated targets as returned by a classifier
+ * @returns Hamming loss in range [0, 1]
+ *
+ * @throws {ShapeError} If yTrue and yPred have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If yTrue and yPred use incompatible label types
+ * @throws {DataValidationError} If numeric labels contain NaN or infinite values
+ *
+ * @example
+ * ```ts
+ * import { hammingLoss, tensor } from 'deepbox/metrics';
+ *
+ * const yTrue = tensor([0, 1, 1, 0, 1]);
+ * const yPred = tensor([0, 1, 0, 0, 1]);
+ * const loss = hammingLoss(yTrue, yPred); // 0.2
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.hamming_loss.html | Scikit-learn hamming_loss}
+ */
+declare function hammingLoss(yTrue: Tensor, yPred: Tensor): number;
+/**
+ * Jaccard similarity score (Intersection over Union).
+ *
+ * Computes the Jaccard similarity coefficient between two binary label sets.
+ * Also known as the Jaccard index or Intersection over Union (IoU).
+ *
+ * **Formula**: jaccard = TP / (TP + FP + FN)
+ *
+ * **Edge Cases**:
+ * - If both yTrue and yPred contain no positive labels (TP + FP + FN = 0),
+ *   returns 1 to reflect perfect similarity of empty sets.
+ *
+ * **Range**: [0, 1], where 1 is perfect.
+ *
+ * **Time Complexity**: O(n)
+ * **Space Complexity**: O(1)
+ *
+ * @param yTrue - Ground truth binary labels (0 or 1)
+ * @param yPred - Predicted binary labels (0 or 1)
+ * @returns Jaccard score in range [0, 1]
+ *
+ * @throws {ShapeError} If yTrue and yPred have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If labels are not numeric (string or bigint)
+ * @throws {DataValidationError} If labels contain NaN or infinite values
+ * @throws {InvalidParameterError} If labels are not binary (0 or 1)
+ *
+ * @example
+ * ```ts
+ * import { jaccardScore, tensor } from 'deepbox/metrics';
+ *
+ * const yTrue = tensor([0, 1, 1, 0, 1]);
+ * const yPred = tensor([0, 1, 0, 0, 1]);
+ * const score = jaccardScore(yTrue, yPred); // 0.667
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.jaccard_score.html | Scikit-learn jaccard_score}
+ */
+declare function jaccardScore(yTrue: Tensor, yPred: Tensor): number;
+/**
+ * Matthews correlation coefficient (MCC).
+ *
+ * Computes the Matthews correlation coefficient, a balanced measure that
+ * can be used even if the classes are of very different sizes. MCC is
+ * considered one of the best metrics for binary classification.
+ *
+ * **Formula**: MCC = (TP*TN - FP*FN) / sqrt((TP+FP)(TP+FN)(TN+FP)(TN+FN))
+ *
+ * **Range**: [-1, 1], where 1 is perfect, 0 is random, -1 is inverse.
+ *
+ * **Time Complexity**: O(n)
+ * **Space Complexity**: O(1)
+ *
+ * @param yTrue - Ground truth binary labels (0 or 1)
+ * @param yPred - Predicted binary labels (0 or 1)
+ * @returns MCC score in range [-1, 1]
+ *
+ * @throws {ShapeError} If yTrue and yPred have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If labels are not numeric (string or bigint)
+ * @throws {DataValidationError} If labels contain NaN or infinite values
+ *
+ * @example
+ * ```ts
+ * import { matthewsCorrcoef, tensor } from 'deepbox/metrics';
+ *
+ * const yTrue = tensor([0, 1, 1, 0, 1]);
+ * const yPred = tensor([0, 1, 0, 0, 1]);
+ * const mcc = matthewsCorrcoef(yTrue, yPred); // ~0.667
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.matthews_corrcoef.html | Scikit-learn matthews_corrcoef}
+ */
+declare function matthewsCorrcoef(yTrue: Tensor, yPred: Tensor): number;
+/**
+ * Cohen's kappa score.
+ *
+ * Computes Cohen's kappa, a statistic that measures inter-annotator agreement.
+ * It is generally thought to be a more robust measure than simple percent
+ * agreement since it takes into account the possibility of agreement by chance.
+ *
+ * **Formula**: kappa = (p_o - p_e) / (1 - p_e)
+ * - p_o: observed agreement
+ * - p_e: expected agreement by chance
+ *
+ * **Range**: [-1, 1], where 1 is perfect agreement, 0 is chance, <0 is worse than chance.
+ *
+ * **Time Complexity**: O(n)
+ * **Space Complexity**: O(k) where k is number of classes
+ *
+ * @param yTrue - Ground truth labels
+ * @param yPred - Predicted labels
+ * @returns Kappa score in range [-1, 1]
+ *
+ * @throws {ShapeError} If yTrue and yPred have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If labels are not numeric (string or bigint)
+ * @throws {DataValidationError} If labels contain NaN or infinite values
+ *
+ * @example
+ * ```ts
+ * import { cohenKappaScore, tensor } from 'deepbox/metrics';
+ *
+ * const yTrue = tensor([0, 1, 1, 0, 1]);
+ * const yPred = tensor([0, 1, 0, 0, 1]);
+ * const kappa = cohenKappaScore(yTrue, yPred); // ~0.615
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.cohen_kappa_score.html | Scikit-learn cohen_kappa_score}
+ */
+declare function cohenKappaScore(yTrue: Tensor, yPred: Tensor): number;
+/**
+ * Balanced accuracy score.
+ *
+ * Computes the balanced accuracy, which is the macro-averaged recall.
+ * It is useful for imbalanced datasets where regular accuracy can be misleading.
+ *
+ * **Formula**: balanced_accuracy = (1/n_classes) * Σ(recall_per_class)
+ *
+ * **Range**: [0, 1], where 1 is perfect.
+ *
+ * **Time Complexity**: O(n * k) where k is number of classes
+ * **Space Complexity**: O(k)
+ *
+ * @param yTrue - Ground truth labels
+ * @param yPred - Predicted labels
+ * @returns Balanced accuracy score in range [0, 1]
+ *
+ * @throws {ShapeError} If yTrue and yPred have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If labels are not numeric (string or bigint)
+ * @throws {DataValidationError} If labels contain NaN or infinite values
+ *
+ * @example
+ * ```ts
+ * import { balancedAccuracyScore, tensor } from 'deepbox/metrics';
+ *
+ * const yTrue = tensor([0, 0, 0, 0, 1]); // Imbalanced
+ * const yPred = tensor([0, 0, 0, 0, 0]); // Predicts all 0
+ * const bacc = balancedAccuracyScore(yTrue, yPred); // 0.5 (not 0.8!)
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.balanced_accuracy_score.html | Scikit-learn balanced_accuracy_score}
+ */
+declare function balancedAccuracyScore(yTrue: Tensor, yPred: Tensor): number;
+
+type AverageMethod = "min" | "geometric" | "arithmetic" | "max";
+type SilhouetteMetric = "euclidean" | "precomputed";
+/**
+ * Computes the mean Silhouette Coefficient over all samples.
+ *
+ * The Silhouette Coefficient for a sample measures how similar it is to its own
+ * cluster compared to other clusters. Values range from -1 to 1, where higher
+ * values indicate better-defined clusters.
+ *
+ * **Formula**: s(i) = (b(i) - a(i)) / max(a(i), b(i))
+ * - a(i): mean intra-cluster distance for sample i
+ * - b(i): mean nearest-cluster distance for sample i
+ *
+ * **Time Complexity**: O(n²) where n is the number of samples
+ * **Space Complexity**: O(n + k) where k is the number of clusters
+ *
+ * @param X - Feature matrix of shape [n_samples, n_features], or a precomputed distance matrix
+ * @param labels - Cluster labels for each sample
+ * @param metric - Distance metric: 'euclidean' (default) or 'precomputed'
+ * @param options - Optional parameters
+ * @param options.sampleSize - Number of samples to use for approximation (required when n > 2000)
+ * @param options.randomState - Seed for reproducible sampling
+ * @returns Mean silhouette coefficient in range [-1, 1]
+ *
+ * @throws {InvalidParameterError} If fewer than 2 samples, invalid sampleSize, or unsupported metric
+ * @throws {ShapeError} If labels length doesn't match samples, or X shape is invalid
+ * @throws {DTypeError} If labels are string or X is non-numeric
+ * @throws {DataValidationError} If X contains non-finite values
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.silhouette_score.html | Scikit-learn silhouette_score}
+ */
+declare function silhouetteScore(X: Tensor, labels: Tensor, metric?: SilhouetteMetric, options?: {
+    sampleSize?: number;
+    randomState?: number;
+}): number;
+/**
+ * Computes the Silhouette Coefficient for each sample.
+ *
+ * Returns a tensor of per-sample silhouette values. Useful for identifying
+ * samples that are well-clustered vs. poorly-clustered.
+ *
+ * **Time Complexity**: O(n²) where n is the number of samples
+ * **Space Complexity**: O(n + k) where k is the number of clusters
+ *
+ * @param X - Feature matrix of shape [n_samples, n_features], or a precomputed distance matrix
+ * @param labels - Cluster labels for each sample
+ * @param metric - Distance metric: 'euclidean' (default) or 'precomputed'
+ * @returns Tensor of silhouette coefficients in range [-1, 1] for each sample
+ *
+ * @throws {InvalidParameterError} If fewer than 2 samples or unsupported metric
+ * @throws {ShapeError} If labels length doesn't match samples, or X shape is invalid
+ * @throws {DTypeError} If labels are string or X is non-numeric
+ * @throws {DataValidationError} If X contains non-finite values
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.silhouette_samples.html | Scikit-learn silhouette_samples}
+ */
+declare function silhouetteSamples(X: Tensor, labels: Tensor, metric?: SilhouetteMetric): Tensor;
+/**
+ * Computes the Davies-Bouldin index.
+ *
+ * The Davies-Bouldin index measures the average similarity ratio of each cluster
+ * with its most similar cluster. Lower values indicate better clustering.
+ * Returns 0 when k < 2 or n_samples == 0.
+ *
+ * **Time Complexity**: O(n * d + k² * d) where n is samples, d is features, k is clusters
+ * **Space Complexity**: O(k * d)
+ *
+ * @param X - Feature matrix of shape [n_samples, n_features]
+ * @param labels - Cluster labels for each sample
+ * @returns Davies-Bouldin index (lower is better, 0 is minimum)
+ *
+ * @throws {ShapeError} If labels length doesn't match samples, or X shape is invalid
+ * @throws {DTypeError} If labels are string or X is non-numeric
+ * @throws {DataValidationError} If X contains non-finite values
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.davies_bouldin_score.html | Scikit-learn davies_bouldin_score}
+ */
+declare function daviesBouldinScore(X: Tensor, labels: Tensor): number;
+/**
+ * Computes the Calinski-Harabasz index (Variance Ratio Criterion).
+ *
+ * The score is the ratio of between-cluster dispersion to within-cluster
+ * dispersion. Higher values indicate better-defined clusters.
+ * Returns 0 when k < 2, n_samples == 0, or within-group sum of squares is 0.
+ *
+ * **Time Complexity**: O(n * d) where n is samples and d is features
+ * **Space Complexity**: O(k * d) where k is clusters
+ *
+ * @param X - Feature matrix of shape [n_samples, n_features]
+ * @param labels - Cluster labels for each sample
+ * @returns Calinski-Harabasz index (higher is better)
+ *
+ * @throws {ShapeError} If labels length doesn't match samples, or X shape is invalid
+ * @throws {DTypeError} If labels are string or X is non-numeric
+ * @throws {DataValidationError} If X contains non-finite values
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.calinski_harabasz_score.html | Scikit-learn calinski_harabasz_score}
+ */
+declare function calinskiHarabaszScore(X: Tensor, labels: Tensor): number;
+/**
+ * Computes the Adjusted Rand Index (ARI).
+ *
+ * The ARI measures the similarity between two clusterings, adjusted for chance.
+ * It ranges from -1 to 1, where 1 indicates perfect agreement, 0 indicates
+ * random labeling, and negative values indicate worse than random.
+ *
+ * **Time Complexity**: O(n + k₁ * k₂) where k₁, k₂ are cluster counts
+ * **Space Complexity**: O(k₁ * k₂)
+ *
+ * @param labelsTrue - Ground truth cluster labels
+ * @param labelsPred - Predicted cluster labels
+ * @returns Adjusted Rand Index in range [-1, 1]
+ *
+ * @throws {ShapeError} If labelsTrue and labelsPred have different sizes
+ * @throws {DTypeError} If labels are string
+ * @throws {DataValidationError} If labels contain non-finite or non-integer values
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.adjusted_rand_score.html | Scikit-learn adjusted_rand_score}
+ */
+declare function adjustedRandScore(labelsTrue: Tensor, labelsPred: Tensor): number;
+/**
+ * Computes the Adjusted Mutual Information (AMI) between two clusterings.
+ *
+ * AMI adjusts the Mutual Information score to account for chance, providing
+ * a normalized measure of agreement between two clusterings.
+ *
+ * **Time Complexity**: O(n + k₁ * k₂ * min(k₁, k₂))
+ * **Space Complexity**: O(k₁ * k₂ + n)
+ *
+ * @param labelsTrue - Ground truth cluster labels
+ * @param labelsPred - Predicted cluster labels
+ * @param averageMethod - Method to compute the normalizer: 'min', 'geometric', 'arithmetic' (default), or 'max'
+ * @returns Adjusted Mutual Information score, typically in range [0, 1]
+ *
+ * @throws {ShapeError} If labelsTrue and labelsPred have different sizes
+ * @throws {DTypeError} If labels are string
+ * @throws {DataValidationError} If labels contain non-finite or non-integer values
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.adjusted_mutual_info_score.html | Scikit-learn adjusted_mutual_info_score}
+ */
+declare function adjustedMutualInfoScore(labelsTrue: Tensor, labelsPred: Tensor, averageMethod?: AverageMethod): number;
+/**
+ * Computes the Normalized Mutual Information (NMI) between two clusterings.
+ *
+ * NMI normalizes the Mutual Information score to scale between 0 and 1,
+ * where 1 indicates perfect correlation between clusterings.
+ *
+ * **Time Complexity**: O(n + k₁ * k₂)
+ * **Space Complexity**: O(k₁ * k₂)
+ *
+ * @param labelsTrue - Ground truth cluster labels
+ * @param labelsPred - Predicted cluster labels
+ * @param averageMethod - Method to compute the normalizer: 'min', 'geometric', 'arithmetic' (default), or 'max'
+ * @returns Normalized Mutual Information score in range [0, 1]
+ *
+ * @throws {ShapeError} If labelsTrue and labelsPred have different sizes
+ * @throws {DTypeError} If labels are string
+ * @throws {DataValidationError} If labels contain non-finite or non-integer values
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.normalized_mutual_info_score.html | Scikit-learn normalized_mutual_info_score}
+ */
+declare function normalizedMutualInfoScore(labelsTrue: Tensor, labelsPred: Tensor, averageMethod?: AverageMethod): number;
+/**
+ * Computes the Fowlkes-Mallows Index (FMI).
+ *
+ * The FMI is the geometric mean of pairwise precision and recall.
+ * It ranges from 0 to 1, where 1 indicates perfect agreement.
+ *
+ * **Time Complexity**: O(n + k₁ * k₂)
+ * **Space Complexity**: O(k₁ * k₂)
+ *
+ * @param labelsTrue - Ground truth cluster labels
+ * @param labelsPred - Predicted cluster labels
+ * @returns Fowlkes-Mallows score in range [0, 1]
+ *
+ * @throws {ShapeError} If labelsTrue and labelsPred have different sizes
+ * @throws {DTypeError} If labels are string
+ * @throws {DataValidationError} If labels contain non-finite or non-integer values
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.fowlkes_mallows_score.html | Scikit-learn fowlkes_mallows_score}
+ */
+declare function fowlkesMallowsScore(labelsTrue: Tensor, labelsPred: Tensor): number;
+/**
+ * Computes the homogeneity score of a clustering.
+ *
+ * A clustering result satisfies homogeneity if all of its clusters contain
+ * only data points which are members of a single class. Score ranges from
+ * 0 to 1, where 1 indicates perfectly homogeneous clustering.
+ *
+ * **Time Complexity**: O(n + k₁ * k₂)
+ * **Space Complexity**: O(k₁ * k₂)
+ *
+ * @param labelsTrue - Ground truth class labels
+ * @param labelsPred - Predicted cluster labels
+ * @returns Homogeneity score in range [0, 1]
+ *
+ * @throws {ShapeError} If labelsTrue and labelsPred have different sizes
+ * @throws {DTypeError} If labels are string
+ * @throws {DataValidationError} If labels contain non-finite or non-integer values
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.homogeneity_score.html | Scikit-learn homogeneity_score}
+ */
+declare function homogeneityScore(labelsTrue: Tensor, labelsPred: Tensor): number;
+/**
+ * Computes the completeness score of a clustering.
+ *
+ * A clustering result satisfies completeness if all data points that are
+ * members of a given class are assigned to the same cluster. Score ranges
+ * from 0 to 1, where 1 indicates perfectly complete clustering.
+ *
+ * **Time Complexity**: O(n + k₁ * k₂)
+ * **Space Complexity**: O(k₁ * k₂)
+ *
+ * @param labelsTrue - Ground truth class labels
+ * @param labelsPred - Predicted cluster labels
+ * @returns Completeness score in range [0, 1]
+ *
+ * @throws {ShapeError} If labelsTrue and labelsPred have different sizes
+ * @throws {DTypeError} If labels are string
+ * @throws {DataValidationError} If labels contain non-finite or non-integer values
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.completeness_score.html | Scikit-learn completeness_score}
+ */
+declare function completenessScore(labelsTrue: Tensor, labelsPred: Tensor): number;
+/**
+ * Computes the V-measure score of a clustering.
+ *
+ * V-measure is the harmonic mean of homogeneity and completeness, controlled
+ * by the beta parameter. When beta > 1, completeness is weighted more; when
+ * beta < 1, homogeneity is weighted more.
+ *
+ * **Formula**: v = (1 + beta) * h * c / (beta * h + c)
+ *
+ * **Time Complexity**: O(n + k₁ * k₂)
+ * **Space Complexity**: O(k₁ * k₂)
+ *
+ * @param labelsTrue - Ground truth class labels
+ * @param labelsPred - Predicted cluster labels
+ * @param beta - Weight of homogeneity vs completeness (default: 1.0)
+ * @returns V-measure score in range [0, 1]
+ *
+ * @throws {ShapeError} If labelsTrue and labelsPred have different sizes
+ * @throws {DTypeError} If labels are string
+ * @throws {InvalidParameterError} If beta is not a positive finite number
+ * @throws {DataValidationError} If labels contain non-finite or non-integer values
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.v_measure_score.html | Scikit-learn v_measure_score}
+ */
+declare function vMeasureScore(labelsTrue: Tensor, labelsPred: Tensor, beta?: number): number;
+
+/**
+ * Calculate Mean Squared Error (MSE).
+ *
+ * Measures the average squared difference between predictions and actual values.
+ * MSE is sensitive to outliers due to squaring the errors.
+ *
+ * **Formula**: MSE = (1/n) * Σ(y_true - y_pred)²
+ *
+ * **Time Complexity**: O(n) where n is the number of samples
+ * **Space Complexity**: O(1)
+ *
+ * @param yTrue - Ground truth (correct) target values
+ * @param yPred - Estimated target values
+ * @returns MSE value (always non-negative, 0 is perfect)
+ *
+ * @throws {ShapeError} If yTrue and yPred have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If yTrue or yPred is non-numeric or int64
+ * @throws {DataValidationError} If inputs contain NaN or infinite values
+ *
+ * @example
+ * ```ts
+ * import { mse, tensor } from 'deepbox/metrics';
+ *
+ * const yTrue = tensor([3, -0.5, 2, 7]);
+ * const yPred = tensor([2.5, 0.0, 2, 8]);
+ * const error = mse(yTrue, yPred);  // 0.375
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html | Scikit-learn mean_squared_error}
+ */
+declare function mse(yTrue: Tensor, yPred: Tensor): number;
+/**
+ * Calculate Root Mean Squared Error (RMSE).
+ *
+ * Square root of MSE, expressed in the same units as the target variable.
+ * RMSE is more interpretable than MSE as it's in the original scale.
+ *
+ * **Formula**: RMSE = √(MSE) = √((1/n) * Σ(y_true - y_pred)²)
+ *
+ * **Time Complexity**: O(n) where n is the number of samples
+ * **Space Complexity**: O(1)
+ *
+ * @param yTrue - Ground truth (correct) target values
+ * @param yPred - Estimated target values
+ * @returns RMSE value (always non-negative, 0 is perfect)
+ *
+ * @throws {ShapeError} If yTrue and yPred have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If yTrue or yPred is non-numeric or int64
+ * @throws {DataValidationError} If inputs contain NaN or infinite values
+ *
+ * @example
+ * ```ts
+ * import { rmse, tensor } from 'deepbox/metrics';
+ *
+ * const yTrue = tensor([3, -0.5, 2, 7]);
+ * const yPred = tensor([2.5, 0.0, 2, 8]);
+ * const error = rmse(yTrue, yPred);  // √0.375 ≈ 0.612
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html | Scikit-learn mean_squared_error}
+ */
+declare function rmse(yTrue: Tensor, yPred: Tensor): number;
+/**
+ * Calculate Mean Absolute Error (MAE).
+ *
+ * Measures the average absolute difference between predictions and actual values.
+ * MAE is more robust to outliers than MSE.
+ *
+ * **Formula**: MAE = (1/n) * Σ|y_true - y_pred|
+ *
+ * **Time Complexity**: O(n) where n is the number of samples
+ * **Space Complexity**: O(1)
+ *
+ * @param yTrue - Ground truth (correct) target values
+ * @param yPred - Estimated target values
+ * @returns MAE value (always non-negative, 0 is perfect)
+ *
+ * @throws {ShapeError} If yTrue and yPred have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If yTrue or yPred is non-numeric or int64
+ * @throws {DataValidationError} If inputs contain NaN or infinite values
+ *
+ * @example
+ * ```ts
+ * import { mae, tensor } from 'deepbox/metrics';
+ *
+ * const yTrue = tensor([3, -0.5, 2, 7]);
+ * const yPred = tensor([2.5, 0.0, 2, 8]);
+ * const error = mae(yTrue, yPred);  // 0.5
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_absolute_error.html | Scikit-learn mean_absolute_error}
+ */
+declare function mae(yTrue: Tensor, yPred: Tensor): number;
+/**
+ * Calculate R² (coefficient of determination) score.
+ *
+ * Represents the proportion of variance in the target variable that is
+ * explained by the model. R² of 1 indicates perfect predictions, 0 indicates
+ * the model is no better than predicting the mean, and negative values indicate
+ * the model is worse than predicting the mean.
+ *
+ * **Formula**: R² = 1 - (SS_res / SS_tot)
+ * - SS_res = Σ(y_true - y_pred)² (residual sum of squares)
+ * - SS_tot = Σ(y_true - mean(y_true))² (total sum of squares)
+ *
+ * **Time Complexity**: O(n) where n is the number of samples
+ * **Space Complexity**: O(1)
+ *
+ * @param yTrue - Ground truth (correct) target values
+ * @param yPred - Estimated target values
+ * @returns R² score (1 is perfect, 0 is baseline, negative is worse than baseline)
+ *
+ * @throws {ShapeError} If yTrue and yPred have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If yTrue or yPred is non-numeric or int64
+ * @throws {InvalidParameterError} If inputs are empty
+ * @throws {DataValidationError} If inputs contain NaN or infinite values
+ *
+ * @example
+ * ```ts
+ * import { r2Score, tensor } from 'deepbox/metrics';
+ *
+ * const yTrue = tensor([3, -0.5, 2, 7]);
+ * const yPred = tensor([2.5, 0.0, 2, 8]);
+ * const score = r2Score(yTrue, yPred);  // Close to 1 for good fit
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.r2_score.html | Scikit-learn r2_score}
+ */
+declare function r2Score(yTrue: Tensor, yPred: Tensor): number;
+/**
+ * Calculate Adjusted R² score.
+ *
+ * R² adjusted for the number of features in the model. Penalizes the addition
+ * of features that don't improve the model. More appropriate than R² when
+ * comparing models with different numbers of features.
+ *
+ * **Formula**: Adjusted R² = 1 - ((1 - R²) * (n - 1)) / (n - p - 1)
+ * - n = number of samples
+ * - p = number of features
+ *
+ * **Time Complexity**: O(n) where n is the number of samples
+ * **Space Complexity**: O(1)
+ *
+ * **Constraints**: Requires n > p + 1 (more samples than features + 1)
+ *
+ * @param yTrue - Ground truth (correct) target values
+ * @param yPred - Estimated target values
+ * @param nFeatures - Number of features (predictors) used in the model
+ * @returns Adjusted R² score
+ *
+ * @throws {ShapeError} If yTrue and yPred have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If yTrue or yPred is non-numeric or int64
+ * @throws {InvalidParameterError} If nFeatures is not a non-negative integer, n <= p + 1, or inputs are empty
+ * @throws {DataValidationError} If inputs contain NaN or infinite values
+ *
+ * @example
+ * ```ts
+ * import { adjustedR2Score, tensor } from 'deepbox/metrics';
+ *
+ * const yTrue = tensor([3, -0.5, 2, 7]);
+ * const yPred = tensor([2.5, 0.0, 2, 8]);
+ * const score = adjustedR2Score(yTrue, yPred, 2);  // Adjusted for 2 features
+ * ```
+ *
+ * @see {@link https://en.wikipedia.org/wiki/Coefficient_of_determination#Adjusted_R2 | Wikipedia: Adjusted R²}
+ */
+declare function adjustedR2Score(yTrue: Tensor, yPred: Tensor, nFeatures: number): number;
+/**
+ * Calculate Mean Absolute Percentage Error (MAPE).
+ *
+ * Measures the average absolute percentage difference between predictions
+ * and actual values. Expressed as a percentage, making it scale-independent
+ * and easy to interpret.
+ *
+ * **Formula**: MAPE = (100/m) * Σ|((y_true - y_pred) / y_true)|
+ * where m is the number of non-zero targets.
+ *
+ * **Time Complexity**: O(n) where n is the number of samples
+ * **Space Complexity**: O(1)
+ *
+ * **Important**: Zero values in yTrue are skipped. If all targets are zero,
+ * this function returns 0.
+ *
+ * @param yTrue - Ground truth (correct) target values
+ * @param yPred - Estimated target values
+ * @returns MAPE value as percentage (0 is perfect, lower is better)
+ *
+ * @throws {ShapeError} If yTrue and yPred have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If yTrue or yPred is non-numeric or int64
+ * @throws {DataValidationError} If inputs contain NaN or infinite values
+ *
+ * @example
+ * ```ts
+ * import { mape, tensor } from 'deepbox/metrics';
+ *
+ * const yTrue = tensor([3, -0.5, 2, 7]);
+ * const yPred = tensor([2.5, 0.0, 2, 8]);
+ * const error = mape(yTrue, yPred);  // Percentage error
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_absolute_percentage_error.html | Scikit-learn MAPE}
+ */
+declare function mape(yTrue: Tensor, yPred: Tensor): number;
+/**
+ * Calculate Median Absolute Error (MedAE).
+ *
+ * Measures the median of absolute differences between predictions and actual values.
+ * More robust to outliers than MAE or MSE as it uses the median instead of mean.
+ *
+ * **Formula**: MedAE = median(|y_true - y_pred|)
+ *
+ * **Time Complexity**: O(n log n) due to sorting for median calculation
+ * **Space Complexity**: O(n) for storing error array
+ *
+ * @param yTrue - Ground truth (correct) target values
+ * @param yPred - Estimated target values
+ * @returns Median absolute error (always non-negative, 0 is perfect)
+ *
+ * @throws {ShapeError} If yTrue and yPred have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If yTrue or yPred is non-numeric or int64
+ * @throws {DataValidationError} If inputs contain NaN or infinite values
+ *
+ * @example
+ * ```ts
+ * import { medianAbsoluteError, tensor } from 'deepbox/metrics';
+ *
+ * const yTrue = tensor([3, -0.5, 2, 7]);
+ * const yPred = tensor([2.5, 0.0, 2, 8]);
+ * const error = medianAbsoluteError(yTrue, yPred);
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.median_absolute_error.html | Scikit-learn median_absolute_error}
+ */
+declare function medianAbsoluteError(yTrue: Tensor, yPred: Tensor): number;
+/**
+ * Calculate maximum residual error.
+ *
+ * Returns the maximum absolute difference between predictions and actual values.
+ * Useful for identifying the worst-case prediction error.
+ *
+ * **Formula**: max_error = max(|y_true - y_pred|)
+ *
+ * **Time Complexity**: O(n) where n is the number of samples
+ * **Space Complexity**: O(1)
+ *
+ * @param yTrue - Ground truth (correct) target values
+ * @param yPred - Estimated target values
+ * @returns Maximum absolute error (always non-negative, 0 is perfect)
+ *
+ * @throws {ShapeError} If yTrue and yPred have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If yTrue or yPred is non-numeric or int64
+ * @throws {DataValidationError} If inputs contain NaN or infinite values
+ *
+ * @example
+ * ```ts
+ * import { maxError, tensor } from 'deepbox/metrics';
+ *
+ * const yTrue = tensor([3, -0.5, 2, 7]);
+ * const yPred = tensor([2.5, 0.0, 2, 8]);
+ * const error = maxError(yTrue, yPred);  // 1.0 (worst prediction)
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.max_error.html | Scikit-learn max_error}
+ */
+declare function maxError(yTrue: Tensor, yPred: Tensor): number;
+/**
+ * Calculate explained variance score.
+ *
+ * Measures the proportion of variance in the target variable that is explained
+ * by the model. Similar to R² but uses variance instead of sum of squares.
+ * Best possible score is 1.0, lower values are worse.
+ *
+ * **Formula**: explained_variance = 1 - Var(y_true - y_pred) / Var(y_true)
+ *
+ * **Time Complexity**: O(n) where n is the number of samples
+ * **Space Complexity**: O(1)
+ *
+ * @param yTrue - Ground truth (correct) target values
+ * @param yPred - Estimated target values
+ * @returns Explained variance score (1.0 is perfect, lower is worse)
+ *
+ * @throws {ShapeError} If yTrue and yPred have different sizes or are not 1D/column vectors
+ * @throws {DTypeError} If yTrue or yPred is non-numeric or int64
+ * @throws {InvalidParameterError} If inputs are empty
+ * @throws {DataValidationError} If inputs contain NaN or infinite values
+ *
+ * @example
+ * ```ts
+ * import { explainedVarianceScore, tensor } from 'deepbox/metrics';
+ *
+ * const yTrue = tensor([3, -0.5, 2, 7]);
+ * const yPred = tensor([2.5, 0.0, 2, 8]);
+ * const score = explainedVarianceScore(yTrue, yPred);
+ * ```
+ *
+ * @see {@link https://scikit-learn.org/stable/modules/generated/sklearn.metrics.explained_variance_score.html | Scikit-learn explained_variance_score}
+ */
+declare function explainedVarianceScore(yTrue: Tensor, yPred: Tensor): number;
+
+declare const index_accuracy: typeof accuracy;
+declare const index_adjustedMutualInfoScore: typeof adjustedMutualInfoScore;
+declare const index_adjustedR2Score: typeof adjustedR2Score;
+declare const index_adjustedRandScore: typeof adjustedRandScore;
+declare const index_averagePrecisionScore: typeof averagePrecisionScore;
+declare const index_balancedAccuracyScore: typeof balancedAccuracyScore;
+declare const index_calinskiHarabaszScore: typeof calinskiHarabaszScore;
+declare const index_classificationReport: typeof classificationReport;
+declare const index_cohenKappaScore: typeof cohenKappaScore;
+declare const index_completenessScore: typeof completenessScore;
+declare const index_confusionMatrix: typeof confusionMatrix;
+declare const index_daviesBouldinScore: typeof daviesBouldinScore;
+declare const index_explainedVarianceScore: typeof explainedVarianceScore;
+declare const index_f1Score: typeof f1Score;
+declare const index_fbetaScore: typeof fbetaScore;
+declare const index_fowlkesMallowsScore: typeof fowlkesMallowsScore;
+declare const index_hammingLoss: typeof hammingLoss;
+declare const index_homogeneityScore: typeof homogeneityScore;
+declare const index_jaccardScore: typeof jaccardScore;
+declare const index_logLoss: typeof logLoss;
+declare const index_mae: typeof mae;
+declare const index_mape: typeof mape;
+declare const index_matthewsCorrcoef: typeof matthewsCorrcoef;
+declare const index_maxError: typeof maxError;
+declare const index_medianAbsoluteError: typeof medianAbsoluteError;
+declare const index_mse: typeof mse;
+declare const index_normalizedMutualInfoScore: typeof normalizedMutualInfoScore;
+declare const index_precision: typeof precision;
+declare const index_precisionRecallCurve: typeof precisionRecallCurve;
+declare const index_r2Score: typeof r2Score;
+declare const index_recall: typeof recall;
+declare const index_rmse: typeof rmse;
+declare const index_rocAucScore: typeof rocAucScore;
+declare const index_rocCurve: typeof rocCurve;
+declare const index_silhouetteSamples: typeof silhouetteSamples;
+declare const index_silhouetteScore: typeof silhouetteScore;
+declare const index_vMeasureScore: typeof vMeasureScore;
+declare namespace index {
+  export { index_accuracy as accuracy, index_adjustedMutualInfoScore as adjustedMutualInfoScore, index_adjustedR2Score as adjustedR2Score, index_adjustedRandScore as adjustedRandScore, index_averagePrecisionScore as averagePrecisionScore, index_balancedAccuracyScore as balancedAccuracyScore, index_calinskiHarabaszScore as calinskiHarabaszScore, index_classificationReport as classificationReport, index_cohenKappaScore as cohenKappaScore, index_completenessScore as completenessScore, index_confusionMatrix as confusionMatrix, index_daviesBouldinScore as daviesBouldinScore, index_explainedVarianceScore as explainedVarianceScore, index_f1Score as f1Score, index_fbetaScore as fbetaScore, index_fowlkesMallowsScore as fowlkesMallowsScore, index_hammingLoss as hammingLoss, index_homogeneityScore as homogeneityScore, index_jaccardScore as jaccardScore, index_logLoss as logLoss, index_mae as mae, index_mape as mape, index_matthewsCorrcoef as matthewsCorrcoef, index_maxError as maxError, index_medianAbsoluteError as medianAbsoluteError, index_mse as mse, index_normalizedMutualInfoScore as normalizedMutualInfoScore, index_precision as precision, index_precisionRecallCurve as precisionRecallCurve, index_r2Score as r2Score, index_recall as recall, index_rmse as rmse, index_rocAucScore as rocAucScore, index_rocCurve as rocCurve, index_silhouetteSamples as silhouetteSamples, index_silhouetteScore as silhouetteScore, index_vMeasureScore as vMeasureScore };
+}
+
+export { silhouetteSamples as A, silhouetteScore as B, vMeasureScore as C, adjustedR2Score as D, explainedVarianceScore as E, mae as F, mape as G, maxError as H, medianAbsoluteError as I, mse as J, r2Score as K, rmse as L, accuracy as a, averagePrecisionScore as b, balancedAccuracyScore as c, classificationReport as d, cohenKappaScore as e, confusionMatrix as f, f1Score as g, fbetaScore as h, index as i, hammingLoss as j, jaccardScore as k, logLoss as l, matthewsCorrcoef as m, precisionRecallCurve as n, rocAucScore as o, precision as p, rocCurve as q, recall as r, adjustedMutualInfoScore as s, adjustedRandScore as t, calinskiHarabaszScore as u, completenessScore as v, daviesBouldinScore as w, fowlkesMallowsScore as x, homogeneityScore as y, normalizedMutualInfoScore as z };