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

// Pass a `WebGLData` object and specify a shape yourself.

// This makes it possible for TF.js applications to avoid GPU / CPU sync.
// For example, if your application includes a preprocessing step on the GPU,
// you could upload the GPU output directly to TF.js, rather than first
// downloading the values.

// Example for WebGL2:
if (tf.findBackend('custom-webgl') == null) {
   const customCanvas = document.createElement('canvas');
   const customBackend = new tf.MathBackendWebGL(customCanvas);
   tf.registerBackend('custom-webgl', () => customBackend);
}
const savedBackend = tf.getBackend();
await tf.setBackend('custom-webgl');
const gl = tf.backend().gpgpu.gl;
const texture = gl.createTexture();
const tex2d = gl.TEXTURE_2D;
const width = 2;
const height = 2;

gl.bindTexture(tex2d, texture);
gl.texParameteri(tex2d, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
gl.texParameteri(tex2d, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
gl.texParameteri(tex2d, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(tex2d, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
gl.texImage2D(
   tex2d, 0, gl.RGBA32F, // internalFormat
   width, height, 0,
   gl.RGBA, // textureFormat
   gl.FLOAT, // textureType
   new Float32Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
);

// Currently, the `texture` has 4 pixels:
// Pixel0 is {R:0, G:1, B:2, A:3}
// Pixel1 is {R:4, G:5, B:6, A:7}
// Pixel2 is {R:8, G:9, B:10, A:11}
// Pixel3 is {R:12, G:13, B:14, A:15}

const logicalShape = [height * width * 2];
const a = tf.tensor({texture, height, width, channels: 'BR'}, logicalShape);
a.print();
// Tensor value will be [2, 0, 6, 4, 10, 8, 14, 12], since [2, 0] is the
// values of 'B' and 'R' channels of Pixel0, [6, 4] is the values of 'B' and
'R'
// channels of Pixel1...

// For postprocessing on the GPU, it's possible to retrieve the texture
// backing any tensor by calling the tensor's `dataToGPU` method like
// so:

const tex = a.dataToGPU();
await tf.setBackend(savedBackend);

// Pass a `WebGPUData` object and specify a shape yourself.

// This makes it possible for TF.js applications to avoid GPU / CPU sync.
// For example, if your application includes a preprocessing step on the GPU,
// you could upload the GPU output directly to TF.js, rather than first
// downloading the values. Unlike WebGL, this optionally supports zero copy
// by WebGPUData.zeroCopy. When zeroCopy is false or undefined(default), this
// passing GPUBuffer can be destroyed after tensor is created. When zeroCopy
// is true, this GPUBuffer is bound directly by the tensor, so do not destroy
// this GPUBuffer until all access is done.

// Example for WebGPU:
function createGPUBufferFromData(device, data, dtype) {
   const bytesPerElement = 4;
   const sizeInBytes = data.length * bytesPerElement;

   const gpuWriteBuffer = device.createBuffer({
     mappedAtCreation: true,
     size: sizeInBytes,
     usage: GPUBufferUsage.MAP_WRITE | GPUBufferUsage.COPY_SRC
   });
   const arrayBuffer = gpuWriteBuffer.getMappedRange();
   if (dtype === 'float32') {
     new Float32Array(arrayBuffer).set(data);
   } else if (dtype === 'int32') {
     new Int32Array(arrayBuffer).set(data);
   } else {
     throw new Error(
         `Creating tensor from GPUBuffer only supports` +
         `'float32'|'int32' dtype, while the dtype is ${dtype}.`);
   }
   gpuWriteBuffer.unmap();

   const gpuReadBuffer = device.createBuffer({
     mappedAtCreation: false,
     size: sizeInBytes,
     usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE |
         GPUBufferUsage.COPY_SRC
   });

   const copyEncoder = device.createCommandEncoder();
   copyEncoder.copyBufferToBuffer(
       gpuWriteBuffer, 0, gpuReadBuffer, 0, sizeInBytes);
   const copyCommands = copyEncoder.finish();
   device.queue.submit([copyCommands]);
   gpuWriteBuffer.destroy();
   return gpuReadBuffer;
}

const savedBackend = tf.getBackend();
await tf.setBackend('webgpu').catch(
     () => {throw new Error(
         'Failed to use WebGPU backend. Please use Chrome Canary to run.')});
const dtype = 'float32';
const device = tf.backend().device;
const aData = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
const bData = [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4];
const expected = [2, 4, 6, 8, 6, 8, 10, 12, 10, 12, 14, 16, 14, 16, 18, 20];
const aBuffer = createGPUBufferFromData(device, aData, dtype);
const shape = [aData.length];
// To use zeroCopy, use {buffer: aBuffer, zeroCopy: true} instead and destroy
// aBuffer untill all access is done.
const a = tf.tensor({buffer: aBuffer}, shape, dtype);
const b = tf.tensor(bData, shape, dtype);
const result = tf.add(a, b);
result.print();
a.dispose();
b.dispose();
result.dispose();
aBuffer.destroy();
await tf.setBackend(savedBackend);

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]]],[[[5],[6]],[[7],[8]]]]]).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();

