@dniskav/neuron 0.2.6 → 0.3.0

package/dist/index.d.mts

@@ -593,4 +593,473 @@ 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;
+}
+
+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, Autoencoder, BatchNorm, BiasVector, CausalConv1D, ClipOptimizer, ClippedOptimizerFactory, Conv1D, Conv2D, DataAugmentation, DataLoader, type DataPair, DecisionTree, Dropout, EarlyStopping, EmbeddingMatrix, Flatten, GAN, GRULayer, GaussianNaiveBayes, HopfieldNetwork, KMeans, type KMeansOptions, LRScheduler, LSTMLayer, Layer, LayerNorm, 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, RNN, SGD, SOM, type SOMOptions, Seq2Seq, type Serializable, SoftmaxRegression, TCN, type TrainDataset, type TrainMetrics, type TrainableNetwork, type TrainableNetworkWithWeights, Trainer, type TrainerOptions, TransformerBlock, type TransformerBlockOptions, VAE, Value, WeightInspector, WeightMatrix, type WeightStats, 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 };