Creates a tf.Tensor with the provided values, shape and dtype.

// Pass an array of values to create a vector.
tf.tensor([1, 2, 3, 4]).print();

// Pass a nested array of values to make a matrix or a higher
// dimensional tensor.
tf.tensor([[1, 2], [3, 4]]).print();

// Pass a flat array and specify a shape yourself.
tf.tensor([1, 2, 3, 4], [2, 2]).print();

Creates rank-0 tf.Tensor (scalar) with the provided value and dtype.

The same functionality can be achieved with tf.tensor(), but in general we recommend using tf.scalar() as it makes the code more readable.

tf.scalar(3.14).print();

Creates rank-1 tf.Tensor with the provided values, shape and dtype.

The same functionality can be achieved with tf.tensor(), but in general we recommend using tf.tensor1d() as it makes the code more readable.

tf.tensor1d([1, 2, 3]).print();

Creates rank-2 tf.Tensor with the provided values, shape and dtype.

The same functionality can be achieved with tf.tensor(), but in general we recommend using tf.tensor2d() as it makes the code more readable.

// Pass a nested array.
tf.tensor2d([[1, 2], [3, 4]]).print();

// Pass a flat array and specify a shape.
tf.tensor2d([1, 2, 3, 4], [2, 2]).print();

Creates rank-3 tf.Tensor with the provided values, shape and dtype.

The same functionality can be achieved with tf.tensor(), but in general we recommend using tf.tensor3d() as it makes the code more readable.

// Pass a nested array.
tf.tensor3d([[[1], [2]], [[3], [4]]]).print();

// Pass a flat array and specify a shape.
tf.tensor3d([1, 2, 3, 4], [2, 2, 1]).print();

Creates rank-4 tf.Tensor with the provided values, shape and dtype.

The same functionality can be achieved with tf.tensor(), but in general we recommend using tf.tensor4d() as it makes the code more readable.

// Pass a nested array.
tf.tensor4d([[[[1], [2]], [[3], [4]]]]).print();

// Pass a flat array and specify a shape.
tf.tensor4d([1, 2, 3, 4], [1, 2, 2, 1]).print();

Creates rank-5 tf.Tensor with the provided values, shape and dtype.

The same functionality can be achieved with tf.tensor(), but in general we recommend using tf.tensor5d() as it makes the code more readable.

// Pass a nested array.
tf.tensor5d([[[[[1], [2]], [[3], [4]]]]]).print();

// Pass a flat array and specify a shape.
tf.tensor5d([1, 2, 3, 4, 5, 6, 7, 8], [1, 2, 2, 2, 1]).print();

Creates rank-6 tf.Tensor with the provided values, shape and dtype.

The same functionality can be achieved with tf.tensor(), but in general we recommend using tf.tensor6d() as it makes the code more readable.

// Pass a nested array.
tf.tensor6d([[[[[[1],[2]],[[3],[4]]],[[[5],[6]],[[7],[8]]]]]]).print();

// Pass a flat array and specify a shape.
tf.tensor6d([1, 2, 3, 4, 5, 6, 7, 8], [1, 1, 2, 2, 2, 1]).print();

Creates an empty tf.TensorBuffer with the specified shape and dtype.

The values are stored in CPU as TypedArray. Fill the buffer using buffer.set(), or by modifying directly buffer.values.

When done, call buffer.toTensor() to get an immutable tf.Tensor with those values.

// Create a buffer and set values at particular indices.
const buffer = tf.buffer([2, 2]);
buffer.set(3, 0, 0);
buffer.set(5, 1, 0);

// Convert the buffer back to a tensor.
buffer.toTensor().print();

Creates a new tensor with the same values and shape as the specified tensor.

const x = tf.tensor([1, 2]);

x.clone().print();

Converts two real numbers to a complex number.

Given a tensor real representing the real part of a complex number, and a tensor imag representing the imaginary part of a complex number, this operation returns complex numbers elementwise of the form [r0, i0, r1, i1], where r represents the real part and i represents the imag part.

