@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 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 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 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[];
    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[];
} | {
    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: '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: '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: 'variable';
    size: number[] | string;
    l2_decay?: number;
    l1_decay?: number;
    value?: number[] | number[][] | Tensor;
} | {
    type: 'variance';
    axis?: number | number[] | string;
    keepdims?: boolean;
} | {
    type: 'xor';
});