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

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

export type KernelType = 'rbf' | 'linear' | 'poly' | 'laplacian' | 'custom';
export interface KernelSpec {
    type: KernelType;
    /** RBF / Laplacian: gamma scale; default 1/D */
    gamma?: number;
    /** Poly: (gamma * x·z + coef0)^degree */
    degree?: number;
    coef0?: number;
    /** For custom kernels — lookup name in KernelRegistry */
    name?: string;
}
export type KELMMode = 'exact' | 'nystrom';
export interface NystromOptions {
    /** # landmarks (m). Required unless using preset. If omitted, defaults to ~sqrt(N). */
    m?: number;
    /** Landmark selection strategy */
    strategy?: 'uniform' | 'kmeans++' | 'preset';
    /** Random seed for sampling / kmeans++ */
    seed?: number;
    /** Provide explicit landmarks */
    preset?: {
        points?: number[][];
        indices?: number[];
    };
    /** Apply whitening Φ = K_nm · K_mm^{-1/2} (symmetric). Default: false */
    whiten?: boolean;
    /** Jitter added to K_mm before eig-invsqrt. Default: 1e-10 */
    jitter?: number;
}
export interface KernelELMConfig {
    /** Output dimension K (classes for one-hot classification, or dims for regression) */
    outputDim: number;
    /** Kernel parameters */
    kernel: KernelSpec;
    /** Ridge regularization λ (default 1e-2) */
    ridgeLambda?: number;
    /** Convenience for classification helpers */
    task?: 'classification' | 'regression';
    /** Solver mode (default 'exact') */
    mode?: KELMMode;
    /** Nyström options (used when mode='nystrom') */
    nystrom?: NystromOptions;
    /** Logging */
    log?: {
        modelName?: string;
        verbose?: boolean;
    };
}
export interface KernelELMJSON {
    config: KernelELMConfig & {
        __version: string;
    };
    X?: number[][];
    alpha?: number[][];
    Z?: number[][];
    W?: number[][];
    /** Symmetric whitener K_mm^{-1/2} (present when whiten=true) */
    R?: number[][];
}
type TaskKind = 'classification' | 'regression';
interface ResolvedNystromOptions {
    m: number | undefined;
    strategy: 'uniform' | 'kmeans++' | 'preset';
    seed: number;
    preset?: {
        points?: number[][];
        indices?: number[];
    };
    whiten: boolean;
    jitter: number;
}
interface ResolvedKernelELMConfig {
    outputDim: number;
    kernel: KernelSpec;
    ridgeLambda: number;
    task: TaskKind;
    mode: KELMMode;
    nystrom: ResolvedNystromOptions;
    log: {
        modelName: string;
        verbose: boolean;
    };
}
type KernelFn = (x: number[], z: number[]) => number;
export declare class KernelRegistry {
    private static map;
    static register(name: string, fn: KernelFn): void;
    static get(name: string): KernelFn;
}
export declare class KernelELM {
    readonly cfg: ResolvedKernelELMConfig;
    private kernel;
    private Xtrain;
    private alpha;
    private Z;
    private W;
    private R;
    private readonly verbose;
    private readonly name;
    constructor(config: KernelELMConfig);
    fit(X: number[][], Y: number[][]): void;
    private featuresFor;
    /** Raw logits for batch (M x K) */
    predictLogitsFromVectors(X: number[][]): number[][];
    /** Probabilities for classification; raw scores for regression */
    predictProbaFromVectors(X: number[][]): number[][];
    /** Top-K for classification */
    predictTopKFromVectors(X: number[][], k?: number): Array<Array<{
        index: number;
        prob: number;
    }>>;
    /** Embedding for chaining:
     *  - exact: Φ = K(X, X_train)  (M x N)
     *  - nystrom: Φ = K(X, Z)      (M x m)  or K(X,Z)·R if whiten=true
     */
    getEmbedding(X: number[][]): number[][];
    toJSON(): KernelELMJSON;
    fromJSON(payload: string | KernelELMJSON): void;
}
export {};