The input tensors real and imag must have the same shape.

const real = tf.tensor1d([2.25, 3.25]);
const imag = tf.tensor1d([4.75, 5.75]);
const complex = tf.complex(real, imag);

complex.print();

Create an identity matrix.

Creates a tf.Tensor filled with a scalar value.

tf.fill([2, 2], 4).print();

Returns the imaginary part of a complex (or real) tensor.

Given a tensor input, this operation returns a tensor of type float that is the imaginary part of each element in input considered as a complex number. If input is real, a tensor of all zeros is returned.

const x = tf.complex([-2.25, 3.25], [4.75, 5.75]);
tf.imag(x).print();

Return an evenly spaced sequence of numbers over the given interval.

tf.linspace(0, 9, 10).print();

Creates a one-hot tf.Tensor. The locations represented by indices take value onValue (defaults to 1), while all other locations take value offValue (defaults to 0). If indices is rank R, the output has rank R+1 with the last axis of size depth.

tf.oneHot(tf.tensor1d([0, 1], 'int32'), 3).print();

Creates a tf.Tensor with all elements set to 1.

tf.ones([2, 2]).print();

Creates a tf.Tensor with all elements set to 1 with the same shape as the given tensor.

const x = tf.tensor([1, 2]);
tf.onesLike(x).print();

Prints information about the tf.Tensor including its data.

const verbose = true;
tf.tensor2d([1, 2, 3, 4], [2, 2]).print(verbose);

Creates a new tf.Tensor1D filled with the numbers in the range provided.

The tensor is a is half-open interval meaning it includes start, but excludes stop. Decrementing ranges and negative step values are also supported.

tf.range(0, 9, 2).print();

Returns the real part of a complex (or real) tensor.

Given a tensor input, this operation returns a tensor of type float that is the real part of each element in input considered as a complex number.

If the input is real, it simply makes a clone.

const x = tf.complex([-2.25, 3.25], [4.75, 5.75]);
tf.real(x).print();

Creates a tf.Tensor with values sampled from a truncated normal distribution.

tf.truncatedNormal([2, 2]).print();

The generated values follow a normal distribution with specified mean and standard deviation, except that values whose magnitude is more than 2 standard deviations from the mean are dropped and re-picked.

Creates a new variable with the provided initial value.

const x = tf.variable(tf.tensor([1, 2, 3]));
x.assign(tf.tensor([4, 5, 6]));

x.print();

Creates a tf.Tensor with all elements set to 0.

tf.zeros([2, 2]).print();

Creates a tf.Tensor with all elements set to 0 with the same shape as the given tensor.

const x = tf.tensor([1, 2]);
tf.zerosLike(x).print();

This operation reshapes the "batch" dimension 0 into M + 1 dimensions of shape blockShape + [batch], interleaves these blocks back into the grid defined by the spatial dimensions [1, ..., M], to obtain a result with the same rank as the input. The spatial dimensions of this intermediate result are then optionally cropped according to crops to produce the output. This is the reverse of tf.spaceToBatchND(). See below for a precise description.

const x = tf.tensor4d([1, 2, 3, 4], [4, 1, 1, 1]);
const blockShape = [2, 2];
const crops = [[0, 0], [0, 0]];

x.batchToSpaceND(blockShape, crops).print();

Casts a tf.Tensor to a new dtype.

const x = tf.tensor1d([1.5, 2.5, 3]);
tf.cast(x, 'int32').print();

Rearranges data from depth into blocks of spatial data. More specifically, this op outputs a copy of the input tensor where values from the depth dimension are moved in spatial blocks to the height and width dimensions. The attr blockSize indicates the input block size and how the data is moved.

• Chunks of data of size blockSize * blockSize from depth are rearranged into non-overlapping blocks of size blockSize x blockSize

• The width the output tensor is inputWidth * blockSize, whereas the height is inputHeight * blockSize

• The Y, X coordinates within each block of the output image are determined by the high order component of the input channel index

• The depth of the input tensor must be divisible by blockSize * blockSize

The dataFormat attr specifies the layout of the input and output tensors with the following options: "NHWC": [ batch, height, width, channels ] "NCHW": [ batch, channels, height, width ]

const x = tf.tensor4d([1, 2, 3, 4], [1, 1, 1, 4]);
const blockSize = 2;
const dataFormat = "NHWC";

tf.depthToSpace(x, blockSize, dataFormat).print();

Returns a tf.Tensor that has expanded rank, by inserting a dimension into the tensor's shape.

const x = tf.tensor1d([1, 2, 3, 4]);
const axis = 1;
x.expandDims(axis).print();

Pads a tf.Tensor with a given value and paddings.

This operation currently only implements the CONSTANT mode.

Also available are stricter rank-specific methods with the same signature as this method that assert that paddings is of given length.

• tf.pad1d
• tf.pad2d
• tf.pad3d
• tf.pad4d

const x = tf.tensor1d([1, 2, 3, 4]);
x.pad([[1, 2]]).print();

Reshapes a tf.Tensor to a given shape.

Given an input tensor, returns a new tensor with the same values as the input tensor with shape shape.

If one component of shape is the special value -1, the size of that dimension is computed so that the total size remains constant. In particular, a shape of [-1] flattens into 1-D. At most one component of shape can be -1.

If shape is 1-D or higher, then the operation returns a tensor with shape shape filled with the values of tensor. In this case, the number of elements implied by shape must be the same as the number of elements in tensor.

const x = tf.tensor1d([1, 2, 3, 4]);
x.reshape([2, 2]).print();

Computes the difference between two lists of numbers.

Given a Tensor x and a Tensor y, this operation returns a Tensor out that represents all values that are in x but not in y. The returned Tensor out is sorted in the same order that the numbers appear in x (duplicates are preserved). This operation also returns a Tensor indices that represents the position of each out element in x. In other words:

out[i] = x[idx[i]] for i in [0, 1, ..., out.length - 1]

const x = [1, 2, 3, 4, 5, 6];
const y = [1, 3, 5];

const [out, indices] = await tf.setdiff1dAsync(x, y);
out.print(); // [2, 4, 6]
indices.print(); // [1, 3, 5]

This operation divides "spatial" dimensions [1, ..., M] of the input into a grid of blocks of shape blockShape, and interleaves these blocks with the "batch" dimension (0) such that in the output, the spatial dimensions [1, ..., M] correspond to the position within the grid, and the batch dimension combines both the position within a spatial block and the original batch position. Prior to division into blocks, the spatial dimensions of the input are optionally zero padded according to paddings. See below for a precise description.

const x = tf.tensor4d([1, 2, 3, 4], [1, 2, 2, 1]);
const blockShape = [2, 2];
const paddings = [[0, 0], [0, 0]];

x.spaceToBatchND(blockShape, paddings).print();

Removes dimensions of size 1 from the shape of a tf.Tensor.

const x = tf.tensor([1, 2, 3, 4], [1, 1, 4]);
x.squeeze().print();

Concatenates a list of tf.Tensors along a given axis.

The tensors ranks and types must match, and their sizes must match in all dimensions except axis.

Also available are stricter rank-specific methods that assert that tensors are of the given rank:

• tf.concat1d
• tf.concat2d
• tf.concat3d
• tf.concat4d

Except tf.concat1d (which does not have axis param), all methods have same signature as this method.

const a = tf.tensor1d([1, 2]);
const b = tf.tensor1d([3, 4]);
a.concat(b).print();  // or a.concat(b)

const a = tf.tensor1d([1, 2]);
const b = tf.tensor1d([3, 4]);
const c = tf.tensor1d([5, 6]);
tf.concat([a, b, c]).print();

const a = tf.tensor2d([[1, 2], [10, 20]]);
const b = tf.tensor2d([[3, 4], [30, 40]]);
const axis = 1;
tf.concat([a, b], axis).print();

Gather slices from tensor x's axis axis according to indices.

const x = tf.tensor1d([1, 2, 3, 4]);
const indices = tf.tensor1d([1, 3, 3], 'int32');

x.gather(indices).print();

const x = tf.tensor2d([1, 2, 3, 4], [2, 2]);
const indices = tf.tensor1d([1, 1, 0], 'int32');

x.gather(indices).print();

Reverses a tf.Tensor along a specified axis.

Also available are stricter rank-specific methods that assert that x is of the given rank:

• tf.reverse1d
• tf.reverse2d
• tf.reverse3d
• tf.reverse4d

Except tf.reverse1d (which does not have axis param), all methods have same signature as this method.

const x = tf.tensor1d([1, 2, 3, 4]);

x.reverse().print();

const x = tf.tensor2d([1, 2, 3, 4], [2, 2]);

const axis = 1;
x.reverse(axis).print();

Extracts a slice from a tf.Tensor starting at coordinates begin and is of size size.

Also available are stricter rank-specific methods with the same signature as this method that assert that x is of the given rank:

• tf.slice1d
• tf.slice2d
• tf.slice3d
• tf.slice4d

const x = tf.tensor1d([1, 2, 3, 4]);

x.slice([1], [2]).print();

const x = tf.tensor2d([1, 2, 3, 4], [2, 2]);

x.slice([1, 0], [1, 2]).print();

Splits a tf.Tensor into sub tensors.

If numOrSizeSplits is a number, splits x along dimension axis into numOrSizeSplits smaller tensors. Requires that numOrSizeSplits evenly divides x.shape[axis].

If numOrSizeSplits is a number array, splits x into numOrSizeSplits.length pieces. The shape of the i-th piece has the same size as x except along dimension axis where the size is numOrSizeSplits[i].

const x = tf.tensor2d([1, 2, 3, 4, 5, 6, 7, 8], [2, 4]);
const [a, b] = tf.split(x, 2, 1);
a.print();
b.print();

const [c, d, e] = tf.split(x, [1, 2, 1], 1);
c.print();
d.print();
e.print();

Stacks a list of rank-R tf.Tensors into one rank-(R+1) tf.Tensor.

const a = tf.tensor1d([1, 2]);
const b = tf.tensor1d([3, 4]);
const c = tf.tensor1d([5, 6]);
tf.stack([a, b, c]).print();

Construct a tensor by repeating it the number of times given by reps.

This operation creates a new tensor by replicating input reps times. The output tensor's i'th dimension has input.shape[i] * reps[i] elements, and the values of input are replicated reps[i] times along the i'th dimension. For example, tiling [a, b, c, d] by [2] produces [a, b, c, d, a, b, c, d].

const a = tf.tensor1d([1, 2]);

a.tile([2]).print();    // or a.tile([2])

const a = tf.tensor2d([1, 2, 3, 4], [2, 2]);

a.tile([1, 2]).print();  // or a.tile([1, 2])

Unstacks a tf.Tensor of rank-R into a list of rank-(R-1) tf.Tensors.

const a = tf.tensor2d([1, 2, 3, 4], [2, 2]);

tf.unstack(a).forEach(tensor => tensor.print());

Creates a tf.Tensor with values drawn from a multinomial distribution.

const probs = tf.tensor([.75, .25]);
tf.multinomial(probs, 3).print();

Creates a tf.Tensor with values sampled from a normal distribution.

tf.randomNormal([2, 2]).print();

Creates a tf.Tensor with values sampled from a uniform distribution.

The generated values follow a uniform distribution in the range [minval, maxval). The lower bound minval is included in the range, while the upper bound maxval is excluded.

tf.randomUniform([2, 2]).print();

Creates a tf.Sequential model. A sequential model is any model where the outputs of one layer are the inputs to the next layer, i.e. the model topology is a simple 'stack' of layers, with no branching or skipping.

This means that the first layer passed to a tf.Sequential model should have a defined input shape. What that means is that it should have received an inputShape or batchInputShape argument, or for some type of layers (recurrent, Dense...) an inputDim argument.

The key difference between tf.model() and tf.sequential() is that tf.sequential() is less generic, supporting only a linear stack of layers. tf.model() is more generic and supports an arbitrary graph (without cycles) of layers.

Examples:

const model = tf.sequential();

// First layer must have an input shape defined.
model.add(tf.layers.dense({units: 32, inputShape: [50]}));
// Afterwards, TF.js does automatic shape inference.
model.add(tf.layers.dense({units: 4}));

// Inspect the inferred shape of the model's output, which equals
// `[null, 4]`. The 1st dimension is the undetermined batch dimension; the
// 2nd is the output size of the model's last layer.
console.log(JSON.stringify(model.outputs[0].shape));

It is also possible to specify a batch size (with potentially undetermined batch dimension, denoted by "null") for the first layer using the batchInputShape key. The following example is equivalent to the above:

const model = tf.sequential();

// First layer must have a defined input shape
model.add(tf.layers.dense({units: 32, batchInputShape: [null, 50]}));
// Afterwards, TF.js does automatic shape inference.
model.add(tf.layers.dense({units: 4}));

// Inspect the inferred shape of the model's output.
console.log(JSON.stringify(model.outputs[0].shape));

You can also use an Array of already-constructed Layers to create a tf.Sequential model:

const model = tf.sequential({
   layers: [tf.layers.dense({units: 32, inputShape: [50]}),
            tf.layers.dense({units: 4})]
});
console.log(JSON.stringify(model.outputs[0].shape));

A model is a data structure that consists of Layers and defines inputs and outputs.

The key difference between tf.model() and tf.sequential() is that tf.model() is more generic, supporting an arbitrary graph (without cycles) of layers. tf.sequential() is less generic and supports only a linear stack of layers.

When creating a tf.LayersModel, specify its input(s) and output(s). Layers are used to wire input(s) to output(s).

For example, the following code snippet defines a model consisting of two dense layers, with 10 and 4 units, respectively.

// Define input, which has a size of 5 (not including batch dimension).
const input = tf.input({shape: [5]});

// First dense layer uses relu activation.
const denseLayer1 = tf.layers.dense({units: 10, activation: 'relu'});
// Second dense layer uses softmax activation.
const denseLayer2 = tf.layers.dense({units: 4, activation: 'softmax'});

// Obtain the output symbolic tensor by applying the layers on the input.
const output = denseLayer2.apply(denseLayer1.apply(input));

// Create the model based on the inputs.
const model = tf.model({inputs: input, outputs: output});

// The model can be used for training, evaluation and prediction.
// For example, the following line runs prediction with the model on
// some fake data.
model.predict(tf.ones([2, 5])).print();

See also: tf.sequential(), tf.loadLayersModel().

Used to instantiate an input to a model as a tf.SymbolicTensor.

Users should call the input factory function for consistency with other generator functions.

Example:

// Defines a simple logistic regression model with 32 dimensional input
// and 3 dimensional output.
const x = tf.input({shape: [32]});
const y = tf.layers.dense({units: 3, activation: 'softmax'}).apply(x);
const model = tf.LayersModel({inputs: x, outputs: y});
model.predict(tf.ones([2, 32])).print();

Note: input is only necessary when using model. When using sequential, specify inputShape for the first layer or use inputLayer as the first layer.

Load a graph model given a URL to the model definition.

Example of loading MobileNetV2 from a URL and making a prediction with a zeros input:

const modelUrl =
    'https://storage.googleapis.com/tfjs-models/savedmodel/mobilenet_v2_1.0_224/model.json';
const model = await tf.loadGraphModel(modelUrl);
const zeros = tf.zeros([1, 224, 224, 3]);
model.predict(zeros).print();

Example of loading MobileNetV2 from a TF Hub URL and making a prediction with a zeros input:

const modelUrl =
    'https://tfhub.dev/google/imagenet/mobilenet_v2_140_224/classification/2';
const model = await tf.loadGraphModel(modelUrl, {fromTFHub: true});
const zeros = tf.zeros([1, 224, 224, 3]);
model.predict(zeros).print();

Load a model composed of Layer objects, including its topology and optionally weights. See the Tutorial named "How to import a Keras Model" for usage examples.

This method is applicable to:

1. Models created with the tf.layers.*, tf.sequential(), and tf.model() APIs of TensorFlow.js and later saved with the tf.LayersModel.save() method.
2. Models converted from Keras or TensorFlow tf.keras using the tensorflowjs_converter

This mode is not applicable to TensorFlow SavedModels or their converted forms. For those models, use tf.loadGraphModel().

Example 1. Load a model from an HTTP server.

const model = await tf.loadLayersModel(
     'https://storage.googleapis.com/tfjs-models/tfjs/iris_v1/model.json');
model.summary();

Example 2: Save model's topology and weights to browser local storage; then load it back.

const model = tf.sequential(
     {layers: [tf.layers.dense({units: 1, inputShape: [3]})]});
console.log('Prediction from original model:');
model.predict(tf.ones([1, 3])).print();

const saveResults = await model.save('localstorage://my-model-1');

const loadedModel = await tf.loadLayersModel('localstorage://my-model-1');
console.log('Prediction from loaded model:');
loadedModel.predict(tf.ones([1, 3])).print();

Example 3. Saving model's topology and weights to browser IndexedDB; then load it back.

const model = tf.sequential(
     {layers: [tf.layers.dense({units: 1, inputShape: [3]})]});
console.log('Prediction from original model:');
model.predict(tf.ones([1, 3])).print();

const saveResults = await model.save('indexeddb://my-model-1');

const loadedModel = await tf.loadLayersModel('indexeddb://my-model-1');
console.log('Prediction from loaded model:');
loadedModel.predict(tf.ones([1, 3])).print();

Example 4. Load a model from user-selected files from HTML file input elements.

// Note: this code snippet will not work without the HTML elements in the
//   page
const jsonUpload = document.getElementById('json-upload');
const weightsUpload = document.getElementById('weights-upload');

const model = await tf.loadLayersModel(
     tf.io.browserFiles([jsonUpload.files[0], weightsUpload.files[0]]));

Creates an IOHandler that triggers file downloads from the browser.

The returned IOHandler instance can be used as model exporting methods such as tf.Model.save and supports only saving.

const model = tf.sequential();
model.add(tf.layers.dense(
     {units: 1, inputShape: [10], activation: 'sigmoid'}));
const saveResult = await model.save('downloads://mymodel'));
// This will trigger downloading of two files:
//   'mymodel.json' and 'mymodel.weights.bin'.
console.log(saveResult);

Creates an IOHandler that loads model artifacts from user-selected files.

This method can be used for loading from files such as user-selected files in the browser. When used in conjunction with tf.loadModel, an instance of tf.Model (Keras-style) can be constructed from the loaded artifacts.

// Note: This code snippet won't run properly without the actual file input
//   elements in the HTML DOM.

// Suppose there are two HTML file input (`<input type="file" ...>`)
// elements.
const uploadJSONInput = document.getElementById('upload-json');
const uploadWeightsInput = document.getElementById('upload-weights');
const model = await tfl.loadModel(tf.io.browserFiles(
     [uploadJSONInput.files[0], uploadWeightsInput.files[0]]));

Copy a model from one URL to another.

This function supports:

1. Copying within a storage medium, e.g., tf.io.copyModel('localstorage://model-1', 'localstorage://model-2')
2. Copying between two storage mediums, e.g., tf.io.copyModel('localstorage://model-1', 'indexeddb://model-1')

// First create and save a model.
const model = tf.sequential();
model.add(tf.layers.dense(
     {units: 1, inputShape: [10], activation: 'sigmoid'}));
await model.save('localstorage://demo/management/model1');

// Then list existing models.
console.log(JSON.stringify(await tf.io.listModels()));

// Copy the model, from Local Storage to IndexedDB.
await tf.io.copyModel(
     'localstorage://demo/management/model1',
     'indexeddb://demo/management/model1');

// List models again.
console.log(JSON.stringify(await tf.io.listModels()));

// Remove both models.
await tf.io.removeModel('localstorage://demo/management/model1');
await tf.io.removeModel('indexeddb://demo/management/model1');

List all models stored in registered storage mediums.

For a web browser environment, the registered mediums are Local Storage and IndexedDB.

// First create and save a model.
const model = tf.sequential();
model.add(tf.layers.dense(
     {units: 1, inputShape: [10], activation: 'sigmoid'}));
await model.save('localstorage://demo/management/model1');

// Then list existing models.
console.log(JSON.stringify(await tf.io.listModels()));

// Delete the model.
await tf.io.removeModel('localstorage://demo/management/model1');

// List models again.
console.log(JSON.stringify(await tf.io.listModels()));

Move a model from one URL to another.

This function supports:

1. Moving within a storage medium, e.g., tf.io.moveModel('localstorage://model-1', 'localstorage://model-2')
2. Moving between two storage mediums, e.g., tf.io.moveModel('localstorage://model-1', 'indexeddb://model-1')

// First create and save a model.
const model = tf.sequential();
model.add(tf.layers.dense(
     {units: 1, inputShape: [10], activation: 'sigmoid'}));
await model.save('localstorage://demo/management/model1');

// Then list existing models.
console.log(JSON.stringify(await tf.io.listModels()));

// Move the model, from Local Storage to IndexedDB.
await tf.io.moveModel(
     'localstorage://demo/management/model1',
     'indexeddb://demo/management/model1');

// List models again.
console.log(JSON.stringify(await tf.io.listModels()));

// Remove the moved model.
await tf.io.removeModel('indexeddb://demo/management/model1');

Remove a model specified by URL from a reigstered storage medium.

// First create and save a model.
const model = tf.sequential();
model.add(tf.layers.dense(
     {units: 1, inputShape: [10], activation: 'sigmoid'}));
await model.save('localstorage://demo/management/model1');

// Then list existing models.
console.log(JSON.stringify(await tf.io.listModels()));

// Delete the model.
await tf.io.removeModel('localstorage://demo/management/model1');

// List models again.
console.log(JSON.stringify(await tf.io.listModels()));

Register a class with the serialization map of TensorFlow.js.

This is often used for registering custom Layers, so they can be serialized and deserialized.

Example:

class MyCustomLayer extends tf.layers.Layer {
   static className = 'MyCustomLayer';

   constructor(config) {
     super(config);
   }
}
tf.serialization.registerClass(MyCustomLayer);

Exponetial 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)

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.

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.

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.

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.

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

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:

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.LayersModel({
     inputs: input,
     outputs: [denseOutput, activationOutput]
});

// Collect both outputs and print separately.
const [denseOut, activationOut] = model.predict(tf.randomNormal([6, 5]));
denseOut.print();
activationOut.print();

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.

Applies dropout 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.

Maps positive integers (indices) into dense vectors of fixed size. eg. [[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].

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:

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));

Permutes the dimensions of the input according to a given pattern.

Useful for, e.g., connecting RNNs and convnets together.

Example:

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 othe 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.

Repeats the input n times in a new dimension.

  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 see
  model.predict(x).print();
  // output shape is now [batch, 2, 4]

Reshapes an input to a certain shape.

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 ReshapeLayerConfig field input_shape when using this layer as the first layer in a model.

Output shape: [batchSize, targetShape[0], targetShape[1], ..., targetShape[targetShape.length - 1]].

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.

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'.

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
• Deconvolutional Networks

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

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]

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 depthMultplier argument controls how many output channels are generated per input channel in the depthwise step.

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.