/**
|
* @license
|
* Copyright 2018 Google LLC
|
*
|
* Use of this source code is governed by an MIT-style
|
* license that can be found in the LICENSE file or at
|
* https://opensource.org/licenses/MIT.
|
* =============================================================================
|
*/
|
/* Original source keras/models.py */
|
import { dispose, io, serialization, util } from '@tensorflow/tfjs-core';
|
import { getUid } from './backend/state';
|
import { Input } from './engine/input_layer';
|
import { getSourceInputs, Node } from './engine/topology';
|
import { LayersModel } from './engine/training';
|
import { NotImplementedError, RuntimeError, ValueError } from './errors';
|
import { deserialize } from './layers/serialization';
|
import * as generic_utils from './utils/generic_utils';
|
import { convertPythonicToTs } from './utils/serialization_utils';
|
import { getExactlyOneShape } from './utils/types_utils';
|
/**
|
* Parses a JSON model configuration file and returns a model instance.
|
*
|
* ```js
|
* // This example shows how to serialize a model using `toJSON()` and
|
* // deserialize it as another model using `tf.models.modelFromJSON()`.
|
* // Note: this example serializes and deserializes only the topology
|
* // of the model; the weights of the loaded model will be different
|
* // from those of the the original model, due to random weight
|
* // initialization.
|
* // To load the topology and weights of a model, use `tf.loadLayersModel()`.
|
* const model1 = tf.sequential();
|
* model1.add(tf.layers.repeatVector({inputShape: [2], n: 4}));
|
* // Serialize `model1` as a JSON object.
|
* const model1JSON = model1.toJSON(null, false);
|
* model1.summary();
|
*
|
* const model2 = await tf.models.modelFromJSON(model1JSON);
|
* model2.summary();
|
* ```
|
*
|
* @param modelAndWeightsConfig JSON object or string encoding a model and
|
* weights configuration. It can also be only the topology JSON of the
|
* model, in which case the weights will not be loaded.
|
* @param custom_objects Optional dictionary mapping names
|
* (strings) to custom classes or functions to be
|
* considered during deserialization.
|
* @returns A TensorFlow.js Layers `tf.LayersModel` instance (uncompiled).
|
*/
|
export async function modelFromJSON(modelAndWeightsConfig, customObjects) {
|
if (!('modelTopology' in modelAndWeightsConfig)) {
|
modelAndWeightsConfig = { modelTopology: modelAndWeightsConfig };
|
}
|
modelAndWeightsConfig = modelAndWeightsConfig;
|
let modelTopology = modelAndWeightsConfig.modelTopology;
|
if (modelTopology['model_config'] != null) {
|
// If the model-topology JSON contains a 'model_config' field, then it is
|
// a full model JSON (e.g., from `keras.Model.save()`), which contains
|
// not only the model's architecture in its 'model_config' field, but
|
// additional information such as the model's optimizer. We use only the
|
// 'model_config' field currently.
|
modelTopology = modelTopology['model_config'];
|
}
|
const tsConfig = convertPythonicToTs(modelTopology);
|
const model = deserialize(tsConfig, customObjects);
|
if (modelAndWeightsConfig.weightsManifest != null) {
|
// Load the weight values keyed by the original tensor names in the model
|
// file that was loaded. These should match the keys of the weight
|
// manifest.
|
const weightValues = await io.loadWeights(modelAndWeightsConfig.weightsManifest, modelAndWeightsConfig.pathPrefix, model.weights.map(weight => weight.originalName));
|
// Map the weights to the unique tensor names generated during model loading
|
const uniqueWeightValues = {};
|
for (const weight of model.weights) {
|
uniqueWeightValues[weight.originalName] =
|
weightValues[weight.originalName];
|
}
|
model.loadWeights(uniqueWeightValues);
|
// Dispose temporary weight values.
|
dispose(weightValues);
|
}
|
return model;
|
}
|
/**
|
* 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](https://github.com/tensorflow/tfjs/tree/master/tfjs-converter).
|
*
|
* This mode is *not* applicable to TensorFlow `SavedModel`s or their converted
|
* forms. For those models, use `tf.loadGraphModel`.
|
*
|
* Example 1. Load a model from an HTTP server.
|
*
|
* ```js
|
* 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](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage);
|
* then load it back.
|
*
|
* ```js
|
* 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](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API);
|
* then load it back.
|
*
|
* ```js
|
* 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](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/file).
|
*
|
* ```js
|
* // 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]]));
|
* ```
|
*
|
* @param pathOrIOHandler Can be either of the two formats
|
* 1. A string path to the `ModelAndWeightsConfig` JSON describing
|
* the model in the canonical TensorFlow.js format. For file://
|
* (tfjs-node-only), http:// and https:// schemas, the path can be
|
* either absolute or relative. The content of the JSON file is assumed to
|
* be a JSON object with the following fields and values:
|
* - 'modelTopology': A JSON object that can be either of:
|
* 1. a model architecture JSON consistent with the format of the return
|
* value of `keras.Model.to_json()`
|
* 2. a full model JSON in the format of `keras.models.save_model()`.
|
* - 'weightsManifest': A TensorFlow.js weights manifest.
|
* See the Python converter function `save_model()` for more details.
|
* It is also assumed that model weights can be accessed from relative
|
* paths described by the `paths` fields in weights manifest.
|
* 2. A `tf.io.IOHandler` object that loads model artifacts with its `load`
|
* method.
|
* @param options Optional configuration arguments for the model loading,
|
* including:
|
* - `strict`: Require that the provided weights exactly match those required
|
* by the layers. Default true. Passing false means that both extra
|
* weights and missing weights will be silently ignored.
|
* - `onProgress`: A progress callback of the form:
|
* `(fraction: number) => void`. This callback can be used to monitor the
|
* model-loading process.
|
* @returns A `Promise` of `tf.LayersModel`, with the topology and weights
|
* loaded.
|
*
|
* @doc {heading: 'Models', subheading: 'Loading'}
|
*/
|
export async function loadLayersModel(pathOrIOHandler, options) {
|
if (options == null) {
|
options = {};
|
}
|
if (typeof pathOrIOHandler === 'string') {
|
const handlers = io.getLoadHandlers(pathOrIOHandler, options);
|
if (handlers.length === 0) {
|
// For backward compatibility: if no load handler can be found,
|
// assume it is a relative http path.
|
// TODO(cais): Reformat the args into a single `LoadOptions` once the core
|
// is refactored.
|
handlers.push(io.browserHTTPRequest(pathOrIOHandler, options));
|
}
|
else if (handlers.length > 1) {
|
throw new ValueError(`Found more than one (${handlers.length}) load handlers for ` +
|
`URL '${pathOrIOHandler}'`);
|
}
|
pathOrIOHandler = handlers[0];
|
}
|
return loadLayersModelFromIOHandler(pathOrIOHandler, undefined, options);
|
}
|
/**
|
* Load a model and optionally its weights, using an IOHandler object.
|
*
|
* @param handler The instance of `IOHandler` to be used during the model
|
* loading.
|
* @param customObjects Any optional custom objects to be used during model
|
* loading.
|
* @param strict Whether the weight loading will be done in strict mode.
|
* Default: `true`.
|
*/
|
export async function loadLayersModelFromIOHandler(handler, customObjects, options) {
|
if (options == null) {
|
options = {};
|
}
|
if (handler.load == null) {
|
throw new ValueError('Cannot proceed with model loading because the IOHandler provided ' +
|
'does not have the `load` method implemented.');
|
}
|
const artifacts = await handler.load();
|
let modelTopology = artifacts.modelTopology;
|
if (modelTopology['model_config'] != null) {
|
modelTopology = modelTopology['model_config'];
|
}
|
const strict = options.strict == null ? true : options.strict;
|
// If weights are provided and the weight-loading mode is strict, use
|
// fast weight initialization. This skips costly initializers such as
|
// 'orthogonal' and saves unnecessary computation in cases where
|
// the initialized weight values will immediately be overwritten by
|
// loaded weight values.
|
const fastWeightInit = artifacts.weightData != null && artifacts.weightSpecs != null && strict;
|
const model = deserialize(convertPythonicToTs(modelTopology), customObjects, fastWeightInit);
|
const trainingConfig = artifacts.trainingConfig;
|
if (trainingConfig != null) {
|
model.loadTrainingConfig(trainingConfig);
|
}
|
if (artifacts.userDefinedMetadata != null) {
|
model.setUserDefinedMetadata(artifacts.userDefinedMetadata);
|
}
|
// If weightData is present, load the weights into the model.
|
if (artifacts.weightData != null) {
|
// Loading weights requires weightSpecs.
|
if (artifacts.weightSpecs == null) {
|
throw new ValueError('LayersModel artifacts contains weight data, but not weight specs. ' +
|
'Therefore loading of weights cannot proceed.');
|
}
|
const { modelWeights, optimizerWeights } = decodeModelAndOptimizerWeights(artifacts.weightData, artifacts.weightSpecs);
|
model.loadWeights(modelWeights, strict);
|
if (model.optimizer != null && optimizerWeights.length > 0) {
|
await model.optimizer.setWeights(optimizerWeights);
|
}
|
// Dispose temporary weight values.
|
dispose(modelWeights);
|
dispose(optimizerWeights.map(w => w.tensor));
|
}
|
return model;
|
}
|
function decodeModelAndOptimizerWeights(weightData, specs) {
|
const name2Tensor = io.decodeWeights(weightData, specs);
|
const modelWeights = {};
|
const optimizerWeights = [];
|
specs.forEach(spec => {
|
if (spec.group === 'optimizer') {
|
optimizerWeights.push({ name: spec.name, tensor: name2Tensor[spec.name] });
|
}
|
else {
|
modelWeights[spec.name] = name2Tensor[spec.name];
|
}
|
});
|
return { modelWeights, optimizerWeights };
|
}
|
/**
|
* A model with a stack of layers, feeding linearly from one to the next.
|
*
|
* `tf.sequential` is a factory function that creates an instance of
|
* `tf.Sequential`.
|
*
|
* ```js
|
* // 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();
|
* ```
|
*
|
* @doc {heading: 'Models', subheading: 'Classes'}
|
*/
|
class Sequential extends LayersModel {
|
constructor(args) {
|
super({ inputs: [], outputs: [] });
|
args = args || {};
|
this.trainable = true;
|
this.built = false;
|
// Set model name.
|
this.name = (args.name != null) ? args.name : getUid('sequential_');
|
// Add to the model any layers passed to the constructor.
|
if (args.layers != null) {
|
for (const layer of args.layers) {
|
this.add(layer);
|
}
|
}
|
}
|
// Helper function to Sequential.add Throws if the new output shape will be
|
// invalid.
|
checkShape(layer) {
|
const shape = layer.inboundNodes[0].outputTensors[0].shape;
|
if (shape.some(x => x < 0)) {
|
throw new ValueError('Negative dimension size caused by adding layer ' +
|
`${layer.name} with input shape [` +
|
`${layer.inboundNodes[0].inputTensors[0].shape}]`);
|
}
|
}
|
/**
|
* Adds a layer instance on top of the layer stack.
|
*
|
* ```js
|
* const model = tf.sequential();
|
* model.add(tf.layers.dense({units: 8, inputShape: [1]}));
|
* model.add(tf.layers.dense({units: 4, activation: 'relu6'}));
|
* model.add(tf.layers.dense({units: 1, activation: 'relu6'}));
|
* // Note that the untrained model is random at this point.
|
* model.predict(tf.randomNormal([10, 1])).print();
|
* ```
|
* @param layer Layer instance.
|
*
|
* @exception ValueError In case the `layer` argument does not know its
|
* input shape.
|
* @exception ValueError In case the `layer` argument has multiple output
|
* tensors, or is already connected somewhere else (forbidden in
|
* `Sequential` models).
|
*
|
* @doc {heading: 'Models', subheading: 'Classes'}
|
*/
|
add(layer) {
|
const isLayerModelInstance = layer instanceof Sequential || layer instanceof LayersModel;
|
let modelLayer;
|
if (isLayerModelInstance) {
|
modelLayer = layer;
|
if (modelLayer.outputs.length !== 1) {
|
throw new ValueError('All layers in a Sequential model ' +
|
'should have a single output tensor. ' +
|
'For multi-output layers, ' +
|
'use the functional API.');
|
}
|
if (modelLayer.inputs.length !== 1) {
|
throw new ValueError('All layers in a Sequential model ' +
|
'should have a single input tensor. ' +
|
'For multi-input layers, ' +
|
'use the functional API.');
|
}
|
}
|
if (this.outputs.length === 0) {
|
// first layer in model: check that it is an input layer
|
if (layer.inboundNodes.length === 0) {
|
// create an input layer
|
if (layer.batchInputShape == null) {
|
throw new ValueError('The first layer in a Sequential model must ' +
|
'get an `inputShape` or `batchInputShape` argument.');
|
}
|
// Instantiate the input layer.
|
const x = Input({
|
batchShape: layer.batchInputShape,
|
dtype: layer.dtype,
|
name: layer.name + '_input'
|
});
|
// This will build the current layer and create the node connecting
|
// the current layer to the input layer we just created.
|
layer.apply(x);
|
}
|
if (isLayerModelInstance) {
|
this.outputs = modelLayer.outputs;
|
this.inputs = modelLayer.inputs;
|
}
|
else {
|
if (layer.inboundNodes.length !== 1) {
|
throw new ValueError('A layer added to a Sequential model must not already be ' +
|
`connected somewhere else. LayersModel received layer ${layer.name} ` +
|
`which has ${layer.inboundNodes.length} pre-existing inbound ` +
|
'connections.');
|
}
|
if (layer.inboundNodes[0].outputTensors.length !== 1) {
|
throw new ValueError('All layers in a Sequential model ' +
|
'should have a single output tensor. ' +
|
'For multi-output layers, ' +
|
'use the functional API.');
|
}
|
this.checkShape(layer);
|
this.outputs = [layer.inboundNodes[0].outputTensors[0]];
|
this.inputs = getSourceInputs(this.outputs[0]);
|
}
|
this.inboundNodes = [];
|
// We create an input node, which we will keep updated
|
// as we add more layers.
|
// (This call has side effects.)
|
// tslint:disable-next-line:no-unused-expression
|
new Node({
|
outboundLayer: this,
|
inboundLayers: [],
|
nodeIndices: [],
|
tensorIndices: [],
|
inputTensors: this.inputs,
|
outputTensors: this.outputs,
|
// no model-level masking for now
|
inputMasks: generic_utils.pyListRepeat(null, this.inputs.length),
|
outputMasks: [null],
|
inputShapes: this.inputs.map(x => x.shape),
|
outputShapes: this.outputs[0].shape
|
});
|
}
|
else {
|
const outputTensor = layer.apply(this.outputs[0]);
|
if (Array.isArray(outputTensor)) {
|
throw new TypeError('All layers in a Sequential model ' +
|
'should have a single output tensor. ' +
|
'For multi-output layers, ' +
|
'use the functional API.');
|
}
|
this.checkShape(layer);
|
this.outputs = [outputTensor];
|
// update self.inbound_nodes
|
this.inboundNodes[0].outputTensors = this.outputs;
|
this.inboundNodes[0].outputShapes = [this.outputs[0].shape];
|
}
|
this.layers.push(layer);
|
this.built = false;
|
}
|
/**
|
* Removes the last layer in the model.
|
*
|
* @exception TypeError if there are no layers in the model.
|
*/
|
pop() {
|
if (this.layers.length === 0) {
|
throw new TypeError('There are no layers in the model.');
|
}
|
this.layers.pop();
|
if (this.layers.length === 0) {
|
this.outputs = [];
|
this.inboundNodes = [];
|
this.outboundNodes = [];
|
}
|
else {
|
const lastLayerIndex = this.layers.length - 1;
|
this.layers[lastLayerIndex].outboundNodes = [];
|
this.outputs = [this.layers[lastLayerIndex].output];
|
// update self.inbound_nodes
|
this.inboundNodes[0].outputTensors = this.outputs;
|
this.inboundNodes[0].outputShapes = [this.outputs[0].shape];
|
}
|
}
|
call(inputs, kwargs) {
|
if (this.model == null) {
|
this.build();
|
}
|
return this.model.call(inputs, kwargs);
|
}
|
build(inputShape) {
|
// Call `getExactlyOneShape` without using its return value,
|
// to verify that exactly one input shape is provided.
|
getExactlyOneShape(inputShape);
|
if (this.inputs.length === 0 || this.outputs.length === 0) {
|
throw new TypeError('Sequential model cannot be built: model is empty.' +
|
' Add some layers first.');
|
}
|
// actually create the model
|
this.model = new LayersModel({
|
inputs: this.inputs,
|
outputs: this.outputs[0],
|
name: this.name + '_model'
|
});
|
this.model.trainable = this.trainable;
|
// mirror model attributes
|
this.supportsMasking = this.model.supportsMasking;
|
// TODO(michaelterry): Add caches
|
this.inputLayers = this.model.inputLayers;
|
this.inputLayersNodeIndices = this.model.inputLayersNodeIndices;
|
this.inputLayersTensorIndices = this.model.inputLayersTensorIndices;
|
this.outputLayers = this.model.outputLayers;
|
this.outputLayersNodeIndices = this.model.outputLayersNodeIndices;
|
this.outputLayersTensorIndices = this.model.outputLayersTensorIndices;
|
this.nodesByDepth = this.model.nodesByDepth;
|
this.containerNodes = this.model.containerNodes;
|
this.outputNames = this.model.outputNames;
|
this.inputNames = this.model.inputNames;
|
// TODO(michaelterry): Add feedInputNames, feedInputs, if needed.
|
// TODO(michaelterry): Add callbackModel if needed.
|
this.built = true;
|
}
|
countParams() {
|
if (!this.built) {
|
this.build();
|
}
|
return super.countParams();
|
}
|
/**
|
* Print a text summary of the Sequential model's layers.
|
*
|
* The summary includes
|
* - Name and type of all layers that comprise the model.
|
* - Output shape(s) of the layers
|
* - Number of weight parameters of each layer
|
* - The total number of trainable and non-trainable parameters of the
|
* model.
|
*
|
* ```js
|
* const model = tf.sequential();
|
* model.add(
|
* tf.layers.dense({units: 100, inputShape: [10], activation: 'relu'}));
|
* model.add(tf.layers.dense({units: 1, activation: 'sigmoid'}));
|
*
|
* model.summary();
|
* ```
|
*
|
* @param lineLength Custom line length, in number of characters.
|
* @param positions Custom widths of each of the columns, as either
|
* fractions of `lineLength` (e.g., `[0.5, 0.75, 1]`) or absolute number
|
* of characters (e.g., `[30, 50, 65]`). Each number corresponds to
|
* right-most (i.e., ending) position of a column.
|
* @param printFn Custom print function. Can be used to replace the default
|
* `console.log`. For example, you can use `x => {}` to mute the printed
|
* messages in the console.
|
*
|
* @doc {heading: 'Models', subheading: 'Classes'}
|
*/
|
summary(lineLength, positions, printFn = console.log) {
|
if (!this.built) {
|
this.build();
|
}
|
super.summary(lineLength, positions, printFn);
|
}
|
/**
|
* Sets the weights of the model.
|
*
|
* @param weights Should be a list of Tensors with shapes and types matching
|
* the output of `model.getWeights()`.
|
*/
|
setWeights(weights) {
|
if (this.model == null) {
|
this.build();
|
}
|
this.model.setWeights(weights);
|
}
|
/**
|
* Returns the loss value & metrics values for the model in test mode.
|
*
|
* Loss and metrics are specified during `compile()`, which needs to happen
|
* before calls to `evaluate()`.
|
*
|
* Computation is done in batches.
|
*
|
* ```js
|
* const model = tf.sequential({
|
* layers: [tf.layers.dense({units: 1, inputShape: [10]})]
|
* });
|
* model.compile({optimizer: 'sgd', loss: 'meanSquaredError'});
|
* const result = model.evaluate(tf.ones([8, 10]), tf.ones([8, 1]), {
|
* batchSize: 4,
|
* });
|
* result.print();
|
* ```
|
*
|
* @param x `tf.Tensor` of test data, or an `Array` of `tf.Tensor`s if the
|
* model has multiple inputs.
|
* @param y `tf.Tensor` of target data, or an `Array` of `tf.Tensor`s if the
|
* model has multiple outputs.
|
* @param args A `ModelEvaluateConfig`, containing optional fields.
|
*
|
* @return `Scalar` test loss (if the model has a single output and no
|
* metrics) or `Array` of `Scalar`s (if the model has multiple outputs
|
* and/or metrics). The attribute `model.metricsNames`
|
* will give you the display labels for the scalar outputs.
|
*
|
* @doc {heading: 'Models', subheading: 'Classes'}
|
*/
|
evaluate(x, y, args = {}) {
|
if (!this.built) {
|
throw new RuntimeError('The model needs to be compiled before being used.');
|
}
|
return this.model.evaluate(x, y, args);
|
}
|
// TODO(cais): Add code snippet below once real dataset objects are
|
// available.
|
/**
|
* Evaluate model using a dataset object.
|
*
|
* Note: Unlike `evaluate()`, this method is asynchronous (`async`).
|
*
|
* @param dataset A dataset object. Its `iterator()` method is expected
|
* to generate a dataset iterator object, the `next()` method of which
|
* is expected to produce data batches for evaluation. The return value
|
* of the `next()` call ought to contain a boolean `done` field and a
|
* `value` field. The `value` field is expected to be an array of two
|
* `tf.Tensor`s or an array of two nested `tf.Tensor` structures. The former
|
* case is for models with exactly one input and one output (e.g.
|
* a sequential model). The latter case is for models with multiple
|
* inputs and/or multiple outputs. Of the two items in the array, the
|
* first is the input feature(s) and the second is the output target(s).
|
* @param args A configuration object for the dataset-based evaluation.
|
* @returns Loss and metric values as an Array of `Scalar` objects.
|
*
|
* @doc {heading: 'Models', subheading: 'Classes'}
|
*/
|
async evaluateDataset(dataset, args) {
|
if (!this.built) {
|
throw new RuntimeError('The model needs to be compiled before being used.');
|
}
|
return this.model.evaluateDataset(dataset, args);
|
}
|
/**
|
* Generates output predictions for the input samples.
|
*
|
* Computation is done in batches.
|
*
|
* Note: the "step" mode of predict() is currently not supported.
|
* This is because the TensorFlow.js core backend is imperative only.
|
*
|
* ```js
|
* const model = tf.sequential({
|
* layers: [tf.layers.dense({units: 1, inputShape: [10]})]
|
* });
|
* model.predict(tf.ones([2, 10])).print();
|
* ```
|
*
|
* @param x The input data, as a Tensor, or an `Array` of `tf.Tensor`s if
|
* the model has multiple inputs.
|
* @param conifg A `ModelPredictConfig` object containing optional fields.
|
*
|
* @return `tf.Tensor`(s) of predictions.
|
*
|
* @exception ValueError In case of mismatch between the provided input data
|
* and the model's expectations, or in case a stateful model receives a
|
* number of samples that is not a multiple of the batch size.
|
*
|
* @doc {heading: 'Models', subheading: 'Classes'}
|
*/
|
predict(x, args = {}) {
|
if (this.model == null) {
|
this.build();
|
}
|
return this.model.predict(x, args);
|
}
|
/**
|
* Returns predictions for a single batch of samples.
|
*
|
* @param x: Input samples, as a Tensor, or list of Tensors (if the model
|
* has multiple inputs).
|
* @return Tensor(s) of predictions
|
*/
|
predictOnBatch(x) {
|
if (this.model == null) {
|
this.build();
|
}
|
return this.model.predictOnBatch(x);
|
}
|
/**
|
* See `LayersModel.compile`.
|
*
|
* @param args
|
*/
|
compile(args) {
|
this.build();
|
this.model.compile(args);
|
this.optimizer_ = this.model.optimizer;
|
// tslint:disable-next-line:no-any
|
this.isOptimizerOwned = this.model.isOptimizerOwned;
|
this.loss = this.model.loss;
|
this.metrics = this.model.metrics;
|
// TODO(cais): Add this.lossWeights, this.sampleWeightMode,
|
// this.weightedMetrics, this.targets.
|
this.metricsTensors = this.model.metricsTensors;
|
this.metricsNames = this.model.metricsNames;
|
// TODO(cais): Add sampleWeights.
|
}
|
get optimizer() {
|
return this.model == null ? undefined : this.model.optimizer;
|
}
|
set optimizer(optimizer) {
|
this.model.optimizer = optimizer;
|
}
|
/**
|
* Trains the model for a fixed number of epochs (iterations on a dataset).
|
*
|
* ```js
|
* const model = tf.sequential({
|
* layers: [tf.layers.dense({units: 1, inputShape: [10]})]
|
* });
|
* model.compile({optimizer: 'sgd', loss: 'meanSquaredError'});
|
* const history = await model.fit(tf.ones([8, 10]), tf.ones([8, 1]), {
|
* batchSize: 4,
|
* epochs: 3
|
* });
|
* console.log(history.history.loss[0]);
|
* ```
|
*
|
* @param x `tf.Tensor` of training data, or an array of `tf.Tensor`s 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.Tensor`s.
|
* @param y `tf.Tensor` of target (label) data, or an array of `tf.Tensor`s 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.Tensor`s.
|
* @param args A `ModelFitConfig`, containing optional fields.
|
*
|
* @return A `History` instance. Its `history` attribute contains all
|
* information collected during training.
|
*
|
* @exception ValueError In case of mismatch between the provided input data
|
* and what the model expects.
|
*
|
* @doc {heading: 'Models', subheading: 'Classes'}
|
*/
|
async fit(x, y, args = {}) {
|
if (!this.built) {
|
throw new RuntimeError('The model needs to be compiled before ' +
|
'being used.');
|
}
|
return this.model.fit(x, y, args);
|
}
|
/**
|
* Trains the model using a dataset object.
|
*
|
* ```js
|
* const xArray = [
|
* [1, 1, 1, 1, 1, 1, 1, 1, 1],
|
* [1, 1, 1, 1, 1, 1, 1, 1, 1],
|
* [1, 1, 1, 1, 1, 1, 1, 1, 1],
|
* [1, 1, 1, 1, 1, 1, 1, 1, 1],
|
* ];
|
* const yArray = [1, 1, 1, 1];
|
* // Create a dataset from the JavaScript array.
|
* const xDataset = tf.data.array(xArray);
|
* const yDataset = tf.data.array(yArray);
|
* // Zip combines the `x` and `y` Datasets into a single Dataset, the
|
* // iterator of which will return an object containing of two tensors,
|
* // corresponding to `x` and `y`. The call to `batch(4)` will bundle
|
* // four such samples into a single object, with the same keys now pointing
|
* // to tensors that hold 4 examples, organized along the batch dimension.
|
* // The call to `shuffle(4)` causes each iteration through the dataset to
|
* // happen in a different order. The size of the shuffle window is 4.
|
* const xyDataset = tf.data.zip({xs: xDataset, ys: yDataset})
|
* .batch(4)
|
* .shuffle(4);
|
* const model = tf.sequential({
|
* layers: [tf.layers.dense({units: 1, inputShape: [9]})]
|
* });
|
* model.compile({optimizer: 'sgd', loss: 'meanSquaredError'});
|
* const history = await model.fitDataset(xyDataset, {
|
* epochs: 4,
|
* callbacks: {onEpochEnd: (epoch, logs) => console.log(logs.loss)}
|
* });
|
* ```
|
*
|
* @param dataset A dataset object. Its `iterator()` method is expected to
|
* generate a dataset iterator object, the `next()` method of which is
|
* expected to produce data batches for evaluation. The return value of the
|
* `next()` call ought to contain a boolean `done` field and a `value`
|
* field.
|
*
|
* The `value` field is expected to be an object of with fields
|
* `xs` and `ys`, which point to the feature tensor and the target tensor,
|
* respectively. This case is for models with exactly one input and one
|
* output (e.g. a sequential model). For example:
|
* ```js
|
* {value: {xs: xsTensor, ys: ysTensor}, done: false}
|
* ```
|
*
|
* If the model has multiple inputs, the `xs` field of `value` should
|
* be an object mapping input names to their respective feature tensors.
|
* For example:
|
* ```js
|
* {
|
* value: {
|
* xs: {
|
* input_1: xsTensor1,
|
* input_2: xsTensor2
|
* },
|
* ys: ysTensor
|
* },
|
* done: false
|
* }
|
* ```
|
* If the model has multiple outputs, the `ys` field of `value` should
|
* be an object mapping output names to their respective target tensors.
|
* For example:
|
* ```js
|
* {
|
* value: {
|
* xs: xsTensor,
|
* ys: {
|
* output_1: ysTensor1,
|
* output_2: ysTensor2
|
* },
|
* },
|
* done: false
|
* }
|
* ```
|
* @param args A `ModelFitDatasetArgs`, containing optional fields.
|
*
|
* @return A `History` instance. Its `history` attribute contains all
|
* information collected during training.
|
*
|
* @doc {heading: 'Models', subheading: 'Classes', ignoreCI: true}
|
*/
|
async fitDataset(dataset, args) {
|
if (!this.built) {
|
throw new RuntimeError('The model needs to be compiled before ' +
|
'being used.');
|
}
|
return this.model.fitDataset(dataset, args);
|
}
|
/**
|
* Runs a single gradient update on a single batch of data.
|
*
|
* This method differs from `fit()` and `fitDataset()` in the following
|
* regards:
|
* - It operates on exactly one batch of data.
|
* - It returns only the loss and metric values, instead of
|
* returning the batch-by-batch loss and metric values.
|
* - It doesn't support fine-grained options such as verbosity and
|
* callbacks.
|
*
|
* @param x Input data. It could be one of the following:
|
* - A `tf.Tensor`, or an Array of `tf.Tensor`s (in case the model has
|
* multiple inputs).
|
* - An Object mapping input names to corresponding `tf.Tensor` (if the
|
* model has named inputs).
|
* @param y Target data. It could be either a `tf.Tensor` or multiple
|
* `tf.Tensor`s. It should be consistent with `x`.
|
* @returns Training loss or losses (in case the model has
|
* multiple outputs), along with metrics (if any), as numbers.
|
*
|
* @doc {heading: 'Models', subheading: 'Classes'}
|
*/
|
async trainOnBatch(x, y) {
|
return this.model.trainOnBatch(x, y);
|
}
|
/* See parent class for JsDoc */
|
/** @nocollapse */
|
static fromConfig(cls, config, customObjects = {}, fastWeightInit = false) {
|
let configArray;
|
let extraModelConfig = {};
|
if (config instanceof Array) {
|
if (!(config[0].className != null) ||
|
config[0]['className'] === 'Merge') {
|
throw new ValueError('Legacy serialization format not supported yet.');
|
}
|
configArray = config;
|
}
|
else {
|
util.assert(config['layers'] != null, () => `When the config data for a Sequential model is not an Array, ` +
|
`it must be an Object that contains the 'layers' field.`);
|
configArray = config['layers'];
|
delete config['layers'];
|
extraModelConfig = config;
|
}
|
const model = new cls(extraModelConfig);
|
if (!(model instanceof Sequential)) {
|
throw new NotImplementedError(`Sequential.fromConfig called on non-Sequential input: ${model}`);
|
}
|
for (const conf of configArray) {
|
const customObjects = undefined;
|
const layer = deserialize(conf, customObjects, fastWeightInit);
|
if (fastWeightInit) {
|
layer.setFastWeightInitDuringBuild(true);
|
}
|
model.add(layer);
|
}
|
return model;
|
}
|
/**
|
* Setter used for force stopping of LayersModel.fit() (i.e., training).
|
*
|
* Example:
|
*
|
* ```js
|
* const model = tf.sequential();
|
* model.add(tf.layers.dense({units: 1, inputShape: [10]}));
|
* model.compile({loss: 'meanSquaredError', optimizer: 'sgd'});
|
* const xs = tf.ones([8, 10]);
|
* const ys = tf.zeros([8, 1]);
|
*
|
* const history = await model.fit(xs, ys, {
|
* epochs: 10,
|
* callbacks: {
|
* onEpochEnd: async (epoch, logs) => {
|
* if (epoch === 2) {
|
* model.stopTraining = true;
|
* }
|
* }
|
* }
|
* });
|
*
|
* // There should be only 3 values in the loss array, instead of 10 values,
|
* // due to the stopping after 3 epochs.
|
* console.log(history.history.loss);
|
* ```
|
*/
|
set stopTraining(stop) {
|
// TODO(cais): When refactoring to remove the composition pattern happens,
|
// remove this method overriding.
|
if (this.model == null) {
|
throw new ValueError('Cannot set the stopTraining property of a sequential model before ' +
|
'it is compiled.');
|
}
|
this.model.stopTraining = stop;
|
}
|
get stopTraining() {
|
if (this.model == null) {
|
throw new ValueError('Cannot get the stopTraining property of a sequential model before ' +
|
'it is compiled.');
|
}
|
return this.model.stopTraining;
|
}
|
// TODO(cais): Override get trainableWeights() here
|
// tslint:disable-next-line:no-any
|
getConfig() {
|
// NOTE(cais): We override the return type of getConfig() to `any` here,
|
// because the `Sequential` class is a special case among `Container`
|
// subtypes in that its getConfig() method returns an Array (not a
|
// dict).
|
const layers = [];
|
for (const layer of this.layers) {
|
const dict = {};
|
dict['className'] = layer.getClassName();
|
dict['config'] = layer.getConfig();
|
layers.push(dict);
|
}
|
return { name: this.name, layers };
|
}
|
}
|
/** @nocollapse */
|
Sequential.className = 'Sequential';
|
export { Sequential };
|
serialization.registerClass(Sequential);
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"models.js","sourceRoot":"","sources":["../../../../../tfjs-layers/src/models.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2018 Google LLC\n *\n * Use of this source code is governed by an MIT-style\n * license that can be found in the LICENSE file or at\n * https://opensource.org/licenses/MIT.\n * =============================================================================\n */\n\n/* Original source keras/models.py */\n\nimport {dispose, io, NamedTensorMap, Optimizer, Scalar, serialization, Tensor, util} from '@tensorflow/tfjs-core';\n\nimport {getUid} from './backend/state';\nimport {History} from './base_callbacks';\nimport {Dataset} from './engine/dataset_stub';\nimport {Input} from './engine/input_layer';\nimport {getSourceInputs, Layer, Node, SymbolicTensor} from './engine/topology';\nimport {LayersModel, ModelCompileArgs, ModelEvaluateArgs} from './engine/training';\nimport {ModelEvaluateDatasetArgs, ModelFitDatasetArgs} from './engine/training_dataset';\nimport {ModelFitArgs} from './engine/training_tensors';\nimport {NotImplementedError, RuntimeError, ValueError} from './errors';\nimport {Shape} from './keras_format/common';\nimport {TrainingConfig} from './keras_format/training_config';\nimport {PyJsonDict} from './keras_format/types';\nimport {deserialize} from './layers/serialization';\nimport {Kwargs, NamedTensor} from './types';\nimport * as generic_utils from './utils/generic_utils';\nimport {convertPythonicToTs} from './utils/serialization_utils';\nimport {getExactlyOneShape} from './utils/types_utils';\n\n/**\n * Parses a JSON model configuration file and returns a model instance.\n *\n * ```js\n * // This example shows how to serialize a model using `toJSON()` and\n * // deserialize it as another model using `tf.models.modelFromJSON()`.\n * // Note: this example serializes and deserializes only the topology\n * // of the model; the weights of the loaded model will be different\n * // from those of the the original model, due to random weight\n * // initialization.\n * // To load the topology and weights of a model, use `tf.loadLayersModel()`.\n * const model1 = tf.sequential();\n * model1.add(tf.layers.repeatVector({inputShape: [2], n: 4}));\n * // Serialize `model1` as a JSON object.\n * const model1JSON = model1.toJSON(null, false);\n * model1.summary();\n *\n * const model2 = await tf.models.modelFromJSON(model1JSON);\n * model2.summary();\n * ```\n *\n *  @param modelAndWeightsConfig JSON object or string encoding a model and\n *       weights configuration. It can also be only the topology JSON of the\n *       model, in which case the weights will not be loaded.\n *  @param custom_objects Optional dictionary mapping names\n *       (strings) to custom classes or functions to be\n *       considered during deserialization.\n * @returns A TensorFlow.js Layers `tf.LayersModel` instance (uncompiled).\n */\nexport async function modelFromJSON(\n    modelAndWeightsConfig: ModelAndWeightsConfig|PyJsonDict,\n    customObjects?: serialization.ConfigDict): Promise<LayersModel> {\n  if (!('modelTopology' in modelAndWeightsConfig)) {\n    modelAndWeightsConfig = {modelTopology: modelAndWeightsConfig};\n  }\n  modelAndWeightsConfig = modelAndWeightsConfig as ModelAndWeightsConfig;\n\n  let modelTopology = modelAndWeightsConfig.modelTopology;\n  if (modelTopology['model_config'] != null) {\n    // If the model-topology JSON contains a 'model_config' field, then it is\n    // a full model JSON (e.g., from `keras.Model.save()`), which contains\n    // not only the model's architecture in its 'model_config' field, but\n    // additional information such as the model's optimizer. We use only the\n    // 'model_config' field currently.\n    modelTopology = modelTopology['model_config'] as PyJsonDict;\n  }\n  const tsConfig =\n      convertPythonicToTs(modelTopology) as serialization.ConfigDict;\n  const model = deserialize(tsConfig, customObjects) as LayersModel;\n\n  if (modelAndWeightsConfig.weightsManifest != null) {\n    // Load the weight values keyed by the original tensor names in the model\n    // file that was loaded.  These should match the keys of the weight\n    // manifest.\n    const weightValues = await io.loadWeights(\n        modelAndWeightsConfig.weightsManifest, modelAndWeightsConfig.pathPrefix,\n        model.weights.map(weight => weight.originalName));\n\n    // Map the weights to the unique tensor names generated during model loading\n    const uniqueWeightValues: NamedTensorMap = {};\n    for (const weight of model.weights) {\n      uniqueWeightValues[weight.originalName] =\n          weightValues[weight.originalName];\n    }\n\n    model.loadWeights(uniqueWeightValues);\n    // Dispose temporary weight values.\n    dispose(weightValues);\n  }\n  return model;\n}\n\n/**\n * Options for loading a saved mode in TensorFlow.js format.\n */\nexport interface ModelAndWeightsConfig {\n  /**\n   * A JSON object or JSON string containing the model config.\n   *\n   * This can be either of the following two formats:\n   *   - A model archiecture-only config,  i.e., a format consistent with the\n   *     return value of`keras.Model.to_json()`.\n   *   - A full model config, containing not only model architecture, but also\n   *     training options and state, i.e., a format consistent with the return\n   *     value of `keras.models.save_model()`.\n   */\n  modelTopology: PyJsonDict;\n\n  /**\n   * A weights manifest in TensorFlow.js format.\n   */\n  weightsManifest?: io.WeightsManifestConfig;\n\n  /**\n   * Path to prepend to the paths in `weightManifest` before fetching.\n   *\n   * The path may optionally end in a slash ('/').\n   */\n  pathPrefix?: string;\n}\n\n// TODO(nielsene): Remove after: https://github.com/tensorflow/tfjs/issues/400\nexport interface ModelPredictArgs {\n  /**\n   * Optional. Batch size (Integer). If unspecified, it will default to 32.\n   */\n  batchSize?: number;\n\n  /**\n   * Optional. Verbosity mode. Defaults to false.\n   */\n  verbose?: boolean;\n}\n\n/**\n * Load a model composed of Layer objects, including its topology and optionally\n * weights. See the Tutorial named \"How to import a Keras Model\" for usage\n * examples.\n *\n * This method is applicable to:\n *\n * 1. Models created with the `tf.layers.*`, `tf.sequential`, and\n * `tf.model` APIs of TensorFlow.js and later saved with the\n * `tf.LayersModel.save` method.\n * 2. Models converted from Keras or TensorFlow tf.keras using the\n * [tensorflowjs_converter](https://github.com/tensorflow/tfjs/tree/master/tfjs-converter).\n *\n * This mode is *not* applicable to TensorFlow `SavedModel`s or their converted\n * forms. For those models, use `tf.loadGraphModel`.\n *\n * Example 1. Load a model from an HTTP server.\n *\n * ```js\n * const model = await tf.loadLayersModel(\n *     'https://storage.googleapis.com/tfjs-models/tfjs/iris_v1/model.json');\n * model.summary();\n * ```\n *\n * Example 2: Save `model`'s topology and weights to browser [local\n * storage](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage);\n * then load it back.\n *\n * ```js\n * const model = tf.sequential(\n *     {layers: [tf.layers.dense({units: 1, inputShape: [3]})]});\n * console.log('Prediction from original model:');\n * model.predict(tf.ones([1, 3])).print();\n *\n * const saveResults = await model.save('localstorage://my-model-1');\n *\n * const loadedModel = await tf.loadLayersModel('localstorage://my-model-1');\n * console.log('Prediction from loaded model:');\n * loadedModel.predict(tf.ones([1, 3])).print();\n * ```\n *\n * Example 3. Saving `model`'s topology and weights to browser\n * [IndexedDB](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API);\n * then load it back.\n *\n * ```js\n * const model = tf.sequential(\n *     {layers: [tf.layers.dense({units: 1, inputShape: [3]})]});\n * console.log('Prediction from original model:');\n * model.predict(tf.ones([1, 3])).print();\n *\n * const saveResults = await model.save('indexeddb://my-model-1');\n *\n * const loadedModel = await tf.loadLayersModel('indexeddb://my-model-1');\n * console.log('Prediction from loaded model:');\n * loadedModel.predict(tf.ones([1, 3])).print();\n * ```\n *\n * Example 4. Load a model from user-selected files from HTML\n * [file input\n * elements](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/file).\n *\n * ```js\n * // Note: this code snippet will not work without the HTML elements in the\n * //   page\n * const jsonUpload = document.getElementById('json-upload');\n * const weightsUpload = document.getElementById('weights-upload');\n *\n * const model = await tf.loadLayersModel(\n *     tf.io.browserFiles([jsonUpload.files[0], weightsUpload.files[0]]));\n * ```\n *\n * @param pathOrIOHandler Can be either of the two formats\n *   1. A string path to the `ModelAndWeightsConfig` JSON describing\n *      the model in the canonical TensorFlow.js format. For file://\n *      (tfjs-node-only), http:// and https:// schemas, the path can be\n *      either absolute or relative. The content of the JSON file is assumed to\n *      be a JSON object with the following fields and values:\n *      - 'modelTopology': A JSON object that can be either of:\n *        1. a model architecture JSON consistent with the format of the return\n *            value of `keras.Model.to_json()`\n *        2. a full model JSON in the format of `keras.models.save_model()`.\n *      - 'weightsManifest': A TensorFlow.js weights manifest.\n *      See the Python converter function `save_model()` for more details.\n *      It is also assumed that model weights can be accessed from relative\n *      paths described by the `paths` fields in weights manifest.\n *   2. A `tf.io.IOHandler` object that loads model artifacts with its `load`\n *      method.\n * @param options Optional configuration arguments for the model loading,\n *   including:\n *   - `strict`: Require that the provided weights exactly match those required\n *     by the layers.  Default true.  Passing false means that both extra\n *     weights and missing weights will be silently ignored.\n *   - `onProgress`: A progress callback of the form:\n *     `(fraction: number) => void`. This callback can be used to monitor the\n *     model-loading process.\n * @returns A `Promise` of `tf.LayersModel`, with the topology and weights\n *     loaded.\n *\n * @doc {heading: 'Models', subheading: 'Loading'}\n */\nexport async function loadLayersModel(\n    pathOrIOHandler: string|io.IOHandler,\n    options?: io.LoadOptions): Promise<LayersModel> {\n  if (options == null) {\n    options = {};\n  }\n  if (typeof pathOrIOHandler === 'string') {\n    const handlers = io.getLoadHandlers(pathOrIOHandler, options);\n    if (handlers.length === 0) {\n      // For backward compatibility: if no load handler can be found,\n      // assume it is a relative http path.\n      // TODO(cais): Reformat the args into a single `LoadOptions` once the core\n      // is refactored.\n      handlers.push(io.browserHTTPRequest(pathOrIOHandler, options));\n    } else if (handlers.length > 1) {\n      throw new ValueError(\n          `Found more than one (${handlers.length}) load handlers for ` +\n          `URL '${pathOrIOHandler}'`);\n    }\n    pathOrIOHandler = handlers[0];\n  }\n  return loadLayersModelFromIOHandler(pathOrIOHandler, undefined, options);\n}\n\n/**\n * Load a model and optionally its weights, using an IOHandler object.\n *\n * @param handler The instance of `IOHandler` to be used during the model\n *   loading.\n * @param customObjects Any optional custom objects to be used during model\n *   loading.\n * @param strict Whether the weight loading will be done in strict mode.\n *   Default: `true`.\n */\nexport async function loadLayersModelFromIOHandler(\n    handler: io.IOHandler, customObjects?: serialization.ConfigDict,\n    options?: io.LoadOptions): Promise<LayersModel> {\n  if (options == null) {\n    options = {};\n  }\n  if (handler.load == null) {\n    throw new ValueError(\n        'Cannot proceed with model loading because the IOHandler provided ' +\n        'does not have the `load` method implemented.');\n  }\n  const artifacts = await handler.load();\n  let modelTopology = artifacts.modelTopology as PyJsonDict;\n  if (modelTopology['model_config'] != null) {\n    modelTopology = modelTopology['model_config'] as PyJsonDict;\n  }\n\n  const strict = options.strict == null ? true : options.strict;\n  // If weights are provided and the weight-loading mode is strict, use\n  // fast weight initialization. This skips costly initializers such as\n  // 'orthogonal' and saves unnecessary computation in cases where\n  // the initialized weight values will immediately be overwritten by\n  // loaded weight values.\n  const fastWeightInit =\n      artifacts.weightData != null && artifacts.weightSpecs != null && strict;\n  const model =\n      deserialize(\n          convertPythonicToTs(modelTopology) as serialization.ConfigDict,\n          customObjects, fastWeightInit) as LayersModel;\n\n  const trainingConfig = artifacts.trainingConfig as TrainingConfig;\n  if (trainingConfig != null) {\n    model.loadTrainingConfig(trainingConfig);\n  }\n  if (artifacts.userDefinedMetadata != null) {\n    model.setUserDefinedMetadata(artifacts.userDefinedMetadata);\n  }\n\n  // If weightData is present, load the weights into the model.\n  if (artifacts.weightData != null) {\n    // Loading weights requires weightSpecs.\n    if (artifacts.weightSpecs == null) {\n      throw new ValueError(\n          'LayersModel artifacts contains weight data, but not weight specs. ' +\n          'Therefore loading of weights cannot proceed.');\n    }\n\n    const {modelWeights, optimizerWeights} = decodeModelAndOptimizerWeights(\n        artifacts.weightData, artifacts.weightSpecs);\n    model.loadWeights(modelWeights, strict);\n\n    if (model.optimizer != null && optimizerWeights.length > 0) {\n      await model.optimizer.setWeights(optimizerWeights);\n    }\n\n    // Dispose temporary weight values.\n    dispose(modelWeights);\n    dispose(optimizerWeights.map(w => w.tensor));\n  }\n  return model;\n}\n\nfunction decodeModelAndOptimizerWeights(\n    weightData: io.WeightData, specs: io.WeightsManifestEntry[]):\n    {modelWeights: NamedTensorMap, optimizerWeights: NamedTensor[]} {\n  const name2Tensor = io.decodeWeights(weightData, specs);\n  const modelWeights: NamedTensorMap = {};\n  const optimizerWeights: NamedTensor[] = [];\n  specs.forEach(spec => {\n    if (spec.group === 'optimizer') {\n      optimizerWeights.push({name: spec.name, tensor: name2Tensor[spec.name]});\n    } else {\n      modelWeights[spec.name] = name2Tensor[spec.name];\n    }\n  });\n  return {modelWeights, optimizerWeights};\n}\n\n/**\n * Configuration for a Sequential model.\n */\nexport interface SequentialArgs {\n  /** Stack of layers for the model. */\n  layers?: Layer[];\n\n  /** The name of this model. */\n  name?: string;\n}\n\n/**\n * A model with a stack of layers, feeding linearly from one to the next.\n *\n * `tf.sequential` is a factory function that creates an instance of\n * `tf.Sequential`.\n *\n * ```js\n *  // Define a model for linear regression.\n *  const model = tf.sequential();\n *  model.add(tf.layers.dense({units: 1, inputShape: [1]}));\n *\n *  // Prepare the model for training: Specify the loss and the optimizer.\n *  model.compile({loss: 'meanSquaredError', optimizer: 'sgd'});\n *\n *  // Generate some synthetic data for training.\n *  const xs = tf.tensor2d([1, 2, 3, 4], [4, 1]);\n *  const ys = tf.tensor2d([1, 3, 5, 7], [4, 1]);\n *\n *  // Train the model using the data then do inference on a data point the\n *  // model hasn't seen:\n *  await model.fit(xs, ys);\n *  model.predict(tf.tensor2d([5], [1, 1])).print();\n * ```\n *\n * @doc {heading: 'Models', subheading: 'Classes'}\n */\nexport class Sequential extends LayersModel {\n  /** @nocollapse */\n  static override className = 'Sequential';\n  private model: LayersModel;\n  constructor(args?: SequentialArgs) {\n    super({inputs: [], outputs: []});\n    args = args || {};\n\n    this.trainable = true;\n    this.built = false;\n\n    // Set model name.\n    this.name = (args.name != null) ? args.name : getUid('sequential_');\n\n    // Add to the model any layers passed to the constructor.\n    if (args.layers != null) {\n      for (const layer of args.layers) {\n        this.add(layer);\n      }\n    }\n  }\n\n  // Helper function to Sequential.add  Throws if the new output shape will be\n  // invalid.\n  private checkShape(layer: Layer) {\n    const shape = layer.inboundNodes[0].outputTensors[0].shape;\n    if (shape.some(x => x < 0)) {\n      throw new ValueError(\n          'Negative dimension size caused by adding layer ' +\n          `${layer.name} with input shape [` +\n          `${layer.inboundNodes[0].inputTensors[0].shape}]`);\n    }\n  }\n\n  /**\n   * Adds a layer instance on top of the layer stack.\n   *\n   * ```js\n   *  const model = tf.sequential();\n   *  model.add(tf.layers.dense({units: 8, inputShape: [1]}));\n   *  model.add(tf.layers.dense({units: 4, activation: 'relu6'}));\n   *  model.add(tf.layers.dense({units: 1, activation: 'relu6'}));\n   *  // Note that the untrained model is random at this point.\n   *  model.predict(tf.randomNormal([10, 1])).print();\n   * ```\n   * @param layer Layer instance.\n   *\n   * @exception ValueError In case the `layer` argument does not know its\n   * input shape.\n   * @exception ValueError In case the `layer` argument has multiple output\n   *   tensors, or is already connected somewhere else (forbidden in\n   *   `Sequential` models).\n   *\n   * @doc {heading: 'Models', subheading: 'Classes'}\n   */\n  add(layer: Layer): void {\n    const isLayerModelInstance =\n        layer instanceof Sequential || layer instanceof LayersModel;\n    let modelLayer: LayersModel;\n    if (isLayerModelInstance) {\n      modelLayer = layer as LayersModel;\n      if (modelLayer.outputs.length !== 1) {\n        throw new ValueError(\n            'All layers in a Sequential model ' +\n            'should have a single output tensor. ' +\n            'For multi-output layers, ' +\n            'use the functional API.');\n      }\n      if (modelLayer.inputs.length !== 1) {\n        throw new ValueError(\n            'All layers in a Sequential model ' +\n            'should have a single input tensor. ' +\n            'For multi-input layers, ' +\n            'use the functional API.');\n      }\n    }\n\n    if (this.outputs.length === 0) {\n      // first layer in model: check that it is an input layer\n      if (layer.inboundNodes.length === 0) {\n        // create an input layer\n        if (layer.batchInputShape == null) {\n          throw new ValueError(\n              'The first layer in a Sequential model must ' +\n              'get an `inputShape` or `batchInputShape` argument.');\n        }\n        // Instantiate the input layer.\n        const x = Input({\n          batchShape: layer.batchInputShape,\n          dtype: layer.dtype,\n          name: layer.name + '_input'\n        });\n        // This will build the current layer and create the node connecting\n        // the current layer to the input layer we just created.\n        layer.apply(x);\n      }\n\n      if (isLayerModelInstance) {\n        this.outputs = modelLayer.outputs;\n        this.inputs = modelLayer.inputs;\n      } else {\n        if (layer.inboundNodes.length !== 1) {\n          throw new ValueError(\n              'A layer added to a Sequential model must not already be ' +\n              `connected somewhere else. LayersModel received layer ${\n                  layer.name} ` +\n              `which has ${layer.inboundNodes.length} pre-existing inbound ` +\n              'connections.');\n        }\n\n        if (layer.inboundNodes[0].outputTensors.length !== 1) {\n          throw new ValueError(\n              'All layers in a Sequential model ' +\n              'should have a single output tensor. ' +\n              'For multi-output layers, ' +\n              'use the functional API.');\n        }\n        this.checkShape(layer);\n        this.outputs = [layer.inboundNodes[0].outputTensors[0]];\n        this.inputs = getSourceInputs(this.outputs[0]);\n      }\n\n      this.inboundNodes = [];\n      // We create an input node, which we will keep updated\n      // as we add more layers.\n      // (This call has side effects.)\n      // tslint:disable-next-line:no-unused-expression\n      new Node({\n        outboundLayer: this,\n        inboundLayers: [],\n        nodeIndices: [],\n        tensorIndices: [],\n        inputTensors: this.inputs,\n        outputTensors: this.outputs,\n        // no model-level masking for now\n        inputMasks: generic_utils.pyListRepeat(null, this.inputs.length),\n        outputMasks: [null],\n        inputShapes: this.inputs.map(x => x.shape),\n        outputShapes: this.outputs[0].shape\n      });\n    } else {\n      const outputTensor = layer.apply(this.outputs[0]);\n      if (Array.isArray(outputTensor)) {\n        throw new TypeError(\n            'All layers in a Sequential model ' +\n            'should have a single output tensor. ' +\n            'For multi-output layers, ' +\n            'use the functional API.');\n      }\n      this.checkShape(layer);\n      this.outputs = [outputTensor as SymbolicTensor];\n      // update self.inbound_nodes\n      this.inboundNodes[0].outputTensors = this.outputs;\n      this.inboundNodes[0].outputShapes = [this.outputs[0].shape];\n    }\n\n    this.layers.push(layer);\n    this.built = false;\n  }\n\n  /**\n   * Removes the last layer in the model.\n   *\n   * @exception TypeError if there are no layers in the model.\n   */\n  pop(): void {\n    if (this.layers.length === 0) {\n      throw new TypeError('There are no layers in the model.');\n    }\n\n    this.layers.pop();\n    if (this.layers.length === 0) {\n      this.outputs = [];\n      this.inboundNodes = [];\n      this.outboundNodes = [];\n    } else {\n      const lastLayerIndex = this.layers.length - 1;\n      this.layers[lastLayerIndex].outboundNodes = [];\n      this.outputs = [this.layers[lastLayerIndex].output as SymbolicTensor];\n      // update self.inbound_nodes\n      this.inboundNodes[0].outputTensors = this.outputs;\n      this.inboundNodes[0].outputShapes = [this.outputs[0].shape];\n    }\n  }\n\n  override call(inputs: Tensor|Tensor[], kwargs: Kwargs): Tensor|Tensor[] {\n    if (this.model == null) {\n      this.build();\n    }\n    return this.model.call(inputs, kwargs);\n  }\n\n  override build(inputShape?: Shape|Shape[]) {\n    // Call `getExactlyOneShape` without using its return value,\n    // to verify that exactly one input shape is provided.\n    getExactlyOneShape(inputShape);\n\n    if (this.inputs.length === 0 || this.outputs.length === 0) {\n      throw new TypeError(\n          'Sequential model cannot be built: model is empty.' +\n          ' Add some layers first.');\n    }\n    // actually create the model\n    this.model = new LayersModel({\n      inputs: this.inputs,\n      outputs: this.outputs[0],\n      name: this.name + '_model'\n    });\n    this.model.trainable = this.trainable;\n\n    // mirror model attributes\n    this.supportsMasking = this.model.supportsMasking;\n    // TODO(michaelterry): Add caches\n    this.inputLayers = this.model.inputLayers;\n    this.inputLayersNodeIndices = this.model.inputLayersNodeIndices;\n    this.inputLayersTensorIndices = this.model.inputLayersTensorIndices;\n    this.outputLayers = this.model.outputLayers;\n    this.outputLayersNodeIndices = this.model.outputLayersNodeIndices;\n    this.outputLayersTensorIndices = this.model.outputLayersTensorIndices;\n    this.nodesByDepth = this.model.nodesByDepth;\n    this.containerNodes = this.model.containerNodes;\n    this.outputNames = this.model.outputNames;\n    this.inputNames = this.model.inputNames;\n    // TODO(michaelterry): Add feedInputNames, feedInputs, if needed.\n    // TODO(michaelterry): Add callbackModel if needed.\n    this.built = true;\n  }\n\n  override countParams(): number {\n    if (!this.built) {\n      this.build();\n    }\n    return super.countParams();\n  }\n\n  /**\n   * Print a text summary of the Sequential model's layers.\n   *\n   * The summary includes\n   * - Name and type of all layers that comprise the model.\n   * - Output shape(s) of the layers\n   * - Number of weight parameters of each layer\n   * - The total number of trainable and non-trainable parameters of the\n   * model.\n   *\n   * ```js\n   * const model = tf.sequential();\n   * model.add(\n   *     tf.layers.dense({units: 100, inputShape: [10], activation: 'relu'}));\n   * model.add(tf.layers.dense({units: 1, activation: 'sigmoid'}));\n   *\n   * model.summary();\n   * ```\n   *\n   * @param lineLength Custom line length, in number of characters.\n   * @param positions Custom widths of each of the columns, as either\n   *   fractions of `lineLength` (e.g., `[0.5, 0.75, 1]`) or absolute number\n   *   of characters (e.g., `[30, 50, 65]`). Each number corresponds to\n   *   right-most (i.e., ending) position of a column.\n   * @param printFn Custom print function. Can be used to replace the default\n   *   `console.log`. For example, you can use `x => {}` to mute the printed\n   *   messages in the console.\n   *\n   * @doc {heading: 'Models', subheading: 'Classes'}\n   */\n  override summary(\n      lineLength?: number, positions?: number[],\n      printFn:\n          // tslint:disable-next-line:no-any\n      (message?: any, ...optionalParams: any[]) => void = console.log) {\n    if (!this.built) {\n      this.build();\n    }\n    super.summary(lineLength, positions, printFn);\n  }\n\n  /**\n   * Sets the weights of the model.\n   *\n   * @param weights Should be a list of Tensors with shapes and types matching\n   *   the output of `model.getWeights()`.\n   */\n  override setWeights(weights: Tensor[]): void {\n    if (this.model == null) {\n      this.build();\n    }\n    this.model.setWeights(weights);\n  }\n\n  /**\n   * Returns the loss value & metrics values for the model in test mode.\n   *\n   * Loss and metrics are specified during `compile()`, which needs to happen\n   * before calls to `evaluate()`.\n   *\n   * Computation is done in batches.\n   *\n   * ```js\n   * const model = tf.sequential({\n   *   layers: [tf.layers.dense({units: 1, inputShape: [10]})]\n   * });\n   * model.compile({optimizer: 'sgd', loss: 'meanSquaredError'});\n   * const result = model.evaluate(tf.ones([8, 10]), tf.ones([8, 1]), {\n   *   batchSize: 4,\n   * });\n   * result.print();\n   * ```\n   *\n   * @param x `tf.Tensor` of test data, or an `Array` of `tf.Tensor`s if the\n   * model has multiple inputs.\n   * @param y `tf.Tensor` of target data, or an `Array` of `tf.Tensor`s if the\n   * model has multiple outputs.\n   * @param args A `ModelEvaluateConfig`, containing optional fields.\n   *\n   * @return `Scalar` test loss (if the model has a single output and no\n   *   metrics) or `Array` of `Scalar`s (if the model has multiple outputs\n   *   and/or metrics). The attribute `model.metricsNames`\n   *   will give you the display labels for the scalar outputs.\n   *\n   * @doc {heading: 'Models', subheading: 'Classes'}\n   */\n  override evaluate(\n      x: Tensor|Tensor[], y: Tensor|Tensor[],\n      args: ModelEvaluateArgs = {}): Scalar|Scalar[] {\n    if (!this.built) {\n      throw new RuntimeError(\n          'The model needs to be compiled before being used.');\n    }\n    return this.model.evaluate(x, y, args);\n  }\n\n  // TODO(cais): Add code snippet below once real dataset objects are\n  //   available.\n  /**\n   * Evaluate model using a dataset object.\n   *\n   * Note: Unlike `evaluate()`, this method is asynchronous (`async`).\n   *\n   * @param dataset A dataset object. Its `iterator()` method is expected\n   *   to generate a dataset iterator object, the `next()` method of which\n   *   is expected to produce data batches for evaluation. The return value\n   *   of the `next()` call ought to contain a boolean `done` field and a\n   *   `value` field. The `value` field is expected to be an array of two\n   *   `tf.Tensor`s or an array of two nested `tf.Tensor` structures. The former\n   *   case is for models with exactly one input and one output (e.g.\n   *   a sequential model). The latter case is for models with multiple\n   *   inputs and/or multiple outputs. Of the two items in the array, the\n   *   first is the input feature(s) and the second is the output target(s).\n   * @param args A configuration object for the dataset-based evaluation.\n   * @returns Loss and metric values as an Array of `Scalar` objects.\n   *\n   * @doc {heading: 'Models', subheading: 'Classes'}\n   */\n  override async evaluateDataset(dataset: Dataset<{}>,\n      args: ModelEvaluateDatasetArgs): Promise<Scalar|Scalar[]> {\n    if (!this.built) {\n      throw new RuntimeError(\n          'The model needs to be compiled before being used.');\n    }\n    return this.model.evaluateDataset(dataset, args);\n  }\n\n  /**\n   * Generates output predictions for the input samples.\n   *\n   * Computation is done in batches.\n   *\n   * Note: the \"step\" mode of predict() is currently not supported.\n   *   This is because the TensorFlow.js core backend is imperative only.\n   *\n   * ```js\n   * const model = tf.sequential({\n   *   layers: [tf.layers.dense({units: 1, inputShape: [10]})]\n   * });\n   * model.predict(tf.ones([2, 10])).print();\n   * ```\n   *\n   * @param x The input data, as a Tensor, or an `Array` of `tf.Tensor`s if\n   *   the model has multiple inputs.\n   * @param conifg A `ModelPredictConfig` object containing optional fields.\n   *\n   * @return `tf.Tensor`(s) of predictions.\n   *\n   * @exception ValueError In case of mismatch between the provided input data\n   *   and the model's expectations, or in case a stateful model receives a\n   *   number of samples that is not a multiple of the batch size.\n   *\n   * @doc {heading: 'Models', subheading: 'Classes'}\n   */\n  override predict(x: Tensor|Tensor[], args: ModelPredictArgs = {}):\n      Tensor|Tensor[] {\n    if (this.model == null) {\n      this.build();\n    }\n    return this.model.predict(x, args);\n  }\n\n  /**\n   * Returns predictions for a single batch of samples.\n   *\n   * @param x: Input samples, as a Tensor, or list of Tensors (if the model\n   *   has multiple inputs).\n   * @return Tensor(s) of predictions\n   */\n  override predictOnBatch(x: Tensor): Tensor|Tensor[] {\n    if (this.model == null) {\n      this.build();\n    }\n    return this.model.predictOnBatch(x);\n  }\n\n  /**\n   * See `LayersModel.compile`.\n   *\n   * @param args\n   */\n  override compile(args: ModelCompileArgs): void {\n    this.build();\n    this.model.compile(args);\n    this.optimizer_ = this.model.optimizer;\n    // tslint:disable-next-line:no-any\n    this.isOptimizerOwned = (this.model as any).isOptimizerOwned;\n    this.loss = this.model.loss;\n    this.metrics = this.model.metrics;\n    // TODO(cais): Add this.lossWeights, this.sampleWeightMode,\n    //   this.weightedMetrics, this.targets.\n    this.metricsTensors = this.model.metricsTensors;\n    this.metricsNames = this.model.metricsNames;\n    // TODO(cais): Add sampleWeights.\n  }\n\n  override get optimizer(): Optimizer {\n    return this.model == null ? undefined : this.model.optimizer;\n  }\n\n  override set optimizer(optimizer: Optimizer) {\n    this.model.optimizer = optimizer;\n  }\n\n  /**\n   * Trains the model for a fixed number of epochs (iterations on a dataset).\n   *\n   * ```js\n   * const model = tf.sequential({\n   *   layers: [tf.layers.dense({units: 1, inputShape: [10]})]\n   * });\n   * model.compile({optimizer: 'sgd', loss: 'meanSquaredError'});\n   * const history = await model.fit(tf.ones([8, 10]), tf.ones([8, 1]), {\n   *   batchSize: 4,\n   *   epochs: 3\n   * });\n   * console.log(history.history.loss[0]);\n   * ```\n   *\n   * @param x `tf.Tensor` of training data, or an array of `tf.Tensor`s if the\n   * model has multiple inputs. If all inputs in the model are named, you can\n   * also pass a dictionary mapping input names to `tf.Tensor`s.\n   * @param y `tf.Tensor` of target (label) data, or an array of `tf.Tensor`s if\n   * the model has multiple outputs. If all outputs in the model are named, you\n   *  can also pass a dictionary mapping output names to `tf.Tensor`s.\n   * @param args  A `ModelFitConfig`, containing optional fields.\n   *\n   * @return A `History` instance. Its `history` attribute contains all\n   *   information collected during training.\n   *\n   * @exception ValueError In case of mismatch between the provided input data\n   *   and what the model expects.\n   *\n   * @doc {heading: 'Models', subheading: 'Classes'}\n   */\n  override async fit(\n      x: Tensor|Tensor[]|{[inputName: string]: Tensor},\n      y: Tensor|Tensor[]|{[inputName: string]: Tensor},\n      args: ModelFitArgs = {}): Promise<History> {\n    if (!this.built) {\n      throw new RuntimeError(\n          'The model needs to be compiled before ' +\n          'being used.');\n    }\n    return this.model.fit(x, y, args);\n  }\n\n  /**\n   * Trains the model using a dataset object.\n   *\n   * ```js\n   * const xArray = [\n   *   [1, 1, 1, 1, 1, 1, 1, 1, 1],\n   *   [1, 1, 1, 1, 1, 1, 1, 1, 1],\n   *   [1, 1, 1, 1, 1, 1, 1, 1, 1],\n   *   [1, 1, 1, 1, 1, 1, 1, 1, 1],\n   * ];\n   * const yArray = [1, 1, 1, 1];\n   * // Create a dataset from the JavaScript array.\n   * const xDataset = tf.data.array(xArray);\n   * const yDataset = tf.data.array(yArray);\n   * // Zip combines the `x` and `y` Datasets into a single Dataset, the\n   * // iterator of which will return an object containing of two tensors,\n   * // corresponding to `x` and `y`.  The call to `batch(4)` will bundle\n   * // four such samples into a single object, with the same keys now pointing\n   * // to tensors that hold 4 examples, organized along the batch dimension.\n   * // The call to `shuffle(4)` causes each iteration through the dataset to\n   * // happen in a different order.  The size of the shuffle window is 4.\n   * const xyDataset = tf.data.zip({xs: xDataset, ys: yDataset})\n   *     .batch(4)\n   *     .shuffle(4);\n   * const model = tf.sequential({\n   *   layers: [tf.layers.dense({units: 1, inputShape: [9]})]\n   * });\n   * model.compile({optimizer: 'sgd', loss: 'meanSquaredError'});\n   * const history = await model.fitDataset(xyDataset, {\n   *   epochs: 4,\n   *   callbacks: {onEpochEnd: (epoch, logs) => console.log(logs.loss)}\n   * });\n   * ```\n   *\n   * @param dataset A dataset object. Its `iterator()` method is expected to\n   *   generate a dataset iterator object, the `next()` method of which is\n   *   expected to produce data batches for evaluation. The return value of the\n   *   `next()` call ought to contain a boolean `done` field and a `value`\n   *   field.\n   *\n   *   The `value` field is expected to be an object of with fields\n   *   `xs` and `ys`, which point to the feature tensor and the target tensor,\n   *   respectively. This case is for models with exactly one input and one\n   *   output (e.g. a sequential model). For example:\n   *   ```js\n   *   {value: {xs: xsTensor, ys: ysTensor}, done: false}\n   *   ```\n   *\n   *   If the model has multiple inputs, the `xs` field of `value` should\n   *   be an object mapping input names to their respective feature tensors.\n   *   For example:\n   *   ```js\n   *   {\n   *     value: {\n   *       xs: {\n   *         input_1: xsTensor1,\n   *         input_2: xsTensor2\n   *       },\n   *       ys: ysTensor\n   *     },\n   *     done: false\n   *   }\n   *   ```\n   *   If the model has multiple outputs, the `ys` field of `value` should\n   *   be an object mapping output names to their respective target tensors.\n   *   For example:\n   *   ```js\n   *   {\n   *     value: {\n   *       xs: xsTensor,\n   *       ys: {\n   *         output_1: ysTensor1,\n   *         output_2: ysTensor2\n   *       },\n   *     },\n   *     done: false\n   *   }\n   *   ```\n   * @param args A `ModelFitDatasetArgs`, containing optional fields.\n   *\n   * @return A `History` instance. Its `history` attribute contains all\n   *   information collected during training.\n   *\n   * @doc {heading: 'Models', subheading: 'Classes', ignoreCI: true}\n   */\n  override async fitDataset<T>(dataset: Dataset<T>,\n      args: ModelFitDatasetArgs<T>): Promise<History> {\n    if (!this.built) {\n      throw new RuntimeError(\n          'The model needs to be compiled before ' +\n          'being used.');\n    }\n    return this.model.fitDataset(dataset, args);\n  }\n\n  /**\n   * Runs a single gradient update on a single batch of data.\n   *\n   * This method differs from `fit()` and `fitDataset()` in the following\n   * regards:\n   *   - It operates on exactly one batch of data.\n   *   - It returns only the loss and metric values, instead of\n   *     returning the batch-by-batch loss and metric values.\n   *   - It doesn't support fine-grained options such as verbosity and\n   *     callbacks.\n   *\n   * @param x Input data. It could be one of the following:\n   *   - A `tf.Tensor`, or an Array of `tf.Tensor`s (in case the model has\n   *     multiple inputs).\n   *   - An Object mapping input names to corresponding `tf.Tensor` (if the\n   *     model has named inputs).\n   * @param y Target data. It could be either a `tf.Tensor` or multiple\n   *   `tf.Tensor`s. It should be consistent with `x`.\n   * @returns Training loss or losses (in case the model has\n   *   multiple outputs), along with metrics (if any), as numbers.\n   *\n   * @doc {heading: 'Models', subheading: 'Classes'}\n   */\n  override async trainOnBatch(\n      x: Tensor|Tensor[]|{[inputName: string]: Tensor},\n      y: Tensor|Tensor[]|\n      {[inputName: string]: Tensor}): Promise<number|number[]> {\n    return this.model.trainOnBatch(x, y);\n  }\n\n  /* See parent class for JsDoc */\n  /** @nocollapse */\n  static override fromConfig<T extends serialization.Serializable>(\n      cls: serialization.SerializableConstructor<T>,\n      config: serialization.ConfigDict,\n      customObjects = {} as serialization.ConfigDict,\n      fastWeightInit = false): T {\n    let configArray: serialization.ConfigDictArray;\n    let extraModelConfig: serialization.ConfigDict = {};\n    if (config instanceof Array) {\n      if (!(config[0].className != null) ||\n          config[0]['className'] === 'Merge') {\n        throw new ValueError('Legacy serialization format not supported yet.');\n      }\n      configArray = config;\n    } else {\n      util.assert(\n          config['layers'] != null,\n          () =>\n              `When the config data for a Sequential model is not an Array, ` +\n              `it must be an Object that contains the 'layers' field.`);\n      configArray = config['layers'] as serialization.ConfigDictArray;\n      delete config['layers'];\n      extraModelConfig = config;\n    }\n\n    const model = new cls(extraModelConfig);\n    if (!(model instanceof Sequential)) {\n      throw new NotImplementedError(\n          `Sequential.fromConfig called on non-Sequential input: ${model}`);\n    }\n    for (const conf of configArray) {\n      const customObjects: serialization.ConfigDict = undefined;\n      const layer = deserialize(\n                        conf as serialization.ConfigDict, customObjects,\n                        fastWeightInit) as Layer;\n      if (fastWeightInit) {\n        layer.setFastWeightInitDuringBuild(true);\n      }\n      model.add(layer);\n    }\n    return model;\n  }\n\n  /**\n   * Setter used for force stopping of LayersModel.fit() (i.e., training).\n   *\n   * Example:\n   *\n   * ```js\n   * const model = tf.sequential();\n   * model.add(tf.layers.dense({units: 1, inputShape: [10]}));\n   * model.compile({loss: 'meanSquaredError', optimizer: 'sgd'});\n   * const xs = tf.ones([8, 10]);\n   * const ys = tf.zeros([8, 1]);\n   *\n   * const history = await model.fit(xs, ys, {\n   *   epochs: 10,\n   *   callbacks: {\n   *     onEpochEnd: async (epoch, logs) => {\n   *       if (epoch === 2) {\n   *         model.stopTraining = true;\n   *       }\n   *     }\n   *   }\n   * });\n   *\n   * // There should be only 3 values in the loss array, instead of 10 values,\n   * // due to the stopping after 3 epochs.\n   * console.log(history.history.loss);\n   * ```\n   */\n  override set stopTraining(stop: boolean) {\n    // TODO(cais): When refactoring to remove the composition pattern happens,\n    // remove this method overriding.\n    if (this.model == null) {\n      throw new ValueError(\n          'Cannot set the stopTraining property of a sequential model before ' +\n          'it is compiled.');\n    }\n    this.model.stopTraining = stop;\n  }\n\n  override get stopTraining(): boolean {\n    if (this.model == null) {\n      throw new ValueError(\n          'Cannot get the stopTraining property of a sequential model before ' +\n          'it is compiled.');\n    }\n    return this.model.stopTraining;\n  }\n\n  // TODO(cais): Override get trainableWeights() here\n\n  // tslint:disable-next-line:no-any\n  override getConfig(): any {\n    // NOTE(cais): We override the return type of getConfig() to `any` here,\n    //   because the `Sequential` class is a special case among `Container`\n    //   subtypes in that its getConfig() method returns an Array (not a\n    //   dict).\n    const layers: serialization.ConfigDict[] = [];\n    for (const layer of this.layers) {\n      const dict: serialization.ConfigDict = {};\n      dict['className'] = layer.getClassName();\n      dict['config'] = layer.getConfig();\n      layers.push(dict);\n    }\n    return {name: this.name, layers};\n  }\n}\nserialization.registerClass(Sequential);\n"]}
|
