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

Data analysis model package without any dependencies

// This file is generated automatically.
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'

/**
 * @ignore
 * @typedef {import("../../../util/matrix").default} Matrix
 * @ignore
 * @typedef {import("../../../util/tensor").default} Tensor
 * @ignore
 * @typedef {import("../../neuralnetwork").default} NeuralNetwork
 */
/**
 * @typedef {(
 * { type: 'abs' } |
 * { type: 'acos' } |
 * { type: 'acosh' } |
 * { type: 'add' } |
 * { type: 'additive_coupling', d?: number | null, net?: NeuralNetwork | *[] | 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' }
 * )} PlainLayerObject
 */