/**

* @license

* Copyright 2018 Google LLC

*

* Use of this source code is governed by an MIT-style

* license that can be found in the LICENSE file or at

* https://opensource.org/licenses/MIT.

* =============================================================================

*/

/* Original source keras/models.py */

import {dispose, io, NamedTensorMap, Scalar, serialization, Tensor, util} from '@tensorflow/tfjs-core';

import {getUid} from './backend/state';

import {History} from './base_callbacks';

import {Dataset} from './engine/dataset_stub';

import {Input} from './engine/input_layer';

import {getSourceInputs, Layer, Node, SymbolicTensor} from './engine/topology';

import {LayersModel, ModelCompileArgs, ModelEvaluateArgs} from './engine/training';

import {ModelEvaluateDatasetArgs, ModelFitDatasetArgs} from './engine/training_dataset';

import {ModelFitArgs} from './engine/training_tensors';

import {NotImplementedError, RuntimeError, ValueError} from './errors';

import {Shape} from './keras_format/common';

import {PyJsonDict} from './keras_format/types';

import {deserialize} from './layers/serialization';

import {Kwargs} from './types';

import * as generic_utils from './utils/generic_utils';

import {convertPythonicToTs} from './utils/serialization_utils';

import {getExactlyOneShape} from './utils/types_utils';

/**

* Parses a JSON model configuration file and returns a model instance.

*

* ```js

* // This example shows how to serialize a model using `toJSON()` and

* // deserialize it as another model using `tf.models.modelFromJSON()`.

* // Note: this example serializes and deserializes only the topology

* // of the model; the weights of the loaded model will be different

* // from those of the the original model, due to random weight

* // initialization.

* // To load the topology and weights of a model, use `tf.loadLayersModel()`.

* const model1 = tf.sequential();

* model1.add(tf.layers.repeatVector({inputShape: [2], n: 4}));

* // Serialize `model1` as a JSON object.

* const model1JSON = model1.toJSON(null, false);

* model1.summary();

*

* const model2 = await tf.models.modelFromJSON(model1JSON);

* model2.summary();

* ```

*

* @param modelAndWeightsConfig JSON object or string encoding a model and

* weights configuration. It can also be only the topology JSON of the

* model, in which case the weights will not be loaded.

* @param custom_objects Optional dictionary mapping names

* (strings) to custom classes or functions to be

* considered during deserialization.

* @returns A TensorFlow.js Layers `tf.LayersModel` instance (uncompiled).

*/

export async function modelFromJSON(

}

/**

* Options for loading a saved mode in TensorFlow.js format.

*/

export interface ModelAndWeightsConfig {

}

// TODO(nielsene): Remove after: https://github.com/tensorflow/tfjs/issues/400

export interface ModelPredictArgs {

}

/**

* Load a model, including its topology and optionally weights. See the

* Tutorial named "How to import a Keras Model" for usage examples.

*

* Example 1: Save `model`'s topology and weights to browser [local

* storage](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage);

* then load it back.

*

* ```js

* const model = tf.sequential(

* {layers: [tf.layers.dense({units: 1, inputShape: [3]})]});

* console.log('Prediction from original model:');

* model.predict(tf.ones([1, 3])).print();

*

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

*

* const loadedModel = await tf.loadLayersModel('localstorage://my-model-1');

* console.log('Prediction from loaded model:');

* loadedModel.predict(tf.ones([1, 3])).print();

* ```

*

* Example 2. Saving `model`'s topology and weights to browser

* [IndexedDB](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API);

* then load it back.

*

* ```js

* const model = tf.sequential(

* {layers: [tf.layers.dense({units: 1, inputShape: [3]})]});

* console.log('Prediction from original model:');

* model.predict(tf.ones([1, 3])).print();

*

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

*

* const loadedModel = await tf.loadLayersModel('indexeddb://my-model-1');

* console.log('Prediction from loaded model:');

* loadedModel.predict(tf.ones([1, 3])).print();

* ```

*

* Example 3. Load a model from user-selected files from HTML

* [file input

* elements](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/file).

*

* ```js

* // Note: this code snippet will not work without the HTML elements in the

* // page

* const jsonUpload = document.getElementById('json-upload');

* const weightsUpload = document.getElementById('weights-upload');

*

* const model = await tf.loadLayersModel(

* tf.io.browserFiles([jsonUpload.files[0], weightsUpload.files[0]]));

* ```

*

* Example 4. Load a model from an HTTP server.

*

* ```js

* const model = await

* tf.loadLayersModel('https://storage.googleapis.com/tfjs-models/tfjs/iris_v1/model.json');

* model.summary();

* ```

*

* @param pathOrIOHandler Can be either of the two formats

* 1. A string path to the `ModelAndWeightsConfig` JSON describing

* the model in the canonical TensorFlow.js format. This path will be

* interpreted as a relative HTTP path, to which `fetch` will be used to

* request the model topology and weight manifest JSON.

* The content of the JSON file is assumed to be a JSON object with the

* following fields and values:

* - 'modelTopology': A JSON object that can be either of:

* 1. a model architecture JSON consistent with the format of the return

* value of `keras.Model.to_json()`

* 2. a full model JSON in the format of `keras.models.save_model()`.

* - 'weightsManifest': A TensorFlow.js weights manifest.

* See the Python converter function `save_model()` for more details.

* It is also assumed that model weights can be accessed from relative

* paths described by the `paths` fields in weights manifest.

* 2. An `tf.io.IOHandler` object that loads model artifacts with its `load`

* method.

* @param options Optional configuration arguments for the model loading,

* including:

* - `strict`: Require that the provided weights exactly match those required

* by the layers. Default true. Passing false means that both extra

* weights and missing weights will be silently ignored.

* - `onProgress`: A progress callback of the form:

* `(fraction: number) => void`. This callback can be used to monitor the

* model-loading process.

* @returns A `Promise` of `tf.LayersModel`, with the topology and weights

* loaded.

*/

export async function loadLayersModelInternal(

}

/**

* Load a model and optionally its weights, using an IOHandler object.

*

* @param handler The instance of `IOHandler` to be used during the model

* loading.

* @param customObjects Any optional custom objects to be used during model

* loading.

* @param strict Whether the weight loading will be done in strict mode.

* Default: `true`.

*/

export async function loadLayersModelFromIOHandler(

}

/**

* Configuration for a Sequential model.

*/

export interface SequentialArgs {

}

/**

* A model with a stack of layers, feeding linearly from one to the next.

*

* `tf.sequential` is a factory function that creates an instance of

* `tf.Sequential`.

*

* ```js

* // Define a model for linear regression.

* const model = tf.sequential();

* model.add(tf.layers.dense({units: 1, inputShape: [1]}));

*

* // Prepare the model for training: Specify the loss and the optimizer.

* model.compile({loss: 'meanSquaredError', optimizer: 'sgd'});

*

* // Generate some synthetic data for training.

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

* const ys = tf.tensor2d([1, 3, 5, 7], [4, 1]);

*

* // Train the model using the data then do inference on a data point the

* // model hasn't seen:

* await model.fit(xs, ys);

* model.predict(tf.tensor2d([5], [1, 1])).print();

* ```

*/

/** @doc {heading: 'Models', subheading: 'Classes'} */

export class Sequential extends LayersModel {