/**
|
* @license
|
* Copyright 2018 Google LLC
|
*
|
* Use of this source code is governed by an MIT-style
|
* license that can be found in the LICENSE file or at
|
* https://opensource.org/licenses/MIT.
|
* =============================================================================
|
*/
|
import { InputLayer } from './engine/input_layer';
|
import { Layer } from './engine/topology';
|
import { input } from './exports';
|
import { ELU, LeakyReLU, PReLU, ReLU, Softmax, ThresholdedReLU } from './layers/advanced_activations';
|
import { Conv1D, Conv2D, Conv2DTranspose, Conv3D, Cropping2D, SeparableConv2D, UpSampling2D, Conv3DTranspose } from './layers/convolutional';
|
import { DepthwiseConv2D } from './layers/convolutional_depthwise';
|
import { ConvLSTM2D, ConvLSTM2DCell } from './layers/convolutional_recurrent';
|
import { Activation, Dense, Dropout, Flatten, Masking, Permute, RepeatVector, Reshape, SpatialDropout1D } from './layers/core';
|
import { Embedding } from './layers/embeddings';
|
import { Add, Average, Concatenate, Dot, Maximum, Minimum, Multiply } from './layers/merge';
|
import { AlphaDropout, GaussianDropout, GaussianNoise } from './layers/noise';
|
import { BatchNormalization, LayerNormalization } from './layers/normalization';
|
import { ZeroPadding2D } from './layers/padding';
|
import { AveragePooling1D, AveragePooling2D, AveragePooling3D, GlobalAveragePooling1D, GlobalAveragePooling2D, GlobalMaxPooling1D, GlobalMaxPooling2D, MaxPooling1D, MaxPooling2D, MaxPooling3D } from './layers/pooling';
|
import { GRU, GRUCell, LSTM, LSTMCell, RNN, RNNCell, SimpleRNN, SimpleRNNCell, StackedRNNCells } from './layers/recurrent';
|
import { Bidirectional, TimeDistributed } from './layers/wrappers';
|
import { Rescaling } from './layers/preprocessing/image_preprocessing';
|
import { CenterCrop } from './layers/preprocessing/center_crop';
|
import { CategoryEncoding } from './layers/preprocessing/category_encoding';
|
import { Resizing } from './layers/preprocessing/image_resizing';
|
import { RandomWidth } from './layers/preprocessing/random_width';
|
// TODO(cais): Add doc string to all the public static functions in this
|
// class; include exectuable JavaScript code snippets where applicable
|
// (b/74074458).
|
// Input Layer.
|
/**
|
* An input layer is an entry point into a `tf.LayersModel`.
|
*
|
* `InputLayer` is generated automatically for `tf.Sequential` models by
|
* specifying the `inputshape` or `batchInputShape` for the first layer. It
|
* should not be specified explicitly. However, it can be useful sometimes,
|
* e.g., when constructing a sequential model from a subset of another
|
* sequential model's layers. Like the code snippet below shows.
|
*
|
* ```js
|
* // Define a model which simply adds two inputs.
|
* const model1 = tf.sequential();
|
* model1.add(tf.layers.dense({inputShape: [4], units: 3, activation: 'relu'}));
|
* model1.add(tf.layers.dense({units: 1, activation: 'sigmoid'}));
|
* model1.summary();
|
* model1.predict(tf.zeros([1, 4])).print();
|
*
|
* // Construct another model, reusing the second layer of `model1` while
|
* // not using the first layer of `model1`. Note that you cannot add the second
|
* // layer of `model` directly as the first layer of the new sequential model,
|
* // because doing so will lead to an error related to the fact that the layer
|
* // is not an input layer. Instead, you need to create an `inputLayer` and add
|
* // it to the new sequential model before adding the reused layer.
|
* const model2 = tf.sequential();
|
* // Use an inputShape that matches the input shape of `model1`'s second
|
* // layer.
|
* model2.add(tf.layers.inputLayer({inputShape: [3]}));
|
* model2.add(model1.layers[1]);
|
* model2.summary();
|
* model2.predict(tf.zeros([1, 3])).print();
|
* ```
|
*
|
* @doc {heading: 'Layers', subheading: 'Inputs', namespace: 'layers'}
|
*/
|
export function inputLayer(args) {
|
return new InputLayer(args);
|
}
|
// Advanced Activation Layers.
|
/**
|
* Exponential Linear Unit (ELU).
|
*
|
* It follows:
|
* `f(x) = alpha * (exp(x) - 1.) for x < 0`,
|
* `f(x) = x for x >= 0`.
|
*
|
* Input shape:
|
* Arbitrary. Use the configuration `inputShape` when using this layer as the
|
* first layer in a model.
|
*
|
* Output shape:
|
* Same shape as the input.
|
*
|
* References:
|
* - [Fast and Accurate Deep Network Learning by Exponential Linear Units
|
* (ELUs)](https://arxiv.org/abs/1511.07289v1)
|
*
|
* @doc {
|
* heading: 'Layers',
|
* subheading: 'Advanced Activation',
|
* namespace: 'layers'
|
* }
|
*/
|
export function elu(args) {
|
return new ELU(args);
|
}
|
/**
|
* Rectified Linear Unit activation function.
|
*
|
* Input shape:
|
* Arbitrary. Use the config field `inputShape` (Array of integers, does
|
* not include the sample axis) when using this layer as the first layer
|
* in a model.
|
*
|
* Output shape:
|
* Same shape as the input.
|
*
|
* @doc {
|
* heading: 'Layers',
|
* subheading: 'Advanced Activation',
|
* namespace: 'layers'
|
* }
|
*/
|
export function reLU(args) {
|
return new ReLU(args);
|
}
|
/**
|
* Leaky version of a rectified linear unit.
|
*
|
* It allows a small gradient when the unit is not active:
|
* `f(x) = alpha * x for x < 0.`
|
* `f(x) = x for x >= 0.`
|
*
|
* Input shape:
|
* Arbitrary. Use the configuration `inputShape` when using this layer as the
|
* first layer in a model.
|
*
|
* Output shape:
|
* Same shape as the input.
|
*
|
* @doc {
|
* heading: 'Layers',
|
* subheading: 'Advanced Activation',
|
* namespace: 'layers'
|
* }
|
*/
|
export function leakyReLU(args) {
|
return new LeakyReLU(args);
|
}
|
/**
|
* Parameterized version of a leaky rectified linear unit.
|
*
|
* It follows
|
* `f(x) = alpha * x for x < 0.`
|
* `f(x) = x for x >= 0.`
|
* wherein `alpha` is a trainable weight.
|
*
|
* Input shape:
|
* Arbitrary. Use the configuration `inputShape` when using this layer as the
|
* first layer in a model.
|
*
|
* Output shape:
|
* Same shape as the input.
|
*
|
* @doc {
|
* heading: 'Layers',
|
* subheading: 'Advanced Activation',
|
* namespace: 'layers'
|
* }
|
*/
|
export function prelu(args) {
|
return new PReLU(args);
|
}
|
/**
|
* Softmax activation layer.
|
*
|
* Input shape:
|
* Arbitrary. Use the configuration `inputShape` when using this layer as the
|
* first layer in a model.
|
*
|
* Output shape:
|
* Same shape as the input.
|
*
|
* @doc {
|
* heading: 'Layers',
|
* subheading: 'Advanced Activation',
|
* namespace: 'layers'
|
* }
|
*/
|
export function softmax(args) {
|
return new Softmax(args);
|
}
|
/**
|
* Thresholded Rectified Linear Unit.
|
*
|
* It follows:
|
* `f(x) = x for x > theta`,
|
* `f(x) = 0 otherwise`.
|
*
|
* Input shape:
|
* Arbitrary. Use the configuration `inputShape` when using this layer as the
|
* first layer in a model.
|
*
|
* Output shape:
|
* Same shape as the input.
|
*
|
* References:
|
* - [Zero-Bias Autoencoders and the Benefits of Co-Adapting
|
* Features](http://arxiv.org/abs/1402.3337)
|
*
|
* @doc {
|
* heading: 'Layers',
|
* subheading: 'Advanced Activation',
|
* namespace: 'layers'
|
* }
|
*/
|
export function thresholdedReLU(args) {
|
return new ThresholdedReLU(args);
|
}
|
// Convolutional Layers.
|
/**
|
* 1D convolution layer (e.g., temporal convolution).
|
*
|
* This layer creates a convolution kernel that is convolved
|
* with the layer input over a single spatial (or temporal) dimension
|
* to produce a tensor of outputs.
|
*
|
* If `use_bias` is True, a bias vector is created and added to the outputs.
|
*
|
* If `activation` is not `null`, it is applied to the outputs as well.
|
*
|
* When using this layer as the first layer in a model, provide an
|
* `inputShape` argument `Array` or `null`.
|
*
|
* For example, `inputShape` would be:
|
* - `[10, 128]` for sequences of 10 vectors of 128-dimensional vectors
|
* - `[null, 128]` for variable-length sequences of 128-dimensional vectors.
|
*
|
* @doc {heading: 'Layers', subheading: 'Convolutional', namespace: 'layers'}
|
*/
|
export function conv1d(args) {
|
return new Conv1D(args);
|
}
|
/**
|
* 2D convolution layer (e.g. spatial convolution over images).
|
*
|
* This layer creates a convolution kernel that is convolved
|
* with the layer input to produce a tensor of outputs.
|
*
|
* If `useBias` is True, a bias vector is created and added to the outputs.
|
*
|
* If `activation` is not `null`, it is applied to the outputs as well.
|
*
|
* When using this layer as the first layer in a model,
|
* provide the keyword argument `inputShape`
|
* (Array of integers, does not include the sample axis),
|
* e.g. `inputShape=[128, 128, 3]` for 128x128 RGB pictures
|
* in `dataFormat='channelsLast'`.
|
*
|
* @doc {heading: 'Layers', subheading: 'Convolutional', namespace: 'layers'}
|
*/
|
export function conv2d(args) {
|
return new Conv2D(args);
|
}
|
/**
|
* Transposed convolutional layer (sometimes called Deconvolution).
|
*
|
* The need for transposed convolutions generally arises
|
* from the desire to use a transformation going in the opposite direction of
|
* a normal convolution, i.e., from something that has the shape of the output
|
* of some convolution to something that has the shape of its input while
|
* maintaining a connectivity pattern that is compatible with said
|
* convolution.
|
*
|
* When using this layer as the first layer in a model, provide the
|
* configuration `inputShape` (`Array` of integers, does not include the
|
* sample axis), e.g., `inputShape: [128, 128, 3]` for 128x128 RGB pictures in
|
* `dataFormat: 'channelsLast'`.
|
*
|
* Input shape:
|
* 4D tensor with shape:
|
* `[batch, channels, rows, cols]` if `dataFormat` is `'channelsFirst'`.
|
* or 4D tensor with shape
|
* `[batch, rows, cols, channels]` if `dataFormat` is `'channelsLast'`.
|
*
|
* Output shape:
|
* 4D tensor with shape:
|
* `[batch, filters, newRows, newCols]` if `dataFormat` is
|
* `'channelsFirst'`. or 4D tensor with shape:
|
* `[batch, newRows, newCols, filters]` if `dataFormat` is `'channelsLast'`.
|
*
|
* References:
|
* - [A guide to convolution arithmetic for deep
|
* learning](https://arxiv.org/abs/1603.07285v1)
|
* - [Deconvolutional
|
* Networks](http://www.matthewzeiler.com/pubs/cvpr2010/cvpr2010.pdf)
|
*
|
* @doc {heading: 'Layers', subheading: 'Convolutional', namespace: 'layers'}
|
*/
|
export function conv2dTranspose(args) {
|
return new Conv2DTranspose(args);
|
}
|
/**
|
* 3D convolution layer (e.g. spatial convolution over volumes).
|
*
|
* This layer creates a convolution kernel that is convolved
|
* with the layer input to produce a tensor of outputs.
|
*
|
* If `useBias` is True, a bias vector is created and added to the outputs.
|
*
|
* If `activation` is not `null`, it is applied to the outputs as well.
|
*
|
* When using this layer as the first layer in a model,
|
* provide the keyword argument `inputShape`
|
* (Array of integers, does not include the sample axis),
|
* e.g. `inputShape=[128, 128, 128, 1]` for 128x128x128 grayscale volumes
|
* in `dataFormat='channelsLast'`.
|
*
|
* @doc {heading: 'Layers', subheading: 'Convolutional', namespace: 'layers'}
|
*/
|
export function conv3d(args) {
|
return new Conv3D(args);
|
}
|
export function conv3dTranspose(args) {
|
return new Conv3DTranspose(args);
|
}
|
/**
|
* Depthwise separable 2D convolution.
|
*
|
* Separable convolution consists of first performing
|
* a depthwise spatial convolution
|
* (which acts on each input channel separately)
|
* followed by a pointwise convolution which mixes together the resulting
|
* output channels. The `depthMultiplier` argument controls how many
|
* output channels are generated per input channel in the depthwise step.
|
*
|
* Intuitively, separable convolutions can be understood as
|
* a way to factorize a convolution kernel into two smaller kernels,
|
* or as an extreme version of an Inception block.
|
*
|
* Input shape:
|
* 4D tensor with shape:
|
* `[batch, channels, rows, cols]` if data_format='channelsFirst'
|
* or 4D tensor with shape:
|
* `[batch, rows, cols, channels]` if data_format='channelsLast'.
|
*
|
* Output shape:
|
* 4D tensor with shape:
|
* `[batch, filters, newRows, newCols]` if data_format='channelsFirst'
|
* or 4D tensor with shape:
|
* `[batch, newRows, newCols, filters]` if data_format='channelsLast'.
|
* `rows` and `cols` values might have changed due to padding.
|
*
|
* @doc {heading: 'Layers', subheading: 'Convolutional', namespace: 'layers'}
|
*/
|
export function separableConv2d(args) {
|
return new SeparableConv2D(args);
|
}
|
/**
|
* Cropping layer for 2D input (e.g., image).
|
*
|
* This layer can crop an input
|
* at the top, bottom, left and right side of an image tensor.
|
*
|
* Input shape:
|
* 4D tensor with shape:
|
* - If `dataFormat` is `"channelsLast"`:
|
* `[batch, rows, cols, channels]`
|
* - If `data_format` is `"channels_first"`:
|
* `[batch, channels, rows, cols]`.
|
*
|
* Output shape:
|
* 4D with shape:
|
* - If `dataFormat` is `"channelsLast"`:
|
* `[batch, croppedRows, croppedCols, channels]`
|
* - If `dataFormat` is `"channelsFirst"`:
|
* `[batch, channels, croppedRows, croppedCols]`.
|
*
|
* Examples
|
* ```js
|
*
|
* const model = tf.sequential();
|
* model.add(tf.layers.cropping2D({cropping:[[2, 2], [2, 2]],
|
* inputShape: [128, 128, 3]}));
|
* //now output shape is [batch, 124, 124, 3]
|
* ```
|
*
|
* @doc {heading: 'Layers', subheading: 'Convolutional', namespace: 'layers'}
|
*/
|
export function cropping2D(args) {
|
return new Cropping2D(args);
|
}
|
/**
|
* Upsampling layer for 2D inputs.
|
*
|
* Repeats the rows and columns of the data
|
* by size[0] and size[1] respectively.
|
*
|
*
|
* Input shape:
|
* 4D tensor with shape:
|
* - If `dataFormat` is `"channelsLast"`:
|
* `[batch, rows, cols, channels]`
|
* - If `dataFormat` is `"channelsFirst"`:
|
* `[batch, channels, rows, cols]`
|
*
|
* Output shape:
|
* 4D tensor with shape:
|
* - If `dataFormat` is `"channelsLast"`:
|
* `[batch, upsampledRows, upsampledCols, channels]`
|
* - If `dataFormat` is `"channelsFirst"`:
|
* `[batch, channels, upsampledRows, upsampledCols]`
|
*
|
*
|
* @doc {heading: 'Layers', subheading: 'Convolutional', namespace: 'layers'}
|
*/
|
export function upSampling2d(args) {
|
return new UpSampling2D(args);
|
}
|
// Convolutional(depthwise) Layers.
|
/**
|
* Depthwise separable 2D convolution.
|
*
|
* Depthwise Separable convolutions consists in performing just the first step
|
* in a depthwise spatial convolution (which acts on each input channel
|
* separately). The `depthMultiplier` argument controls how many output channels
|
* are generated per input channel in the depthwise step.
|
*
|
* @doc {heading: 'Layers', subheading: 'Convolutional', namespace: 'layers'}
|
*/
|
export function depthwiseConv2d(args) {
|
return new DepthwiseConv2D(args);
|
}
|
// Basic Layers.
|
/**
|
* Applies an activation function to an output.
|
*
|
* This layer applies element-wise activation function. Other layers, notably
|
* `dense` can also apply activation functions. Use this isolated activation
|
* function to extract the values before and after the
|
* activation. For instance:
|
*
|
* ```js
|
* const input = tf.input({shape: [5]});
|
* const denseLayer = tf.layers.dense({units: 1});
|
* const activationLayer = tf.layers.activation({activation: 'relu6'});
|
*
|
* // Obtain the output symbolic tensors by applying the layers in order.
|
* const denseOutput = denseLayer.apply(input);
|
* const activationOutput = activationLayer.apply(denseOutput);
|
*
|
* // Create the model based on the inputs.
|
* const model = tf.model({
|
* inputs: input,
|
* outputs: [denseOutput, activationOutput]
|
* });
|
*
|
* // Collect both outputs and print separately.
|
* const [denseOut, activationOut] = model.predict(tf.randomNormal([6, 5]));
|
* denseOut.print();
|
* activationOut.print();
|
* ```
|
*
|
* @doc {heading: 'Layers', subheading: 'Basic', namespace: 'layers'}
|
*/
|
export function activation(args) {
|
return new Activation(args);
|
}
|
/**
|
* Creates a dense (fully connected) layer.
|
*
|
* This layer implements the operation:
|
* `output = activation(dot(input, kernel) + bias)`
|
*
|
* `activation` is the element-wise activation function
|
* passed as the `activation` argument.
|
*
|
* `kernel` is a weights matrix created by the layer.
|
*
|
* `bias` is a bias vector created by the layer (only applicable if `useBias`
|
* is `true`).
|
*
|
* **Input shape:**
|
*
|
* nD `tf.Tensor` with shape: `(batchSize, ..., inputDim)`.
|
*
|
* The most common situation would be
|
* a 2D input with shape `(batchSize, inputDim)`.
|
*
|
* **Output shape:**
|
*
|
* nD tensor with shape: `(batchSize, ..., units)`.
|
*
|
* For instance, for a 2D input with shape `(batchSize, inputDim)`,
|
* the output would have shape `(batchSize, units)`.
|
*
|
* Note: if the input to the layer has a rank greater than 2, then it is
|
* flattened prior to the initial dot product with the kernel.
|
*
|
* @doc {heading: 'Layers', subheading: 'Basic', namespace: 'layers'}
|
*/
|
export function dense(args) {
|
return new Dense(args);
|
}
|
/**
|
* Applies
|
* [dropout](http://www.cs.toronto.edu/~rsalakhu/papers/srivastava14a.pdf) to
|
* the input.
|
*
|
* Dropout consists in randomly setting a fraction `rate` of input units to 0 at
|
* each update during training time, which helps prevent overfitting.
|
*
|
* @doc {heading: 'Layers', subheading: 'Basic', namespace: 'layers'}
|
*/
|
export function dropout(args) {
|
return new Dropout(args);
|
}
|
/**
|
* Spatial 1D version of Dropout.
|
*
|
* This Layer type performs the same function as the Dropout layer, but it drops
|
* entire 1D feature maps instead of individual elements. For example, if an
|
* input example consists of 3 timesteps and the feature map for each timestep
|
* has a size of 4, a `spatialDropout1d` layer may zero out the feature maps
|
* of the 1st timesteps and 2nd timesteps completely while sparing all feature
|
* elements of the 3rd timestep.
|
*
|
* If adjacent frames (timesteps) are strongly correlated (as is normally the
|
* case in early convolution layers), regular dropout will not regularize the
|
* activation and will otherwise just result in merely an effective learning
|
* rate decrease. In this case, `spatialDropout1d` will help promote
|
* independence among feature maps and should be used instead.
|
*
|
* **Arguments:**
|
* rate: A floating-point number >=0 and <=1. Fraction of the input elements
|
* to drop.
|
*
|
* **Input shape:**
|
* 3D tensor with shape `(samples, timesteps, channels)`.
|
*
|
* **Output shape:**
|
* Same as the input shape.
|
*
|
* References:
|
* - [Efficient Object Localization Using Convolutional
|
* Networks](https://arxiv.org/abs/1411.4280)
|
*
|
* @doc {heading: 'Layers', subheading: 'Basic', namespace: 'layers'}
|
*/
|
export function spatialDropout1d(args) {
|
return new SpatialDropout1D(args);
|
}
|
/**
|
* Flattens the input. Does not affect the batch size.
|
*
|
* A `Flatten` layer flattens each batch in its inputs to 1D (making the output
|
* 2D).
|
*
|
* For example:
|
*
|
* ```js
|
* const input = tf.input({shape: [4, 3]});
|
* const flattenLayer = tf.layers.flatten();
|
* // Inspect the inferred output shape of the flatten layer, which
|
* // equals `[null, 12]`. The 2nd dimension is 4 * 3, i.e., the result of the
|
* // flattening. (The 1st dimension is the undermined batch size.)
|
* console.log(JSON.stringify(flattenLayer.apply(input).shape));
|
* ```
|
*
|
* @doc {heading: 'Layers', subheading: 'Basic', namespace: 'layers'}
|
*/
|
export function flatten(args) {
|
return new Flatten(args);
|
}
|
/**
|
* Repeats the input n times in a new dimension.
|
*
|
* ```js
|
* const model = tf.sequential();
|
* model.add(tf.layers.repeatVector({n: 4, inputShape: [2]}));
|
* const x = tf.tensor2d([[10, 20]]);
|
* // Use the model to do inference on a data point the model hasn't seen
|
* model.predict(x).print();
|
* // output shape is now [batch, 2, 4]
|
* ```
|
*
|
* @doc {heading: 'Layers', subheading: 'Basic', namespace: 'layers'}
|
*/
|
export function repeatVector(args) {
|
return new RepeatVector(args);
|
}
|
/**
|
* Reshapes an input to a certain shape.
|
*
|
* ```js
|
* const input = tf.input({shape: [4, 3]});
|
* const reshapeLayer = tf.layers.reshape({targetShape: [2, 6]});
|
* // Inspect the inferred output shape of the Reshape layer, which
|
* // equals `[null, 2, 6]`. (The 1st dimension is the undermined batch size.)
|
* console.log(JSON.stringify(reshapeLayer.apply(input).shape));
|
* ```
|
*
|
* Input shape:
|
* Arbitrary, although all dimensions in the input shape must be fixed.
|
* Use the configuration `inputShape` when using this layer as the
|
* first layer in a model.
|
*
|
*
|
* Output shape:
|
* [batchSize, targetShape[0], targetShape[1], ...,
|
* targetShape[targetShape.length - 1]].
|
*
|
* @doc {heading: 'Layers', subheading: 'Basic', namespace: 'layers'}
|
*/
|
export function reshape(args) {
|
return new Reshape(args);
|
}
|
/**
|
* Permutes the dimensions of the input according to a given pattern.
|
*
|
* Useful for, e.g., connecting RNNs and convnets together.
|
*
|
* Example:
|
*
|
* ```js
|
* const model = tf.sequential();
|
* model.add(tf.layers.permute({
|
* dims: [2, 1],
|
* inputShape: [10, 64]
|
* }));
|
* console.log(model.outputShape);
|
* // Now model's output shape is [null, 64, 10], where null is the
|
* // unpermuted sample (batch) dimension.
|
* ```
|
*
|
* Input shape:
|
* Arbitrary. Use the configuration field `inputShape` when using this
|
* layer as the first layer in a model.
|
*
|
* Output shape:
|
* Same rank as the input shape, but with the dimensions re-ordered (i.e.,
|
* permuted) according to the `dims` configuration of this layer.
|
*
|
* @doc {heading: 'Layers', subheading: 'Basic', namespace: 'layers'}
|
*/
|
export function permute(args) {
|
return new Permute(args);
|
}
|
/**
|
* Maps positive integers (indices) into dense vectors of fixed size.
|
* E.g. [[4], [20]] -> [[0.25, 0.1], [0.6, -0.2]]
|
*
|
* **Input shape:** 2D tensor with shape: `[batchSize, sequenceLength]`.
|
*
|
* **Output shape:** 3D tensor with shape: `[batchSize, sequenceLength,
|
* outputDim]`.
|
*
|
* @doc {heading: 'Layers', subheading: 'Basic', namespace: 'layers'}
|
*/
|
export function embedding(args) {
|
return new Embedding(args);
|
}
|
// Merge Layers.
|
/**
|
* Layer that performs element-wise addition on an `Array` of inputs.
|
*
|
* It takes as input a list of tensors, all of the same shape, and returns a
|
* single tensor (also of the same shape). The inputs are specified as an
|
* `Array` when the `apply` method of the `Add` layer instance is called. For
|
* example:
|
*
|
* ```js
|
* const input1 = tf.input({shape: [2, 2]});
|
* const input2 = tf.input({shape: [2, 2]});
|
* const addLayer = tf.layers.add();
|
* const sum = addLayer.apply([input1, input2]);
|
* console.log(JSON.stringify(sum.shape));
|
* // You get [null, 2, 2], with the first dimension as the undetermined batch
|
* // dimension.
|
* ```
|
*
|
* @doc {heading: 'Layers', subheading: 'Merge', namespace: 'layers'}
|
*/
|
export function add(args) {
|
return new Add(args);
|
}
|
/**
|
* Layer that performs element-wise averaging on an `Array` of inputs.
|
*
|
* It takes as input a list of tensors, all of the same shape, and returns a
|
* single tensor (also of the same shape). For example:
|
*
|
* ```js
|
* const input1 = tf.input({shape: [2, 2]});
|
* const input2 = tf.input({shape: [2, 2]});
|
* const averageLayer = tf.layers.average();
|
* const average = averageLayer.apply([input1, input2]);
|
* console.log(JSON.stringify(average.shape));
|
* // You get [null, 2, 2], with the first dimension as the undetermined batch
|
* // dimension.
|
* ```
|
*
|
* @doc {heading: 'Layers', subheading: 'Merge', namespace: 'layers'}
|
*/
|
export function average(args) {
|
return new Average(args);
|
}
|
/**
|
* Layer that concatenates an `Array` of inputs.
|
*
|
* It takes a list of tensors, all of the same shape except for the
|
* concatenation axis, and returns a single tensor, the concatenation
|
* of all inputs. For example:
|
*
|
* ```js
|
* const input1 = tf.input({shape: [2, 2]});
|
* const input2 = tf.input({shape: [2, 3]});
|
* const concatLayer = tf.layers.concatenate();
|
* const output = concatLayer.apply([input1, input2]);
|
* console.log(JSON.stringify(output.shape));
|
* // You get [null, 2, 5], with the first dimension as the undetermined batch
|
* // dimension. The last dimension (5) is the result of concatenating the
|
* // last dimensions of the inputs (2 and 3).
|
* ```
|
*
|
* @doc {heading: 'Layers', subheading: 'Merge', namespace: 'layers'}
|
*/
|
export function concatenate(args) {
|
return new Concatenate(args);
|
}
|
/**
|
* Layer that computes the element-wise maximum of an `Array` of inputs.
|
*
|
* It takes as input a list of tensors, all of the same shape, and returns a
|
* single tensor (also of the same shape). For example:
|
*
|
* ```js
|
* const input1 = tf.input({shape: [2, 2]});
|
* const input2 = tf.input({shape: [2, 2]});
|
* const maxLayer = tf.layers.maximum();
|
* const max = maxLayer.apply([input1, input2]);
|
* console.log(JSON.stringify(max.shape));
|
* // You get [null, 2, 2], with the first dimension as the undetermined batch
|
* // dimension.
|
* ```
|
*
|
* @doc {heading: 'Layers', subheading: 'Merge', namespace: 'layers'}
|
*/
|
export function maximum(args) {
|
return new Maximum(args);
|
}
|
/**
|
* Layer that computes the element-wise minimum of an `Array` of inputs.
|
*
|
* It takes as input a list of tensors, all of the same shape, and returns a
|
* single tensor (also of the same shape). For example:
|
*
|
* ```js
|
* const input1 = tf.input({shape: [2, 2]});
|
* const input2 = tf.input({shape: [2, 2]});
|
* const minLayer = tf.layers.minimum();
|
* const min = minLayer.apply([input1, input2]);
|
* console.log(JSON.stringify(min.shape));
|
* // You get [null, 2, 2], with the first dimension as the undetermined batch
|
* // dimension.
|
* ```
|
*
|
* @doc {heading: 'Layers', subheading: 'Merge', namespace: 'layers'}
|
*/
|
export function minimum(args) {
|
return new Minimum(args);
|
}
|
/**
|
* Layer that multiplies (element-wise) an `Array` of inputs.
|
*
|
* It takes as input an Array of tensors, all of the same
|
* shape, and returns a single tensor (also of the same shape).
|
* For example:
|
*
|
* ```js
|
* const input1 = tf.input({shape: [2, 2]});
|
* const input2 = tf.input({shape: [2, 2]});
|
* const input3 = tf.input({shape: [2, 2]});
|
* const multiplyLayer = tf.layers.multiply();
|
* const product = multiplyLayer.apply([input1, input2, input3]);
|
* console.log(product.shape);
|
* // You get [null, 2, 2], with the first dimension as the undetermined batch
|
* // dimension.
|
*
|
* @doc {heading: 'Layers', subheading: 'Merge', namespace: 'layers'}
|
*/
|
export function multiply(args) {
|
return new Multiply(args);
|
}
|
/**
|
* Layer that computes a dot product between samples in two tensors.
|
*
|
* E.g., if applied to a list of two tensors `a` and `b` both of shape
|
* `[batchSize, n]`, the output will be a tensor of shape `[batchSize, 1]`,
|
* where each entry at index `[i, 0]` will be the dot product between
|
* `a[i, :]` and `b[i, :]`.
|
*
|
* Example:
|
*
|
* ```js
|
* const dotLayer = tf.layers.dot({axes: -1});
|
* const x1 = tf.tensor2d([[10, 20], [30, 40]]);
|
* const x2 = tf.tensor2d([[-1, -2], [-3, -4]]);
|
*
|
* // Invoke the layer's apply() method in eager (imperative) mode.
|
* const y = dotLayer.apply([x1, x2]);
|
* y.print();
|
* ```
|
*
|
* @doc {heading: 'Layers', subheading: 'Merge', namespace: 'layers'}
|
*/
|
export function dot(args) {
|
return new Dot(args);
|
}
|
// Normalization Layers.
|
/**
|
* Batch normalization layer (Ioffe and Szegedy, 2014).
|
*
|
* Normalize the activations of the previous layer at each batch,
|
* i.e. applies a transformation that maintains the mean activation
|
* close to 0 and the activation standard deviation close to 1.
|
*
|
* Input shape:
|
* Arbitrary. Use the keyword argument `inputShape` (Array of integers, does
|
* not include the sample axis) when calling the constructor of this class,
|
* if this layer is used as a first layer in a model.
|
*
|
* Output shape:
|
* Same shape as input.
|
*
|
* References:
|
* - [Batch Normalization: Accelerating Deep Network Training by Reducing
|
* Internal Covariate Shift](https://arxiv.org/abs/1502.03167)
|
*
|
* @doc {heading: 'Layers', subheading: 'Normalization', namespace: 'layers'}
|
*/
|
export function batchNormalization(args) {
|
return new BatchNormalization(args);
|
}
|
/**
|
* Layer-normalization layer (Ba et al., 2016).
|
*
|
* Normalizes the activations of the previous layer for each given example in a
|
* batch independently, instead of across a batch like in `batchNormalization`.
|
* In other words, this layer applies a transformation that maintains the mean
|
* activation within each example close to 0 and activation variance close to 1.
|
*
|
* Input shape:
|
* Arbitrary. Use the argument `inputShape` when using this layer as the first
|
* layer in a model.
|
*
|
* Output shape:
|
* Same as input.
|
*
|
* References:
|
* - [Layer Normalization](https://arxiv.org/abs/1607.06450)
|
*
|
* @doc {heading: 'Layers', subheading: 'Normalization', namespace: 'layers'}
|
*/
|
export function layerNormalization(args) {
|
return new LayerNormalization(args);
|
}
|
// Padding Layers.
|
/**
|
* Zero-padding layer for 2D input (e.g., image).
|
*
|
* This layer can add rows and columns of zeros
|
* at the top, bottom, left and right side of an image tensor.
|
*
|
* Input shape:
|
* 4D tensor with shape:
|
* - If `dataFormat` is `"channelsLast"`:
|
* `[batch, rows, cols, channels]`
|
* - If `data_format` is `"channels_first"`:
|
* `[batch, channels, rows, cols]`.
|
*
|
* Output shape:
|
* 4D with shape:
|
* - If `dataFormat` is `"channelsLast"`:
|
* `[batch, paddedRows, paddedCols, channels]`
|
* - If `dataFormat` is `"channelsFirst"`:
|
* `[batch, channels, paddedRows, paddedCols]`.
|
*
|
* @doc {heading: 'Layers', subheading: 'Padding', namespace: 'layers'}
|
*/
|
export function zeroPadding2d(args) {
|
return new ZeroPadding2D(args);
|
}
|
// Pooling Layers.
|
/**
|
* Average pooling operation for spatial data.
|
*
|
* Input shape: `[batchSize, inLength, channels]`
|
*
|
* Output shape: `[batchSize, pooledLength, channels]`
|
*
|
* `tf.avgPool1d` is an alias.
|
*
|
* @doc {heading: 'Layers', subheading: 'Pooling', namespace: 'layers'}
|
*/
|
export function averagePooling1d(args) {
|
return new AveragePooling1D(args);
|
}
|
export function avgPool1d(args) {
|
return averagePooling1d(args);
|
}
|
// For backwards compatibility.
|
// See https://github.com/tensorflow/tfjs/issues/152
|
export function avgPooling1d(args) {
|
return averagePooling1d(args);
|
}
|
/**
|
* Average pooling operation for spatial data.
|
*
|
* Input shape:
|
* - If `dataFormat === CHANNEL_LAST`:
|
* 4D tensor with shape:
|
* `[batchSize, rows, cols, channels]`
|
* - If `dataFormat === CHANNEL_FIRST`:
|
* 4D tensor with shape:
|
* `[batchSize, channels, rows, cols]`
|
*
|
* Output shape
|
* - If `dataFormat === CHANNEL_LAST`:
|
* 4D tensor with shape:
|
* `[batchSize, pooledRows, pooledCols, channels]`
|
* - If `dataFormat === CHANNEL_FIRST`:
|
* 4D tensor with shape:
|
* `[batchSize, channels, pooledRows, pooledCols]`
|
*
|
* `tf.avgPool2d` is an alias.
|
*
|
* @doc {heading: 'Layers', subheading: 'Pooling', namespace: 'layers'}
|
*/
|
export function averagePooling2d(args) {
|
return new AveragePooling2D(args);
|
}
|
export function avgPool2d(args) {
|
return averagePooling2d(args);
|
}
|
// For backwards compatibility.
|
// See https://github.com/tensorflow/tfjs/issues/152
|
export function avgPooling2d(args) {
|
return averagePooling2d(args);
|
}
|
/**
|
* Average pooling operation for 3D data.
|
*
|
* Input shape
|
* - If `dataFormat === channelsLast`:
|
* 5D tensor with shape:
|
* `[batchSize, depths, rows, cols, channels]`
|
* - If `dataFormat === channelsFirst`:
|
* 4D tensor with shape:
|
* `[batchSize, channels, depths, rows, cols]`
|
*
|
* Output shape
|
* - If `dataFormat=channelsLast`:
|
* 5D tensor with shape:
|
* `[batchSize, pooledDepths, pooledRows, pooledCols, channels]`
|
* - If `dataFormat=channelsFirst`:
|
* 5D tensor with shape:
|
* `[batchSize, channels, pooledDepths, pooledRows, pooledCols]`
|
*
|
* @doc {heading: 'Layers', subheading: 'Pooling', namespace: 'layers'}
|
*/
|
export function averagePooling3d(args) {
|
return new AveragePooling3D(args);
|
}
|
export function avgPool3d(args) {
|
return averagePooling3d(args);
|
}
|
// For backwards compatibility.
|
// See https://github.com/tensorflow/tfjs/issues/152
|
export function avgPooling3d(args) {
|
return averagePooling3d(args);
|
}
|
/**
|
* Global average pooling operation for temporal data.
|
*
|
* Input Shape: 3D tensor with shape: `[batchSize, steps, features]`.
|
*
|
* Output Shape: 2D tensor with shape: `[batchSize, features]`.
|
*
|
* @doc {heading: 'Layers', subheading: 'Pooling', namespace: 'layers'}
|
*/
|
export function globalAveragePooling1d(args) {
|
return new GlobalAveragePooling1D(args);
|
}
|
/**
|
* Global average pooling operation for spatial data.
|
*
|
* Input shape:
|
* - If `dataFormat` is `CHANNEL_LAST`:
|
* 4D tensor with shape: `[batchSize, rows, cols, channels]`.
|
* - If `dataFormat` is `CHANNEL_FIRST`:
|
* 4D tensor with shape: `[batchSize, channels, rows, cols]`.
|
*
|
* Output shape:
|
* 2D tensor with shape: `[batchSize, channels]`.
|
*
|
* @doc {heading: 'Layers', subheading: 'Pooling', namespace: 'layers'}
|
*/
|
export function globalAveragePooling2d(args) {
|
return new GlobalAveragePooling2D(args);
|
}
|
/**
|
* Global max pooling operation for temporal data.
|
*
|
* Input Shape: 3D tensor with shape: `[batchSize, steps, features]`.
|
*
|
* Output Shape: 2D tensor with shape: `[batchSize, features]`.
|
*
|
* @doc {heading: 'Layers', subheading: 'Pooling', namespace: 'layers'}
|
*/
|
export function globalMaxPooling1d(args) {
|
return new GlobalMaxPooling1D(args);
|
}
|
/**
|
* Global max pooling operation for spatial data.
|
*
|
* Input shape:
|
* - If `dataFormat` is `CHANNEL_LAST`:
|
* 4D tensor with shape: `[batchSize, rows, cols, channels]`.
|
* - If `dataFormat` is `CHANNEL_FIRST`:
|
* 4D tensor with shape: `[batchSize, channels, rows, cols]`.
|
*
|
* Output shape:
|
* 2D tensor with shape: `[batchSize, channels]`.
|
*
|
* @doc {heading: 'Layers', subheading: 'Pooling', namespace: 'layers'}
|
*/
|
export function globalMaxPooling2d(args) {
|
return new GlobalMaxPooling2D(args);
|
}
|
/**
|
* Max pooling operation for temporal data.
|
*
|
* Input shape: `[batchSize, inLength, channels]`
|
*
|
* Output shape: `[batchSize, pooledLength, channels]`
|
*
|
* @doc {heading: 'Layers', subheading: 'Pooling', namespace: 'layers'}
|
*/
|
export function maxPooling1d(args) {
|
return new MaxPooling1D(args);
|
}
|
/**
|
* Max pooling operation for spatial data.
|
*
|
* Input shape
|
* - If `dataFormat === CHANNEL_LAST`:
|
* 4D tensor with shape:
|
* `[batchSize, rows, cols, channels]`
|
* - If `dataFormat === CHANNEL_FIRST`:
|
* 4D tensor with shape:
|
* `[batchSize, channels, rows, cols]`
|
*
|
* Output shape
|
* - If `dataFormat=CHANNEL_LAST`:
|
* 4D tensor with shape:
|
* `[batchSize, pooledRows, pooledCols, channels]`
|
* - If `dataFormat=CHANNEL_FIRST`:
|
* 4D tensor with shape:
|
* `[batchSize, channels, pooledRows, pooledCols]`
|
*
|
* @doc {heading: 'Layers', subheading: 'Pooling', namespace: 'layers'}
|
*/
|
export function maxPooling2d(args) {
|
return new MaxPooling2D(args);
|
}
|
/**
|
* Max pooling operation for 3D data.
|
*
|
* Input shape
|
* - If `dataFormat === channelsLast`:
|
* 5D tensor with shape:
|
* `[batchSize, depths, rows, cols, channels]`
|
* - If `dataFormat === channelsFirst`:
|
* 5D tensor with shape:
|
* `[batchSize, channels, depths, rows, cols]`
|
*
|
* Output shape
|
* - If `dataFormat=channelsLast`:
|
* 5D tensor with shape:
|
* `[batchSize, pooledDepths, pooledRows, pooledCols, channels]`
|
* - If `dataFormat=channelsFirst`:
|
* 5D tensor with shape:
|
* `[batchSize, channels, pooledDepths, pooledRows, pooledCols]`
|
*
|
* @doc {heading: 'Layers', subheading: 'Pooling', namespace: 'layers'}
|
*/
|
export function maxPooling3d(args) {
|
return new MaxPooling3D(args);
|
}
|
// Recurrent Layers.
|
/**
|
* Gated Recurrent Unit - Cho et al. 2014.
|
*
|
* This is an `RNN` layer consisting of one `GRUCell`. However, unlike
|
* the underlying `GRUCell`, the `apply` method of `SimpleRNN` operates
|
* on a sequence of inputs. The shape of the input (not including the first,
|
* batch dimension) needs to be at least 2-D, with the first dimension being
|
* time steps. For example:
|
*
|
* ```js
|
* const rnn = tf.layers.gru({units: 8, returnSequences: true});
|
*
|
* // Create an input with 10 time steps.
|
* const input = tf.input({shape: [10, 20]});
|
* const output = rnn.apply(input);
|
*
|
* console.log(JSON.stringify(output.shape));
|
* // [null, 10, 8]: 1st dimension is unknown batch size; 2nd dimension is the
|
* // same as the sequence length of `input`, due to `returnSequences`: `true`;
|
* // 3rd dimension is the `GRUCell`'s number of units.
|
*
|
* @doc {heading: 'Layers', subheading: 'Recurrent', namespace: 'layers'}
|
*/
|
export function gru(args) {
|
return new GRU(args);
|
}
|
/**
|
* Cell class for `GRU`.
|
*
|
* `GRUCell` is distinct from the `RNN` subclass `GRU` in that its
|
* `apply` method takes the input data of only a single time step and returns
|
* the cell's output at the time step, while `GRU` takes the input data
|
* over a number of time steps. For example:
|
*
|
* ```js
|
* const cell = tf.layers.gruCell({units: 2});
|
* const input = tf.input({shape: [10]});
|
* const output = cell.apply(input);
|
*
|
* console.log(JSON.stringify(output.shape));
|
* // [null, 10]: This is the cell's output at a single time step. The 1st
|
* // dimension is the unknown batch size.
|
* ```
|
*
|
* Instance(s) of `GRUCell` can be used to construct `RNN` layers. The
|
* most typical use of this workflow is to combine a number of cells into a
|
* stacked RNN cell (i.e., `StackedRNNCell` internally) and use it to create an
|
* RNN. For example:
|
*
|
* ```js
|
* const cells = [
|
* tf.layers.gruCell({units: 4}),
|
* tf.layers.gruCell({units: 8}),
|
* ];
|
* const rnn = tf.layers.rnn({cell: cells, returnSequences: true});
|
*
|
* // Create an input with 10 time steps and a length-20 vector at each step.
|
* const input = tf.input({shape: [10, 20]});
|
* const output = rnn.apply(input);
|
*
|
* console.log(JSON.stringify(output.shape));
|
* // [null, 10, 8]: 1st dimension is unknown batch size; 2nd dimension is the
|
* // same as the sequence length of `input`, due to `returnSequences`: `true`;
|
* // 3rd dimension is the last `gruCell`'s number of units.
|
* ```
|
*
|
* To create an `RNN` consisting of only *one* `GRUCell`, use the
|
* `tf.layers.gru`.
|
*
|
* @doc {heading: 'Layers', subheading: 'Recurrent', namespace: 'layers'}
|
*/
|
export function gruCell(args) {
|
return new GRUCell(args);
|
}
|
/**
|
* Long-Short Term Memory layer - Hochreiter 1997.
|
*
|
* This is an `RNN` layer consisting of one `LSTMCell`. However, unlike
|
* the underlying `LSTMCell`, the `apply` method of `LSTM` operates
|
* on a sequence of inputs. The shape of the input (not including the first,
|
* batch dimension) needs to be at least 2-D, with the first dimension being
|
* time steps. For example:
|
*
|
* ```js
|
* const lstm = tf.layers.lstm({units: 8, returnSequences: true});
|
*
|
* // Create an input with 10 time steps.
|
* const input = tf.input({shape: [10, 20]});
|
* const output = lstm.apply(input);
|
*
|
* console.log(JSON.stringify(output.shape));
|
* // [null, 10, 8]: 1st dimension is unknown batch size; 2nd dimension is the
|
* // same as the sequence length of `input`, due to `returnSequences`: `true`;
|
* // 3rd dimension is the `LSTMCell`'s number of units.
|
*
|
* @doc {heading: 'Layers', subheading: 'Recurrent', namespace: 'layers'}
|
*/
|
export function lstm(args) {
|
return new LSTM(args);
|
}
|
/**
|
* Cell class for `LSTM`.
|
*
|
* `LSTMCell` is distinct from the `RNN` subclass `LSTM` in that its
|
* `apply` method takes the input data of only a single time step and returns
|
* the cell's output at the time step, while `LSTM` takes the input data
|
* over a number of time steps. For example:
|
*
|
* ```js
|
* const cell = tf.layers.lstmCell({units: 2});
|
* const input = tf.input({shape: [10]});
|
* const output = cell.apply(input);
|
*
|
* console.log(JSON.stringify(output.shape));
|
* // [null, 10]: This is the cell's output at a single time step. The 1st
|
* // dimension is the unknown batch size.
|
* ```
|
*
|
* Instance(s) of `LSTMCell` can be used to construct `RNN` layers. The
|
* most typical use of this workflow is to combine a number of cells into a
|
* stacked RNN cell (i.e., `StackedRNNCell` internally) and use it to create an
|
* RNN. For example:
|
*
|
* ```js
|
* const cells = [
|
* tf.layers.lstmCell({units: 4}),
|
* tf.layers.lstmCell({units: 8}),
|
* ];
|
* const rnn = tf.layers.rnn({cell: cells, returnSequences: true});
|
*
|
* // Create an input with 10 time steps and a length-20 vector at each step.
|
* const input = tf.input({shape: [10, 20]});
|
* const output = rnn.apply(input);
|
*
|
* console.log(JSON.stringify(output.shape));
|
* // [null, 10, 8]: 1st dimension is unknown batch size; 2nd dimension is the
|
* // same as the sequence length of `input`, due to `returnSequences`: `true`;
|
* // 3rd dimension is the last `lstmCell`'s number of units.
|
* ```
|
*
|
* To create an `RNN` consisting of only *one* `LSTMCell`, use the
|
* `tf.layers.lstm`.
|
*
|
* @doc {heading: 'Layers', subheading: 'Recurrent', namespace: 'layers'}
|
*/
|
export function lstmCell(args) {
|
return new LSTMCell(args);
|
}
|
/**
|
* Fully-connected RNN where the output is to be fed back to input.
|
*
|
* This is an `RNN` layer consisting of one `SimpleRNNCell`. However, unlike
|
* the underlying `SimpleRNNCell`, the `apply` method of `SimpleRNN` operates
|
* on a sequence of inputs. The shape of the input (not including the first,
|
* batch dimension) needs to be at least 2-D, with the first dimension being
|
* time steps. For example:
|
*
|
* ```js
|
* const rnn = tf.layers.simpleRNN({units: 8, returnSequences: true});
|
*
|
* // Create an input with 10 time steps.
|
* const input = tf.input({shape: [10, 20]});
|
* const output = rnn.apply(input);
|
*
|
* console.log(JSON.stringify(output.shape));
|
* // [null, 10, 8]: 1st dimension is unknown batch size; 2nd dimension is the
|
* // same as the sequence length of `input`, due to `returnSequences`: `true`;
|
* // 3rd dimension is the `SimpleRNNCell`'s number of units.
|
* ```
|
*
|
* @doc {heading: 'Layers', subheading: 'Recurrent', namespace: 'layers'}
|
*/
|
export function simpleRNN(args) {
|
return new SimpleRNN(args);
|
}
|
/**
|
* Cell class for `SimpleRNN`.
|
*
|
* `SimpleRNNCell` is distinct from the `RNN` subclass `SimpleRNN` in that its
|
* `apply` method takes the input data of only a single time step and returns
|
* the cell's output at the time step, while `SimpleRNN` takes the input data
|
* over a number of time steps. For example:
|
*
|
* ```js
|
* const cell = tf.layers.simpleRNNCell({units: 2});
|
* const input = tf.input({shape: [10]});
|
* const output = cell.apply(input);
|
*
|
* console.log(JSON.stringify(output.shape));
|
* // [null, 10]: This is the cell's output at a single time step. The 1st
|
* // dimension is the unknown batch size.
|
* ```
|
*
|
* Instance(s) of `SimpleRNNCell` can be used to construct `RNN` layers. The
|
* most typical use of this workflow is to combine a number of cells into a
|
* stacked RNN cell (i.e., `StackedRNNCell` internally) and use it to create an
|
* RNN. For example:
|
*
|
* ```js
|
* const cells = [
|
* tf.layers.simpleRNNCell({units: 4}),
|
* tf.layers.simpleRNNCell({units: 8}),
|
* ];
|
* const rnn = tf.layers.rnn({cell: cells, returnSequences: true});
|
*
|
* // Create an input with 10 time steps and a length-20 vector at each step.
|
* const input = tf.input({shape: [10, 20]});
|
* const output = rnn.apply(input);
|
*
|
* console.log(JSON.stringify(output.shape));
|
* // [null, 10, 8]: 1st dimension is unknown batch size; 2nd dimension is the
|
* // same as the sequence length of `input`, due to `returnSequences`: `true`;
|
* // 3rd dimension is the last `SimpleRNNCell`'s number of units.
|
* ```
|
*
|
* To create an `RNN` consisting of only *one* `SimpleRNNCell`, use the
|
* `tf.layers.simpleRNN`.
|
*
|
* @doc {heading: 'Layers', subheading: 'Recurrent', namespace: 'layers'}
|
*/
|
export function simpleRNNCell(args) {
|
return new SimpleRNNCell(args);
|
}
|
/**
|
* Convolutional LSTM layer - Xingjian Shi 2015.
|
*
|
* This is a `ConvRNN2D` layer consisting of one `ConvLSTM2DCell`. However,
|
* unlike the underlying `ConvLSTM2DCell`, the `apply` method of `ConvLSTM2D`
|
* operates on a sequence of inputs. The shape of the input (not including the
|
* first, batch dimension) needs to be 4-D, with the first dimension being time
|
* steps. For example:
|
*
|
* ```js
|
* const filters = 3;
|
* const kernelSize = 3;
|
*
|
* const batchSize = 4;
|
* const sequenceLength = 2;
|
* const size = 5;
|
* const channels = 3;
|
*
|
* const inputShape = [batchSize, sequenceLength, size, size, channels];
|
* const input = tf.ones(inputShape);
|
*
|
* const layer = tf.layers.convLstm2d({filters, kernelSize});
|
*
|
* const output = layer.apply(input);
|
* ```
|
*/
|
/** @doc {heading: 'Layers', subheading: 'Recurrent', namespace: 'layers'} */
|
export function convLstm2d(args) {
|
return new ConvLSTM2D(args);
|
}
|
/**
|
* Cell class for `ConvLSTM2D`.
|
*
|
* `ConvLSTM2DCell` is distinct from the `ConvRNN2D` subclass `ConvLSTM2D` in
|
* that its `call` method takes the input data of only a single time step and
|
* returns the cell's output at the time step, while `ConvLSTM2D` takes the
|
* input data over a number of time steps. For example:
|
*
|
* ```js
|
* const filters = 3;
|
* const kernelSize = 3;
|
*
|
* const sequenceLength = 1;
|
* const size = 5;
|
* const channels = 3;
|
*
|
* const inputShape = [sequenceLength, size, size, channels];
|
* const input = tf.ones(inputShape);
|
*
|
* const cell = tf.layers.convLstm2dCell({filters, kernelSize});
|
*
|
* cell.build(input.shape);
|
*
|
* const outputSize = size - kernelSize + 1;
|
* const outShape = [sequenceLength, outputSize, outputSize, filters];
|
*
|
* const initialH = tf.zeros(outShape);
|
* const initialC = tf.zeros(outShape);
|
*
|
* const [o, h, c] = cell.call([input, initialH, initialC], {});
|
* ```
|
*/
|
/** @doc {heading: 'Layers', subheading: 'Recurrent', namespace: 'layers'} */
|
export function convLstm2dCell(args) {
|
return new ConvLSTM2DCell(args);
|
}
|
/**
|
* Base class for recurrent layers.
|
*
|
* Input shape:
|
* 3D tensor with shape `[batchSize, timeSteps, inputDim]`.
|
*
|
* Output shape:
|
* - if `returnState`, an Array of tensors (i.e., `tf.Tensor`s). The first
|
* tensor is the output. The remaining tensors are the states at the
|
* last time step, each with shape `[batchSize, units]`.
|
* - if `returnSequences`, the output will have shape
|
* `[batchSize, timeSteps, units]`.
|
* - else, the output will have shape `[batchSize, units]`.
|
*
|
* Masking:
|
* This layer supports masking for input data with a variable number
|
* of timesteps. To introduce masks to your data,
|
* use an embedding layer with the `mask_zero` parameter
|
* set to `True`.
|
*
|
* Notes on using statefulness in RNNs:
|
* You can set RNN layers to be 'stateful', which means that the states
|
* computed for the samples in one batch will be reused as initial states
|
* for the samples in the next batch. This assumes a one-to-one mapping
|
* between samples in different successive batches.
|
*
|
* To enable statefulness:
|
* - specify `stateful: true` in the layer constructor.
|
* - specify a fixed batch size for your model, by passing
|
* if sequential model:
|
* `batchInputShape=[...]` to the first layer in your model.
|
* else for functional model with 1 or more Input layers:
|
* `batchShape=[...]` to all the first layers in your model.
|
* This is the expected shape of your inputs *including the batch size*.
|
* It should be a tuple of integers, e.g. `(32, 10, 100)`.
|
* - specify `shuffle=False` when calling fit().
|
*
|
* To reset the states of your model, call `.resetStates()` on either
|
* a specific layer, or on your entire model.
|
*
|
* Note on specifying the initial state of RNNs
|
* You can specify the initial state of RNN layers symbolically by
|
* calling them with the option `initialState`. The value of
|
* `initialState` should be a tensor or list of tensors representing
|
* the initial state of the RNN layer.
|
*
|
* You can specify the initial state of RNN layers numerically by
|
* calling `resetStates` with the keyword argument `states`. The value of
|
* `states` should be a numpy array or list of numpy arrays representing
|
* the initial state of the RNN layer.
|
*
|
* Note on passing external constants to RNNs
|
* You can pass "external" constants to the cell using the `constants`
|
* keyword argument of `RNN.call` method. This requires that the `cell.call`
|
* method accepts the same keyword argument `constants`. Such constants
|
* can be used to condition the cell transformation on additional static
|
* inputs (not changing over time), a.k.a. an attention mechanism.
|
*
|
* @doc {heading: 'Layers', subheading: 'Recurrent', namespace: 'layers'}
|
*/
|
export function rnn(args) {
|
return new RNN(args);
|
}
|
/**
|
* Wrapper allowing a stack of RNN cells to behave as a single cell.
|
*
|
* Used to implement efficient stacked RNNs.
|
*
|
* @doc {heading: 'Layers', subheading: 'Recurrent', namespace: 'layers'}
|
*/
|
export function stackedRNNCells(args) {
|
return new StackedRNNCells(args);
|
}
|
// Wrapper Layers.
|
/** @doc {heading: 'Layers', subheading: 'Wrapper', namespace: 'layers'} */
|
export function bidirectional(args) {
|
return new Bidirectional(args);
|
}
|
/**
|
* This wrapper applies a layer to every temporal slice of an input.
|
*
|
* The input should be at least 3D, and the dimension of the index `1` will be
|
* considered to be the temporal dimension.
|
*
|
* Consider a batch of 32 samples, where each sample is a sequence of 10 vectors
|
* of 16 dimensions. The batch input shape of the layer is then `[32, 10,
|
* 16]`, and the `inputShape`, not including the sample dimension, is
|
* `[10, 16]`.
|
*
|
* You can then use `TimeDistributed` to apply a `Dense` layer to each of the 10
|
* timesteps, independently:
|
*
|
* ```js
|
* const model = tf.sequential();
|
* model.add(tf.layers.timeDistributed({
|
* layer: tf.layers.dense({units: 8}),
|
* inputShape: [10, 16],
|
* }));
|
*
|
* // Now model.outputShape = [null, 10, 8].
|
* // The output will then have shape `[32, 10, 8]`.
|
*
|
* // In subsequent layers, there is no need for `inputShape`:
|
* model.add(tf.layers.timeDistributed({layer: tf.layers.dense({units: 32})}));
|
* console.log(JSON.stringify(model.outputs[0].shape));
|
* // Now model.outputShape = [null, 10, 32].
|
* ```
|
*
|
* The output will then have shape `[32, 10, 32]`.
|
*
|
* `TimeDistributed` can be used with arbitrary layers, not just `Dense`, for
|
* instance a `Conv2D` layer.
|
*
|
* ```js
|
* const model = tf.sequential();
|
* model.add(tf.layers.timeDistributed({
|
* layer: tf.layers.conv2d({filters: 64, kernelSize: [3, 3]}),
|
* inputShape: [10, 299, 299, 3],
|
* }));
|
* console.log(JSON.stringify(model.outputs[0].shape));
|
* ```
|
*
|
* @doc {heading: 'Layers', subheading: 'Wrapper', namespace: 'layers'}
|
*/
|
export function timeDistributed(args) {
|
return new TimeDistributed(args);
|
}
|
// Aliases for pooling.
|
export const globalMaxPool1d = globalMaxPooling1d;
|
export const globalMaxPool2d = globalMaxPooling2d;
|
export const maxPool1d = maxPooling1d;
|
export const maxPool2d = maxPooling2d;
|
export { Layer, RNN, RNNCell, input /* alias for tf.input */ };
|
/**
|
* Apply additive zero-centered Gaussian noise.
|
*
|
* As it is a regularization layer, it is only active at training time.
|
*
|
* This is useful to mitigate overfitting
|
* (you could see it as a form of random data augmentation).
|
* Gaussian Noise (GS) is a natural choice as corruption process
|
* for real valued inputs.
|
*
|
* # Arguments
|
* stddev: float, standard deviation of the noise distribution.
|
*
|
* # Input shape
|
* Arbitrary. Use the keyword argument `input_shape`
|
* (tuple of integers, does not include the samples axis)
|
* when using this layer as the first layer in a model.
|
*
|
* # Output shape
|
* Same shape as input.
|
*
|
* @doc {heading: 'Layers', subheading: 'Noise', namespace: 'layers'}
|
*/
|
export function gaussianNoise(args) {
|
return new GaussianNoise(args);
|
}
|
/**
|
* Apply multiplicative 1-centered Gaussian noise.
|
*
|
* As it is a regularization layer, it is only active at training time.
|
*
|
* Arguments:
|
* - `rate`: float, drop probability (as with `Dropout`).
|
* The multiplicative noise will have
|
* standard deviation `sqrt(rate / (1 - rate))`.
|
*
|
* Input shape:
|
* Arbitrary. Use the keyword argument `inputShape`
|
* (tuple of integers, does not include the samples axis)
|
* when using this layer as the first layer in a model.
|
*
|
* Output shape:
|
* Same shape as input.
|
*
|
* References:
|
* - [Dropout: A Simple Way to Prevent Neural Networks from Overfitting](
|
* http://www.cs.toronto.edu/~rsalakhu/papers/srivastava14a.pdf)
|
*
|
* @doc {heading: 'Layers', subheading: 'Noise', namespace: 'layers'}
|
*/
|
export function gaussianDropout(args) {
|
return new GaussianDropout(args);
|
}
|
/**
|
* Applies Alpha Dropout to the input.
|
*
|
* As it is a regularization layer, it is only active at training time.
|
*
|
* Alpha Dropout is a `Dropout` that keeps mean and variance of inputs
|
* to their original values, in order to ensure the self-normalizing property
|
* even after this dropout.
|
* Alpha Dropout fits well to Scaled Exponential Linear Units
|
* by randomly setting activations to the negative saturation value.
|
*
|
* Arguments:
|
* - `rate`: float, drop probability (as with `Dropout`).
|
* The multiplicative noise will have
|
* standard deviation `sqrt(rate / (1 - rate))`.
|
* - `noise_shape`: A 1-D `Tensor` of type `int32`, representing the
|
* shape for randomly generated keep/drop flags.
|
*
|
* Input shape:
|
* Arbitrary. Use the keyword argument `inputShape`
|
* (tuple of integers, does not include the samples axis)
|
* when using this layer as the first layer in a model.
|
*
|
* Output shape:
|
* Same shape as input.
|
*
|
* References:
|
* - [Self-Normalizing Neural Networks](https://arxiv.org/abs/1706.02515)
|
*
|
* @doc {heading: 'Layers', subheading: 'Noise', namespace: 'layers'}
|
*/
|
export function alphaDropout(args) {
|
return new AlphaDropout(args);
|
}
|
/**
|
* Masks a sequence by using a mask value to skip timesteps.
|
*
|
* If all features for a given sample timestep are equal to `mask_value`,
|
* then the sample timestep will be masked (skipped) in all downstream layers
|
* (as long as they support masking).
|
*
|
* If any downstream layer does not support masking yet receives such
|
* an input mask, an exception will be raised.
|
*
|
* Arguments:
|
* - `maskValue`: Either None or mask value to skip.
|
*
|
* Input shape:
|
* Arbitrary. Use the keyword argument `inputShape`
|
* (tuple of integers, does not include the samples axis)
|
* when using this layer as the first layer in a model.
|
*
|
* Output shape:
|
* Same shape as input.
|
*
|
* @doc {heading: 'Layers', subheading: 'Mask', namespace: 'layers'}
|
*/
|
export function masking(args) {
|
return new Masking(args);
|
}
|
/**
|
* A preprocessing layer which rescales input values to a new range.
|
*
|
* This layer rescales every value of an input (often an image) by multiplying
|
* by `scale` and adding `offset`.
|
*
|
* For instance:
|
* 1. To rescale an input in the ``[0, 255]`` range
|
* to be in the `[0, 1]` range, you would pass `scale=1/255`.
|
* 2. To rescale an input in the ``[0, 255]`` range to be in the `[-1, 1]`
|
* range, you would pass `scale=1./127.5, offset=-1`.
|
* The rescaling is applied both during training and inference. Inputs can be
|
* of integer or floating point dtype, and by default the layer will output
|
* floats.
|
*
|
* Arguments:
|
* - `scale`: Float, the scale to apply to the inputs.
|
* - `offset`: Float, the offset to apply to the inputs.
|
*
|
* Input shape:
|
* Arbitrary.
|
*
|
* Output shape:
|
* Same as input.
|
*
|
* @doc {heading: 'Layers', subheading: 'Rescaling', namespace: 'layers'}
|
*/
|
export function rescaling(args) {
|
return new Rescaling(args);
|
}
|
/**
|
* A preprocessing layer which center crops images.
|
*
|
* This layers crops the central portion of the images to a target size. If an
|
* image is smaller than the target size, it will be resized and cropped so as
|
* to return the largest possible window in the image that matches the target
|
* aspect ratio.
|
*
|
* Input pixel values can be of any range (e.g. `[0., 1.)` or `[0, 255]`) and
|
* of integer or floating point dtype.
|
*
|
* If the input height/width is even and the target height/width is odd (or
|
* inversely), the input image is left-padded by 1 pixel.
|
*
|
* Arguments:
|
* `height`: Integer, the height of the output shape.
|
* `width`: Integer, the width of the output shape.
|
*
|
* Input shape:
|
* 3D (unbatched) or 4D (batched) tensor with shape:
|
* `(..., height, width, channels)`, in `channelsLast` format.
|
*
|
* Output shape:
|
* 3D (unbatched) or 4D (batched) tensor with shape:
|
* `(..., targetHeight, targetWidth, channels)`.
|
*
|
*
|
* @doc {heading: 'Layers', subheading: 'CenterCrop', namespace: 'layers'}
|
*/
|
export function centerCrop(args) {
|
return new CenterCrop(args);
|
}
|
/**
|
* A preprocessing layer which resizes images.
|
* This layer resizes an image input to a target height and width. The input
|
* should be a 4D (batched) or 3D (unbatched) tensor in `"channels_last"`
|
* format. Input pixel values can be of any range (e.g. `[0., 1.)` or `[0,
|
* 255]`) and of interger or floating point dtype. By default, the layer will
|
* output floats.
|
*
|
* Arguments:
|
* - `height`: number, the height for the output tensor.
|
* - `width`: number, the width for the output tensor.
|
* - `interpolation`: string, the method for image resizing interpolation.
|
* - `cropToAspectRatio`: boolean, whether to keep image aspect ratio.
|
*
|
* Input shape:
|
* Arbitrary.
|
*
|
* Output shape:
|
* height, width, num channels.
|
*
|
* @doc {heading: 'Layers', subheading: 'Resizing', namespace: 'layers'}
|
*/
|
export function resizing(args) {
|
return new Resizing(args);
|
}
|
/**
|
* A preprocessing layer which encodes integer features.
|
*
|
* This layer provides options for condensing data into a categorical encoding
|
* when the total number of tokens are known in advance. It accepts integer
|
* values as inputs, and it outputs a dense representation of those
|
* inputs.
|
*
|
* Arguments:
|
*
|
* numTokens: The total number of tokens the layer should support. All
|
* inputs to the layer must integers in the range `0 <= value <
|
* numTokens`, or an error will be thrown.
|
*
|
* outputMode: Specification for the output of the layer.
|
* Defaults to `multiHot`. Values can be `oneHot`, `multiHot` or
|
* `count`, configuring the layer as follows:
|
*
|
* oneHot: Encodes each individual element in the input into an
|
* array of `numTokens` size, containing a 1 at the element index. If
|
* the last dimension is size 1, will encode on that dimension. If the
|
* last dimension is not size 1, will append a new dimension for the
|
* encoded output.
|
*
|
* multiHot: Encodes each sample in the input into a single array
|
* of `numTokens` size, containing a 1 for each vocabulary term
|
* present in the sample. Treats the last dimension as the sample
|
* dimension, if input shape is `(..., sampleLength)`, output shape
|
* will be `(..., numTokens)`.
|
*
|
* count: Like `multiHot`, but the int array contains a count of
|
* the number of times the token at that index appeared in the sample.
|
*
|
* For all output modes, currently only output up to rank 2 is supported.
|
* Call arguments:
|
* inputs: A 1D or 2D tensor of integer inputs.
|
* countWeights: A tensor in the same shape as `inputs` indicating the
|
* weight for each sample value when summing up in `count` mode. Not used
|
* in `multiHot` or `oneHot` modes.
|
*
|
*
|
* @doc {heading: 'Layers', subheading: 'CategoryEncoding', namespace: 'layers'}
|
*/
|
export function categoryEncoding(args) {
|
return new CategoryEncoding(args);
|
}
|
/**
|
* A preprocessing layer which randomly varies image width during training.
|
*
|
* This layer will randomly adjusts the width of a batch of images of a batch
|
* of images by a random factor.
|
*
|
* The input should be a 3D (unbatched) or 4D (batched) tensor in
|
* the `"channels_last"` image data format. Input pixel values can be of any
|
* range (e.g. `[0., 1.)` or `[0, 255]`) and of integer or floating point
|
* dtype. By default, the layer will output floats. By default, this layer is
|
* inactive during inference. For an overview and full list of preprocessing
|
* layers, see the preprocessing [guide]
|
* (https://www.tensorflow.org/guide/keras/preprocessing_layers).
|
*
|
* Arguments:
|
*
|
* factor:
|
* A positive float (fraction of original width), or a tuple of size 2
|
* representing lower and upper bound for resizing vertically.
|
* When represented as a single float, this value is used for both the upper
|
* and lower bound. For instance, `factor=(0.2, 0.3)` results in an output
|
* with width changed by a random amount in the range `[20%, 30%]`.
|
* `factor=(-0.2, 0.3)` results in an output with width changed by a random
|
* amount in the range `[-20%, +30%]`. `factor=0.2` results in an output
|
* with width changed by a random amount in the range `[-20%, +20%]`.
|
* interpolation:
|
* String, the interpolation method.
|
* Defaults to `bilinear`.
|
* Supports `"bilinear"`, `"nearest"`.
|
* The tf methods `"bicubic"`, `"area"`, `"lanczos3"`, `"lanczos5"`,
|
* `"gaussian"`, `"mitchellcubic"` are unimplemented in tfjs.
|
* seed:
|
* Integer. Used to create a random seed.
|
*
|
* Input shape:
|
* 3D (unbatched) or 4D (batched) tensor with shape:
|
* `(..., height, width, channels)`, in `"channels_last"` format.
|
* Output shape:
|
* 3D (unbatched) or 4D (batched) tensor with shape:
|
* `(..., height, random_width, channels)`.
|
*
|
*
|
* @doc {heading: 'Layers', subheading: 'RandomWidth', namespace: 'layers'}
|
*/
|
export function randomWidth(args) {
|
return new RandomWidth(args);
|
}
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"exports_layers.js","sourceRoot":"","sources":["../../../../../tfjs-layers/src/exports_layers.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2018 Google LLC\n *\n * Use of this source code is governed by an MIT-style\n * license that can be found in the LICENSE file or at\n * https://opensource.org/licenses/MIT.\n * =============================================================================\n */\n\nimport {InputLayer, InputLayerArgs} from './engine/input_layer';\nimport {Layer, LayerArgs} from './engine/topology';\nimport {input} from './exports';\nimport {ELU, ELULayerArgs, LeakyReLU, LeakyReLULayerArgs, PReLU, PReLULayerArgs, ReLU, ReLULayerArgs, Softmax, SoftmaxLayerArgs, ThresholdedReLU, ThresholdedReLULayerArgs} from './layers/advanced_activations';\nimport {Conv1D, Conv2D, Conv2DTranspose, Conv3D, ConvLayerArgs, Cropping2D, Cropping2DLayerArgs, SeparableConv2D, SeparableConvLayerArgs, UpSampling2D, UpSampling2DLayerArgs, Conv3DTranspose} from './layers/convolutional';\nimport {DepthwiseConv2D, DepthwiseConv2DLayerArgs} from './layers/convolutional_depthwise';\nimport {ConvLSTM2D, ConvLSTM2DArgs, ConvLSTM2DCell, ConvLSTM2DCellArgs} from './layers/convolutional_recurrent';\nimport {Activation, ActivationLayerArgs, Dense, DenseLayerArgs, Dropout, DropoutLayerArgs, Flatten, FlattenLayerArgs, Masking, MaskingArgs, Permute, PermuteLayerArgs, RepeatVector, RepeatVectorLayerArgs, Reshape, ReshapeLayerArgs, SpatialDropout1D, SpatialDropout1DLayerConfig} from './layers/core';\nimport {Embedding, EmbeddingLayerArgs} from './layers/embeddings';\nimport {Add, Average, Concatenate, ConcatenateLayerArgs, Dot, DotLayerArgs, Maximum, Minimum, Multiply} from './layers/merge';\nimport {AlphaDropout, AlphaDropoutArgs, GaussianDropout, GaussianDropoutArgs, GaussianNoise, GaussianNoiseArgs} from './layers/noise';\nimport {BatchNormalization, BatchNormalizationLayerArgs, LayerNormalization, LayerNormalizationLayerArgs} from './layers/normalization';\nimport {ZeroPadding2D, ZeroPadding2DLayerArgs} from './layers/padding';\nimport {AveragePooling1D, AveragePooling2D, AveragePooling3D, GlobalAveragePooling1D, GlobalAveragePooling2D, GlobalMaxPooling1D, GlobalMaxPooling2D, GlobalPooling2DLayerArgs, MaxPooling1D, MaxPooling2D, MaxPooling3D, Pooling1DLayerArgs, Pooling2DLayerArgs, Pooling3DLayerArgs} from './layers/pooling';\nimport {GRU, GRUCell, GRUCellLayerArgs, GRULayerArgs, LSTM, LSTMCell, LSTMCellLayerArgs, LSTMLayerArgs, RNN, RNNCell, RNNLayerArgs, SimpleRNN, SimpleRNNCell, SimpleRNNCellLayerArgs, SimpleRNNLayerArgs, StackedRNNCells, StackedRNNCellsArgs} from './layers/recurrent';\nimport {Bidirectional, BidirectionalLayerArgs, TimeDistributed, WrapperLayerArgs} from './layers/wrappers';\nimport {Rescaling, RescalingArgs} from './layers/preprocessing/image_preprocessing';\nimport {CenterCrop, CenterCropArgs} from './layers/preprocessing/center_crop';\nimport {CategoryEncoding, CategoryEncodingArgs} from './layers/preprocessing/category_encoding';\nimport {Resizing, ResizingArgs} from './layers/preprocessing/image_resizing';\nimport {RandomWidth, RandomWidthArgs} from './layers/preprocessing/random_width';\n\n// TODO(cais): Add doc string to all the public static functions in this\n//   class; include exectuable JavaScript code snippets where applicable\n//   (b/74074458).\n\n// Input Layer.\n/**\n * An input layer is an entry point into a `tf.LayersModel`.\n *\n * `InputLayer` is generated automatically for `tf.Sequential` models by\n * specifying the `inputshape` or `batchInputShape` for the first layer.  It\n * should not be specified explicitly. However, it can be useful sometimes,\n * e.g., when constructing a sequential model from a subset of another\n * sequential model's layers. Like the code snippet below shows.\n *\n * ```js\n * // Define a model which simply adds two inputs.\n * const model1 = tf.sequential();\n * model1.add(tf.layers.dense({inputShape: [4], units: 3, activation: 'relu'}));\n * model1.add(tf.layers.dense({units: 1, activation: 'sigmoid'}));\n * model1.summary();\n * model1.predict(tf.zeros([1, 4])).print();\n *\n * // Construct another model, reusing the second layer of `model1` while\n * // not using the first layer of `model1`. Note that you cannot add the second\n * // layer of `model` directly as the first layer of the new sequential model,\n * // because doing so will lead to an error related to the fact that the layer\n * // is not an input layer. Instead, you need to create an `inputLayer` and add\n * // it to the new sequential model before adding the reused layer.\n * const model2 = tf.sequential();\n * // Use an inputShape that matches the input shape of `model1`'s second\n * // layer.\n * model2.add(tf.layers.inputLayer({inputShape: [3]}));\n * model2.add(model1.layers[1]);\n * model2.summary();\n * model2.predict(tf.zeros([1, 3])).print();\n * ```\n *\n * @doc {heading: 'Layers', subheading: 'Inputs', namespace: 'layers'}\n */\nexport function inputLayer(args: InputLayerArgs) {\n  return new InputLayer(args);\n}\n\n// Advanced Activation Layers.\n\n/**\n * Exponential Linear Unit (ELU).\n *\n * It follows:\n * `f(x) =  alpha * (exp(x) - 1.) for x < 0`,\n * `f(x) = x for x >= 0`.\n *\n * Input shape:\n *   Arbitrary. Use the configuration `inputShape` when using this layer as the\n *   first layer in a model.\n *\n * Output shape:\n *   Same shape as the input.\n *\n * References:\n *   - [Fast and Accurate Deep Network Learning by Exponential Linear Units\n * (ELUs)](https://arxiv.org/abs/1511.07289v1)\n *\n * @doc {\n *   heading: 'Layers',\n *   subheading: 'Advanced Activation',\n *   namespace: 'layers'\n * }\n */\nexport function elu(args?: ELULayerArgs) {\n  return new ELU(args);\n}\n\n/**\n * Rectified Linear Unit activation function.\n *\n * Input shape:\n *   Arbitrary. Use the config field `inputShape` (Array of integers, does\n *   not include the sample axis) when using this layer as the first layer\n *   in a model.\n *\n * Output shape:\n *   Same shape as the input.\n *\n * @doc {\n *   heading: 'Layers',\n *   subheading: 'Advanced Activation',\n *   namespace: 'layers'\n * }\n */\nexport function reLU(args?: ReLULayerArgs) {\n  return new ReLU(args);\n}\n\n/**\n * Leaky version of a rectified linear unit.\n *\n * It allows a small gradient when the unit is not active:\n * `f(x) = alpha * x for x < 0.`\n * `f(x) = x for x >= 0.`\n *\n * Input shape:\n *   Arbitrary. Use the configuration `inputShape` when using this layer as the\n *   first layer in a model.\n *\n * Output shape:\n *   Same shape as the input.\n *\n * @doc {\n *   heading: 'Layers',\n *   subheading: 'Advanced Activation',\n *   namespace: 'layers'\n * }\n */\nexport function leakyReLU(args?: LeakyReLULayerArgs) {\n  return new LeakyReLU(args);\n}\n\n/**\n * Parameterized version of a leaky rectified linear unit.\n *\n * It follows\n * `f(x) = alpha * x for x < 0.`\n * `f(x) = x for x >= 0.`\n * wherein `alpha` is a trainable weight.\n *\n * Input shape:\n *   Arbitrary. Use the configuration `inputShape` when using this layer as the\n *   first layer in a model.\n *\n * Output shape:\n *   Same shape as the input.\n *\n * @doc {\n *   heading: 'Layers',\n *   subheading: 'Advanced Activation',\n *   namespace: 'layers'\n * }\n */\nexport function prelu(args?: PReLULayerArgs) {\n  return new PReLU(args);\n}\n\n/**\n * Softmax activation layer.\n *\n * Input shape:\n *   Arbitrary. Use the configuration `inputShape` when using this layer as the\n *   first layer in a model.\n *\n * Output shape:\n *   Same shape as the input.\n *\n * @doc {\n *   heading: 'Layers',\n *   subheading: 'Advanced Activation',\n *   namespace: 'layers'\n * }\n */\nexport function softmax(args?: SoftmaxLayerArgs) {\n  return new Softmax(args);\n}\n\n/**\n * Thresholded Rectified Linear Unit.\n *\n * It follows:\n * `f(x) = x for x > theta`,\n * `f(x) = 0 otherwise`.\n *\n * Input shape:\n *   Arbitrary. Use the configuration `inputShape` when using this layer as the\n *   first layer in a model.\n *\n * Output shape:\n *   Same shape as the input.\n *\n * References:\n *   - [Zero-Bias Autoencoders and the Benefits of Co-Adapting\n * Features](http://arxiv.org/abs/1402.3337)\n *\n * @doc {\n *   heading: 'Layers',\n *   subheading: 'Advanced Activation',\n *   namespace: 'layers'\n * }\n */\nexport function thresholdedReLU(args?: ThresholdedReLULayerArgs) {\n  return new ThresholdedReLU(args);\n}\n\n// Convolutional Layers.\n\n/**\n * 1D convolution layer (e.g., temporal convolution).\n *\n * This layer creates a convolution kernel that is convolved\n * with the layer input over a single spatial (or temporal) dimension\n * to produce a tensor of outputs.\n *\n * If `use_bias` is True, a bias vector is created and added to the outputs.\n *\n * If `activation` is not `null`, it is applied to the outputs as well.\n *\n * When using this layer as the first layer in a model, provide an\n * `inputShape` argument `Array` or `null`.\n *\n * For example, `inputShape` would be:\n * - `[10, 128]` for sequences of 10 vectors of 128-dimensional vectors\n * - `[null, 128]` for variable-length sequences of 128-dimensional vectors.\n *\n * @doc {heading: 'Layers', subheading: 'Convolutional',  namespace: 'layers'}\n */\nexport function conv1d(args: ConvLayerArgs) {\n  return new Conv1D(args);\n}\n\n/**\n * 2D convolution layer (e.g. spatial convolution over images).\n *\n * This layer creates a convolution kernel that is convolved\n * with the layer input to produce a tensor of outputs.\n *\n * If `useBias` is True, a bias vector is created and added to the outputs.\n *\n * If `activation` is not `null`, it is applied to the outputs as well.\n *\n * When using this layer as the first layer in a model,\n * provide the keyword argument `inputShape`\n * (Array of integers, does not include the sample axis),\n * e.g. `inputShape=[128, 128, 3]` for 128x128 RGB pictures\n * in `dataFormat='channelsLast'`.\n *\n * @doc {heading: 'Layers', subheading: 'Convolutional', namespace: 'layers'}\n */\nexport function conv2d(args: ConvLayerArgs) {\n  return new Conv2D(args);\n}\n\n/**\n * Transposed convolutional layer (sometimes called Deconvolution).\n *\n * The need for transposed convolutions generally arises\n * from the desire to use a transformation going in the opposite direction of\n * a normal convolution, i.e., from something that has the shape of the output\n * of some convolution to something that has the shape of its input while\n * maintaining a connectivity pattern that is compatible with said\n * convolution.\n *\n * When using this layer as the first layer in a model, provide the\n * configuration `inputShape` (`Array` of integers, does not include the\n * sample axis), e.g., `inputShape: [128, 128, 3]` for 128x128 RGB pictures in\n * `dataFormat: 'channelsLast'`.\n *\n * Input shape:\n *   4D tensor with shape:\n *   `[batch, channels, rows, cols]` if `dataFormat` is `'channelsFirst'`.\n *   or 4D tensor with shape\n *   `[batch, rows, cols, channels]` if `dataFormat` is `'channelsLast'`.\n *\n * Output shape:\n *   4D tensor with shape:\n *   `[batch, filters, newRows, newCols]` if `dataFormat` is\n * `'channelsFirst'`. or 4D tensor with shape:\n *   `[batch, newRows, newCols, filters]` if `dataFormat` is `'channelsLast'`.\n *\n * References:\n *   - [A guide to convolution arithmetic for deep\n * learning](https://arxiv.org/abs/1603.07285v1)\n *   - [Deconvolutional\n * Networks](http://www.matthewzeiler.com/pubs/cvpr2010/cvpr2010.pdf)\n *\n * @doc {heading: 'Layers', subheading: 'Convolutional', namespace: 'layers'}\n */\nexport function conv2dTranspose(args: ConvLayerArgs) {\n  return new Conv2DTranspose(args);\n}\n\n/**\n * 3D convolution layer (e.g. spatial convolution over volumes).\n *\n * This layer creates a convolution kernel that is convolved\n * with the layer input to produce a tensor of outputs.\n *\n * If `useBias` is True, a bias vector is created and added to the outputs.\n *\n * If `activation` is not `null`, it is applied to the outputs as well.\n *\n * When using this layer as the first layer in a model,\n * provide the keyword argument `inputShape`\n * (Array of integers, does not include the sample axis),\n * e.g. `inputShape=[128, 128, 128, 1]` for 128x128x128 grayscale volumes\n * in `dataFormat='channelsLast'`.\n *\n * @doc {heading: 'Layers', subheading: 'Convolutional', namespace: 'layers'}\n */\nexport function conv3d(args: ConvLayerArgs) {\n  return new Conv3D(args);\n}\n\nexport function conv3dTranspose(args: ConvLayerArgs): Layer {\n  return new Conv3DTranspose(args);\n}\n\n/**\n * Depthwise separable 2D convolution.\n *\n * Separable convolution consists of first performing\n * a depthwise spatial convolution\n * (which acts on each input channel separately)\n * followed by a pointwise convolution which mixes together the resulting\n * output channels. The `depthMultiplier` argument controls how many\n * output channels are generated per input channel in the depthwise step.\n *\n * Intuitively, separable convolutions can be understood as\n * a way to factorize a convolution kernel into two smaller kernels,\n * or as an extreme version of an Inception block.\n *\n * Input shape:\n *   4D tensor with shape:\n *     `[batch, channels, rows, cols]` if data_format='channelsFirst'\n *   or 4D tensor with shape:\n *     `[batch, rows, cols, channels]` if data_format='channelsLast'.\n *\n * Output shape:\n *   4D tensor with shape:\n *     `[batch, filters, newRows, newCols]` if data_format='channelsFirst'\n *   or 4D tensor with shape:\n *     `[batch, newRows, newCols, filters]` if data_format='channelsLast'.\n *     `rows` and `cols` values might have changed due to padding.\n *\n * @doc {heading: 'Layers', subheading: 'Convolutional', namespace: 'layers'}\n */\nexport function separableConv2d(args: SeparableConvLayerArgs) {\n  return new SeparableConv2D(args);\n}\n\n/**\n * Cropping layer for 2D input (e.g., image).\n *\n * This layer can crop an input\n * at the top, bottom, left and right side of an image tensor.\n *\n * Input shape:\n *   4D tensor with shape:\n *   - If `dataFormat` is `\"channelsLast\"`:\n *     `[batch, rows, cols, channels]`\n *   - If `data_format` is `\"channels_first\"`:\n *     `[batch, channels, rows, cols]`.\n *\n * Output shape:\n *   4D with shape:\n *   - If `dataFormat` is `\"channelsLast\"`:\n *     `[batch, croppedRows, croppedCols, channels]`\n *    - If `dataFormat` is `\"channelsFirst\"`:\n *     `[batch, channels, croppedRows, croppedCols]`.\n *\n * Examples\n * ```js\n *\n * const model = tf.sequential();\n * model.add(tf.layers.cropping2D({cropping:[[2, 2], [2, 2]],\n *                                inputShape: [128, 128, 3]}));\n * //now output shape is [batch, 124, 124, 3]\n * ```\n *\n * @doc {heading: 'Layers', subheading: 'Convolutional', namespace: 'layers'}\n */\nexport function cropping2D(args: Cropping2DLayerArgs) {\n  return new Cropping2D(args);\n}\n\n/**\n * Upsampling layer for 2D inputs.\n *\n * Repeats the rows and columns of the data\n * by size[0] and size[1] respectively.\n *\n *\n * Input shape:\n *    4D tensor with shape:\n *     - If `dataFormat` is `\"channelsLast\"`:\n *         `[batch, rows, cols, channels]`\n *     - If `dataFormat` is `\"channelsFirst\"`:\n *        `[batch, channels, rows, cols]`\n *\n * Output shape:\n *     4D tensor with shape:\n *     - If `dataFormat` is `\"channelsLast\"`:\n *        `[batch, upsampledRows, upsampledCols, channels]`\n *     - If `dataFormat` is `\"channelsFirst\"`:\n *         `[batch, channels, upsampledRows, upsampledCols]`\n *\n *\n * @doc {heading: 'Layers', subheading: 'Convolutional', namespace: 'layers'}\n */\nexport function upSampling2d(args: UpSampling2DLayerArgs) {\n  return new UpSampling2D(args);\n}\n\n// Convolutional(depthwise) Layers.\n\n/**\n * Depthwise separable 2D convolution.\n *\n * Depthwise Separable convolutions consists in performing just the first step\n * in a depthwise spatial convolution (which acts on each input channel\n * separately). The `depthMultiplier` argument controls how many output channels\n * are generated per input channel in the depthwise step.\n *\n * @doc {heading: 'Layers', subheading: 'Convolutional', namespace: 'layers'}\n */\nexport function depthwiseConv2d(args: DepthwiseConv2DLayerArgs) {\n  return new DepthwiseConv2D(args);\n}\n\n// Basic Layers.\n\n/**\n * Applies an activation function to an output.\n *\n * This layer applies element-wise activation function.  Other layers, notably\n * `dense` can also apply activation functions.  Use this isolated activation\n * function to extract the values before and after the\n * activation. For instance:\n *\n * ```js\n * const input = tf.input({shape: [5]});\n * const denseLayer = tf.layers.dense({units: 1});\n * const activationLayer = tf.layers.activation({activation: 'relu6'});\n *\n * // Obtain the output symbolic tensors by applying the layers in order.\n * const denseOutput = denseLayer.apply(input);\n * const activationOutput = activationLayer.apply(denseOutput);\n *\n * // Create the model based on the inputs.\n * const model = tf.model({\n *     inputs: input,\n *     outputs: [denseOutput, activationOutput]\n * });\n *\n * // Collect both outputs and print separately.\n * const [denseOut, activationOut] = model.predict(tf.randomNormal([6, 5]));\n * denseOut.print();\n * activationOut.print();\n * ```\n *\n * @doc {heading: 'Layers', subheading: 'Basic', namespace: 'layers'}\n */\nexport function activation(args: ActivationLayerArgs) {\n  return new Activation(args);\n}\n\n/**\n * Creates a dense (fully connected) layer.\n *\n * This layer implements the operation:\n *   `output = activation(dot(input, kernel) + bias)`\n *\n * `activation` is the element-wise activation function\n *   passed as the `activation` argument.\n *\n * `kernel` is a weights matrix created by the layer.\n *\n * `bias` is a bias vector created by the layer (only applicable if `useBias`\n * is `true`).\n *\n * **Input shape:**\n *\n *   nD `tf.Tensor` with shape: `(batchSize, ..., inputDim)`.\n *\n *   The most common situation would be\n *   a 2D input with shape `(batchSize, inputDim)`.\n *\n * **Output shape:**\n *\n *   nD tensor with shape: `(batchSize, ..., units)`.\n *\n *   For instance, for a 2D input with shape `(batchSize, inputDim)`,\n *   the output would have shape `(batchSize, units)`.\n *\n * Note: if the input to the layer has a rank greater than 2, then it is\n * flattened prior to the initial dot product with the kernel.\n *\n * @doc {heading: 'Layers', subheading: 'Basic', namespace: 'layers'}\n */\nexport function dense(args: DenseLayerArgs) {\n  return new Dense(args);\n}\n\n/**\n * Applies\n * [dropout](http://www.cs.toronto.edu/~rsalakhu/papers/srivastava14a.pdf) to\n * the input.\n *\n * Dropout consists in randomly setting a fraction `rate` of input units to 0 at\n * each update during training time, which helps prevent overfitting.\n *\n * @doc {heading: 'Layers', subheading: 'Basic', namespace: 'layers'}\n */\nexport function dropout(args: DropoutLayerArgs) {\n  return new Dropout(args);\n}\n\n/**\n * Spatial 1D version of Dropout.\n *\n * This Layer type performs the same function as the Dropout layer, but it drops\n * entire 1D feature maps instead of individual elements. For example, if an\n * input example consists of 3 timesteps and the feature map for each timestep\n * has a size of 4, a `spatialDropout1d` layer may zero out the feature maps\n * of the 1st timesteps and 2nd timesteps completely while sparing all feature\n * elements of the 3rd timestep.\n *\n * If adjacent frames (timesteps) are strongly correlated (as is normally the\n * case in early convolution layers), regular dropout will not regularize the\n * activation and will otherwise just result in merely an effective learning\n * rate decrease. In this case, `spatialDropout1d` will help promote\n * independence among feature maps and should be used instead.\n *\n * **Arguments:**\n *   rate: A floating-point number >=0 and <=1. Fraction of the input elements\n *     to drop.\n *\n * **Input shape:**\n *   3D tensor with shape `(samples, timesteps, channels)`.\n *\n * **Output shape:**\n *   Same as the input shape.\n *\n * References:\n *   - [Efficient Object Localization Using Convolutional\n *      Networks](https://arxiv.org/abs/1411.4280)\n *\n * @doc {heading: 'Layers', subheading: 'Basic', namespace: 'layers'}\n */\nexport function spatialDropout1d(args: SpatialDropout1DLayerConfig) {\n  return new SpatialDropout1D(args);\n}\n\n/**\n * Flattens the input. Does not affect the batch size.\n *\n * A `Flatten` layer flattens each batch in its inputs to 1D (making the output\n * 2D).\n *\n * For example:\n *\n * ```js\n * const input = tf.input({shape: [4, 3]});\n * const flattenLayer = tf.layers.flatten();\n * // Inspect the inferred output shape of the flatten layer, which\n * // equals `[null, 12]`. The 2nd dimension is 4 * 3, i.e., the result of the\n * // flattening. (The 1st dimension is the undermined batch size.)\n * console.log(JSON.stringify(flattenLayer.apply(input).shape));\n * ```\n *\n * @doc {heading: 'Layers', subheading: 'Basic', namespace: 'layers'}\n */\nexport function flatten(args?: FlattenLayerArgs) {\n  return new Flatten(args);\n}\n\n/**\n * Repeats the input n times in a new dimension.\n *\n * ```js\n *  const model = tf.sequential();\n *  model.add(tf.layers.repeatVector({n: 4, inputShape: [2]}));\n *  const x = tf.tensor2d([[10, 20]]);\n *  // Use the model to do inference on a data point the model hasn't seen\n *  model.predict(x).print();\n *  // output shape is now [batch, 2, 4]\n * ```\n *\n * @doc {heading: 'Layers', subheading: 'Basic', namespace: 'layers'}\n */\nexport function repeatVector(args: RepeatVectorLayerArgs) {\n  return new RepeatVector(args);\n}\n\n/**\n * Reshapes an input to a certain shape.\n *\n * ```js\n * const input = tf.input({shape: [4, 3]});\n * const reshapeLayer = tf.layers.reshape({targetShape: [2, 6]});\n * // Inspect the inferred output shape of the Reshape layer, which\n * // equals `[null, 2, 6]`. (The 1st dimension is the undermined batch size.)\n * console.log(JSON.stringify(reshapeLayer.apply(input).shape));\n * ```\n *\n * Input shape:\n *   Arbitrary, although all dimensions in the input shape must be fixed.\n *   Use the configuration `inputShape` when using this layer as the\n *   first layer in a model.\n *\n *\n * Output shape:\n *   [batchSize, targetShape[0], targetShape[1], ...,\n *    targetShape[targetShape.length - 1]].\n *\n * @doc {heading: 'Layers', subheading: 'Basic', namespace: 'layers'}\n */\nexport function reshape(args: ReshapeLayerArgs) {\n  return new Reshape(args);\n}\n\n/**\n * Permutes the dimensions of the input according to a given pattern.\n *\n * Useful for, e.g., connecting RNNs and convnets together.\n *\n * Example:\n *\n * ```js\n * const model = tf.sequential();\n * model.add(tf.layers.permute({\n *   dims: [2, 1],\n *   inputShape: [10, 64]\n * }));\n * console.log(model.outputShape);\n * // Now model's output shape is [null, 64, 10], where null is the\n * // unpermuted sample (batch) dimension.\n * ```\n *\n * Input shape:\n *   Arbitrary. Use the configuration field `inputShape` when using this\n *   layer as the first layer in a model.\n *\n * Output shape:\n *   Same rank as the input shape, but with the dimensions re-ordered (i.e.,\n *   permuted) according to the `dims` configuration of this layer.\n *\n * @doc {heading: 'Layers', subheading: 'Basic', namespace: 'layers'}\n */\nexport function permute(args: PermuteLayerArgs) {\n  return new Permute(args);\n}\n\n/**\n * Maps positive integers (indices) into dense vectors of fixed size.\n * E.g. [[4], [20]] -> [[0.25, 0.1], [0.6, -0.2]]\n *\n * **Input shape:** 2D tensor with shape: `[batchSize, sequenceLength]`.\n *\n * **Output shape:** 3D tensor with shape: `[batchSize, sequenceLength,\n * outputDim]`.\n *\n * @doc {heading: 'Layers', subheading: 'Basic', namespace: 'layers'}\n */\nexport function embedding(args: EmbeddingLayerArgs) {\n  return new Embedding(args);\n}\n\n// Merge Layers.\n\n/**\n * Layer that performs element-wise addition on an `Array` of inputs.\n *\n * It takes as input a list of tensors, all of the same shape, and returns a\n * single tensor (also of the same shape). The inputs are specified as an\n * `Array` when the `apply` method of the `Add` layer instance is called. For\n * example:\n *\n * ```js\n * const input1 = tf.input({shape: [2, 2]});\n * const input2 = tf.input({shape: [2, 2]});\n * const addLayer = tf.layers.add();\n * const sum = addLayer.apply([input1, input2]);\n * console.log(JSON.stringify(sum.shape));\n * // You get [null, 2, 2], with the first dimension as the undetermined batch\n * // dimension.\n * ```\n *\n * @doc {heading: 'Layers', subheading: 'Merge', namespace: 'layers'}\n */\nexport function add(args?: LayerArgs) {\n  return new Add(args);\n}\n\n/**\n * Layer that performs element-wise averaging on an `Array` of inputs.\n *\n * It takes as input a list of tensors, all of the same shape, and returns a\n * single tensor (also of the same shape). For example:\n *\n * ```js\n * const input1 = tf.input({shape: [2, 2]});\n * const input2 = tf.input({shape: [2, 2]});\n * const averageLayer = tf.layers.average();\n * const average = averageLayer.apply([input1, input2]);\n * console.log(JSON.stringify(average.shape));\n * // You get [null, 2, 2], with the first dimension as the undetermined batch\n * // dimension.\n * ```\n *\n * @doc {heading: 'Layers', subheading: 'Merge', namespace: 'layers'}\n */\nexport function average(args?: LayerArgs) {\n  return new Average(args);\n}\n\n/**\n * Layer that concatenates an `Array` of inputs.\n *\n * It takes a list of tensors, all of the same shape except for the\n * concatenation axis, and returns a single tensor, the concatenation\n * of all inputs. For example:\n *\n * ```js\n * const input1 = tf.input({shape: [2, 2]});\n * const input2 = tf.input({shape: [2, 3]});\n * const concatLayer = tf.layers.concatenate();\n * const output = concatLayer.apply([input1, input2]);\n * console.log(JSON.stringify(output.shape));\n * // You get [null, 2, 5], with the first dimension as the undetermined batch\n * // dimension. The last dimension (5) is the result of concatenating the\n * // last dimensions of the inputs (2 and 3).\n * ```\n *\n * @doc {heading: 'Layers', subheading: 'Merge', namespace: 'layers'}\n */\nexport function concatenate(args?: ConcatenateLayerArgs) {\n  return new Concatenate(args);\n}\n\n/**\n * Layer that computes the element-wise maximum of an `Array` of inputs.\n *\n * It takes as input a list of tensors, all of the same shape, and returns a\n * single tensor (also of the same shape). For example:\n *\n * ```js\n * const input1 = tf.input({shape: [2, 2]});\n * const input2 = tf.input({shape: [2, 2]});\n * const maxLayer = tf.layers.maximum();\n * const max = maxLayer.apply([input1, input2]);\n * console.log(JSON.stringify(max.shape));\n * // You get [null, 2, 2], with the first dimension as the undetermined batch\n * // dimension.\n * ```\n *\n * @doc {heading: 'Layers', subheading: 'Merge', namespace: 'layers'}\n */\nexport function maximum(args?: LayerArgs) {\n  return new Maximum(args);\n}\n\n/**\n * Layer that computes the element-wise minimum of an `Array` of inputs.\n *\n * It takes as input a list of tensors, all of the same shape, and returns a\n * single tensor (also of the same shape). For example:\n *\n * ```js\n * const input1 = tf.input({shape: [2, 2]});\n * const input2 = tf.input({shape: [2, 2]});\n * const minLayer = tf.layers.minimum();\n * const min = minLayer.apply([input1, input2]);\n * console.log(JSON.stringify(min.shape));\n * // You get [null, 2, 2], with the first dimension as the undetermined batch\n * // dimension.\n * ```\n *\n * @doc {heading: 'Layers', subheading: 'Merge', namespace: 'layers'}\n */\nexport function minimum(args?: LayerArgs) {\n  return new Minimum(args);\n}\n\n/**\n * Layer that multiplies (element-wise) an `Array` of inputs.\n *\n * It takes as input an Array of tensors, all of the same\n * shape, and returns a single tensor (also of the same shape).\n * For example:\n *\n * ```js\n * const input1 = tf.input({shape: [2, 2]});\n * const input2 = tf.input({shape: [2, 2]});\n * const input3 = tf.input({shape: [2, 2]});\n * const multiplyLayer = tf.layers.multiply();\n * const product = multiplyLayer.apply([input1, input2, input3]);\n * console.log(product.shape);\n * // You get [null, 2, 2], with the first dimension as the undetermined batch\n * // dimension.\n *\n * @doc {heading: 'Layers', subheading: 'Merge', namespace: 'layers'}\n */\nexport function multiply(args?: LayerArgs) {\n  return new Multiply(args);\n}\n\n/**\n * Layer that computes a dot product between samples in two tensors.\n *\n * E.g., if applied to a list of two tensors `a` and `b` both of shape\n * `[batchSize, n]`, the output will be a tensor of shape `[batchSize, 1]`,\n * where each entry at index `[i, 0]` will be the dot product between\n * `a[i, :]` and `b[i, :]`.\n *\n * Example:\n *\n * ```js\n * const dotLayer = tf.layers.dot({axes: -1});\n * const x1 = tf.tensor2d([[10, 20], [30, 40]]);\n * const x2 = tf.tensor2d([[-1, -2], [-3, -4]]);\n *\n * // Invoke the layer's apply() method in eager (imperative) mode.\n * const y = dotLayer.apply([x1, x2]);\n * y.print();\n * ```\n *\n * @doc {heading: 'Layers', subheading: 'Merge', namespace: 'layers'}\n */\nexport function dot(args: DotLayerArgs) {\n  return new Dot(args);\n}\n\n// Normalization Layers.\n\n/**\n * Batch normalization layer (Ioffe and Szegedy, 2014).\n *\n * Normalize the activations of the previous layer at each batch,\n * i.e. applies a transformation that maintains the mean activation\n * close to 0 and the activation standard deviation close to 1.\n *\n * Input shape:\n *   Arbitrary. Use the keyword argument `inputShape` (Array of integers, does\n *   not include the sample axis) when calling the constructor of this class,\n *   if this layer is used as a first layer in a model.\n *\n * Output shape:\n *   Same shape as input.\n *\n * References:\n *   - [Batch Normalization: Accelerating Deep Network Training by Reducing\n * Internal Covariate Shift](https://arxiv.org/abs/1502.03167)\n *\n * @doc {heading: 'Layers', subheading: 'Normalization', namespace: 'layers'}\n */\nexport function batchNormalization(args?: BatchNormalizationLayerArgs) {\n  return new BatchNormalization(args);\n}\n\n/**\n * Layer-normalization layer (Ba et al., 2016).\n *\n * Normalizes the activations of the previous layer for each given example in a\n * batch independently, instead of across a batch like in `batchNormalization`.\n * In other words, this layer applies a transformation that maintains the mean\n * activation within each example close to 0 and activation variance close to 1.\n *\n * Input shape:\n *   Arbitrary. Use the argument `inputShape` when using this layer as the first\n *   layer in a model.\n *\n * Output shape:\n *   Same as input.\n *\n * References:\n *   - [Layer Normalization](https://arxiv.org/abs/1607.06450)\n *\n * @doc {heading: 'Layers', subheading: 'Normalization', namespace: 'layers'}\n */\nexport function layerNormalization(args?: LayerNormalizationLayerArgs) {\n  return new LayerNormalization(args);\n}\n\n// Padding Layers.\n\n/**\n * Zero-padding layer for 2D input (e.g., image).\n *\n * This layer can add rows and columns of zeros\n * at the top, bottom, left and right side of an image tensor.\n *\n * Input shape:\n *   4D tensor with shape:\n *   - If `dataFormat` is `\"channelsLast\"`:\n *     `[batch, rows, cols, channels]`\n *   - If `data_format` is `\"channels_first\"`:\n *     `[batch, channels, rows, cols]`.\n *\n * Output shape:\n *   4D with shape:\n *   - If `dataFormat` is `\"channelsLast\"`:\n *     `[batch, paddedRows, paddedCols, channels]`\n *    - If `dataFormat` is `\"channelsFirst\"`:\n *     `[batch, channels, paddedRows, paddedCols]`.\n *\n * @doc {heading: 'Layers', subheading: 'Padding', namespace: 'layers'}\n */\nexport function zeroPadding2d(args?: ZeroPadding2DLayerArgs) {\n  return new ZeroPadding2D(args);\n}\n\n// Pooling Layers.\n\n/**\n * Average pooling operation for spatial data.\n *\n * Input shape: `[batchSize, inLength, channels]`\n *\n * Output shape: `[batchSize, pooledLength, channels]`\n *\n * `tf.avgPool1d` is an alias.\n *\n * @doc {heading: 'Layers', subheading: 'Pooling', namespace: 'layers'}\n */\nexport function averagePooling1d(args: Pooling1DLayerArgs) {\n  return new AveragePooling1D(args);\n}\nexport function avgPool1d(args: Pooling1DLayerArgs) {\n  return averagePooling1d(args);\n}\n// For backwards compatibility.\n// See https://github.com/tensorflow/tfjs/issues/152\nexport function avgPooling1d(args: Pooling1DLayerArgs) {\n  return averagePooling1d(args);\n}\n\n/**\n * Average pooling operation for spatial data.\n *\n * Input shape:\n *  - If `dataFormat === CHANNEL_LAST`:\n *      4D tensor with shape:\n *      `[batchSize, rows, cols, channels]`\n *  - If `dataFormat === CHANNEL_FIRST`:\n *      4D tensor with shape:\n *      `[batchSize, channels, rows, cols]`\n *\n * Output shape\n *  - If `dataFormat === CHANNEL_LAST`:\n *      4D tensor with shape:\n *      `[batchSize, pooledRows, pooledCols, channels]`\n *  - If `dataFormat === CHANNEL_FIRST`:\n *      4D tensor with shape:\n *      `[batchSize, channels, pooledRows, pooledCols]`\n *\n * `tf.avgPool2d` is an alias.\n *\n * @doc {heading: 'Layers', subheading: 'Pooling', namespace: 'layers'}\n */\nexport function averagePooling2d(args: Pooling2DLayerArgs) {\n  return new AveragePooling2D(args);\n}\nexport function avgPool2d(args: Pooling2DLayerArgs) {\n  return averagePooling2d(args);\n}\n// For backwards compatibility.\n// See https://github.com/tensorflow/tfjs/issues/152\nexport function avgPooling2d(args: Pooling2DLayerArgs) {\n  return averagePooling2d(args);\n}\n\n/**\n * Average pooling operation for 3D data.\n *\n * Input shape\n *   - If `dataFormat === channelsLast`:\n *       5D tensor with shape:\n *       `[batchSize, depths, rows, cols, channels]`\n *   - If `dataFormat === channelsFirst`:\n *      4D tensor with shape:\n *       `[batchSize, channels, depths, rows, cols]`\n *\n * Output shape\n *   - If `dataFormat=channelsLast`:\n *       5D tensor with shape:\n *       `[batchSize, pooledDepths, pooledRows, pooledCols, channels]`\n *   - If `dataFormat=channelsFirst`:\n *       5D tensor with shape:\n *       `[batchSize, channels, pooledDepths, pooledRows, pooledCols]`\n *\n * @doc {heading: 'Layers', subheading: 'Pooling', namespace: 'layers'}\n */\nexport function averagePooling3d(args: Pooling3DLayerArgs) {\n  return new AveragePooling3D(args);\n}\nexport function avgPool3d(args: Pooling3DLayerArgs) {\n  return averagePooling3d(args);\n}\n// For backwards compatibility.\n// See https://github.com/tensorflow/tfjs/issues/152\nexport function avgPooling3d(args: Pooling3DLayerArgs) {\n  return averagePooling3d(args);\n}\n\n/**\n * Global average pooling operation for temporal data.\n *\n * Input Shape: 3D tensor with shape: `[batchSize, steps, features]`.\n *\n * Output Shape: 2D tensor with shape: `[batchSize, features]`.\n *\n * @doc {heading: 'Layers', subheading: 'Pooling', namespace: 'layers'}\n */\nexport function globalAveragePooling1d(args?: LayerArgs) {\n  return new GlobalAveragePooling1D(args);\n}\n\n/**\n * Global average pooling operation for spatial data.\n *\n * Input shape:\n *   - If `dataFormat` is `CHANNEL_LAST`:\n *       4D tensor with shape: `[batchSize, rows, cols, channels]`.\n *   - If `dataFormat` is `CHANNEL_FIRST`:\n *       4D tensor with shape: `[batchSize, channels, rows, cols]`.\n *\n * Output shape:\n *   2D tensor with shape: `[batchSize, channels]`.\n *\n * @doc {heading: 'Layers', subheading: 'Pooling', namespace: 'layers'}\n */\nexport function globalAveragePooling2d(args: GlobalPooling2DLayerArgs) {\n  return new GlobalAveragePooling2D(args);\n}\n\n/**\n * Global max pooling operation for temporal data.\n *\n * Input Shape: 3D tensor with shape: `[batchSize, steps, features]`.\n *\n * Output Shape: 2D tensor with shape: `[batchSize, features]`.\n *\n * @doc {heading: 'Layers', subheading: 'Pooling', namespace: 'layers'}\n */\nexport function globalMaxPooling1d(args?: LayerArgs) {\n  return new GlobalMaxPooling1D(args);\n}\n\n/**\n * Global max pooling operation for spatial data.\n *\n * Input shape:\n *   - If `dataFormat` is `CHANNEL_LAST`:\n *       4D tensor with shape: `[batchSize, rows, cols, channels]`.\n *   - If `dataFormat` is `CHANNEL_FIRST`:\n *       4D tensor with shape: `[batchSize, channels, rows, cols]`.\n *\n * Output shape:\n *   2D tensor with shape: `[batchSize, channels]`.\n *\n * @doc {heading: 'Layers', subheading: 'Pooling', namespace: 'layers'}\n */\nexport function globalMaxPooling2d(args: GlobalPooling2DLayerArgs) {\n  return new GlobalMaxPooling2D(args);\n}\n\n/**\n * Max pooling operation for temporal data.\n *\n * Input shape:  `[batchSize, inLength, channels]`\n *\n * Output shape: `[batchSize, pooledLength, channels]`\n *\n * @doc {heading: 'Layers', subheading: 'Pooling', namespace: 'layers'}\n */\nexport function maxPooling1d(args: Pooling1DLayerArgs) {\n  return new MaxPooling1D(args);\n}\n\n/**\n * Max pooling operation for spatial data.\n *\n * Input shape\n *   - If `dataFormat === CHANNEL_LAST`:\n *       4D tensor with shape:\n *       `[batchSize, rows, cols, channels]`\n *   - If `dataFormat === CHANNEL_FIRST`:\n *      4D tensor with shape:\n *       `[batchSize, channels, rows, cols]`\n *\n * Output shape\n *   - If `dataFormat=CHANNEL_LAST`:\n *       4D tensor with shape:\n *       `[batchSize, pooledRows, pooledCols, channels]`\n *   - If `dataFormat=CHANNEL_FIRST`:\n *       4D tensor with shape:\n *       `[batchSize, channels, pooledRows, pooledCols]`\n *\n * @doc {heading: 'Layers', subheading: 'Pooling', namespace: 'layers'}\n */\nexport function maxPooling2d(args: Pooling2DLayerArgs) {\n  return new MaxPooling2D(args);\n}\n\n/**\n * Max pooling operation for 3D data.\n *\n * Input shape\n *   - If `dataFormat === channelsLast`:\n *       5D tensor with shape:\n *       `[batchSize, depths, rows, cols, channels]`\n *   - If `dataFormat === channelsFirst`:\n *      5D tensor with shape:\n *       `[batchSize, channels, depths, rows, cols]`\n *\n * Output shape\n *   - If `dataFormat=channelsLast`:\n *       5D tensor with shape:\n *       `[batchSize, pooledDepths, pooledRows, pooledCols, channels]`\n *   - If `dataFormat=channelsFirst`:\n *       5D tensor with shape:\n *       `[batchSize, channels, pooledDepths, pooledRows, pooledCols]`\n *\n * @doc {heading: 'Layers', subheading: 'Pooling', namespace: 'layers'}\n */\nexport function maxPooling3d(args: Pooling3DLayerArgs) {\n  return new MaxPooling3D(args);\n}\n\n// Recurrent Layers.\n\n/**\n * Gated Recurrent Unit - Cho et al. 2014.\n *\n * This is an `RNN` layer consisting of one `GRUCell`. However, unlike\n * the underlying `GRUCell`, the `apply` method of `SimpleRNN` operates\n * on a sequence of inputs. The shape of the input (not including the first,\n * batch dimension) needs to be at least 2-D, with the first dimension being\n * time steps. For example:\n *\n * ```js\n * const rnn = tf.layers.gru({units: 8, returnSequences: true});\n *\n * // Create an input with 10 time steps.\n * const input = tf.input({shape: [10, 20]});\n * const output = rnn.apply(input);\n *\n * console.log(JSON.stringify(output.shape));\n * // [null, 10, 8]: 1st dimension is unknown batch size; 2nd dimension is the\n * // same as the sequence length of `input`, due to `returnSequences`: `true`;\n * // 3rd dimension is the `GRUCell`'s number of units.\n *\n * @doc {heading: 'Layers', subheading: 'Recurrent', namespace: 'layers'}\n */\nexport function gru(args: GRULayerArgs) {\n  return new GRU(args);\n}\n\n/**\n * Cell class for `GRU`.\n *\n * `GRUCell` is distinct from the `RNN` subclass `GRU` in that its\n * `apply` method takes the input data of only a single time step and returns\n * the cell's output at the time step, while `GRU` takes the input data\n * over a number of time steps. For example:\n *\n * ```js\n * const cell = tf.layers.gruCell({units: 2});\n * const input = tf.input({shape: [10]});\n * const output = cell.apply(input);\n *\n * console.log(JSON.stringify(output.shape));\n * // [null, 10]: This is the cell's output at a single time step. The 1st\n * // dimension is the unknown batch size.\n * ```\n *\n * Instance(s) of `GRUCell` can be used to construct `RNN` layers. The\n * most typical use of this workflow is to combine a number of cells into a\n * stacked RNN cell (i.e., `StackedRNNCell` internally) and use it to create an\n * RNN. For example:\n *\n * ```js\n * const cells = [\n *   tf.layers.gruCell({units: 4}),\n *   tf.layers.gruCell({units: 8}),\n * ];\n * const rnn = tf.layers.rnn({cell: cells, returnSequences: true});\n *\n * // Create an input with 10 time steps and a length-20 vector at each step.\n * const input = tf.input({shape: [10, 20]});\n * const output = rnn.apply(input);\n *\n * console.log(JSON.stringify(output.shape));\n * // [null, 10, 8]: 1st dimension is unknown batch size; 2nd dimension is the\n * // same as the sequence length of `input`, due to `returnSequences`: `true`;\n * // 3rd dimension is the last `gruCell`'s number of units.\n * ```\n *\n * To create an `RNN` consisting of only *one* `GRUCell`, use the\n * `tf.layers.gru`.\n *\n * @doc {heading: 'Layers', subheading: 'Recurrent', namespace: 'layers'}\n */\nexport function gruCell(args: GRUCellLayerArgs) {\n  return new GRUCell(args);\n}\n\n/**\n * Long-Short Term Memory layer - Hochreiter 1997.\n *\n * This is an `RNN` layer consisting of one `LSTMCell`. However, unlike\n * the underlying `LSTMCell`, the `apply` method of `LSTM` operates\n * on a sequence of inputs. The shape of the input (not including the first,\n * batch dimension) needs to be at least 2-D, with the first dimension being\n * time steps. For example:\n *\n * ```js\n * const lstm = tf.layers.lstm({units: 8, returnSequences: true});\n *\n * // Create an input with 10 time steps.\n * const input = tf.input({shape: [10, 20]});\n * const output = lstm.apply(input);\n *\n * console.log(JSON.stringify(output.shape));\n * // [null, 10, 8]: 1st dimension is unknown batch size; 2nd dimension is the\n * // same as the sequence length of `input`, due to `returnSequences`: `true`;\n * // 3rd dimension is the `LSTMCell`'s number of units.\n *\n * @doc {heading: 'Layers', subheading: 'Recurrent', namespace: 'layers'}\n */\nexport function lstm(args: LSTMLayerArgs) {\n  return new LSTM(args);\n}\n\n/**\n * Cell class for `LSTM`.\n *\n * `LSTMCell` is distinct from the `RNN` subclass `LSTM` in that its\n * `apply` method takes the input data of only a single time step and returns\n * the cell's output at the time step, while `LSTM` takes the input data\n * over a number of time steps. For example:\n *\n * ```js\n * const cell = tf.layers.lstmCell({units: 2});\n * const input = tf.input({shape: [10]});\n * const output = cell.apply(input);\n *\n * console.log(JSON.stringify(output.shape));\n * // [null, 10]: This is the cell's output at a single time step. The 1st\n * // dimension is the unknown batch size.\n * ```\n *\n * Instance(s) of `LSTMCell` can be used to construct `RNN` layers. The\n * most typical use of this workflow is to combine a number of cells into a\n * stacked RNN cell (i.e., `StackedRNNCell` internally) and use it to create an\n * RNN. For example:\n *\n * ```js\n * const cells = [\n *   tf.layers.lstmCell({units: 4}),\n *   tf.layers.lstmCell({units: 8}),\n * ];\n * const rnn = tf.layers.rnn({cell: cells, returnSequences: true});\n *\n * // Create an input with 10 time steps and a length-20 vector at each step.\n * const input = tf.input({shape: [10, 20]});\n * const output = rnn.apply(input);\n *\n * console.log(JSON.stringify(output.shape));\n * // [null, 10, 8]: 1st dimension is unknown batch size; 2nd dimension is the\n * // same as the sequence length of `input`, due to `returnSequences`: `true`;\n * // 3rd dimension is the last `lstmCell`'s number of units.\n * ```\n *\n * To create an `RNN` consisting of only *one* `LSTMCell`, use the\n * `tf.layers.lstm`.\n *\n * @doc {heading: 'Layers', subheading: 'Recurrent', namespace: 'layers'}\n */\nexport function lstmCell(args: LSTMCellLayerArgs) {\n  return new LSTMCell(args);\n}\n\n/**\n * Fully-connected RNN where the output is to be fed back to input.\n *\n * This is an `RNN` layer consisting of one `SimpleRNNCell`. However, unlike\n * the underlying `SimpleRNNCell`, the `apply` method of `SimpleRNN` operates\n * on a sequence of inputs. The shape of the input (not including the first,\n * batch dimension) needs to be at least 2-D, with the first dimension being\n * time steps. For example:\n *\n * ```js\n * const rnn = tf.layers.simpleRNN({units: 8, returnSequences: true});\n *\n * // Create an input with 10 time steps.\n * const input = tf.input({shape: [10, 20]});\n * const output = rnn.apply(input);\n *\n * console.log(JSON.stringify(output.shape));\n * // [null, 10, 8]: 1st dimension is unknown batch size; 2nd dimension is the\n * // same as the sequence length of `input`, due to `returnSequences`: `true`;\n * // 3rd dimension is the `SimpleRNNCell`'s number of units.\n * ```\n *\n * @doc {heading: 'Layers', subheading: 'Recurrent', namespace: 'layers'}\n */\nexport function simpleRNN(args: SimpleRNNLayerArgs) {\n  return new SimpleRNN(args);\n}\n\n/**\n * Cell class for `SimpleRNN`.\n *\n * `SimpleRNNCell` is distinct from the `RNN` subclass `SimpleRNN` in that its\n * `apply` method takes the input data of only a single time step and returns\n * the cell's output at the time step, while `SimpleRNN` takes the input data\n * over a number of time steps. For example:\n *\n * ```js\n * const cell = tf.layers.simpleRNNCell({units: 2});\n * const input = tf.input({shape: [10]});\n * const output = cell.apply(input);\n *\n * console.log(JSON.stringify(output.shape));\n * // [null, 10]: This is the cell's output at a single time step. The 1st\n * // dimension is the unknown batch size.\n * ```\n *\n * Instance(s) of `SimpleRNNCell` can be used to construct `RNN` layers. The\n * most typical use of this workflow is to combine a number of cells into a\n * stacked RNN cell (i.e., `StackedRNNCell` internally) and use it to create an\n * RNN. For example:\n *\n * ```js\n * const cells = [\n *   tf.layers.simpleRNNCell({units: 4}),\n *   tf.layers.simpleRNNCell({units: 8}),\n * ];\n * const rnn = tf.layers.rnn({cell: cells, returnSequences: true});\n *\n * // Create an input with 10 time steps and a length-20 vector at each step.\n * const input = tf.input({shape: [10, 20]});\n * const output = rnn.apply(input);\n *\n * console.log(JSON.stringify(output.shape));\n * // [null, 10, 8]: 1st dimension is unknown batch size; 2nd dimension is the\n * // same as the sequence length of `input`, due to `returnSequences`: `true`;\n * // 3rd dimension is the last `SimpleRNNCell`'s number of units.\n * ```\n *\n * To create an `RNN` consisting of only *one* `SimpleRNNCell`, use the\n * `tf.layers.simpleRNN`.\n *\n * @doc {heading: 'Layers', subheading: 'Recurrent', namespace: 'layers'}\n */\nexport function simpleRNNCell(args: SimpleRNNCellLayerArgs) {\n  return new SimpleRNNCell(args);\n}\n\n/**\n * Convolutional LSTM layer - Xingjian Shi 2015.\n *\n * This is a `ConvRNN2D` layer consisting of one `ConvLSTM2DCell`. However,\n * unlike the underlying `ConvLSTM2DCell`, the `apply` method of `ConvLSTM2D`\n * operates on a sequence of inputs. The shape of the input (not including the\n * first, batch dimension) needs to be 4-D, with the first dimension being time\n * steps. For example:\n *\n * ```js\n * const filters = 3;\n * const kernelSize = 3;\n *\n * const batchSize = 4;\n * const sequenceLength = 2;\n * const size = 5;\n * const channels = 3;\n *\n * const inputShape = [batchSize, sequenceLength, size, size, channels];\n * const input = tf.ones(inputShape);\n *\n * const layer = tf.layers.convLstm2d({filters, kernelSize});\n *\n * const output = layer.apply(input);\n * ```\n */\n/** @doc {heading: 'Layers', subheading: 'Recurrent', namespace: 'layers'} */\nexport function convLstm2d(args: ConvLSTM2DArgs) {\n  return new ConvLSTM2D(args);\n}\n\n/**\n * Cell class for `ConvLSTM2D`.\n *\n * `ConvLSTM2DCell` is distinct from the `ConvRNN2D` subclass `ConvLSTM2D` in\n * that its `call` method takes the input data of only a single time step and\n * returns the cell's output at the time step, while `ConvLSTM2D` takes the\n * input data over a number of time steps. For example:\n *\n * ```js\n * const filters = 3;\n * const kernelSize = 3;\n *\n * const sequenceLength = 1;\n * const size = 5;\n * const channels = 3;\n *\n * const inputShape = [sequenceLength, size, size, channels];\n * const input = tf.ones(inputShape);\n *\n * const cell = tf.layers.convLstm2dCell({filters, kernelSize});\n *\n * cell.build(input.shape);\n *\n * const outputSize = size - kernelSize + 1;\n * const outShape = [sequenceLength, outputSize, outputSize, filters];\n *\n * const initialH = tf.zeros(outShape);\n * const initialC = tf.zeros(outShape);\n *\n * const [o, h, c] = cell.call([input, initialH, initialC], {});\n * ```\n */\n/** @doc {heading: 'Layers', subheading: 'Recurrent', namespace: 'layers'} */\nexport function convLstm2dCell(args: ConvLSTM2DCellArgs) {\n  return new ConvLSTM2DCell(args);\n}\n\n/**\n * Base class for recurrent layers.\n *\n * Input shape:\n *   3D tensor with shape `[batchSize, timeSteps, inputDim]`.\n *\n * Output shape:\n *   - if `returnState`, an Array of tensors (i.e., `tf.Tensor`s). The first\n *     tensor is the output. The remaining tensors are the states at the\n *     last time step, each with shape `[batchSize, units]`.\n *   - if `returnSequences`, the output will have shape\n *     `[batchSize, timeSteps, units]`.\n *   - else, the output will have shape `[batchSize, units]`.\n *\n * Masking:\n *   This layer supports masking for input data with a variable number\n *   of timesteps. To introduce masks to your data,\n *   use an embedding layer with the `mask_zero` parameter\n *   set to `True`.\n *\n * Notes on using statefulness in RNNs:\n *   You can set RNN layers to be 'stateful', which means that the states\n *   computed for the samples in one batch will be reused as initial states\n *   for the samples in the next batch. This assumes a one-to-one mapping\n *   between samples in different successive batches.\n *\n *   To enable statefulness:\n *     - specify `stateful: true` in the layer constructor.\n *     - specify a fixed batch size for your model, by passing\n *       if sequential model:\n *         `batchInputShape=[...]` to the first layer in your model.\n *       else for functional model with 1 or more Input layers:\n *         `batchShape=[...]` to all the first layers in your model.\n *       This is the expected shape of your inputs *including the batch size*.\n *       It should be a tuple of integers, e.g. `(32, 10, 100)`.\n *     - specify `shuffle=False` when calling fit().\n *\n *   To reset the states of your model, call `.resetStates()` on either\n *   a specific layer, or on your entire model.\n *\n * Note on specifying the initial state of RNNs\n *   You can specify the initial state of RNN layers symbolically by\n *   calling them with the option `initialState`. The value of\n *   `initialState` should be a tensor or list of tensors representing\n *   the initial state of the RNN layer.\n *\n *   You can specify the initial state of RNN layers numerically by\n *   calling `resetStates` with the keyword argument `states`. The value of\n *   `states` should be a numpy array or list of numpy arrays representing\n *   the initial state of the RNN layer.\n *\n * Note on passing external constants to RNNs\n *   You can pass \"external\" constants to the cell using the `constants`\n *   keyword argument of `RNN.call` method. This requires that the `cell.call`\n *   method accepts the same keyword argument `constants`. Such constants\n *   can be used to condition the cell transformation on additional static\n *   inputs (not changing over time), a.k.a. an attention mechanism.\n *\n * @doc {heading: 'Layers', subheading: 'Recurrent', namespace: 'layers'}\n */\nexport function rnn(args: RNNLayerArgs) {\n  return new RNN(args);\n}\n\n/**\n * Wrapper allowing a stack of RNN cells to behave as a single cell.\n *\n * Used to implement efficient stacked RNNs.\n *\n * @doc {heading: 'Layers', subheading: 'Recurrent', namespace: 'layers'}\n */\nexport function stackedRNNCells(args: StackedRNNCellsArgs){\n  return new StackedRNNCells(args);\n}\n\n// Wrapper Layers.\n\n/** @doc {heading: 'Layers', subheading: 'Wrapper', namespace: 'layers'} */\nexport function bidirectional(args: BidirectionalLayerArgs) {\n  return new Bidirectional(args);\n}\n\n/**\n * This wrapper applies a layer to every temporal slice of an input.\n *\n * The input should be at least 3D,  and the dimension of the index `1` will be\n * considered to be the temporal dimension.\n *\n * Consider a batch of 32 samples, where each sample is a sequence of 10 vectors\n * of 16 dimensions. The batch input shape of the layer is then `[32,  10,\n * 16]`, and the `inputShape`, not including the sample dimension, is\n * `[10, 16]`.\n *\n * You can then use `TimeDistributed` to apply a `Dense` layer to each of the 10\n * timesteps, independently:\n *\n * ```js\n * const model = tf.sequential();\n * model.add(tf.layers.timeDistributed({\n *   layer: tf.layers.dense({units: 8}),\n *   inputShape: [10, 16],\n * }));\n *\n * // Now model.outputShape = [null, 10, 8].\n * // The output will then have shape `[32, 10, 8]`.\n *\n * // In subsequent layers, there is no need for `inputShape`:\n * model.add(tf.layers.timeDistributed({layer: tf.layers.dense({units: 32})}));\n * console.log(JSON.stringify(model.outputs[0].shape));\n * // Now model.outputShape = [null, 10, 32].\n * ```\n *\n * The output will then have shape `[32, 10, 32]`.\n *\n * `TimeDistributed` can be used with arbitrary layers, not just `Dense`, for\n * instance a `Conv2D` layer.\n *\n * ```js\n * const model = tf.sequential();\n * model.add(tf.layers.timeDistributed({\n *   layer: tf.layers.conv2d({filters: 64, kernelSize: [3, 3]}),\n *   inputShape: [10, 299, 299, 3],\n * }));\n * console.log(JSON.stringify(model.outputs[0].shape));\n * ```\n *\n * @doc {heading: 'Layers', subheading: 'Wrapper', namespace: 'layers'}\n */\nexport function timeDistributed(args: WrapperLayerArgs) {\n  return new TimeDistributed(args);\n}\n\n// Aliases for pooling.\nexport const globalMaxPool1d = globalMaxPooling1d;\nexport const globalMaxPool2d = globalMaxPooling2d;\nexport const maxPool1d = maxPooling1d;\nexport const maxPool2d = maxPooling2d;\n\nexport {Layer, RNN, RNNCell, input /* alias for tf.input */};\n\n/**\n * Apply additive zero-centered Gaussian noise.\n *\n * As it is a regularization layer, it is only active at training time.\n *\n * This is useful to mitigate overfitting\n * (you could see it as a form of random data augmentation).\n * Gaussian Noise (GS) is a natural choice as corruption process\n * for real valued inputs.\n *\n * # Arguments\n * stddev: float, standard deviation of the noise distribution.\n *\n * # Input shape\n * Arbitrary. Use the keyword argument `input_shape`\n * (tuple of integers, does not include the samples axis)\n * when using this layer as the first layer in a model.\n *\n * # Output shape\n * Same shape as input.\n *\n * @doc {heading: 'Layers', subheading: 'Noise', namespace: 'layers'}\n */\nexport function gaussianNoise(args: GaussianNoiseArgs) {\n  return new GaussianNoise(args);\n}\n\n/**\n * Apply multiplicative 1-centered Gaussian noise.\n *\n * As it is a regularization layer, it is only active at training time.\n *\n * Arguments:\n *   - `rate`: float, drop probability (as with `Dropout`).\n *     The multiplicative noise will have\n *     standard deviation `sqrt(rate / (1 - rate))`.\n *\n * Input shape:\n *   Arbitrary. Use the keyword argument `inputShape`\n *   (tuple of integers, does not include the samples axis)\n *   when using this layer as the first layer in a model.\n *\n * Output shape:\n *   Same shape as input.\n *\n * References:\n *   - [Dropout: A Simple Way to Prevent Neural Networks from Overfitting](\n *      http://www.cs.toronto.edu/~rsalakhu/papers/srivastava14a.pdf)\n *\n * @doc {heading: 'Layers', subheading: 'Noise', namespace: 'layers'}\n */\nexport function gaussianDropout(args: GaussianDropoutArgs) {\n  return new GaussianDropout(args);\n}\n\n/**\n * Applies Alpha Dropout to the input.\n *\n * As it is a regularization layer, it is only active at training time.\n *\n * Alpha Dropout is a `Dropout` that keeps mean and variance of inputs\n * to their original values, in order to ensure the self-normalizing property\n * even after this dropout.\n * Alpha Dropout fits well to Scaled Exponential Linear Units\n * by randomly setting activations to the negative saturation value.\n *\n * Arguments:\n *   - `rate`: float, drop probability (as with `Dropout`).\n *     The multiplicative noise will have\n *     standard deviation `sqrt(rate / (1 - rate))`.\n *   - `noise_shape`: A 1-D `Tensor` of type `int32`, representing the\n *     shape for randomly generated keep/drop flags.\n *\n * Input shape:\n *   Arbitrary. Use the keyword argument `inputShape`\n *   (tuple of integers, does not include the samples axis)\n *   when using this layer as the first layer in a model.\n *\n * Output shape:\n *   Same shape as input.\n *\n * References:\n *   - [Self-Normalizing Neural Networks](https://arxiv.org/abs/1706.02515)\n *\n * @doc {heading: 'Layers', subheading: 'Noise', namespace: 'layers'}\n */\nexport function alphaDropout(args: AlphaDropoutArgs) {\n  return new AlphaDropout(args);\n}\n\n/**\n * Masks a sequence by using a mask value to skip timesteps.\n *\n * If all features for a given sample timestep are equal to `mask_value`,\n * then the sample timestep will be masked (skipped) in all downstream layers\n * (as long as they support masking).\n *\n * If any downstream layer does not support masking yet receives such\n * an input mask, an exception will be raised.\n *\n * Arguments:\n *   - `maskValue`: Either None or mask value to skip.\n *\n * Input shape:\n *   Arbitrary. Use the keyword argument `inputShape`\n *   (tuple of integers, does not include the samples axis)\n *   when using this layer as the first layer in a model.\n *\n * Output shape:\n *   Same shape as input.\n *\n * @doc {heading: 'Layers', subheading: 'Mask', namespace: 'layers'}\n */\nexport function masking(args?: MaskingArgs) {\n  return new Masking(args);\n}\n\n/**\n * A preprocessing layer which rescales input values to a new range.\n *\n * This layer rescales every value of an input (often an image) by multiplying\n * by `scale` and adding `offset`.\n *\n * For instance:\n * 1. To rescale an input in the ``[0, 255]`` range\n * to be in the `[0, 1]` range, you would pass `scale=1/255`.\n * 2. To rescale an input in the ``[0, 255]`` range to be in the `[-1, 1]`\n * range, you would pass `scale=1./127.5, offset=-1`.\n * The rescaling is applied both during training and inference. Inputs can be\n * of integer or floating point dtype, and by default the layer will output\n * floats.\n *\n * Arguments:\n *   - `scale`: Float, the scale to apply to the inputs.\n *   - `offset`: Float, the offset to apply to the inputs.\n *\n * Input shape:\n *   Arbitrary.\n *\n * Output shape:\n *   Same as input.\n *\n * @doc {heading: 'Layers', subheading: 'Rescaling', namespace: 'layers'}\n */\nexport function rescaling(args?: RescalingArgs) {\n  return new Rescaling(args);\n}\n\n/**\n *  A preprocessing layer which center crops images.\n *\n *   This layers crops the central portion of the images to a target size. If an\n *   image is smaller than the target size, it will be resized and cropped so as\n *   to return the largest possible window in the image that matches the target\n *   aspect ratio.\n *\n *   Input pixel values can be of any range (e.g. `[0., 1.)` or `[0, 255]`) and\n *   of integer or floating point dtype.\n *\n *   If the input height/width is even and the target height/width is odd (or\n *   inversely), the input image is left-padded by 1 pixel.\n *\n *   Arguments:\n *     `height`: Integer, the height of the output shape.\n *     `width`: Integer, the width of the output shape.\n *\n *   Input shape:\n *     3D (unbatched) or 4D (batched) tensor with shape:\n *     `(..., height, width, channels)`, in `channelsLast` format.\n *\n *   Output shape:\n *     3D (unbatched) or 4D (batched) tensor with shape:\n *     `(..., targetHeight, targetWidth, channels)`.\n *\n *\n *  @doc {heading: 'Layers', subheading: 'CenterCrop', namespace: 'layers'}\n */\nexport function centerCrop(args?: CenterCropArgs) {\n   return new CenterCrop(args);\n  }\n\n/**\n * A preprocessing layer which resizes images.\n * This layer resizes an image input to a target height and width. The input\n * should be a 4D (batched) or 3D (unbatched) tensor in `\"channels_last\"`\n * format.  Input pixel values can be of any range (e.g. `[0., 1.)` or `[0,\n * 255]`) and of interger or floating point dtype. By default, the layer will\n * output floats.\n *\n * Arguments:\n *   - `height`: number, the height for the output tensor.\n *   - `width`: number, the width for the output tensor.\n *   - `interpolation`: string, the method for image resizing interpolation.\n *   - `cropToAspectRatio`: boolean, whether to keep image aspect ratio.\n *\n * Input shape:\n *   Arbitrary.\n *\n * Output shape:\n *   height, width, num channels.\n *\n * @doc {heading: 'Layers', subheading: 'Resizing', namespace: 'layers'}\n */\nexport function resizing(args?: ResizingArgs) {\n  return new Resizing(args);\n}\n\n/**\n * A preprocessing layer which encodes integer features.\n *\n * This layer provides options for condensing data into a categorical encoding\n * when the total number of tokens are known in advance. It accepts integer\n * values as inputs, and it outputs a dense representation of those\n * inputs.\n *\n * Arguments:\n *\n * numTokens: The total number of tokens the layer should support. All\n *  inputs to the layer must integers in the range `0 <= value <\n *  numTokens`, or an error will be thrown.\n *\n * outputMode: Specification for the output of the layer.\n *  Defaults to `multiHot`. Values can be `oneHot`, `multiHot` or\n *  `count`, configuring the layer as follows:\n *\n *    oneHot: Encodes each individual element in the input into an\n *      array of `numTokens` size, containing a 1 at the element index. If\n *      the last dimension is size 1, will encode on that dimension. If the\n *      last dimension is not size 1, will append a new dimension for the\n *      encoded output.\n *\n *    multiHot: Encodes each sample in the input into a single array\n *     of `numTokens` size, containing a 1 for each vocabulary term\n *     present in the sample. Treats the last dimension as the sample\n *     dimension, if input shape is `(..., sampleLength)`, output shape\n *     will be `(..., numTokens)`.\n *\n *    count: Like `multiHot`, but the int array contains a count of\n *     the number of times the token at that index appeared in the sample.\n *\n *  For all output modes, currently only output up to rank 2 is supported.\n *   Call arguments:\n *    inputs: A 1D or 2D tensor of integer inputs.\n *    countWeights: A tensor in the same shape as `inputs` indicating the\n *    weight for each sample value when summing up in `count` mode. Not used\n *    in `multiHot` or `oneHot` modes.\n *\n *\n * @doc {heading: 'Layers', subheading: 'CategoryEncoding', namespace: 'layers'}\n */\nexport function categoryEncoding(args: CategoryEncodingArgs) {\n  return new CategoryEncoding(args);\n}\n\n /**\n  * A preprocessing layer which randomly varies image width during training.\n  *\n  * This layer will randomly adjusts the width of a batch of images of a batch\n  * of images by a random factor.\n  *\n  * The input should be a 3D (unbatched) or 4D (batched) tensor in\n  * the `\"channels_last\"` image data format. Input pixel values can be of any\n  * range (e.g. `[0., 1.)` or `[0, 255]`) and of integer or floating point\n  * dtype. By default, the layer will output floats. By default, this layer is\n  * inactive during inference. For an overview and full list of preprocessing\n  * layers, see the preprocessing [guide]\n  * (https://www.tensorflow.org/guide/keras/preprocessing_layers).\n  *\n  * Arguments:\n  *\n  * factor:\n  *   A positive float (fraction of original width), or a tuple of size 2\n  *   representing lower and upper bound for resizing vertically.\n  *   When represented as a single float, this value is used for both the upper\n  *   and lower bound. For instance, `factor=(0.2, 0.3)` results in an output\n  *   with width changed by a random amount in the range `[20%, 30%]`.\n  *   `factor=(-0.2, 0.3)` results in an output with width changed by a random\n  *   amount in the range `[-20%, +30%]`. `factor=0.2` results in an output\n  *   with width changed by a random amount in the range `[-20%, +20%]`.\n  * interpolation:\n  *   String, the interpolation method.\n  *   Defaults to `bilinear`.\n  *   Supports `\"bilinear\"`, `\"nearest\"`.\n  *   The tf methods `\"bicubic\"`, `\"area\"`, `\"lanczos3\"`, `\"lanczos5\"`,\n  *   `\"gaussian\"`, `\"mitchellcubic\"` are unimplemented in tfjs.\n  * seed:\n  *   Integer. Used to create a random seed.\n  *\n  * Input shape:\n  *     3D (unbatched) or 4D (batched) tensor with shape:\n  *     `(..., height, width, channels)`, in `\"channels_last\"` format.\n  * Output shape:\n  *     3D (unbatched) or 4D (batched) tensor with shape:\n  *     `(..., height, random_width, channels)`.\n  *\n  *\n  * @doc {heading: 'Layers', subheading: 'RandomWidth', namespace: 'layers'}\n  */\n  export function randomWidth(args: RandomWidthArgs) {\n    return new RandomWidth(args);\n  }\n"]}
|
