/**
|
* @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: engine/training.py */
|
import * as tfc from '@tensorflow/tfjs-core';
|
import { io, Optimizer, scalar, serialization, Tensor, tensor1d, util } from '@tensorflow/tfjs-core';
|
import * as K from '../backend/tfjs_backend';
|
import { configureCallbacks, standardizeCallbacks } from '../base_callbacks';
|
import { nameScope } from '../common';
|
import { NotImplementedError, RuntimeError, ValueError } from '../errors';
|
import { deserialize } from '../layers/serialization';
|
import { disposeTensorsInLogs } from '../logs';
|
import * as losses from '../losses';
|
import * as Metrics from '../metrics';
|
import * as optimizers from '../optimizers';
|
import { checkUserDefinedMetadata } from '../user_defined_metadata';
|
import { count, pyListRepeat, singletonOrArray, toCamelCase, toSnakeCase, unique } from '../utils/generic_utils';
|
import { printSummary } from '../utils/layer_utils';
|
import { range } from '../utils/math_utils';
|
import { convertPythonicToTs } from '../utils/serialization_utils';
|
import { version } from '../version';
|
import { Container } from './container';
|
import { execute, FeedDict } from './executor';
|
import { evaluateDataset, fitDataset } from './training_dataset';
|
import { checkBatchSize, disposeNewTensors, ensureTensorsRank2OrHigher, makeBatches, sliceArrays, sliceArraysByIndices } from './training_tensors';
|
import { computeWeightedLoss, standardizeClassWeights, standardizeWeights } from './training_utils';
|
/**
|
* Helper function for polymorphic input data: 1. singleton Tensor.
|
*/
|
export function isDataTensor(x) {
|
return x instanceof Tensor;
|
}
|
/**
|
* Helper function for polymorphic input data: 2. Array of Tensor.
|
*/
|
export function isDataArray(x) {
|
return Array.isArray(x);
|
}
|
/**
|
* Helper function for polymorphic input data: 3. "dict" of Tensor.
|
*/
|
export function isDataDict(x) {
|
return !isDataTensor(x) && !isDataArray(x);
|
}
|
/**
|
* Normalizes inputs and targets provided by users.
|
* @param data User-provided input data (polymorphic).
|
* @param names An Array of expected Tensor names.
|
* @param shapes Optional Array of expected Tensor shapes.
|
* @param checkBatchAxis Whether to check that the batch axis of the arrays
|
* match the expected value found in `shapes`.
|
* @param exceptionPrefix String prefix used for exception formatting.
|
* @returns List of standardized input Tensors (one Tensor per model input).
|
* @throws ValueError: in case of improperly formatted user data.
|
*/
|
export function standardizeInputData(data, names, shapes, checkBatchAxis = true, exceptionPrefix = '') {
|
if (names == null || names.length === 0) {
|
// Check for the case where the model expected no data, but some data got
|
// sent.
|
if (data != null) {
|
let gotUnexpectedData = false;
|
if (isDataArray(data) && data.length > 0) {
|
gotUnexpectedData = true;
|
}
|
else if (isDataDict(data)) {
|
for (const key in data) {
|
if (data.hasOwnProperty(key)) {
|
gotUnexpectedData = true;
|
break;
|
}
|
}
|
}
|
else {
|
// `data` is a singleton Tensor in this case.
|
gotUnexpectedData = true;
|
}
|
if (gotUnexpectedData) {
|
throw new ValueError(`Error when checking model ${exceptionPrefix} expected no data, ` +
|
`but got ${data}`);
|
}
|
}
|
return [];
|
}
|
if (data == null) {
|
return names.map(name => null);
|
}
|
let arrays;
|
if (isDataDict(data)) {
|
data = data;
|
arrays = [];
|
for (const name of names) {
|
if (data[name] == null) {
|
throw new ValueError(`No data provided for "${name}". Need data for each key in: ` +
|
`${names}`);
|
}
|
arrays.push(data[name]);
|
}
|
}
|
else if (isDataArray(data)) {
|
data = data;
|
if (data.length !== names.length) {
|
throw new ValueError(`Error when checking model ${exceptionPrefix}: the Array of ` +
|
`Tensors that you are passing to your model is not the size the ` +
|
`model expected. Expected to see ${names.length} Tensor(s), but ` +
|
`instead got the following list of Tensor(s): ${data}`);
|
}
|
arrays = data;
|
}
|
else {
|
data = data;
|
if (names.length > 1) {
|
throw new ValueError(`The model ${exceptionPrefix} expects ${names.length} Tensor(s), ` +
|
`but only received one Tensor. Found: Tensor with shape ${data.shape}`);
|
}
|
arrays = [data];
|
}
|
arrays = ensureTensorsRank2OrHigher(arrays);
|
// Check shape compatibility.
|
if (shapes != null) {
|
for (let i = 0; i < names.length; ++i) {
|
if (shapes[i] == null) {
|
continue;
|
}
|
const array = arrays[i];
|
if (array.shape.length !== shapes[i].length) {
|
throw new ValueError(`Error when checking ${exceptionPrefix}: expected ${names[i]} ` +
|
`to have ${shapes[i].length} dimension(s). but got array with ` +
|
`shape ${array.shape}`);
|
}
|
for (let j = 0; j < shapes[i].length; ++j) {
|
if (j === 0 && !checkBatchAxis) {
|
// Skip the first (batch) axis.
|
continue;
|
}
|
const dim = array.shape[j];
|
const refDim = shapes[i][j];
|
if (refDim != null && refDim >= 0 && dim !== refDim) {
|
throw new ValueError(`${exceptionPrefix} expected a batch of elements where each ` +
|
`example has shape [${shapes[i].slice(1, shapes[i].length)}] ` +
|
`(i.e.,tensor shape [*,${shapes[i].slice(1, shapes[i].length)}])` +
|
` but the ${exceptionPrefix} received an input with ${array.shape[0]}` +
|
` examples, each with shape [${array.shape.slice(1, array.shape.length)}]` +
|
` (tensor shape [${array.shape}])`);
|
}
|
}
|
}
|
}
|
return arrays;
|
}
|
/**
|
* User input validation for Tensors.
|
* @param inputs `Array` of `tf.Tensor`s for inputs.
|
* @param targets `Array` of `tf.Tensor`s for targets.
|
* @param weights Optional `Array` of `tf.Tensor`s for sample weights.
|
* @throws ValueError: in case of incorrectly formatted data.
|
*/
|
export function checkArrayLengths(inputs, targets, weights) {
|
const setX = unique(inputs.map(input => input.shape[0]));
|
setX.sort();
|
const setY = unique(targets.map(target => target.shape[0]));
|
setY.sort();
|
// TODO(cais): Check `weights` as well.
|
if (setX.length > 1) {
|
throw new ValueError(`All input Tensors (x) should have the same number of samples. ` +
|
`Got array shapes: ` +
|
`${JSON.stringify(inputs.map(input => input.shape))}`);
|
}
|
if (setY.length > 1) {
|
throw new ValueError(`All target Tensors (y) should have the same number of samples. ` +
|
`Got array shapes: ` +
|
`${JSON.stringify(targets.map(target => target.shape))}`);
|
}
|
if (setX.length > 0 && setY.length > 0 && !util.arraysEqual(setX, setY)) {
|
throw new ValueError(`Input Tensors should have the same number of samples as target ` +
|
`Tensors. Found ${setX[0]} input sample(s) and ${setY[0]} target ` +
|
`sample(s).`);
|
}
|
}
|
/**
|
* Validation on the compatibility of targes and loss functions.
|
*
|
* This helps prevent users from using loss functions incorrectly.
|
*
|
* @param targets `Array` of `tf.Tensor`s of targets.
|
* @param lossFns `Array` of loss functions.
|
* @param outputShapes `Array` of shapes of model outputs.
|
*/
|
function checkLossAndTargetCompatibility(targets, lossFns, outputShapes) {
|
// TODO(cais): Dedicated test coverage?
|
const keyLosses = [
|
losses.meanSquaredError, losses.binaryCrossentropy,
|
losses.categoricalCrossentropy
|
];
|
for (let i = 0; i < targets.length; ++i) {
|
const y = targets[i];
|
const loss = lossFns[i];
|
const shape = outputShapes[i];
|
if (loss == null) {
|
continue;
|
}
|
if (loss === losses.categoricalCrossentropy) {
|
if (y.shape[y.shape.length - 1] === 1) {
|
throw new ValueError(`You are passing a target array of shape ${y.shape} while using ` +
|
`a loss 'categorical_crossentropy'. 'categorical_crossentropy'` +
|
`expects targets to be binary matrices (1s and 0s) of shape ` +
|
`[samples, classes].`);
|
// TODO(cais): Example code in error message.
|
}
|
}
|
if (keyLosses.indexOf(loss) !== -1) {
|
const slicedYShape = y.shape.slice(1);
|
const slicedShape = shape.slice(1);
|
for (let j = 0; j < slicedYShape.length; ++j) {
|
const targetDim = slicedYShape[j];
|
const outDim = slicedShape[j];
|
if (outDim != null && targetDim !== outDim) {
|
throw new ValueError(`A target Tensor with shape ${y.shape} was passed for an ` +
|
`output of shape ${shape}, while using a loss function that ` +
|
`expects targets to have the same shape as the output.`);
|
}
|
}
|
}
|
}
|
}
|
/**
|
* Check inputs provided by the user.
|
*
|
* Porting Note: This corresponds to _standardize_input_data() in Python
|
* Keras. Because of the strong typing in TF.js, we do not need to convert
|
* the data. Specifically:
|
* 1) in PyKeras, `data` can be `DataFrame` instances from pandas, for
|
* example. We don't need to worry about that here because there is no
|
* widely popular javascript/typesdcript equivalent of pandas (so far).
|
* If one becomes available in the future, we can add support.
|
* 2) in PyKeras, inputs can be Python dict. But here we are stipulating
|
* that the data is either a single `tf.Tensor` or an Array of `tf.Tensor`s. We
|
* may add support for `Object` data inputs in the future when the need
|
* arises.
|
*
|
* Instead, we perform basic checks for number of parameters and shapes.
|
*
|
* @param data: The input data.
|
* @param names: Name for the inputs, from the model.
|
* @param shapes: Expected shapes for the input data, from the model.
|
* @param checkBatchAxis: Whether the size along the batch axis (i.e., the
|
* first dimension) will be checked for matching.
|
* @param exceptionPrefix: Execption prefix message, used in generating error
|
* messages.
|
* @throws ValueError: on incorrect number of inputs or mismatches in shapes.
|
*/
|
function checkInputData(data, names, shapes, checkBatchAxis = true, exceptionPrefix = '') {
|
let arrays;
|
if (Array.isArray(data)) {
|
if (data.length !== names.length) {
|
throw new ValueError(`Error when checking model ${exceptionPrefix}: the Array of ` +
|
`Tensors that you are passing to your model is not the size the ` +
|
`the model expected. Expected to see ${names.length} Tensor(s),` +
|
` but instead got ${data.length} Tensors(s).`);
|
}
|
arrays = data;
|
}
|
else {
|
if (names.length > 1) {
|
throw new ValueError(`The model expects ${names.length} ${exceptionPrefix} Tensors, ` +
|
`but only received one Tensor. Found: array with shape ` +
|
`${JSON.stringify(data.shape)}.`);
|
}
|
arrays = [data];
|
}
|
if (shapes != null) {
|
for (let i = 0; i < names.length; ++i) {
|
if (shapes[i] == null) {
|
continue;
|
}
|
const array = arrays[i];
|
if (array.shape.length !== shapes[i].length) {
|
throw new ValueError(`Error when checking ${exceptionPrefix}: expected ${names[i]} ` +
|
`to have ${shapes[i].length} dimension(s), but got array with ` +
|
`shape ${JSON.stringify(array.shape)}`);
|
}
|
for (let j = 0; j < shapes[i].length; ++j) {
|
if (j === 0 && !checkBatchAxis) {
|
continue;
|
}
|
const dim = array.shape[j];
|
const refDim = shapes[i][j];
|
if (refDim != null) {
|
if (refDim !== dim) {
|
throw new ValueError(`Error when checking ${exceptionPrefix}: expected ` +
|
`${names[i]} to have shape ${JSON.stringify(shapes[i])} but ` +
|
`got array with shape ${JSON.stringify(array.shape)}.`);
|
}
|
}
|
}
|
}
|
}
|
}
|
/**
|
* Maps metric functions to model outputs.
|
* @param metrics An shortcut strings name, metric function, `Array` or dict
|
* (`Object`) of metric functions.
|
* @param outputNames An `Array` of the names of model outputs.
|
* @returns An `Array` (one entry per model output) of `Array` of metric
|
* functions. For instance, if the model has 2 outputs, and for the first
|
* output we want to compute `binaryAccuracy` and `binaryCrossentropy`,
|
* and just `binaryAccuracy` for the second output, the `Array` would look
|
* like:
|
* `[[binaryAccuracy, binaryCrossentropy], [binaryAccuracy]]`
|
* @throws TypeError: incompatible metrics format.
|
*/
|
export function collectMetrics(metrics, outputNames) {
|
if (metrics == null || Array.isArray(metrics) && metrics.length === 0) {
|
return outputNames.map(name => []);
|
}
|
let wrappedMetrics;
|
if (typeof metrics === 'string' || typeof metrics === 'function') {
|
wrappedMetrics = [metrics];
|
}
|
else if (Array.isArray(metrics) || typeof metrics === 'object') {
|
wrappedMetrics = metrics;
|
}
|
else {
|
throw new TypeError('Type of metrics argument not understood. Expected an string,' +
|
`function, Array, or Object, found: ${metrics}`);
|
}
|
if (Array.isArray(wrappedMetrics)) {
|
// We then apply all metrics to all outputs.
|
return outputNames.map(name => wrappedMetrics);
|
}
|
else {
|
// In this case, metrics is a dict.
|
const nestedMetrics = [];
|
for (const name of outputNames) {
|
let outputMetrics = wrappedMetrics.hasOwnProperty(name) ? wrappedMetrics[name] : [];
|
if (!Array.isArray(outputMetrics)) {
|
outputMetrics = [outputMetrics];
|
}
|
nestedMetrics.push(outputMetrics);
|
}
|
return nestedMetrics;
|
}
|
}
|
const LAYERS_MODEL_FORMAT_NAME = 'layers-model';
|
/**
|
* A `tf.LayersModel` is a directed, acyclic graph of `tf.Layer`s plus methods
|
* for training, evaluation, prediction and saving.
|
*
|
* `tf.LayersModel` is the basic unit of training, inference and evaluation in
|
* TensorFlow.js. To create a `tf.LayersModel`, use `tf.LayersModel`.
|
*
|
* See also:
|
* `tf.Sequential`, `tf.loadLayersModel`.
|
*
|
* @doc {heading: 'Models', subheading: 'Classes'}
|
*/
|
class LayersModel extends Container {
|
constructor(args) {
|
super(args);
|
this.isTraining = false;
|
}
|
/**
|
* Print a text summary of the 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
|
* - If the model has non-sequential-like topology, the inputs each layer
|
* receives
|
* - The total number of trainable and non-trainable parameters of the model.
|
*
|
* ```js
|
* 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();
|
* ```
|
*
|
* @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) {
|
throw new ValueError(`This model has never been called, thus its weights have not been ` +
|
`created yet. So no summary can be displayed. Build the model ` +
|
`first (e.g., by calling it on some test data).`);
|
}
|
printSummary(this, lineLength, positions, printFn);
|
}
|
/**
|
* Configures and prepares the model for training and evaluation. Compiling
|
* outfits the model with an optimizer, loss, and/or metrics. Calling `fit`
|
* or `evaluate` on an un-compiled model will throw an error.
|
*
|
* @param args a `ModelCompileArgs` specifying the loss, optimizer, and
|
* metrics to be used for fitting and evaluating this model.
|
*
|
* @doc {heading: 'Models', subheading: 'Classes'}
|
*/
|
compile(args) {
|
if (args.loss == null) {
|
args.loss = [];
|
}
|
this.loss = args.loss;
|
if (typeof args.optimizer === 'string') {
|
this.optimizer_ = optimizers.getOptimizer(args.optimizer);
|
this.isOptimizerOwned = true;
|
}
|
else {
|
if (!(args.optimizer instanceof Optimizer)) {
|
throw new ValueError(`User-defined optimizer must be an instance of tf.Optimizer.`);
|
}
|
this.optimizer_ = args.optimizer;
|
this.isOptimizerOwned = false;
|
}
|
// TODO(cais): Add lossWeights.
|
// TODO(cais): Add sampleWeightMode.
|
// Prepare loss functions.
|
let lossFunctions = [];
|
if (!Array.isArray(args.loss) && typeof args.loss !== 'string' &&
|
typeof args.loss !== 'function') {
|
args.loss = args.loss;
|
for (const name in args.loss) {
|
if (this.outputNames.indexOf(name) === -1) {
|
throw new ValueError(`Unknown entry in loss dictionary: "${name}". ` +
|
`Only expected the following keys: ${this.outputNames}`);
|
}
|
}
|
for (const name of this.outputNames) {
|
if (args.loss[name] == null) {
|
console.warn(`Output "${name}" is missing from loss dictionary. We assume ` +
|
`this was done on purpose, and we will not be expecting data ` +
|
`to be passed to ${name} during training`);
|
}
|
lossFunctions.push(losses.get(args.loss[name]));
|
}
|
}
|
else if (Array.isArray(args.loss)) {
|
if (args.loss.length !== this.outputs.length) {
|
throw new ValueError(`When passing an Array as loss, it should have one entry per ` +
|
`model output. The model has ${this.outputs.length} output(s), ` +
|
`but you passed loss=${args.loss}.`);
|
}
|
const theLosses = args.loss;
|
lossFunctions = theLosses.map(l => losses.get(l));
|
}
|
else {
|
const lossFunction = losses.get(args.loss);
|
this.outputs.forEach(_ => {
|
lossFunctions.push(lossFunction);
|
});
|
}
|
this.lossFunctions = lossFunctions;
|
this.feedOutputNames = [];
|
this.feedOutputShapes = [];
|
this.feedLossFns = [];
|
for (let i = 0; i < this.outputs.length; ++i) {
|
// TODO(cais): Logic for skipping target(s).
|
const shape = this.internalOutputShapes[i];
|
const name = this.outputNames[i];
|
this.feedOutputNames.push(name);
|
this.feedOutputShapes.push(shape);
|
this.feedLossFns.push(this.lossFunctions[i]);
|
}
|
// TODO(cais): Add logic for output masks.
|
// TODO(cais): Add logic for sample weights.
|
const skipTargetIndices = [];
|
// Prepare metrics.
|
this.metrics = args.metrics;
|
// TODO(cais): Add weightedMetrics.
|
this.metricsNames = ['loss'];
|
this.metricsTensors = [];
|
// Compute total loss.
|
// Porting Note: In PyKeras, metrics_tensors are symbolic tensor objects.
|
// Here, metricsTensors are TypeScript functions. This difference is due
|
// to the difference in symbolic/imperative property of the backends.
|
nameScope('loss', () => {
|
for (let i = 0; i < this.outputs.length; ++i) {
|
if (skipTargetIndices.indexOf(i) !== -1) {
|
continue;
|
}
|
// TODO(cais): Add weightedLoss, sampleWeight and mask.
|
// The following line should be weightedLoss
|
const weightedLoss = this.lossFunctions[i];
|
if (this.outputs.length > 1) {
|
this.metricsTensors.push([weightedLoss, i]);
|
this.metricsNames.push(this.outputNames[i] + '_loss');
|
}
|
}
|
// Porting Note: Due to the imperative nature of the backend, we calculate
|
// the regularizer penalties in the totalLossFunction, instead of here.
|
});
|
const nestedMetrics = collectMetrics(args.metrics, this.outputNames);
|
// TODO(cais): Add nestedWeightedMetrics.
|
/**
|
* Helper function used in loop below.
|
*/
|
const appendMetric = (outputIndex, metricName, metricTensor) => {
|
if (this.outputNames.length > 1) {
|
metricName = this.outputNames[outputIndex] + '_' + metricName;
|
}
|
this.metricsNames.push(metricName);
|
this.metricsTensors.push([metricTensor, outputIndex]);
|
};
|
nameScope('metric', () => {
|
for (let i = 0; i < this.outputs.length; ++i) {
|
if (skipTargetIndices.indexOf(i) !== -1) {
|
continue;
|
}
|
const outputMetrics = nestedMetrics[i];
|
// TODO(cais): Add weights and outputWeightedMetrics.
|
// TODO(cais): Add optional arg `weights` to the following function.
|
const handleMetrics = (metrics) => {
|
const metricNamePrefix = '';
|
let metricName;
|
let accFn;
|
let weightedMetricFn;
|
// TODO(cais): Use 'weights_' for weighted metrics.
|
for (const metric of metrics) {
|
if (typeof metric === 'string' &&
|
['accuracy', 'acc', 'crossentropy', 'ce'].indexOf(metric) !==
|
-1) {
|
const outputShape = this.internalOutputShapes[i];
|
if (outputShape[outputShape.length - 1] === 1 ||
|
this.lossFunctions[i] === losses.binaryCrossentropy) {
|
// case: binary accuracy/crossentropy.
|
if (['accuracy', 'acc'].indexOf(metric) !== -1) {
|
accFn = Metrics.binaryAccuracy;
|
}
|
else if (['crossentropy', 'ce'].indexOf(metric) !== -1) {
|
accFn = Metrics.binaryCrossentropy;
|
}
|
}
|
else if (this.lossFunctions[i] ===
|
losses.sparseCategoricalCrossentropy) {
|
// case: categorical accuracy / crossentropy with sparse
|
// targets.
|
if (['accuracy', 'acc'].indexOf(metric) !== -1) {
|
accFn = Metrics.sparseCategoricalAccuracy;
|
}
|
else if (['crossentropy', 'ce'].indexOf(metric) !== -1) {
|
accFn = Metrics.sparseCategoricalCrossentropy;
|
}
|
}
|
else {
|
// case: categorical accuracy / crossentropy.
|
if (['accuracy', 'acc'].indexOf(metric) !== -1) {
|
accFn = Metrics.categoricalAccuracy;
|
}
|
else if (['crossentropy', 'ce'].indexOf(metric) !== -1) {
|
accFn = Metrics.categoricalCrossentropy;
|
}
|
}
|
let suffix;
|
if (['accuracy', 'acc'].indexOf(metric) !== -1) {
|
suffix = 'acc';
|
}
|
else if (['crossentropy', 'ce'].indexOf(metric) !== -1) {
|
suffix = 'ce';
|
}
|
// TODO(cais): Add weighting actually.
|
weightedMetricFn = accFn;
|
metricName = metricNamePrefix + suffix;
|
}
|
else {
|
const metricFn = Metrics.get(metric);
|
// TODO(cais): Add weighting actually.
|
weightedMetricFn = metricFn;
|
metricName =
|
metricNamePrefix + Metrics.getLossOrMetricName(metric);
|
}
|
// TODO(cais): Add weighting and masking to metricResult.
|
let metricResult;
|
nameScope(metricName, () => {
|
metricResult = weightedMetricFn;
|
});
|
appendMetric(i, metricName, metricResult);
|
}
|
};
|
handleMetrics(outputMetrics);
|
// TODO(cais): Call handleMetrics with weights.
|
}
|
});
|
// Porting Notes: Given the imperative backend of tfjs-core,
|
// there is no need for constructing the symbolic graph and placeholders.
|
this.collectedTrainableWeights = this.trainableWeights;
|
}
|
/**
|
* Check trainable weights count consistency.
|
*
|
* This will raise a warning if `this.trainableWeights` and
|
* `this.collectedTrainableWeights` are inconsistent (i.e., have different
|
* numbers of parameters).
|
* Inconsistency will typically arise when one modifies `model.trainable`
|
* without calling `model.compile()` again.
|
*/
|
checkTrainableWeightsConsistency() {
|
if (this.collectedTrainableWeights == null) {
|
return;
|
}
|
if (this.trainableWeights.length !==
|
this.collectedTrainableWeights.length) {
|
console.warn('Discrepancy between trainableweights and collected trainable ' +
|
'weights. Did you set `model.trainable` without calling ' +
|
'`model.compile()` afterwards?');
|
}
|
}
|
/**
|
* 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 `ModelEvaluateArgs`, 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 = {}) {
|
const batchSize = args.batchSize == null ? 32 : args.batchSize;
|
checkBatchSize(batchSize);
|
// TODO(cais): Standardize `config.sampleWeights` as well.
|
// Validate user data.
|
const checkBatchAxis = true;
|
const standardizedOuts = this.standardizeUserDataXY(x, y, checkBatchAxis, batchSize);
|
try {
|
// TODO(cais): If uses `useLearningPhase`, set the corresponding element
|
// of the input to 0.
|
const ins = standardizedOuts[0].concat(standardizedOuts[1]);
|
this.makeTestFunction();
|
const f = this.testFunction;
|
const testOuts = this.testLoop(f, ins, batchSize, args.verbose, args.steps);
|
return singletonOrArray(testOuts);
|
}
|
finally {
|
disposeNewTensors(standardizedOuts[0], x);
|
disposeNewTensors(standardizedOuts[1], y);
|
}
|
}
|
// 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) {
|
this.makeTestFunction();
|
return evaluateDataset(this, dataset, args);
|
}
|
/**
|
* Get number of samples provided for training, evaluation or prediction.
|
*
|
* @param ins Input `tf.Tensor`.
|
* @param batchSize Integer batch size, optional.
|
* @param steps Total number of steps (batches of samples) before
|
* declaring loop finished. Optional.
|
* @param stepsName The public API's parameter name for `steps`.
|
* @returns Number of samples provided.
|
*/
|
checkNumSamples(ins, batchSize, steps, stepsName = 'steps') {
|
let numSamples;
|
if (steps != null) {
|
numSamples = null;
|
if (batchSize != null) {
|
throw new ValueError(`If ${stepsName} is set, batchSize must be null or undefined.` +
|
`Got batchSize = ${batchSize}`);
|
}
|
}
|
else if (ins != null) {
|
if (Array.isArray(ins)) {
|
numSamples = ins[0].shape[0];
|
}
|
else {
|
numSamples = ins.shape[0];
|
}
|
}
|
else {
|
throw new ValueError(`Either the input data should have a defined shape, or ` +
|
`${stepsName} shoud be specified.`);
|
}
|
return numSamples;
|
}
|
/**
|
* Execute internal tensors of the model with input data feed.
|
* @param inputs Input data feed. Must match the inputs of the model.
|
* @param outputs Names of the output tensors to be fetched. Must match
|
* names of the SymbolicTensors that belong to the graph.
|
* @returns Fetched values for `outputs`.
|
*/
|
execute(inputs, outputs) {
|
if (Array.isArray(outputs) && outputs.length === 0) {
|
throw new ValueError('`outputs` is an empty Array, which is not allowed.');
|
}
|
const outputsIsArray = Array.isArray(outputs);
|
const outputNames = (outputsIsArray ? outputs : [outputs]);
|
const outputSymbolicTensors = this.retrieveSymbolicTensors(outputNames);
|
// Format the input into a FeedDict.
|
const feedDict = new FeedDict();
|
if (inputs instanceof Tensor) {
|
inputs = [inputs];
|
}
|
if (Array.isArray(inputs)) {
|
if (inputs.length !== this.inputs.length) {
|
throw new ValueError(`The number of inputs provided (${inputs.length}) ` +
|
`does not match the number of inputs of this model ` +
|
`(${this.inputs.length}).`);
|
}
|
for (let i = 0; i < this.inputs.length; ++i) {
|
feedDict.add(this.inputs[i], inputs[i]);
|
}
|
}
|
else {
|
for (const input of this.inputs) {
|
const tensorValue = inputs[input.name];
|
if (tensorValue == null) {
|
throw new ValueError(`No value is provided for the model's input ${input.name}`);
|
}
|
feedDict.add(input, tensorValue);
|
}
|
}
|
// Run execution.
|
const executeOutputs = execute(outputSymbolicTensors, feedDict);
|
return outputsIsArray ? executeOutputs : executeOutputs[0];
|
}
|
/**
|
* Retrieve the model's internal symbolic tensors from symbolic-tensor names.
|
*/
|
retrieveSymbolicTensors(symbolicTensorNames) {
|
const outputSymbolicTensors = pyListRepeat(null, symbolicTensorNames.length);
|
let outputsRemaining = symbolicTensorNames.length;
|
for (const layer of this.layers) {
|
const layerOutputs = Array.isArray(layer.output) ? layer.output : [layer.output];
|
const layerOutputNames = layerOutputs.map(output => output.name);
|
for (let i = 0; i < symbolicTensorNames.length; ++i) {
|
const index = layerOutputNames.indexOf(symbolicTensorNames[i]);
|
if (index !== -1) {
|
outputSymbolicTensors[i] = layerOutputs[index];
|
outputsRemaining--;
|
}
|
if (outputsRemaining === 0) {
|
break;
|
}
|
}
|
if (outputsRemaining === 0) {
|
break;
|
}
|
}
|
if (outputsRemaining > 0) {
|
const remainingNames = [];
|
outputSymbolicTensors.forEach((tensor, i) => {
|
if (tensor == null) {
|
remainingNames.push(symbolicTensorNames[i]);
|
}
|
});
|
throw new ValueError(`Cannot find SymbolicTensors for output name(s): ` +
|
`${JSON.stringify(remainingNames)}`);
|
}
|
return outputSymbolicTensors;
|
}
|
/**
|
* Helper method to loop over some data in batches.
|
*
|
* Porting Note: Not using the functional approach in the Python equivalent
|
* due to the imperative backend.
|
* Porting Note: Does not support step mode currently.
|
*
|
* @param ins: input data
|
* @param batchSize: integer batch size.
|
* @param verbose: verbosity model
|
* @returns: Predictions as `tf.Tensor` (if a single output) or an `Array` of
|
* `tf.Tensor` (if multipe outputs).
|
*/
|
predictLoop(ins, batchSize = 32, verbose = false) {
|
return tfc.tidy(() => {
|
const numSamples = this.checkNumSamples(ins);
|
if (verbose) {
|
throw new NotImplementedError('Verbose predictLoop() is not implemented yet.');
|
}
|
// Sample-based predictions.
|
// Porting Note: Tensor currently does not support sliced assignments as
|
// in numpy, e.g., x[1:3] = y. Therefore we use concatenation while
|
// iterating over the batches.
|
const batches = makeBatches(numSamples, batchSize);
|
const outsBatches = this.outputs.map(output => []);
|
// TODO(cais): Can the scope() be pushed down inside the for loop?
|
for (let batchIndex = 0; batchIndex < batches.length; ++batchIndex) {
|
const batchOuts = tfc.tidy(() => {
|
const batchStart = batches[batchIndex][0];
|
const batchEnd = batches[batchIndex][1];
|
// TODO(cais): Take care of the case of the last element is a flag for
|
// training/test.
|
const insBatch = sliceArrays(ins, batchStart, batchEnd);
|
// Construct the feeds for execute();
|
const feeds = [];
|
if (Array.isArray(insBatch)) {
|
for (let i = 0; i < insBatch.length; ++i) {
|
feeds.push({ key: this.inputs[i], value: insBatch[i] });
|
}
|
}
|
else {
|
feeds.push({ key: this.inputs[0], value: insBatch });
|
}
|
const feedDict = new FeedDict(feeds);
|
return execute(this.outputs, feedDict);
|
});
|
batchOuts.forEach((batchOut, i) => outsBatches[i].push(batchOut));
|
}
|
return singletonOrArray(outsBatches.map(batches => tfc.concat(batches, 0)));
|
});
|
}
|
/**
|
* 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([8, 10]), {batchSize: 4}).print();
|
* ```
|
*
|
* @param x The input data, as a Tensor, or an `Array` of `tf.Tensor`s if
|
* the model has multiple inputs.
|
* @param args A `ModelPredictArgs` object containing optional fields.
|
*
|
* @return Prediction results as a `tf.Tensor`(s).
|
*
|
* @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 = {}) {
|
const xsRank2OrHigher = ensureTensorsRank2OrHigher(x);
|
checkInputData(xsRank2OrHigher, this.inputNames, this.feedInputShapes, false);
|
try {
|
// TODO(cais): Take care of stateful models.
|
// if (this.stateful) ...
|
// TODO(cais): Take care of the learning_phase boolean flag.
|
// if (this.useLearningPhase) ...
|
const batchSize = args.batchSize == null ? 32 : args.batchSize;
|
checkBatchSize(batchSize);
|
return this.predictLoop(xsRank2OrHigher, batchSize);
|
}
|
finally {
|
disposeNewTensors(xsRank2OrHigher, x);
|
}
|
}
|
/**
|
* Returns predictions for a single batch of samples.
|
*
|
* ```js
|
* const model = tf.sequential({
|
* layers: [tf.layers.dense({units: 1, inputShape: [10]})]
|
* });
|
* model.predictOnBatch(tf.ones([8, 10])).print();
|
* ```
|
* @param x: Input samples, as a Tensor (for models with exactly one
|
* input) or an array of Tensors (for models with more than one input).
|
* @return Tensor(s) of predictions
|
*
|
* @doc {heading: 'Models', subheading: 'Classes'}
|
*/
|
predictOnBatch(x) {
|
checkInputData(x, this.inputNames, this.feedInputShapes, true);
|
// TODO(cais): Take care of the learning_phase boolean flag.
|
// if (this.useLearningPhase) ...
|
const batchSize = (Array.isArray(x) ? x[0] : x).shape[0];
|
return this.predictLoop(x, batchSize);
|
}
|
standardizeUserDataXY(x, y, checkBatchAxis = true, batchSize) {
|
// TODO(cais): Add sampleWeight, classWeight
|
if (this.optimizer_ == null) {
|
throw new RuntimeError('You must compile a model before training/testing. Use ' +
|
'LayersModel.compile(modelCompileArgs).');
|
}
|
const outputShapes = [];
|
for (let i = 0; i < this.feedOutputShapes.length; ++i) {
|
const outputShape = this.feedOutputShapes[i];
|
const lossFn = this.feedLossFns[i];
|
if (lossFn === losses.sparseCategoricalCrossentropy) {
|
outputShapes.push(outputShape.slice(0, outputShape.length - 1).concat([1]));
|
}
|
else {
|
// Porting Note: Because of strong typing `lossFn` must be a function.
|
outputShapes.push(outputShape);
|
}
|
}
|
x = standardizeInputData(x, this.feedInputNames, this.feedInputShapes, false, 'input');
|
y = standardizeInputData(y, this.feedOutputNames, outputShapes, false, 'target');
|
// TODO(cais): Standardize sampleWeights & classWeights.
|
checkArrayLengths(x, y, null);
|
// TODO(cais): Check sampleWeights as well.
|
checkLossAndTargetCompatibility(y, this.feedLossFns, this.feedOutputShapes);
|
if (this.stateful && batchSize != null && batchSize > 0) {
|
if (x[0].shape[0] % batchSize !== 0) {
|
throw new ValueError(`In a stateful network, you should only pass inputs with a ` +
|
`number of samples that is divisible by the batch size ` +
|
`${batchSize}. Found: ${x[0].shape[0]} sample(s).`);
|
}
|
}
|
return [x, y];
|
}
|
async standardizeUserData(x, y, sampleWeight, classWeight, checkBatchAxis = true, batchSize) {
|
const [standardXs, standardYs] = this.standardizeUserDataXY(x, y, checkBatchAxis, batchSize);
|
// TODO(cais): Handle sampleWeights.
|
if (sampleWeight != null) {
|
throw new Error('sample weight is not supported yet.');
|
}
|
let standardSampleWeights = null;
|
if (classWeight != null) {
|
const classWeights = standardizeClassWeights(classWeight, this.outputNames);
|
standardSampleWeights = [];
|
for (let i = 0; i < classWeights.length; ++i) {
|
standardSampleWeights.push(await standardizeWeights(standardYs[i], null, classWeights[i]));
|
}
|
}
|
// TODO(cais): Deal with the case of model.stateful == true.
|
return [standardXs, standardYs, standardSampleWeights];
|
}
|
/**
|
* Loop over some test data in batches.
|
* @param f A Function returning a list of tensors.
|
* @param ins Array of tensors to be fed to `f`.
|
* @param batchSize Integer batch size or `null` / `undefined`.
|
* @param verbose verbosity mode.
|
* @param steps Total number of steps (batches of samples) before
|
* declaring test finished. Ignored with the default value of `null` /
|
* `undefined`.
|
* @returns Array of Scalars.
|
*/
|
testLoop(f, ins, batchSize, verbose = 0, steps) {
|
return tfc.tidy(() => {
|
const numSamples = this.checkNumSamples(ins, batchSize, steps, 'steps');
|
const outs = [];
|
if (verbose > 0) {
|
throw new NotImplementedError('Verbose mode is not implemented yet.');
|
}
|
// TODO(cais): Use `indicesForConversionToDense' to prevent slow down.
|
if (steps != null) {
|
throw new NotImplementedError('steps mode in testLoop() is not implemented yet');
|
}
|
else {
|
const batches = makeBatches(numSamples, batchSize);
|
const indexArray = tensor1d(range(0, numSamples));
|
for (let batchIndex = 0; batchIndex < batches.length; ++batchIndex) {
|
const batchStart = batches[batchIndex][0];
|
const batchEnd = batches[batchIndex][1];
|
const batchIds = K.sliceAlongFirstAxis(indexArray, batchStart, batchEnd - batchStart);
|
// TODO(cais): In ins, train flag can be a number, instead of an
|
// Tensor? Do we need to handle this in tfjs-layers?
|
const insBatch = sliceArraysByIndices(ins, batchIds);
|
const batchOuts = f(insBatch);
|
if (batchIndex === 0) {
|
for (let i = 0; i < batchOuts.length; ++i) {
|
outs.push(scalar(0));
|
}
|
}
|
for (let i = 0; i < batchOuts.length; ++i) {
|
const batchOut = batchOuts[i];
|
outs[i] =
|
tfc.add(outs[i], tfc.mul(batchEnd - batchStart, batchOut));
|
}
|
}
|
for (let i = 0; i < outs.length; ++i) {
|
outs[i] = tfc.div(outs[i], numSamples);
|
}
|
}
|
return outs;
|
});
|
}
|
getDedupedMetricsNames() {
|
const outLabels = this.metricsNames;
|
// Rename duplicated metrics names (can happen with an output layer
|
// shared among multiple dataflows).
|
const dedupedOutLabels = [];
|
for (let i = 0; i < outLabels.length; ++i) {
|
const label = outLabels[i];
|
let newLabel = label;
|
if (count(outLabels, label) > 1) {
|
const dupIndex = count(outLabels.slice(0, i), label);
|
newLabel += `_${dupIndex}`;
|
}
|
dedupedOutLabels.push(newLabel);
|
}
|
return dedupedOutLabels;
|
}
|
/**
|
* Creates a function that performs the following actions:
|
*
|
* 1. computes the losses
|
* 2. sums them to get the total loss
|
* 3. call the optimizer computes the gradients of the LayersModel's
|
* trainable weights w.r.t. the total loss and update the variables
|
* 4. calculates the metrics
|
* 5. returns the values of the losses and metrics.
|
*/
|
makeTrainFunction() {
|
return (data) => {
|
const lossValues = [];
|
const inputs = data.slice(0, this.inputs.length);
|
const targets = data.slice(this.inputs.length, this.inputs.length + this.outputs.length);
|
const sampleWeights = data.slice(this.inputs.length + this.outputs.length, this.inputs.length + this.outputs.length * 2);
|
const metricsValues = [];
|
// Create a function that computes the total loss based on the
|
// inputs. This function is used for obtaining gradients through
|
// backprop.
|
const totalLossFunction = () => {
|
const feeds = [];
|
for (let i = 0; i < this.inputs.length; ++i) {
|
feeds.push({ key: this.inputs[i], value: inputs[i] });
|
}
|
const feedDict = new FeedDict(feeds);
|
const outputs = execute(this.outputs, feedDict, { 'training': true });
|
// TODO(cais): Take care of the case of multiple outputs from a
|
// single layer?
|
let totalLoss;
|
for (let i = 0; i < this.lossFunctions.length; ++i) {
|
const lossFunction = this.lossFunctions[i];
|
let loss = lossFunction(targets[i], outputs[i]);
|
if (sampleWeights[i] != null) {
|
loss = computeWeightedLoss(loss, sampleWeights[i]);
|
}
|
// TODO(cais): push Scalar instead.
|
const meanLoss = tfc.mean(loss);
|
// TODO(cais): Use a scope() instead, to avoid ownership.
|
lossValues.push(meanLoss);
|
if (i === 0) {
|
totalLoss = loss;
|
}
|
else {
|
totalLoss = tfc.add(totalLoss, loss);
|
}
|
}
|
// Compute the metrics.
|
// TODO(cais): These should probably be calculated outside
|
// totalLossFunction to benefit speed?
|
for (let i = 0; i < this.metricsTensors.length; ++i) {
|
let weightedMetric;
|
if (this.outputs.length > 1 && i < this.outputs.length) {
|
weightedMetric = lossValues[i];
|
}
|
else {
|
const metric = this.metricsTensors[i][0];
|
const outputIndex = this.metricsTensors[i][1];
|
weightedMetric =
|
tfc.mean(metric(targets[outputIndex], outputs[outputIndex]));
|
}
|
tfc.keep(weightedMetric);
|
// TODO(cais): Use a scope() instead, to avoid ownership.
|
metricsValues.push(weightedMetric);
|
}
|
totalLoss = tfc.mean(totalLoss);
|
// Add regularizer penalties.
|
this.calculateLosses().forEach(regularizerLoss => {
|
totalLoss = tfc.add(totalLoss, regularizerLoss);
|
});
|
return totalLoss;
|
};
|
const variables = this.collectedTrainableWeights.map(param => param.read());
|
const returnCost = true;
|
const totalLossValue = this.optimizer_.minimize(totalLossFunction, returnCost, variables);
|
return [totalLossValue].concat(metricsValues);
|
};
|
}
|
/**
|
* Create a function which, when invoked with an array of `tf.Tensor`s as a
|
* batch of inputs, returns the prespecified loss and metrics of the model
|
* under the batch of input data.
|
*/
|
makeTestFunction() {
|
this.testFunction = (data) => {
|
return tfc.tidy(() => {
|
const valOutputs = [];
|
let totalLoss;
|
const inputs = data.slice(0, this.inputs.length);
|
const targets = data.slice(this.inputs.length, this.inputs.length + this.outputs.length);
|
const feeds = [];
|
for (let i = 0; i < this.inputs.length; ++i) {
|
feeds.push({ key: this.inputs[i], value: inputs[i] });
|
}
|
const feedDict = new FeedDict(feeds);
|
const outputs = execute(this.outputs, feedDict);
|
// Compute total loss.
|
for (let i = 0; i < this.lossFunctions.length; ++i) {
|
const lossFunction = this.lossFunctions[i];
|
// TODO(cais): Add sample weighting and replace the simple
|
// averaging.
|
const loss = tfc.mean(lossFunction(targets[i], outputs[i]));
|
if (i === 0) {
|
totalLoss = loss;
|
}
|
else {
|
totalLoss = tfc.add(totalLoss, loss);
|
}
|
valOutputs.push(totalLoss);
|
}
|
// Compute the metrics.
|
for (let i = 0; i < this.metricsTensors.length; ++i) {
|
const metric = this.metricsTensors[i][0];
|
const outputIndex = this.metricsTensors[i][1];
|
// TODO(cais): Replace K.mean() with a proper weighting function.
|
const meanMetric = tfc.mean(metric(targets[outputIndex], outputs[outputIndex]));
|
valOutputs.push(meanMetric);
|
}
|
return valOutputs;
|
});
|
};
|
}
|
/**
|
* 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'});
|
* 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]);
|
* }
|
* ```
|
*
|
* @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 `ModelFitArgs`, 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.isTraining) {
|
throw new Error('Cannot start training because another fit() call is ongoing.');
|
}
|
this.isTraining = true;
|
let inputs;
|
let targets;
|
let originalInputs;
|
let originalTargets;
|
let inputValX;
|
let inputValY;
|
let valX;
|
let valY;
|
let sampleWeights;
|
try {
|
const batchSize = args.batchSize == null ? 32 : args.batchSize;
|
checkBatchSize(batchSize);
|
// Validate user data.
|
// TODO(cais): Support sampleWeight.
|
const checkBatchAxis = false;
|
const standardizedOuts = await this.standardizeUserData(x, y, args.sampleWeight, args.classWeight, checkBatchAxis, batchSize);
|
inputs = standardizedOuts[0];
|
targets = standardizedOuts[1];
|
sampleWeights = standardizedOuts[2];
|
// Prepare validation data.
|
let doValidation = false;
|
let valIns;
|
if (args.validationData != null && args.validationData.length > 0) {
|
doValidation = true;
|
if (args.validationData.length === 2) {
|
// config.validationData consists of valX and valY.
|
inputValX = args.validationData[0];
|
inputValY = args.validationData[1];
|
}
|
else if (args.validationData.length === 3) {
|
throw new NotImplementedError('validationData including sample weights is not supported yet.');
|
}
|
else {
|
throw new ValueError(`When passing validation data, it must contain 2 (valX, valY) ` +
|
`or 3 (valX, valY, valSampleWeight) items; ` +
|
`${args.validationData} is invalid.`);
|
}
|
const checkBatchAxis = true;
|
const valStandardized = await this.standardizeUserData(inputValX, inputValY, null, /** Unused sample weights. */ null, /** Unused class weights. */ checkBatchAxis, batchSize);
|
valX = valStandardized[0];
|
valY = valStandardized[1];
|
valIns = valX.concat(valY);
|
// TODO(cais): Add useLearningPhase data properly.
|
}
|
else if (args.validationSplit != null && args.validationSplit > 0 &&
|
args.validationSplit < 1) {
|
doValidation = true;
|
// Porting Note: In tfjs-layers, inputs[0] is always a Tensor.
|
const splitAt = Math.floor(inputs[0].shape[0] * (1 - args.validationSplit));
|
const originalBatchSize = inputs[0].shape[0];
|
valX = sliceArrays(inputs, splitAt, originalBatchSize);
|
originalInputs = inputs;
|
inputs = sliceArrays(inputs, 0, splitAt);
|
valY = sliceArrays(targets, splitAt, originalBatchSize);
|
originalTargets = targets;
|
targets = sliceArrays(targets, 0, splitAt);
|
// TODO(cais): Once sampleWeights becomes available, slice it to get
|
// valSampleWeights.
|
valIns = valX.concat(valY);
|
// TODO(cais): Add useLearningPhase data properly.
|
}
|
else if (args.validationSteps != null) {
|
doValidation = true;
|
// TODO(cais): Add useLearningPhase.
|
}
|
const ins = inputs.concat(targets).concat(sampleWeights);
|
this.checkTrainableWeightsConsistency();
|
// TODO(cais): Handle use_learning_phase and learning_phase?
|
// Porting Note: Here we see a key deviation of tfjs-layers from
|
// Keras.
|
// Due to the imperative nature of tfjs-layers' backend (tfjs-core),
|
// we do not construct symbolic computation graphs to embody the
|
// training process. Instead, we define a function that performs the
|
// training action. In PyKeras, the data (inputs and targets) are fed
|
// through graph placeholders. In tfjs-layers, the data are fed as
|
// function arguments. Since the function are defined below in the
|
// scope, we don't have equivalents of PyKeras's
|
// `_make_train_funciton`.
|
const trainFunction = this.makeTrainFunction();
|
const outLabels = this.getDedupedMetricsNames();
|
let valFunction;
|
let callbackMetrics;
|
if (doValidation) {
|
this.makeTestFunction();
|
valFunction = this.testFunction;
|
callbackMetrics =
|
outLabels.slice().concat(outLabels.map(n => 'val_' + n));
|
}
|
else {
|
valFunction = null;
|
valIns = [];
|
callbackMetrics = outLabels.slice();
|
}
|
const callbacks = standardizeCallbacks(args.callbacks, args.yieldEvery);
|
const out = await this.fitLoop(trainFunction, ins, outLabels, batchSize, args.epochs, args.verbose, callbacks, valFunction, valIns, args.shuffle, callbackMetrics, args.initialEpoch, null, null);
|
return out;
|
}
|
finally {
|
this.isTraining = false;
|
// Memory clean up.
|
disposeNewTensors(inputs, x);
|
disposeNewTensors(targets, y);
|
disposeNewTensors(originalInputs, x);
|
disposeNewTensors(originalTargets, y);
|
disposeNewTensors(valX, inputValX);
|
disposeNewTensors(valY, inputValY);
|
if (sampleWeights != null) {
|
tfc.dispose(sampleWeights);
|
}
|
}
|
// TODO(cais): Add value to outLabels.
|
}
|
/**
|
* Abstract fit function for `f(ins)`.
|
* @param f A Function returning a list of tensors. For training, this
|
* function is expected to perform the updates to the variables.
|
* @param ins List of tensors to be fed to `f`.
|
* @param outLabels List of strings, display names of the outputs of `f`.
|
* @param batchSize Integer batch size or `== null` if unknown. Default : 32.
|
* @param epochs Number of times to iterate over the data. Default : 1.
|
* @param verbose Verbosity mode: 0, 1, or 2. Default: 1.
|
* @param callbacks List of callbacks to be called during training.
|
* @param valF Function to call for validation.
|
* @param valIns List of tensors to be fed to `valF`.
|
* @param shuffle Whether to shuffle the data at the beginning of every
|
* epoch. Default : true.
|
* @param callbackMetrics List of strings, the display names of the metrics
|
* passed to the callbacks. They should be the concatenation of the
|
* display names of the outputs of `f` and the list of display names
|
* of the outputs of `valF`.
|
* @param initialEpoch Epoch at which to start training (useful for
|
* resuming a previous training run). Default : 0.
|
* @param stepsPerEpoch Total number of steps (batches on samples) before
|
* declaring one epoch finished and starting the next epoch. Ignored with
|
* the default value of `undefined` or `null`.
|
* @param validationSteps Number of steps to run validation for (only if
|
* doing validation from data tensors). Not applicable for tfjs-layers.
|
* @returns A `History` object.
|
*/
|
async fitLoop(f, ins, outLabels, batchSize, epochs, verbose, callbacks, valF, valIns, shuffle, callbackMetrics, initialEpoch, stepsPerEpoch, validationSteps) {
|
if (batchSize == null) {
|
batchSize = 32;
|
}
|
if (epochs == null) {
|
epochs = 1;
|
}
|
if (shuffle == null) {
|
shuffle = true;
|
}
|
if (initialEpoch == null) {
|
initialEpoch = 0;
|
}
|
// TODO(cais): Change const to let below when implementing validation.
|
let doValidation = false;
|
if (valF != null && valIns != null) {
|
doValidation = true;
|
// TODO(cais): verbose message.
|
}
|
if (validationSteps != null) {
|
doValidation = true;
|
if (stepsPerEpoch == null) {
|
throw new ValueError('Can only use `validationSteps` when doing step-wise training, ' +
|
'i.e., `stepsPerEpoch` must be set.');
|
}
|
}
|
const numTrainSamples = this.checkNumSamples(ins, batchSize, stepsPerEpoch, 'steps_per_epoch');
|
let indexArray;
|
if (numTrainSamples != null) {
|
indexArray = range(0, numTrainSamples);
|
}
|
if (verbose == null) {
|
verbose = 1;
|
}
|
const { callbackList, history } = configureCallbacks(callbacks, verbose, epochs, initialEpoch, numTrainSamples, stepsPerEpoch, batchSize, doValidation, callbackMetrics);
|
callbackList.setModel(this);
|
this.history = history;
|
await callbackList.onTrainBegin();
|
this.stopTraining_ = false;
|
// TODO(cais): Take care of callbacks.validation_data as in PyKeras.
|
// TODO(cais): Pre-convert feeds for performance as in PyKeras.
|
for (let epoch = initialEpoch; epoch < epochs; ++epoch) {
|
await callbackList.onEpochBegin(epoch);
|
const epochLogs = {};
|
if (stepsPerEpoch != null) {
|
throw new NotImplementedError('stepsPerEpoch mode is not implemented yet.');
|
}
|
else {
|
if (shuffle === 'batch') {
|
throw new NotImplementedError('batch shuffling is not implemneted'
|
+ ' yet');
|
}
|
else if (shuffle) {
|
util.shuffle(indexArray);
|
}
|
// Convert the potentially shuffled indices to Tensor1D, to avoid the
|
// cost of repeated creation of Array1Ds later on.
|
const epochIndexArray1D = tensor1d(indexArray);
|
const batches = makeBatches(numTrainSamples, batchSize);
|
for (let batchIndex = 0; batchIndex < batches.length; ++batchIndex) {
|
const batchLogs = {};
|
await callbackList.onBatchBegin(batchIndex, batchLogs);
|
tfc.tidy(() => {
|
const batchStart = batches[batchIndex][0];
|
const batchEnd = batches[batchIndex][1];
|
const batchIds = K.sliceAlongFirstAxis(epochIndexArray1D, batchStart, batchEnd - batchStart);
|
batchLogs['batch'] = batchIndex;
|
batchLogs['size'] = batchEnd - batchStart;
|
// TODO(cais): In ins, train flag can be a number, instead of an
|
// Tensor? Do we need to handle this in tfjs-layers?
|
const insBatch = sliceArraysByIndices(ins, batchIds);
|
const outs = f(insBatch);
|
for (let i = 0; i < outLabels.length; ++i) {
|
const label = outLabels[i];
|
const out = outs[i];
|
batchLogs[label] = out;
|
tfc.keep(out);
|
// TODO(cais): Use scope() to avoid ownership.
|
}
|
if (batchIndex === batches.length - 1) { // Last batch.
|
if (doValidation) {
|
const valOuts = this.testLoop(valF, valIns, batchSize);
|
// Porting Notes: In tfjs-layers, valOuts is always an Array.
|
for (let i = 0; i < outLabels.length; ++i) {
|
const label = outLabels[i];
|
const out = valOuts[i];
|
tfc.keep(out);
|
// TODO(cais): Use scope() to avoid ownership.
|
epochLogs['val_' + label] = out;
|
}
|
}
|
}
|
});
|
await callbackList.onBatchEnd(batchIndex, batchLogs);
|
disposeTensorsInLogs(batchLogs);
|
if (this.stopTraining_) {
|
break;
|
}
|
// TODO(cais): return outs as list of Tensor.
|
}
|
epochIndexArray1D.dispose();
|
}
|
// TODO(cais): Run validation at the end of the epoch.
|
await callbackList.onEpochEnd(epoch, epochLogs);
|
if (this.stopTraining_) {
|
break;
|
}
|
}
|
await callbackList.onTrainEnd();
|
await this.history.syncData();
|
return this.history;
|
}
|
// TODO(cais): Add code snippet below when it's possible to instantiate
|
// actual dataset objects.
|
/**
|
* Trains the model using a dataset object.
|
*
|
* @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 training. 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 `ModelFitDatasetArgs`, containing optional fields.
|
*
|
* @return A `History` instance. Its `history` attribute contains all
|
* information collected during training.
|
*
|
* @doc {heading: 'Models', subheading: 'Classes'}
|
*/
|
async fitDataset(dataset, args) {
|
return fitDataset(this, 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) {
|
// TODO(cais): Support sampleWeight and classWeight.
|
// TODO(cais): Support Dataset objects.
|
const standardizeOut = await this.standardizeUserData(x, y);
|
const inputs = standardizeOut[0];
|
const targets = standardizeOut[1];
|
const trainFunction = this.makeTrainFunction();
|
const losses = trainFunction(inputs.concat(targets));
|
const lossValues = [];
|
for (const loss of losses) {
|
const v = await loss.data();
|
lossValues.push(v[0]);
|
}
|
tfc.dispose(losses);
|
disposeNewTensors(standardizeOut[0], x);
|
disposeNewTensors(standardizeOut[1], y);
|
return singletonOrArray(lossValues);
|
}
|
/**
|
* Extract weight values of the model.
|
*
|
* @param config: An instance of `io.SaveConfig`, which specifies
|
* model-saving options such as whether only trainable weights are to be
|
* saved.
|
* @returns A `NamedTensorMap` mapping original weight names (i.e.,
|
* non-uniqueified weight names) to their values.
|
*/
|
getNamedWeights(config) {
|
const namedWeights = [];
|
const trainableOnly = config != null && config.trainableOnly;
|
const weights = trainableOnly ? this.trainableWeights : this.weights;
|
const weightValues = this.getWeights(trainableOnly);
|
for (let i = 0; i < weights.length; ++i) {
|
if (trainableOnly && !weights[i].trainable) {
|
// Optionally skip non-trainable weights.
|
continue;
|
}
|
namedWeights.push({ name: weights[i].originalName, tensor: weightValues[i] });
|
}
|
return namedWeights;
|
}
|
/**
|
* Setter used for force stopping of LayersModel.fit() (i.e., training).
|
*
|
* Example:
|
*
|
* ```js
|
* const input = tf.input({shape: [10]});
|
* const output = tf.layers.dense({units: 1}).apply(input);
|
* const model = tf.model({inputs: [input], outputs: [output]});
|
* 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) {
|
this.stopTraining_ = stop;
|
}
|
get stopTraining() {
|
return this.stopTraining_;
|
}
|
get optimizer() {
|
return this.optimizer_;
|
}
|
set optimizer(optimizer) {
|
if (this.optimizer_ !== optimizer) {
|
this.optimizer_ = optimizer;
|
this.isOptimizerOwned = false;
|
}
|
}
|
dispose() {
|
const result = super.dispose();
|
if (result.refCountAfterDispose === 0 && this.optimizer != null &&
|
this.isOptimizerOwned) {
|
const numTensorsBeforeOptmizerDisposal = tfc.memory().numTensors;
|
this.optimizer_.dispose();
|
result.numDisposedVariables +=
|
numTensorsBeforeOptmizerDisposal - tfc.memory().numTensors;
|
}
|
return result;
|
}
|
getLossIdentifiers() {
|
let lossNames;
|
if (typeof this.loss === 'string') {
|
lossNames = toSnakeCase(this.loss);
|
}
|
else if (Array.isArray(this.loss)) {
|
for (const loss of this.loss) {
|
if (typeof loss !== 'string') {
|
throw new Error('Serialization of non-string loss is not supported.');
|
}
|
}
|
lossNames = this.loss.map(name => toSnakeCase(name));
|
}
|
else {
|
const outputNames = Object.keys(this.loss);
|
lossNames = {};
|
const losses = this.loss;
|
for (const outputName of outputNames) {
|
if (typeof losses[outputName] === 'string') {
|
lossNames[outputName] =
|
toSnakeCase(losses[outputName]);
|
}
|
else {
|
throw new Error('Serialization of non-string loss is not supported.');
|
}
|
}
|
}
|
return lossNames;
|
}
|
getMetricIdentifiers() {
|
if (typeof this.metrics === 'string' ||
|
typeof this.metrics === 'function') {
|
return [toSnakeCase(Metrics.getLossOrMetricName(this.metrics))];
|
}
|
else if (Array.isArray(this.metrics)) {
|
return this.metrics.map(metric => toSnakeCase(Metrics.getLossOrMetricName(metric)));
|
}
|
else {
|
const metricsIdentifiers = {};
|
for (const key in this.metrics) {
|
metricsIdentifiers[key] =
|
toSnakeCase(Metrics.getLossOrMetricName(this.metrics[key]));
|
}
|
return metricsIdentifiers;
|
}
|
}
|
getTrainingConfig() {
|
return {
|
loss: this.getLossIdentifiers(),
|
metrics: this.getMetricIdentifiers(),
|
optimizer_config: {
|
class_name: this.optimizer.getClassName(),
|
config: this.optimizer.getConfig()
|
}
|
};
|
// TODO(cais): Add weight_metrics when they are supported.
|
// TODO(cais): Add sample_weight_mode when it's supported.
|
// TODO(cais): Add loss_weights when it's supported.
|
}
|
loadTrainingConfig(trainingConfig) {
|
if (trainingConfig.weighted_metrics != null) {
|
throw new Error('Loading weight_metrics is not supported yet.');
|
}
|
if (trainingConfig.loss_weights != null) {
|
throw new Error('Loading loss_weights is not supported yet.');
|
}
|
if (trainingConfig.sample_weight_mode != null) {
|
throw new Error('Loading sample_weight_mode is not supported yet.');
|
}
|
const tsConfig = convertPythonicToTs(trainingConfig.optimizer_config);
|
const optimizer = deserialize(tsConfig);
|
let loss;
|
if (typeof trainingConfig.loss === 'string') {
|
loss = toCamelCase(trainingConfig.loss);
|
}
|
else if (Array.isArray(trainingConfig.loss)) {
|
loss = trainingConfig.loss.map(lossEntry => toCamelCase(lossEntry));
|
}
|
else if (trainingConfig.loss != null) {
|
loss = {};
|
for (const key in trainingConfig.loss) {
|
loss[key] = toCamelCase(trainingConfig.loss[key]);
|
}
|
}
|
let metrics;
|
if (Array.isArray(trainingConfig.metrics)) {
|
metrics = trainingConfig.metrics.map(metric => toCamelCase(metric));
|
}
|
else if (trainingConfig.metrics != null) {
|
metrics = {};
|
for (const key in trainingConfig.metrics) {
|
metrics[key] = toCamelCase(trainingConfig.metrics[key]);
|
}
|
}
|
this.compile({ loss, metrics, optimizer });
|
}
|
/**
|
* Save the configuration and/or weights of the LayersModel.
|
*
|
* An `IOHandler` is an object that has a `save` method of the proper
|
* signature defined. The `save` method manages the storing or
|
* transmission of serialized data ("artifacts") that represent the
|
* model's topology and weights onto or via a specific medium, such as
|
* file downloads, local storage, IndexedDB in the web browser and HTTP
|
* requests to a server. TensorFlow.js provides `IOHandler`
|
* implementations for a number of frequently used saving mediums, such as
|
* `tf.io.browserDownloads` and `tf.io.browserLocalStorage`. See `tf.io`
|
* for more details.
|
*
|
* This method also allows you to refer to certain types of `IOHandler`s
|
* as URL-like string shortcuts, such as 'localstorage://' and
|
* 'indexeddb://'.
|
*
|
* Example 1: 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 2. 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 3. Saving `model`'s topology and weights as two files
|
* (`my-model-1.json` and `my-model-1.weights.bin`) downloaded from
|
* browser.
|
*
|
* ```js
|
* const model = tf.sequential(
|
* {layers: [tf.layers.dense({units: 1, inputShape: [3]})]});
|
* const saveResults = await model.save('downloads://my-model-1');
|
* ```
|
*
|
* Example 4. Send `model`'s topology and weights to an HTTP server.
|
* See the documentation of `tf.io.http` for more details
|
* including specifying request parameters and implementation of the
|
* server.
|
*
|
* ```js
|
* const model = tf.sequential(
|
* {layers: [tf.layers.dense({units: 1, inputShape: [3]})]});
|
* const saveResults = await model.save('http://my-server/model/upload');
|
* ```
|
*
|
* @param handlerOrURL An instance of `IOHandler` or a URL-like,
|
* scheme-based string shortcut for `IOHandler`.
|
* @param config Options for saving the model.
|
* @returns A `Promise` of `SaveResult`, which summarizes the result of
|
* the saving, such as byte sizes of the saved artifacts for the model's
|
* topology and weight values.
|
*
|
* @doc {heading: 'Models', subheading: 'Classes', ignoreCI: true}
|
*/
|
async save(handlerOrURL, config) {
|
if (typeof handlerOrURL === 'string') {
|
const handlers = io.getSaveHandlers(handlerOrURL);
|
if (handlers.length === 0) {
|
throw new ValueError(`Cannot find any save handlers for URL '${handlerOrURL}'`);
|
}
|
else if (handlers.length > 1) {
|
throw new ValueError(`Found more than one (${handlers.length}) save handlers for ` +
|
`URL '${handlerOrURL}'`);
|
}
|
handlerOrURL = handlers[0];
|
}
|
if (handlerOrURL.save == null) {
|
throw new ValueError('LayersModel.save() cannot proceed because the IOHandler ' +
|
'provided does not have the `save` attribute defined.');
|
}
|
const weightDataAndSpecs = await io.encodeWeights(this.getNamedWeights(config));
|
const returnString = false;
|
const unusedArg = null;
|
const modelConfig = this.toJSON(unusedArg, returnString);
|
const modelArtifacts = {
|
modelTopology: modelConfig,
|
format: LAYERS_MODEL_FORMAT_NAME,
|
generatedBy: `TensorFlow.js tfjs-layers v${version}`,
|
convertedBy: null,
|
};
|
const includeOptimizer = config == null ? false : config.includeOptimizer;
|
if (includeOptimizer && this.optimizer != null) {
|
modelArtifacts.trainingConfig = this.getTrainingConfig();
|
const weightType = 'optimizer';
|
const { data: optimizerWeightData, specs: optimizerWeightSpecs } = await io.encodeWeights(await this.optimizer.getWeights(), weightType);
|
weightDataAndSpecs.specs.push(...optimizerWeightSpecs);
|
weightDataAndSpecs.data = io.concatenateArrayBuffers([weightDataAndSpecs.data, optimizerWeightData]);
|
}
|
if (this.userDefinedMetadata != null) {
|
// Check serialized size of user-defined metadata.
|
const checkSize = true;
|
checkUserDefinedMetadata(this.userDefinedMetadata, this.name, checkSize);
|
modelArtifacts.userDefinedMetadata = this.userDefinedMetadata;
|
}
|
modelArtifacts.weightData = weightDataAndSpecs.data;
|
modelArtifacts.weightSpecs = weightDataAndSpecs.specs;
|
return handlerOrURL.save(modelArtifacts);
|
}
|
/**
|
* Set user-defined metadata.
|
*
|
* The set metadata will be serialized together with the topology
|
* and weights of the model during `save()` calls.
|
*
|
* @param setUserDefinedMetadata
|
*/
|
setUserDefinedMetadata(userDefinedMetadata) {
|
checkUserDefinedMetadata(userDefinedMetadata, this.name);
|
this.userDefinedMetadata = userDefinedMetadata;
|
}
|
/**
|
* Get user-defined metadata.
|
*
|
* The metadata is supplied via one of the two routes:
|
* 1. By calling `setUserDefinedMetadata()`.
|
* 2. Loaded during model loading (if the model is constructed
|
* via `tf.loadLayersModel()`.)
|
*
|
* If no user-defined metadata is available from either of the
|
* two routes, this function will return `undefined`.
|
*/
|
getUserDefinedMetadata() {
|
return this.userDefinedMetadata;
|
}
|
}
|
// The class name is 'Model' rather than 'LayersModel' for backwards
|
// compatibility since this class name shows up in the serialization format.
|
/** @nocollapse */
|
LayersModel.className = 'Model';
|
export { LayersModel };
|
serialization.registerClass(LayersModel);
|
/**
|
* A `tf.Functional` is an alias to `tf.LayersModel`.
|
*
|
* See also:
|
* `tf.LayersModel`, `tf.Sequential`, `tf.loadLayersModel`.
|
*/
|
/** @doc {heading: 'Models', subheading: 'Classes'} */
|
class Functional extends LayersModel {
|
}
|
Functional.className = 'Functional';
|
export { Functional };
|
serialization.registerClass(Functional);
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"training.js","sourceRoot":"","sources":["../../../../../../tfjs-layers/src/engine/training.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: engine/training.py */\n\nimport * as tfc from '@tensorflow/tfjs-core';\nimport {io, ModelPredictConfig as ModelPredictArgs, NamedTensorMap, Optimizer, Scalar, scalar, serialization, Tensor, Tensor1D, tensor1d, util} from '@tensorflow/tfjs-core';\n\nimport * as K from '../backend/tfjs_backend';\nimport {BaseCallback, configureCallbacks, History, ModelLoggingVerbosity, standardizeCallbacks} from '../base_callbacks';\nimport {nameScope} from '../common';\nimport {NotImplementedError, RuntimeError, ValueError} from '../errors';\nimport {Shape} from '../keras_format/common';\nimport {LossIdentifier} from '../keras_format/loss_config';\nimport {OptimizerSerialization} from '../keras_format/optimizer_config';\nimport {MetricsIdentifier, TrainingConfig} from '../keras_format/training_config';\nimport {deserialize} from '../layers/serialization';\nimport { disposeTensorsInLogs, UnresolvedLogs } from '../logs';\nimport * as losses from '../losses';\nimport * as Metrics from '../metrics';\nimport * as optimizers from '../optimizers';\nimport {LossOrMetricFn, NamedTensor} from '../types';\nimport {checkUserDefinedMetadata} from '../user_defined_metadata';\nimport {count, pyListRepeat, singletonOrArray, toCamelCase, toSnakeCase, unique} from '../utils/generic_utils';\nimport {printSummary} from '../utils/layer_utils';\nimport {range} from '../utils/math_utils';\nimport {convertPythonicToTs} from '../utils/serialization_utils';\nimport {LayerVariable} from '../variables';\nimport {version} from '../version';\n\nimport {Container, ContainerArgs} from './container';\nimport {Dataset} from './dataset_stub';\nimport {execute, FeedDict} from './executor';\nimport {DisposeResult, SymbolicTensor} from './topology';\nimport {evaluateDataset, fitDataset, ModelEvaluateDatasetArgs, ModelFitDatasetArgs} from './training_dataset';\nimport {checkBatchSize, disposeNewTensors, ensureTensorsRank2OrHigher, makeBatches, ModelFitArgs, sliceArrays, sliceArraysByIndices} from './training_tensors';\nimport {ClassWeight, ClassWeightMap, computeWeightedLoss, standardizeClassWeights, standardizeWeights} from './training_utils';\n\n/**\n * Helper function for polymorphic input data: 1. singleton Tensor.\n */\nexport function isDataTensor(x: Tensor|Tensor[]|{[inputName: string]: Tensor}|\n                             {[inputName: string]: Tensor[]}): boolean {\n  return x instanceof Tensor;\n}\n\n/**\n * Helper function for polymorphic input data: 2. Array of Tensor.\n */\nexport function isDataArray(x: Tensor|Tensor[]|\n                            {[inputName: string]: Tensor}): boolean {\n  return Array.isArray(x);\n}\n\n/**\n * Helper function for polymorphic input data: 3. \"dict\" of Tensor.\n */\nexport function isDataDict(x: Tensor|Tensor[]|\n                           {[inputName: string]: Tensor}): boolean {\n  return !isDataTensor(x) && !isDataArray(x);\n}\n\n/**\n * Normalizes inputs and targets provided by users.\n * @param data User-provided input data (polymorphic).\n * @param names An Array of expected Tensor names.\n * @param shapes Optional Array of expected Tensor shapes.\n * @param checkBatchAxis Whether to check that the batch axis of the arrays\n *   match  the expected value found in `shapes`.\n * @param exceptionPrefix String prefix used for exception formatting.\n * @returns List of standardized input Tensors (one Tensor per model input).\n * @throws ValueError: in case of improperly formatted user data.\n */\nexport function standardizeInputData(\n    data: Tensor|Tensor[]|{[inputName: string]: Tensor}, names: string[],\n    shapes?: Shape[], checkBatchAxis = true, exceptionPrefix = ''): Tensor[] {\n  if (names == null || names.length === 0) {\n    // Check for the case where the model expected no data, but some data got\n    // sent.\n    if (data != null) {\n      let gotUnexpectedData = false;\n      if (isDataArray(data) && (data as Tensor[]).length > 0) {\n        gotUnexpectedData = true;\n      } else if (isDataDict(data)) {\n        for (const key in data) {\n          if (data.hasOwnProperty(key)) {\n            gotUnexpectedData = true;\n            break;\n          }\n        }\n      } else {\n        // `data` is a singleton Tensor in this case.\n        gotUnexpectedData = true;\n      }\n      if (gotUnexpectedData) {\n        throw new ValueError(\n            `Error when checking model ${exceptionPrefix} expected no data, ` +\n            `but got ${data}`);\n      }\n    }\n    return [];\n  }\n  if (data == null) {\n    return names.map(name => null);\n  }\n\n  let arrays: Tensor[];\n  if (isDataDict(data)) {\n    data = data as {[inputName: string]: Tensor};\n    arrays = [];\n    for (const name of names) {\n      if (data[name] == null) {\n        throw new ValueError(\n            `No data provided for \"${name}\". Need data for each key in: ` +\n            `${names}`);\n      }\n      arrays.push(data[name]);\n    }\n  } else if (isDataArray(data)) {\n    data = data as Tensor[];\n    if (data.length !== names.length) {\n      throw new ValueError(\n          `Error when checking model ${exceptionPrefix}: the Array of ` +\n          `Tensors that you are passing to your model is not the size the ` +\n          `model expected. Expected to see ${names.length} Tensor(s), but ` +\n          `instead got the following list of Tensor(s): ${data}`);\n    }\n    arrays = data;\n  } else {\n    data = data as Tensor;\n    if (names.length > 1) {\n      throw new ValueError(\n          `The model ${exceptionPrefix} expects ${names.length} Tensor(s), ` +\n          `but only received one Tensor. Found: Tensor with shape ${\n              data.shape}`);\n    }\n    arrays = [data];\n  }\n\n  arrays = ensureTensorsRank2OrHigher(arrays);\n\n  // Check shape compatibility.\n  if (shapes != null) {\n    for (let i = 0; i < names.length; ++i) {\n      if (shapes[i] == null) {\n        continue;\n      }\n      const array = arrays[i];\n      if (array.shape.length !== shapes[i].length) {\n        throw new ValueError(\n            `Error when checking ${exceptionPrefix}: expected ${names[i]} ` +\n            `to have ${shapes[i].length} dimension(s). but got array with ` +\n            `shape ${array.shape}`);\n      }\n      for (let j = 0; j < shapes[i].length; ++j) {\n        if (j === 0 && !checkBatchAxis) {\n          // Skip the first (batch) axis.\n          continue;\n        }\n        const dim = array.shape[j];\n        const refDim = shapes[i][j];\n        if (refDim != null && refDim >= 0 && dim !== refDim) {\n          throw new ValueError(\n              `${exceptionPrefix} expected a batch of elements where each ` +\n              `example has shape [${shapes[i].slice(1, shapes[i].length)}] ` +\n              `(i.e.,tensor shape [*,${\n                  shapes[i].slice(1, shapes[i].length)}])` +\n              ` but the ${exceptionPrefix} received an input with ${\n                  array.shape[0]}` +\n              ` examples, each with shape [${\n                  array.shape.slice(1, array.shape.length)}]` +\n              ` (tensor shape [${array.shape}])`);\n        }\n      }\n    }\n  }\n  return arrays;\n}\n\n/**\n * User input validation for Tensors.\n * @param inputs `Array` of `tf.Tensor`s for inputs.\n * @param targets `Array` of `tf.Tensor`s for targets.\n * @param weights Optional `Array` of `tf.Tensor`s for sample weights.\n * @throws ValueError: in case of incorrectly formatted data.\n */\nexport function checkArrayLengths(\n    inputs: Tensor[], targets: Tensor[], weights?: Tensor[]) {\n  const setX = unique(inputs.map(input => input.shape[0]));\n  setX.sort();\n  const setY = unique(targets.map(target => target.shape[0]));\n  setY.sort();\n  // TODO(cais): Check `weights` as well.\n  if (setX.length > 1) {\n    throw new ValueError(\n        `All input Tensors (x) should have the same number of samples. ` +\n        `Got array shapes: ` +\n        `${JSON.stringify(inputs.map(input => input.shape))}`);\n  }\n  if (setY.length > 1) {\n    throw new ValueError(\n        `All target Tensors (y) should have the same number of samples. ` +\n        `Got array shapes: ` +\n        `${JSON.stringify(targets.map(target => target.shape))}`);\n  }\n  if (setX.length > 0 && setY.length > 0 && !util.arraysEqual(setX, setY)) {\n    throw new ValueError(\n        `Input Tensors should have the same number of samples as target ` +\n        `Tensors. Found ${setX[0]} input sample(s) and ${setY[0]} target ` +\n        `sample(s).`);\n  }\n}\n\n/**\n * Validation on the compatibility of targes and loss functions.\n *\n * This helps prevent users from using loss functions incorrectly.\n *\n * @param targets `Array` of `tf.Tensor`s of targets.\n * @param lossFns `Array` of loss functions.\n * @param outputShapes `Array` of shapes of model outputs.\n */\nfunction checkLossAndTargetCompatibility(\n    targets: Tensor[], lossFns: LossOrMetricFn[], outputShapes: Shape[]) {\n  // TODO(cais): Dedicated test coverage?\n  const keyLosses = [\n    losses.meanSquaredError, losses.binaryCrossentropy,\n    losses.categoricalCrossentropy\n  ];\n  for (let i = 0; i < targets.length; ++i) {\n    const y = targets[i];\n    const loss = lossFns[i];\n    const shape = outputShapes[i];\n    if (loss == null) {\n      continue;\n    }\n    if (loss === losses.categoricalCrossentropy) {\n      if (y.shape[y.shape.length - 1] === 1) {\n        throw new ValueError(\n            `You are passing a target array of shape ${y.shape} while using ` +\n            `a loss 'categorical_crossentropy'. 'categorical_crossentropy'` +\n            `expects targets to be binary matrices (1s and 0s) of shape ` +\n            `[samples, classes].`);\n        // TODO(cais): Example code in error message.\n      }\n    }\n    if (keyLosses.indexOf(loss) !== -1) {\n      const slicedYShape = y.shape.slice(1);\n      const slicedShape = shape.slice(1);\n      for (let j = 0; j < slicedYShape.length; ++j) {\n        const targetDim = slicedYShape[j];\n        const outDim = slicedShape[j];\n        if (outDim != null && targetDim !== outDim) {\n          throw new ValueError(\n              `A target Tensor with shape ${y.shape} was passed for an ` +\n              `output of shape ${shape}, while using a loss function that ` +\n              `expects targets to have the same shape as the output.`);\n        }\n      }\n    }\n  }\n}\n\n/**\n * Check inputs provided by the user.\n *\n * Porting Note: This corresponds to _standardize_input_data() in Python\n *   Keras. Because of the strong typing in TF.js, we do not need to convert\n *   the data. Specifically:\n *   1) in PyKeras, `data` can be `DataFrame` instances from pandas, for\n *      example. We don't need to worry about that here because there is no\n *      widely popular javascript/typesdcript equivalent of pandas (so far).\n *      If one becomes available in the future, we can add support.\n *   2) in PyKeras, inputs can be Python dict. But here we are stipulating\n * that the data is either a single `tf.Tensor` or an Array of `tf.Tensor`s. We\n * may add support for `Object` data inputs in the future when the need\n * arises.\n *\n * Instead, we perform basic checks for number of parameters and shapes.\n *\n * @param data: The input data.\n * @param names: Name for the inputs, from the model.\n * @param shapes: Expected shapes for the input data, from the model.\n * @param checkBatchAxis: Whether the size along the batch axis (i.e., the\n *   first dimension) will be checked for matching.\n * @param exceptionPrefix: Execption prefix message, used in generating error\n *   messages.\n * @throws ValueError: on incorrect number of inputs or mismatches in shapes.\n */\nfunction checkInputData(\n    data: Tensor|Tensor[], names: string[], shapes?: Shape[],\n    checkBatchAxis = true, exceptionPrefix = '') {\n  let arrays: Tensor[];\n  if (Array.isArray(data)) {\n    if (data.length !== names.length) {\n      throw new ValueError(\n          `Error when checking model ${exceptionPrefix}: the Array of ` +\n          `Tensors that you are passing to your model is not the size the ` +\n          `the model expected. Expected to see ${names.length} Tensor(s),` +\n          ` but instead got ${data.length} Tensors(s).`);\n    }\n    arrays = data;\n  } else {\n    if (names.length > 1) {\n      throw new ValueError(\n          `The model expects ${names.length} ${exceptionPrefix} Tensors, ` +\n          `but only received one Tensor. Found: array with shape ` +\n          `${JSON.stringify(data.shape)}.`);\n    }\n    arrays = [data];\n  }\n\n  if (shapes != null) {\n    for (let i = 0; i < names.length; ++i) {\n      if (shapes[i] == null) {\n        continue;\n      }\n      const array = arrays[i];\n      if (array.shape.length !== shapes[i].length) {\n        throw new ValueError(\n            `Error when checking ${exceptionPrefix}: expected ${names[i]} ` +\n            `to have ${shapes[i].length} dimension(s), but got array with ` +\n            `shape ${JSON.stringify(array.shape)}`);\n      }\n      for (let j = 0; j < shapes[i].length; ++j) {\n        if (j === 0 && !checkBatchAxis) {\n          continue;\n        }\n        const dim = array.shape[j];\n        const refDim = shapes[i][j];\n        if (refDim != null) {\n          if (refDim !== dim) {\n            throw new ValueError(\n                `Error when checking ${exceptionPrefix}: expected ` +\n                `${names[i]} to have shape ${JSON.stringify(shapes[i])} but ` +\n                `got array with shape ${JSON.stringify(array.shape)}.`);\n          }\n        }\n      }\n    }\n  }\n}\n\n/**\n * Maps metric functions to model outputs.\n * @param metrics An shortcut strings name, metric function, `Array` or dict\n *   (`Object`) of metric functions.\n * @param outputNames An `Array` of the names of model outputs.\n * @returns An `Array` (one entry per model output) of `Array` of metric\n *   functions. For instance, if the model has 2 outputs, and for the first\n *   output we want to compute `binaryAccuracy` and `binaryCrossentropy`,\n *   and just `binaryAccuracy` for the second output, the `Array` would look\n *   like:\n *     `[[binaryAccuracy, binaryCrossentropy],  [binaryAccuracy]]`\n * @throws TypeError: incompatible metrics format.\n */\nexport function collectMetrics(\n    metrics: string|LossOrMetricFn|Array<string|LossOrMetricFn>|\n    {[outputName: string]: string | LossOrMetricFn},\n    outputNames: string[]): Array<Array<string|LossOrMetricFn>> {\n  if (metrics == null || Array.isArray(metrics) && metrics.length === 0) {\n    return outputNames.map(name => []);\n  }\n\n  let wrappedMetrics: Array<string|LossOrMetricFn>|\n      {[outputName: string]: string | LossOrMetricFn};\n  if (typeof metrics === 'string' || typeof metrics === 'function') {\n    wrappedMetrics = [metrics];\n  } else if (Array.isArray(metrics) || typeof metrics === 'object') {\n    wrappedMetrics = metrics as Array<string|LossOrMetricFn>|\n        {[outputName: string]: string} | {[outputName: string]: LossOrMetricFn};\n  } else {\n    throw new TypeError(\n        'Type of metrics argument not understood. Expected an string,' +\n        `function, Array, or Object, found: ${metrics}`);\n  }\n\n  if (Array.isArray(wrappedMetrics)) {\n    // We then apply all metrics to all outputs.\n    return outputNames.map(\n        name => wrappedMetrics as Array<string|LossOrMetricFn>);\n  } else {\n    // In this case, metrics is a dict.\n    const nestedMetrics: Array<Array<string|LossOrMetricFn>> = [];\n    for (const name of outputNames) {\n      let outputMetrics: string|LossOrMetricFn|Array<string|LossOrMetricFn> =\n          wrappedMetrics.hasOwnProperty(name) ? wrappedMetrics[name] : [];\n      if (!Array.isArray(outputMetrics)) {\n        outputMetrics = [outputMetrics];\n      }\n      nestedMetrics.push(outputMetrics);\n    }\n    return nestedMetrics;\n  }\n}\n\nexport interface ModelEvaluateArgs {\n  /**\n   * Batch size (Integer). If unspecified, it will default to 32.\n   */\n  batchSize?: number;\n\n  /**\n   * Verbosity mode.\n   */\n  verbose?: ModelLoggingVerbosity;\n\n  /**\n   * Tensor of weights to weight the contribution of different samples to the\n   * loss and metrics.\n   */\n  sampleWeight?: Tensor;\n\n  /**\n   * integer: total number of steps (batches of samples)\n   * before declaring the evaluation round finished. Ignored with the default\n   * value of `undefined`.\n   */\n  steps?: number;\n}\n\n/**\n * Configuration for calls to `LayersModel.compile()`.\n */\nexport interface ModelCompileArgs {\n  /**\n   * An instance of `tf.train.Optimizer` or a string name for an Optimizer.\n   */\n  optimizer: string|Optimizer;\n\n  /**\n   * Object function(s) or name(s) of object function(s).\n   * If the model has multiple outputs, you can use a different loss\n   * on each output by passing a dictionary or an Array of losses.\n   * The loss value that will be minimized by the model will then be the sum\n   * of all individual losses.\n   */\n  loss: string|string[]|{[outputName: string]: string}|LossOrMetricFn|\n      LossOrMetricFn[]|{[outputName: string]: LossOrMetricFn};\n\n  /**\n   * List of metrics to be evaluated by the model during training and testing.\n   * Typically you will use `metrics=['accuracy']`.\n   * To specify different metrics for different outputs of a multi-output\n   * model, you could also pass a dictionary.\n   */\n  metrics?: string|LossOrMetricFn|Array<string|LossOrMetricFn>|\n      {[outputName: string]: string | LossOrMetricFn};\n\n  // TODO(cais): Add lossWeights, sampleWeightMode, weightedMetrics, and\n  //   targetTensors.\n}\n\nconst LAYERS_MODEL_FORMAT_NAME = 'layers-model';\n\n/**\n * A `tf.LayersModel` is a directed, acyclic graph of `tf.Layer`s plus methods\n * for training, evaluation, prediction and saving.\n *\n * `tf.LayersModel` is the basic unit of training, inference and evaluation in\n * TensorFlow.js. To create a `tf.LayersModel`, use `tf.LayersModel`.\n *\n * See also:\n *   `tf.Sequential`, `tf.loadLayersModel`.\n *\n * @doc {heading: 'Models', subheading: 'Classes'}\n */\nexport class LayersModel extends Container implements tfc.InferenceModel {\n  // The class name is 'Model' rather than 'LayersModel' for backwards\n  // compatibility since this class name shows up in the serialization format.\n  /** @nocollapse */\n  static className = 'Model';\n  protected optimizer_: Optimizer;\n  // Whether the model instance owns the optimizer: `true` if and only if\n  // `optimizer` is created from a string parameter during `compile()` call.\n  protected isOptimizerOwned: boolean;\n\n  loss: string|string[]|{[outputName: string]: string}|LossOrMetricFn|\n      LossOrMetricFn[]|{[outputName: string]: LossOrMetricFn};\n  lossFunctions: LossOrMetricFn[];\n\n  // TODO(cais): These private variables should probably not have the string\n  //   'feed' in their names, because we are not dealing with a symbolic\n  //   backend.\n  private feedOutputShapes: Shape[];\n  private feedLossFns: LossOrMetricFn[];\n  private collectedTrainableWeights: LayerVariable[];\n  private testFunction: (data: Tensor[]) => Scalar[];\n  history: History;\n\n  // A public property that can be set by Callbacks to order early stopping\n  // during `fit()` calls.\n  protected stopTraining_: boolean;\n  protected isTraining: boolean;\n\n  metrics: string|LossOrMetricFn|Array<string|LossOrMetricFn>|\n      {[outputName: string]: string | LossOrMetricFn};\n  metricsNames: string[];\n  // Porting Note: `metrics_tensors` in PyKeras is a symbolic tensor. But given\n  //   the imperative nature of tfjs-core, `metricsTensors` is a\n  //   TypeScript function here.\n  //   Also note that due to the imperative nature of tfjs-core, `metricsTensor`\n  //   here needs an output index to keep track of which output of the\n  //   LayersModel a metric belongs to. This is unlike `metrics_tensors` in\n  //   PyKeras, which is a `list` of symbolic tensors, each of which has\n  //   implicit \"knowledge\" of the outputs it depends on.\n  metricsTensors: Array<[LossOrMetricFn, number]>;\n\n  // User defind metadata (if any).\n  private userDefinedMetadata: {};\n\n  constructor(args: ContainerArgs) {\n    super(args);\n    this.isTraining = false;\n  }\n\n  /**\n   * Print a text summary of the 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   * - If the model has non-sequential-like topology, the inputs each layer\n   *   receives\n   * - The total number of trainable and non-trainable parameters of the model.\n   *\n   * ```js\n   * const input1 = tf.input({shape: [10]});\n   * const input2 = tf.input({shape: [20]});\n   * const dense1 = tf.layers.dense({units: 4}).apply(input1);\n   * const dense2 = tf.layers.dense({units: 8}).apply(input2);\n   * const concat = tf.layers.concatenate().apply([dense1, dense2]);\n   * const output =\n   *     tf.layers.dense({units: 3, activation: 'softmax'}).apply(concat);\n   *\n   * const model = tf.model({inputs: [input1, input2], outputs: output});\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  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      throw new ValueError(\n          `This model has never been called, thus its weights have not been ` +\n          `created yet. So no summary can be displayed. Build the model ` +\n          `first (e.g., by calling it on some test data).`);\n    }\n    printSummary(this, lineLength, positions, printFn);\n  }\n\n  /**\n   * Configures and prepares the model for training and evaluation.  Compiling\n   * outfits the model with an optimizer, loss, and/or metrics.  Calling `fit`\n   * or `evaluate` on an un-compiled model will throw an error.\n   *\n   * @param args a `ModelCompileArgs` specifying the loss, optimizer, and\n   * metrics to be used for fitting and evaluating this model.\n   *\n   * @doc {heading: 'Models', subheading: 'Classes'}\n   */\n  compile(args: ModelCompileArgs): void {\n    if (args.loss == null) {\n      args.loss = [];\n    }\n    this.loss = args.loss;\n\n    if (typeof args.optimizer === 'string') {\n      this.optimizer_ = optimizers.getOptimizer(args.optimizer);\n      this.isOptimizerOwned = true;\n    } else {\n      if (!(args.optimizer instanceof Optimizer)) {\n        throw new ValueError(\n            `User-defined optimizer must be an instance of tf.Optimizer.`);\n      }\n      this.optimizer_ = args.optimizer;\n      this.isOptimizerOwned = false;\n    }\n\n    // TODO(cais): Add lossWeights.\n    // TODO(cais): Add sampleWeightMode.\n\n    // Prepare loss functions.\n    let lossFunctions: LossOrMetricFn[] = [];\n    if (!Array.isArray(args.loss) && typeof args.loss !== 'string' &&\n        typeof args.loss !== 'function') {\n      args.loss = args.loss as {[outputName: string]: string};\n      for (const name in args.loss) {\n        if (this.outputNames.indexOf(name) === -1) {\n          throw new ValueError(\n              `Unknown entry in loss dictionary: \"${name}\". ` +\n              `Only expected the following keys: ${this.outputNames}`);\n        }\n      }\n      for (const name of this.outputNames) {\n        if (args.loss[name] == null) {\n          console.warn(\n              `Output \"${name}\" is missing from loss dictionary. We assume ` +\n              `this was done on purpose, and we will not be expecting data ` +\n              `to be passed to ${name} during training`);\n        }\n        lossFunctions.push(losses.get(args.loss[name]));\n      }\n    } else if (Array.isArray(args.loss)) {\n      if (args.loss.length !== this.outputs.length) {\n        throw new ValueError(\n            `When passing an Array as loss, it should have one entry per ` +\n            `model output. The model has ${this.outputs.length} output(s), ` +\n            `but you passed loss=${args.loss}.`);\n      }\n      const theLosses = args.loss as Array<string|LossOrMetricFn>;\n      lossFunctions = theLosses.map(l => losses.get(l));\n    } else {\n      const lossFunction = losses.get(args.loss);\n      this.outputs.forEach(_ => {\n        lossFunctions.push(lossFunction);\n      });\n    }\n\n    this.lossFunctions = lossFunctions;\n\n    this.feedOutputNames = [];\n    this.feedOutputShapes = [];\n    this.feedLossFns = [];\n    for (let i = 0; i < this.outputs.length; ++i) {\n      // TODO(cais): Logic for skipping target(s).\n      const shape = this.internalOutputShapes[i];\n      const name = this.outputNames[i];\n      this.feedOutputNames.push(name);\n      this.feedOutputShapes.push(shape);\n      this.feedLossFns.push(this.lossFunctions[i]);\n    }\n\n    // TODO(cais): Add logic for output masks.\n    // TODO(cais): Add logic for sample weights.\n    const skipTargetIndices: number[] = [];\n\n    // Prepare metrics.\n    this.metrics = args.metrics;\n    // TODO(cais): Add weightedMetrics.\n    this.metricsNames = ['loss'];\n    this.metricsTensors = [];\n\n    // Compute total loss.\n    // Porting Note: In PyKeras, metrics_tensors are symbolic tensor objects.\n    //   Here, metricsTensors are TypeScript functions. This difference is due\n    //   to the difference in symbolic/imperative property of the backends.\n    nameScope('loss', () => {\n      for (let i = 0; i < this.outputs.length; ++i) {\n        if (skipTargetIndices.indexOf(i) !== -1) {\n          continue;\n        }\n        // TODO(cais): Add weightedLoss, sampleWeight and mask.\n        //   The following line should be weightedLoss\n        const weightedLoss = this.lossFunctions[i];\n        if (this.outputs.length > 1) {\n          this.metricsTensors.push([weightedLoss, i]);\n          this.metricsNames.push(this.outputNames[i] + '_loss');\n        }\n      }\n\n      // Porting Note: Due to the imperative nature of the backend, we calculate\n      //   the regularizer penalties in the totalLossFunction, instead of here.\n    });\n\n    const nestedMetrics = collectMetrics(args.metrics, this.outputNames);\n    // TODO(cais): Add nestedWeightedMetrics.\n\n    /**\n     * Helper function used in loop below.\n     */\n    const appendMetric =\n        (outputIndex: number, metricName: string,\n         metricTensor: LossOrMetricFn) => {\n          if (this.outputNames.length > 1) {\n            metricName = this.outputNames[outputIndex] + '_' + metricName;\n          }\n          this.metricsNames.push(metricName);\n          this.metricsTensors.push([metricTensor, outputIndex]);\n        };\n\n    nameScope('metric', () => {\n      for (let i = 0; i < this.outputs.length; ++i) {\n        if (skipTargetIndices.indexOf(i) !== -1) {\n          continue;\n        }\n        const outputMetrics = nestedMetrics[i];\n        // TODO(cais): Add weights and outputWeightedMetrics.\n\n        // TODO(cais): Add optional arg `weights` to the following function.\n        const handleMetrics = (metrics: Array<string|LossOrMetricFn>) => {\n          const metricNamePrefix = '';\n          let metricName: string;\n          let accFn: LossOrMetricFn;\n          let weightedMetricFn: LossOrMetricFn;\n          //  TODO(cais): Use 'weights_' for weighted metrics.\n\n          for (const metric of metrics) {\n            if (typeof metric === 'string' &&\n                ['accuracy', 'acc', 'crossentropy', 'ce'].indexOf(metric) !==\n                    -1) {\n              const outputShape = this.internalOutputShapes[i];\n\n              if (outputShape[outputShape.length - 1] === 1 ||\n                  this.lossFunctions[i] === losses.binaryCrossentropy) {\n                // case: binary accuracy/crossentropy.\n                if (['accuracy', 'acc'].indexOf(metric) !== -1) {\n                  accFn = Metrics.binaryAccuracy;\n                } else if (['crossentropy', 'ce'].indexOf(metric) !== -1) {\n                  accFn = Metrics.binaryCrossentropy;\n                }\n              } else if (\n                  this.lossFunctions[i] ===\n                  losses.sparseCategoricalCrossentropy) {\n                // case: categorical accuracy / crossentropy with sparse\n                // targets.\n                if (['accuracy', 'acc'].indexOf(metric) !== -1) {\n                  accFn = Metrics.sparseCategoricalAccuracy;\n                } else if (['crossentropy', 'ce'].indexOf(metric) !== -1) {\n                  accFn = Metrics.sparseCategoricalCrossentropy;\n                }\n              } else {\n                // case: categorical accuracy / crossentropy.\n                if (['accuracy', 'acc'].indexOf(metric) !== -1) {\n                  accFn = Metrics.categoricalAccuracy;\n                } else if (['crossentropy', 'ce'].indexOf(metric) !== -1) {\n                  accFn = Metrics.categoricalCrossentropy;\n                }\n              }\n              let suffix: string;\n              if (['accuracy', 'acc'].indexOf(metric) !== -1) {\n                suffix = 'acc';\n              } else if (['crossentropy', 'ce'].indexOf(metric) !== -1) {\n                suffix = 'ce';\n              }\n              // TODO(cais): Add weighting actually.\n              weightedMetricFn = accFn;\n              metricName = metricNamePrefix + suffix;\n            } else {\n              const metricFn = Metrics.get(metric);\n              // TODO(cais): Add weighting actually.\n              weightedMetricFn = metricFn;\n              metricName =\n                  metricNamePrefix + Metrics.getLossOrMetricName(metric);\n            }\n\n            // TODO(cais): Add weighting and masking to metricResult.\n            let metricResult: LossOrMetricFn;\n            nameScope(metricName, () => {\n              metricResult = weightedMetricFn;\n            });\n            appendMetric(i, metricName, metricResult);\n          }\n        };\n\n        handleMetrics(outputMetrics);\n        // TODO(cais): Call handleMetrics with weights.\n      }\n    });\n\n    // Porting Notes: Given the imperative backend of tfjs-core,\n    //   there is no need for constructing the symbolic graph and placeholders.\n    this.collectedTrainableWeights = this.trainableWeights;\n  }\n\n  /**\n   * Check trainable weights count consistency.\n   *\n   * This will raise a warning if `this.trainableWeights` and\n   * `this.collectedTrainableWeights` are inconsistent (i.e., have different\n   * numbers of parameters).\n   * Inconsistency will typically arise when one modifies `model.trainable`\n   * without calling `model.compile()` again.\n   */\n  protected checkTrainableWeightsConsistency(): void {\n    if (this.collectedTrainableWeights == null) {\n      return;\n    }\n    if (this.trainableWeights.length !==\n        this.collectedTrainableWeights.length) {\n      console.warn(\n          'Discrepancy between trainableweights and collected trainable ' +\n          'weights. Did you set `model.trainable` without calling ' +\n          '`model.compile()` afterwards?');\n    }\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(\n   *     tf.ones([8, 10]), tf.ones([8, 1]), {batchSize: 4});\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 `ModelEvaluateArgs`, 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  evaluate(\n      x: Tensor|Tensor[], y: Tensor|Tensor[],\n      args: ModelEvaluateArgs = {}): Scalar|Scalar[] {\n    const batchSize = args.batchSize == null ? 32 : args.batchSize;\n    checkBatchSize(batchSize);\n\n    // TODO(cais): Standardize `config.sampleWeights` as well.\n    // Validate user data.\n    const checkBatchAxis = true;\n    const standardizedOuts =\n        this.standardizeUserDataXY(x, y, checkBatchAxis, batchSize);\n    try {\n      // TODO(cais): If uses `useLearningPhase`, set the corresponding element\n      // of the input to 0.\n      const ins = standardizedOuts[0].concat(standardizedOuts[1]);\n      this.makeTestFunction();\n      const f = this.testFunction;\n      const testOuts =\n          this.testLoop(f, ins, batchSize, args.verbose, args.steps);\n      return singletonOrArray(testOuts);\n    } finally {\n      disposeNewTensors(standardizedOuts[0], x);\n      disposeNewTensors(standardizedOuts[1], y);\n    }\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  async evaluateDataset(dataset: Dataset<{}>, args?: ModelEvaluateDatasetArgs):\n      Promise<Scalar|Scalar[]> {\n    this.makeTestFunction();\n    return evaluateDataset(this, dataset, args);\n  }\n\n  /**\n   * Get number of samples provided for training, evaluation or prediction.\n   *\n   * @param ins Input `tf.Tensor`.\n   * @param batchSize Integer batch size, optional.\n   * @param steps Total number of steps (batches of samples) before\n   * declaring loop finished. Optional.\n   * @param stepsName The public API's parameter name for `steps`.\n   * @returns Number of samples provided.\n   */\n  private checkNumSamples(\n      ins: Tensor|Tensor[], batchSize?: number, steps?: number,\n      stepsName = 'steps'): number {\n    let numSamples: number;\n    if (steps != null) {\n      numSamples = null;\n      if (batchSize != null) {\n        throw new ValueError(\n            `If ${stepsName} is set, batchSize must be null or undefined.` +\n            `Got batchSize = ${batchSize}`);\n      }\n    } else if (ins != null) {\n      if (Array.isArray(ins)) {\n        numSamples = ins[0].shape[0];\n      } else {\n        numSamples = ins.shape[0];\n      }\n    } else {\n      throw new ValueError(\n          `Either the input data should have a defined shape, or ` +\n          `${stepsName} shoud be specified.`);\n    }\n    return numSamples;\n  }\n\n  /**\n   * Execute internal tensors of the model with input data feed.\n   * @param inputs Input data feed. Must match the inputs of the model.\n   * @param outputs Names of the output tensors to be fetched. Must match\n   *   names of the SymbolicTensors that belong to the graph.\n   * @returns Fetched values for `outputs`.\n   */\n  execute(inputs: Tensor|Tensor[]|NamedTensorMap, outputs: string|string[]):\n      Tensor|Tensor[] {\n    if (Array.isArray(outputs) && outputs.length === 0) {\n      throw new ValueError(\n          '`outputs` is an empty Array, which is not allowed.');\n    }\n\n    const outputsIsArray = Array.isArray(outputs);\n    const outputNames =\n        (outputsIsArray ? outputs : [outputs]);\n    const outputSymbolicTensors = this.retrieveSymbolicTensors(outputNames);\n\n    // Format the input into a FeedDict.\n    const feedDict = new FeedDict();\n    if (inputs instanceof Tensor) {\n      inputs = [inputs];\n    }\n    if (Array.isArray(inputs)) {\n      if (inputs.length !== this.inputs.length) {\n        throw new ValueError(\n            `The number of inputs provided (${inputs.length}) ` +\n            `does not match the number of inputs of this model ` +\n            `(${this.inputs.length}).`);\n      }\n      for (let i = 0; i < this.inputs.length; ++i) {\n        feedDict.add(this.inputs[i], inputs[i]);\n      }\n    } else {\n      for (const input of this.inputs) {\n        const tensorValue = inputs[input.name];\n        if (tensorValue == null) {\n          throw new ValueError(\n              `No value is provided for the model's input ${input.name}`);\n        }\n        feedDict.add(input, tensorValue);\n      }\n    }\n\n    // Run execution.\n    const executeOutputs = execute(outputSymbolicTensors, feedDict) as Tensor[];\n    return outputsIsArray ? executeOutputs : executeOutputs[0];\n  }\n\n  /**\n   * Retrieve the model's internal symbolic tensors from symbolic-tensor names.\n   */\n  private retrieveSymbolicTensors(symbolicTensorNames: string[]):\n      SymbolicTensor[] {\n    const outputSymbolicTensors: SymbolicTensor[] =\n        pyListRepeat(null, symbolicTensorNames.length);\n    let outputsRemaining = symbolicTensorNames.length;\n    for (const layer of this.layers) {\n      const layerOutputs: SymbolicTensor[] =\n          Array.isArray(layer.output) ? layer.output : [layer.output];\n      const layerOutputNames = layerOutputs.map(output => output.name);\n      for (let i = 0; i < symbolicTensorNames.length; ++i) {\n        const index = layerOutputNames.indexOf(symbolicTensorNames[i]);\n        if (index !== -1) {\n          outputSymbolicTensors[i] = layerOutputs[index];\n          outputsRemaining--;\n        }\n        if (outputsRemaining === 0) {\n          break;\n        }\n      }\n      if (outputsRemaining === 0) {\n        break;\n      }\n    }\n\n    if (outputsRemaining > 0) {\n      const remainingNames: string[] = [];\n      outputSymbolicTensors.forEach((tensor, i) => {\n        if (tensor == null) {\n          remainingNames.push(symbolicTensorNames[i]);\n        }\n      });\n      throw new ValueError(\n          `Cannot find SymbolicTensors for output name(s): ` +\n          `${JSON.stringify(remainingNames)}`);\n    }\n    return outputSymbolicTensors;\n  }\n\n  /**\n   * Helper method to loop over some data in batches.\n   *\n   * Porting Note: Not using the functional approach in the Python equivalent\n   *   due to the imperative backend.\n   * Porting Note: Does not support step mode currently.\n   *\n   * @param ins: input data\n   * @param batchSize: integer batch size.\n   * @param verbose: verbosity model\n   * @returns: Predictions as `tf.Tensor` (if a single output) or an `Array` of\n   *   `tf.Tensor` (if multipe outputs).\n   */\n  private predictLoop(ins: Tensor|Tensor[], batchSize = 32, verbose = false):\n      Tensor|Tensor[] {\n    return tfc.tidy(() => {\n      const numSamples = this.checkNumSamples(ins);\n      if (verbose) {\n        throw new NotImplementedError(\n            'Verbose predictLoop() is not implemented yet.');\n      }\n\n      // Sample-based predictions.\n      // Porting Note: Tensor currently does not support sliced assignments as\n      //   in numpy, e.g., x[1:3] = y. Therefore we use concatenation while\n      //   iterating over the batches.\n\n      const batches = makeBatches(numSamples, batchSize);\n      const outsBatches: Tensor[][] = this.outputs.map(output => []);\n\n      // TODO(cais): Can the scope() be pushed down inside the for loop?\n      for (let batchIndex = 0; batchIndex < batches.length; ++batchIndex) {\n        const batchOuts = tfc.tidy(() => {\n          const batchStart = batches[batchIndex][0];\n          const batchEnd = batches[batchIndex][1];\n          // TODO(cais): Take care of the case of the last element is a flag for\n          //   training/test.\n          const insBatch = sliceArrays(ins, batchStart, batchEnd);\n\n          // Construct the feeds for execute();\n          const feeds = [];\n          if (Array.isArray(insBatch)) {\n            for (let i = 0; i < insBatch.length; ++i) {\n              feeds.push({key: this.inputs[i], value: insBatch[i]});\n            }\n          } else {\n            feeds.push({key: this.inputs[0], value: insBatch});\n          }\n          const feedDict = new FeedDict(feeds);\n          return execute(this.outputs, feedDict) as Tensor[];\n        });\n        batchOuts.forEach((batchOut, i) => outsBatches[i].push(batchOut));\n      }\n      return singletonOrArray(\n          outsBatches.map(batches => tfc.concat(batches, 0)));\n    });\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([8, 10]), {batchSize: 4}).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 args A `ModelPredictArgs` object containing optional fields.\n   *\n   * @return Prediction results as a `tf.Tensor`(s).\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  predict(x: Tensor|Tensor[], args: ModelPredictArgs = {}): Tensor|Tensor[] {\n    const xsRank2OrHigher = ensureTensorsRank2OrHigher(x);\n    checkInputData(\n        xsRank2OrHigher, this.inputNames, this.feedInputShapes, false);\n    try {\n      // TODO(cais): Take care of stateful models.\n      //   if (this.stateful) ...\n      // TODO(cais): Take care of the learning_phase boolean flag.\n      //   if (this.useLearningPhase) ...\n      const batchSize = args.batchSize == null ? 32 : args.batchSize;\n      checkBatchSize(batchSize);\n      return this.predictLoop(xsRank2OrHigher, batchSize);\n    } finally {\n      disposeNewTensors(xsRank2OrHigher, x);\n    }\n  }\n\n  /**\n   * Returns predictions for a single batch of samples.\n   *\n   * ```js\n   * const model = tf.sequential({\n   *   layers: [tf.layers.dense({units: 1, inputShape: [10]})]\n   * });\n   * model.predictOnBatch(tf.ones([8, 10])).print();\n   * ```\n   * @param x: Input samples, as a Tensor (for models with exactly one\n   *   input) or an array of Tensors (for models with more than one input).\n   * @return Tensor(s) of predictions\n   *\n   * @doc {heading: 'Models', subheading: 'Classes'}\n   */\n  predictOnBatch(x: Tensor|Tensor[]): Tensor|Tensor[] {\n    checkInputData(x, this.inputNames, this.feedInputShapes, true);\n    // TODO(cais): Take care of the learning_phase boolean flag.\n    //   if (this.useLearningPhase) ...\n    const batchSize = (Array.isArray(x) ? x[0] : x).shape[0];\n    return this.predictLoop(x, batchSize);\n  }\n\n  protected standardizeUserDataXY(\n      x: Tensor|Tensor[]|{[inputName: string]: Tensor},\n      y: Tensor|Tensor[]|{[inputName: string]: Tensor}, checkBatchAxis = true,\n      batchSize?: number): [Tensor[], Tensor[]] {\n    // TODO(cais): Add sampleWeight, classWeight\n    if (this.optimizer_ == null) {\n      throw new RuntimeError(\n          'You must compile a model before training/testing. Use ' +\n          'LayersModel.compile(modelCompileArgs).');\n    }\n    const outputShapes: Shape[] = [];\n    for (let i = 0; i < this.feedOutputShapes.length; ++i) {\n      const outputShape = this.feedOutputShapes[i];\n      const lossFn = this.feedLossFns[i];\n      if (lossFn === losses.sparseCategoricalCrossentropy) {\n        outputShapes.push(\n            outputShape.slice(0, outputShape.length - 1).concat([1]));\n      } else {\n        // Porting Note: Because of strong typing `lossFn` must be a function.\n        outputShapes.push(outputShape);\n      }\n    }\n    x = standardizeInputData(\n        x, this.feedInputNames, this.feedInputShapes, false, 'input');\n    y = standardizeInputData(\n        y, this.feedOutputNames, outputShapes, false, 'target');\n    // TODO(cais): Standardize sampleWeights & classWeights.\n    checkArrayLengths(x, y, null);\n    // TODO(cais): Check sampleWeights as well.\n    checkLossAndTargetCompatibility(y, this.feedLossFns, this.feedOutputShapes);\n    if (this.stateful && batchSize != null && batchSize > 0) {\n      if (x[0].shape[0] % batchSize !== 0) {\n        throw new ValueError(\n            `In a stateful network, you should only pass inputs with a ` +\n            `number of samples that is divisible by the batch size ` +\n            `${batchSize}. Found: ${x[0].shape[0]} sample(s).`);\n      }\n    }\n    return [x, y];\n  }\n\n  protected async standardizeUserData(\n      x: Tensor|Tensor[]|{[inputName: string]: Tensor},\n      y: Tensor|Tensor[]|{[inputName: string]: Tensor},\n      sampleWeight?: Tensor|Tensor[]|{[outputName: string]: Tensor},\n      classWeight?: ClassWeight|ClassWeight[]|ClassWeightMap,\n      checkBatchAxis = true,\n      batchSize?: number): Promise<[Tensor[], Tensor[], Tensor[]]> {\n    const [standardXs, standardYs] =\n        this.standardizeUserDataXY(x, y, checkBatchAxis, batchSize);\n    // TODO(cais): Handle sampleWeights.\n    if (sampleWeight != null) {\n      throw new Error('sample weight is not supported yet.');\n    }\n\n    let standardSampleWeights: Tensor[] = null;\n    if (classWeight != null) {\n      const classWeights =\n          standardizeClassWeights(classWeight, this.outputNames);\n      standardSampleWeights = [];\n      for (let i = 0; i < classWeights.length; ++i) {\n        standardSampleWeights.push(\n            await standardizeWeights(standardYs[i], null, classWeights[i]));\n      }\n    }\n\n    // TODO(cais): Deal with the case of model.stateful == true.\n    return [standardXs, standardYs, standardSampleWeights];\n  }\n\n  /**\n   * Loop over some test data in batches.\n   * @param f A Function returning a list of tensors.\n   * @param ins Array of tensors to be fed to `f`.\n   * @param batchSize Integer batch size or `null` / `undefined`.\n   * @param verbose verbosity mode.\n   * @param steps Total number of steps (batches of samples) before\n   * declaring test finished. Ignored with the default value of `null` /\n   * `undefined`.\n   * @returns Array of Scalars.\n   */\n  private testLoop(\n      f: (data: Tensor[]) => Scalar[], ins: Tensor[], batchSize?: number,\n      verbose = 0, steps?: number): Scalar[] {\n    return tfc.tidy(() => {\n      const numSamples = this.checkNumSamples(ins, batchSize, steps, 'steps');\n      const outs: Scalar[] = [];\n      if (verbose > 0) {\n        throw new NotImplementedError('Verbose mode is not implemented yet.');\n      }\n      // TODO(cais): Use `indicesForConversionToDense' to prevent slow down.\n      if (steps != null) {\n        throw new NotImplementedError(\n            'steps mode in testLoop() is not implemented yet');\n      } else {\n        const batches = makeBatches(numSamples, batchSize);\n        const indexArray = tensor1d(range(0, numSamples));\n        for (let batchIndex = 0; batchIndex < batches.length; ++batchIndex) {\n          const batchStart = batches[batchIndex][0];\n          const batchEnd = batches[batchIndex][1];\n          const batchIds =\n              K.sliceAlongFirstAxis(\n                  indexArray, batchStart, batchEnd - batchStart) as Tensor1D;\n          // TODO(cais): In ins, train flag can be a number, instead of an\n          //   Tensor? Do we need to handle this in tfjs-layers?\n          const insBatch = sliceArraysByIndices(ins, batchIds) as Scalar[];\n          const batchOuts = f(insBatch);\n          if (batchIndex === 0) {\n            for (let i = 0; i < batchOuts.length; ++i) {\n              outs.push(scalar(0));\n            }\n          }\n          for (let i = 0; i < batchOuts.length; ++i) {\n            const batchOut = batchOuts[i];\n            outs[i] =\n                tfc.add(outs[i], tfc.mul(batchEnd - batchStart, batchOut));\n          }\n        }\n        for (let i = 0; i < outs.length; ++i) {\n          outs[i] = tfc.div(outs[i], numSamples);\n        }\n      }\n      return outs;\n    });\n  }\n\n  protected getDedupedMetricsNames(): string[] {\n    const outLabels = this.metricsNames;\n    // Rename duplicated metrics names (can happen with an output layer\n    // shared among multiple dataflows).\n    const dedupedOutLabels = [];\n    for (let i = 0; i < outLabels.length; ++i) {\n      const label = outLabels[i];\n      let newLabel = label;\n      if (count(outLabels, label) > 1) {\n        const dupIndex = count(outLabels.slice(0, i), label);\n        newLabel += `_${dupIndex}`;\n      }\n      dedupedOutLabels.push(newLabel);\n    }\n    return dedupedOutLabels;\n  }\n\n  /**\n   * Creates a function that performs the following actions:\n   *\n   * 1. computes the losses\n   * 2. sums them to get the total loss\n   * 3. call the optimizer computes the gradients of the LayersModel's\n   *    trainable weights w.r.t. the total loss and update the variables\n   * 4. calculates the metrics\n   * 5. returns the values of the losses and metrics.\n   */\n  protected makeTrainFunction(): (data: Tensor[]) => Scalar[] {\n    return (data: Tensor[]) => {\n      const lossValues: Scalar[] = [];\n\n      const inputs = data.slice(0, this.inputs.length);\n      const targets = data.slice(\n          this.inputs.length, this.inputs.length + this.outputs.length);\n      const sampleWeights = data.slice(\n          this.inputs.length + this.outputs.length,\n          this.inputs.length + this.outputs.length * 2);\n\n      const metricsValues: Scalar[] = [];\n\n      // Create a function that computes the total loss based on the\n      // inputs. This function is used for obtaining gradients through\n      // backprop.\n      const totalLossFunction = () => {\n        const feeds = [];\n        for (let i = 0; i < this.inputs.length; ++i) {\n          feeds.push({key: this.inputs[i], value: inputs[i]});\n        }\n        const feedDict = new FeedDict(feeds);\n        const outputs =\n            execute(this.outputs, feedDict, {'training': true}) as Tensor[];\n        // TODO(cais): Take care of the case of multiple outputs from a\n        //   single layer?\n\n        let totalLoss: Tensor;\n        for (let i = 0; i < this.lossFunctions.length; ++i) {\n          const lossFunction = this.lossFunctions[i];\n          let loss = lossFunction(targets[i], outputs[i]);\n          if (sampleWeights[i] != null) {\n            loss = computeWeightedLoss(loss, sampleWeights[i]);\n          }\n\n          // TODO(cais): push Scalar instead.\n          const meanLoss: Scalar = tfc.mean(loss);\n          // TODO(cais): Use a scope() instead, to avoid ownership.\n          lossValues.push(meanLoss);\n          if (i === 0) {\n            totalLoss = loss;\n          } else {\n            totalLoss = tfc.add(totalLoss, loss);\n          }\n        }\n\n        // Compute the metrics.\n        // TODO(cais): These should probably be calculated outside\n        //   totalLossFunction to benefit speed?\n        for (let i = 0; i < this.metricsTensors.length; ++i) {\n          let weightedMetric: Scalar;\n\n          if (this.outputs.length > 1 && i < this.outputs.length) {\n            weightedMetric = lossValues[i];\n          } else {\n            const metric = this.metricsTensors[i][0];\n            const outputIndex = this.metricsTensors[i][1];\n            weightedMetric =\n                tfc.mean(metric(targets[outputIndex], outputs[outputIndex]));\n          }\n\n          tfc.keep(weightedMetric);\n          // TODO(cais): Use a scope() instead, to avoid ownership.\n          metricsValues.push(weightedMetric);\n        }\n\n        totalLoss = tfc.mean(totalLoss);\n\n        // Add regularizer penalties.\n        this.calculateLosses().forEach(regularizerLoss => {\n          totalLoss = tfc.add(totalLoss, regularizerLoss);\n        });\n\n        return totalLoss as Scalar;\n      };\n\n      const variables = this.collectedTrainableWeights.map(\n          param => param.read() as tfc.Variable);\n      const returnCost = true;\n      const totalLossValue =\n          this.optimizer_.minimize(totalLossFunction, returnCost, variables);\n\n      return [totalLossValue].concat(metricsValues);\n    };\n  }\n\n  /**\n   * Create a function which, when invoked with an array of `tf.Tensor`s as a\n   * batch of inputs, returns the prespecified loss and metrics of the model\n   * under the batch of input data.\n   */\n  private makeTestFunction() {\n    this.testFunction = (data: Tensor[]) => {\n      return tfc.tidy(() => {\n        const valOutputs: Scalar[] = [];\n        let totalLoss: Scalar;\n        const inputs = data.slice(0, this.inputs.length);\n        const targets = data.slice(\n            this.inputs.length, this.inputs.length + this.outputs.length);\n        const feeds = [];\n        for (let i = 0; i < this.inputs.length; ++i) {\n          feeds.push({key: this.inputs[i], value: inputs[i]});\n        }\n        const feedDict = new FeedDict(feeds);\n        const outputs = execute(this.outputs, feedDict) as Tensor[];\n        // Compute total loss.\n        for (let i = 0; i < this.lossFunctions.length; ++i) {\n          const lossFunction = this.lossFunctions[i];\n          // TODO(cais): Add sample weighting and replace the simple\n          // averaging.\n          const loss: Scalar = tfc.mean(lossFunction(targets[i], outputs[i]));\n          if (i === 0) {\n            totalLoss = loss;\n          } else {\n            totalLoss = tfc.add(totalLoss, loss);\n          }\n          valOutputs.push(totalLoss);\n        }\n        // Compute the metrics.\n        for (let i = 0; i < this.metricsTensors.length; ++i) {\n          const metric = this.metricsTensors[i][0];\n          const outputIndex = this.metricsTensors[i][1];\n          // TODO(cais): Replace K.mean() with a proper weighting function.\n          const meanMetric =\n              tfc.mean(metric(targets[outputIndex], outputs[outputIndex]));\n          valOutputs.push(meanMetric as Scalar);\n        }\n        return valOutputs;\n      });\n    };\n  }\n\n  /**\n   * Trains the model for a fixed number of epochs (iterations on a\n   * 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   * for (let i = 1; i < 5 ; ++i) {\n   *   const h = await model.fit(tf.ones([8, 10]), tf.ones([8, 1]), {\n   *       batchSize: 4,\n   *       epochs: 3\n   *   });\n   *   console.log(\"Loss after Epoch \" + i + \" : \" + h.history.loss[0]);\n   * }\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\n   * can 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,\n   * you can also pass a dictionary mapping output names to `tf.Tensor`s.\n   * @param args A `ModelFitArgs`, 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\n   * data and what the model expects.\n   *\n   * @doc {heading: 'Models', subheading: 'Classes'}\n   */\n  async fit(\n      x: Tensor|Tensor[]|{[inputName: string]: Tensor},\n      y: Tensor|Tensor[]|{[inputName: string]: Tensor},\n      args: ModelFitArgs = {}): Promise<History> {\n    if (this.isTraining) {\n      throw new Error(\n          'Cannot start training because another fit() call is ongoing.');\n    }\n    this.isTraining = true;\n    let inputs: Tensor[];\n    let targets: Tensor[];\n    let originalInputs: Tensor[];\n    let originalTargets: Tensor[];\n    let inputValX: Tensor|Tensor[];\n    let inputValY: Tensor|Tensor[];\n    let valX: Tensor|Tensor[];\n    let valY: Tensor|Tensor[];\n    let sampleWeights: Tensor[];\n    try {\n      const batchSize = args.batchSize == null ? 32 : args.batchSize;\n      checkBatchSize(batchSize);\n\n      // Validate user data.\n      // TODO(cais): Support sampleWeight.\n      const checkBatchAxis = false;\n      const standardizedOuts =\n          await this.standardizeUserData(\n              x, y, args.sampleWeight, args.classWeight, checkBatchAxis,\n              batchSize) as [Tensor[], Tensor[], Tensor[]];\n      inputs = standardizedOuts[0];\n      targets = standardizedOuts[1];\n      sampleWeights = standardizedOuts[2];\n\n      // Prepare validation data.\n      let doValidation = false;\n      let valIns: Tensor[];\n      if (args.validationData != null && args.validationData.length > 0) {\n        doValidation = true;\n        if (args.validationData.length === 2) {\n          // config.validationData consists of valX and valY.\n          inputValX = args.validationData[0];\n          inputValY = args.validationData[1];\n        } else if (args.validationData.length === 3) {\n          throw new NotImplementedError(\n              'validationData including sample weights is not supported yet.');\n        } else {\n          throw new ValueError(\n              `When passing validation data, it must contain 2 (valX, valY) ` +\n              `or 3 (valX, valY, valSampleWeight) items; ` +\n              `${args.validationData} is invalid.`);\n        }\n\n        const checkBatchAxis = true;\n        const valStandardized =\n            await this.standardizeUserData(\n                inputValX, inputValY, null, /** Unused sample weights. */\n                null,                       /** Unused class weights. */\n                checkBatchAxis, batchSize) as [Tensor[], Tensor[], Tensor[]];\n        valX = valStandardized[0];\n        valY = valStandardized[1];\n        valIns = valX.concat(valY);\n        // TODO(cais): Add useLearningPhase data properly.\n      } else if (\n          args.validationSplit != null && args.validationSplit > 0 &&\n          args.validationSplit < 1) {\n        doValidation = true;\n        // Porting Note: In tfjs-layers, inputs[0] is always a Tensor.\n        const splitAt =\n            Math.floor(inputs[0].shape[0] * (1 - args.validationSplit));\n        const originalBatchSize = inputs[0].shape[0];\n        valX = sliceArrays(inputs, splitAt, originalBatchSize) as Tensor[];\n        originalInputs = inputs;\n        inputs = sliceArrays(inputs, 0, splitAt) as Tensor[];\n        valY = sliceArrays(targets, splitAt, originalBatchSize) as Tensor[];\n        originalTargets = targets;\n        targets = sliceArrays(targets, 0, splitAt) as Tensor[];\n        // TODO(cais): Once sampleWeights becomes available, slice it to get\n        //   valSampleWeights.\n        valIns = valX.concat(valY);\n\n        // TODO(cais): Add useLearningPhase data properly.\n      } else if (args.validationSteps != null) {\n        doValidation = true;\n        // TODO(cais): Add useLearningPhase.\n      }\n\n      const ins = inputs.concat(targets).concat(sampleWeights);\n\n      this.checkTrainableWeightsConsistency();\n\n      // TODO(cais): Handle use_learning_phase and learning_phase?\n\n      // Porting Note: Here we see a key deviation of tfjs-layers from\n      // Keras.\n      //  Due to the imperative nature of tfjs-layers' backend (tfjs-core),\n      //  we do not construct symbolic computation graphs to embody the\n      //  training process. Instead, we define a function that performs the\n      //  training action. In PyKeras, the data (inputs and targets) are fed\n      //  through graph placeholders. In tfjs-layers, the data are fed as\n      //  function arguments. Since the function are defined below in the\n      //  scope, we don't have equivalents of PyKeras's\n      //  `_make_train_funciton`.\n      const trainFunction = this.makeTrainFunction();\n      const outLabels = this.getDedupedMetricsNames();\n\n      let valFunction: (data: Tensor[]) => Scalar[];\n      let callbackMetrics: string[];\n      if (doValidation) {\n        this.makeTestFunction();\n        valFunction = this.testFunction;\n        callbackMetrics =\n            outLabels.slice().concat(outLabels.map(n => 'val_' + n));\n      } else {\n        valFunction = null;\n        valIns = [];\n        callbackMetrics = outLabels.slice();\n      }\n\n      const callbacks = standardizeCallbacks(args.callbacks, args.yieldEvery);\n      const out = await this.fitLoop(\n          trainFunction, ins, outLabels, batchSize, args.epochs,\n          args.verbose, callbacks, valFunction, valIns, args.shuffle,\n          callbackMetrics, args.initialEpoch, null, null);\n      return out;\n    } finally {\n      this.isTraining = false;\n      // Memory clean up.\n      disposeNewTensors(inputs, x);\n      disposeNewTensors(targets, y);\n      disposeNewTensors(originalInputs, x);\n      disposeNewTensors(originalTargets, y);\n      disposeNewTensors(valX as Tensor[], inputValX);\n      disposeNewTensors(valY as Tensor[], inputValY);\n      if (sampleWeights != null) {\n        tfc.dispose(sampleWeights);\n      }\n    }\n    // TODO(cais): Add value to outLabels.\n  }\n\n  /**\n   * Abstract fit function for `f(ins)`.\n   * @param f A Function returning a list of tensors. For training, this\n   *   function is expected to perform the updates to the variables.\n   * @param ins List of tensors to be fed to `f`.\n   * @param outLabels List of strings, display names of the outputs of `f`.\n   * @param batchSize Integer batch size or `== null` if unknown. Default : 32.\n   * @param epochs Number of times to iterate over the data. Default : 1.\n   * @param verbose Verbosity mode: 0, 1, or 2. Default: 1.\n   * @param callbacks List of callbacks to be called during training.\n   * @param valF Function to call for validation.\n   * @param valIns List of tensors to be fed to `valF`.\n   * @param shuffle Whether to shuffle the data at the beginning of every\n   * epoch. Default : true.\n   * @param callbackMetrics List of strings, the display names of the metrics\n   *   passed to the callbacks. They should be the concatenation of the\n   *   display names of the outputs of `f` and the list of display names\n   *   of the outputs of `valF`.\n   * @param initialEpoch Epoch at which to start training (useful for\n   *   resuming a previous training run). Default : 0.\n   * @param stepsPerEpoch Total number of steps (batches on samples) before\n   *   declaring one epoch finished and starting the next epoch. Ignored with\n   *   the default value of `undefined` or `null`.\n   * @param validationSteps Number of steps to run validation for (only if\n   *   doing validation from data tensors). Not applicable for tfjs-layers.\n   * @returns A `History` object.\n   */\n  async fitLoop(\n      f: (data: Tensor[]) => Scalar[], ins: Tensor[], outLabels?:\n      string[], batchSize?: number, epochs?: number, verbose?: number,\n      callbacks?: BaseCallback[], valF?: (data: Tensor[]) => Scalar[], valIns?:\n      Tensor[], shuffle?: boolean|string, callbackMetrics?: string[],\n      initialEpoch?: number, stepsPerEpoch?: number, validationSteps?: number):\n      Promise<History> {\n    if (batchSize == null) {\n      batchSize = 32;\n    }\n    if (epochs == null) {\n      epochs = 1;\n    }\n    if (shuffle == null) {\n      shuffle = true;\n    }\n    if (initialEpoch == null) {\n      initialEpoch = 0;\n    }\n\n    // TODO(cais): Change const to let below when implementing validation.\n    let doValidation = false;\n    if (valF != null && valIns != null) {\n      doValidation = true;\n      // TODO(cais): verbose message.\n    }\n    if (validationSteps != null) {\n      doValidation = true;\n      if (stepsPerEpoch == null) {\n        throw new ValueError(\n            'Can only use `validationSteps` when doing step-wise training, ' +\n            'i.e., `stepsPerEpoch` must be set.');\n      }\n    }\n\n    const numTrainSamples =\n        this.checkNumSamples(ins, batchSize, stepsPerEpoch, 'steps_per_epoch');\n    let indexArray: number[];\n    if (numTrainSamples != null) {\n      indexArray = range(0, numTrainSamples);\n    }\n\n    if (verbose == null) {\n      verbose = 1;\n    }\n\n    const {callbackList, history} = configureCallbacks(\n        callbacks, verbose, epochs, initialEpoch, numTrainSamples,\n        stepsPerEpoch, batchSize, doValidation, callbackMetrics);\n    callbackList.setModel(this);\n    this.history = history;\n    await callbackList.onTrainBegin();\n    this.stopTraining_ = false;\n    // TODO(cais): Take care of callbacks.validation_data as in PyKeras.\n    // TODO(cais): Pre-convert feeds for performance as in PyKeras.\n\n    for (let epoch = initialEpoch; epoch < epochs; ++epoch) {\n      await callbackList.onEpochBegin(epoch);\n      const epochLogs: UnresolvedLogs = {};\n      if (stepsPerEpoch != null) {\n        throw new NotImplementedError(\n            'stepsPerEpoch mode is not implemented yet.');\n      } else {\n        if (shuffle === 'batch') {\n          throw new NotImplementedError('batch shuffling is not implemneted'\n                                        + ' yet');\n        } else if (shuffle) {\n          util.shuffle(indexArray);\n        }\n        // Convert the potentially shuffled indices to Tensor1D, to avoid the\n        // cost of repeated creation of Array1Ds later on.\n        const epochIndexArray1D = tensor1d(indexArray);\n\n        const batches = makeBatches(numTrainSamples, batchSize);\n        for (let batchIndex = 0; batchIndex < batches.length; ++batchIndex) {\n          const batchLogs: UnresolvedLogs = {};\n          await callbackList.onBatchBegin(batchIndex, batchLogs);\n\n          tfc.tidy(() => {\n            const batchStart = batches[batchIndex][0];\n            const batchEnd = batches[batchIndex][1];\n            const batchIds = K.sliceAlongFirstAxis(\n                                 epochIndexArray1D, batchStart,\n                                 batchEnd - batchStart) as Tensor1D;\n            batchLogs['batch'] = batchIndex;\n            batchLogs['size'] = batchEnd - batchStart;\n\n            // TODO(cais): In ins, train flag can be a number, instead of an\n            //   Tensor? Do we need to handle this in tfjs-layers?\n            const insBatch = sliceArraysByIndices(ins, batchIds) as Tensor[];\n            const outs = f(insBatch);\n            for (let i = 0; i < outLabels.length; ++i) {\n              const label = outLabels[i];\n              const out = outs[i];\n              batchLogs[label] = out;\n              tfc.keep(out);\n              // TODO(cais): Use scope() to avoid ownership.\n            }\n\n            if (batchIndex === batches.length - 1) {  // Last batch.\n              if (doValidation) {\n                const valOuts = this.testLoop(valF, valIns, batchSize);\n                // Porting Notes: In tfjs-layers, valOuts is always an Array.\n                for (let i = 0; i < outLabels.length; ++i) {\n                  const label = outLabels[i];\n                  const out = valOuts[i];\n                  tfc.keep(out);\n                  // TODO(cais): Use scope() to avoid ownership.\n                  epochLogs['val_' + label] = out;\n                }\n              }\n            }\n          });\n\n          await callbackList.onBatchEnd(batchIndex, batchLogs);\n          disposeTensorsInLogs(batchLogs);\n\n          if (this.stopTraining_) {\n            break;\n          }\n          // TODO(cais): return outs as list of Tensor.\n        }\n\n        epochIndexArray1D.dispose();\n      }\n      // TODO(cais): Run validation at the end of the epoch.\n      await callbackList.onEpochEnd(epoch, epochLogs);\n      if (this.stopTraining_) {\n        break;\n      }\n    }\n    await callbackList.onTrainEnd();\n\n    await this.history.syncData();\n    return this.history;\n  }\n\n  // TODO(cais): Add code snippet below when it's possible to instantiate\n  //   actual dataset objects.\n  /**\n   * Trains the model using a dataset object.\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 training. 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.\n   *   Of the two items in the array, the first is the input feature(s) and\n   *   the second is the output target(s).\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'}\n   */\n  async fitDataset<T>(dataset: Dataset<T>, args: ModelFitDatasetArgs<T>):\n      Promise<History> {\n    return fitDataset(this, 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  async trainOnBatch(\n      x: Tensor|Tensor[]|{[inputName: string]: Tensor},\n      y: Tensor|Tensor[]|\n      {[inputName: string]: Tensor}): Promise<number|number[]> {\n    // TODO(cais): Support sampleWeight and classWeight.\n    // TODO(cais): Support Dataset objects.\n    const standardizeOut = await this.standardizeUserData(x, y);\n    const inputs = standardizeOut[0];\n    const targets = standardizeOut[1];\n    const trainFunction = this.makeTrainFunction();\n    const losses = trainFunction(inputs.concat(targets));\n    const lossValues: number[] = [];\n    for (const loss of losses) {\n      const v = await loss.data();\n      lossValues.push(v[0]);\n    }\n    tfc.dispose(losses);\n    disposeNewTensors(standardizeOut[0], x);\n    disposeNewTensors(standardizeOut[1], y);\n    return singletonOrArray(lossValues);\n  }\n\n  /**\n   * Extract weight values of the model.\n   *\n   * @param config: An instance of `io.SaveConfig`, which specifies\n   * model-saving options such as whether only trainable weights are to be\n   * saved.\n   * @returns A `NamedTensorMap` mapping original weight names (i.e.,\n   *   non-uniqueified weight names) to their values.\n   */\n  protected getNamedWeights(config?: io.SaveConfig): NamedTensor[] {\n    const namedWeights: NamedTensor[] = [];\n\n    const trainableOnly = config != null && config.trainableOnly;\n    const weights = trainableOnly ? this.trainableWeights : this.weights;\n    const weightValues = this.getWeights(trainableOnly);\n    for (let i = 0; i < weights.length; ++i) {\n      if (trainableOnly && !weights[i].trainable) {\n        // Optionally skip non-trainable weights.\n        continue;\n      }\n      namedWeights.push(\n          {name: weights[i].originalName, tensor: weightValues[i]});\n    }\n    return namedWeights;\n  }\n\n  /**\n   * Setter used for force stopping of LayersModel.fit() (i.e., training).\n   *\n   * Example:\n   *\n   * ```js\n   * const input = tf.input({shape: [10]});\n   * const output = tf.layers.dense({units: 1}).apply(input);\n   * const model = tf.model({inputs: [input], outputs: [output]});\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\n   * values,\n   * // due to the stopping after 3 epochs.\n   * console.log(history.history.loss);\n   * ```\n   */\n  set stopTraining(stop: boolean) {\n    this.stopTraining_ = stop;\n  }\n\n  get stopTraining(): boolean {\n    return this.stopTraining_;\n  }\n\n  get optimizer(): Optimizer {\n    return this.optimizer_;\n  }\n\n  set optimizer(optimizer: Optimizer) {\n    if (this.optimizer_ !== optimizer) {\n      this.optimizer_ = optimizer;\n      this.isOptimizerOwned = false;\n    }\n  }\n\n  override dispose(): DisposeResult {\n    const result = super.dispose();\n    if (result.refCountAfterDispose === 0 && this.optimizer != null &&\n        this.isOptimizerOwned) {\n      const numTensorsBeforeOptmizerDisposal = tfc.memory().numTensors;\n      this.optimizer_.dispose();\n      result.numDisposedVariables +=\n          numTensorsBeforeOptmizerDisposal - tfc.memory().numTensors;\n    }\n    return result;\n  }\n\n  private getLossIdentifiers(): LossIdentifier|LossIdentifier[]|\n      {[outputName: string]: LossIdentifier} {\n    let lossNames: LossIdentifier|LossIdentifier[]|\n        {[outputName: string]: LossIdentifier};\n    if (typeof this.loss === 'string') {\n      lossNames = toSnakeCase(this.loss) as LossIdentifier;\n    } else if (Array.isArray(this.loss)) {\n      for (const loss of this.loss) {\n        if (typeof loss !== 'string') {\n          throw new Error('Serialization of non-string loss is not supported.');\n        }\n      }\n      lossNames = (this.loss as string[]).map(name => toSnakeCase(name)) as\n          LossIdentifier[];\n    } else {\n      const outputNames = Object.keys(this.loss);\n      lossNames = {} as {[outputName: string]: LossIdentifier};\n      const losses =\n          this.loss as {[outputName: string]: LossOrMetricFn | string};\n      for (const outputName of outputNames) {\n        if (typeof losses[outputName] === 'string') {\n          lossNames[outputName] =\n              toSnakeCase(losses[outputName] as string) as LossIdentifier;\n        } else {\n          throw new Error('Serialization of non-string loss is not supported.');\n        }\n      }\n    }\n    return lossNames;\n  }\n\n  private getMetricIdentifiers(): MetricsIdentifier[]|\n      {[key: string]: MetricsIdentifier} {\n    if (typeof this.metrics === 'string' ||\n        typeof this.metrics === 'function') {\n      return [toSnakeCase(Metrics.getLossOrMetricName(this.metrics))];\n    } else if (Array.isArray(this.metrics)) {\n      return this.metrics.map(\n          metric => toSnakeCase(Metrics.getLossOrMetricName(metric)));\n    } else {\n      const metricsIdentifiers: {[key: string]: MetricsIdentifier} = {};\n      for (const key in this.metrics) {\n        metricsIdentifiers[key] =\n            toSnakeCase(Metrics.getLossOrMetricName(this.metrics[key]));\n      }\n      return metricsIdentifiers;\n    }\n  }\n\n  protected getTrainingConfig(): TrainingConfig {\n    return {\n      loss: this.getLossIdentifiers(),\n      metrics: this.getMetricIdentifiers(),\n      optimizer_config: {\n        class_name: this.optimizer.getClassName(),\n        config: this.optimizer.getConfig()\n      } as OptimizerSerialization\n    };\n    // TODO(cais): Add weight_metrics when they are supported.\n    // TODO(cais): Add sample_weight_mode when it's supported.\n    // TODO(cais): Add loss_weights when it's supported.\n  }\n\n  loadTrainingConfig(trainingConfig: TrainingConfig) {\n    if (trainingConfig.weighted_metrics != null) {\n      throw new Error('Loading weight_metrics is not supported yet.');\n    }\n    if (trainingConfig.loss_weights != null) {\n      throw new Error('Loading loss_weights is not supported yet.');\n    }\n    if (trainingConfig.sample_weight_mode != null) {\n      throw new Error('Loading sample_weight_mode is not supported yet.');\n    }\n\n    const tsConfig = convertPythonicToTs(trainingConfig.optimizer_config) as\n        serialization.ConfigDict;\n    const optimizer = deserialize(tsConfig) as Optimizer;\n\n    let loss;\n    if (typeof trainingConfig.loss === 'string') {\n      loss = toCamelCase(trainingConfig.loss);\n    } else if (Array.isArray(trainingConfig.loss)) {\n      loss = trainingConfig.loss.map(lossEntry => toCamelCase(lossEntry));\n    } else if (trainingConfig.loss != null) {\n      loss = {} as {[outputName: string]: LossIdentifier};\n      for (const key in trainingConfig.loss) {\n        loss[key] = toCamelCase(trainingConfig.loss[key]) as LossIdentifier;\n      }\n    }\n\n    let metrics;\n    if (Array.isArray(trainingConfig.metrics)) {\n      metrics = trainingConfig.metrics.map(metric => toCamelCase(metric));\n    } else if (trainingConfig.metrics != null) {\n      metrics = {} as {[outputName: string]: MetricsIdentifier};\n      for (const key in trainingConfig.metrics) {\n        metrics[key] = toCamelCase(trainingConfig.metrics[key]);\n      }\n    }\n\n    this.compile({loss, metrics, optimizer});\n  }\n\n  /**\n   * Save the configuration and/or weights of the LayersModel.\n   *\n   * An `IOHandler` is an object that has a `save` method of the proper\n   * signature defined. The `save` method manages the storing or\n   * transmission of serialized data (\"artifacts\") that represent the\n   * model's topology and weights onto or via a specific medium, such as\n   * file downloads, local storage, IndexedDB in the web browser and HTTP\n   * requests to a server. TensorFlow.js provides `IOHandler`\n   * implementations for a number of frequently used saving mediums, such as\n   * `tf.io.browserDownloads` and `tf.io.browserLocalStorage`. See `tf.io`\n   * for more details.\n   *\n   * This method also allows you to refer to certain types of `IOHandler`s\n   * as URL-like string shortcuts, such as 'localstorage://' and\n   * 'indexeddb://'.\n   *\n   * Example 1: 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 2. 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 3. Saving `model`'s topology and weights as two files\n   * (`my-model-1.json` and `my-model-1.weights.bin`) downloaded from\n   * browser.\n   *\n   * ```js\n   * const model = tf.sequential(\n   *     {layers: [tf.layers.dense({units: 1, inputShape: [3]})]});\n   * const saveResults = await model.save('downloads://my-model-1');\n   * ```\n   *\n   * Example 4. Send  `model`'s topology and weights to an HTTP server.\n   * See the documentation of `tf.io.http` for more details\n   * including specifying request parameters and implementation of the\n   * server.\n   *\n   * ```js\n   * const model = tf.sequential(\n   *     {layers: [tf.layers.dense({units: 1, inputShape: [3]})]});\n   * const saveResults = await model.save('http://my-server/model/upload');\n   * ```\n   *\n   * @param handlerOrURL An instance of `IOHandler` or a URL-like,\n   * scheme-based string shortcut for `IOHandler`.\n   * @param config Options for saving the model.\n   * @returns A `Promise` of `SaveResult`, which summarizes the result of\n   * the saving, such as byte sizes of the saved artifacts for the model's\n   *   topology and weight values.\n   *\n   * @doc {heading: 'Models', subheading: 'Classes', ignoreCI: true}\n   */\n  async save(handlerOrURL: io.IOHandler|string, config?: io.SaveConfig):\n      Promise<io.SaveResult> {\n    if (typeof handlerOrURL === 'string') {\n      const handlers = io.getSaveHandlers(handlerOrURL);\n      if (handlers.length === 0) {\n        throw new ValueError(\n            `Cannot find any save handlers for URL '${handlerOrURL}'`);\n      } else if (handlers.length > 1) {\n        throw new ValueError(\n            `Found more than one (${handlers.length}) save handlers for ` +\n            `URL '${handlerOrURL}'`);\n      }\n      handlerOrURL = handlers[0];\n    }\n    if (handlerOrURL.save == null) {\n      throw new ValueError(\n          'LayersModel.save() cannot proceed because the IOHandler ' +\n          'provided does not have the `save` attribute defined.');\n    }\n\n    const weightDataAndSpecs =\n        await io.encodeWeights(this.getNamedWeights(config));\n\n    const returnString = false;\n    const unusedArg: {} = null;\n    const modelConfig = this.toJSON(unusedArg, returnString);\n    const modelArtifacts: io.ModelArtifacts = {\n      modelTopology: modelConfig,\n      format: LAYERS_MODEL_FORMAT_NAME,\n      generatedBy: `TensorFlow.js tfjs-layers v${version}`,\n      convertedBy: null,\n    };\n\n    const includeOptimizer = config == null ? false : config.includeOptimizer;\n    if (includeOptimizer && this.optimizer != null) {\n      modelArtifacts.trainingConfig = this.getTrainingConfig();\n      const weightType = 'optimizer';\n      const {data: optimizerWeightData, specs: optimizerWeightSpecs} =\n          await io.encodeWeights(await this.optimizer.getWeights(), weightType);\n      weightDataAndSpecs.specs.push(...optimizerWeightSpecs);\n      weightDataAndSpecs.data = io.concatenateArrayBuffers(\n          [weightDataAndSpecs.data, optimizerWeightData]);\n    }\n\n    if (this.userDefinedMetadata != null) {\n      // Check serialized size of user-defined metadata.\n      const checkSize = true;\n      checkUserDefinedMetadata(this.userDefinedMetadata, this.name, checkSize);\n      modelArtifacts.userDefinedMetadata = this.userDefinedMetadata;\n    }\n\n    modelArtifacts.weightData = weightDataAndSpecs.data;\n    modelArtifacts.weightSpecs = weightDataAndSpecs.specs;\n    return handlerOrURL.save(modelArtifacts);\n  }\n\n  /**\n   * Set user-defined metadata.\n   *\n   * The set metadata will be serialized together with the topology\n   * and weights of the model during `save()` calls.\n   *\n   * @param setUserDefinedMetadata\n   */\n  setUserDefinedMetadata(userDefinedMetadata: {}): void {\n    checkUserDefinedMetadata(userDefinedMetadata, this.name);\n    this.userDefinedMetadata = userDefinedMetadata;\n  }\n\n  /**\n   * Get user-defined metadata.\n   *\n   * The metadata is supplied via one of the two routes:\n   *   1. By calling `setUserDefinedMetadata()`.\n   *   2. Loaded during model loading (if the model is constructed\n   *      via `tf.loadLayersModel()`.)\n   *\n   * If no user-defined metadata is available from either of the\n   * two routes, this function will return `undefined`.\n   */\n  getUserDefinedMetadata(): {} {\n    return this.userDefinedMetadata;\n  }\n}\nserialization.registerClass(LayersModel);\n\n/**\n * A `tf.Functional` is an alias to `tf.LayersModel`.\n *\n * See also:\n *   `tf.LayersModel`, `tf.Sequential`, `tf.loadLayersModel`.\n */\n/** @doc {heading: 'Models', subheading: 'Classes'} */\nexport class Functional extends LayersModel {\n  static override className = 'Functional';\n}\nserialization.registerClass(Functional);\n"]}
|
