bun-scikit 0.1.1

package/src/ensemble/RandomForestRegressor.ts

@@ -0,0 +1,136 @@
+import type { Matrix, RegressionModel, Vector } from "../types";
+import { r2Score } from "../metrics/regression";
+import { DecisionTreeRegressor } from "../tree/DecisionTreeRegressor";
+import { assertFiniteVector, validateRegressionInputs } from "../utils/validation";
+import type { MaxFeaturesOption } from "../tree/DecisionTreeClassifier";
+
+export interface RandomForestRegressorOptions {
+  nEstimators?: number;
+  maxDepth?: number;
+  minSamplesSplit?: number;
+  minSamplesLeaf?: number;
+  maxFeatures?: MaxFeaturesOption;
+  bootstrap?: boolean;
+  randomState?: number;
+}
+
+function mulberry32(seed: number): () => number {
+  let state = seed >>> 0;
+  return () => {
+    state += 0x6d2b79f5;
+    let t = Math.imul(state ^ (state >>> 15), 1 | state);
+    t ^= t + Math.imul(t ^ (t >>> 7), 61 | t);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+export class RandomForestRegressor implements RegressionModel {
+  private readonly nEstimators: number;
+  private readonly maxDepth?: number;
+  private readonly minSamplesSplit?: number;
+  private readonly minSamplesLeaf?: number;
+  private readonly maxFeatures: MaxFeaturesOption;
+  private readonly bootstrap: boolean;
+  private readonly randomState?: number;
+  private trees: DecisionTreeRegressor[] = [];
+
+  constructor(options: RandomForestRegressorOptions = {}) {
+    this.nEstimators = options.nEstimators ?? 50;
+    this.maxDepth = options.maxDepth ?? 12;
+    this.minSamplesSplit = options.minSamplesSplit ?? 2;
+    this.minSamplesLeaf = options.minSamplesLeaf ?? 1;
+    this.maxFeatures = options.maxFeatures ?? "sqrt";
+    this.bootstrap = options.bootstrap ?? true;
+    this.randomState = options.randomState;
+
+    if (!Number.isInteger(this.nEstimators) || this.nEstimators < 1) {
+      throw new Error(`nEstimators must be a positive integer. Got ${this.nEstimators}.`);
+    }
+  }
+
+  fit(X: Matrix, y: Vector): this {
+    validateRegressionInputs(X, y);
+
+    const sampleCount = X.length;
+    const featureCount = X[0].length;
+    const random = this.randomState === undefined ? Math.random : mulberry32(this.randomState);
+    const flattenedX = this.flattenTrainingMatrix(X, sampleCount, featureCount);
+    const yValues = this.toFloat64Vector(y);
+    this.trees = new Array(this.nEstimators);
+
+    for (let estimatorIndex = 0; estimatorIndex < this.nEstimators; estimatorIndex += 1) {
+      const sampleIndices = new Uint32Array(sampleCount);
+      if (this.bootstrap) {
+        for (let i = 0; i < sampleCount; i += 1) {
+          sampleIndices[i] = Math.floor(random() * sampleCount);
+        }
+      } else {
+        for (let i = 0; i < sampleCount; i += 1) {
+          sampleIndices[i] = i;
+        }
+      }
+
+      const tree = new DecisionTreeRegressor({
+        maxDepth: this.maxDepth,
+        minSamplesSplit: this.minSamplesSplit,
+        minSamplesLeaf: this.minSamplesLeaf,
+        maxFeatures: this.maxFeatures,
+        randomState:
+          this.randomState === undefined ? undefined : this.randomState + estimatorIndex + 1,
+      });
+      tree.fit(X, y, sampleIndices, true, flattenedX, yValues);
+      this.trees[estimatorIndex] = tree;
+    }
+
+    return this;
+  }
+
+  predict(X: Matrix): Vector {
+    if (this.trees.length === 0) {
+      throw new Error("RandomForestRegressor has not been fitted.");
+    }
+
+    const treePredictions = this.trees.map((tree) => tree.predict(X));
+    const sampleCount = X.length;
+    const predictions = new Array<number>(sampleCount).fill(0);
+
+    for (let sampleIndex = 0; sampleIndex < sampleCount; sampleIndex += 1) {
+      let sum = 0;
+      for (let treeIndex = 0; treeIndex < treePredictions.length; treeIndex += 1) {
+        sum += treePredictions[treeIndex][sampleIndex];
+      }
+      predictions[sampleIndex] = sum / this.trees.length;
+    }
+
+    return predictions;
+  }
+
+  score(X: Matrix, y: Vector): number {
+    assertFiniteVector(y);
+    return r2Score(y, this.predict(X));
+  }
+
+  private flattenTrainingMatrix(
+    X: Matrix,
+    sampleCount: number,
+    featureCount: number,
+  ): Float64Array {
+    const flattened = new Float64Array(sampleCount * featureCount);
+    for (let i = 0; i < sampleCount; i += 1) {
+      const row = X[i];
+      const rowOffset = i * featureCount;
+      for (let j = 0; j < featureCount; j += 1) {
+        flattened[rowOffset + j] = row[j];
+      }
+    }
+    return flattened;
+  }
+
+  private toFloat64Vector(y: Vector): Float64Array {
+    const out = new Float64Array(y.length);
+    for (let i = 0; i < y.length; i += 1) {
+      out[i] = y[i];
+    }
+    return out;
+  }
+}

package/src/index.ts

@@ -0,0 +1,32 @@
+export * from "./types";
+
+export * from "./preprocessing/StandardScaler";
+export * from "./preprocessing/MinMaxScaler";
+export * from "./preprocessing/RobustScaler";
+export * from "./preprocessing/PolynomialFeatures";
+export * from "./preprocessing/SimpleImputer";
+export * from "./preprocessing/OneHotEncoder";
+export * from "./linear_model/LinearRegression";
+export * from "./linear_model/LogisticRegression";
+export * from "./linear_model/SGDClassifier";
+export * from "./linear_model/SGDRegressor";
+export * from "./neighbors/KNeighborsClassifier";
+export * from "./naive_bayes/GaussianNB";
+export * from "./svm/LinearSVC";
+export * from "./tree/DecisionTreeClassifier";
+export * from "./tree/DecisionTreeRegressor";
+export * from "./ensemble/RandomForestClassifier";
+export * from "./ensemble/RandomForestRegressor";
+export * from "./model_selection/trainTestSplit";
+export * from "./model_selection/KFold";
+export * from "./model_selection/StratifiedKFold";
+export * from "./model_selection/StratifiedShuffleSplit";
+export * from "./model_selection/RepeatedKFold";
+export * from "./model_selection/RepeatedStratifiedKFold";
+export * from "./model_selection/crossValScore";
+export * from "./model_selection/GridSearchCV";
+export * from "./pipeline/Pipeline";
+export * from "./pipeline/ColumnTransformer";
+export * from "./pipeline/FeatureUnion";
+export * from "./metrics/regression";
+export * from "./metrics/classification";

package/src/linear_model/LinearRegression.ts

@@ -0,0 +1,136 @@
+import type { Matrix, RegressionModel, Vector } from "../types";
+import { r2Score } from "../metrics/regression";
+import { dot } from "../utils/linalg";
+import { getZigKernels } from "../native/zigKernels";
+import {
+  assertConsistentRowSize,
+  assertFiniteMatrix,
+  assertFiniteVector,
+  validateRegressionInputs,
+} from "../utils/validation";
+
+export interface LinearRegressionOptions {
+  fitIntercept?: boolean;
+  solver?: "normal";
+}
+
+export class LinearRegression implements RegressionModel {
+  coef_: Vector = [];
+  intercept_ = 0;
+  fitBackend_: "zig" = "zig";
+  fitBackendLibrary_: string | null = null;
+
+  private readonly fitIntercept: boolean;
+  private readonly solver: "normal";
+  private isFitted = false;
+
+  constructor(options: LinearRegressionOptions = {}) {
+    this.fitIntercept = options.fitIntercept ?? true;
+    this.solver = options.solver ?? "normal";
+  }
+
+  fit(X: Matrix, y: Vector): this {
+    validateRegressionInputs(X, y);
+    if (this.solver !== "normal") {
+      throw new Error("LinearRegression solver 'normal' is required in zig-only mode.");
+    }
+    this.fitNormalEquationNative(X, y);
+
+    this.isFitted = true;
+    return this;
+  }
+
+  predict(X: Matrix): Vector {
+    if (!this.isFitted) {
+      throw new Error("LinearRegression has not been fitted.");
+    }
+
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    if (X[0].length !== this.coef_.length) {
+      throw new Error(
+        `Feature size mismatch. Expected ${this.coef_.length}, got ${X[0].length}.`,
+      );
+    }
+
+    return X.map((row) => this.intercept_ + dot(row, this.coef_));
+  }
+
+  score(X: Matrix, y: Vector): number {
+    assertFiniteVector(y);
+    return r2Score(y, this.predict(X));
+  }
+
+  private fitNormalEquationNative(X: Matrix, y: Vector): void {
+    const kernels = getZigKernels();
+    if (!kernels) {
+      throw new Error(
+        "LinearRegression requires native Zig kernels. Build them with `bun run native:build`.",
+      );
+    }
+    if (
+      !kernels.linearModelCreate ||
+      !kernels.linearModelDestroy ||
+      !kernels.linearModelFit ||
+      !kernels.linearModelCopyCoefficients ||
+      !kernels.linearModelGetIntercept
+    ) {
+      throw new Error("Native linear model symbols are not available.");
+    }
+
+    const nSamples = X.length;
+    const nFeatures = X[0].length;
+    const flattenedX = this.flattenMatrix(X);
+    const yBuffer = this.toFloat64Vector(y);
+    const handle = kernels.linearModelCreate(nFeatures, this.fitIntercept ? 1 : 0);
+    if (handle === 0n) {
+      throw new Error("Failed to create native linear model handle.");
+    }
+
+    try {
+      const fitStatus = kernels.linearModelFit(handle, flattenedX, yBuffer, nSamples, 1e-8);
+      if (fitStatus !== 1) {
+        throw new Error("Native linear model fit failed.");
+      }
+
+      const coefficients = new Float64Array(nFeatures);
+      const copied = kernels.linearModelCopyCoefficients(handle, coefficients);
+      if (copied !== 1) {
+        throw new Error("Failed to copy native linear coefficients.");
+      }
+
+      this.coef_ = Array.from(coefficients);
+      this.intercept_ = kernels.linearModelGetIntercept(handle);
+      this.fitBackend_ = "zig";
+      this.fitBackendLibrary_ = kernels.libraryPath;
+    } catch (error) {
+      kernels.linearModelDestroy(handle);
+      throw error;
+    }
+    kernels.linearModelDestroy(handle);
+  }
+
+  private flattenMatrix(X: Matrix): Float64Array {
+    const rowCount = X.length;
+    const featureCount = X[0].length;
+    const flattenedX = new Float64Array(rowCount * featureCount);
+    for (let i = 0; i < rowCount; i += 1) {
+      const row = X[i];
+      const rowOffset = i * featureCount;
+      for (let j = 0; j < featureCount; j += 1) {
+        flattenedX[rowOffset + j] = row[j];
+      }
+    }
+    return flattenedX;
+  }
+
+  private toFloat64Vector(y: Vector): Float64Array {
+    const yBuffer = new Float64Array(y.length);
+    for (let i = 0; i < y.length; i += 1) {
+      yBuffer[i] = y[i];
+    }
+    return yBuffer;
+  }
+
+}

package/src/linear_model/LogisticRegression.ts

@@ -0,0 +1,260 @@
+import type { ClassificationModel, Matrix, Vector } from "../types";
+import { dot } from "../utils/linalg";
+import {
+  assertConsistentRowSize,
+  assertFiniteMatrix,
+  assertFiniteVector,
+  validateClassificationInputs,
+} from "../utils/validation";
+import { accuracyScore } from "../metrics/classification";
+import { getZigKernels } from "../native/zigKernels";
+
+export interface LogisticRegressionOptions {
+  fitIntercept?: boolean;
+  solver?: "gd" | "lbfgs";
+  learningRate?: number;
+  maxIter?: number;
+  tolerance?: number;
+  l2?: number;
+  lbfgsMemory?: number;
+}
+
+function sigmoid(z: number): number {
+  if (z >= 0) {
+    const expNeg = Math.exp(-z);
+    return 1 / (1 + expNeg);
+  }
+  const expPos = Math.exp(z);
+  return expPos / (1 + expPos);
+}
+
+export class LogisticRegression implements ClassificationModel {
+  coef_: Vector = [];
+  intercept_ = 0;
+  classes_: Vector = [0, 1];
+  fitBackend_: "zig" = "zig";
+  fitBackendLibrary_: string | null = null;
+
+  private readonly fitIntercept: boolean;
+  private readonly solver: "gd" | "lbfgs";
+  private readonly learningRate: number;
+  private readonly maxIter: number;
+  private readonly tolerance: number;
+  private readonly l2: number;
+  private readonly lbfgsMemory: number;
+  private isFitted = false;
+
+  constructor(options: LogisticRegressionOptions = {}) {
+    this.fitIntercept = options.fitIntercept ?? true;
+    this.solver = options.solver ?? "gd";
+    this.learningRate = options.learningRate ?? 0.1;
+    this.maxIter = options.maxIter ?? 20_000;
+    this.tolerance = options.tolerance ?? 1e-8;
+    this.l2 = options.l2 ?? 0;
+    this.lbfgsMemory = options.lbfgsMemory ?? 7;
+  }
+
+  fit(X: Matrix, y: Vector): this {
+    validateClassificationInputs(X, y);
+
+    const nSamples = X.length;
+    const nFeatures = X[0].length;
+    const flattenedX = this.flattenMatrix(X);
+    const yBuffer = this.toFloat64Vector(y);
+    const coefficients = new Float64Array(nFeatures);
+    const gradients = new Float64Array(nFeatures);
+    const intercept = new Float64Array(1);
+
+    const kernels = getZigKernels();
+    if (!kernels) {
+      throw new Error(
+        "LogisticRegression requires native Zig kernels. Build them with `bun run native:build`.",
+      );
+    }
+
+    if (
+      kernels?.logisticModelCreate &&
+      kernels.logisticModelDestroy &&
+      kernels.logisticModelCopyCoefficients &&
+      kernels.logisticModelGetIntercept
+    ) {
+      const fitNative =
+        this.solver === "lbfgs" ? kernels.logisticModelFitLbfgs : kernels.logisticModelFit;
+      if (!fitNative) {
+        throw new Error(
+          `LogisticRegression solver '${this.solver}' is unavailable in native kernels.`,
+        );
+      }
+
+      const handle = kernels.logisticModelCreate(nFeatures, this.fitIntercept ? 1 : 0);
+      if (handle === 0n) {
+        throw new Error("Failed to create native logistic model handle.");
+      }
+
+      try {
+        if (!fitNative) {
+          throw new Error("Native solver function is unavailable.");
+        }
+        const epochsRan =
+          this.solver === "lbfgs"
+            ? kernels.logisticModelFitLbfgs!(
+                handle,
+                flattenedX,
+                yBuffer,
+                nSamples,
+                this.maxIter,
+                this.tolerance,
+                this.l2,
+                this.lbfgsMemory,
+              )
+            : kernels.logisticModelFit!(
+                handle,
+                flattenedX,
+                yBuffer,
+                nSamples,
+                this.learningRate,
+                this.l2,
+                this.maxIter,
+                this.tolerance,
+              );
+        if (epochsRan === 0n && this.maxIter > 0) {
+          throw new Error("Native logistic model fit failed.");
+        }
+
+        const copied = kernels.logisticModelCopyCoefficients(handle, coefficients);
+        if (copied !== 1) {
+          throw new Error("Failed to copy native logistic coefficients.");
+        }
+
+        this.fitBackend_ = "zig";
+        this.fitBackendLibrary_ = kernels.libraryPath;
+        this.coef_ = Array.from(coefficients);
+        this.intercept_ = kernels.logisticModelGetIntercept(handle);
+        this.isFitted = true;
+        kernels.logisticModelDestroy(handle);
+        return this;
+      } catch (error) {
+        kernels.logisticModelDestroy(handle);
+        throw error;
+      }
+    }
+
+    if (this.solver === "lbfgs") {
+      throw new Error("LogisticRegression solver 'lbfgs' requires native model-handle kernels.");
+    }
+
+    if (kernels?.logisticTrainEpoch) {
+      if (kernels.logisticTrainEpochs) {
+        kernels.logisticTrainEpochs(
+          flattenedX,
+          yBuffer,
+          nSamples,
+          nFeatures,
+          coefficients,
+          intercept,
+          gradients,
+          this.learningRate,
+          this.l2,
+          this.fitIntercept ? 1 : 0,
+          this.maxIter,
+          this.tolerance,
+        );
+      } else {
+        for (let iter = 0; iter < this.maxIter; iter += 1) {
+          const maxUpdate = kernels.logisticTrainEpoch(
+            flattenedX,
+            yBuffer,
+            nSamples,
+            nFeatures,
+            coefficients,
+            intercept,
+            gradients,
+            this.learningRate,
+            this.l2,
+            this.fitIntercept ? 1 : 0,
+          );
+
+          if (maxUpdate < this.tolerance) {
+            break;
+          }
+        }
+      }
+
+      this.fitBackend_ = "zig";
+      this.fitBackendLibrary_ = kernels.libraryPath;
+      this.coef_ = Array.from(coefficients);
+      this.intercept_ = intercept[0];
+      this.isFitted = true;
+      return this;
+    }
+
+    throw new Error(
+      "Native logistic kernels are unavailable. Rebuild with `bun run native:build` and ensure model-handle or epoch kernels are exported.",
+    );
+  }
+
+  predictProba(X: Matrix): Matrix {
+    if (!this.isFitted) {
+      throw new Error("LogisticRegression has not been fitted.");
+    }
+
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    if (X[0].length !== this.coef_.length) {
+      throw new Error(
+        `Feature size mismatch. Expected ${this.coef_.length}, got ${X[0].length}.`,
+      );
+    }
+
+    return X.map((row) => {
+      const positive = sigmoid(this.intercept_ + dot(row, this.coef_));
+      return [1 - positive, positive];
+    });
+  }
+
+  predict(X: Matrix): Vector {
+    if (!this.isFitted) {
+      throw new Error("LogisticRegression has not been fitted.");
+    }
+
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    if (X[0].length !== this.coef_.length) {
+      throw new Error(
+        `Feature size mismatch. Expected ${this.coef_.length}, got ${X[0].length}.`,
+      );
+    }
+
+    return this.predictProba(X).map((pair) => (pair[1] >= 0.5 ? 1 : 0));
+  }
+
+  score(X: Matrix, y: Vector): number {
+    assertFiniteVector(y);
+    return accuracyScore(y, this.predict(X));
+  }
+
+  private flattenMatrix(X: Matrix): Float64Array {
+    const rowCount = X.length;
+    const featureCount = X[0].length;
+    const flattenedX = new Float64Array(rowCount * featureCount);
+    for (let i = 0; i < rowCount; i += 1) {
+      const row = X[i];
+      const rowOffset = i * featureCount;
+      for (let j = 0; j < featureCount; j += 1) {
+        flattenedX[rowOffset + j] = row[j];
+      }
+    }
+    return flattenedX;
+  }
+
+  private toFloat64Vector(y: Vector): Float64Array {
+    const yBuffer = new Float64Array(y.length);
+    for (let i = 0; i < y.length; i += 1) {
+      yBuffer[i] = y[i];
+    }
+    return yBuffer;
+  }
+
+}