ml-basic/dist/types/classifiers/neural.d.ts

Lightweight, zero dependency, machine learning library

import { Layers } from "../layers";
import DataFrame from "../lib/data-frame";
import { LossFunction } from "../lib/functions";
import Matrix from "../lib/matrix";
import Network from "../lib/network";
import Optimizer from "../optimizers/optimizer";
import Classifier from "./classifier";
export default class Neural<O extends Optimizer> extends Classifier {
    name: string;
    epochs: number;
    error: number;
    network: Network;
    optimizer: O;
    constructor({ layers, optimizer, lossFunction }: {
        layers: Layers[];
        optimizer?: O;
        lossFunction?: LossFunction;
    });
    propagate(input: Matrix): Matrix;
    backPropagate(input: Matrix, target: Matrix): number;
    predict({ input, ranking, labels }: {
        input: Matrix | number[];
        ranking?: boolean;
        labels?: any[];
    }): number[] | {
        certainty: number;
        label: any;
    } | {
        certainty: number;
        label: any;
    }[];
    fit({ data, epochs, errorThreshold, hyperParameters, logProgress, onEpoch }: {
        data: DataFrame;
        epochs: number;
        /**
         * @default 0
         */
        errorThreshold?: number;
        hyperParameters?: Omit<{
            [K in keyof O as O[K] extends Function ? never : K]?: O[K];
        }, 'name' | 't'>;
        logProgress?: boolean;
        onEpoch?: (error: number) => Promise<void> | void;
    }): number;
    validate({ data }: {
        data: DataFrame;
    }): {
        min: number;
        avg: number;
        max: number;
    };
}