ts-classify 0.1.0

package/README.md

@@ -0,0 +1,169 @@
+# SVM
+
+A fast Support Vector Machine implementation in Rust, targeting both native and WebAssembly.
+
+## Features
+
+- **Binary SVM** with two solvers:
+  - **Coordinate Descent** (default) - O(N) per pass, fast for large datasets
+  - **SMO** - O(N²), useful for kernel SVMs (future)
+- **Multiclass classification**:
+  - **One-vs-Rest (OvR)** - K classifiers for K classes, fast prediction
+  - **One-vs-One (OvO)** - K(K-1)/2 classifiers, often more accurate
+- **Sparse vectors** - efficient for high-dimensional data (text, trigrams)
+- **Parallel training** via rayon (native only)
+- **Binary serialization** via bincode
+- **WebAssembly support** with JS-friendly API
+
+## Installation
+
+```toml
+[dependencies]
+svm = { path = "." }
+```
+
+## Usage
+
+### Binary SVM
+
+```rust
+use svm::{SVM, SparseVec};
+
+// Sparse format: Vec<(index, value)>
+let samples: Vec<SparseVec> = vec![
+    vec![(0, -2.0), (1, 0.0)],
+    vec![(0, -1.0), (1, 1.0)],
+    vec![(0, 1.0), (1, 0.0)],
+    vec![(0, 2.0), (1, 1.0)],
+];
+let labels = vec![-1.0, -1.0, 1.0, 1.0];
+
+let mut svm = SVM::new();
+svm.train_sparse(&samples, &labels);
+
+assert_eq!(svm.predict_sparse(&[(0, -3.0)]), -1.0);
+assert_eq!(svm.predict_sparse(&[(0, 3.0)]), 1.0);
+```
+
+### Multiclass (One-vs-Rest)
+
+```rust
+use svm::{OneVsRestSVM, SparseVec};
+
+let samples: Vec<SparseVec> = vec![
+    vec![(0, -2.0), (1, -2.0)],  // class 0
+    vec![(0, 2.0), (1, -2.0)],   // class 1
+    vec![(0, 0.0), (1, 2.0)],    // class 2
+    // ... more samples
+];
+let labels = vec![0, 1, 2, /* ... */];
+
+let mut svm = OneVsRestSVM::new();
+svm.train_sparse(&samples, &labels);
+
+let predicted_class = svm.predict_sparse(&[(0, 0.0), (1, 3.0)]);
+```
+
+### Custom Configuration
+
+```rust
+use svm::{SVM, TrainConfig, Solver};
+
+let config = TrainConfig::coordinate_descent()
+    .with_c(0.5)           // regularization (default: 1.0)
+    .with_max_iter(500)    // max iterations (default: 1000)
+    .with_tol(0.001);      // tolerance (default: 0.01)
+
+let mut svm = SVM::new();
+svm.train_sparse_with_config(&samples, &labels, &config);
+
+// Or use SMO solver
+let config = TrainConfig::smo()
+    .with_c(1.0)
+    .with_max_iter(10000);
+```
+
+### Serialization
+
+```rust
+// Save
+let bytes = svm.to_bytes()?;
+std::fs::write("model.bin", &bytes)?;
+
+// Load
+let bytes = std::fs::read("model.bin")?;
+let svm = SVM::from_bytes(&bytes)?;
+```
+
+## WebAssembly
+
+Build for WASM (without parallel feature):
+
+```bash
+cargo build --release --target wasm32-unknown-unknown --no-default-features
+```
+
+Or use wasm-pack:
+
+```bash
+wasm-pack build --target web --no-default-features
+```
+
+### JavaScript API
+
+```javascript
+import { JsOneVsRestSVM } from 'svm';
+
+const svm = new JsOneVsRestSVM();
+
+// Flat sparse format: [idx, val, idx, val, ...]
+const sampleFlat = new Float64Array([0, -2.0, 1, 0.0]);  // single sample
+const samplesFlat = new Float64Array([
+    0, -2.0, 1, 0.0,  // sample 0: 2 pairs
+    0, 1.0, 1, 1.0,   // sample 1: 2 pairs
+]);
+const sampleLengths = new Uint32Array([2, 2]);  // pairs per sample
+const labels = new Int32Array([0, 1]);
+
+svm.train(samplesFlat, sampleLengths, labels);
+
+const prediction = svm.predict(sampleFlat);
+
+// Serialize/deserialize
+const bytes = svm.to_bytes();
+const loaded = JsOneVsRestSVM.from_bytes(bytes);
+```
+
+## Performance
+
+Coordinate descent vs SMO on 50-class OvR:
+
+| Solver | Train Time |
+|--------|------------|
+| Coordinate Descent | 6ms |
+| SMO | 29s |
+
+Scaling (coordinate descent, OvR):
+
+| Classes | Classifiers | Train | Predict |
+|---------|-------------|-------|---------|
+| 10 | 10 | 511µs | 144ns |
+| 50 | 50 | 560µs | 743ns |
+| 100 | 100 | 1.4ms | 1.6µs |
+| 5000 | 5000 | ~50-100ms | ~80µs |
+
+## Feature Flags
+
+- `parallel` (default) - Enable parallel training via rayon. Disable for WASM.
+
+```toml
+# Native with parallel
+svm = { path = "." }
+
+# WASM (no parallel)
+svm = { path = ".", default-features = false }
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "ts-classify",
+  "type": "module",
+  "description": "Fast text classification with SVM and Nearest Centroid (WebAssembly)",
+  "version": "0.1.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/serialexp/ts-classify"
+  },
+  "files": [
+    "ts_classify_bg.wasm",
+    "ts_classify.js",
+    "ts_classify.d.ts"
+  ],
+  "main": "ts_classify.js",
+  "types": "ts_classify.d.ts",
+  "sideEffects": [
+    "./snippets/*"
+  ]
+}

package/ts_classify.d.ts

@@ -0,0 +1,174 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * JS-friendly wrapper for Nearest Centroid classifier.
+ */
+export class JsNearestCentroid {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Deserialize from bytes.
+     */
+    static from_bytes(bytes: Uint8Array): JsNearestCentroid;
+    /**
+     * Get cosine similarities to all class centroids.
+     * Returns flat array: [class0, similarity0, class1, similarity1, ...]
+     */
+    margins(sample_flat: Float64Array): Float64Array;
+    constructor();
+    /**
+     * Number of classes.
+     */
+    num_classes(): number;
+    /**
+     * Predict class for a single sparse sample.
+     */
+    predict(sample_flat: Float64Array): number;
+    /**
+     * Serialize to bytes.
+     */
+    to_bytes(): Uint8Array;
+    /**
+     * Train on sparse data.
+     * samples_flat: flattened sparse vectors [idx, val, idx, val, ...]
+     * sample_lengths: number of (idx, val) pairs per sample
+     * labels: integer class IDs (0, 1, 2, ...)
+     */
+    train(samples_flat: Float64Array, sample_lengths: Uint32Array, labels: Int32Array): void;
+}
+
+/**
+ * JS-friendly wrapper for One-vs-Rest multiclass SVM.
+ */
+export class JsOneVsRestSVM {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Deserialize from bytes.
+     */
+    static from_bytes(bytes: Uint8Array): JsOneVsRestSVM;
+    /**
+     * Get margins for all classes.
+     * Returns flat array: [class0, margin0, class1, margin1, ...]
+     */
+    margins(sample_flat: Float64Array): Float64Array;
+    constructor();
+    /**
+     * Number of classifiers.
+     */
+    num_classifiers(): number;
+    /**
+     * Predict class for a single sparse sample.
+     */
+    predict(sample_flat: Float64Array): number;
+    /**
+     * Serialize to bytes.
+     */
+    to_bytes(): Uint8Array;
+    /**
+     * Train on sparse data.
+     * labels: integer class IDs (0, 1, 2, ...)
+     */
+    train(samples_flat: Float64Array, sample_lengths: Uint32Array, labels: Int32Array): void;
+    /**
+     * Train with custom parameters.
+     */
+    train_with_config(samples_flat: Float64Array, sample_lengths: Uint32Array, labels: Int32Array, use_smo: boolean, c: number, max_iter: number, tol: number): void;
+}
+
+/**
+ * JS-friendly wrapper for binary SVM.
+ * Uses flat arrays for sparse vectors: [idx0, val0, idx1, val1, ...]
+ */
+export class JsSVM {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Deserialize from bytes.
+     */
+    static from_bytes(bytes: Uint8Array): JsSVM;
+    /**
+     * Get the margin (decision value) for a sample.
+     */
+    margin(sample_flat: Float64Array): number;
+    constructor();
+    /**
+     * Predict class for a single sparse sample.
+     * sample_flat: [idx, val, idx, val, ...]
+     */
+    predict(sample_flat: Float64Array): number;
+    /**
+     * Serialize to bytes.
+     */
+    to_bytes(): Uint8Array;
+    /**
+     * Train on sparse data.
+     * samples_flat: flattened sparse vectors [idx, val, idx, val, ...]
+     * sample_lengths: number of (idx, val) pairs per sample
+     * labels: -1.0 or 1.0 for each sample
+     */
+    train(samples_flat: Float64Array, sample_lengths: Uint32Array, labels: Float64Array): void;
+    /**
+     * Train with custom parameters.
+     */
+    train_with_config(samples_flat: Float64Array, sample_lengths: Uint32Array, labels: Float64Array, use_smo: boolean, c: number, max_iter: number, tol: number): void;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_jsnearestcentroid_free: (a: number, b: number) => void;
+    readonly __wbg_jsonevsrestsvm_free: (a: number, b: number) => void;
+    readonly __wbg_jssvm_free: (a: number, b: number) => void;
+    readonly jsnearestcentroid_from_bytes: (a: number, b: number) => [number, number, number];
+    readonly jsnearestcentroid_margins: (a: number, b: number, c: number) => [number, number];
+    readonly jsnearestcentroid_new: () => number;
+    readonly jsnearestcentroid_num_classes: (a: number) => number;
+    readonly jsnearestcentroid_predict: (a: number, b: number, c: number) => number;
+    readonly jsnearestcentroid_to_bytes: (a: number) => [number, number, number, number];
+    readonly jsnearestcentroid_train: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly jsonevsrestsvm_from_bytes: (a: number, b: number) => [number, number, number];
+    readonly jsonevsrestsvm_margins: (a: number, b: number, c: number) => [number, number];
+    readonly jsonevsrestsvm_new: () => number;
+    readonly jsonevsrestsvm_num_classifiers: (a: number) => number;
+    readonly jsonevsrestsvm_predict: (a: number, b: number, c: number) => number;
+    readonly jsonevsrestsvm_to_bytes: (a: number) => [number, number, number, number];
+    readonly jsonevsrestsvm_train: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly jsonevsrestsvm_train_with_config: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
+    readonly jssvm_from_bytes: (a: number, b: number) => [number, number, number];
+    readonly jssvm_margin: (a: number, b: number, c: number) => number;
+    readonly jssvm_new: () => number;
+    readonly jssvm_predict: (a: number, b: number, c: number) => number;
+    readonly jssvm_to_bytes: (a: number) => [number, number, number, number];
+    readonly jssvm_train: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly jssvm_train_with_config: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/ts_classify.js

@@ -0,0 +1,564 @@
+/* @ts-self-types="./ts_classify.d.ts" */
+
+/**
+ * JS-friendly wrapper for Nearest Centroid classifier.
+ */
+export class JsNearestCentroid {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsNearestCentroid.prototype);
+        obj.__wbg_ptr = ptr;
+        JsNearestCentroidFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsNearestCentroidFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsnearestcentroid_free(ptr, 0);
+    }
+    /**
+     * Deserialize from bytes.
+     * @param {Uint8Array} bytes
+     * @returns {JsNearestCentroid}
+     */
+    static from_bytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jsnearestcentroid_from_bytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return JsNearestCentroid.__wrap(ret[0]);
+    }
+    /**
+     * Get cosine similarities to all class centroids.
+     * Returns flat array: [class0, similarity0, class1, similarity1, ...]
+     * @param {Float64Array} sample_flat
+     * @returns {Float64Array}
+     */
+    margins(sample_flat) {
+        const ptr0 = passArrayF64ToWasm0(sample_flat, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jsnearestcentroid_margins(this.__wbg_ptr, ptr0, len0);
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    constructor() {
+        const ret = wasm.jsnearestcentroid_new();
+        this.__wbg_ptr = ret >>> 0;
+        JsNearestCentroidFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Number of classes.
+     * @returns {number}
+     */
+    num_classes() {
+        const ret = wasm.jsnearestcentroid_num_classes(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Predict class for a single sparse sample.
+     * @param {Float64Array} sample_flat
+     * @returns {number}
+     */
+    predict(sample_flat) {
+        const ptr0 = passArrayF64ToWasm0(sample_flat, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jsnearestcentroid_predict(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Serialize to bytes.
+     * @returns {Uint8Array}
+     */
+    to_bytes() {
+        const ret = wasm.jsnearestcentroid_to_bytes(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Train on sparse data.
+     * samples_flat: flattened sparse vectors [idx, val, idx, val, ...]
+     * sample_lengths: number of (idx, val) pairs per sample
+     * labels: integer class IDs (0, 1, 2, ...)
+     * @param {Float64Array} samples_flat
+     * @param {Uint32Array} sample_lengths
+     * @param {Int32Array} labels
+     */
+    train(samples_flat, sample_lengths, labels) {
+        const ptr0 = passArrayF64ToWasm0(samples_flat, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(sample_lengths, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray32ToWasm0(labels, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.jsnearestcentroid_train(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+    }
+}
+if (Symbol.dispose) JsNearestCentroid.prototype[Symbol.dispose] = JsNearestCentroid.prototype.free;
+
+/**
+ * JS-friendly wrapper for One-vs-Rest multiclass SVM.
+ */
+export class JsOneVsRestSVM {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsOneVsRestSVM.prototype);
+        obj.__wbg_ptr = ptr;
+        JsOneVsRestSVMFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsOneVsRestSVMFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsonevsrestsvm_free(ptr, 0);
+    }
+    /**
+     * Deserialize from bytes.
+     * @param {Uint8Array} bytes
+     * @returns {JsOneVsRestSVM}
+     */
+    static from_bytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jsonevsrestsvm_from_bytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return JsOneVsRestSVM.__wrap(ret[0]);
+    }
+    /**
+     * Get margins for all classes.
+     * Returns flat array: [class0, margin0, class1, margin1, ...]
+     * @param {Float64Array} sample_flat
+     * @returns {Float64Array}
+     */
+    margins(sample_flat) {
+        const ptr0 = passArrayF64ToWasm0(sample_flat, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jsonevsrestsvm_margins(this.__wbg_ptr, ptr0, len0);
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    constructor() {
+        const ret = wasm.jsonevsrestsvm_new();
+        this.__wbg_ptr = ret >>> 0;
+        JsOneVsRestSVMFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Number of classifiers.
+     * @returns {number}
+     */
+    num_classifiers() {
+        const ret = wasm.jsonevsrestsvm_num_classifiers(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Predict class for a single sparse sample.
+     * @param {Float64Array} sample_flat
+     * @returns {number}
+     */
+    predict(sample_flat) {
+        const ptr0 = passArrayF64ToWasm0(sample_flat, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jsonevsrestsvm_predict(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Serialize to bytes.
+     * @returns {Uint8Array}
+     */
+    to_bytes() {
+        const ret = wasm.jsonevsrestsvm_to_bytes(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Train on sparse data.
+     * labels: integer class IDs (0, 1, 2, ...)
+     * @param {Float64Array} samples_flat
+     * @param {Uint32Array} sample_lengths
+     * @param {Int32Array} labels
+     */
+    train(samples_flat, sample_lengths, labels) {
+        const ptr0 = passArrayF64ToWasm0(samples_flat, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(sample_lengths, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray32ToWasm0(labels, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.jsonevsrestsvm_train(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+    }
+    /**
+     * Train with custom parameters.
+     * @param {Float64Array} samples_flat
+     * @param {Uint32Array} sample_lengths
+     * @param {Int32Array} labels
+     * @param {boolean} use_smo
+     * @param {number} c
+     * @param {number} max_iter
+     * @param {number} tol
+     */
+    train_with_config(samples_flat, sample_lengths, labels, use_smo, c, max_iter, tol) {
+        const ptr0 = passArrayF64ToWasm0(samples_flat, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(sample_lengths, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray32ToWasm0(labels, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.jsonevsrestsvm_train_with_config(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, use_smo, c, max_iter, tol);
+    }
+}
+if (Symbol.dispose) JsOneVsRestSVM.prototype[Symbol.dispose] = JsOneVsRestSVM.prototype.free;
+
+/**
+ * JS-friendly wrapper for binary SVM.
+ * Uses flat arrays for sparse vectors: [idx0, val0, idx1, val1, ...]
+ */
+export class JsSVM {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsSVM.prototype);
+        obj.__wbg_ptr = ptr;
+        JsSVMFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsSVMFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jssvm_free(ptr, 0);
+    }
+    /**
+     * Deserialize from bytes.
+     * @param {Uint8Array} bytes
+     * @returns {JsSVM}
+     */
+    static from_bytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jssvm_from_bytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return JsSVM.__wrap(ret[0]);
+    }
+    /**
+     * Get the margin (decision value) for a sample.
+     * @param {Float64Array} sample_flat
+     * @returns {number}
+     */
+    margin(sample_flat) {
+        const ptr0 = passArrayF64ToWasm0(sample_flat, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jssvm_margin(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    constructor() {
+        const ret = wasm.jssvm_new();
+        this.__wbg_ptr = ret >>> 0;
+        JsSVMFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Predict class for a single sparse sample.
+     * sample_flat: [idx, val, idx, val, ...]
+     * @param {Float64Array} sample_flat
+     * @returns {number}
+     */
+    predict(sample_flat) {
+        const ptr0 = passArrayF64ToWasm0(sample_flat, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jssvm_predict(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Serialize to bytes.
+     * @returns {Uint8Array}
+     */
+    to_bytes() {
+        const ret = wasm.jssvm_to_bytes(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Train on sparse data.
+     * samples_flat: flattened sparse vectors [idx, val, idx, val, ...]
+     * sample_lengths: number of (idx, val) pairs per sample
+     * labels: -1.0 or 1.0 for each sample
+     * @param {Float64Array} samples_flat
+     * @param {Uint32Array} sample_lengths
+     * @param {Float64Array} labels
+     */
+    train(samples_flat, sample_lengths, labels) {
+        const ptr0 = passArrayF64ToWasm0(samples_flat, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(sample_lengths, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArrayF64ToWasm0(labels, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.jssvm_train(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+    }
+    /**
+     * Train with custom parameters.
+     * @param {Float64Array} samples_flat
+     * @param {Uint32Array} sample_lengths
+     * @param {Float64Array} labels
+     * @param {boolean} use_smo
+     * @param {number} c
+     * @param {number} max_iter
+     * @param {number} tol
+     */
+    train_with_config(samples_flat, sample_lengths, labels, use_smo, c, max_iter, tol) {
+        const ptr0 = passArrayF64ToWasm0(samples_flat, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(sample_lengths, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArrayF64ToWasm0(labels, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.jssvm_train_with_config(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, use_smo, c, max_iter, tol);
+    }
+}
+if (Symbol.dispose) JsSVM.prototype[Symbol.dispose] = JsSVM.prototype.free;
+
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg_Error_8c4e43fe74559d73: function(arg0, arg1) {
+            const ret = Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./ts_classify_bg.js": import0,
+    };
+}
+
+const JsNearestCentroidFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsnearestcentroid_free(ptr >>> 0, 1));
+const JsOneVsRestSVMFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsonevsrestsvm_free(ptr >>> 0, 1));
+const JsSVMFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jssvm_free(ptr >>> 0, 1));
+
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getUint32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArrayF64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getFloat64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedFloat64ArrayMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = module.ok && expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('ts_classify_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };