bun-scikit 0.1.1

package/src/preprocessing/PolynomialFeatures.ts

@@ -0,0 +1,158 @@
+import type { Matrix } from "../types";
+import {
+  assertConsistentRowSize,
+  assertFiniteMatrix,
+  assertNonEmptyMatrix,
+} from "../utils/validation";
+
+export interface PolynomialFeaturesOptions {
+  degree?: number;
+  includeBias?: boolean;
+  interactionOnly?: boolean;
+}
+
+type TermPower = number[];
+
+function generateCombinationsWithReplacement(
+  nFeatures: number,
+  degree: number,
+  start: number,
+  current: number[],
+  out: number[][],
+): void {
+  if (current.length === degree) {
+    out.push(current.slice());
+    return;
+  }
+
+  for (let featureIndex = start; featureIndex < nFeatures; featureIndex += 1) {
+    current.push(featureIndex);
+    generateCombinationsWithReplacement(
+      nFeatures,
+      degree,
+      featureIndex,
+      current,
+      out,
+    );
+    current.pop();
+  }
+}
+
+function generateCombinationsWithoutReplacement(
+  nFeatures: number,
+  degree: number,
+  start: number,
+  current: number[],
+  out: number[][],
+): void {
+  if (current.length === degree) {
+    out.push(current.slice());
+    return;
+  }
+
+  for (let featureIndex = start; featureIndex < nFeatures; featureIndex += 1) {
+    current.push(featureIndex);
+    generateCombinationsWithoutReplacement(
+      nFeatures,
+      degree,
+      featureIndex + 1,
+      current,
+      out,
+    );
+    current.pop();
+  }
+}
+
+export class PolynomialFeatures {
+  nFeaturesIn_: number | null = null;
+  nOutputFeatures_: number | null = null;
+  powers_: number[][] | null = null;
+
+  private readonly degree: number;
+  private readonly includeBias: boolean;
+  private readonly interactionOnly: boolean;
+
+  constructor(options: PolynomialFeaturesOptions = {}) {
+    this.degree = options.degree ?? 2;
+    this.includeBias = options.includeBias ?? true;
+    this.interactionOnly = options.interactionOnly ?? false;
+
+    if (!Number.isInteger(this.degree) || this.degree < 0) {
+      throw new Error(`degree must be an integer >= 0. Got ${this.degree}.`);
+    }
+  }
+
+  fit(X: Matrix): this {
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    const nFeatures = X[0].length;
+    const powers: TermPower[] = [];
+
+    if (this.includeBias) {
+      powers.push(new Array<number>(nFeatures).fill(0));
+    }
+
+    for (let d = 1; d <= this.degree; d += 1) {
+      const combinations: number[][] = [];
+      if (this.interactionOnly) {
+        generateCombinationsWithoutReplacement(nFeatures, d, 0, [], combinations);
+      } else {
+        generateCombinationsWithReplacement(nFeatures, d, 0, [], combinations);
+      }
+
+      for (let i = 0; i < combinations.length; i += 1) {
+        const power = new Array<number>(nFeatures).fill(0);
+        for (let j = 0; j < combinations[i].length; j += 1) {
+          power[combinations[i][j]] += 1;
+        }
+        powers.push(power);
+      }
+    }
+
+    this.nFeaturesIn_ = nFeatures;
+    this.nOutputFeatures_ = powers.length;
+    this.powers_ = powers;
+    return this;
+  }
+
+  transform(X: Matrix): Matrix {
+    if (this.nFeaturesIn_ === null || this.powers_ === null || this.nOutputFeatures_ === null) {
+      throw new Error("PolynomialFeatures has not been fitted.");
+    }
+
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    if (X[0].length !== this.nFeaturesIn_) {
+      throw new Error(`Feature size mismatch. Expected ${this.nFeaturesIn_}, got ${X[0].length}.`);
+    }
+
+    const transformed = new Array<number[]>(X.length);
+    for (let i = 0; i < X.length; i += 1) {
+      const row = X[i];
+      const outRow = new Array<number>(this.nOutputFeatures_);
+      for (let termIndex = 0; termIndex < this.powers_.length; termIndex += 1) {
+        const power = this.powers_[termIndex];
+        let value = 1;
+        for (let featureIndex = 0; featureIndex < this.nFeaturesIn_; featureIndex += 1) {
+          const exponent = power[featureIndex];
+          if (exponent === 1) {
+            value *= row[featureIndex];
+          } else if (exponent > 1) {
+            value *= row[featureIndex] ** exponent;
+          }
+        }
+        outRow[termIndex] = value;
+      }
+      transformed[i] = outRow;
+    }
+    return transformed;
+  }
+
+  fitTransform(X: Matrix): Matrix {
+    return this.fit(X).transform(X);
+  }
+}

package/src/preprocessing/RobustScaler.ts

@@ -0,0 +1,149 @@
+import type { Matrix, Vector } from "../types";
+import {
+  assertConsistentRowSize,
+  assertFiniteMatrix,
+  assertNonEmptyMatrix,
+} from "../utils/validation";
+
+export interface RobustScalerOptions {
+  withCentering?: boolean;
+  withScaling?: boolean;
+  quantileRange?: [number, number];
+}
+
+function percentile(sortedValues: number[], q: number): number {
+  if (sortedValues.length === 0) {
+    throw new Error("Cannot compute percentile of an empty array.");
+  }
+  if (q <= 0) {
+    return sortedValues[0];
+  }
+  if (q >= 100) {
+    return sortedValues[sortedValues.length - 1];
+  }
+
+  const position = (q / 100) * (sortedValues.length - 1);
+  const lowerIndex = Math.floor(position);
+  const upperIndex = Math.ceil(position);
+  if (lowerIndex === upperIndex) {
+    return sortedValues[lowerIndex];
+  }
+
+  const weight = position - lowerIndex;
+  return sortedValues[lowerIndex] * (1 - weight) + sortedValues[upperIndex] * weight;
+}
+
+export class RobustScaler {
+  center_: Vector | null = null;
+  scale_: Vector | null = null;
+
+  private readonly withCentering: boolean;
+  private readonly withScaling: boolean;
+  private readonly quantileRange: [number, number];
+
+  constructor(options: RobustScalerOptions = {}) {
+    this.withCentering = options.withCentering ?? true;
+    this.withScaling = options.withScaling ?? true;
+    this.quantileRange = options.quantileRange ?? [25, 75];
+
+    const [qMin, qMax] = this.quantileRange;
+    if (
+      !Number.isFinite(qMin) ||
+      !Number.isFinite(qMax) ||
+      qMin < 0 ||
+      qMax > 100 ||
+      qMin >= qMax
+    ) {
+      throw new Error(
+        `quantileRange must satisfy 0 <= qMin < qMax <= 100. Got [${qMin}, ${qMax}].`,
+      );
+    }
+  }
+
+  fit(X: Matrix): this {
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    const nFeatures = X[0].length;
+    const centers = new Array<number>(nFeatures).fill(0);
+    const scales = new Array<number>(nFeatures).fill(1);
+    const [qMin, qMax] = this.quantileRange;
+
+    for (let featureIndex = 0; featureIndex < nFeatures; featureIndex += 1) {
+      const values = new Array<number>(X.length);
+      for (let i = 0; i < X.length; i += 1) {
+        values[i] = X[i][featureIndex];
+      }
+      values.sort((a, b) => a - b);
+
+      centers[featureIndex] = percentile(values, 50);
+      const lower = percentile(values, qMin);
+      const upper = percentile(values, qMax);
+      const iqr = upper - lower;
+      scales[featureIndex] = iqr === 0 ? 1 : iqr;
+    }
+
+    this.center_ = centers;
+    this.scale_ = scales;
+    return this;
+  }
+
+  transform(X: Matrix): Matrix {
+    if (!this.center_ || !this.scale_) {
+      throw new Error("RobustScaler has not been fitted.");
+    }
+
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    if (X[0].length !== this.center_.length) {
+      throw new Error(`Feature size mismatch. Expected ${this.center_.length}, got ${X[0].length}.`);
+    }
+
+    return X.map((row) =>
+      row.map((value, featureIndex) => {
+        let out = value;
+        if (this.withCentering) {
+          out -= this.center_![featureIndex];
+        }
+        if (this.withScaling) {
+          out /= this.scale_![featureIndex];
+        }
+        return out;
+      }),
+    );
+  }
+
+  fitTransform(X: Matrix): Matrix {
+    return this.fit(X).transform(X);
+  }
+
+  inverseTransform(X: Matrix): Matrix {
+    if (!this.center_ || !this.scale_) {
+      throw new Error("RobustScaler has not been fitted.");
+    }
+
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    if (X[0].length !== this.center_.length) {
+      throw new Error(`Feature size mismatch. Expected ${this.center_.length}, got ${X[0].length}.`);
+    }
+
+    return X.map((row) =>
+      row.map((value, featureIndex) => {
+        let out = value;
+        if (this.withScaling) {
+          out *= this.scale_![featureIndex];
+        }
+        if (this.withCentering) {
+          out += this.center_![featureIndex];
+        }
+        return out;
+      }),
+    );
+  }
+}