Returns a diagonal tensor with given diagonal values.

Given a diagonal, this operation returns a tensor with the diagonal and everything else padded with zeros.

Assume the input has dimensions [D1,..., Dk], then the output is a tensor of rank 2k with dimensions [D1,..., Dk, D1,..., Dk]

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

tf.diag(x).print()

const x = tf.tensor2d([1, 2, 3, 4, 5, 6, 7, 8], [4, 2])

tf.diag(x).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. indices used to encode prediction class must start from 0. For example, if you have 3 classes of data, class 1 should be encoded as 0, class 2 should be 1, and class 3 should be 2.

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

Return the shape of s0 op s1 with broadcast.

compute r0, the broadcasted shape as a tensor. s0, s1 and r0 are all integer vectors.

This function returns the shape of the result of an operation between two tensors of size s0 and s1 performed with broadcast.

Broadcast an array to a compatible shape NumPy-style.

The tensor's shape is compared to the broadcast shape from end to beginning. Ones are prepended to the tensor's shape until it has the same length as the broadcast shape. If input.shape[i]==shape[i], the (i+1)-th axis is already broadcast-compatible. If input.shape[i]==1 and shape[i]==N, then the input tensor is tiled N times along that axis (using tf.tile).

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

Checks the input tensor mathes the given shape.

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

The method supports the null value in tensor. It will still check the shapes, and null is a placeholder.

const x = tf.tensor1d([1, 2, 3, 4]);
const y = tf.tensor1d([1, null, 3, 4]);
const z = tf.tensor2d([1, 2, 3, 4], [2,2]);
tf.ensureShape(x, [4]).print();
tf.ensureShape(y, [4]).print();
tf.ensureShape(z, [null, 2]).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 using mirror padding.

This operation implements the REFLECT and SYMMETRIC modes of pad.

const x = tf.range(0, 9).reshape([1, 1, 3, 3]);
x.mirrorPad([[0, 0], [0, 0], [2, 2], [2, 2]], 'reflect').print();

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

This operation implements CONSTANT mode. For REFLECT and SYMMETRIC, refer to tf.mirrorPad().

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

Apply boolean mask to tensor.

const tensor = tf.tensor2d([1, 2, 3, 4, 5, 6], [3, 2]);
const mask = tf.tensor1d([1, 0, 1], 'bool');
const result = await tf.booleanMaskAsync(tensor, mask);
result.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 ith dimension has input.shape[i] * reps[i] elements, and the values of input are replicated reps[i] times along the ith 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 tf.tile(a, [2])

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

a.tile([1, 2]).print();  // or tf.tile(a, [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());

Tensor contraction over specified indices and outer product.

einsum allows defining Tensors by defining their element-wise computation. This computation is based on Einstein summation.

Some special cases include:

Matrix multiplication:

const x = tf.tensor2d([[1, 2, 3], [4, 5, 6]]);
const y = tf.tensor2d([[0, 1], [2, 3], [4, 5]]);
x.print();
y.print();
tf.einsum('ij,jk->ik', x, y).print();

Dot product:

const x = tf.tensor1d([1, 2, 3]);
const y = tf.tensor1d([0, 1, 2]);
x.print();
y.print();
tf.einsum('i,i->', x, y).print();

Batch dot product:

const x = tf.tensor2d([[1, 2, 3], [4, 5, 6]]);
const y = tf.tensor2d([[0, 1, 2], [3, 4, 5]]);
x.print();
y.print();
tf.einsum('bi,bi->b', x, y).print();

Outer prouduct:

const x = tf.tensor1d([1, 3, 5]);
const y = tf.tensor1d([2, 4, 6]);
x.print();
y.print();
tf.einsum('i,j->ij', x, y).print();

Matrix transpose:

