@cuemath/leap 4.1.1-gg4 → 4.1.1-j2

package/dist/node_modules/@tensorflow/tfjs-layers/dist/engine/training.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"training.js","sources":["../../../../../../node_modules/@tensorflow/tfjs-layers/dist/engine/training.js"],"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/* Original Source: engine/training.py */\nimport * as tfc from '@tensorflow/tfjs-core';\nimport { io, Optimizer, scalar, serialization, Tensor, tensor1d, util } from '@tensorflow/tfjs-core';\nimport * as K from '../backend/tfjs_backend';\nimport { configureCallbacks, standardizeCallbacks } from '../base_callbacks';\nimport { nameScope } from '../common';\nimport { NotImplementedError, RuntimeError, ValueError } from '../errors';\nimport { deserialize } from '../layers/serialization';\nimport { disposeTensorsInLogs } from '../logs';\nimport * as losses from '../losses';\nimport * as Metrics from '../metrics';\nimport * as optimizers from '../optimizers';\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 { version } from '../version';\nimport { Container } from './container';\nimport { execute, FeedDict } from './executor';\nimport { evaluateDataset, fitDataset } from './training_dataset';\nimport { checkBatchSize, disposeNewTensors, ensureTensorsRank2OrHigher, makeBatches, sliceArrays, sliceArraysByIndices } from './training_tensors';\nimport { computeWeightedLoss, standardizeClassWeights, standardizeWeights } from './training_utils';\n/**\n * Helper function for polymorphic input data: 1. singleton Tensor.\n */\nexport function isDataTensor(x) {\n    return x instanceof Tensor;\n}\n/**\n * Helper function for polymorphic input data: 2. Array of Tensor.\n */\nexport function isDataArray(x) {\n    return Array.isArray(x);\n}\n/**\n * Helper function for polymorphic input data: 3. \"dict\" of Tensor.\n */\nexport function isDataDict(x) {\n    return !isDataTensor(x) && !isDataArray(x);\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(data, names, shapes, checkBatchAxis = true, exceptionPrefix = '') {\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.length > 0) {\n                gotUnexpectedData = true;\n            }\n            else if (isDataDict(data)) {\n                for (const key in data) {\n                    if (data.hasOwnProperty(key)) {\n                        gotUnexpectedData = true;\n                        break;\n                    }\n                }\n            }\n            else {\n                // `data` is a singleton Tensor in this case.\n                gotUnexpectedData = true;\n            }\n            if (gotUnexpectedData) {\n                throw new ValueError(`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    let arrays;\n    if (isDataDict(data)) {\n        data = data;\n        arrays = [];\n        for (const name of names) {\n            if (data[name] == null) {\n                throw new ValueError(`No data provided for \"${name}\". Need data for each key in: ` +\n                    `${names}`);\n            }\n            arrays.push(data[name]);\n        }\n    }\n    else if (isDataArray(data)) {\n        data = data;\n        if (data.length !== names.length) {\n            throw new ValueError(`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    }\n    else {\n        data = data;\n        if (names.length > 1) {\n            throw new ValueError(`The model ${exceptionPrefix} expects ${names.length} Tensor(s), ` +\n                `but only received one Tensor. Found: Tensor with shape ${data.shape}`);\n        }\n        arrays = [data];\n    }\n    arrays = ensureTensorsRank2OrHigher(arrays);\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(`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(`${exceptionPrefix} expected a batch of elements where each ` +\n                        `example has shape [${shapes[i].slice(1, shapes[i].length)}] ` +\n                        `(i.e.,tensor shape [*,${shapes[i].slice(1, shapes[i].length)}])` +\n                        ` but the ${exceptionPrefix} received an input with ${array.shape[0]}` +\n                        ` examples, each with shape [${array.shape.slice(1, array.shape.length)}]` +\n                        ` (tensor shape [${array.shape}])`);\n                }\n            }\n        }\n    }\n    return arrays;\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(inputs, targets, weights) {\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(`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(`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(`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 * 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(targets, lossFns, outputShapes) {\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(`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(`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 * 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(data, names, shapes, checkBatchAxis = true, exceptionPrefix = '') {\n    let arrays;\n    if (Array.isArray(data)) {\n        if (data.length !== names.length) {\n            throw new ValueError(`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    }\n    else {\n        if (names.length > 1) {\n            throw new ValueError(`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    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(`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(`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 * 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(metrics, outputNames) {\n    if (metrics == null || Array.isArray(metrics) && metrics.length === 0) {\n        return outputNames.map(name => []);\n    }\n    let wrappedMetrics;\n    if (typeof metrics === 'string' || typeof metrics === 'function') {\n        wrappedMetrics = [metrics];\n    }\n    else if (Array.isArray(metrics) || typeof metrics === 'object') {\n        wrappedMetrics = metrics;\n    }\n    else {\n        throw new TypeError('Type of metrics argument not understood. Expected an string,' +\n            `function, Array, or Object, found: ${metrics}`);\n    }\n    if (Array.isArray(wrappedMetrics)) {\n        // We then apply all metrics to all outputs.\n        return outputNames.map(name => wrappedMetrics);\n    }\n    else {\n        // In this case, metrics is a dict.\n        const nestedMetrics = [];\n        for (const name of outputNames) {\n            let outputMetrics = wrappedMetrics.hasOwnProperty(name) ? wrappedMetrics[name] : [];\n            if (!Array.isArray(outputMetrics)) {\n                outputMetrics = [outputMetrics];\n            }\n            nestedMetrics.push(outputMetrics);\n        }\n        return nestedMetrics;\n    }\n}\nconst LAYERS_MODEL_FORMAT_NAME = 'layers-model';\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 */\nclass LayersModel extends Container {\n    constructor(args) {\n        super(args);\n        this.isTraining = false;\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(lineLength, positions, printFn = console.log) {\n        if (!this.built) {\n            throw new ValueError(`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     * 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) {\n        if (args.loss == null) {\n            args.loss = [];\n        }\n        this.loss = args.loss;\n        if (typeof args.optimizer === 'string') {\n            this.optimizer_ = optimizers.getOptimizer(args.optimizer);\n            this.isOptimizerOwned = true;\n        }\n        else {\n            if (!(args.optimizer instanceof Optimizer)) {\n                throw new ValueError(`User-defined optimizer must be an instance of tf.Optimizer.`);\n            }\n            this.optimizer_ = args.optimizer;\n            this.isOptimizerOwned = false;\n        }\n        // TODO(cais): Add lossWeights.\n        // TODO(cais): Add sampleWeightMode.\n        // Prepare loss functions.\n        let lossFunctions = [];\n        if (!Array.isArray(args.loss) && typeof args.loss !== 'string' &&\n            typeof args.loss !== 'function') {\n            args.loss = args.loss;\n            for (const name in args.loss) {\n                if (this.outputNames.indexOf(name) === -1) {\n                    throw new ValueError(`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(`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        }\n        else if (Array.isArray(args.loss)) {\n            if (args.loss.length !== this.outputs.length) {\n                throw new ValueError(`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;\n            lossFunctions = theLosses.map(l => losses.get(l));\n        }\n        else {\n            const lossFunction = losses.get(args.loss);\n            this.outputs.forEach(_ => {\n                lossFunctions.push(lossFunction);\n            });\n        }\n        this.lossFunctions = lossFunctions;\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        // TODO(cais): Add logic for output masks.\n        // TODO(cais): Add logic for sample weights.\n        const skipTargetIndices = [];\n        // Prepare metrics.\n        this.metrics = args.metrics;\n        // TODO(cais): Add weightedMetrics.\n        this.metricsNames = ['loss'];\n        this.metricsTensors = [];\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            // Porting Note: Due to the imperative nature of the backend, we calculate\n            //   the regularizer penalties in the totalLossFunction, instead of here.\n        });\n        const nestedMetrics = collectMetrics(args.metrics, this.outputNames);\n        // TODO(cais): Add nestedWeightedMetrics.\n        /**\n         * Helper function used in loop below.\n         */\n        const appendMetric = (outputIndex, metricName, metricTensor) => {\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        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                // TODO(cais): Add optional arg `weights` to the following function.\n                const handleMetrics = (metrics) => {\n                    const metricNamePrefix = '';\n                    let metricName;\n                    let accFn;\n                    let weightedMetricFn;\n                    //  TODO(cais): Use 'weights_' for weighted metrics.\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                            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                                }\n                                else if (['crossentropy', 'ce'].indexOf(metric) !== -1) {\n                                    accFn = Metrics.binaryCrossentropy;\n                                }\n                            }\n                            else if (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                                }\n                                else if (['crossentropy', 'ce'].indexOf(metric) !== -1) {\n                                    accFn = Metrics.sparseCategoricalCrossentropy;\n                                }\n                            }\n                            else {\n                                // case: categorical accuracy / crossentropy.\n                                if (['accuracy', 'acc'].indexOf(metric) !== -1) {\n                                    accFn = Metrics.categoricalAccuracy;\n                                }\n                                else if (['crossentropy', 'ce'].indexOf(metric) !== -1) {\n                                    accFn = Metrics.categoricalCrossentropy;\n                                }\n                            }\n                            let suffix;\n                            if (['accuracy', 'acc'].indexOf(metric) !== -1) {\n                                suffix = 'acc';\n                            }\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                        }\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                        // TODO(cais): Add weighting and masking to metricResult.\n                        let metricResult;\n                        nameScope(metricName, () => {\n                            metricResult = weightedMetricFn;\n                        });\n                        appendMetric(i, metricName, metricResult);\n                    }\n                };\n                handleMetrics(outputMetrics);\n                // TODO(cais): Call handleMetrics with weights.\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     * 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    checkTrainableWeightsConsistency() {\n        if (this.collectedTrainableWeights == null) {\n            return;\n        }\n        if (this.trainableWeights.length !==\n            this.collectedTrainableWeights.length) {\n            console.warn('Discrepancy between trainableweights and collected trainable ' +\n                'weights. Did you set `model.trainable` without calling ' +\n                '`model.compile()` afterwards?');\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(x, y, args = {}) {\n        const batchSize = args.batchSize == null ? 32 : args.batchSize;\n        checkBatchSize(batchSize);\n        // TODO(cais): Standardize `config.sampleWeights` as well.\n        // Validate user data.\n        const checkBatchAxis = true;\n        const standardizedOuts = 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 = this.testLoop(f, ins, batchSize, args.verbose, args.steps);\n            return singletonOrArray(testOuts);\n        }\n        finally {\n            disposeNewTensors(standardizedOuts[0], x);\n            disposeNewTensors(standardizedOuts[1], y);\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, args) {\n        this.makeTestFunction();\n        return evaluateDataset(this, dataset, args);\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    checkNumSamples(ins, batchSize, steps, stepsName = 'steps') {\n        let numSamples;\n        if (steps != null) {\n            numSamples = null;\n            if (batchSize != null) {\n                throw new ValueError(`If ${stepsName} is set, batchSize must be null or undefined.` +\n                    `Got batchSize = ${batchSize}`);\n            }\n        }\n        else if (ins != null) {\n            if (Array.isArray(ins)) {\n                numSamples = ins[0].shape[0];\n            }\n            else {\n                numSamples = ins.shape[0];\n            }\n        }\n        else {\n            throw new ValueError(`Either the input data should have a defined shape, or ` +\n                `${stepsName} shoud be specified.`);\n        }\n        return numSamples;\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, outputs) {\n        if (Array.isArray(outputs) && outputs.length === 0) {\n            throw new ValueError('`outputs` is an empty Array, which is not allowed.');\n        }\n        const outputsIsArray = Array.isArray(outputs);\n        const outputNames = (outputsIsArray ? outputs : [outputs]);\n        const outputSymbolicTensors = this.retrieveSymbolicTensors(outputNames);\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(`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        }\n        else {\n            for (const input of this.inputs) {\n                const tensorValue = inputs[input.name];\n                if (tensorValue == null) {\n                    throw new ValueError(`No value is provided for the model's input ${input.name}`);\n                }\n                feedDict.add(input, tensorValue);\n            }\n        }\n        // Run execution.\n        const executeOutputs = execute(outputSymbolicTensors, feedDict);\n        return outputsIsArray ? executeOutputs : executeOutputs[0];\n    }\n    /**\n     * Retrieve the model's internal symbolic tensors from symbolic-tensor names.\n     */\n    retrieveSymbolicTensors(symbolicTensorNames) {\n        const outputSymbolicTensors = pyListRepeat(null, symbolicTensorNames.length);\n        let outputsRemaining = symbolicTensorNames.length;\n        for (const layer of this.layers) {\n            const layerOutputs = 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        if (outputsRemaining > 0) {\n            const remainingNames = [];\n            outputSymbolicTensors.forEach((tensor, i) => {\n                if (tensor == null) {\n                    remainingNames.push(symbolicTensorNames[i]);\n                }\n            });\n            throw new ValueError(`Cannot find SymbolicTensors for output name(s): ` +\n                `${JSON.stringify(remainingNames)}`);\n        }\n        return outputSymbolicTensors;\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    predictLoop(ins, batchSize = 32, verbose = false) {\n        return tfc.tidy(() => {\n            const numSamples = this.checkNumSamples(ins);\n            if (verbose) {\n                throw new NotImplementedError('Verbose predictLoop() is not implemented yet.');\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            const batches = makeBatches(numSamples, batchSize);\n            const outsBatches = this.outputs.map(output => []);\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                    // 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                    }\n                    else {\n                        feeds.push({ key: this.inputs[0], value: insBatch });\n                    }\n                    const feedDict = new FeedDict(feeds);\n                    return execute(this.outputs, feedDict);\n                });\n                batchOuts.forEach((batchOut, i) => outsBatches[i].push(batchOut));\n            }\n            return singletonOrArray(outsBatches.map(batches => tfc.concat(batches, 0)));\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, args = {}) {\n        const xsRank2OrHigher = ensureTensorsRank2OrHigher(x);\n        checkInputData(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        }\n        finally {\n            disposeNewTensors(xsRank2OrHigher, x);\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) {\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    standardizeUserDataXY(x, y, checkBatchAxis = true, batchSize) {\n        // TODO(cais): Add sampleWeight, classWeight\n        if (this.optimizer_ == null) {\n            throw new RuntimeError('You must compile a model before training/testing. Use ' +\n                'LayersModel.compile(modelCompileArgs).');\n        }\n        const outputShapes = [];\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(outputShape.slice(0, outputShape.length - 1).concat([1]));\n            }\n            else {\n                // Porting Note: Because of strong typing `lossFn` must be a function.\n                outputShapes.push(outputShape);\n            }\n        }\n        x = standardizeInputData(x, this.feedInputNames, this.feedInputShapes, false, 'input');\n        y = standardizeInputData(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(`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    async standardizeUserData(x, y, sampleWeight, classWeight, checkBatchAxis = true, batchSize) {\n        const [standardXs, standardYs] = 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        let standardSampleWeights = null;\n        if (classWeight != null) {\n            const classWeights = standardizeClassWeights(classWeight, this.outputNames);\n            standardSampleWeights = [];\n            for (let i = 0; i < classWeights.length; ++i) {\n                standardSampleWeights.push(await standardizeWeights(standardYs[i], null, classWeights[i]));\n            }\n        }\n        // TODO(cais): Deal with the case of model.stateful == true.\n        return [standardXs, standardYs, standardSampleWeights];\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    testLoop(f, ins, batchSize, verbose = 0, steps) {\n        return tfc.tidy(() => {\n            const numSamples = this.checkNumSamples(ins, batchSize, steps, 'steps');\n            const outs = [];\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('steps mode in testLoop() is not implemented yet');\n            }\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 = K.sliceAlongFirstAxis(indexArray, batchStart, batchEnd - batchStart);\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);\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    getDedupedMetricsNames() {\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     * 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    makeTrainFunction() {\n        return (data) => {\n            const lossValues = [];\n            const inputs = data.slice(0, this.inputs.length);\n            const targets = data.slice(this.inputs.length, this.inputs.length + this.outputs.length);\n            const sampleWeights = data.slice(this.inputs.length + this.outputs.length, this.inputs.length + this.outputs.length * 2);\n            const metricsValues = [];\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 = execute(this.outputs, feedDict, { 'training': true });\n                // TODO(cais): Take care of the case of multiple outputs from a\n                //   single layer?\n                let totalLoss;\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                    // TODO(cais): push Scalar instead.\n                    const meanLoss = 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                    }\n                    else {\n                        totalLoss = tfc.add(totalLoss, loss);\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;\n                    if (this.outputs.length > 1 && i < this.outputs.length) {\n                        weightedMetric = lossValues[i];\n                    }\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                    tfc.keep(weightedMetric);\n                    // TODO(cais): Use a scope() instead, to avoid ownership.\n                    metricsValues.push(weightedMetric);\n                }\n                totalLoss = tfc.mean(totalLoss);\n                // Add regularizer penalties.\n                this.calculateLosses().forEach(regularizerLoss => {\n                    totalLoss = tfc.add(totalLoss, regularizerLoss);\n                });\n                return totalLoss;\n            };\n            const variables = this.collectedTrainableWeights.map(param => param.read());\n            const returnCost = true;\n            const totalLossValue = this.optimizer_.minimize(totalLossFunction, returnCost, variables);\n            return [totalLossValue].concat(metricsValues);\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    makeTestFunction() {\n        this.testFunction = (data) => {\n            return tfc.tidy(() => {\n                const valOutputs = [];\n                let totalLoss;\n                const inputs = data.slice(0, this.inputs.length);\n                const targets = data.slice(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);\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 = tfc.mean(lossFunction(targets[i], outputs[i]));\n                    if (i === 0) {\n                        totalLoss = loss;\n                    }\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 = tfc.mean(metric(targets[outputIndex], outputs[outputIndex]));\n                    valOutputs.push(meanMetric);\n                }\n                return valOutputs;\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(x, y, args = {}) {\n        if (this.isTraining) {\n            throw new Error('Cannot start training because another fit() call is ongoing.');\n        }\n        this.isTraining = true;\n        let inputs;\n        let targets;\n        let originalInputs;\n        let originalTargets;\n        let inputValX;\n        let inputValY;\n        let valX;\n        let valY;\n        let sampleWeights;\n        try {\n            const batchSize = args.batchSize == null ? 32 : args.batchSize;\n            checkBatchSize(batchSize);\n            // Validate user data.\n            // TODO(cais): Support sampleWeight.\n            const checkBatchAxis = false;\n            const standardizedOuts = await this.standardizeUserData(x, y, args.sampleWeight, args.classWeight, checkBatchAxis, batchSize);\n            inputs = standardizedOuts[0];\n            targets = standardizedOuts[1];\n            sampleWeights = standardizedOuts[2];\n            // Prepare validation data.\n            let doValidation = false;\n            let valIns;\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                }\n                else if (args.validationData.length === 3) {\n                    throw new NotImplementedError('validationData including sample weights is not supported yet.');\n                }\n                else {\n                    throw new ValueError(`When passing validation data, it must contain 2 (valX, valY) ` +\n                        `or 3 (valX, valY, valSampleWeight) items; ` +\n                        `${args.validationData} is invalid.`);\n                }\n                const checkBatchAxis = true;\n                const valStandardized = await this.standardizeUserData(inputValX, inputValY, null, /** Unused sample weights. */ null, /** Unused class weights. */ checkBatchAxis, batchSize);\n                valX = valStandardized[0];\n                valY = valStandardized[1];\n                valIns = valX.concat(valY);\n                // TODO(cais): Add useLearningPhase data properly.\n            }\n            else if (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 = Math.floor(inputs[0].shape[0] * (1 - args.validationSplit));\n                const originalBatchSize = inputs[0].shape[0];\n                valX = sliceArrays(inputs, splitAt, originalBatchSize);\n                originalInputs = inputs;\n                inputs = sliceArrays(inputs, 0, splitAt);\n                valY = sliceArrays(targets, splitAt, originalBatchSize);\n                originalTargets = targets;\n                targets = sliceArrays(targets, 0, splitAt);\n                // TODO(cais): Once sampleWeights becomes available, slice it to get\n                //   valSampleWeights.\n                valIns = valX.concat(valY);\n                // TODO(cais): Add useLearningPhase data properly.\n            }\n            else if (args.validationSteps != null) {\n                doValidation = true;\n                // TODO(cais): Add useLearningPhase.\n            }\n            const ins = inputs.concat(targets).concat(sampleWeights);\n            this.checkTrainableWeightsConsistency();\n            // TODO(cais): Handle use_learning_phase and learning_phase?\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            let valFunction;\n            let callbackMetrics;\n            if (doValidation) {\n                this.makeTestFunction();\n                valFunction = this.testFunction;\n                callbackMetrics =\n                    outLabels.slice().concat(outLabels.map(n => 'val_' + n));\n            }\n            else {\n                valFunction = null;\n                valIns = [];\n                callbackMetrics = outLabels.slice();\n            }\n            const callbacks = standardizeCallbacks(args.callbacks, args.yieldEvery);\n            const out = await this.fitLoop(trainFunction, ins, outLabels, batchSize, args.epochs, args.verbose, callbacks, valFunction, valIns, args.shuffle, callbackMetrics, args.initialEpoch, null, null);\n            return out;\n        }\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, inputValX);\n            disposeNewTensors(valY, inputValY);\n            if (sampleWeights != null) {\n                tfc.dispose(sampleWeights);\n            }\n        }\n        // TODO(cais): Add value to outLabels.\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(f, ins, outLabels, batchSize, epochs, verbose, callbacks, valF, valIns, shuffle, callbackMetrics, initialEpoch, stepsPerEpoch, validationSteps) {\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        // 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('Can only use `validationSteps` when doing step-wise training, ' +\n                    'i.e., `stepsPerEpoch` must be set.');\n            }\n        }\n        const numTrainSamples = this.checkNumSamples(ins, batchSize, stepsPerEpoch, 'steps_per_epoch');\n        let indexArray;\n        if (numTrainSamples != null) {\n            indexArray = range(0, numTrainSamples);\n        }\n        if (verbose == null) {\n            verbose = 1;\n        }\n        const { callbackList, history } = configureCallbacks(callbacks, verbose, epochs, initialEpoch, numTrainSamples, 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        for (let epoch = initialEpoch; epoch < epochs; ++epoch) {\n            await callbackList.onEpochBegin(epoch);\n            const epochLogs = {};\n            if (stepsPerEpoch != null) {\n                throw new NotImplementedError('stepsPerEpoch mode is not implemented yet.');\n            }\n            else {\n                if (shuffle === 'batch') {\n                    throw new NotImplementedError('batch shuffling is not implemneted'\n                        + ' yet');\n                }\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                const batches = makeBatches(numTrainSamples, batchSize);\n                for (let batchIndex = 0; batchIndex < batches.length; ++batchIndex) {\n                    const batchLogs = {};\n                    await callbackList.onBatchBegin(batchIndex, batchLogs);\n                    tfc.tidy(() => {\n                        const batchStart = batches[batchIndex][0];\n                        const batchEnd = batches[batchIndex][1];\n                        const batchIds = K.sliceAlongFirstAxis(epochIndexArray1D, batchStart, batchEnd - batchStart);\n                        batchLogs['batch'] = batchIndex;\n                        batchLogs['size'] = batchEnd - batchStart;\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);\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                        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                    await callbackList.onBatchEnd(batchIndex, batchLogs);\n                    disposeTensorsInLogs(batchLogs);\n                    if (this.stopTraining_) {\n                        break;\n                    }\n                    // TODO(cais): return outs as list of Tensor.\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        await this.history.syncData();\n        return this.history;\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(dataset, args) {\n        return fitDataset(this, dataset, args);\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(x, y) {\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 = [];\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     * 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    getNamedWeights(config) {\n        const namedWeights = [];\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({ name: weights[i].originalName, tensor: weightValues[i] });\n        }\n        return namedWeights;\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) {\n        this.stopTraining_ = stop;\n    }\n    get stopTraining() {\n        return this.stopTraining_;\n    }\n    get optimizer() {\n        return this.optimizer_;\n    }\n    set optimizer(optimizer) {\n        if (this.optimizer_ !== optimizer) {\n            this.optimizer_ = optimizer;\n            this.isOptimizerOwned = false;\n        }\n    }\n    dispose() {\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    getLossIdentifiers() {\n        let lossNames;\n        if (typeof this.loss === 'string') {\n            lossNames = toSnakeCase(this.loss);\n        }\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.map(name => toSnakeCase(name));\n        }\n        else {\n            const outputNames = Object.keys(this.loss);\n            lossNames = {};\n            const losses = this.loss;\n            for (const outputName of outputNames) {\n                if (typeof losses[outputName] === 'string') {\n                    lossNames[outputName] =\n                        toSnakeCase(losses[outputName]);\n                }\n                else {\n                    throw new Error('Serialization of non-string loss is not supported.');\n                }\n            }\n        }\n        return lossNames;\n    }\n    getMetricIdentifiers() {\n        if (typeof this.metrics === 'string' ||\n            typeof this.metrics === 'function') {\n            return [toSnakeCase(Metrics.getLossOrMetricName(this.metrics))];\n        }\n        else if (Array.isArray(this.metrics)) {\n            return this.metrics.map(metric => toSnakeCase(Metrics.getLossOrMetricName(metric)));\n        }\n        else {\n            const metricsIdentifiers = {};\n            for (const key in this.metrics) {\n                metricsIdentifiers[key] =\n                    toSnakeCase(Metrics.getLossOrMetricName(this.metrics[key]));\n            }\n            return metricsIdentifiers;\n        }\n    }\n    getTrainingConfig() {\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            }\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    loadTrainingConfig(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        const tsConfig = convertPythonicToTs(trainingConfig.optimizer_config);\n        const optimizer = deserialize(tsConfig);\n        let loss;\n        if (typeof trainingConfig.loss === 'string') {\n            loss = toCamelCase(trainingConfig.loss);\n        }\n        else if (Array.isArray(trainingConfig.loss)) {\n            loss = trainingConfig.loss.map(lossEntry => toCamelCase(lossEntry));\n        }\n        else if (trainingConfig.loss != null) {\n            loss = {};\n            for (const key in trainingConfig.loss) {\n                loss[key] = toCamelCase(trainingConfig.loss[key]);\n            }\n        }\n        let metrics;\n        if (Array.isArray(trainingConfig.metrics)) {\n            metrics = trainingConfig.metrics.map(metric => toCamelCase(metric));\n        }\n        else if (trainingConfig.metrics != null) {\n            metrics = {};\n            for (const key in trainingConfig.metrics) {\n                metrics[key] = toCamelCase(trainingConfig.metrics[key]);\n            }\n        }\n        this.compile({ loss, metrics, optimizer });\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, config) {\n        if (typeof handlerOrURL === 'string') {\n            const handlers = io.getSaveHandlers(handlerOrURL);\n            if (handlers.length === 0) {\n                throw new ValueError(`Cannot find any save handlers for URL '${handlerOrURL}'`);\n            }\n            else if (handlers.length > 1) {\n                throw new ValueError(`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('LayersModel.save() cannot proceed because the IOHandler ' +\n                'provided does not have the `save` attribute defined.');\n        }\n        const weightDataAndSpecs = await io.encodeWeights(this.getNamedWeights(config));\n        const returnString = false;\n        const unusedArg = null;\n        const modelConfig = this.toJSON(unusedArg, returnString);\n        const modelArtifacts = {\n            modelTopology: modelConfig,\n            format: LAYERS_MODEL_FORMAT_NAME,\n            generatedBy: `TensorFlow.js tfjs-layers v${version}`,\n            convertedBy: null,\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 } = await io.encodeWeights(await this.optimizer.getWeights(), weightType);\n            weightDataAndSpecs.specs.push(...optimizerWeightSpecs);\n            weightDataAndSpecs.data = io.concatenateArrayBuffers([weightDataAndSpecs.data, optimizerWeightData]);\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        modelArtifacts.weightData = weightDataAndSpecs.data;\n        modelArtifacts.weightSpecs = weightDataAndSpecs.specs;\n        return handlerOrURL.save(modelArtifacts);\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) {\n        checkUserDefinedMetadata(userDefinedMetadata, this.name);\n        this.userDefinedMetadata = userDefinedMetadata;\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}\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 */\nLayersModel.className = 'Model';\nexport { LayersModel };\nserialization.registerClass(LayersModel);\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'} */\nclass Functional extends LayersModel {\n}\nFunctional.className = 'Functional';\nexport { Functional };\nserialization.registerClass(Functional);\n//# 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"]}"],"names":["isDataTensor","x","Tensor","isDataArray","isDataDict","standardizeInputData","data","names","shapes","checkBatchAxis","exceptionPrefix","gotUnexpectedData","key","ValueError","name","arrays","ensureTensorsRank2OrHigher","i","array","j","dim","refDim","checkArrayLengths","inputs","targets","weights","setX","unique","input","setY","target","util.arraysEqual","checkLossAndTargetCompatibility","lossFns","outputShapes","keyLosses","losses.meanSquaredError","losses.binaryCrossentropy","losses.categoricalCrossentropy","y","loss","shape","slicedYShape","slicedShape","targetDim","outDim","checkInputData","collectMetrics","metrics","outputNames","wrappedMetrics","nestedMetrics","outputMetrics","LAYERS_MODEL_FORMAT_NAME","LayersModel","Container","args","lineLength","positions","printFn","printSummary","optimizers.getOptimizer","Optimizer","lossFunctions","losses.get","l","lossFunction","_","skipTargetIndices","nameScope","weightedLoss","appendMetric","outputIndex","metricName","metricTensor","metricNamePrefix","accFn","weightedMetricFn","metric","outputShape","Metrics.binaryAccuracy","Metrics.binaryCrossentropy","losses.sparseCategoricalCrossentropy","Metrics.sparseCategoricalAccuracy","Metrics.sparseCategoricalCrossentropy","Metrics.categoricalAccuracy","Metrics.categoricalCrossentropy","suffix","Metrics.get","Metrics.getLossOrMetricName","metricResult","batchSize","checkBatchSize","standardizedOuts","ins","f","testOuts","singletonOrArray","disposeNewTensors","dataset","evaluateDataset","steps","stepsName","numSamples","outputs","outputsIsArray","outputSymbolicTensors","feedDict","FeedDict","tensorValue","executeOutputs","execute","symbolicTensorNames","pyListRepeat","outputsRemaining","layer","layerOutputs","layerOutputNames","output","index","remainingNames","tensor","verbose","tfc.tidy","NotImplementedError","batches","makeBatches","outsBatches","batchIndex","batchStart","batchEnd","insBatch","sliceArrays","feeds","batchOut","tfc.concat","xsRank2OrHigher","RuntimeError","sampleWeight","classWeight","standardXs","standardYs","standardSampleWeights","classWeights","standardizeClassWeights","standardizeWeights","outs","indexArray","tensor1d","range","batchIds","K.sliceAlongFirstAxis","sliceArraysByIndices","batchOuts","scalar","tfc.add","tfc.mul","tfc.div","outLabels","dedupedOutLabels","label","newLabel","count","dupIndex","lossValues","sampleWeights","metricsValues","totalLossFunction","totalLoss","computeWeightedLoss","meanLoss","tfc.mean","weightedMetric","tfc.keep","regularizerLoss","variables","param","valOutputs","meanMetric","originalInputs","originalTargets","inputValX","inputValY","valX","valY","doValidation","valIns","valStandardized","splitAt","originalBatchSize","trainFunction","valFunction","callbackMetrics","n","callbacks","standardizeCallbacks","tfc.dispose","epochs","valF","shuffle","initialEpoch","stepsPerEpoch","validationSteps","numTrainSamples","callbackList","history","configureCallbacks","epoch","epochLogs","util.shuffle","epochIndexArray1D","batchLogs","out","valOuts","disposeTensorsInLogs","fitDataset","standardizeOut","losses","v","config","namedWeights","trainableOnly","weightValues","stop","optimizer","result","numTensorsBeforeOptmizerDisposal","tfc.memory","lossNames","toSnakeCase","outputName","metricsIdentifiers","trainingConfig","tsConfig","convertPythonicToTs","deserialize","toCamelCase","lossEntry","handlerOrURL","handlers","io.getSaveHandlers","weightDataAndSpecs","io.encodeWeights","modelArtifacts","version","weightType","optimizerWeightData","optimizerWeightSpecs","io.concatenateArrayBuffers","checkUserDefinedMetadata","userDefinedMetadata","serialization.registerClass","Functional"],"mappings":"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","x_google_ignoreList":[0]}