package/src/preprocessing/SimpleImputer.ts

@@ -0,0 +1,150 @@
+import type { Matrix, Vector } from "../types";
+import { assertConsistentRowSize, assertNonEmptyMatrix } from "../utils/validation";
+
+export type ImputerStrategy = "mean" | "median" | "most_frequent" | "constant";
+
+export interface SimpleImputerOptions {
+  strategy?: ImputerStrategy;
+  fillValue?: number;
+}
+
+function isMissing(value: number): boolean {
+  return Number.isNaN(value);
+}
+
+function assertFiniteOrMissing(X: Matrix, label = "X"): void {
+  for (let i = 0; i < X.length; i += 1) {
+    for (let j = 0; j < X[i].length; j += 1) {
+      const value = X[i][j];
+      if (!Number.isFinite(value) && !isMissing(value)) {
+        throw new Error(`${label} contains non-finite non-missing value at [${i}, ${j}].`);
+      }
+    }
+  }
+}
+
+function median(values: number[]): number {
+  if (values.length === 0) {
+    throw new Error("Cannot compute median of an empty array.");
+  }
+  const sorted = values.slice().sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+  if (sorted.length % 2 === 0) {
+    return 0.5 * (sorted[middle - 1] + sorted[middle]);
+  }
+  return sorted[middle];
+}
+
+function mostFrequent(values: number[]): number {
+  if (values.length === 0) {
+    throw new Error("Cannot compute most frequent of an empty array.");
+  }
+  const counts = new Map<number, number>();
+  for (let i = 0; i < values.length; i += 1) {
+    counts.set(values[i], (counts.get(values[i]) ?? 0) + 1);
+  }
+
+  let bestValue = values[0];
+  let bestCount = counts.get(bestValue)!;
+  for (const [value, count] of counts.entries()) {
+    if (count > bestCount || (count === bestCount && value < bestValue)) {
+      bestValue = value;
+      bestCount = count;
+    }
+  }
+  return bestValue;
+}
+
+export class SimpleImputer {
+  statistics_: Vector | null = null;
+  private readonly strategy: ImputerStrategy;
+  private readonly fillValue?: number;
+
+  constructor(options: SimpleImputerOptions = {}) {
+    this.strategy = options.strategy ?? "mean";
+    this.fillValue = options.fillValue;
+
+    if (this.strategy === "constant") {
+      const value = this.fillValue ?? 0;
+      if (!Number.isFinite(value)) {
+        throw new Error(`fillValue must be finite for constant strategy. Got ${value}.`);
+      }
+    }
+  }
+
+  fit(X: Matrix): this {
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteOrMissing(X);
+
+    const nFeatures = X[0].length;
+    const stats = new Array<number>(nFeatures);
+
+    for (let featureIndex = 0; featureIndex < nFeatures; featureIndex += 1) {
+      const values: number[] = [];
+      for (let i = 0; i < X.length; i += 1) {
+        const value = X[i][featureIndex];
+        if (!isMissing(value)) {
+          values.push(value);
+        }
+      }
+
+      if (values.length === 0) {
+        if (this.strategy === "constant") {
+          stats[featureIndex] = this.fillValue ?? 0;
+          continue;
+        }
+        throw new Error(
+          `Feature at index ${featureIndex} has only missing values. Use strategy='constant' or provide observed values.`,
+        );
+      }
+
+      switch (this.strategy) {
+        case "mean": {
+          let sum = 0;
+          for (let i = 0; i < values.length; i += 1) {
+            sum += values[i];
+          }
+          stats[featureIndex] = sum / values.length;
+          break;
+        }
+        case "median":
+          stats[featureIndex] = median(values);
+          break;
+        case "most_frequent":
+          stats[featureIndex] = mostFrequent(values);
+          break;
+        case "constant":
+          stats[featureIndex] = this.fillValue ?? 0;
+          break;
+      }
+    }
+
+    this.statistics_ = stats;
+    return this;
+  }
+
+  transform(X: Matrix): Matrix {
+    if (!this.statistics_) {
+      throw new Error("SimpleImputer has not been fitted.");
+    }
+
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteOrMissing(X);
+
+    if (X[0].length !== this.statistics_.length) {
+      throw new Error(
+        `Feature size mismatch. Expected ${this.statistics_.length}, got ${X[0].length}.`,
+      );
+    }
+
+    return X.map((row) =>
+      row.map((value, featureIndex) => (isMissing(value) ? this.statistics_![featureIndex] : value)),
+    );
+  }
+
+  fitTransform(X: Matrix): Matrix {
+    return this.fit(X).transform(X);
+  }
+}

