bun-scikit 0.1.1

package/src/pipeline/ColumnTransformer.ts

@@ -0,0 +1,203 @@
+import type { Matrix, Vector } from "../types";
+import { assertConsistentRowSize, assertFiniteMatrix, assertNonEmptyMatrix } from "../utils/validation";
+
+interface TransformerLike {
+  fit(X: Matrix, y?: Vector): unknown;
+  transform(X: Matrix): Matrix;
+  fitTransform?: (X: Matrix, y?: Vector) => Matrix;
+}
+
+export type ColumnSelector = number[] | { start: number; end: number };
+
+export type ColumnTransformerSpec = [name: string, transformer: TransformerLike, columns: ColumnSelector];
+
+export interface ColumnTransformerOptions {
+  remainder?: "drop" | "passthrough";
+}
+
+function normalizeColumns(selector: ColumnSelector, featureCount: number): number[] {
+  if (Array.isArray(selector)) {
+    if (selector.length === 0) {
+      throw new Error("Column selector arrays must not be empty.");
+    }
+    const normalized = selector.map((index) => {
+      if (!Number.isInteger(index) || index < 0 || index >= featureCount) {
+        throw new Error(`Invalid column index ${index} for featureCount=${featureCount}.`);
+      }
+      return index;
+    });
+    return Array.from(new Set(normalized)).sort((a, b) => a - b);
+  }
+
+  const { start, end } = selector;
+  if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end <= start || end > featureCount) {
+    throw new Error(
+      `Range selector must satisfy 0 <= start < end <= featureCount. Got start=${start}, end=${end}, featureCount=${featureCount}.`,
+    );
+  }
+  const columns = new Array<number>(end - start);
+  for (let i = start; i < end; i += 1) {
+    columns[i - start] = i;
+  }
+  return columns;
+}
+
+function selectColumns(X: Matrix, columns: number[]): Matrix {
+  return X.map((row) => columns.map((idx) => row[idx]));
+}
+
+function fitTransform(transformer: TransformerLike, X: Matrix, y?: Vector): Matrix {
+  if (typeof transformer.fitTransform === "function") {
+    return transformer.fitTransform(X, y);
+  }
+  transformer.fit(X, y);
+  return transformer.transform(X);
+}
+
+interface RuntimeSpec {
+  name: string;
+  transformer: TransformerLike;
+  columns: number[];
+}
+
+export class ColumnTransformer {
+  transformers_: ReadonlyArray<readonly [string, TransformerLike, number[]]> = [];
+
+  private readonly specs: ColumnTransformerSpec[];
+  private readonly remainder: "drop" | "passthrough";
+  private runtimeSpecs: RuntimeSpec[] = [];
+  private passthroughColumns: number[] = [];
+  private nFeaturesIn: number | null = null;
+  private isFitted = false;
+
+  constructor(specs: ColumnTransformerSpec[], options: ColumnTransformerOptions = {}) {
+    if (!Array.isArray(specs) || specs.length === 0) {
+      throw new Error("ColumnTransformer requires at least one transformer spec.");
+    }
+    this.specs = specs;
+    this.remainder = options.remainder ?? "drop";
+  }
+
+  fit(X: Matrix, y?: Vector): this {
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    const featureCount = X[0].length;
+    this.nFeaturesIn = featureCount;
+    const used = new Uint8Array(featureCount);
+    this.runtimeSpecs = [];
+
+    for (let i = 0; i < this.specs.length; i += 1) {
+      const [name, transformer, selector] = this.specs[i];
+      if (typeof name !== "string" || name.trim().length === 0) {
+        throw new Error("ColumnTransformer spec names must be non-empty strings.");
+      }
+      const columns = normalizeColumns(selector, featureCount);
+      for (let j = 0; j < columns.length; j += 1) {
+        used[columns[j]] = 1;
+      }
+      const subX = selectColumns(X, columns);
+      transformer.fit(subX, y);
+      this.runtimeSpecs.push({ name, transformer, columns });
+    }
+
+    this.passthroughColumns = [];
+    if (this.remainder === "passthrough") {
+      for (let i = 0; i < featureCount; i += 1) {
+        if (used[i] === 0) {
+          this.passthroughColumns.push(i);
+        }
+      }
+    }
+
+    this.transformers_ = this.runtimeSpecs.map(
+      (spec) => [spec.name, spec.transformer, spec.columns] as const,
+    );
+    this.isFitted = true;
+    return this;
+  }
+
+  transform(X: Matrix): Matrix {
+    if (!this.isFitted || this.nFeaturesIn === null) {
+      throw new Error("ColumnTransformer 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 transformedBlocks = this.runtimeSpecs.map((spec) =>
+      spec.transformer.transform(selectColumns(X, spec.columns)),
+    );
+    const passthroughBlock =
+      this.passthroughColumns.length > 0 ? selectColumns(X, this.passthroughColumns) : null;
+
+    const out = new Array<number[]>(X.length);
+    for (let rowIndex = 0; rowIndex < X.length; rowIndex += 1) {
+      const row: number[] = [];
+      for (let b = 0; b < transformedBlocks.length; b += 1) {
+        row.push(...transformedBlocks[b][rowIndex]);
+      }
+      if (passthroughBlock) {
+        row.push(...passthroughBlock[rowIndex]);
+      }
+      out[rowIndex] = row;
+    }
+    return out;
+  }
+
+  fitTransform(X: Matrix, y?: Vector): Matrix {
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    const featureCount = X[0].length;
+    this.nFeaturesIn = featureCount;
+    const used = new Uint8Array(featureCount);
+    this.runtimeSpecs = [];
+
+    const transformedBlocks: Matrix[] = [];
+    for (let i = 0; i < this.specs.length; i += 1) {
+      const [name, transformer, selector] = this.specs[i];
+      const columns = normalizeColumns(selector, featureCount);
+      for (let j = 0; j < columns.length; j += 1) {
+        used[columns[j]] = 1;
+      }
+      const transformed = fitTransform(transformer, selectColumns(X, columns), y);
+      transformedBlocks.push(transformed);
+      this.runtimeSpecs.push({ name, transformer, columns });
+    }
+
+    this.passthroughColumns = [];
+    if (this.remainder === "passthrough") {
+      for (let i = 0; i < featureCount; i += 1) {
+        if (used[i] === 0) {
+          this.passthroughColumns.push(i);
+        }
+      }
+    }
+    const passthroughBlock =
+      this.passthroughColumns.length > 0 ? selectColumns(X, this.passthroughColumns) : null;
+
+    this.transformers_ = this.runtimeSpecs.map(
+      (spec) => [spec.name, spec.transformer, spec.columns] as const,
+    );
+    this.isFitted = true;
+
+    const out = new Array<number[]>(X.length);
+    for (let rowIndex = 0; rowIndex < X.length; rowIndex += 1) {
+      const row: number[] = [];
+      for (let b = 0; b < transformedBlocks.length; b += 1) {
+        row.push(...transformedBlocks[b][rowIndex]);
+      }
+      if (passthroughBlock) {
+        row.push(...passthroughBlock[rowIndex]);
+      }
+      out[rowIndex] = row;
+    }
+    return out;
+  }
+}

package/src/pipeline/FeatureUnion.ts

@@ -0,0 +1,123 @@
+import type { Matrix, Vector } from "../types";
+import { assertConsistentRowSize, assertFiniteMatrix, assertNonEmptyMatrix } from "../utils/validation";
+
+interface TransformerLike {
+  fit(X: Matrix, y?: Vector): unknown;
+  transform(X: Matrix): Matrix;
+  fitTransform?: (X: Matrix, y?: Vector) => Matrix;
+}
+
+export type FeatureUnionSpec = [name: string, transformer: TransformerLike];
+
+function fitTransform(transformer: TransformerLike, X: Matrix, y?: Vector): Matrix {
+  if (typeof transformer.fitTransform === "function") {
+    return transformer.fitTransform(X, y);
+  }
+  transformer.fit(X, y);
+  return transformer.transform(X);
+}
+
+export class FeatureUnion {
+  transformerList_: ReadonlyArray<readonly [string, TransformerLike]> = [];
+
+  private readonly specs: FeatureUnionSpec[];
+  private runtimeSpecs: FeatureUnionSpec[] = [];
+  private nFeaturesIn: number | null = null;
+  private isFitted = false;
+
+  constructor(specs: FeatureUnionSpec[]) {
+    if (!Array.isArray(specs) || specs.length === 0) {
+      throw new Error("FeatureUnion requires at least one transformer.");
+    }
+    this.specs = specs;
+  }
+
+  fit(X: Matrix, y?: Vector): this {
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+    this.nFeaturesIn = X[0].length;
+
+    const seen = new Set<string>();
+    this.runtimeSpecs = [];
+    for (let i = 0; i < this.specs.length; i += 1) {
+      const [name, transformer] = this.specs[i];
+      if (typeof name !== "string" || name.trim().length === 0) {
+        throw new Error("FeatureUnion transformer names must be non-empty strings.");
+      }
+      if (seen.has(name)) {
+        throw new Error(`FeatureUnion transformer names must be unique. Duplicate '${name}'.`);
+      }
+      seen.add(name);
+      transformer.fit(X, y);
+      this.runtimeSpecs.push([name, transformer]);
+    }
+
+    this.transformerList_ = this.runtimeSpecs.map(
+      ([name, transformer]) => [name, transformer] as const,
+    );
+    this.isFitted = true;
+    return this;
+  }
+
+  transform(X: Matrix): Matrix {
+    if (!this.isFitted || this.nFeaturesIn === null) {
+      throw new Error("FeatureUnion 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 blocks = this.runtimeSpecs.map(([, transformer]) => transformer.transform(X));
+    const out = new Array<number[]>(X.length);
+    for (let rowIndex = 0; rowIndex < X.length; rowIndex += 1) {
+      const row: number[] = [];
+      for (let b = 0; b < blocks.length; b += 1) {
+        row.push(...blocks[b][rowIndex]);
+      }
+      out[rowIndex] = row;
+    }
+    return out;
+  }
+
+  fitTransform(X: Matrix, y?: Vector): Matrix {
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+    this.nFeaturesIn = X[0].length;
+
+    const seen = new Set<string>();
+    this.runtimeSpecs = [];
+    const blocks: Matrix[] = [];
+    for (let i = 0; i < this.specs.length; i += 1) {
+      const [name, transformer] = this.specs[i];
+      if (typeof name !== "string" || name.trim().length === 0) {
+        throw new Error("FeatureUnion transformer names must be non-empty strings.");
+      }
+      if (seen.has(name)) {
+        throw new Error(`FeatureUnion transformer names must be unique. Duplicate '${name}'.`);
+      }
+      seen.add(name);
+      blocks.push(fitTransform(transformer, X, y));
+      this.runtimeSpecs.push([name, transformer]);
+    }
+
+    this.transformerList_ = this.runtimeSpecs.map(
+      ([name, transformer]) => [name, transformer] as const,
+    );
+    this.isFitted = true;
+
+    const out = new Array<number[]>(X.length);
+    for (let rowIndex = 0; rowIndex < X.length; rowIndex += 1) {
+      const row: number[] = [];
+      for (let b = 0; b < blocks.length; b += 1) {
+        row.push(...blocks[b][rowIndex]);
+      }
+      out[rowIndex] = row;
+    }
+    return out;
+  }
+}

package/src/pipeline/Pipeline.ts

@@ -0,0 +1,168 @@
+import type { Matrix, Vector } from "../types";
+import { assertConsistentRowSize, assertNonEmptyMatrix } from "../utils/validation";
+
+type StepValue = Record<string, unknown>;
+
+interface RuntimeStep {
+  name: string;
+  value: StepValue;
+}
+
+interface Fittable {
+  fit(X: Matrix, y?: Vector): unknown;
+}
+
+interface TransformLike extends Fittable {
+  transform(X: Matrix): Matrix;
+  fitTransform?: (X: Matrix, y?: Vector) => Matrix;
+}
+
+interface PredictLike extends Fittable {
+  predict(X: Matrix): Vector;
+}
+
+function isObject(value: unknown): value is StepValue {
+  return typeof value === "object" && value !== null;
+}
+
+function hasFit(value: StepValue): value is StepValue & Fittable {
+  return typeof value.fit === "function";
+}
+
+function hasTransform(value: StepValue): value is StepValue & TransformLike {
+  return typeof value.transform === "function" && hasFit(value);
+}
+
+function hasPredict(value: StepValue): value is StepValue & PredictLike {
+  return typeof value.predict === "function" && hasFit(value);
+}
+
+function fitTransformStep(step: TransformLike, X: Matrix, y?: Vector): Matrix {
+  if (typeof step.fitTransform === "function") {
+    return step.fitTransform(X, y);
+  }
+  step.fit(X, y);
+  return step.transform(X);
+}
+
+export type PipelineStep = [name: string, step: unknown];
+
+export class Pipeline {
+  readonly steps_: ReadonlyArray<readonly [string, unknown]>;
+  readonly namedSteps_: Record<string, unknown>;
+  private readonly runtimeSteps: RuntimeStep[];
+  private isFitted = false;
+
+  constructor(steps: PipelineStep[]) {
+    if (steps.length === 0) {
+      throw new Error("Pipeline requires at least one step.");
+    }
+
+    const seen = new Set<string>();
+    const runtime: RuntimeStep[] = [];
+
+    for (const [name, step] of steps) {
+      if (typeof name !== "string" || name.trim().length === 0) {
+        throw new Error("Pipeline step names must be non-empty strings.");
+      }
+      if (seen.has(name)) {
+        throw new Error(`Pipeline step names must be unique. Duplicate step: '${name}'.`);
+      }
+      if (!isObject(step)) {
+        throw new Error(`Pipeline step '${name}' must be an object.`);
+      }
+      seen.add(name);
+      runtime.push({ name, value: step });
+    }
+
+    this.runtimeSteps = runtime;
+    this.steps_ = runtime.map((step) => [step.name, step.value] as const);
+    this.namedSteps_ = Object.fromEntries(runtime.map((step) => [step.name, step.value]));
+  }
+
+  fit(X: Matrix, y?: Vector): this {
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+
+    let transformedX = X;
+    const lastIndex = this.runtimeSteps.length - 1;
+
+    for (let i = 0; i < lastIndex; i += 1) {
+      const current = this.runtimeSteps[i];
+      if (!hasTransform(current.value)) {
+        throw new Error(
+          `Pipeline step '${current.name}' must implement fit() and transform() because it is not the final step.`,
+        );
+      }
+      transformedX = fitTransformStep(current.value, transformedX, y);
+    }
+
+    const finalStep = this.runtimeSteps[lastIndex];
+    if (!hasFit(finalStep.value)) {
+      throw new Error(`Pipeline final step '${finalStep.name}' must implement fit().`);
+    }
+
+    if (!hasTransform(finalStep.value) && y === undefined) {
+      throw new Error(
+        `Pipeline final step '${finalStep.name}' requires target labels y for fit().`,
+      );
+    }
+
+    finalStep.value.fit(transformedX, y);
+    this.isFitted = true;
+    return this;
+  }
+
+  predict(X: Matrix): Vector {
+    this.assertFitted();
+
+    const lastStep = this.runtimeSteps[this.runtimeSteps.length - 1];
+    if (!hasPredict(lastStep.value)) {
+      throw new Error(`Pipeline final step '${lastStep.name}' does not implement predict().`);
+    }
+
+    const transformed = this.transformThroughIntermediates(X);
+    return lastStep.value.predict(transformed);
+  }
+
+  transform(X: Matrix): Matrix {
+    this.assertFitted();
+
+    const transformed = this.transformThroughIntermediates(X);
+    const lastStep = this.runtimeSteps[this.runtimeSteps.length - 1];
+    if (!hasTransform(lastStep.value)) {
+      throw new Error(`Pipeline final step '${lastStep.name}' does not implement transform().`);
+    }
+
+    return lastStep.value.transform(transformed);
+  }
+
+  fitTransform(X: Matrix, y?: Vector): Matrix {
+    this.fit(X, y);
+    return this.transform(X);
+  }
+
+  private transformThroughIntermediates(X: Matrix): Matrix {
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+
+    let transformedX = X;
+    const lastIndex = this.runtimeSteps.length - 1;
+    for (let i = 0; i < lastIndex; i += 1) {
+      const current = this.runtimeSteps[i];
+      if (!hasTransform(current.value)) {
+        throw new Error(
+          `Pipeline step '${current.name}' must implement transform() for inference.`,
+        );
+      }
+      transformedX = current.value.transform(transformedX);
+    }
+    return transformedX;
+  }
+
+  private assertFitted(): void {
+    if (!this.isFitted) {
+      throw new Error("Pipeline has not been fitted.");
+    }
+  }
+}

package/src/preprocessing/MinMaxScaler.ts

@@ -0,0 +1,113 @@
+import type { Matrix, Vector } from "../types";
+import {
+  assertConsistentRowSize,
+  assertFiniteMatrix,
+  assertNonEmptyMatrix,
+} from "../utils/validation";
+
+export interface MinMaxScalerOptions {
+  featureRange?: [number, number];
+}
+
+export class MinMaxScaler {
+  dataMin_: Vector | null = null;
+  dataMax_: Vector | null = null;
+  dataRange_: Vector | null = null;
+  scale_: Vector | null = null;
+  min_: Vector | null = null;
+
+  private readonly featureRange: [number, number];
+
+  constructor(options: MinMaxScalerOptions = {}) {
+    this.featureRange = options.featureRange ?? [0, 1];
+    const [rangeMin, rangeMax] = this.featureRange;
+    if (!Number.isFinite(rangeMin) || !Number.isFinite(rangeMax) || rangeMin >= rangeMax) {
+      throw new Error(
+        `featureRange must be finite and satisfy min < max. Got [${rangeMin}, ${rangeMax}].`,
+      );
+    }
+  }
+
+  fit(X: Matrix): this {
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    const nFeatures = X[0].length;
+    const dataMin = new Array(nFeatures).fill(Number.POSITIVE_INFINITY);
+    const dataMax = new Array(nFeatures).fill(Number.NEGATIVE_INFINITY);
+
+    for (let i = 0; i < X.length; i += 1) {
+      for (let j = 0; j < nFeatures; j += 1) {
+        const value = X[i][j];
+        if (value < dataMin[j]) {
+          dataMin[j] = value;
+        }
+        if (value > dataMax[j]) {
+          dataMax[j] = value;
+        }
+      }
+    }
+
+    const [rangeMin, rangeMax] = this.featureRange;
+    const targetRange = rangeMax - rangeMin;
+    const dataRange = new Array(nFeatures).fill(0);
+    const scale = new Array(nFeatures).fill(1);
+    const min = new Array(nFeatures).fill(rangeMin);
+
+    for (let j = 0; j < nFeatures; j += 1) {
+      const featureDataRange = dataMax[j] - dataMin[j];
+      dataRange[j] = featureDataRange;
+      const safeDenominator = featureDataRange === 0 ? 1 : featureDataRange;
+      scale[j] = targetRange / safeDenominator;
+      min[j] = rangeMin - dataMin[j] * scale[j];
+    }
+
+    this.dataMin_ = dataMin;
+    this.dataMax_ = dataMax;
+    this.dataRange_ = dataRange;
+    this.scale_ = scale;
+    this.min_ = min;
+    return this;
+  }
+
+  transform(X: Matrix): Matrix {
+    if (!this.scale_ || !this.min_) {
+      throw new Error("MinMaxScaler has not been fitted.");
+    }
+
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    if (X[0].length !== this.scale_.length) {
+      throw new Error(`Feature size mismatch. Expected ${this.scale_.length}, got ${X[0].length}.`);
+    }
+
+    return X.map((row) =>
+      row.map((value, featureIdx) => value * this.scale_![featureIdx] + this.min_![featureIdx]),
+    );
+  }
+
+  fitTransform(X: Matrix): Matrix {
+    return this.fit(X).transform(X);
+  }
+
+  inverseTransform(X: Matrix): Matrix {
+    if (!this.scale_ || !this.min_) {
+      throw new Error("MinMaxScaler has not been fitted.");
+    }
+
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    if (X[0].length !== this.scale_.length) {
+      throw new Error(`Feature size mismatch. Expected ${this.scale_.length}, got ${X[0].length}.`);
+    }
+
+    return X.map((row) =>
+      row.map((value, featureIdx) => (value - this.min_![featureIdx]) / this.scale_![featureIdx]),
+    );
+  }
+}

package/src/preprocessing/OneHotEncoder.ts

@@ -0,0 +1,91 @@
+import type { Matrix } from "../types";
+import { assertConsistentRowSize, assertFiniteMatrix, assertNonEmptyMatrix } from "../utils/validation";
+
+export interface OneHotEncoderOptions {
+  handleUnknown?: "error" | "ignore";
+}
+
+export class OneHotEncoder {
+  categories_: number[][] | null = null;
+  nFeaturesIn_: number | null = null;
+  nOutputFeatures_: number | null = null;
+  featureOffsets_: number[] | null = null;
+
+  private readonly handleUnknown: "error" | "ignore";
+
+  constructor(options: OneHotEncoderOptions = {}) {
+    this.handleUnknown = options.handleUnknown ?? "error";
+  }
+
+  fit(X: Matrix): this {
+    assertNonEmptyMatrix(X);
+    assertConsistentRowSize(X);
+    assertFiniteMatrix(X);
+
+    const nFeatures = X[0].length;
+    const categories = new Array<number[]>(nFeatures);
+    const offsets = new Array<number>(nFeatures);
+    let offset = 0;
+
+    for (let featureIndex = 0; featureIndex < nFeatures; featureIndex += 1) {
+      const unique = new Set<number>();
+      for (let i = 0; i < X.length; i += 1) {
+        unique.add(X[i][featureIndex]);
+      }
+      const values = Array.from(unique).sort((a, b) => a - b);
+      categories[featureIndex] = values;
+      offsets[featureIndex] = offset;
+      offset += values.length;
+    }
+
+    this.categories_ = categories;
+    this.nFeaturesIn_ = nFeatures;
+    this.nOutputFeatures_ = offset;
+    this.featureOffsets_ = offsets;
+    return this;
+  }
+
+  transform(X: Matrix): Matrix {
+    if (
+      this.categories_ === null ||
+      this.nFeaturesIn_ === null ||
+      this.nOutputFeatures_ === null ||
+      this.featureOffsets_ === null
+    ) {
+      throw new Error("OneHotEncoder 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 encoded = new Array<number[]>(X.length);
+    for (let rowIndex = 0; rowIndex < X.length; rowIndex += 1) {
+      const row = new Array<number>(this.nOutputFeatures_).fill(0);
+      for (let featureIndex = 0; featureIndex < this.nFeaturesIn_; featureIndex += 1) {
+        const value = X[rowIndex][featureIndex];
+        const categories = this.categories_[featureIndex];
+        const categoryIndex = categories.indexOf(value);
+        if (categoryIndex === -1) {
+          if (this.handleUnknown === "error") {
+            throw new Error(
+              `Unknown category ${value} in feature ${featureIndex}. Set handleUnknown='ignore' to skip.`,
+            );
+          }
+          continue;
+        }
+        row[this.featureOffsets_[featureIndex] + categoryIndex] = 1;
+      }
+      encoded[rowIndex] = row;
+    }
+    return encoded;
+  }
+
+  fitTransform(X: Matrix): Matrix {
+    return this.fit(X).transform(X);
+  }
+}