/**
|
* @license
|
* Copyright 2018 Google LLC. All Rights Reserved.
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
* =============================================================================
|
*/
|
import { dispose, io, Tensor, util } from '@tensorflow/tfjs-core';
|
import { OperationMapper } from '../operations/operation_mapper';
|
import { GraphExecutor } from './graph_executor';
|
import { ResourceManager } from './resource_manager';
|
// tslint:disable-next-line: no-imports-from-dist
|
import { decodeWeightsStream } from '@tensorflow/tfjs-core/dist/io/io_utils';
|
export const TFHUB_SEARCH_PARAM = '?tfjs-format=file';
|
export const DEFAULT_MODEL_NAME = 'model.json';
|
/**
|
* A `tf.GraphModel` is a directed, acyclic graph built from a
|
* SavedModel GraphDef and allows inference execution.
|
*
|
* A `tf.GraphModel` can only be created by loading from a model converted from
|
* a [TensorFlow SavedModel](https://www.tensorflow.org/guide/saved_model) using
|
* the command line converter tool and loaded via `tf.loadGraphModel`.
|
*
|
* @doc {heading: 'Models', subheading: 'Classes'}
|
*/
|
export class GraphModel {
|
// Returns the version information for the tensorflow model GraphDef.
|
get modelVersion() {
|
return this.version;
|
}
|
get inputNodes() {
|
return this.executor.inputNodes;
|
}
|
get outputNodes() {
|
return this.executor.outputNodes;
|
}
|
get inputs() {
|
return this.executor.inputs;
|
}
|
get outputs() {
|
return this.executor.outputs;
|
}
|
get weights() {
|
return this.executor.weightMap;
|
}
|
get metadata() {
|
return this.artifacts.userDefinedMetadata;
|
}
|
get modelSignature() {
|
return this.signature;
|
}
|
get modelStructuredOutputKeys() {
|
return this.structuredOutputKeys;
|
}
|
/**
|
* @param modelUrl url for the model, or an `io.IOHandler`.
|
* @param weightManifestUrl url for the weight file generated by
|
* scripts/convert.py script.
|
* @param requestOption options for Request, which allows to send credentials
|
* and custom headers.
|
* @param onProgress Optional, progress callback function, fired periodically
|
* before the load is completed.
|
*/
|
constructor(modelUrl, loadOptions = {}, tfio = io) {
|
this.modelUrl = modelUrl;
|
this.loadOptions = loadOptions;
|
this.version = 'n/a';
|
this.io = tfio;
|
if (loadOptions == null) {
|
this.loadOptions = {};
|
}
|
this.resourceManager = new ResourceManager();
|
}
|
findIOHandler() {
|
const path = this.modelUrl;
|
if (path.load != null) {
|
// Path is an IO Handler.
|
this.handler = path;
|
}
|
else if (this.loadOptions.requestInit != null) {
|
this.handler = this.io.browserHTTPRequest(path, this.loadOptions);
|
}
|
else {
|
const handlers = this.io.getLoadHandlers(path, this.loadOptions);
|
if (handlers.length === 0) {
|
// For backward compatibility: if no load handler can be found,
|
// assume it is a relative http path.
|
handlers.push(this.io.browserHTTPRequest(path, this.loadOptions));
|
}
|
else if (handlers.length > 1) {
|
throw new Error(`Found more than one (${handlers.length}) load handlers for ` +
|
`URL '${[path]}'`);
|
}
|
this.handler = handlers[0];
|
}
|
}
|
/**
|
* Loads the model and weight files, construct the in memory weight map and
|
* compile the inference graph.
|
*/
|
load() {
|
this.findIOHandler();
|
if (this.handler.load == null) {
|
throw new Error('Cannot proceed with model loading because the IOHandler provided ' +
|
'does not have the `load` method implemented.');
|
}
|
const loadResult = this.handler.load();
|
if (util.isPromise(loadResult)) {
|
return loadResult.then(artifacts => {
|
if (artifacts.getWeightStream == null) {
|
return this.loadSync(artifacts);
|
}
|
return this.loadStreaming(artifacts);
|
});
|
}
|
return this.loadSync(loadResult);
|
}
|
/**
|
* Synchronously construct the in memory weight map and
|
* compile the inference graph.
|
*
|
* @doc {heading: 'Models', subheading: 'Classes', ignoreCI: true}
|
*/
|
loadSync(artifacts) {
|
const weightMap = this.io.decodeWeights(artifacts.weightData, artifacts.weightSpecs);
|
return this.loadWithWeightMap(artifacts, weightMap);
|
}
|
async loadStreaming(artifacts) {
|
if (artifacts.getWeightStream == null) {
|
throw new Error('Model artifacts missing streamWeights function');
|
}
|
const weightMap = await decodeWeightsStream(artifacts.getWeightStream(), artifacts.weightSpecs);
|
return this.loadWithWeightMap(artifacts, weightMap);
|
}
|
loadWithWeightMap(artifacts, weightMap) {
|
this.artifacts = artifacts;
|
const graph = this.artifacts.modelTopology;
|
let signature = this.artifacts.signature;
|
if (this.artifacts.userDefinedMetadata != null) {
|
const metadata = this.artifacts.userDefinedMetadata;
|
if (metadata.signature != null) {
|
signature = metadata.signature;
|
}
|
if (metadata.structuredOutputKeys != null) {
|
this.structuredOutputKeys = metadata.structuredOutputKeys;
|
}
|
}
|
this.signature = signature;
|
this.version = `${graph.versions.producer}.${graph.versions.minConsumer}`;
|
this.executor = new GraphExecutor(OperationMapper.Instance.transformGraph(graph, this.signature));
|
this.executor.weightMap = this.convertTensorMapToTensorsMap(weightMap);
|
// Attach a model-level resourceManager to each executor to share resources,
|
// such as `HashTable`.
|
this.executor.resourceManager = this.resourceManager;
|
if (artifacts.modelInitializer != null &&
|
artifacts.modelInitializer.node != null) {
|
const initializer = OperationMapper.Instance.transformGraph(artifacts.modelInitializer);
|
this.initializer = new GraphExecutor(initializer);
|
this.initializer.weightMap = this.executor.weightMap;
|
// Attach a model-level resourceManager to the initializer, the
|
// hashTables created from when executing the initializer will be stored
|
// in the resourceManager.
|
this.initializer.resourceManager = this.resourceManager;
|
this.initializerSignature = artifacts.initializerSignature;
|
}
|
return true;
|
}
|
/**
|
* Save the configuration and/or weights of the GraphModel.
|
*
|
* An `IOHandler` is an object that has a `save` method of the proper
|
* signature defined. The `save` method manages the storing or
|
* transmission of serialized data ("artifacts") that represent the
|
* model's topology and weights onto or via a specific medium, such as
|
* file downloads, local storage, IndexedDB in the web browser and HTTP
|
* requests to a server. TensorFlow.js provides `IOHandler`
|
* implementations for a number of frequently used saving mediums, such as
|
* `tf.io.browserDownloads` and `tf.io.browserLocalStorage`. See `tf.io`
|
* for more details.
|
*
|
* This method also allows you to refer to certain types of `IOHandler`s
|
* as URL-like string shortcuts, such as 'localstorage://' and
|
* 'indexeddb://'.
|
*
|
* Example 1: Save `model`'s topology and weights to browser [local
|
* storage](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage);
|
* then load it back.
|
*
|
* ```js
|
* const modelUrl =
|
* 'https://storage.googleapis.com/tfjs-models/savedmodel/mobilenet_v2_1.0_224/model.json';
|
* const model = await tf.loadGraphModel(modelUrl);
|
* const zeros = tf.zeros([1, 224, 224, 3]);
|
* model.predict(zeros).print();
|
*
|
* const saveResults = await model.save('localstorage://my-model-1');
|
*
|
* const loadedModel = await tf.loadGraphModel('localstorage://my-model-1');
|
* console.log('Prediction from loaded model:');
|
* model.predict(zeros).print();
|
* ```
|
*
|
* @param handlerOrURL An instance of `IOHandler` or a URL-like,
|
* scheme-based string shortcut for `IOHandler`.
|
* @param config Options for saving the model.
|
* @returns A `Promise` of `SaveResult`, which summarizes the result of
|
* the saving, such as byte sizes of the saved artifacts for the model's
|
* topology and weight values.
|
*
|
* @doc {heading: 'Models', subheading: 'Classes', ignoreCI: true}
|
*/
|
async save(handlerOrURL, config) {
|
if (typeof handlerOrURL === 'string') {
|
const handlers = this.io.getSaveHandlers(handlerOrURL);
|
if (handlers.length === 0) {
|
throw new Error(`Cannot find any save handlers for URL '${handlerOrURL}'`);
|
}
|
else if (handlers.length > 1) {
|
throw new Error(`Found more than one (${handlers.length}) save handlers for ` +
|
`URL '${handlerOrURL}'`);
|
}
|
handlerOrURL = handlers[0];
|
}
|
if (handlerOrURL.save == null) {
|
throw new Error('GraphModel.save() cannot proceed because the IOHandler ' +
|
'provided does not have the `save` attribute defined.');
|
}
|
return handlerOrURL.save(this.artifacts);
|
}
|
addStructuredOutputNames(outputTensors) {
|
if (this.structuredOutputKeys) {
|
const outputTensorsArray = outputTensors instanceof Tensor ? [outputTensors] : outputTensors;
|
const outputTensorMap = {};
|
outputTensorsArray.forEach((outputTensor, i) => outputTensorMap[this.structuredOutputKeys[i]] =
|
outputTensor);
|
return outputTensorMap;
|
}
|
return outputTensors;
|
}
|
/**
|
* Execute the inference for the input tensors.
|
*
|
* @param input The input tensors, when there is single input for the model,
|
* inputs param should be a `tf.Tensor`. For models with mutliple inputs,
|
* inputs params should be in either `tf.Tensor`[] if the input order is
|
* fixed, or otherwise NamedTensorMap format.
|
*
|
* For model with multiple inputs, we recommend you use NamedTensorMap as the
|
* input type, if you use `tf.Tensor`[], the order of the array needs to
|
* follow the
|
* order of inputNodes array. @see {@link GraphModel.inputNodes}
|
*
|
* You can also feed any intermediate nodes using the NamedTensorMap as the
|
* input type. For example, given the graph
|
* InputNode => Intermediate => OutputNode,
|
* you can execute the subgraph Intermediate => OutputNode by calling
|
* model.execute('IntermediateNode' : tf.tensor(...));
|
*
|
* This is useful for models that uses tf.dynamic_rnn, where the intermediate
|
* state needs to be fed manually.
|
*
|
* For batch inference execution, the tensors for each input need to be
|
* concatenated together. For example with mobilenet, the required input shape
|
* is [1, 244, 244, 3], which represents the [batch, height, width, channel].
|
* If we are provide a batched data of 100 images, the input tensor should be
|
* in the shape of [100, 244, 244, 3].
|
*
|
* @param config Prediction configuration for specifying the batch size.
|
* Currently the batch size option is ignored for graph model.
|
*
|
* @returns Inference result tensors. If the model is converted and it
|
* originally had structured_outputs in tensorflow, then a NamedTensorMap
|
* will be returned matching the structured_outputs. If no structured_outputs
|
* are present, the output will be single `tf.Tensor` if the model has single
|
* output node, otherwise Tensor[].
|
*
|
* @doc {heading: 'Models', subheading: 'Classes'}
|
*/
|
predict(inputs, config) {
|
const outputTensors = this.execute(inputs, this.outputNodes);
|
return this.addStructuredOutputNames(outputTensors);
|
}
|
/**
|
* Execute the inference for the input tensors in async fashion, use this
|
* method when your model contains control flow ops.
|
*
|
* @param input The input tensors, when there is single input for the model,
|
* inputs param should be a `tf.Tensor`. For models with mutliple inputs,
|
* inputs params should be in either `tf.Tensor`[] if the input order is
|
* fixed, or otherwise NamedTensorMap format.
|
*
|
* For model with multiple inputs, we recommend you use NamedTensorMap as the
|
* input type, if you use `tf.Tensor`[], the order of the array needs to
|
* follow the
|
* order of inputNodes array. @see {@link GraphModel.inputNodes}
|
*
|
* You can also feed any intermediate nodes using the NamedTensorMap as the
|
* input type. For example, given the graph
|
* InputNode => Intermediate => OutputNode,
|
* you can execute the subgraph Intermediate => OutputNode by calling
|
* model.execute('IntermediateNode' : tf.tensor(...));
|
*
|
* This is useful for models that uses tf.dynamic_rnn, where the intermediate
|
* state needs to be fed manually.
|
*
|
* For batch inference execution, the tensors for each input need to be
|
* concatenated together. For example with mobilenet, the required input shape
|
* is [1, 244, 244, 3], which represents the [batch, height, width, channel].
|
* If we are provide a batched data of 100 images, the input tensor should be
|
* in the shape of [100, 244, 244, 3].
|
*
|
* @param config Prediction configuration for specifying the batch size.
|
* Currently the batch size option is ignored for graph model.
|
*
|
* @returns A Promise of inference result tensors. If the model is converted
|
* and it originally had structured_outputs in tensorflow, then a
|
* NamedTensorMap will be returned matching the structured_outputs. If no
|
* structured_outputs are present, the output will be single `tf.Tensor` if
|
* the model has single output node, otherwise Tensor[].
|
*
|
* @doc {heading: 'Models', subheading: 'Classes'}
|
*/
|
async predictAsync(inputs, config) {
|
const outputTensors = await this.executeAsync(inputs, this.outputNodes);
|
return this.addStructuredOutputNames(outputTensors);
|
}
|
normalizeInputs(inputs) {
|
var _a;
|
if (!(inputs instanceof Tensor) && !Array.isArray(inputs)) {
|
// The input is already a NamedTensorMap.
|
const signatureInputs = (_a = this.signature) === null || _a === void 0 ? void 0 : _a.inputs;
|
if (signatureInputs != null) {
|
for (const input in signatureInputs) {
|
const tensor = signatureInputs[input];
|
if (tensor.resourceId != null) {
|
inputs[input] = this.resourceIdToCapturedInput[tensor.resourceId];
|
}
|
}
|
}
|
return inputs;
|
}
|
inputs = Array.isArray(inputs) ? inputs : [inputs];
|
const numCapturedInputs = Object.keys(this.resourceIdToCapturedInput).length;
|
if (inputs.length + numCapturedInputs !== this.inputNodes.length) {
|
throw new Error(`Input tensor count mismatch, the graph model has ${this.inputNodes.length -
|
numCapturedInputs} non-resource placeholders, while there are ${inputs.length} input tensors provided.`);
|
}
|
let inputIndex = 0;
|
return this.inputNodes.reduce((map, inputName) => {
|
var _a, _b, _c;
|
const resourceId = (_c = (_b = (_a = this.signature) === null || _a === void 0 ? void 0 : _a.inputs) === null || _b === void 0 ? void 0 : _b[inputName]) === null || _c === void 0 ? void 0 : _c.resourceId;
|
if (resourceId != null) {
|
map[inputName] = this.resourceIdToCapturedInput[resourceId];
|
}
|
else {
|
map[inputName] = inputs[inputIndex++];
|
}
|
return map;
|
}, {});
|
}
|
normalizeOutputs(outputs) {
|
outputs = outputs || this.outputNodes;
|
return !Array.isArray(outputs) ? [outputs] : outputs;
|
}
|
executeInitializerGraph() {
|
if (this.initializer == null) {
|
return [];
|
}
|
if (this.initializerSignature == null) {
|
return this.initializer.execute({}, []);
|
}
|
else {
|
return this.initializer.execute({}, Object.keys(this.initializerSignature.outputs));
|
}
|
}
|
async executeInitializerGraphAsync() {
|
if (this.initializer == null) {
|
return [];
|
}
|
if (this.initializerSignature == null) {
|
return this.initializer.executeAsync({}, []);
|
}
|
else {
|
return this.initializer.executeAsync({}, Object.keys(this.initializerSignature.outputs));
|
}
|
}
|
setResourceIdToCapturedInput(outputs) {
|
this.resourceIdToCapturedInput = {};
|
if (this.initializerSignature) {
|
const signatureOutputs = this.initializerSignature.outputs;
|
const outputNames = Object.keys(signatureOutputs);
|
for (let i = 0; i < outputNames.length; i++) {
|
const outputName = outputNames[i];
|
const tensorInfo = signatureOutputs[outputName];
|
this.resourceIdToCapturedInput[tensorInfo.resourceId] = outputs[i];
|
}
|
}
|
}
|
/**
|
* Executes inference for the model for given input tensors.
|
* @param inputs tensor, tensor array or tensor map of the inputs for the
|
* model, keyed by the input node names.
|
* @param outputs output node name from the TensorFlow model, if no
|
* outputs are specified, the default outputs of the model would be used.
|
* You can inspect intermediate nodes of the model by adding them to the
|
* outputs array.
|
*
|
* @returns A single tensor if provided with a single output or no outputs
|
* are provided and there is only one default output, otherwise return a
|
* tensor array. The order of the tensor array is the same as the outputs
|
* if provided, otherwise the order of outputNodes attribute of the model.
|
*
|
* @doc {heading: 'Models', subheading: 'Classes'}
|
*/
|
execute(inputs, outputs) {
|
if (this.resourceIdToCapturedInput == null) {
|
this.setResourceIdToCapturedInput(this.executeInitializerGraph());
|
}
|
inputs = this.normalizeInputs(inputs);
|
outputs = this.normalizeOutputs(outputs);
|
const result = this.executor.execute(inputs, outputs);
|
return result.length > 1 ? result : result[0];
|
}
|
/**
|
* Executes inference for the model for given input tensors in async
|
* fashion, use this method when your model contains control flow ops.
|
* @param inputs tensor, tensor array or tensor map of the inputs for the
|
* model, keyed by the input node names.
|
* @param outputs output node name from the TensorFlow model, if no outputs
|
* are specified, the default outputs of the model would be used. You can
|
* inspect intermediate nodes of the model by adding them to the outputs
|
* array.
|
*
|
* @returns A Promise of single tensor if provided with a single output or
|
* no outputs are provided and there is only one default output, otherwise
|
* return a tensor map.
|
*
|
* @doc {heading: 'Models', subheading: 'Classes'}
|
*/
|
async executeAsync(inputs, outputs) {
|
if (this.resourceIdToCapturedInput == null) {
|
this.setResourceIdToCapturedInput(await this.executeInitializerGraphAsync());
|
}
|
inputs = this.normalizeInputs(inputs);
|
outputs = this.normalizeOutputs(outputs);
|
const result = await this.executor.executeAsync(inputs, outputs);
|
return result.length > 1 ? result : result[0];
|
}
|
/**
|
* Get intermediate tensors for model debugging mode (flag
|
* KEEP_INTERMEDIATE_TENSORS is true).
|
*
|
* @doc {heading: 'Models', subheading: 'Classes'}
|
*/
|
getIntermediateTensors() {
|
return this.executor.getIntermediateTensors();
|
}
|
/**
|
* Dispose intermediate tensors for model debugging mode (flag
|
* KEEP_INTERMEDIATE_TENSORS is true).
|
*
|
* @doc {heading: 'Models', subheading: 'Classes'}
|
*/
|
disposeIntermediateTensors() {
|
this.executor.disposeIntermediateTensors();
|
}
|
convertTensorMapToTensorsMap(map) {
|
return Object.keys(map).reduce((newMap, key) => {
|
newMap[key] = [map[key]];
|
return newMap;
|
}, {});
|
}
|
/**
|
* Releases the memory used by the weight tensors and resourceManager.
|
*
|
* @doc {heading: 'Models', subheading: 'Classes'}
|
*/
|
dispose() {
|
this.executor.dispose();
|
if (this.initializer) {
|
this.initializer.dispose();
|
if (this.resourceIdToCapturedInput) {
|
dispose(this.resourceIdToCapturedInput);
|
}
|
}
|
this.resourceManager.dispose();
|
}
|
}
|
/**
|
* Load a graph model given a URL to the model definition.
|
*
|
* Example of loading MobileNetV2 from a URL and making a prediction with a
|
* zeros input:
|
*
|
* ```js
|
* const modelUrl =
|
* 'https://storage.googleapis.com/tfjs-models/savedmodel/mobilenet_v2_1.0_224/model.json';
|
* const model = await tf.loadGraphModel(modelUrl);
|
* const zeros = tf.zeros([1, 224, 224, 3]);
|
* model.predict(zeros).print();
|
* ```
|
*
|
* Example of loading MobileNetV2 from a TF Hub URL and making a prediction
|
* with a zeros input:
|
*
|
* ```js
|
* const modelUrl =
|
* 'https://tfhub.dev/google/imagenet/mobilenet_v2_140_224/classification/2';
|
* const model = await tf.loadGraphModel(modelUrl, {fromTFHub: true});
|
* const zeros = tf.zeros([1, 224, 224, 3]);
|
* model.predict(zeros).print();
|
* ```
|
* @param modelUrl The url or an `io.IOHandler` that loads the model.
|
* @param options Options for the HTTP request, which allows to send
|
* credentials
|
* and custom headers.
|
*
|
* @doc {heading: 'Models', subheading: 'Loading'}
|
*/
|
export async function loadGraphModel(modelUrl, options = {}, tfio = io) {
|
if (modelUrl == null) {
|
throw new Error('modelUrl in loadGraphModel() cannot be null. Please provide a url ' +
|
'or an IOHandler that loads the model');
|
}
|
if (options == null) {
|
options = {};
|
}
|
if (options.fromTFHub && typeof modelUrl === 'string') {
|
modelUrl = getTFHubUrl(modelUrl);
|
}
|
const model = new GraphModel(modelUrl, options, tfio);
|
await model.load();
|
return model;
|
}
|
/**
|
* Load a graph model given a synchronous IO handler with a 'load' method.
|
*
|
* @param modelSource The `io.IOHandlerSync` that loads the model, or the
|
* `io.ModelArtifacts` that encode the model, or a tuple of
|
* `[io.ModelJSON, ArrayBuffer]` of which the first element encodes the
|
* model and the second contains the weights.
|
*
|
* @doc {heading: 'Models', subheading: 'Loading'}
|
*/
|
export function loadGraphModelSync(modelSource) {
|
if (modelSource == null) {
|
throw new Error('modelUrl in loadGraphModelSync() cannot be null. Please provide ' +
|
'model artifacts or an IOHandler that loads the model');
|
}
|
let ioHandler;
|
if (modelSource instanceof Array) {
|
const [modelJSON, weights] = modelSource;
|
if (!modelJSON) {
|
throw new Error('modelJSON must be the first element of the array');
|
}
|
if (!weights || !(weights instanceof ArrayBuffer)) {
|
throw new Error('An ArrayBuffer of weights must be the second element of' +
|
' the array');
|
}
|
if (!('modelTopology' in modelJSON)) {
|
throw new Error('Model JSON is missing \'modelTopology\'');
|
}
|
if (!('weightsManifest' in modelJSON)) {
|
throw new Error('Model JSON is missing \'weightsManifest\'');
|
}
|
const weightSpecs = io.getWeightSpecs(modelJSON.weightsManifest);
|
const modelArtifacts = io.getModelArtifactsForJSONSync(modelJSON, weightSpecs, weights);
|
ioHandler = io.fromMemorySync(modelArtifacts);
|
}
|
else if ('load' in modelSource) {
|
// Then modelSource is already an IOHandlerSync.
|
ioHandler = modelSource;
|
}
|
else if ('modelTopology' in modelSource && 'weightSpecs' in modelSource &&
|
'weightData' in modelSource) {
|
// modelSource is of type ModelArtifacts.
|
ioHandler = io.fromMemorySync(modelSource);
|
}
|
else {
|
throw new Error('Unknown model format');
|
}
|
const model = new GraphModel(ioHandler);
|
model.load();
|
return model;
|
}
|
function getTFHubUrl(modelUrl) {
|
if (!modelUrl.endsWith('/')) {
|
modelUrl = (modelUrl) + '/';
|
}
|
return `${modelUrl}${DEFAULT_MODEL_NAME}${TFHUB_SEARCH_PARAM}`;
|
}
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"graph_model.js","sourceRoot":"","sources":["../../../../../../tfjs-converter/src/executor/graph_model.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2018 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\nimport {dispose, InferenceModel, io, ModelPredictConfig, NamedTensorMap, Tensor, util} from '@tensorflow/tfjs-core';\n\nimport * as tensorflow from '../data/compiled_api';\nimport {NamedTensorsMap, TensorInfo} from '../data/types';\nimport {OperationMapper} from '../operations/operation_mapper';\n\nimport {GraphExecutor} from './graph_executor';\nimport {ResourceManager} from './resource_manager';\n// tslint:disable-next-line: no-imports-from-dist\nimport {decodeWeightsStream} from '@tensorflow/tfjs-core/dist/io/io_utils';\n\nexport const TFHUB_SEARCH_PARAM = '?tfjs-format=file';\nexport const DEFAULT_MODEL_NAME = 'model.json';\ntype Url = string|io.IOHandler|io.IOHandlerSync;\ntype UrlIOHandler<T extends Url> = T extends string ? io.IOHandler : T;\n\n/**\n * A `tf.GraphModel` is a directed, acyclic graph built from a\n * SavedModel GraphDef and allows inference execution.\n *\n * A `tf.GraphModel` can only be created by loading from a model converted from\n * a [TensorFlow SavedModel](https://www.tensorflow.org/guide/saved_model) using\n * the command line converter tool and loaded via `tf.loadGraphModel`.\n *\n * @doc {heading: 'Models', subheading: 'Classes'}\n */\nexport class GraphModel<ModelURL extends Url = string | io.IOHandler> implements\n    InferenceModel {\n  private executor: GraphExecutor;\n  private version = 'n/a';\n  private handler: UrlIOHandler<ModelURL>;\n  private artifacts: io.ModelArtifacts;\n  private initializer: GraphExecutor;\n  private resourceIdToCapturedInput: {[key: number]: Tensor};\n  private resourceManager: ResourceManager;\n  private signature: tensorflow.ISignatureDef;\n  private initializerSignature: tensorflow.ISignatureDef;\n  private structuredOutputKeys: string[];\n  private readonly io: typeof io;\n\n  // Returns the version information for the tensorflow model GraphDef.\n  get modelVersion(): string {\n    return this.version;\n  }\n\n  get inputNodes(): string[] {\n    return this.executor.inputNodes;\n  }\n\n  get outputNodes(): string[] {\n    return this.executor.outputNodes;\n  }\n\n  get inputs(): TensorInfo[] {\n    return this.executor.inputs;\n  }\n\n  get outputs(): TensorInfo[] {\n    return this.executor.outputs;\n  }\n\n  get weights(): NamedTensorsMap {\n    return this.executor.weightMap;\n  }\n\n  get metadata(): {} {\n    return this.artifacts.userDefinedMetadata;\n  }\n\n  get modelSignature(): {} {\n    return this.signature;\n  }\n\n  get modelStructuredOutputKeys(): {} {\n    return this.structuredOutputKeys;\n  }\n\n  /**\n   * @param modelUrl url for the model, or an `io.IOHandler`.\n   * @param weightManifestUrl url for the weight file generated by\n   * scripts/convert.py script.\n   * @param requestOption options for Request, which allows to send credentials\n   * and custom headers.\n   * @param onProgress Optional, progress callback function, fired periodically\n   * before the load is completed.\n   */\n  constructor(\n      private modelUrl: ModelURL, private loadOptions: io.LoadOptions = {},\n      tfio = io) {\n    this.io = tfio;\n    if (loadOptions == null) {\n      this.loadOptions = {};\n    }\n    this.resourceManager = new ResourceManager();\n  }\n\n  private findIOHandler() {\n    type IOHandler = UrlIOHandler<ModelURL>;\n    const path = this.modelUrl;\n    if ((path as io.IOHandler).load != null) {\n      // Path is an IO Handler.\n      this.handler = path as IOHandler;\n    } else if (this.loadOptions.requestInit != null) {\n      this.handler = this.io.browserHTTPRequest(\n                         path as string, this.loadOptions) as IOHandler;\n    } else {\n      const handlers =\n          this.io.getLoadHandlers(path as string, this.loadOptions);\n      if (handlers.length === 0) {\n        // For backward compatibility: if no load handler can be found,\n        // assume it is a relative http path.\n        handlers.push(\n            this.io.browserHTTPRequest(path as string, this.loadOptions));\n      } else if (handlers.length > 1) {\n        throw new Error(\n            `Found more than one (${handlers.length}) load handlers for ` +\n            `URL '${[path]}'`);\n      }\n      this.handler = handlers[0] as IOHandler;\n    }\n  }\n\n  /**\n   * Loads the model and weight files, construct the in memory weight map and\n   * compile the inference graph.\n   */\n  load(): UrlIOHandler<ModelURL> extends io.IOHandlerSync? boolean:\n                                             Promise<boolean> {\n    type IOHandler = UrlIOHandler<ModelURL>;\n    this.findIOHandler();\n    if (this.handler.load == null) {\n      throw new Error(\n          'Cannot proceed with model loading because the IOHandler provided ' +\n          'does not have the `load` method implemented.');\n    }\n\n    type Result =\n        IOHandler extends io.IOHandlerSync ? boolean : Promise<boolean>;\n\n    const loadResult = this.handler.load() as ReturnType<IOHandler['load']>;\n    if (util.isPromise(loadResult)) {\n      return loadResult.then(artifacts => {\n        if (artifacts.getWeightStream == null) {\n          return this.loadSync(artifacts);\n        }\n        return this.loadStreaming(artifacts);\n      }) as Result;\n    }\n\n    return this.loadSync(loadResult) as Result;\n  }\n\n  /**\n   * Synchronously construct the in memory weight map and\n   * compile the inference graph.\n   *\n   * @doc {heading: 'Models', subheading: 'Classes', ignoreCI: true}\n   */\n  loadSync(artifacts: io.ModelArtifacts) {\n    const weightMap = this.io.decodeWeights(\n        artifacts.weightData, artifacts.weightSpecs);\n\n    return this.loadWithWeightMap(artifacts, weightMap);\n  }\n\n  private async loadStreaming(artifacts: io.ModelArtifacts): Promise<boolean> {\n    if (artifacts.getWeightStream == null) {\n      throw new Error('Model artifacts missing streamWeights function');\n    }\n\n    const weightMap = await decodeWeightsStream(\n      artifacts.getWeightStream(), artifacts.weightSpecs);\n\n    return this.loadWithWeightMap(artifacts, weightMap);\n  }\n\n  private loadWithWeightMap(artifacts: io.ModelArtifacts,\n                            weightMap: NamedTensorMap) {\n    this.artifacts = artifacts;\n    const graph = this.artifacts.modelTopology as tensorflow.IGraphDef;\n\n    let signature = this.artifacts.signature;\n    if (this.artifacts.userDefinedMetadata != null) {\n      const metadata = this.artifacts.userDefinedMetadata;\n      if (metadata.signature != null) {\n        signature = metadata.signature;\n      }\n\n      if (metadata.structuredOutputKeys != null) {\n        this.structuredOutputKeys = metadata.structuredOutputKeys as string[];\n      }\n    }\n    this.signature = signature;\n\n    this.version = `${graph.versions.producer}.${graph.versions.minConsumer}`;\n    this.executor = new GraphExecutor(\n        OperationMapper.Instance.transformGraph(graph, this.signature));\n    this.executor.weightMap = this.convertTensorMapToTensorsMap(weightMap);\n    // Attach a model-level resourceManager to each executor to share resources,\n    // such as `HashTable`.\n    this.executor.resourceManager = this.resourceManager;\n\n    if (artifacts.modelInitializer != null &&\n        (artifacts.modelInitializer as tensorflow.IGraphDef).node != null) {\n      const initializer =\n          OperationMapper.Instance.transformGraph(artifacts.modelInitializer);\n      this.initializer = new GraphExecutor(initializer);\n      this.initializer.weightMap = this.executor.weightMap;\n      // Attach a model-level resourceManager to the initializer, the\n      // hashTables created from when executing the initializer will be stored\n      // in the resourceManager.\n      this.initializer.resourceManager = this.resourceManager;\n      this.initializerSignature = artifacts.initializerSignature;\n    }\n\n    return true;\n  }\n\n  /**\n   * Save the configuration and/or weights of the GraphModel.\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 modelUrl =\n   *    'https://storage.googleapis.com/tfjs-models/savedmodel/mobilenet_v2_1.0_224/model.json';\n   * const model = await tf.loadGraphModel(modelUrl);\n   * const zeros = tf.zeros([1, 224, 224, 3]);\n   * model.predict(zeros).print();\n   *\n   * const saveResults = await model.save('localstorage://my-model-1');\n   *\n   * const loadedModel = await tf.loadGraphModel('localstorage://my-model-1');\n   * console.log('Prediction from loaded model:');\n   * model.predict(zeros).print();\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 = this.io.getSaveHandlers(handlerOrURL);\n      if (handlers.length === 0) {\n        throw new Error(\n            `Cannot find any save handlers for URL '${handlerOrURL}'`);\n      } else if (handlers.length > 1) {\n        throw new Error(\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 Error(\n          'GraphModel.save() cannot proceed because the IOHandler ' +\n          'provided does not have the `save` attribute defined.');\n    }\n\n    return handlerOrURL.save(this.artifacts);\n  }\n\n  private addStructuredOutputNames(outputTensors: Tensor|Tensor[]) {\n    if (this.structuredOutputKeys) {\n      const outputTensorsArray =\n          outputTensors instanceof Tensor ? [outputTensors] : outputTensors;\n      const outputTensorMap: NamedTensorMap = {};\n\n      outputTensorsArray.forEach(\n          (outputTensor, i) => outputTensorMap[this.structuredOutputKeys[i]] =\n              outputTensor);\n\n      return outputTensorMap;\n    }\n    return outputTensors;\n  }\n\n  /**\n   * Execute the inference for the input tensors.\n   *\n   * @param input The input tensors, when there is single input for the model,\n   * inputs param should be a `tf.Tensor`. For models with mutliple inputs,\n   * inputs params should be in either `tf.Tensor`[] if the input order is\n   * fixed, or otherwise NamedTensorMap format.\n   *\n   * For model with multiple inputs, we recommend you use NamedTensorMap as the\n   * input type, if you use `tf.Tensor`[], the order of the array needs to\n   * follow the\n   * order of inputNodes array. @see {@link GraphModel.inputNodes}\n   *\n   * You can also feed any intermediate nodes using the NamedTensorMap as the\n   * input type. For example, given the graph\n   *    InputNode => Intermediate => OutputNode,\n   * you can execute the subgraph Intermediate => OutputNode by calling\n   *    model.execute('IntermediateNode' : tf.tensor(...));\n   *\n   * This is useful for models that uses tf.dynamic_rnn, where the intermediate\n   * state needs to be fed manually.\n   *\n   * For batch inference execution, the tensors for each input need to be\n   * concatenated together. For example with mobilenet, the required input shape\n   * is [1, 244, 244, 3], which represents the [batch, height, width, channel].\n   * If we are provide a batched data of 100 images, the input tensor should be\n   * in the shape of [100, 244, 244, 3].\n   *\n   * @param config Prediction configuration for specifying the batch size.\n   * Currently the batch size option is ignored for graph model.\n   *\n   * @returns Inference result tensors. If the model is converted and it\n   * originally had structured_outputs in tensorflow, then a NamedTensorMap\n   * will be returned matching the structured_outputs. If no structured_outputs\n   * are present, the output will be single `tf.Tensor` if the model has single\n   * output node, otherwise Tensor[].\n   *\n   * @doc {heading: 'Models', subheading: 'Classes'}\n   */\n  predict(inputs: Tensor|Tensor[]|NamedTensorMap, config?: ModelPredictConfig):\n      Tensor|Tensor[]|NamedTensorMap {\n    const outputTensors = this.execute(inputs, this.outputNodes);\n    return this.addStructuredOutputNames(outputTensors);\n  }\n\n  /**\n   * Execute the inference for the input tensors in async fashion, use this\n   * method when your model contains control flow ops.\n   *\n   * @param input The input tensors, when there is single input for the model,\n   * inputs param should be a `tf.Tensor`. For models with mutliple inputs,\n   * inputs params should be in either `tf.Tensor`[] if the input order is\n   * fixed, or otherwise NamedTensorMap format.\n   *\n   * For model with multiple inputs, we recommend you use NamedTensorMap as the\n   * input type, if you use `tf.Tensor`[], the order of the array needs to\n   * follow the\n   * order of inputNodes array. @see {@link GraphModel.inputNodes}\n   *\n   * You can also feed any intermediate nodes using the NamedTensorMap as the\n   * input type. For example, given the graph\n   *    InputNode => Intermediate => OutputNode,\n   * you can execute the subgraph Intermediate => OutputNode by calling\n   *    model.execute('IntermediateNode' : tf.tensor(...));\n   *\n   * This is useful for models that uses tf.dynamic_rnn, where the intermediate\n   * state needs to be fed manually.\n   *\n   * For batch inference execution, the tensors for each input need to be\n   * concatenated together. For example with mobilenet, the required input shape\n   * is [1, 244, 244, 3], which represents the [batch, height, width, channel].\n   * If we are provide a batched data of 100 images, the input tensor should be\n   * in the shape of [100, 244, 244, 3].\n   *\n   * @param config Prediction configuration for specifying the batch size.\n   * Currently the batch size option is ignored for graph model.\n   *\n   * @returns A Promise of inference result tensors. If the model is converted\n   * and it originally had structured_outputs in tensorflow, then a\n   * NamedTensorMap will be returned matching the structured_outputs. If no\n   * structured_outputs are present, the output will be single `tf.Tensor` if\n   * the model has single output node, otherwise Tensor[].\n   *\n   * @doc {heading: 'Models', subheading: 'Classes'}\n   */\n  async predictAsync(\n      inputs: Tensor|Tensor[]|NamedTensorMap,\n      config?: ModelPredictConfig): Promise<Tensor|Tensor[]|NamedTensorMap> {\n    const outputTensors = await this.executeAsync(inputs, this.outputNodes);\n    return this.addStructuredOutputNames(outputTensors);\n  }\n\n  private normalizeInputs(inputs: Tensor|Tensor[]|\n                          NamedTensorMap): NamedTensorMap {\n    if (!(inputs instanceof Tensor) && !Array.isArray(inputs)) {\n      // The input is already a NamedTensorMap.\n      const signatureInputs = this.signature?.inputs;\n      if (signatureInputs != null) {\n        for (const input in signatureInputs) {\n          const tensor = signatureInputs[input];\n          if (tensor.resourceId != null) {\n            inputs[input] = this.resourceIdToCapturedInput[tensor.resourceId];\n          }\n        }\n      }\n      return inputs;\n    }\n    inputs = Array.isArray(inputs) ? inputs : [inputs];\n\n    const numCapturedInputs =\n        Object.keys(this.resourceIdToCapturedInput).length;\n    if (inputs.length + numCapturedInputs !== this.inputNodes.length) {\n      throw new Error(`Input tensor count mismatch, the graph model has ${\n          this.inputNodes.length -\n          numCapturedInputs} non-resource placeholders, while there are ${\n          inputs.length} input tensors provided.`);\n    }\n\n    let inputIndex = 0;\n    return this.inputNodes.reduce((map, inputName) => {\n      const resourceId = this.signature?.inputs?.[inputName]?.resourceId;\n      if (resourceId != null) {\n        map[inputName] = this.resourceIdToCapturedInput[resourceId];\n      } else {\n        map[inputName] = (inputs as Tensor[])[inputIndex++];\n      }\n      return map;\n    }, {} as NamedTensorMap);\n  }\n\n  private normalizeOutputs(outputs: string|string[]): string[] {\n    outputs = outputs || this.outputNodes;\n    return !Array.isArray(outputs) ? [outputs] : outputs;\n  }\n\n  private executeInitializerGraph() {\n    if (this.initializer == null) {\n      return [];\n    }\n    if (this.initializerSignature == null) {\n      return this.initializer.execute({}, []);\n    } else {\n      return this.initializer.execute(\n          {}, Object.keys(this.initializerSignature.outputs));\n    }\n  }\n\n  private async executeInitializerGraphAsync() {\n    if (this.initializer == null) {\n      return [];\n    }\n    if (this.initializerSignature == null) {\n      return this.initializer.executeAsync({}, []);\n    } else {\n      return this.initializer.executeAsync(\n          {}, Object.keys(this.initializerSignature.outputs));\n    }\n  }\n\n  private setResourceIdToCapturedInput(outputs: Tensor[]) {\n    this.resourceIdToCapturedInput = {};\n\n    if (this.initializerSignature) {\n      const signatureOutputs = this.initializerSignature.outputs;\n      const outputNames = Object.keys(signatureOutputs);\n      for (let i = 0; i < outputNames.length; i++) {\n        const outputName = outputNames[i];\n        const tensorInfo = signatureOutputs[outputName];\n        this.resourceIdToCapturedInput[tensorInfo.resourceId] = outputs[i];\n      }\n    }\n  }\n\n  /**\n   * Executes inference for the model for given input tensors.\n   * @param inputs tensor, tensor array or tensor map of the inputs for the\n   * model, keyed by the input node names.\n   * @param outputs output node name from the TensorFlow model, if no\n   * outputs are specified, the default outputs of the model would be used.\n   * You can inspect intermediate nodes of the model by adding them to the\n   * outputs array.\n   *\n   * @returns A single tensor if provided with a single output or no outputs\n   * are provided and there is only one default output, otherwise return a\n   * tensor array. The order of the tensor array is the same as the outputs\n   * if provided, otherwise the order of outputNodes attribute of the model.\n   *\n   * @doc {heading: 'Models', subheading: 'Classes'}\n   */\n  execute(inputs: Tensor|Tensor[]|NamedTensorMap, outputs?: string|string[]):\n      Tensor|Tensor[] {\n    if (this.resourceIdToCapturedInput == null) {\n      this.setResourceIdToCapturedInput(this.executeInitializerGraph());\n    }\n    inputs = this.normalizeInputs(inputs);\n    outputs = this.normalizeOutputs(outputs);\n    const result = this.executor.execute(inputs, outputs);\n    return result.length > 1 ? result : result[0];\n  }\n\n  /**\n   * Executes inference for the model for given input tensors in async\n   * fashion, use this method when your model contains control flow ops.\n   * @param inputs tensor, tensor array or tensor map of the inputs for the\n   * model, keyed by the input node names.\n   * @param outputs output node name from the TensorFlow model, if no outputs\n   * are specified, the default outputs of the model would be used. You can\n   * inspect intermediate nodes of the model by adding them to the outputs\n   * array.\n   *\n   * @returns A Promise of single tensor if provided with a single output or\n   * no outputs are provided and there is only one default output, otherwise\n   * return a tensor map.\n   *\n   * @doc {heading: 'Models', subheading: 'Classes'}\n   */\n  async executeAsync(\n      inputs: Tensor|Tensor[]|NamedTensorMap,\n      outputs?: string|string[]): Promise<Tensor|Tensor[]> {\n    if (this.resourceIdToCapturedInput == null) {\n      this.setResourceIdToCapturedInput(\n          await this.executeInitializerGraphAsync());\n    }\n    inputs = this.normalizeInputs(inputs);\n    outputs = this.normalizeOutputs(outputs);\n    const result = await this.executor.executeAsync(inputs, outputs);\n    return result.length > 1 ? result : result[0];\n  }\n\n  /**\n   * Get intermediate tensors for model debugging mode (flag\n   * KEEP_INTERMEDIATE_TENSORS is true).\n   *\n   * @doc {heading: 'Models', subheading: 'Classes'}\n   */\n  getIntermediateTensors(): NamedTensorsMap {\n    return this.executor.getIntermediateTensors();\n  }\n\n  /**\n   * Dispose intermediate tensors for model debugging mode (flag\n   * KEEP_INTERMEDIATE_TENSORS is true).\n   *\n   * @doc {heading: 'Models', subheading: 'Classes'}\n   */\n  disposeIntermediateTensors() {\n    this.executor.disposeIntermediateTensors();\n  }\n\n  private convertTensorMapToTensorsMap(map: NamedTensorMap): NamedTensorsMap {\n    return Object.keys(map).reduce((newMap: NamedTensorsMap, key) => {\n      newMap[key] = [map[key]];\n      return newMap;\n    }, {});\n  }\n\n  /**\n   * Releases the memory used by the weight tensors and resourceManager.\n   *\n   * @doc {heading: 'Models', subheading: 'Classes'}\n   */\n  dispose() {\n    this.executor.dispose();\n\n    if (this.initializer) {\n      this.initializer.dispose();\n      if (this.resourceIdToCapturedInput) {\n        dispose(this.resourceIdToCapturedInput);\n      }\n    }\n\n    this.resourceManager.dispose();\n  }\n}\n\n/**\n * Load a graph model given a URL to the model definition.\n *\n * Example of loading MobileNetV2 from a URL and making a prediction with a\n * zeros input:\n *\n * ```js\n * const modelUrl =\n *    'https://storage.googleapis.com/tfjs-models/savedmodel/mobilenet_v2_1.0_224/model.json';\n * const model = await tf.loadGraphModel(modelUrl);\n * const zeros = tf.zeros([1, 224, 224, 3]);\n * model.predict(zeros).print();\n * ```\n *\n * Example of loading MobileNetV2 from a TF Hub URL and making a prediction\n * with a zeros input:\n *\n * ```js\n * const modelUrl =\n *    'https://tfhub.dev/google/imagenet/mobilenet_v2_140_224/classification/2';\n * const model = await tf.loadGraphModel(modelUrl, {fromTFHub: true});\n * const zeros = tf.zeros([1, 224, 224, 3]);\n * model.predict(zeros).print();\n * ```\n * @param modelUrl The url or an `io.IOHandler` that loads the model.\n * @param options Options for the HTTP request, which allows to send\n *     credentials\n *    and custom headers.\n *\n * @doc {heading: 'Models', subheading: 'Loading'}\n */\nexport async function loadGraphModel(\n    modelUrl: string|io.IOHandler, options: io.LoadOptions = {},\n    tfio = io): Promise<GraphModel> {\n  if (modelUrl == null) {\n    throw new Error(\n        'modelUrl in loadGraphModel() cannot be null. Please provide a url ' +\n        'or an IOHandler that loads the model');\n  }\n  if (options == null) {\n    options = {};\n  }\n\n  if (options.fromTFHub && typeof modelUrl === 'string') {\n    modelUrl = getTFHubUrl(modelUrl);\n  }\n  const model = new GraphModel(modelUrl, options, tfio);\n  await model.load();\n  return model;\n}\n\n/**\n * Load a graph model given a synchronous IO handler with a 'load' method.\n *\n * @param modelSource The `io.IOHandlerSync` that loads the model, or the\n *     `io.ModelArtifacts` that encode the model, or a tuple of\n *     `[io.ModelJSON, ArrayBuffer]` of which the first element encodes the\n *      model and the second contains the weights.\n *\n * @doc {heading: 'Models', subheading: 'Loading'}\n */\nexport function loadGraphModelSync(\n    modelSource: io.IOHandlerSync|\n    io.ModelArtifacts|[io.ModelJSON, /* Weights */ ArrayBuffer]):\n    GraphModel<io.IOHandlerSync> {\n  if (modelSource == null) {\n    throw new Error(\n        'modelUrl in loadGraphModelSync() cannot be null. Please provide ' +\n        'model artifacts or an IOHandler that loads the model');\n  }\n\n  let ioHandler: io.IOHandlerSync;\n  if (modelSource instanceof Array) {\n    const [modelJSON, weights] = modelSource;\n    if (!modelJSON) {\n      throw new Error('modelJSON must be the first element of the array');\n    }\n    if (!weights || !(weights instanceof ArrayBuffer)) {\n      throw new Error(\n          'An ArrayBuffer of weights must be the second element of' +\n          ' the array');\n    }\n    if (!('modelTopology' in modelJSON)) {\n      throw new Error('Model JSON is missing \\'modelTopology\\'');\n    }\n    if (!('weightsManifest' in modelJSON)) {\n      throw new Error('Model JSON is missing \\'weightsManifest\\'');\n    }\n\n    const weightSpecs = io.getWeightSpecs(modelJSON.weightsManifest);\n    const modelArtifacts =\n        io.getModelArtifactsForJSONSync(modelJSON, weightSpecs, weights);\n    ioHandler = io.fromMemorySync(modelArtifacts);\n  } else if ('load' in modelSource) {\n    // Then modelSource is already an IOHandlerSync.\n    ioHandler = modelSource;\n  } else if (\n      'modelTopology' in modelSource && 'weightSpecs' in modelSource &&\n      'weightData' in modelSource) {\n    // modelSource is of type ModelArtifacts.\n    ioHandler = io.fromMemorySync(modelSource);\n  } else {\n    throw new Error('Unknown model format');\n  }\n\n  const model = new GraphModel(ioHandler);\n  model.load();\n  return model;\n}\n\nfunction getTFHubUrl(modelUrl: string): string {\n  if (!modelUrl.endsWith('/')) {\n    modelUrl = (modelUrl) + '/';\n  }\n  return `${modelUrl}${DEFAULT_MODEL_NAME}${TFHUB_SEARCH_PARAM}`;\n}\n"]}
|
