bun-scikit 0.1.3 → 0.1.4

package/src/native/node-addon/bun_scikit_addon.cpp

@@ -27,6 +27,10 @@ using LogisticModelFitFn = std::size_t (*)(NativeHandle, const double*, const do
 using LogisticModelFitLbfgsFn = std::size_t (*)(NativeHandle, const double*, const double*, std::size_t, std::size_t, double, double, std::size_t);
 using LogisticModelCopyCoefficientsFn = std::uint8_t (*)(NativeHandle, double*);
 using LogisticModelGetInterceptFn = double (*)(NativeHandle);
+using DecisionTreeModelCreateFn = NativeHandle (*)(std::size_t, std::size_t, std::size_t, std::uint8_t, std::size_t, std::uint32_t, std::uint8_t, std::size_t);
+using DecisionTreeModelDestroyFn = void (*)(NativeHandle);
+using DecisionTreeModelFitFn = std::uint8_t (*)(NativeHandle, const double*, const std::uint8_t*, std::size_t, std::size_t, const std::uint32_t*, std::size_t);
+using DecisionTreeModelPredictFn = std::uint8_t (*)(NativeHandle, const double*, std::size_t, std::size_t, std::uint8_t*);
 
 struct KernelLibrary {
 #if defined(_WIN32)
@@ -47,6 +51,10 @@ struct KernelLibrary {
   LogisticModelFitLbfgsFn logistic_model_fit_lbfgs{nullptr};
   LogisticModelCopyCoefficientsFn logistic_model_copy_coefficients{nullptr};
   LogisticModelGetInterceptFn logistic_model_get_intercept{nullptr};
+  DecisionTreeModelCreateFn decision_tree_model_create{nullptr};
+  DecisionTreeModelDestroyFn decision_tree_model_destroy{nullptr};
+  DecisionTreeModelFitFn decision_tree_model_fit{nullptr};
+  DecisionTreeModelPredictFn decision_tree_model_predict{nullptr};
 };
 
 KernelLibrary g_library{};
@@ -138,6 +146,14 @@ Napi::Value LoadNativeLibrary(const Napi::CallbackInfo& info) {
       loadSymbol<LogisticModelCopyCoefficientsFn>("logistic_model_copy_coefficients");
   g_library.logistic_model_get_intercept =
       loadSymbol<LogisticModelGetInterceptFn>("logistic_model_get_intercept");
+  g_library.decision_tree_model_create =
+      loadSymbol<DecisionTreeModelCreateFn>("decision_tree_model_create");
+  g_library.decision_tree_model_destroy =
+      loadSymbol<DecisionTreeModelDestroyFn>("decision_tree_model_destroy");
+  g_library.decision_tree_model_fit =
+      loadSymbol<DecisionTreeModelFitFn>("decision_tree_model_fit");
+  g_library.decision_tree_model_predict =
+      loadSymbol<DecisionTreeModelPredictFn>("decision_tree_model_predict");
 
   return Napi::Boolean::New(env, true);
 }
@@ -423,6 +439,134 @@ Napi::Value LogisticModelGetIntercept(const Napi::CallbackInfo& info) {
   return Napi::Number::New(env, g_library.logistic_model_get_intercept(handle));
 }
 
+Napi::Value DecisionTreeModelCreate(const Napi::CallbackInfo& info) {
+  const Napi::Env env = info.Env();
+  if (!isLibraryLoaded(env)) {
+    return env.Null();
+  }
+  if (!g_library.decision_tree_model_create) {
+    throwError(env, "Symbol decision_tree_model_create is unavailable.");
+    return env.Null();
+  }
+  if (info.Length() != 8 || !info[0].IsNumber() || !info[1].IsNumber() || !info[2].IsNumber() ||
+      !info[3].IsNumber() || !info[4].IsNumber() || !info[5].IsNumber() || !info[6].IsNumber() ||
+      !info[7].IsNumber()) {
+    throwTypeError(env, "decisionTreeModelCreate(maxDepth, minSamplesSplit, minSamplesLeaf, maxFeaturesMode, maxFeaturesValue, randomState, useRandomState, nFeatures) expects eight numbers.");
+    return env.Null();
+  }
+
+  const std::size_t max_depth = static_cast<std::size_t>(info[0].As<Napi::Number>().Uint32Value());
+  const std::size_t min_samples_split = static_cast<std::size_t>(info[1].As<Napi::Number>().Uint32Value());
+  const std::size_t min_samples_leaf = static_cast<std::size_t>(info[2].As<Napi::Number>().Uint32Value());
+  const std::uint8_t max_features_mode = static_cast<std::uint8_t>(info[3].As<Napi::Number>().Uint32Value());
+  const std::size_t max_features_value = static_cast<std::size_t>(info[4].As<Napi::Number>().Uint32Value());
+  const std::uint32_t random_state = static_cast<std::uint32_t>(info[5].As<Napi::Number>().Uint32Value());
+  const std::uint8_t use_random_state = static_cast<std::uint8_t>(info[6].As<Napi::Number>().Uint32Value());
+  const std::size_t n_features = static_cast<std::size_t>(info[7].As<Napi::Number>().Uint32Value());
+
+  const NativeHandle handle = g_library.decision_tree_model_create(
+      max_depth,
+      min_samples_split,
+      min_samples_leaf,
+      max_features_mode,
+      max_features_value,
+      random_state,
+      use_random_state,
+      n_features);
+  return Napi::BigInt::New(env, static_cast<std::uint64_t>(handle));
+}
+
+Napi::Value DecisionTreeModelDestroy(const Napi::CallbackInfo& info) {
+  const Napi::Env env = info.Env();
+  if (!isLibraryLoaded(env)) {
+    return env.Null();
+  }
+  if (!g_library.decision_tree_model_destroy) {
+    throwError(env, "Symbol decision_tree_model_destroy is unavailable.");
+    return env.Null();
+  }
+  if (info.Length() != 1) {
+    throwTypeError(env, "decisionTreeModelDestroy(handle) expects one BigInt.");
+    return env.Null();
+  }
+  const NativeHandle handle = handleFromBigInt(info[0], env);
+  if (env.IsExceptionPending()) {
+    return env.Null();
+  }
+  g_library.decision_tree_model_destroy(handle);
+  return env.Undefined();
+}
+
+Napi::Value DecisionTreeModelFit(const Napi::CallbackInfo& info) {
+  const Napi::Env env = info.Env();
+  if (!isLibraryLoaded(env)) {
+    return env.Null();
+  }
+  if (!g_library.decision_tree_model_fit) {
+    throwError(env, "Symbol decision_tree_model_fit is unavailable.");
+    return env.Null();
+  }
+  if (info.Length() != 7 || !info[1].IsTypedArray() || !info[2].IsTypedArray() ||
+      !info[3].IsNumber() || !info[4].IsNumber() || !info[5].IsTypedArray() || !info[6].IsNumber()) {
+    throwTypeError(env, "decisionTreeModelFit(handle, x, y, nSamples, nFeatures, sampleIndices, sampleCount) has invalid arguments.");
+    return env.Null();
+  }
+
+  const NativeHandle handle = handleFromBigInt(info[0], env);
+  if (env.IsExceptionPending()) {
+    return env.Null();
+  }
+  auto x = info[1].As<Napi::Float64Array>();
+  auto y = info[2].As<Napi::Uint8Array>();
+  const std::size_t n_samples = static_cast<std::size_t>(info[3].As<Napi::Number>().Uint32Value());
+  const std::size_t n_features = static_cast<std::size_t>(info[4].As<Napi::Number>().Uint32Value());
+  auto sample_indices = info[5].As<Napi::Uint32Array>();
+  const std::size_t sample_count = static_cast<std::size_t>(info[6].As<Napi::Number>().Uint32Value());
+
+  const std::uint8_t status = g_library.decision_tree_model_fit(
+      handle,
+      x.Data(),
+      y.Data(),
+      n_samples,
+      n_features,
+      sample_indices.Data(),
+      sample_count);
+  return Napi::Number::New(env, status);
+}
+
+Napi::Value DecisionTreeModelPredict(const Napi::CallbackInfo& info) {
+  const Napi::Env env = info.Env();
+  if (!isLibraryLoaded(env)) {
+    return env.Null();
+  }
+  if (!g_library.decision_tree_model_predict) {
+    throwError(env, "Symbol decision_tree_model_predict is unavailable.");
+    return env.Null();
+  }
+  if (info.Length() != 5 || !info[1].IsTypedArray() || !info[2].IsNumber() || !info[3].IsNumber() ||
+      !info[4].IsTypedArray()) {
+    throwTypeError(env, "decisionTreeModelPredict(handle, x, nSamples, nFeatures, outLabels) has invalid arguments.");
+    return env.Null();
+  }
+
+  const NativeHandle handle = handleFromBigInt(info[0], env);
+  if (env.IsExceptionPending()) {
+    return env.Null();
+  }
+  auto x = info[1].As<Napi::Float64Array>();
+  const std::size_t n_samples = static_cast<std::size_t>(info[2].As<Napi::Number>().Uint32Value());
+  const std::size_t n_features = static_cast<std::size_t>(info[3].As<Napi::Number>().Uint32Value());
+  auto out_labels = info[4].As<Napi::Uint8Array>();
+
+  const std::uint8_t status = g_library.decision_tree_model_predict(
+      handle,
+      x.Data(),
+      n_samples,
+      n_features,
+      out_labels.Data());
+  return Napi::Number::New(env, status);
+}
+
 Napi::Object Init(Napi::Env env, Napi::Object exports) {
   exports.Set("loadLibrary", Napi::Function::New(env, LoadNativeLibrary));
   exports.Set("unloadLibrary", Napi::Function::New(env, UnloadLibrary));
@@ -442,6 +586,11 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
   exports.Set("logisticModelCopyCoefficients", Napi::Function::New(env, LogisticModelCopyCoefficients));
   exports.Set("logisticModelGetIntercept", Napi::Function::New(env, LogisticModelGetIntercept));
 
+  exports.Set("decisionTreeModelCreate", Napi::Function::New(env, DecisionTreeModelCreate));
+  exports.Set("decisionTreeModelDestroy", Napi::Function::New(env, DecisionTreeModelDestroy));
+  exports.Set("decisionTreeModelFit", Napi::Function::New(env, DecisionTreeModelFit));
+  exports.Set("decisionTreeModelPredict", Napi::Function::New(env, DecisionTreeModelPredict));
+
   return exports;
 }
 

package/src/native/zigKernels.ts

@@ -243,6 +243,10 @@ interface NodeApiAddon {
   logisticModelFitLbfgs: LogisticModelFitLbfgsFn;
   logisticModelCopyCoefficients: LogisticModelCopyCoefficientsFn;
   logisticModelGetIntercept: LogisticModelGetInterceptFn;
+  decisionTreeModelCreate?: DecisionTreeModelCreateFn;
+  decisionTreeModelDestroy?: DecisionTreeModelDestroyFn;
+  decisionTreeModelFit?: DecisionTreeModelFitFn;
+  decisionTreeModelPredict?: DecisionTreeModelPredictFn;
 }
 
 function tryLoadNodeApiKernels(): ZigKernels | null {
@@ -281,10 +285,10 @@ function tryLoadNodeApiKernels(): ZigKernels | null {
           logisticModelPredict: null,
           logisticModelCopyCoefficients: addon.logisticModelCopyCoefficients ?? null,
           logisticModelGetIntercept: addon.logisticModelGetIntercept ?? null,
-          decisionTreeModelCreate: null,
-          decisionTreeModelDestroy: null,
-          decisionTreeModelFit: null,
-          decisionTreeModelPredict: null,
+          decisionTreeModelCreate: addon.decisionTreeModelCreate ?? null,
+          decisionTreeModelDestroy: addon.decisionTreeModelDestroy ?? null,
+          decisionTreeModelFit: addon.decisionTreeModelFit ?? null,
+          decisionTreeModelPredict: addon.decisionTreeModelPredict ?? null,
           logisticTrainEpoch: null,
           logisticTrainEpochs: null,
           abiVersion,
@@ -403,6 +407,31 @@ export function getZigKernels(): ZigKernels | null {
             args: ["usize"],
             returns: FFIType.f64,
           },
+          decision_tree_model_create: {
+            args: [
+              "usize",
+              "usize",
+              "usize",
+              FFIType.u8,
+              "usize",
+              FFIType.u32,
+              FFIType.u8,
+              "usize",
+            ],
+            returns: "usize",
+          },
+          decision_tree_model_destroy: {
+            args: ["usize"],
+            returns: FFIType.void,
+          },
+          decision_tree_model_fit: {
+            args: ["usize", FFIType.ptr, FFIType.ptr, "usize", "usize", FFIType.ptr, "usize"],
+            returns: FFIType.u8,
+          },
+          decision_tree_model_predict: {
+            args: ["usize", FFIType.ptr, "usize", "usize", FFIType.ptr],
+            returns: FFIType.u8,
+          },
           logistic_train_epoch: {
             args: [
               FFIType.ptr,

package/src/preprocessing/Binarizer.ts

@@ -0,0 +1,46 @@
+import type { Matrix } from "../types";
+import {
+  assertConsistentRowSize,
+  assertFiniteMatrix,
+  assertNonEmptyMatrix,
+} from "../utils/validation";
+
+export interface BinarizerOptions {
+  threshold?: number;
+}
+
+export class Binarizer {
+  nFeaturesIn_: number | null = null;
+  private readonly threshold: number;
+
+  constructor(options: BinarizerOptions = {}) {
+    this.threshold = options.threshold ?? 0;
+    if (!Number.isFinite(this.threshold)) {
+      throw new Error(`threshold must be finite. Got ${this.threshold}.`);
+    }
+  }
+
+  fit(X: Matrix): this {
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+    this.nFeaturesIn_ = X[0].length;
+    return this;
+  }
+
+  transform(X: Matrix): Matrix {
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    if (this.nFeaturesIn_ !== null && X[0].length !== this.nFeaturesIn_) {
+      throw new Error(`Feature size mismatch. Expected ${this.nFeaturesIn_}, got ${X[0].length}.`);
+    }
+
+    return X.map((row) => row.map((value) => (value > this.threshold ? 1 : 0)));
+  }
+
+  fitTransform(X: Matrix): Matrix {
+    return this.fit(X).transform(X);
+  }
+}

package/src/preprocessing/LabelEncoder.ts

@@ -0,0 +1,62 @@
+import type { Vector } from "../types";
+import { assertFiniteVector } from "../utils/validation";
+
+export class LabelEncoder {
+  classes_: number[] | null = null;
+  private classToIndex: Map<number, number> | null = null;
+
+  fit(y: Vector): this {
+    if (!Array.isArray(y) || y.length === 0) {
+      throw new Error("y must be a non-empty array.");
+    }
+    assertFiniteVector(y);
+
+    const classes = Array.from(new Set(y)).sort((a, b) => a - b);
+    const classToIndex = new Map<number, number>();
+    for (let i = 0; i < classes.length; i += 1) {
+      classToIndex.set(classes[i], i);
+    }
+
+    this.classes_ = classes;
+    this.classToIndex = classToIndex;
+    return this;
+  }
+
+  transform(y: Vector): Vector {
+    if (!this.classToIndex) {
+      throw new Error("LabelEncoder has not been fitted.");
+    }
+    assertFiniteVector(y);
+
+    const encoded = new Array<number>(y.length);
+    for (let i = 0; i < y.length; i += 1) {
+      const idx = this.classToIndex.get(y[i]);
+      if (idx === undefined) {
+        throw new Error(`Unknown label ${y[i]} at index ${i}.`);
+      }
+      encoded[i] = idx;
+    }
+    return encoded;
+  }
+
+  fitTransform(y: Vector): Vector {
+    return this.fit(y).transform(y);
+  }
+
+  inverseTransform(y: Vector): Vector {
+    if (!this.classes_) {
+      throw new Error("LabelEncoder has not been fitted.");
+    }
+    assertFiniteVector(y);
+
+    const decoded = new Array<number>(y.length);
+    for (let i = 0; i < y.length; i += 1) {
+      const encoded = y[i];
+      if (!Number.isInteger(encoded) || encoded < 0 || encoded >= this.classes_.length) {
+        throw new Error(`Encoded label out of range at index ${i}: ${encoded}.`);
+      }
+      decoded[i] = this.classes_[encoded];
+    }
+    return decoded;
+  }
+}

package/src/preprocessing/MaxAbsScaler.ts

@@ -0,0 +1,77 @@
+import type { Matrix, Vector } from "../types";
+import {
+  assertConsistentRowSize,
+  assertFiniteMatrix,
+  assertNonEmptyMatrix,
+} from "../utils/validation";
+
+export class MaxAbsScaler {
+  maxAbs_: Vector | null = null;
+
+  fit(X: Matrix): this {
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    const nFeatures = X[0].length;
+    const maxAbs = new Array<number>(nFeatures).fill(0);
+
+    for (let i = 0; i < X.length; i += 1) {
+      for (let j = 0; j < nFeatures; j += 1) {
+        const abs = Math.abs(X[i][j]);
+        if (abs > maxAbs[j]) {
+          maxAbs[j] = abs;
+        }
+      }
+    }
+
+    for (let j = 0; j < nFeatures; j += 1) {
+      if (maxAbs[j] === 0) {
+        maxAbs[j] = 1;
+      }
+    }
+
+    this.maxAbs_ = maxAbs;
+    return this;
+  }
+
+  transform(X: Matrix): Matrix {
+    if (!this.maxAbs_) {
+      throw new Error("MaxAbsScaler has not been fitted.");
+    }
+
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    if (X[0].length !== this.maxAbs_.length) {
+      throw new Error(
+        `Feature size mismatch. Expected ${this.maxAbs_.length}, got ${X[0].length}.`,
+      );
+    }
+
+    return X.map((row) => row.map((value, featureIdx) => value / this.maxAbs_![featureIdx]));
+  }
+
+  fitTransform(X: Matrix): Matrix {
+    return this.fit(X).transform(X);
+  }
+
+  inverseTransform(X: Matrix): Matrix {
+    if (!this.maxAbs_) {
+      throw new Error("MaxAbsScaler has not been fitted.");
+    }
+
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    if (X[0].length !== this.maxAbs_.length) {
+      throw new Error(
+        `Feature size mismatch. Expected ${this.maxAbs_.length}, got ${X[0].length}.`,
+      );
+    }
+
+    return X.map((row) => row.map((value, featureIdx) => value * this.maxAbs_![featureIdx]));
+  }
+}

package/src/preprocessing/Normalizer.ts

@@ -0,0 +1,66 @@
+import type { Matrix } from "../types";
+import {
+  assertConsistentRowSize,
+  assertFiniteMatrix,
+  assertNonEmptyMatrix,
+} from "../utils/validation";
+
+export interface NormalizerOptions {
+  norm?: "l1" | "l2" | "max";
+}
+
+export class Normalizer {
+  private readonly norm: "l1" | "l2" | "max";
+  private nFeatures_: number | null = null;
+
+  constructor(options: NormalizerOptions = {}) {
+    this.norm = options.norm ?? "l2";
+  }
+
+  fit(X: Matrix): this {
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+    this.nFeatures_ = X[0].length;
+    return this;
+  }
+
+  transform(X: Matrix): Matrix {
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+    if (this.nFeatures_ !== null && X[0].length !== this.nFeatures_) {
+      throw new Error(`Feature size mismatch. Expected ${this.nFeatures_}, got ${X[0].length}.`);
+    }
+
+    return X.map((row) => {
+      let scale = 0;
+      if (this.norm === "l1") {
+        for (let i = 0; i < row.length; i += 1) {
+          scale += Math.abs(row[i]);
+        }
+      } else if (this.norm === "l2") {
+        for (let i = 0; i < row.length; i += 1) {
+          scale += row[i] * row[i];
+        }
+        scale = Math.sqrt(scale);
+      } else {
+        for (let i = 0; i < row.length; i += 1) {
+          const abs = Math.abs(row[i]);
+          if (abs > scale) {
+            scale = abs;
+          }
+        }
+      }
+
+      if (scale === 0) {
+        return [...row];
+      }
+      return row.map((value) => value / scale);
+    });
+  }
+
+  fitTransform(X: Matrix): Matrix {
+    return this.fit(X).transform(X);
+  }
+}