adnn.ts/dist/adnn.d.ts

adnn provides TypeSafe Javascript-native neural networks on top of general scalar/tensor reverse-mode automatic differentiation. You can use just the AD code, or the NN layer built on top of it. This architecture makes it easy to define big, complex numer

export declare let Tensor: TensorConstructor;
export declare let ad: AD;
export declare let nn: NN;
export declare let opt: Opt;
export declare let Network: NetworkConstructor;
type AD = {
    lift(x: number): ScalarNode;
    lift(x: Tensor): TensorNode;
    value(x: number): number;
    value(x: ScalarNode): ScalarNode['x'];
    derivative(x: ScalarNode): ScalarNode['dx'];
    derivative(x: TensorNode): TensorNode['dx'];
    /** @description Create randomly-initialized params */
    params(dims: number[], name?: string): TensorNode;
    scalar: {
        add: ScalarBinaryOp;
        sub: ScalarBinaryOp;
        mul: ScalarBinaryOp;
        div: ScalarBinaryOp;
        sqrt: ScalarUnaryOp;
        sum: ScalarUnaryReduction;
    };
    tensor: {
        add: TensorBinaryOp;
        sub: TensorBinaryOp;
        mul: TensorBinaryOp;
        div: TensorBinaryOp;
        sqrt: TensorUnaryOp;
        sumreduce: TensorUnaryReduction;
    };
};
interface ScalarUnaryReduction {
    (...xs: number[]): number;
    (xs: number[]): number;
    (...xs: scalar[]): ScalarNode;
    (xs: scalar[]): ScalarNode;
}
interface ScalarUnaryOp {
    (x: number): number;
    (x: ScalarNode): ScalarNode;
}
interface ScalarBinaryOp {
    (x: number, y: number): number;
    (x: scalar, y: scalar): ScalarNode;
}
interface TensorUnaryReduction {
    (x: Tensor): number;
    (x: TensorNode): ScalarNode;
}
interface TensorUnaryOp {
    (x: Tensor): Tensor;
    (x: TensorNode): TensorNode;
}
interface TensorBinaryOp {
    (x: Tensor, y: number | Tensor): Tensor;
    (x: TensorNode, y: number | Tensor | TensorNode): TensorNode;
}
type NN = {
    relu: Network;
    tanh: Network;
    sigmoid: Network;
    /**
     * @description Sigmoid, shifted and scaled to the range (-1, 1)
     *  Same output range as tanh, but numerically stable
     * (i.e. doesn't give NaNs for large inputs).
     */
    sigmoidCentered: Network;
    softmax: Network;
    mlp(nIn: number, layerdefs: NetworkLayerDef[], name?: string, debug?: boolean): Network;
    sequence(networks: Network[], name?: string, debug?: boolean): CompoundNetwork;
    linear(nIn: number, nOut: number, name?: string): LinearNetwork;
};
type Opt = {
    nnTrain(network: Network, trainingData: TrainingData, lossFn: LossFn, options: TrainOptions): void;
    sgd(options?: {
        stepSize?: number;
        stepSizeDecay?: number;
        mu?: number;
    }): OptimizeMethod;
    adagrad(options?: {
        stepSize?: number;
    }): OptimizeMethod;
    rmsprop(options?: {
        stepSize?: number;
        decayRate?: number;
    }): OptimizeMethod;
    adam(options?: {
        stepSize?: number;
    }): OptimizeMethod;
    classificationLoss: LossFn;
    regressionLoss: LossFn;
};
export type OptimizationMethodName = 'sgd' | 'adagrad' | 'rmsprop' | 'adam';
export type TrainOptions = {
    iterations?: number;
    batchSize?: number;
    method?: OptimizeMethod;
};
export type OptimizeMethod = {};
export type LossFn = ((outputProbs: Tensor, trueClassIndex: number) => Tensor | number) | ((outputProbs: Tensor, trueOutput: number[]) => Tensor | number);
export type TrainingData = {
    input: NetworkInput;
    output: NetworkOutput;
}[];
export type NetworkLayerDef = {
    nOut: number;
    activation?: Activation;
};
export type Activation = NN[ActivationFunctionName];
export type ActivationFunctionName = 'relu' | 'tanh' | 'sigmoid' | 'sigmoidCentered' | 'softmax';
export interface NetworkConstructor {
    new (...args: unknown[]): Network;
    deserializeJSON(json: unknown): Network;
}
export interface Network {
    name: string;
    isTraining: boolean;
    eval(input: NetworkInput): NetworkOutput;
    setParameters(params: unknown): void;
    getParameters(): unknown;
    setTraining(isTraining: boolean): void;
    serializeJSON(): unknown;
}
export type NetworkInput = Tensor;
export type NetworkOutput = Tensor | ClassIndex;
/** @description starting from 0 */
export type ClassIndex = number;
export interface CompoundNetwork extends Network {
    networks: Network[];
}
export interface LinearNetwork extends Network {
    inSize: number;
    outSize: number;
    weights: TensorNode;
    biases: TensorNode;
}
export interface TensorConstructor {
    new (dims: number[]): Tensor;
}
export interface Tensor {
    dims: number[];
    length: number;
    fromArray(arr: number[]): this;
    fromFlatArray(arr: number[]): this;
    fillRandom(): this;
    toArray(): number[];
    toFlatArray(): number[];
    data: Float64Array;
}
export interface TensorNode extends Node<Tensor> {
    x: Tensor;
    dx: Tensor;
}
export type scalar = ScalarNode | number;
export interface ScalarNode extends Node<number> {
    x: number;
    dx: number;
    backprop(): void;
}
export interface Node<T> {
    x: T;
    parents?: Node<unknown>[];
    inputs?: unknown[];
    backward?: unknown;
    outDegree: number;
    name: string;
}
export {};