TensorFlow.js

https://js.tensorflow.org/api/latest
Admin
TensorFlow.js is a library for machine learning in JavaScript, enabling developers to build, train,...
Tokens:113,679
Snippets:951
Trust Score:9.9
Update:2 months ago
Show doc for...
Tokens:
Raw
### tf.backend()

Source: https://js.tensorflow.org/api/latest

Gets the current backend. If no backends have been initialized, this will attempt to initialize the best backend.

```APIDOC
## tf.backend()

### Description
Gets the current backend. If no backends have been initialized, this will attempt to initialize the best backend. Will throw an error if the highest priority backend has async initialization, in which case you should call 'await tf.ready()' before running other code.

### Returns
- **KernelBackend** - The current backend instance.
```

--------------------------------

### Create Tensors with tf.tensor

Source: https://js.tensorflow.org/api/latest

Examples of creating vectors, matrices, and shaped tensors using tf.tensor.

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

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

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

--------------------------------

### tf.ready()

Source: https://js.tensorflow.org/api/latest

Returns a promise that resolves when the currently selected backend has initialized.

```APIDOC
## tf.ready()

### Description
Returns a promise that resolves when the currently selected backend (or the highest priority one) has initialized. Await this promise when you are using a backend that has async initialization.

### Returns
- **Promise<void>**
```

--------------------------------

### tf.range(start, stop, step?, dtype?)

Source: https://js.tensorflow.org/api/latest

Creates a tensor containing a range of numbers.

```APIDOC
## tf.range(start, stop, step?, dtype?)

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

### Parameters
- **start** (number) - Required - An integer start value.
- **stop** (number) - Required - An integer stop value.
- **step** (number) - Optional - An integer increment.
- **dtype** ('float32'|'int32') - Optional - The data type of the output tensor.

### Returns
- **tf.Tensor1D**
```

--------------------------------

### Initialize and apply a GRU layer

Source: https://js.tensorflow.org/api/latest

Demonstrates how to instantiate a GRU layer with returnSequences enabled and apply it to a 3D input tensor representing a sequence of time steps.

```javascript
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.
```

--------------------------------

### Slice tensor regions

Source: https://js.tensorflow.org/api/latest

Extracts a sub-section of a tensor starting at a specific coordinate with a defined size.

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

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

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

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

--------------------------------

### Manage Models with Copy, List, and Remove

Source: https://js.tensorflow.org/api/latest

Demonstrates saving, listing, copying between storage mediums, and removing models.

```javascript
// 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');
```

--------------------------------

### Initialize and call ConvLSTM2DCell

Source: https://js.tensorflow.org/api/latest

Demonstrates how to define a ConvLSTM2DCell, build it with an input shape, and execute the call method with initial state tensors.

```javascript
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], {});
```

--------------------------------

### tf.linspace(start, stop, num)

Source: https://js.tensorflow.org/api/latest

Generates an evenly spaced sequence of numbers over a given interval.

```APIDOC
## tf.linspace(start, stop, num)

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

### Parameters
- **start** (number) - Required - The start value of the sequence.
- **stop** (number) - Required - The end value of the sequence.
- **num** (number) - Required - The number of values to generate.

### Returns
- **tf.Tensor**
```

--------------------------------

### compile(args)

Source: https://js.tensorflow.org/api/latest

Configures and prepares the model for training and evaluation by setting the optimizer, loss, and metrics.

```APIDOC
## compile(args)

### Description
Configures and prepares the model for training and evaluation. Compiling outfits the model with an optimizer, loss, and/or metrics.

### Parameters
- **args** (Object) - Required - A `ModelCompileArgs` specifying the loss, optimizer, and metrics.
  - **optimizer** (string|tf.train.Optimizer) - Required - An instance of tf.train.Optimizer or a string name.
  - **loss** (string|string[]|Object|LossOrMetricFn|LossOrMetricFn[]) - Required - Function(s) or name(s) of object function(s).
  - **metrics** (string|LossOrMetricFn|Array|Object) - Optional - List of metrics to be evaluated.
```

--------------------------------

### Initialize and apply an LSTM layer

Source: https://js.tensorflow.org/api/latest

Demonstrates how to instantiate an LSTM layer with specific units and return sequences, then apply it to an input tensor.

```javascript
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.
```

