deepbox 0.1.0 → 0.2.0

package/dist/{chunk-MLBMYKCG.js → chunk-H3JR7SV2.js}

@@ -1,6 +1,6 @@
-import { svd, lstsq, cholesky, solveTriangular } from './chunk-AU7XHGKJ.js';
-import { tensor, mean, dot, sub, reshape, transpose, isContiguous } from './chunk-BCR7G3A6.js';
-import { __export, InvalidParameterError, NotImplementedError, NotFittedError, DataValidationError, ShapeError, DeepboxError } from './chunk-4S73VUBD.js';
+import { svd, lstsq, cholesky, solveTriangular } from './chunk-AJTKVBY5.js';
+import { tensor, mean, dot, sub, reshape, transpose, isContiguous } from './chunk-KCF6P34A.js';
+import { __export, InvalidParameterError, NotImplementedError, NotFittedError, DataValidationError, ShapeError, DeepboxError } from './chunk-CZOMBUI7.js';
 
 // src/ml/index.ts
 var ml_exports = {};
@@ -272,6 +272,23 @@ var DBSCAN = class {
     }
     return this.labels_;
   }
+  /**
+   * Number of clusters found (excluding noise).
+   *
+   * @returns Number of distinct clusters (labels >= 0)
+   * @throws {NotFittedError} If the model has not been fitted
+   */
+  get nClusters() {
+    if (!this.fitted || !this.labels_) {
+      throw new NotFittedError("DBSCAN must be fitted to access nClusters");
+    }
+    const unique = /* @__PURE__ */ new Set();
+    for (let i = 0; i < this.labels_.size; i++) {
+      const label = Number(this.labels_.data[this.labels_.offset + i]);
+      if (label >= 0) unique.add(label);
+    }
+    return unique.size;
+  }
   /**
    * Get indices of core samples discovered during fitting.
    *
@@ -1903,10 +1920,10 @@ var GradientBoostingClassifier = class {
   maxDepth;
   /** Minimum samples to split */
   minSamplesSplit;
-  /** Array of weak learners */
-  estimators = [];
-  /** Initial log-odds prediction */
-  initPrediction = 0;
+  /** Per-class arrays of weak learners (OvR for multiclass, single for binary) */
+  estimatorsPerClass = [];
+  /** Per-class initial log-odds predictions */
+  initPredictions = [];
   /** Number of features */
   nFeatures = 0;
   /** Unique class labels */
@@ -1947,19 +1964,65 @@ var GradientBoostingClassifier = class {
       );
     }
   }