const x = tf.tensor2d([[1, 2], [3, 4]]);
x.print();
tf.einsum('ij->ji', x).print();

Batch matrix transpose:

const x = tf.tensor3d([[[1, 2], [3, 4]], [[-1, -2], [-3, -4]]]);
x.print();
tf.einsum('bij->bji', x).print();

Limitations:

This implementation of einsum has the following limitations:

• Does not support >2 input tensors.
• Does not support duplicate axes for any given input tensor. E.g., equation 'ii->' is not supported.
• The ... notation is not supported.

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 random number generator function defined by the user.

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

tf.randomGamma([2, 2], 1).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 normal distribution.

The generated values will have mean 0 and standard deviation 1.

tf.randomStandardNormal([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.Tensor with integers sampled from a uniform distribution.

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

tf.randomUniformInt([2, 2], 0, 10).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.model({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.loadLayersModel(), an instance of tf.LayersModel (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 tf.loadLayersModel(tf.io.browserFiles(
     [uploadJSONInput.files[0], uploadWeightsInput.files[0]]));

Creates an IOHandler subtype that sends model artifacts to HTTP server.

An HTTP request of the multipart/form-data mime type will be sent to the path URL. The form data includes artifacts that represent the topology and/or weights of the model. In the case of Keras-style tf.Model, two blobs (files) exist in form-data:

• A JSON file consisting of modelTopology and weightsManifest.
• A binary weights file consisting of the concatenated weight values. These files are in the same format as the one generated by tfjs_converter.

The following code snippet exemplifies the client-side code that uses this function:

const model = tf.sequential();
model.add(
     tf.layers.dense({units: 1, inputShape: [100], activation: 'sigmoid'}));

const saveResult = await model.save(tf.io.http(
     'http://model-server:5000/upload', {requestInit: {method: 'PUT'}}));
console.log(saveResult);

If the default POST method is to be used, without any custom parameters such as headers, you can simply pass an HTTP or HTTPS URL to model.save:

const saveResult = await model.save('http://model-server:5000/upload');

The following GitHub Gist https://gist.github.com/dsmilkov/1b6046fd6132d7408d5257b0976f7864 implements a server based on flask that can receive the request. Upon receiving the model artifacts via the request, this particular server reconstitutes instances of Keras Models in memory.

Load a graph model given a synchronous IO handler with a 'load' method.

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 registered 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 1. Register the class without package name and specified name.

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

   constructor(config) {
     super(config);
   }
}
tf.serialization.registerClass(MyCustomLayer);
console.log(tf.serialization.GLOBALCUSTOMOBJECT.get("Custom>MyCustomLayer"));
console.log(tf.serialization.GLOBALCUSTOMNAMES.get(MyCustomLayer));

Example 2. Register the class with package name: "Package" and specified name: "MyLayer".

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

   constructor(config) {
     super(config);
   }
}
tf.serialization.registerClass(MyCustomLayer, "Package", "MyLayer");
console.log(tf.serialization.GLOBALCUSTOMOBJECT.get("Package>MyLayer"));
console.log(tf.serialization.GLOBALCUSTOMNAMES.get(MyCustomLayer));

Example 3. Register the class with specified name: "MyLayer".

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

   constructor(config) {
     super(config);
   }
}
tf.serialization.registerClass(MyCustomLayer, undefined, "MyLayer");
console.log(tf.serialization.GLOBALCUSTOMOBJECT.get("Custom>MyLayer"));
console.log(tf.serialization.GLOBALCUSTOMNAMES.get(MyCustomLayer));

Example 4. Register the class with specified package name: "Package".

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

   constructor(config) {
     super(config);
   }
}
tf.serialization.registerClass(MyCustomLayer, "Package");
console.log(tf.serialization.GLOBALCUSTOMOBJECT
.get("Package>MyCustomLayer"));
console.log(tf.serialization.GLOBALCUSTOMNAMES
.get(MyCustomLayer));

Deregister the Op for graph model executor.

Retrieve the OpMapper object for the registered op.

Register an Op for graph model executor. This allows you to register TensorFlow custom op or override existing op.

Here is an example of registering a new MatMul Op.

const customMatmul = (node) =>
    tf.matMul(
        node.inputs[0], node.inputs[1],
        node.attrs['transpose_a'], node.attrs['transpose_b']);

tf.registerOp('MatMul', customMatmul);

The inputs and attrs of the node object are based on the TensorFlow op registry.

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)

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.