package/src/preprocessing/StandardScaler.ts

@@ -0,0 +1,92 @@
+import type { Matrix, Vector } from "../types";
+import {
+  assertConsistentRowSize,
+  assertFiniteMatrix,
+  assertNonEmptyMatrix,
+} from "../utils/validation";
+
+export class StandardScaler {
+  mean_: Vector | null = null;
+  scale_: Vector | null = null;
+
+  fit(X: Matrix): this {
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    const nSamples = X.length;
+    const nFeatures = X[0].length;
+    const means = new Array(nFeatures).fill(0);
+    const variances = new Array(nFeatures).fill(0);
+
+    for (let i = 0; i < nSamples; i += 1) {
+      for (let j = 0; j < nFeatures; j += 1) {
+        means[j] += X[i][j];
+      }
+    }
+
+    for (let j = 0; j < nFeatures; j += 1) {
+      means[j] /= nSamples;
+    }
+
+    for (let i = 0; i < nSamples; i += 1) {
+      for (let j = 0; j < nFeatures; j += 1) {
+        const diff = X[i][j] - means[j];
+        variances[j] += diff * diff;
+      }
+    }
+
+    const scales = variances.map((v) => {
+      const std = Math.sqrt(v / nSamples);
+      return std === 0 ? 1 : std;
+    });
+
+    this.mean_ = means;
+    this.scale_ = scales;
+    return this;
+  }
+
+  transform(X: Matrix): Matrix {
+    if (!this.mean_ || !this.scale_) {
+      throw new Error("StandardScaler has not been fitted.");
+    }
+
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    if (X[0].length !== this.mean_.length) {
+      throw new Error(
+        `Feature size mismatch. Expected ${this.mean_.length}, got ${X[0].length}.`,
+      );
+    }
+
+    return X.map((row) =>
+      row.map((value, featureIdx) => (value - this.mean_![featureIdx]) / this.scale_![featureIdx]),
+    );
+  }
+
+  fitTransform(X: Matrix): Matrix {
+    return this.fit(X).transform(X);
+  }
+
+  inverseTransform(X: Matrix): Matrix {
+    if (!this.mean_ || !this.scale_) {
+      throw new Error("StandardScaler has not been fitted.");
+    }
+
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    if (X[0].length !== this.mean_.length) {
+      throw new Error(
+        `Feature size mismatch. Expected ${this.mean_.length}, got ${X[0].length}.`,
+      );
+    }
+
+    return X.map((row) =>
+      row.map((value, featureIdx) => value * this.scale_![featureIdx] + this.mean_![featureIdx]),
+    );
+  }
+}

