@ai-on-browser/data-analysis-models/lib/model/nns/layer/index.d.ts

Data analysis model package without any dependencies

export { default as AdditiveCoupling } from "./additive_coupling.js";
export { default as AdaptivePiecewiseLinearLayer } from "./apl.js";
export { default as ArandaLayer } from "./aranda.js";
export { default as ArgmaxLayer } from "./argmax.js";
export { default as ArgminLayer } from "./argmin.js";
export { default as AttentionLayer } from "./attention.js";
export { default as AveragePoolLayer } from "./averagepool.js";
export { default as BatchNormalizationLayer } from "./batch_normalization.js";
export { default as BimodalDerivativeAdaptiveActivationLayer } from "./bdaa.js";
export { default as BendableLinearUnitLayer } from "./blu.js";
export { default as BoundedReLULayer } from "./brelu.js";
export { default as ContinuouslyDifferentiableELULayer } from "./celu.js";
export { default as ClipLayer } from "./clip.js";
export { default as ConcatLayer } from "./concat.js";
export { default as CondLayer } from "./cond.js";
export { default as ConstLayer } from "./const.js";
export { default as ConvLayer } from "./conv.js";
export { default as ConcatenatedReLULayer } from "./crelu.js";
export { default as DropoutLayer } from "./dropout.js";
export { default as ElasticELULayer } from "./eelu.js";
export { default as ELULayer } from "./elu.js";
export { default as EmbeddingLayer } from "./embedding.js";
export { default as ElasticReLULayer } from "./erelu.js";
export { default as ESwishLayer } from "./eswish.js";
export { default as FastELULayer } from "./felu.js";
export { default as FlattenLayer } from "./flatten.js";
export { default as FlexibleReLULayer } from "./frelu.js";
export { default as FullyConnected } from "./full.js";
export { default as FunctionLayer } from "./function.js";
export { default as GaussianLayer } from "./gaussian.js";
export { default as GlobalAveragePoolLayer } from "./global_averagepool.js";
export { default as GlobalLpPoolLayer } from "./global_lppool.js";
export { default as GlobalMaxPoolLayer } from "./global_maxpool.js";
export { default as GraphConvolutionalLayer } from "./graph_conv.js";
export { default as GraphSAGELayer } from "./graph_sage.js";
export { default as GRULayer } from "./gru.js";
export { default as HardShrinkLayer } from "./hard_shrink.js";
export { default as HardSigmoidLayer } from "./hard_sigmoid.js";
export { default as HardTanhLayer } from "./hard_tanh.js";
export { default as HexpoLayer } from "./hexpo.js";
export { default as HuberLayer } from "./huber.js";
export { default as IncludeLayer } from "./include.js";
export { default as InputLayer } from "./input.js";
export { default as ImprovedSigmoidLayer } from "./isigmoid.js";
export { default as LayerNormalizationLayer } from "./layer_normalization.js";
export { default as LeakyReLULayer } from "./leaky_relu.js";
export { default as LogSoftmaxLayer } from "./logsoftmax.js";
export { default as LpPoolLayer } from "./lppool.js";
export { default as LRNLayer } from "./lrn.js";
export { default as LSTMLayer } from "./lstm.js";
export { default as MatmulLayer } from "./matmul.js";
export { default as MaxPoolLayer } from "./maxpool.js";
export { default as MeanLayer } from "./mean.js";
export { default as MultipleParametricELULayer } from "./mpelu.js";
export { default as MSELayer } from "./mse.js";
export { default as MultibinTrainableLinearUnitLayer } from "./mtlu.js";
export { default as NaturalLogarithmReLULayer } from "./nlrelu.js";
export { default as OnehotLayer } from "./onehot.js";
export { default as OutputLayer } from "./output.js";
export { default as PadeActivationUnitLayer } from "./pau.js";
export { default as ParametricDeformableELULayer } from "./pdelu.js";
export { default as ParametricELULayer } from "./pelu.js";
export { default as PiecewiseLinearUnitLayer } from "./plu.js";
export { default as ParametricReLULayer } from "./prelu.js";
export { default as ParametricRectifiedExponentialUnitLayer } from "./preu.js";
export { default as ProdLayer } from "./prod.js";
export { default as ParametricSigmoidFunctionLayer } from "./psf.js";
export { default as PenalizedTanhLayer } from "./ptanh.js";
export { default as ParametricTanhLinearUnitLayer } from "./ptelu.js";
export { default as RandomLayer } from "./random.js";
export { default as ReadoutLayer } from "./readout.js";
export { default as ReduceMaxLayer } from "./reduce_max.js";
export { default as ReduceMinLayer } from "./reduce_min.js";
export { default as RectifiedPowerUnitLayer } from "./repu.js";
export { default as ReshapeLayer } from "./reshape.js";
export { default as ReverseLayer } from "./reverse.js";
export { default as RNNLayer } from "./rnn.js";
export { default as RandomizedReLULayer } from "./rrelu.js";
export { default as RandomTranslationReLULayer } from "./rtrelu.js";
export { default as ScaledELULayer } from "./selu.js";
export { default as ShapeLayer } from "./shape.js";
export { default as SigmoidLayer } from "./sigmoid.js";
export { default as SelfLearnableAFLayer } from "./slaf.js";
export { default as SoftplusLinearUnitLayer } from "./slu.js";
export { default as SoftShrinkLayer } from "./soft_shrink.js";
export { default as SoftargmaxLayer } from "./softargmax.js";
export { default as SoftmaxLayer } from "./softmax.js";
export { default as SoftminLayer } from "./softmin.js";
export { default as SoftplusLayer } from "./softplus.js";
export { default as SparseLayer } from "./sparse.js";
export { default as SpikeEncodingLayer } from "./spike_encoding.js";
export { default as SpikeLIFLayer } from "./spike_lif.js";
export { default as SplitLayer } from "./split.js";
export { default as ShiftedReLULayer } from "./srelu.js";
export { default as SoftRootSignLayer } from "./srs.js";
export { default as ScaledTanhLayer } from "./stanh.js";
export { default as StdLayer } from "./std.js";
export { default as SumLayer } from "./sum.js";
export { default as SupervisorLayer } from "./supervisor.js";
export { default as SwishLayer } from "./swish.js";
export { default as TrainableAFLayer } from "./taf.js";
export { default as ThresholdedReLULayer } from "./thresholded_relu.js";
export { default as TransposeLayer } from "./transpose.js";
export { default as UpSamplingLayer } from "./upsampling.js";
export { default as VariableLayer } from "./variable.js";
export { default as VarLayer } from "./variance.js";
export type Matrix = import("../../../util/matrix").default;
export type Tensor = import("../../../util/tensor").default;
export type NeuralNetwork = import("../../neuralnetwork").default;
export type PlainLayerObject = ({
    type: "abs";
} | {
    type: "acos";
} | {
    type: "acosh";
} | {
    type: "add";
} | {
    type: "additive_coupling";
    d?: number | null;
    net?: NeuralNetwork | any[] | null;
} | {
    type: "and";
} | {
    type: "apl";
    s?: number;
    a?: number | number[];
    b?: number | number[];
} | {
    type: "aranda";
    l?: number;
} | {
    type: "argmax";
    axis?: number;
    keepdims?: boolean;
} | {
    type: "argmin";
    axis?: number;
    keepdims?: boolean;
} | {
    type: "asin";
} | {
    type: "asinh";
} | {
    type: "atan";
} | {
    type: "atanh";
} | {
    type: "attention";
    dk?: number;
    dv?: number;
    wq?: number[][] | Matrix | string;
    wk?: number[][] | Matrix | string;
    wv?: number[][] | Matrix | string;
} | {
    type: "average_pool";
    kernel: number | number[];
    stride?: number | number[];
    padding?: number | number[];
    channel_dim?: number;
} | {
    type: "batch_normalization";
    scale?: number | number[] | string;
    offset?: number | number[] | string;
    epsilon?: number;
    channel_dim?: number;
    input_mean?: number[] | string;
    input_var?: number[] | string;
} | {
    type: "bdaa";
    alpha?: number;
} | {
    type: "bent_identity";
} | {
    type: "bitwise_and";
} | {
    type: "bitwise_not";
} | {
    type: "bitwise_or";
} | {
    type: "bitwise_xor";
} | {
    type: "blu";
    beta?: number;
} | {
    type: "brelu";
    a?: number;
} | {
    type: "ceil";
} | {
    type: "celu";
    a?: number;
} | {
    type: "clip";
    min?: number | string;
    max?: number | string;
} | {
    type: "cloglog";
} | {
    type: "cloglogm";
} | {
    type: "concat";
    axis?: number;
} | {
    type: "cond";
} | {
    type: "const";
    value: number;
} | {
    type: "conv";
    kernel: number | number[];
    channel?: number;
    stride?: number | number[];
    padding?: number | number[] | [number, number][];
    w?: number[][] | Tensor | string;
    activation?: string | object;
    l2_decay?: number;
    l1_decay?: number;
    channel_dim?: number;
} | {
    type: "cos";
} | {
    type: "cosh";
} | {
    type: "crelu";
} | {
    type: "detach";
} | {
    type: "div";
} | {
    type: "dropout";
    drop_rate?: number;
} | {
    type: "eelu";
    k?: number;
    alpha?: number;
    beta?: number;
} | {
    type: "elish";
} | {
    type: "elliott";
} | {
    type: "elu";
    a?: number;
} | {
    type: "embedding";
    size?: number;
    embeddings?: object;
} | {
    type: "equal";
} | {
    type: "erelu";
} | {
    type: "erf";
} | {
    type: "eswish";
    beta?: number;
} | {
    type: "exp";
} | {
    type: "felu";
    alpha?: number;
} | {
    type: "flatten";
} | {
    type: "floor";
} | {
    type: "frelu";
    b?: number;
} | {
    type: "full";
    out_size: number | string;
    w?: number[][] | Matrix | string;
    b?: number[][] | Matrix | string;
    activation?: string | object;
    l2_decay?: number;
    l1_decay?: number;
} | {
    type: "function";
    func: string;
} | {
    type: "gaussian";
} | {
    type: "gelu";
} | {
    type: "global_average_pool";
    channel_dim?: number;
} | {
    type: "global_lp_pool";
    p?: number;
    channel_dim?: number;
} | {
    type: "global_max_pool";
    channel_dim?: number;
} | {
    type: "graph_conv";
    out_size: number;
    w?: number[][] | Matrix | string;
    b?: number[][] | Matrix | string;
    activation?: string | object;
    l2_decay?: number;
    l1_decay?: number;
} | {
    type: "graph_sage";
    out_size: number;
    aggregate?: "mean";
    w?: number[][] | Matrix | string;
    b?: number[][] | Matrix | string;
    activation?: string | object;
    l2_decay?: number;
    l1_decay?: number;
} | {
    type: "greater";
} | {
    type: "greater_or_equal";
} | {
    type: "gru";
    size: number;
    return_sequences?: boolean;
    w_z?: number[][] | Matrix | string;
    w_r?: number[][] | Matrix | string;
    w_h?: number[][] | Matrix | string;
    u_z?: number[][] | Matrix | string;
    u_r?: number[][] | Matrix | string;
    u_h?: number[][] | Matrix | string;
    b_z?: number[][] | Matrix | string;
    b_r?: number[][] | Matrix | string;
    b_h?: number[][] | Matrix | string;
    sequence_dim?: number;
} | {
    type: "hard_elish";
} | {
    type: "hard_shrink";
    l?: number;
} | {
    type: "hard_sigmoid";
    alpha?: number;
    beta?: number;
} | {
    type: "hard_swish";
} | {
    type: "hard_tanh";
    v?: number;
} | {
    type: "hexpo";
    a?: number;
    b?: number;
    c?: number;
    d?: number;
} | {
    type: "huber";
} | {
    type: "identity";
} | {
    type: "include";
    net: NeuralNetwork | object[];
    input_to?: string;
    train?: boolean;
} | {
    type: "input";
    name?: string;
    size?: (number | null)[];
    value?: number | number[] | number[][] | number[][][] | number[][][][] | Matrix | Tensor;
} | {
    type: "is_inf";
} | {
    type: "is_nan";
} | {
    type: "isigmoid";
    a?: number;
    alpha?: number;
} | {
    type: "layer_normalization";
    axis?: number;
    epsilon?: number;
    scale?: number | number[] | string;
    offset?: number | number[] | string;
} | {
    type: "leaky_relu";
    a?: number;
} | {
    type: "left_bitshift";
} | {
    type: "less";
} | {
    type: "less_or_equal";
} | {
    type: "lisht";
} | {
    type: "log";
} | {
    type: "log_softmax";
    axis?: number;
} | {
    type: "loglog";
} | {
    type: "logsigmoid";
} | {
    type: "lp_pool";
    p?: number;
    kernel: number | number[];
    stride?: number | number[];
    padding?: number | number[];
    channel_dim?: number;
} | {
    type: "lrn";
    alpha?: number;
    beta?: number;
    k?: number;
    n: number;
    channel_dim?: number;
} | {
    type: "lstm";
    size: number;
    return_sequences?: boolean;
    w_z?: number[][] | Matrix | string;
    w_in?: number[][] | Matrix | string;
    w_for?: number[][] | Matrix | string;
    w_out?: number[][] | Matrix | string;
    r_z?: number[][] | Matrix | string;
    r_in?: number[][] | Matrix | string;
    r_for?: number[][] | Matrix | string;
    r_out?: number[][] | Matrix | string;
    p_in?: number[][] | Matrix | string;
    p_for?: number[][] | Matrix | string;
    p_out?: number[][] | Matrix | string;
    b_z?: number[][] | Matrix | string;
    b_in?: number[][] | Matrix | string;
    b_for?: number[][] | Matrix | string;
    b_out?: number[][] | Matrix | string;
    sequence_dim?: number;
} | {
    type: "matmul";
} | {
    type: "max";
} | {
    type: "max_pool";
    kernel: number | number[];
    stride?: number | number[];
    padding?: number | number[];
    channel_dim?: number;
} | {
    type: "mean";
    axis?: number | number[] | string;
    keepdims?: boolean;
} | {
    type: "min";
} | {
    type: "mish";
} | {
    type: "mod";
} | {
    type: "mpelu";
    alpha?: number;
    beta?: number;
} | {
    type: "mse";
} | {
    type: "mtlu";
    a?: number | number[];
    b?: number | number[];
    c?: number | number[];
    k?: number;
} | {
    type: "mult";
} | {
    type: "negative";
} | {
    type: "nlrelu";
    beta?: number;
} | {
    type: "not";
} | {
    type: "onehot";
    class_size?: number;
    values?: number[];
} | {
    type: "or";
} | {
    type: "output";
} | {
    type: "pau";
    m?: number;
    n?: number;
    a?: number | number[];
    b?: number | number[];
} | {
    type: "pdelu";
    t?: number;
    alpha?: number;
} | {
    type: "pelu";
    a?: number;
    b?: number;
} | {
    type: "plu";
    alpha?: number;
    c?: number;
} | {
    type: "power";
} | {
    type: "prelu";
    a?: number | number[] | string;
} | {
    type: "preu";
    alpha?: number;
    beta?: number;
} | {
    type: "prod";
    axis?: number | number[] | string;
    keepdims?: boolean;
} | {
    type: "psf";
    m?: number;
} | {
    type: "ptanh";
    a?: number;
} | {
    type: "ptelu";
    alpha?: number;
    beta?: number;
} | {
    type: "random";
    size: number | number[] | string;
    mean?: number;
    variance?: number;
} | {
    type: "readout";
    method?: "sum" | "mean";
} | {
    type: "reciprocal";
} | {
    type: "reduce_max";
    axis?: number | number[] | string;
    keepdims?: boolean;
} | {
    type: "reduce_min";
    axis?: number | number[] | string;
    keepdims?: boolean;
} | {
    type: "relu";
} | {
    type: "repu";
    s?: number;
} | {
    type: "resech";
} | {
    type: "reshape";
    size: number[] | string;
} | {
    type: "reu";
} | {
    type: "reverse";
    axis?: number;
} | {
    type: "right_bitshift";
} | {
    type: "rnn";
    size: number;
    activation?: string | object;
    return_sequences?: boolean;
    w_x?: number[][] | Matrix | string;
    w_h?: number[][] | Matrix | string;
    b_x?: number[][] | Matrix | string;
    b_h?: number[][] | Matrix | string;
    sequence_dim?: number;
} | {
    type: "rootsig";
} | {
    type: "round";
} | {
    type: "rrelu";
    l?: number;
    u?: number;
} | {
    type: "rtrelu";
} | {
    type: "selu";
    a?: number;
    g?: number;
} | {
    type: "shape";
} | {
    type: "sigmoid";
    a?: number;
} | {
    type: "sign";
} | {
    type: "silu";
} | {
    type: "sin";
} | {
    type: "sinh";
} | {
    type: "slaf";
    n?: number;
    a?: number | number[];
} | {
    type: "slu";
    alpha?: number;
    beta?: number;
    gamma?: number;
} | {
    type: "soft_shrink";
    l?: number;
} | {
    type: "softargmax";
    beta?: number;
} | {
    type: "softmax";
    axis?: number;
} | {
    type: "softmin";
    axis?: number;
} | {
    type: "softplus";
    beta?: number;
} | {
    type: "softsign";
} | {
    type: "sparsity";
    rho: number;
    beta: number;
} | {
    type: "spike_encoding";
    size: number;
    method?: string;
    max_freq?: number;
    dt?: number;
} | {
    type: "spike_lif";
    size: number;
    w?: number[][] | Matrix | string;
    th?: number;
    spike_train_dim?: number;
} | {
    type: "split";
    axis?: number;
    size: number | number[];
} | {
    type: "sqrt";
} | {
    type: "square";
} | {
    type: "srelu";
    d?: number;
} | {
    type: "srs";
    alpha?: number;
    beta?: number;
} | {
    type: "ssigmoid";
} | {
    type: "stanh";
    a?: number;
    b?: number;
} | {
    type: "std";
    axis?: number | number[] | string;
    keepdims?: boolean;
} | {
    type: "sub";
} | {
    type: "sum";
    axis?: number | number[] | string;
    keepdims?: boolean;
} | {
    type: "supervisor";
} | {
    type: "swish";
    beta?: number;
} | {
    type: "taf";
    a?: number;
    b?: number;
} | {
    type: "tan";
} | {
    type: "tanh";
} | {
    type: "tanhexp";
} | {
    type: "tanhshrink";
} | {
    type: "thresholded_relu";
    a?: number;
} | {
    type: "transpose";
    axis: number[];
} | {
    type: "up_sampling";
    size: number | number[];
    channel_dim?: number;
} | {
    type: "variable";
    size: number[] | string;
    l2_decay?: number;
    l1_decay?: number;
    value?: number[] | number[][] | Tensor;
} | {
    type: "variance";
    axis?: number | number[] | string;
    keepdims?: boolean;
} | {
    type: "xor";
});