--------------------------------

### Getting high-resolution time with tf.util.now

Source: https://js.tensorflow.org/api/latest

Returns the current time in milliseconds, providing a consistent interface across different platforms.

```javascript
console.log(tf.util.now());
```

--------------------------------

### Get coordinates of true elements asynchronously

Source: https://js.tensorflow.org/api/latest

Returns the indices of true elements in a condition tensor as a 2D tensor. Requires an asynchronous call.

```javascript
const cond = tf.tensor1d([false, false, true], 'bool');
const result = await tf.whereAsync(cond);
result.print();
```

--------------------------------

### Create and Train a Sequential Model

Source: https://js.tensorflow.org/api/latest

Demonstrates defining a linear regression model, compiling it with an optimizer, and performing training and inference.

```javascript
  // Define a model for linear regression.
  const model = tf.sequential();
  model.add(tf.layers.dense({units: 1, inputShape: [1]}));

  // Prepare the model for training: Specify the loss and the optimizer.
  model.compile({loss: 'meanSquaredError', optimizer: 'sgd'});

  // Generate some synthetic data for training.
  const xs = tf.tensor2d([1, 2, 3, 4], [4, 1]);
  const ys = tf.tensor2d([1, 3, 5, 7], [4, 1]);

  // Train the model using the data then do inference on a data point the
  // model hasn't seen:
  await model.fit(xs, ys);
  model.predict(tf.tensor2d([5], [1, 1])).print();
```

--------------------------------

### Create and use WebGPU buffers in TF.js

Source: https://js.tensorflow.org/api/latest

Demonstrates creating a GPU buffer, populating it with data, and using it to initialize a TF.js tensor. Ensure the buffer usage includes STORAGE and COPY_SRC flags.

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

--------------------------------

### Train a model using the fit method

Source: https://js.tensorflow.org/api/latest

Demonstrates how to compile and train a sequential model using the fit method within a loop.

```javascript
const model = tf.sequential({
     layers: [tf.layers.dense({units: 1, inputShape: [10]})]
});
model.compile({optimizer: 'sgd', loss: 'meanSquaredError'});
for (let i = 1; i < 5 ; ++i) {
   const h = await model.fit(tf.ones([8, 10]), tf.ones([8, 1]), {
       batchSize: 4,
       epochs: 3
   });
   console.log("Loss after Epoch " + i + " : " + h.history.loss[0]);
}
```

--------------------------------

### Take initial elements with take

Source: https://js.tensorflow.org/api/latest

Creates a new dataset containing only the first N elements of the original dataset.

```javascript
const a = tf.data.array([1, 2, 3, 4, 5, 6]).take(3);
await a.forEachAsync(e => console.log(e));
```

--------------------------------

### Initialize and apply a ConvLSTM2D layer

Source: https://js.tensorflow.org/api/latest

Demonstrates how to define input dimensions and apply a ConvLSTM2D layer to a 5D tensor input.

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

--------------------------------

### Build Models with Symbolic Tensors

Source: https://js.tensorflow.org/api/latest

Shows how to use apply() with symbolic tensors to define model architecture and shape transformations before execution.

```javascript
const flattenLayer = tf.layers.flatten();
const denseLayer = tf.layers.dense({units: 1});

// Use tf.layers.input() to obtain a SymbolicTensor as input to apply().
const input = tf.input({shape: [2, 2]});
const output1 = flattenLayer.apply(input);

// output1.shape is [null, 4]. The first dimension is the undetermined
// batch size. The second dimension comes from flattening the [2, 2]
// shape.
console.log(JSON.stringify(output1.shape));

// The output SymbolicTensor of the flatten layer can be used to call
// the apply() of the dense layer:
const output2 = denseLayer.apply(output1);

// output2.shape is [null, 1]. The first dimension is the undetermined
// batch size. The second dimension matches the number of units of the
// dense layer.
console.log(JSON.stringify(output2.shape));

// The input and output can be used to construct a model that consists
// of the flatten and dense layers.
const model = tf.model({inputs: input, outputs: output2});
```

--------------------------------

### take(count)

Source: https://js.tensorflow.org/api/latest

Creates a Dataset with at most count initial elements from this dataset.

```APIDOC
## take(count)

### Description
Creates a Dataset with at most count initial elements from this dataset.

### Parameters
- **count** (number) - Required - The number of elements to take.

### Returns
- **tf.data.Dataset**
```

--------------------------------

### Create and summarize a multi-input model

Source: https://js.tensorflow.org/api/latest

Demonstrates defining a model with multiple inputs using functional API and printing its architecture summary.

```javascript
const input1 = tf.input({shape: [10]});
const input2 = tf.input({shape: [20]});
const dense1 = tf.layers.dense({units: 4}).apply(input1);
const dense2 = tf.layers.dense({units: 8}).apply(input2);
const concat = tf.layers.concatenate().apply([dense1, dense2]);
const output =
     tf.layers.dense({units: 3, activation: 'softmax'}).apply(concat);

const model = tf.model({inputs: [input1, input2], outputs: output});
model.summary();
```

--------------------------------

### prefetch(bufferSize)

Source: https://js.tensorflow.org/api/latest

Creates a Dataset that prefetches elements from this dataset.

```APIDOC
## prefetch(bufferSize)

### Description
Creates a Dataset that prefetches elements from this dataset.

### Parameters
- **bufferSize** (number) - Required - An integer specifying the number of elements to be prefetched.

### Returns
- **tf.data.Dataset**
```

--------------------------------

### Process single time step with GRUCell

Source: https://js.tensorflow.org/api/latest

Demonstrates how to instantiate a GRUCell and apply it to a single time step input, noting that the output shape reflects the unknown batch size.

```typescript
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.
```

--------------------------------

### Save and load model using browser local storage

Source: https://js.tensorflow.org/api/latest

Demonstrates saving a sequential model to local storage and reloading it.

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

--------------------------------

### tf.env()

Source: https://js.tensorflow.org/api/latest

Returns the current global environment singleton.

```APIDOC
## tf.env()

### Description
Returns the current environment (a global singleton). The environment object contains the evaluated feature values as well as the active platform.

### Returns
- **tf.Environment**
```

--------------------------------

### tf.initializers.glorotUniform(args)

Source: https://js.tensorflow.org/api/latest

Glorot uniform initializer, also called Xavier uniform initializer.

```APIDOC
## tf.initializers.glorotUniform(args)

### Description
Glorot uniform initializer, also called Xavier uniform initializer. It draws samples from a uniform distribution.

### Parameters
- **args** (Object) - Required
- **seed** (number) - Required - Random number generator seed

### Returns
- **tf.initializers.Initializer**
```

--------------------------------

### tf.fetch(path, requestInits?)

Source: https://js.tensorflow.org/api/latest

Returns a platform-specific implementation of the fetch API.

```APIDOC
## tf.fetch(path, requestInits?)

### Description
Returns a platform-specific implementation of `fetch`. If `fetch` is defined on the global object, it returns that; otherwise, it returns a platform-specific solution.

### Parameters
- **path** (string) - Required - The resource path.
- **requestInits** (RequestInit) - Optional - Request initialization options.

### Returns
- **Promise<Response>**
```

--------------------------------

### tf.registerBackend()

Source: https://js.tensorflow.org/api/latest

Registers a global backend.

```APIDOC
## tf.registerBackend(name, factory, priority?)

### Description
Registers a global backend. The registration should happen when importing a module file and is used for modular builds.

### Parameters
- **name** (string) - Required - The name of the backend.
- **factory** (() => KernelBackend | Promise<KernelBackend>) - Required - The backend factory function.
- **priority** (number) - Optional - The priority of the backend (higher = more important). Defaults to 1.

### Returns
- **boolean**
```

--------------------------------

### tf.io.browserFiles(files)

Source: https://js.tensorflow.org/api/latest

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

```APIDOC
## tf.io.browserFiles(files)

### Description
Creates an IOHandler that loads model artifacts from user-selected files. This is typically used in conjunction with tf.loadLayersModel().

### Parameters
- **files** (File[]) - Required - An array of File objects. The first file should be the JSON model topology, followed by optional binary weight files.

### Returns
- **IOHandler** - An IOHandler instance for loading model artifacts.
```

--------------------------------

### tf.train.adagrad(learningRate, initialAccumulatorValue?)

Source: https://js.tensorflow.org/api/latest

Constructs an Adagrad optimizer.

```APIDOC
## tf.train.adagrad(learningRate, initialAccumulatorValue?)

### Description
Constructs a tf.AdagradOptimizer that uses the Adagrad algorithm.

### Parameters
- **learningRate** (number) - Required - The learning rate.
- **initialAccumulatorValue** (number) - Optional - Starting value for accumulators.
```

--------------------------------

### tf.io.http(path, loadOptions?)

Source: https://js.tensorflow.org/api/latest

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

```APIDOC
## tf.io.http(path, loadOptions?)

### Description
Creates an IOHandler that sends model artifacts to an HTTP server via a multipart/form-data POST or custom request.

### Parameters
- **path** (string) - Required - The URL path to the model.
- **loadOptions** (LoadOptions) - Optional - Configuration including weightPathPrefix, fetchFunc, and onProgress callback.

### Returns
- **IOHandler** - An IOHandler instance for saving model artifacts.
```

--------------------------------

### tf.train.adadelta(learningRate?, rho?, epsilon?)

Source: https://js.tensorflow.org/api/latest

Constructs an Adadelta optimizer.

```APIDOC
## tf.train.adadelta(learningRate?, rho?, epsilon?)

### Description
Constructs a tf.AdadeltaOptimizer that uses the Adadelta algorithm.

### Parameters
- **learningRate** (number) - Optional - The learning rate.
- **rho** (number) - Optional - The learning rate decay.
- **epsilon** (number) - Optional - Constant for numerical stability.
```

--------------------------------

### Reusing Layers with inputLayer

Source: https://js.tensorflow.org/api/latest

Demonstrates how to construct a new sequential model by reusing a layer from an existing model, which requires an explicit inputLayer to define the input shape.

```javascript
// 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();
```

--------------------------------

### Save and load GraphModel to local storage

Source: https://js.tensorflow.org/api/latest

Demonstrates loading a model, performing inference, saving the model to browser local storage, and reloading it.

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

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

const loadedModel = await tf.loadGraphModel('localstorage://my-model-1');
console.log('Prediction from loaded model:');
model.predict(zeros).print();
```

--------------------------------

### tf.initializers.leCunNormal(args)

Source: https://js.tensorflow.org/api/latest

LeCun normal initializer.

```APIDOC
## tf.initializers.leCunNormal(args)

### Description
LeCun normal initializer. It draws samples from a truncated normal distribution centered on 0.

### Parameters
- **args** (Object) - Required
- **seed** (number) - Required - Random number generator seed

### Returns
- **tf.initializers.Initializer**
```

--------------------------------

### Create a Dataset from a Generator Function

Source: https://js.tensorflow.org/api/latest

Demonstrates creating a tf.data.generator using a standard JavaScript generator function.

```javascript
function* dataGenerator() {
   const numElements = 10;
   let index = 0;
   while (index < numElements) {
     const x = index;
     index++;
     yield x;
   }
}

const ds = tf.data.generator(dataGenerator);
await ds.forEachAsync(e => console.log(e));
```

--------------------------------

### tf.initializers.heNormal(args)

Source: https://js.tensorflow.org/api/latest

He normal initializer.

```APIDOC
## tf.initializers.heNormal(args)

### Description
He normal initializer. It draws samples from a truncated normal distribution centered on 0.

### Parameters
- **args** (Object) - Required
- **seed** (number) - Required - Random number generator seed

### Returns
- **tf.initializers.Initializer**
```

--------------------------------

### executeAsync(inputs, outputs?)

Source: https://js.tensorflow.org/api/latest

Executes inference for the model for given input tensors in async fashion.

```APIDOC
## executeAsync(inputs, outputs?)

### Description
Executes inference for the model for given input tensors in async fashion, use this method when your model contains control flow ops.

### Parameters
- **inputs** (tf.Tensor|tf.Tensor[]|{[name: string]: tf.Tensor}) - Required - Tensor, tensor array or tensor map of the inputs for the model, keyed by the input node names.
- **outputs** (string|string[]) - Optional - Output node name from the TensorFlow model.

### Returns
Promise<tf.Tensor|tf.Tensor[]>
```

--------------------------------

### Capture Microphone Audio as Spectrograms

Source: https://js.tensorflow.org/api/latest

Captures audio from the microphone and converts it into spectrogram and waveform tensors. Requires a device with a microphone and user permission.

```javascript
const mic = await tf.data.microphone({
   fftSize: 1024,
   columnTruncateLength: 232,
   numFramesPerSpectrogram: 43,
   sampleRateHz:44100,
   includeSpectrogram: true,
   includeWaveform: true
});
const audioData = await mic.capture();
const spectrogramTensor = audioData.spectrogram;
spectrogramTensor.print();
const waveformTensor = audioData.waveform;
waveformTensor.print();
mic.stop();
```

--------------------------------

### summary(lineLength?, positions?, printFn?)

Source: https://js.tensorflow.org/api/latest

Print a text summary of the model's layers.

```APIDOC
## summary(lineLength?, positions?, printFn?)

### Description
Print a text summary of the model's layers, including name, type, output shape, and parameter counts.

### Parameters
- **lineLength** (number) - Optional - Custom line length, in number of characters.
- **positions** (number[]) - Optional - Custom widths of each of the columns.
- **printFn** ((message?: tf.any(), ...optionalParams: tf.any()[]) => void) - Optional - Custom print function.
```

--------------------------------

### tf.initializers.glorotNormal(args)

Source: https://js.tensorflow.org/api/latest

Glorot normal initializer, also called Xavier normal initializer.

```APIDOC
## tf.initializers.glorotNormal(args)

### Description
Glorot normal initializer, also called Xavier normal initializer. It draws samples from a truncated normal distribution centered on 0.

### Parameters
- **args** (Object) - Required
- **seed** (number) - Required - Random number generator seed

### Returns
- **tf.initializers.Initializer**
```

--------------------------------

### Fetching resources with tf.util.fetch

Source: https://js.tensorflow.org/api/latest

Returns a platform-specific implementation of the fetch API, falling back to a custom solution if not globally defined.

```javascript
const resource = await tf.util.fetch('https://cdn.jsdelivr.net/npm/@tensorflow/tfjs');
// handle response
```

--------------------------------

### execute(inputs, outputs?)

Source: https://js.tensorflow.org/api/latest

Executes inference for the model for given input tensors.

```APIDOC
## execute(inputs, outputs?)

### Description
Executes inference for the model for given input tensors.

### Parameters
- **inputs** (tf.Tensor|tf.Tensor[]|{[name: string]: tf.Tensor}) - Required - Tensor, tensor array or tensor map of the inputs for the model, keyed by the input node names.
- **outputs** (string|string[]) - Optional - Output node name from the TensorFlow model. If no outputs are specified, the default outputs of the model are used.

### Returns
tf.Tensor|tf.Tensor[]|{[name: string]: tf.Tensor}
```

--------------------------------

### tf.layers.inputLayer

Source: https://js.tensorflow.org/api/latest

Creates an input layer as an entry point into a tf.LayersModel.

```APIDOC
## tf.layers.inputLayer(args)

### Description
An input layer is an entry point into a tf.LayersModel. It is typically generated automatically for sequential models but can be specified explicitly.

### Parameters
- **args** (Object) - Required - Configuration object.
- **args.inputShape** ((null | number)[]) - Optional - Input shape, not including the batch axis.
- **args.batchSize** (number) - Optional - Input batch size.
- **args.batchInputShape** ((null | number)[]) - Optional - Batch input shape, including the batch axis.
- **args.dtype** ('float32'|'int32'|'bool'|'complex64'|'string') - Optional - Datatype of the input.
- **args.sparse** (boolean) - Optional - Whether the placeholder is sparse.
- **args.name** (string) - Optional - Name of the layer.
```

--------------------------------

### Load a model from user-selected files

Source: https://js.tensorflow.org/api/latest

Loads a model from HTML file input elements using tf.io.browserFiles.

```javascript
// 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]]));
```

--------------------------------

### Create a sequential model with tf.sequential

Source: https://js.tensorflow.org/api/latest

Builds a linear stack of layers where the first layer must define an input shape. Subsequent layers infer their input shapes automatically.

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

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

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

--------------------------------

### tf.train.adam(learningRate?, beta1?, beta2?, epsilon?)

Source: https://js.tensorflow.org/api/latest

Constructs an Adam optimizer.

```APIDOC
## tf.train.adam(learningRate?, beta1?, beta2?, epsilon?)

### Description
Constructs a tf.AdamOptimizer that uses the Adam algorithm.

### Parameters
- **learningRate** (number) - Optional - The learning rate.
- **beta1** (number) - Optional - Decay rate for 1st moment.
- **beta2** (number) - Optional - Decay rate for 2nd moment.
- **epsilon** (number) - Optional - Constant for numerical stability.
```

--------------------------------

### tf.layers.softmax(args?)

Source: https://js.tensorflow.org/api/latest

Creates a Softmax activation layer. The input shape is arbitrary, and the output shape is the same as the input.

```APIDOC
## tf.layers.softmax(args?)

### Description
Softmax activation layer that applies normalization along a specified axis.

### Parameters
- **args** (Object) - Optional - Configuration object for the layer.
- **axis** (number|number[]) - Optional - Integer, axis along which the softmax normalization is applied. Defaults to -1.
- **inputShape** ((null | number)[]) - Optional - Used to create an input layer if this is the first layer.
- **batchInputShape** ((null | number)[]) - Optional - Used to create an input layer if this is the first layer.
- **batchSize** (number) - Optional - Used to construct batchInputShape if inputShape is provided.
- **dtype** ('float32'|'int32'|'bool'|'complex64'|'string') - Optional - Data-type for the layer. Defaults to 'float32'.
- **name** (string) - Optional - Name for this layer.
- **trainable** (boolean) - Optional - Whether weights are updatable. Defaults to true.
- **weights** (tf.Tensor[]) - Optional - Initial weight values.
```

--------------------------------

### Save and load model using browser IndexedDB

Source: https://js.tensorflow.org/api/latest

Demonstrates saving a sequential model to IndexedDB and reloading it.

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

--------------------------------

### tf.initializers.heUniform(args)

Source: https://js.tensorflow.org/api/latest

He uniform initializer.

```APIDOC
## tf.initializers.heUniform(args)

### Description
He uniform initializer. It draws samples from a uniform distribution.

### Parameters
- **args** (Object) - Required
- **seed** (number) - Required - Random number generator seed

### Returns
- **tf.initializers.Initializer**
```

--------------------------------

### tf.getBackend()

Source: https://js.tensorflow.org/api/latest

Returns the current backend name.

```APIDOC
## tf.getBackend()

### Description
Returns the current backend name (cpu, webgl, etc). The backend is responsible for creating tensors and executing operations on those tensors.

### Returns
- **string** - The name of the current backend.
```

--------------------------------

### Apply Cropping2D Layer

Source: https://js.tensorflow.org/api/latest

Demonstrates adding a Cropping2D layer to a sequential model to crop input dimensions.

```javascript
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]
```

--------------------------------

### Create a Dataset from an Iterator Factory

Source: https://js.tensorflow.org/api/latest

Demonstrates creating a tf.data.generator using a custom iterator factory function.

```javascript
function makeIterator() {
   const numElements = 10;
   let index = 0;

   const iterator = {
     next: () => {
       let result;
       if (index < numElements) {
         result = {value: index, done: false};
         index++;
         return result;
       }
       return {value: index, done: true};
     }
   };
   return iterator;
}
const ds = tf.data.generator(makeIterator);
await ds.forEachAsync(e => console.log(e));
```

--------------------------------

### Apply a SimpleRNN Layer to an Input Sequence

Source: https://js.tensorflow.org/api/latest

Demonstrates initializing a SimpleRNN layer and applying it to an input tensor with a defined sequence length.

```javascript
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.
```

--------------------------------

### Skip initial elements with skip

Source: https://js.tensorflow.org/api/latest

Creates a new dataset by skipping a specified number of initial elements.

```javascript
const a = tf.data.array([1, 2, 3, 4, 5, 6]).skip(3);
await a.forEachAsync(e => console.log(e));
```

--------------------------------

### tf.layers.gru(args)

Source: https://js.tensorflow.org/api/latest

Creates a GRU layer with the specified configuration parameters.

```APIDOC
## tf.layers.gru(args)

### Description
Creates a recurrent neural network layer consisting of one GRUCell. This layer is used to process sequential data.

### Parameters
- **args** (Object) - Required - Configuration object for the GRU layer.

#### Configuration Fields
- **units** (number) - Required - Dimensionality of the output space.
- **recurrentActivation** (string) - Optional - Activation function for the recurrent step. Defaults to 'hardSigmoid'.
- **activation** (string) - Optional - Activation function to use. Defaults to 'tanh'.
- **useBias** (boolean) - Optional - Whether the layer uses a bias vector.
- **kernelInitializer** (string|Initializer) - Optional - Initializer for the kernel weights matrix.
- **recurrentInitializer** (string|Initializer) - Optional - Initializer for the recurrentKernel weights matrix.
- **biasInitializer** (string|Initializer) - Optional - Initializer for the bias vector.
- **dropout** (number) - Optional - Fraction of units to drop for input linear transformation (0-1).
- **recurrentDropout** (number) - Optional - Fraction of units to drop for recurrent state linear transformation (0-1).
- **inputShape** (number[]) - Optional - Shape of the input data.
- **batchInputShape** (number[]) - Optional - Shape of the input data including batch size.
- **dtype** (string) - Optional - Data type for the layer. Defaults to 'float32'.
- **name** (string) - Optional - Name for the layer.
- **trainable** (boolean) - Optional - Whether the layer weights are updatable. Defaults to true.
```

--------------------------------

### model.fit(x, y, args?)

Source: https://js.tensorflow.org/api/latest

Trains the model for a fixed number of epochs (iterations on a dataset).

```APIDOC
## model.fit(x, y, args?)

### Description
Trains the model for a fixed number of epochs (iterations on a dataset).

### Parameters
- **x** (tf.Tensor|tf.Tensor[]|{[inputName: string]: tf.Tensor}) - Required - tf.Tensor of training data, or an array of tf.Tensors if the model has multiple inputs. If all inputs in the model are named, you can also pass a dictionary mapping input names to tf.Tensors.
- **y** (tf.Tensor|tf.Tensor[]|{[inputName: string]: tf.Tensor}) - Required - tf.Tensor of target (label) data, or an array of tf.Tensors if the model has multiple outputs. If all outputs in the model are named, you can also pass a dictionary mapping output names to tf.Tensors.
- **args** (Object) - Optional - A ModelFitArgs object containing optional training configurations.
  - **batchSize** (number) - Optional - Number of samples per gradient update. Defaults to 32.
  - **epochs** (number) - Optional - Integer number of times to iterate over the training data arrays.
  - **verbose** (ModelLoggingVerbosity | 2) - Optional - Verbosity level (0, 1, or 2). Default is 1.
  - **callbacks** (BaseCallback[]|CustomCallbackArgs|CustomCallbackArgs[]) - Optional - List of callbacks to be called during training.
  - **validationSplit** (number) - Optional - Float between 0 and 1: fraction of the training data to be used as validation data.
  - **validationData** ([tf.Tensor|tf.Tensor[], tf.Tensor|tf.Tensor[]]|[tf.Tensor|tf.Tensor[], tf.Tensor|tf.Tensor[], tf.Tensor|tf.Tensor[]]) - Optional - Data on which to evaluate the loss and any model metrics at the end of each epoch.
  - **shuffle** (boolean) - Optional - Whether to shuffle the training data before each epoch.
  - **classWeight** (ClassWeight|ClassWeight[]|ClassWeightMap) - Optional - Object mapping class indices to weights to apply to the model's loss.
  - **sampleWeight** (tf.Tensor) - Optional - Array of the same length as x, containing weights to apply to the model's loss for each sample.
  - **initialEpoch** (number) - Optional - Epoch at which to start training.

### Returns
- **tf.Tensor|tf.Tensor[]** - The training history object.
```

--------------------------------

### tf.train.momentum(learningRate, momentum, useNesterov?)

Source: https://js.tensorflow.org/api/latest

Constructs a Momentum optimizer.

```APIDOC
## tf.train.momentum(learningRate, momentum, useNesterov?)

### Description
Constructs a tf.MomentumOptimizer that uses momentum gradient descent.

### Parameters
- **learningRate** (number) - Required - The learning rate.
- **momentum** (number) - Required - The momentum value.
- **useNesterov** (boolean) - Optional - Whether to use Nesterov momentum.
```

--------------------------------

### tf.sequential(config?)

Source: https://js.tensorflow.org/api/latest

Creates a tf.Sequential model, which is a linear stack of layers where the output of one layer is the input to the next.

```APIDOC
## tf.sequential(config?)

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

### Parameters
- **config** (Object) - Optional - Configuration object for the model.
- **layers** (tf.layers.Layer[]) - Optional - Stack of layers for the model.
- **name** (string) - Optional - The name of this model.
```

--------------------------------

### tf.train.sgd(learningRate)

Source: https://js.tensorflow.org/api/latest

Constructs an SGD optimizer.

```APIDOC
## tf.train.sgd(learningRate)

### Description
Constructs a tf.SGDOptimizer that uses stochastic gradient descent.

### Parameters
- **learningRate** (number) - Required - The learning rate to use.
```

--------------------------------

### apply(inputs, kwargs?)

Source: https://js.tensorflow.org/api/latest

Builds or executes a Layer's logic. When called with tf.Tensor(s), it executes the computation. When called with tf.SymbolicTensor(s), it prepares the layer for future execution.

```APIDOC
## apply(inputs, kwargs?)

### Description
Builds or executes a Layer's logic. When called with tf.Tensor(s), it executes the computation and returns Tensor(s). When called with tf.SymbolicTensor(s), it prepares the layer for future execution by wiring layers together and initializing weights.

### Parameters
- **inputs** (tf.Tensor|tf.Tensor[]|tf.SymbolicTensor|tf.SymbolicTensor[]) - Required - A tf.Tensor or tf.SymbolicTensor or an Array of them.
- **kwargs** (Kwargs) - Optional - Additional keyword arguments to be passed to call().

### Returns
- tf.Tensor|tf.Tensor[]|tf.SymbolicTensor|tf.SymbolicTensor[]
```

--------------------------------

### Construct an RNN with stacked SimpleRNNCells

Source: https://js.tensorflow.org/api/latest

Shows how to combine multiple SimpleRNNCell instances into an RNN layer, useful for creating stacked RNN architectures.

```javascript
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.
```

--------------------------------

### Create and process a CSVDataset

Source: https://js.tensorflow.org/api/latest

Use tf.data.csv to load data from a URL, configure labels, and prepare the dataset for model training.

```javascript
const csvUrl =
'https://storage.googleapis.com/tfjs-examples/multivariate-linear-regression/data/boston-housing-train.csv';

async function run() {
   // We want to predict the column "medv", which represents a median value of
   // a home (in $1000s), so we mark it as a label.
   const csvDataset = tf.data.csv(
     csvUrl, {
       columnConfigs: {
         medv: {
           isLabel: true
         }
       }
     });

   // Number of features is the number of column names minus one for the label
   // column.
   const numOfFeatures = (await csvDataset.columnNames()).length - 1;

   // Prepare the Dataset for training.
   const flattenedDataset =
     csvDataset
     .map(({xs, ys}) =>
       {
         // Convert xs(features) and ys(labels) from object form (keyed by
         // column name) to array form.
         return {xs:Object.values(xs), ys:Object.values(ys)};
       })
     .batch(10);

   // Define the model.
   const model = tf.sequential();
   model.add(tf.layers.dense({
     inputShape: [numOfFeatures],
     units: 1
   }));
   model.compile({
     optimizer: tf.train.sgd(0.000001),
     loss: 'meanSquaredError'
   });

   // Fit the model using the prepared Dataset
   return model.fitDataset(flattenedDataset, {
     epochs: 10,
     callbacks: {
       onEpochEnd: async (epoch, logs) => {
         console.log(epoch + ':' + logs.loss);
       }
     }
   });
}

await run();
```

--------------------------------

### tf.input(config)

Source: https://js.tensorflow.org/api/latest

Instantiates an input to a model as a tf.SymbolicTensor.

```APIDOC
## tf.input(config)

### Description
Used to define the entry point for a model. This is necessary when using the generic tf.model() constructor.

### Parameters
- **config** (Object) - Required
  - **shape** ((null | number)[]) - Optional - The shape of the input, excluding batch size.
  - **batchShape** ((null | number)[]) - Optional - The shape including the batch size.
  - **name** (string) - Optional - Unique name for the layer.
  - **dtype** ('float32'|'int32'|'bool'|'complex64'|'string') - Optional - Data type of the input.
  - **sparse** (boolean) - Optional - Whether the placeholder is sparse.

### Returns
- **tf.SymbolicTensor** - The symbolic tensor representing the input.
```
Tokens:
Raw