package/src/svm/LinearSVC.ts

@@ -0,0 +1,117 @@
+import type { ClassificationModel, Matrix, Vector } from "../types";
+import { accuracyScore } from "../metrics/classification";
+import { dot } from "../utils/linalg";
+import {
+  assertConsistentRowSize,
+  assertFiniteMatrix,
+  assertFiniteVector,
+  validateClassificationInputs,
+} from "../utils/validation";
+
+export interface LinearSVCOptions {
+  fitIntercept?: boolean;
+  C?: number;
+  learningRate?: number;
+  maxIter?: number;
+  tolerance?: number;
+}
+
+export class LinearSVC implements ClassificationModel {
+  coef_: Vector = [];
+  intercept_ = 0;
+  classes_: Vector = [0, 1];
+
+  private readonly fitIntercept: boolean;
+  private readonly C: number;
+  private readonly learningRate: number;
+  private readonly maxIter: number;
+  private readonly tolerance: number;
+  private isFitted = false;
+
+  constructor(options: LinearSVCOptions = {}) {
+    this.fitIntercept = options.fitIntercept ?? true;
+    this.C = options.C ?? 1.0;
+    this.learningRate = options.learningRate ?? 0.05;
+    this.maxIter = options.maxIter ?? 10_000;
+    this.tolerance = options.tolerance ?? 1e-6;
+
+    if (!Number.isFinite(this.C) || this.C <= 0) {
+      throw new Error(`C must be > 0. Got ${this.C}.`);
+    }
+  }
+
+  fit(X: Matrix, y: Vector): this {
+    validateClassificationInputs(X, y);
+    const nSamples = X.length;
+    const nFeatures = X[0].length;
+
+    this.coef_ = new Array<number>(nFeatures).fill(0);
+    this.intercept_ = 0;
+    const ySigned = y.map((value) => (value === 1 ? 1 : -1));
+
+    for (let iter = 0; iter < this.maxIter; iter += 1) {
+      const gradients = this.coef_.slice();
+      let interceptGradient = 0;
+
+      for (let i = 0; i < nSamples; i += 1) {
+        const margin = ySigned[i] * (dot(X[i], this.coef_) + this.intercept_);
+        if (margin < 1) {
+          const factor = -this.C * ySigned[i];
+          for (let j = 0; j < nFeatures; j += 1) {
+            gradients[j] += factor * X[i][j];
+          }
+          if (this.fitIntercept) {
+            interceptGradient += factor;
+          }
+        }
+      }
+
+      let maxUpdate = 0;
+      for (let j = 0; j < nFeatures; j += 1) {
+        const delta = this.learningRate * (gradients[j] / nSamples);
+        this.coef_[j] -= delta;
+        const absDelta = Math.abs(delta);
+        if (absDelta > maxUpdate) {
+          maxUpdate = absDelta;
+        }
+      }
+
+      if (this.fitIntercept) {
+        const interceptDelta = this.learningRate * (interceptGradient / nSamples);
+        this.intercept_ -= interceptDelta;
+        const absInterceptDelta = Math.abs(interceptDelta);
+        if (absInterceptDelta > maxUpdate) {
+          maxUpdate = absInterceptDelta;
+        }
+      }
+
+      if (maxUpdate < this.tolerance) {
+        break;
+      }
+    }
+
+    this.isFitted = true;
+    return this;
+  }
+
+  decisionFunction(X: Matrix): Vector {
+    if (!this.isFitted) {
+      throw new Error("LinearSVC 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) => dot(row, this.coef_) + this.intercept_);
+  }
+
+  predict(X: Matrix): Vector {
+    return this.decisionFunction(X).map((score) => (score >= 0 ? 1 : 0));
+  }
+
+  score(X: Matrix, y: Vector): number {
+    assertFiniteVector(y);
+    return accuracyScore(y, this.predict(X));
+  }
+}