@astermind/astermind-elm/dist/core/ELM.d.ts

JavaScript Extreme Learning Machine (ELM) library for browser and Node.js.

import { ELMConfig, TrainResult } from './ELMConfig';
import { UniversalEncoder } from '../preprocessing/UniversalEncoder';
export interface ELMModel {
    W: number[][];
    b: number[][];
    beta: number[][];
}
export interface PredictResult {
    label: string;
    prob: number;
}
export interface TopKResult {
    index: number;
    label: string;
    prob: number;
}
export declare class ELM {
    categories: string[];
    hiddenUnits: number;
    activation: string;
    maxLen: number;
    charSet: string;
    useTokenizer: boolean;
    tokenizerDelimiter?: RegExp;
    encoder?: UniversalEncoder;
    model: ELMModel | null;
    metrics?: {
        rmse?: number;
        mae?: number;
        accuracy?: number;
        f1?: number;
        crossEntropy?: number;
        r2?: number;
    };
    verbose: boolean;
    savedModelJSON?: string;
    config: ELMConfig;
    modelName: string;
    logToFile: boolean;
    dropout: number;
    ridgeLambda: number;
    private rng;
    constructor(config: ELMConfig);
    private assertEncoder;
    private xavierLimit;
    private randomMatrix;
    private buildHidden;
    oneHot(n: number, index: number): number[];
    setCategories(categories: string[]): void;
    loadModelFromJSON(json: string): void;
    /** Decide output dimension from config/categories/labels/one-hot */
    private resolveOutputDim;
    /** Coerce X, and turn labels→one-hot if needed. Always returns strict number[][] */
    private coerceXY;
    trainFromData(X: number[][], y: number[] | number[][], options?: {
        reuseWeights?: boolean;
        weights?: number[];
    }): TrainResult;
    train(augmentationOptions?: {
        suffixes?: string[];
        prefixes?: string[];
        includeNoise?: boolean;
    }, weights?: number[]): TrainResult;
    /** Text prediction (uses Option A narrowing) */
    predict(text: string, topK?: number): PredictResult[];
    /** Vector batch prediction (kept for back-compat) */
    predictFromVector(inputVecRows: number[][], topK?: number): PredictResult[][];
    /** Raw logits for a single numeric vector */
    predictLogitsFromVector(vec: number[]): number[];
    /** Raw logits for a batch of numeric vectors */
    predictLogitsFromVectors(X: number[][]): number[][];
    /** Probability vector (softmax) for a single numeric vector */
    predictProbaFromVector(vec: number[]): number[];
    /** Probability matrix (softmax per row) for a batch of numeric vectors */
    predictProbaFromVectors(X: number[][]): number[][];
    /** Top-K results for a single numeric vector */
    predictTopKFromVector(vec: number[], k?: number): TopKResult[];
    /** Top-K results for a batch of numeric vectors */
    predictTopKFromVectors(X: number[][], k?: number): TopKResult[][];
    calculateRMSE(Y: number[][], P: number[][]): number;
    calculateMAE(Y: number[][], P: number[][]): number;
    calculateAccuracy(Y: number[][], P: number[][]): number;
    calculateF1Score(Y: number[][], P: number[][]): number;
    calculateCrossEntropy(Y: number[][], P: number[][]): number;
    calculateR2Score(Y: number[][], P: number[][]): number;
    computeHiddenLayer(X: number[][]): number[][];
    getEmbedding(X: number[][]): number[][];
    private logMetrics;
    saveModelAsJSONFile(filename?: string): void;
    private serializeConfig;
    private argmax;
    getEncoder(): UniversalEncoder | undefined;
}