@dniskav/neuron 0.2.7 → 0.3.1

package/dist/index.d.mts

@@ -593,4 +593,590 @@ declare function validateArrayMinLength(arr: unknown, minLength: number, methodN
 declare function validate2DArray(arr: unknown, expectedRows: number, expectedCols: number, methodName: string): asserts arr is number[][];
 declare function validateNumber(value: unknown, methodName: string): asserts value is number;
 
-export { type Activation, Adam, AttentionHead, BatchNorm, BiasVector, ClipOptimizer, ClippedOptimizerFactory, Conv1D, DataLoader, type DataPair, Dropout, EmbeddingMatrix, GRULayer, LRScheduler, LSTMLayer, Layer, LayerNorm, ModelSaver, Momentum, MultiHeadAttention, Network, NetworkLSTM, type NetworkLSTMOptions, NetworkN, type NetworkNOptions, NetworkTransformer, type NetworkTransformerOptions, NetworkTransformerRL, type NetworkTransformerRLOptions, Neuron, NeuronN, type Optimizer, type OptimizerFactory, SGD, type Serializable, type TrainDataset, type TrainMetrics, type TrainableNetwork, type TrainableNetworkWithWeights, Trainer, type TrainerOptions, TransformerBlock, type TransformerBlockOptions, WeightMatrix, crossEntropy, crossEntropyDelta, crossEntropyDeltaRaw, defaultOptimizer, elu, leakyRelu, linear, makeElu, makeLeakyRelu, matMul, mse, mseDelta, relu, sigmoid, softmax, softmaxBackward, tanh, transpose, validate2DArray, validateArray, validateArrayMinLength, validateNumber };
+declare class Perceptron {
+    weights: number[];
+    bias: number;
+    constructor(nInputs: number);
+    predict(inputs: number[]): 0 | 1;
+    train(inputs: number[], target: 0 | 1, lr: number): number;
+}
+
+declare class LinearRegression {
+    weights: number[];
+    private _nFeatures;
+    fitNormal(X: number[][], y: number[]): void;
+    fitGD(X: number[][], y: number[], lr: number, epochs: number): number[];
+    predict(x: number[]): number;
+    getCoefficients(): {
+        weights: number[];
+        bias: number;
+    };
+}
+
+declare class LogisticRegression {
+    weights: number[];
+    bias: number;
+    private _nFeatures;
+    train(X: number[][], y: number[], lr: number, epochs: number): number[];
+    predict(x: number[]): number;
+    classify(x: number[]): 0 | 1;
+}
+declare class SoftmaxRegression {
+    weights: number[][];
+    biases: number[];
+    private _nFeatures;
+    private _nClasses;
+    private _softmax;
+    train(X: number[][], y: number[], lr: number, epochs: number): number[];
+    predictProba(x: number[]): number[];
+    predict(x: number[]): number;
+}
+
+declare class GaussianNaiveBayes {
+    private _means;
+    private _variances;
+    private _logPriors;
+    private _classes;
+    private _nFeatures;
+    fit(X: number[][], y: number[]): void;
+    private _logGaussian;
+    private _logScores;
+    predict(x: number[]): number;
+    predictProba(x: number[]): Map<number, number>;
+}
+
+declare class DecisionTree {
+    private _root;
+    private _maxDepth;
+    private _minSamplesSplit;
+    private _task;
+    constructor(options?: {
+        maxDepth?: number;
+        minSamplesSplit?: number;
+        task?: "classification" | "regression";
+    });
+    private _gini;
+    private _mse;
+    private _impurity;
+    private _leafValue;
+    private _bestSplit;
+    private _buildNode;
+    fit(X: number[][], y: number[]): void;
+    private _traverse;
+    predict(x: number[]): number;
+    predictBatch(X: number[][]): number[];
+}
+
+interface KMeansOptions {
+    maxIter?: number;
+    seed?: number;
+}
+declare class KMeans {
+    /** Cluster centroids, shape [k][features]. Set after fit(). */
+    centroids: number[][];
+    private readonly _k;
+    private readonly _maxIter;
+    private _rng;
+    constructor(k: number, options?: KMeansOptions);
+    fit(X: number[][]): void;
+    predict(x: number[]): number;
+    predictBatch(X: number[][]): number[];
+    inertia(X: number[][]): number;
+    private _euclideanSq;
+    private _minDistSq;
+    private _nearestCentroid;
+}
+
+declare class PCA {
+    /** Eigenvectors (principal components), shape [nComponents][nFeatures]. */
+    components: number[][];
+    /** Eigenvalue for each component — equals the variance along that direction. */
+    explainedVariance: number[];
+    /** Column mean of the training data. */
+    mean: number[];
+    private readonly _nComponents;
+    constructor(nComponents: number);
+    fit(X: number[][]): void;
+    transform(X: number[][]): number[][];
+    fitTransform(X: number[][]): number[][];
+    inverseTransform(Z: number[][]): number[][];
+    explainedVarianceRatio(): number[];
+    private _covMatrix;
+    private _powerIteration;
+    private _matvec;
+    private _normalize;
+}
+
+interface SOMOptions {
+    initialLr?: number;
+    finalLr?: number;
+    initialSigma?: number;
+    finalSigma?: number;
+}
+declare class SOM {
+    /** Weight (prototype) vectors, shape [rows][cols][inputSize]. */
+    weights: number[][][];
+    private readonly _rows;
+    private readonly _cols;
+    private readonly _inputSize;
+    private readonly _initialLr;
+    private readonly _finalLr;
+    private readonly _initialSigma;
+    private readonly _finalSigma;
+    constructor(rows: number, cols: number, inputSize: number, options?: SOMOptions);
+    train(X: number[][], epochs: number): void;
+    getBMU(x: number[]): [number, number];
+    predict(x: number[]): [number, number];
+    quantizationError(X: number[][]): number;
+    private _distSq;
+    private _shuffle;
+}
+
+declare class HopfieldNetwork {
+    /** Symmetric weight matrix, shape [n][n] with zero diagonal. */
+    weights: number[][];
+    /** Number of neurons. */
+    readonly n: number;
+    /** Number of patterns stored so far. */
+    storedPatterns: number;
+    constructor(n: number);
+    store(pattern: number[]): void;
+    recall(input: number[], maxIter?: number): number[];
+    energy(state: number[]): number;
+    static binarize(arr: number[]): number[];
+    static unbinarize(arr: number[]): number[];
+    private _shuffleInPlace;
+}
+
+declare class Autoencoder {
+    /** Encoder sub-network: maps input → latent representation. */
+    readonly encoder: NetworkN;
+    /** Decoder sub-network: maps latent representation → reconstructed input. */
+    readonly decoder: NetworkN;
+    private readonly _inputSize;
+    private readonly _latentSize;
+    constructor(inputSize: number, encoderHidden: number[], latentSize: number, decoderHidden: number[], options?: NetworkNOptions);
+    encode(x: number[]): number[];
+    decode(z: number[]): number[];
+    reconstruct(x: number[]): number[];
+    train(x: number[], lr: number): number;
+    trainBatch(X: number[][], lr: number): number;
+}
+
+declare class Conv2D {
+    readonly inputHeight: number;
+    readonly inputWidth: number;
+    readonly channels: number;
+    readonly kH: number;
+    readonly kW: number;
+    readonly filters: number;
+    readonly stride: number;
+    readonly padding: 'valid' | 'same';
+    kernels: number[][][][];
+    biases: number[];
+    private _kOpts;
+    private _bOpts;
+    private _input;
+    private _padded;
+    constructor(inputHeight: number, inputWidth: number, channels: number, kernelSize: number | [number, number], filters: number, options?: {
+        stride?: number;
+        padding?: 'valid' | 'same';
+        optimizerFactory?: OptimizerFactory;
+    });
+    private _pad;
+    outputShape(): [number, number, number];
+    forward(input: number[][][]): number[][][];
+    backward(dOutput: number[][][], lr: number): number[][][];
+    getWeights(): number[];
+    setWeights(weights: number[]): void;
+}
+
+declare class MaxPool2D {
+    readonly poolSize: number;
+    readonly stride: number;
+    private _maxMask;
+    private _inputH;
+    private _inputW;
+    private _inputC;
+    constructor(poolSize: number, stride?: number);
+    outputShape(inputH: number, inputW: number, channels: number): [number, number, number];
+    forward(input: number[][][]): number[][][];
+    backward(dOutput: number[][][]): number[][][];
+}
+
+declare class Flatten {
+    inputShape: [number, number, number] | null;
+    forward(input: number[][][]): number[];
+    backward(dOutput: number[]): number[][][];
+}
+
+declare class RNN {
+    readonly inputSize: number;
+    readonly hiddenSize: number;
+    readonly outputSize: number;
+    Wxh: number[][];
+    Whh: number[][];
+    Why: number[][];
+    bh: number[];
+    by: number[];
+    private _h;
+    private _traj;
+    private _outputs;
+    private _opts;
+    constructor(inputSize: number, hiddenSize: number, outputSize: number, optimizerFactory?: OptimizerFactory);
+    reset(): void;
+    forward(sequence: number[][]): {
+        outputs: number[][];
+        hiddens: number[][];
+    };
+    backward(sequence: number[][], targets: number[][], lr: number): number;
+}
+
+declare class Seq2Seq {
+    readonly encoder: LSTMLayer;
+    readonly decoder: LSTMLayer;
+    W_out: number[][];
+    b_out: number[];
+    readonly inputSize: number;
+    readonly hiddenSize: number;
+    readonly outputSize: number;
+    private _wOutOpts;
+    private _bOutOpts;
+    constructor(inputSize: number, hiddenSize: number, outputSize: number, options?: {
+        optimizerFactory?: OptimizerFactory;
+    });
+    private _project;
+    encode(inputSequence: number[][]): {
+        h: number[];
+        c: number[];
+    };
+    decode(contextVector: {
+        h: number[];
+        c: number[];
+    }, steps: number): number[][];
+    trainStep(inputSeq: number[][], targetSeq: number[][], lr: number): number;
+}
+
+declare class CausalConv1D {
+    readonly inputChannels: number;
+    readonly outputChannels: number;
+    readonly kernelSize: number;
+    readonly dilation: number;
+    kernels: number[][][];
+    biases: number[];
+    private _kOpts;
+    private _bOpts;
+    private _paddedInput;
+    private _inputLen;
+    constructor(inputChannels: number, outputChannels: number, kernelSize: number, dilation: number, optimizerFactory?: OptimizerFactory);
+    forward(input: number[][]): number[][];
+    backward(dOutput: number[][], lr: number): number[][];
+}
+declare class TCN {
+    readonly layers: CausalConv1D[];
+    private _outputW;
+    private _outputB;
+    private _outOpts;
+    private _bOutOpts;
+    readonly inputChannels: number;
+    readonly channels: number;
+    readonly kernelSize: number;
+    readonly levels: number;
+    readonly outputSize: number;
+    private _layerInputs;
+    private _layerOutputs;
+    private _lastHidden;
+    private _finalOutputs;
+    constructor(inputChannels: number, channels: number, kernelSize: number, levels: number, outputSize: number, optimizerFactory?: OptimizerFactory);
+    get receptiveField(): number;
+    forward(sequence: number[][]): number[][];
+    train(sequence: number[][], targets: number[][], lr: number): number;
+}
+
+type Word2VecModel = 'skipgram' | 'cbow';
+interface Word2VecOptions {
+    /** Size of the sliding context window on each side of the center word. Default 2. */
+    windowSize?: number;
+    /** Training architecture. Default 'skipgram'. */
+    model?: Word2VecModel;
+    /** Ignore words with corpus frequency below this threshold. Default 1. */
+    minCount?: number;
+}
+declare class Word2Vec {
+    /** Learned word vectors, shape [vocabSize][embeddingDim]. */
+    embeddings: number[][];
+    /** Maps each vocabulary word to its integer index. */
+    vocab: Map<string, number>;
+    vocabSize: number;
+    embeddingDim: number;
+    private _indexToWord;
+    private _W2;
+    private _windowSize;
+    private _model;
+    private _minCount;
+    private _trained;
+    constructor(embeddingDim?: number, options?: Word2VecOptions);
+    buildVocab(sentences: string[][]): void;
+    static tokenize(text: string): string[];
+    train(sentences: string[][], lr?: number, epochs?: number): number[];
+    getEmbedding(word: string): number[];
+    similarity(word1: string, word2: string): number;
+    mostSimilar(word: string, topK?: number): {
+        word: string;
+        score: number;
+    }[];
+    analogy(positive1: string, negative: string, positive2: string, topK?: number): {
+        word: string;
+        score: number;
+    }[];
+    private _skipgramStep;
+    private _cbowStep;
+    private _hiddenToScores;
+    private _nearestByVector;
+    private _cosine;
+}
+
+interface TSNEOptions {
+    /** Dimensionality of the output embedding. Default 2. */
+    nComponents?: number;
+    /**
+     * Perplexity — loosely controls the effective number of neighbors considered
+     * for each point. Typical values: 5–50. Default 30.
+     * Must be less than the number of data points.
+     */
+    perplexity?: number;
+    /** Learning rate for gradient descent. Default 200. */
+    lr?: number;
+    /** Number of gradient-descent iterations. Default 1000. */
+    nIter?: number;
+    /**
+     * Seed for the pseudo-random number generator.
+     * Set to any integer for reproducible results. Default uses Math.random.
+     */
+    seed?: number;
+}
+declare class TSNE {
+    /** Result of the embedding, shape [n][nComponents]. Available after fit(). */
+    embedding: number[][];
+    private readonly _nComponents;
+    private readonly _perplexity;
+    private readonly _lr;
+    private readonly _nIter;
+    private readonly _seed;
+    private _klDivergence;
+    private _P;
+    constructor(options?: TSNEOptions);
+    fit(X: number[][]): void;
+    fitTransform(X: number[][]): number[][];
+    kl(): number;
+    private _computePcond;
+}
+
+declare class PositionalEncoding {
+    static encode(pos: number, dModel: number): number[];
+    static encodeSequence(seqLen: number, dModel: number): number[][];
+    static apply(embeddings: number[][], seqLen?: number): number[][];
+}
+declare class LearnedPositionalEncoding {
+    readonly maxSeqLen: number;
+    readonly dModel: number;
+    weights: number[][];
+    constructor(maxSeqLen: number, dModel: number);
+    getEncoding(pos: number): number[];
+    apply(embeddings: number[][], seqLen?: number): number[][];
+    update(dWeights: number[][], lr: number): void;
+}
+
+declare class Augmenter {
+    static addNoise(x: number[], sigma?: number): number[];
+    static dropoutFeatures(x: number[], rate?: number): number[];
+    static augment(x: number[], noiseStd?: number, dropRate?: number): number[];
+    static makePair(x: number[]): [number[], number[]];
+}
+declare class ContrastiveLearning {
+    encoder: NetworkN;
+    projectionHead: NetworkN;
+    temperature: number;
+    constructor(inputSize: number, encoderHidden: number[], projectionDim: number, options?: {
+        temperature?: number;
+        encoderOptions?: NetworkNOptions;
+    });
+    encode(x: number[]): number[];
+    project(x: number[]): number[];
+    static cosineSimilarity(a: number[], b: number[]): number;
+    computeLoss(pairs: [number[], number[]][]): number;
+    trainStep(pairs: [number[], number[]][], lr: number): number;
+    private _forwardProjections;
+    private _ntXentLoss;
+}
+
+declare class GAN {
+    readonly generator: NetworkN;
+    readonly discriminator: NetworkN;
+    readonly latentDim: number;
+    constructor(latentDim: number, generatorHidden: number[], outputDim: number, discriminatorHidden: number[], options?: {
+        generatorOptions?: NetworkNOptions;
+        discriminatorOptions?: NetworkNOptions;
+    });
+    generate(z?: number[]): number[];
+    discriminate(x: number[]): number;
+    trainStep(realBatch: number[][], lr: number): {
+        dLoss: number;
+        gLoss: number;
+    };
+    sampleLatent(): number[];
+}
+
+declare class VAE {
+    readonly encoder: NetworkN;
+    readonly decoder: NetworkN;
+    readonly latentDim: number;
+    constructor(inputSize: number, encoderHidden: number[], latentDim: number, decoderHidden: number[], options?: NetworkNOptions);
+    encode(x: number[]): {
+        mu: number[];
+        logVar: number[];
+    };
+    reparametrize(mu: number[], logVar: number[]): number[];
+    decode(z: number[]): number[];
+    forward(x: number[]): {
+        reconstruction: number[];
+        mu: number[];
+        logVar: number[];
+        z: number[];
+    };
+    train(x: number[], lr: number): {
+        totalLoss: number;
+        reconLoss: number;
+        klLoss: number;
+    };
+    generate(z?: number[]): number[];
+    private _sampleNormal;
+}
+
+declare class Value {
+    data: number;
+    grad: number;
+    private _backward;
+    private _prev;
+    private _op;
+    constructor(data: number, children?: Value[], op?: string);
+    add(other: Value | number): Value;
+    mul(other: Value | number): Value;
+    pow(exp: number): Value;
+    relu(): Value;
+    tanh(): Value;
+    sigmoid(): Value;
+    exp(): Value;
+    div(other: Value | number): Value;
+    sub(other: Value | number): Value;
+    neg(): Value;
+    backward(): void;
+    toString(): string;
+}
+
+interface WeightStats {
+    mean: number;
+    std: number;
+    min: number;
+    max: number;
+    deadCount: number;
+    totalParams: number;
+}
+declare class WeightInspector {
+    static inspect(network: NetworkN, deadThreshold?: number): WeightStats[];
+    static inspectAll(network: NetworkN, deadThreshold?: number): WeightStats;
+    static print(network: NetworkN, deadThreshold?: number): void;
+    static countDeadReLUs(activations: number[][], threshold?: number): number;
+}
+
+declare function confusionMatrix(yTrue: number[], yPred: number[], numClasses?: number): number[][];
+declare function precision(yTrue: number[], yPred: number[], positiveClass?: number): number;
+declare function recall(yTrue: number[], yPred: number[], positiveClass?: number): number;
+declare function f1Score(yTrue: number[], yPred: number[], positiveClass?: number): number;
+declare function accuracy(yTrue: number[], yPred: number[]): number;
+declare function rocCurve(yTrue: number[], yScores: number[]): {
+    fpr: number;
+    tpr: number;
+    threshold: number;
+}[];
+declare function auc(yTrue: number[], yScores: number[]): number;
+declare function mae(yTrue: number[], yPred: number[]): number;
+declare function rmse(yTrue: number[], yPred: number[]): number;
+declare function r2Score(yTrue: number[], yPred: number[]): number;
+declare function perplexity(yTrue: number[], probabilities: number[][]): number;
+declare function printConfusionMatrix(matrix: number[][], labels?: string[]): void;
+declare function classificationReport(yTrue: number[], yPred: number[], labels?: string[]): void;
+
+declare class EarlyStopping {
+    bestValue: number;
+    readonly patience: number;
+    readonly minDelta: number;
+    readonly mode: 'min' | 'max';
+    readonly restoreBest: boolean;
+    counter: number;
+    stopped: boolean;
+    bestEpoch: number;
+    bestWeights: number[] | null;
+    constructor(options?: {
+        patience?: number;
+        minDelta?: number;
+        mode?: 'min' | 'max';
+        restoreBest?: boolean;
+    });
+    update(value: number, epoch: number, weights?: number[]): boolean;
+    reset(): void;
+}
+
+declare class LossPlotter {
+    private readonly width;
+    private readonly height;
+    private readonly title;
+    private losses;
+    private epochs;
+    constructor(options?: {
+        width?: number;
+        height?: number;
+        title?: string;
+    });
+    add(loss: number, epoch?: number): void;
+    addMultiple(losses: number[]): void;
+    render(): string;
+    print(): void;
+    reset(): void;
+}
+
+declare class DataAugmentation {
+    static addNoise(x: number[], sigma?: number): number[];
+    static jitter(x: number[], delta?: number): number[];
+    static flipHorizontal(x: number[]): number[];
+    static normalize(X: number[][]): {
+        normalized: number[][];
+        min: number[];
+        max: number[];
+    };
+    static normalizePoint(x: number[], min: number[], max: number[]): number[];
+    static standardize(X: number[][]): {
+        standardized: number[][];
+        mean: number[];
+        std: number[];
+    };
+    static standardizePoint(x: number[], mean: number[], std: number[]): number[];
+    static augmentBatch(X: number[][], y: number[], factor?: number, sigma?: number): {
+        X: number[][];
+        y: number[];
+    };
+    static shuffle(X: number[][], y: number[]): {
+        X: number[][];
+        y: number[];
+    };
+    static split(X: number[][], y: number[], trainRatio?: number, valRatio?: number): {
+        trainX: number[][];
+        trainY: number[];
+        valX: number[][];
+        valY: number[];
+        testX: number[][];
+        testY: number[];
+    };
+}
+
+export { type Activation, Adam, AttentionHead, Augmenter, Autoencoder, BatchNorm, BiasVector, CausalConv1D, ClipOptimizer, ClippedOptimizerFactory, ContrastiveLearning, Conv1D, Conv2D, DataAugmentation, DataLoader, type DataPair, DecisionTree, Dropout, EarlyStopping, EmbeddingMatrix, Flatten, GAN, GRULayer, GaussianNaiveBayes, HopfieldNetwork, KMeans, type KMeansOptions, LRScheduler, LSTMLayer, Layer, LayerNorm, LearnedPositionalEncoding, LinearRegression, LogisticRegression, LossPlotter, MaxPool2D, ModelSaver, Momentum, MultiHeadAttention, Network, NetworkLSTM, type NetworkLSTMOptions, NetworkN, type NetworkNOptions, NetworkTransformer, type NetworkTransformerOptions, NetworkTransformerRL, type NetworkTransformerRLOptions, Neuron, NeuronN, type Optimizer, type OptimizerFactory, PCA, Perceptron, PositionalEncoding, RNN, SGD, SOM, type SOMOptions, Seq2Seq, type Serializable, SoftmaxRegression, TCN, TSNE, type TSNEOptions, type TrainDataset, type TrainMetrics, type TrainableNetwork, type TrainableNetworkWithWeights, Trainer, type TrainerOptions, TransformerBlock, type TransformerBlockOptions, VAE, Value, WeightInspector, WeightMatrix, type WeightStats, Word2Vec, type Word2VecModel, type Word2VecOptions, accuracy, auc, classificationReport, confusionMatrix, crossEntropy, crossEntropyDelta, crossEntropyDeltaRaw, defaultOptimizer, elu, f1Score, leakyRelu, linear, mae, makeElu, makeLeakyRelu, matMul, mse, mseDelta, perplexity, precision, printConfusionMatrix, r2Score, recall, relu, rmse, rocCurve, sigmoid, softmax, softmaxBackward, tanh, transpose, validate2DArray, validateArray, validateArrayMinLength, validateNumber };