+  /**
+   * Fit a single binary boosting ensemble.
+   * Trains nEstimators regression trees to optimize log loss for a binary target.
+   */
+  fitBinary(X, yBinary, nSamples) {
+    const posCount = yBinary.filter((v) => v === 1).length;
+    const negCount = nSamples - posCount;
+    const initPred = Math.log((posCount + 1) / (negCount + 1));
+    const rawScores = new Array(nSamples).fill(initPred);
+    const estimators = [];
+    for (let m = 0; m < this.nEstimators; m++) {
+      const residuals = [];
+      for (let i = 0; i < nSamples; i++) {
+        const prob = 1 / (1 + Math.exp(-(rawScores[i] ?? 0)));
+        residuals.push((yBinary[i] ?? 0) - prob);
+      }
+      const tree = new DecisionTreeRegressor({
+        maxDepth: this.maxDepth,
+        minSamplesSplit: this.minSamplesSplit,
+        minSamplesLeaf: 1
+      });
+      tree.fit(X, tensor(residuals));
+      estimators.push(tree);
+      const treePred = tree.predict(X);
+      for (let i = 0; i < nSamples; i++) {
+        rawScores[i] = (rawScores[i] ?? 0) + this.learningRate * Number(treePred.data[treePred.offset + i]);
+      }
+    }
+    return { estimators, initPred };
+  }
+  /**
+   * Compute raw scores for a single binary ensemble.
+   */
+  predictRawBinary(X, classIdx) {
+    const nSamples = X.shape[0] ?? 0;
+    const rawScores = new Array(nSamples).fill(this.initPredictions[classIdx] ?? 0);
+    const estimators = this.estimatorsPerClass[classIdx] ?? [];
+    for (const tree of estimators) {
+      const treePred = tree.predict(X);
+      for (let i = 0; i < nSamples; i++) {
+        rawScores[i] = (rawScores[i] ?? 0) + this.learningRate * Number(treePred.data[treePred.offset + i]);
+      }
+    }
+    return rawScores;
+  }
   /**
    * 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).
+   * Supports binary (2 classes) and multiclass (>2 classes via OvR).
    *
    * @param X - Training data of shape (n_samples, n_features)
-   * @param y - Target class labels of shape (n_samples,). Must contain exactly 2 classes.
+   * @param y - Target class labels of shape (n_samples,). Must contain at least 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
+   * @throws {InvalidParameterError} If y does not contain at least 2 classes
    */
   fit(X, y) {
     validateFitInputs(X, y);
@@ -1971,36 +2034,26 @@ var GradientBoostingClassifier = class {
       yData.push(Number(y.data[y.offset + i]));
     }
     this.classLabels = [...new Set(yData)].sort((a, b) => a - b);
-    if (this.classLabels.length !== 2) {
+    if (this.classLabels.length < 2) {
       throw new InvalidParameterError(
-        "GradientBoostingClassifier requires exactly 2 classes",
+        "GradientBoostingClassifier requires at least 2 classes",
         "y",
         this.classLabels.length
       );
     }
-    const yBinary = yData.map((label) => label === this.classLabels[0] ? 0 : 1);
-    const posCount = yBinary.filter((v) => v === 1).length;
-    const negCount = nSamples - posCount;
-    this.initPrediction = Math.log((posCount + 1) / (negCount + 1));
-    const rawScores = new Array(nSamples).fill(this.initPrediction);
-    this.estimators = [];
-    for (let m = 0; m < this.nEstimators; m++) {
-      const residuals = [];
-      for (let i = 0; i < nSamples; i++) {
-        const prob = 1 / (1 + Math.exp(-(rawScores[i] ?? 0)));
-        const y_i = yBinary[i] ?? 0;
-        residuals.push(y_i - prob);
-      }
-      const tree = new DecisionTreeRegressor({
-        maxDepth: this.maxDepth,
-        minSamplesSplit: this.minSamplesSplit,
-        minSamplesLeaf: 1
-      });
-      tree.fit(X, tensor(residuals));
-      this.estimators.push(tree);
-      const treePred = tree.predict(X);
-      for (let i = 0; i < nSamples; i++) {
-        rawScores[i] = (rawScores[i] ?? 0) + this.learningRate * Number(treePred.data[treePred.offset + i]);
+    this.estimatorsPerClass = [];
+    this.initPredictions = [];
+    if (this.classLabels.length === 2) {
+      const yBinary = yData.map((label) => label === this.classLabels[0] ? 0 : 1);
+      const { estimators, initPred } = this.fitBinary(X, yBinary, nSamples);
+      this.estimatorsPerClass.push(estimators);
+      this.initPredictions.push(initPred);
+    } else {
+      for (const classLabel of this.classLabels) {
+        const yBinary = yData.map((label) => label === classLabel ? 1 : 0);
+        const { estimators, initPred } = this.fitBinary(X, yBinary, nSamples);
+        this.estimatorsPerClass.push(estimators);
+        this.initPredictions.push(initPred);
       }
     }
     this.fitted = true;
@@ -2021,29 +2074,40 @@ var GradientBoostingClassifier = class {
     }
     validatePredictInputs(X, this.nFeatures ?? 0, "GradientBoostingClassifier");
     const nSamples = X.shape[0] ?? 0;
-    const rawScores = new Array(nSamples).fill(this.initPrediction);
-    for (const tree of this.estimators) {
-      const treePred = tree.predict(X);
+    const predictions = [];
+    if (this.classLabels.length === 2) {
+      const rawScores = this.predictRawBinary(X, 0);
       for (let i = 0; i < nSamples; i++) {
-        rawScores[i] = (rawScores[i] ?? 0) + this.learningRate * Number(treePred.data[treePred.offset + i]);
+        const prob = 1 / (1 + Math.exp(-(rawScores[i] ?? 0)));
+        predictions.push(prob >= 0.5 ? this.classLabels[1] ?? 0 : this.classLabels[0] ?? 0);
+      }
+    } else {
+      const allScores = [];
+      for (let c = 0; c < this.classLabels.length; c++) {
+        allScores.push(this.predictRawBinary(X, c));
+      }
+      for (let i = 0; i < nSamples; i++) {
+        let bestClass = 0;
+        let bestScore = -Infinity;
+        for (let c = 0; c < this.classLabels.length; c++) {
+          const score = allScores[c]?.[i] ?? 0;
+          if (score > bestScore) {
+            bestScore = score;
+            bestClass = c;
+          }
+        }
+        predictions.push(this.classLabels[bestClass] ?? 0);
       }
-    }
-    const predictions = [];
-    for (let i = 0; i < nSamples; i++) {
-      const prob = 1 / (1 + Math.exp(-(rawScores[i] ?? 0)));
-      const predictedClass = prob >= 0.5 ? this.classLabels[1] : this.classLabels[0];
-      predictions.push(predictedClass ?? 0);
     }
     return tensor(predictions, { dtype: "int32" });
   }
   /**
    * Predict class probabilities for samples in X.
    *
-   * Returns a matrix of shape (n_samples, 2) where columns are
-   * [P(class_0), P(class_1)].
+   * Returns a matrix of shape (n_samples, n_classes).
    *
    * @param X - Samples of shape (n_samples, n_features)
-   * @returns Class probability matrix of shape (n_samples, 2)
+   * @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
@@ -2054,17 +2118,27 @@ var GradientBoostingClassifier = class {
     }
     validatePredictInputs(X, this.nFeatures ?? 0, "GradientBoostingClassifier");
     const nSamples = X.shape[0] ?? 0;
-    const rawScores = new Array(nSamples).fill(this.initPrediction);
-    for (const tree of this.estimators) {
-      const treePred = tree.predict(X);
+    const nClasses = this.classLabels.length;
+    const proba = [];
+    if (nClasses === 2) {
+      const rawScores = this.predictRawBinary(X, 0);
       for (let i = 0; i < nSamples; i++) {
-        rawScores[i] = (rawScores[i] ?? 0) + this.learningRate * Number(treePred.data[treePred.offset + i]);
+        const prob = 1 / (1 + Math.exp(-(rawScores[i] ?? 0)));
+        proba.push([1 - prob, prob]);
+      }
+    } else {
+      const allScores = [];
+      for (let c = 0; c < nClasses; c++) {
+        allScores.push(this.predictRawBinary(X, c));
+      }
+      for (let i = 0; i < nSamples; i++) {
+        const sigScores = [];
+        for (let c = 0; c < nClasses; c++) {
+          sigScores.push(1 / (1 + Math.exp(-(allScores[c]?.[i] ?? 0))));
+        }
+        const total = sigScores.reduce((s, v) => s + v, 0) || 1;
+        proba.push(sigScores.map((v) => v / total));
       }
-    }
-    const proba = [];
-    for (let i = 0; i < nSamples; i++) {
-      const prob = 1 / (1 + Math.exp(-(rawScores[i] ?? 0)));
-      proba.push([1 - prob, prob]);
     }
     return tensor(proba);
   }
@@ -4699,6 +4773,19 @@ var TSNE = class {
     this.fitTransform(X);
     return this;
   }
+  /**
+   * Return the fitted embedding. For t-SNE, transform is equivalent to
+   * returning the already-computed embedding (t-SNE is non-parametric).
+   *
+   * @param _X - Ignored, present for API compatibility
+   * @returns Low-dimensional embedding of shape (n_samples, n_components)
+   */
+  transform(_X) {
+    if (!this.fitted) {
+      throw new NotFittedError("TSNE must be fitted before transform");
+    }
+    return tensor(this.embedding);
+  }
   /**
    * Get the embedding.
    */
@@ -5332,13 +5419,13 @@ var LinearSVC = class {
   maxIter;
   /** Tolerance for stopping criterion */
   tol;
-  /** Weight vector of shape (n_features,) */
-  weights = [];
-  /** Bias term */
-  bias = 0;
+  /** Per-class weight vectors (OvR for multiclass, single for binary) */
+  weightsPerClass = [];
+  /** Per-class bias terms */
+  biasPerClass = [];
   /** Number of features seen during fit */
   nFeatures = 0;
-  /** Unique class labels [0, 1] mapped from original labels */
+  /** Unique class labels */
   classLabels = [];
   /** Whether the model has been fitted */
   fitted = false;
@@ -5368,19 +5455,69 @@ var LinearSVC = class {
       throw new InvalidParameterError("tol must be >= 0", "tol", this.tol);
     }
   }
+  /**
+   * Fit a single binary SVM using sub-gradient descent on hinge loss.
+   * Maps labels to {-1, +1} and returns learned weights + bias.
+   */
+  fitBinary(XData, yMapped, nSamples, nFeatures) {
+    const weights = new Array(nFeatures).fill(0);
+    let bias = 0;
+    const learningRate = 0.01;
+    for (let iter = 0; iter < this.maxIter; iter++) {
+      let maxViolation = 0;
+      for (let i = 0; i < nSamples; i++) {
+        const xi = XData[i];
+        const yi = yMapped[i];
+        if (xi === void 0 || yi === void 0) continue;
+        let decision = bias;
+        for (let j = 0; j < nFeatures; j++) {
+          decision += (weights[j] ?? 0) * (xi[j] ?? 0);
+        }
+        const margin = yi * decision;
+        if (margin < 1) {
+          maxViolation = Math.max(maxViolation, 1 - margin);
+        }
+        const effectiveLR = Math.min(learningRate, 1 / (this.C * 10));
+        if (margin < 1) {
+          for (let j = 0; j < nFeatures; j++) {
+            weights[j] = (weights[j] ?? 0) * (1 - effectiveLR) + effectiveLR * this.C * yi * (xi[j] ?? 0);
+          }
+          bias += effectiveLR * this.C * yi;
+        } else {
+          for (let j = 0; j < nFeatures; j++) {
+            weights[j] = (weights[j] ?? 0) * (1 - effectiveLR);
+          }
+        }
+      }
+      if (maxViolation < this.tol) break;
+    }
+    return { weights, bias };
+  }
+  /**
+   * Compute decision value for a single binary classifier.
+   */
+  decisionBinary(x, classIdx) {
+    const w = this.weightsPerClass[classIdx];
+    let d = this.biasPerClass[classIdx] ?? 0;
+    if (w) {
+      for (let j = 0; j < w.length; j++) {
+        d += (w[j] ?? 0) * (x[j] ?? 0);
+      }
+    }
+    return d;
+  }
   /**
    * 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))
+   * Supports both binary and multiclass classification (via OvR).
    *
    * @param X - Training data of shape (n_samples, n_features)
-   * @param y - Target labels of shape (n_samples,). Must contain exactly 2 classes.
+   * @param y - Target labels of shape (n_samples,). Must contain at least 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
+   * @throws {InvalidParameterError} If y does not contain at least 2 classes
    */
   fit(X, y) {
     validateFitInputs(X, y);
@@ -5398,45 +5535,26 @@ var LinearSVC = class {
       yData.push(Number(y.data[y.offset + i]));
     }
     this.classLabels = [...new Set(yData)].sort((a, b) => a - b);
-    if (this.classLabels.length !== 2) {
+    if (this.classLabels.length < 2) {
       throw new InvalidParameterError(
-        "LinearSVC requires exactly 2 classes for binary classification",
+        "LinearSVC requires at least 2 classes",
         "y",
         this.classLabels.length
       );
     }
-    const yMapped = yData.map((label) => label === this.classLabels[0] ? -1 : 1);
-    this.weights = new Array(nFeatures).fill(0);
-    this.bias = 0;
-    const learningRate = 0.01;
-    for (let iter = 0; iter < this.maxIter; iter++) {
-      let maxViolation = 0;
-      for (let i = 0; i < nSamples; i++) {
-        const xi = XData[i];
-        const yi = yMapped[i];
-        if (xi === void 0 || yi === void 0) continue;
-        let decision = this.bias;
-        for (let j = 0; j < nFeatures; j++) {
-          decision += (this.weights[j] ?? 0) * (xi[j] ?? 0);
-        }
-        const margin = yi * decision;
-        if (margin < 1) {
-          maxViolation = Math.max(maxViolation, 1 - margin);
-        }
-        const effectiveLR = Math.min(learningRate, 1 / (this.C * 10));
-        if (margin < 1) {
-          for (let j = 0; j < nFeatures; j++) {
-            this.weights[j] = (this.weights[j] ?? 0) * (1 - effectiveLR) + effectiveLR * this.C * yi * (xi[j] ?? 0);
-          }
-          this.bias += effectiveLR * this.C * yi;
-        } else {
-          for (let j = 0; j < nFeatures; j++) {
-            this.weights[j] = (this.weights[j] ?? 0) * (1 - effectiveLR);
-          }
-        }
-      }
-      if (maxViolation < this.tol) {
-        break;
+    this.weightsPerClass = [];
+    this.biasPerClass = [];
+    if (this.classLabels.length === 2) {
+      const yMapped = yData.map((label) => label === this.classLabels[0] ? -1 : 1);
+      const { weights, bias } = this.fitBinary(XData, yMapped, nSamples, nFeatures);
+      this.weightsPerClass.push(weights);
+      this.biasPerClass.push(bias);
+    } else {
+      for (const classLabel of this.classLabels) {
+        const yMapped = yData.map((label) => label === classLabel ? 1 : -1);
+        const { weights, bias } = this.fitBinary(XData, yMapped, nSamples, nFeatures);
+        this.weightsPerClass.push(weights);
+        this.biasPerClass.push(bias);
       }
     }
     this.fitted = true;
@@ -5460,12 +5578,25 @@ var LinearSVC = class {
     const nFeatures = X.shape[1] ?? 0;
     const predictions = [];
     for (let i = 0; i < nSamples; i++) {
-      let decision = this.bias;
+      const xi = [];
       for (let j = 0; j < nFeatures; j++) {
-        decision += (this.weights[j] ?? 0) * Number(X.data[X.offset + i * nFeatures + j]);
+        xi.push(Number(X.data[X.offset + i * nFeatures + j]));
+      }
+      if (this.classLabels.length === 2) {
+        const d = this.decisionBinary(xi, 0);
+        predictions.push(d >= 0 ? this.classLabels[1] ?? 0 : this.classLabels[0] ?? 0);
+      } else {
+        let bestClass = 0;
+        let bestScore = -Infinity;
+        for (let c = 0; c < this.classLabels.length; c++) {
+          const score = this.decisionBinary(xi, c);
+          if (score > bestScore) {
+            bestScore = score;
+            bestClass = c;
+          }
+        }
+        predictions.push(this.classLabels[bestClass] ?? 0);
       }
-      const predictedClass = decision >= 0 ? this.classLabels[1] : this.classLabels[0];
-      predictions.push(predictedClass ?? 0);
     }
     return tensor(predictions, { dtype: "int32" });
   }
@@ -5485,14 +5616,25 @@ var LinearSVC = class {
     validatePredictInputs(X, this.nFeatures ?? 0, "LinearSVC");
     const nSamples = X.shape[0] ?? 0;
     const nFeatures = X.shape[1] ?? 0;
+    const nClasses = this.classLabels.length;
     const proba = [];
     for (let i = 0; i < nSamples; i++) {
-      let decision = this.bias;
+      const xi = [];
       for (let j = 0; j < nFeatures; j++) {
-        decision += (this.weights[j] ?? 0) * Number(X.data[X.offset + i * nFeatures + j]);
+        xi.push(Number(X.data[X.offset + i * nFeatures + j]));
+      }
+      if (nClasses === 2) {
+        const d = this.decisionBinary(xi, 0);
+        const p1 = 1 / (1 + Math.exp(-d));
+        proba.push([1 - p1, p1]);
+      } else {
+        const sigScores = [];
+        for (let c = 0; c < nClasses; c++) {
+          sigScores.push(1 / (1 + Math.exp(-this.decisionBinary(xi, c))));
+        }
+        const total = sigScores.reduce((s, v) => s + v, 0) || 1;
+        proba.push(sigScores.map((v) => v / total));
       }
-      const p1 = 1 / (1 + Math.exp(-decision));
-      proba.push([1 - p1, p1]);
     }
     return tensor(proba);
   }
@@ -5541,19 +5683,19 @@ var LinearSVC = class {
     if (!this.fitted) {
       throw new NotFittedError("LinearSVC must be fitted to access coefficients");
     }
-    return tensor([this.weights]);
+    return tensor(this.weightsPerClass);
   }
   /**
-   * Get the bias term.
+   * Get the bias terms.
    *
-   * @returns Bias value
+   * @returns Bias values as tensor
    * @throws {NotFittedError} If the model has not been fitted
    */
   get intercept() {
     if (!this.fitted) {
       throw new NotFittedError("LinearSVC must be fitted to access intercept");
     }
-    return this.bias;
+    return tensor(this.biasPerClass);
   }
   /**
    * Get hyperparameters for this estimator.
@@ -6375,5 +6517,5 @@ var RandomForestRegressor = class {
 };
 
 export { DBSCAN, DecisionTreeClassifier, DecisionTreeRegressor, GaussianNB, GradientBoostingClassifier, GradientBoostingRegressor, KMeans, KNeighborsClassifier, KNeighborsRegressor, Lasso, LinearRegression, LinearSVC, LinearSVR, LogisticRegression, PCA, RandomForestClassifier, RandomForestRegressor, Ridge, TSNE, ml_exports };
-//# sourceMappingURL=chunk-MLBMYKCG.js.map
-//# sourceMappingURL=chunk-MLBMYKCG.js.map
+//# sourceMappingURL=chunk-H3JR7SV2.js.map
+//# sourceMappingURL=chunk-H3JR7SV2.js.map