1 | /**
|
2 | * @license
|
3 | * Copyright 2018 Google LLC
|
4 | *
|
5 | * Use of this source code is governed by an MIT-style
|
6 | * license that can be found in the LICENSE file or at
|
7 | * https://opensource.org/licenses/MIT.
|
8 | * =============================================================================
|
9 | */
|
10 | import { CallbackConstructorRegistry } from './base_callbacks';
|
11 | import { Input, } from './engine/input_layer';
|
12 | import { LayersModel } from './engine/training';
|
13 | import { loadLayersModelInternal, Sequential } from './models';
|
14 | // TODO(cais): Add doc string to all the public static functions in this
|
15 | // class; include exectuable JavaScript code snippets where applicable
|
16 | // (b/74074458).
|
17 | // LayersModel and related factory methods.
|
18 | /**
|
19 | * A model is a data structure that consists of `Layers` and defines inputs
|
20 | * and outputs.
|
21 | *
|
22 | * The key difference between `tf.model` and `tf.sequential` is that
|
23 | * `tf.model` is more generic, supporting an arbitrary graph (without
|
24 | * cycles) of layers. `tf.sequential` is less generic and supports only a linear
|
25 | * stack of layers.
|
26 | *
|
27 | * When creating a `tf.LayersModel`, specify its input(s) and output(s). Layers
|
28 | * are used to wire input(s) to output(s).
|
29 | *
|
30 | * For example, the following code snippet defines a model consisting of
|
31 | * two `dense` layers, with 10 and 4 units, respectively.
|
32 | *
|
33 | * ```js
|
34 | * // Define input, which has a size of 5 (not including batch dimension).
|
35 | * const input = tf.input({shape: [5]});
|
36 | *
|
37 | * // First dense layer uses relu activation.
|
38 | * const denseLayer1 = tf.layers.dense({units: 10, activation: 'relu'});
|
39 | * // Second dense layer uses softmax activation.
|
40 | * const denseLayer2 = tf.layers.dense({units: 4, activation: 'softmax'});
|
41 | *
|
42 | * // Obtain the output symbolic tensor by applying the layers on the input.
|
43 | * const output = denseLayer2.apply(denseLayer1.apply(input));
|
44 | *
|
45 | * // Create the model based on the inputs.
|
46 | * const model = tf.model({inputs: input, outputs: output});
|
47 | *
|
48 | * // The model can be used for training, evaluation and prediction.
|
49 | * // For example, the following line runs prediction with the model on
|
50 | * // some fake data.
|
51 | * model.predict(tf.ones([2, 5])).print();
|
52 | * ```
|
53 | * See also:
|
54 | * `tf.sequential`, `tf.loadLayersModel`.
|
55 | *
|
56 | * @doc {heading: 'Models', subheading: 'Creation'}
|
57 | */
|
58 | export function model(args) {
|
59 | return new LayersModel(args);
|
60 | }
|
61 | /**
|
62 | * Creates a `tf.Sequential` model. A sequential model is any model where the
|
63 | * outputs of one layer are the inputs to the next layer, i.e. the model
|
64 | * topology is a simple 'stack' of layers, with no branching or skipping.
|
65 | *
|
66 | * This means that the first layer passed to a `tf.Sequential` model should have
|
67 | * a defined input shape. What that means is that it should have received an
|
68 | * `inputShape` or `batchInputShape` argument, or for some type of layers
|
69 | * (recurrent, Dense...) an `inputDim` argument.
|
70 | *
|
71 | * The key difference between `tf.model` and `tf.sequential` is that
|
72 | * `tf.sequential` is less generic, supporting only a linear stack of layers.
|
73 | * `tf.model` is more generic and supports an arbitrary graph (without
|
74 | * cycles) of layers.
|
75 | *
|
76 | * Examples:
|
77 | *
|
78 | * ```js
|
79 | * const model = tf.sequential();
|
80 | *
|
81 | * // First layer must have an input shape defined.
|
82 | * model.add(tf.layers.dense({units: 32, inputShape: [50]}));
|
83 | * // Afterwards, TF.js does automatic shape inference.
|
84 | * model.add(tf.layers.dense({units: 4}));
|
85 | *
|
86 | * // Inspect the inferred shape of the model's output, which equals
|
87 | * // `[null, 4]`. The 1st dimension is the undetermined batch dimension; the
|
88 | * // 2nd is the output size of the model's last layer.
|
89 | * console.log(JSON.stringify(model.outputs[0].shape));
|
90 | * ```
|
91 | *
|
92 | * It is also possible to specify a batch size (with potentially undetermined
|
93 | * batch dimension, denoted by "null") for the first layer using the
|
94 | * `batchInputShape` key. The following example is equivalent to the above:
|
95 | *
|
96 | * ```js
|
97 | * const model = tf.sequential();
|
98 | *
|
99 | * // First layer must have a defined input shape
|
100 | * model.add(tf.layers.dense({units: 32, batchInputShape: [null, 50]}));
|
101 | * // Afterwards, TF.js does automatic shape inference.
|
102 | * model.add(tf.layers.dense({units: 4}));
|
103 | *
|
104 | * // Inspect the inferred shape of the model's output.
|
105 | * console.log(JSON.stringify(model.outputs[0].shape));
|
106 | * ```
|
107 | *
|
108 | * You can also use an `Array` of already-constructed `Layer`s to create
|
109 | * a `tf.Sequential` model:
|
110 | *
|
111 | * ```js
|
112 | * const model = tf.sequential({
|
113 | * layers: [tf.layers.dense({units: 32, inputShape: [50]}),
|
114 | * tf.layers.dense({units: 4})]
|
115 | * });
|
116 | * console.log(JSON.stringify(model.outputs[0].shape));
|
117 | * ```
|
118 | *
|
119 | * @doc {heading: 'Models', subheading: 'Creation'}
|
120 | */
|
121 | export function sequential(config) {
|
122 | return new Sequential(config);
|
123 | }
|
124 | /**
|
125 | * Load a model composed of Layer objects, including its topology and optionally
|
126 | * weights. See the Tutorial named "How to import a Keras Model" for usage
|
127 | * examples.
|
128 | *
|
129 | * This method is applicable to:
|
130 | *
|
131 | * 1. Models created with the `tf.layers.*`, `tf.sequential`, and
|
132 | * `tf.model` APIs of TensorFlow.js and later saved with the
|
133 | * `tf.LayersModel.save` method.
|
134 | * 2. Models converted from Keras or TensorFlow tf.keras using the
|
135 | * [tensorflowjs_converter](https://github.com/tensorflow/tfjs/tree/master/tfjs-converter).
|
136 | *
|
137 | * This mode is *not* applicable to TensorFlow `SavedModel`s or their converted
|
138 | * forms. For those models, use `tf.loadGraphModel`.
|
139 | *
|
140 | * Example 1. Load a model from an HTTP server.
|
141 | *
|
142 | * ```js
|
143 | * const model = await tf.loadLayersModel(
|
144 | * 'https://storage.googleapis.com/tfjs-models/tfjs/iris_v1/model.json');
|
145 | * model.summary();
|
146 | * ```
|
147 | *
|
148 | * Example 2: Save `model`'s topology and weights to browser [local
|
149 | * storage](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage);
|
150 | * then load it back.
|
151 | *
|
152 | * ```js
|
153 | * const model = tf.sequential(
|
154 | * {layers: [tf.layers.dense({units: 1, inputShape: [3]})]});
|
155 | * console.log('Prediction from original model:');
|
156 | * model.predict(tf.ones([1, 3])).print();
|
157 | *
|
158 | * const saveResults = await model.save('localstorage://my-model-1');
|
159 | *
|
160 | * const loadedModel = await tf.loadLayersModel('localstorage://my-model-1');
|
161 | * console.log('Prediction from loaded model:');
|
162 | * loadedModel.predict(tf.ones([1, 3])).print();
|
163 | * ```
|
164 | *
|
165 | * Example 3. Saving `model`'s topology and weights to browser
|
166 | * [IndexedDB](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API);
|
167 | * then load it back.
|
168 | *
|
169 | * ```js
|
170 | * const model = tf.sequential(
|
171 | * {layers: [tf.layers.dense({units: 1, inputShape: [3]})]});
|
172 | * console.log('Prediction from original model:');
|
173 | * model.predict(tf.ones([1, 3])).print();
|
174 | *
|
175 | * const saveResults = await model.save('indexeddb://my-model-1');
|
176 | *
|
177 | * const loadedModel = await tf.loadLayersModel('indexeddb://my-model-1');
|
178 | * console.log('Prediction from loaded model:');
|
179 | * loadedModel.predict(tf.ones([1, 3])).print();
|
180 | * ```
|
181 | *
|
182 | * Example 4. Load a model from user-selected files from HTML
|
183 | * [file input
|
184 | * elements](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/file).
|
185 | *
|
186 | * ```js
|
187 | * // Note: this code snippet will not work without the HTML elements in the
|
188 | * // page
|
189 | * const jsonUpload = document.getElementById('json-upload');
|
190 | * const weightsUpload = document.getElementById('weights-upload');
|
191 | *
|
192 | * const model = await tf.loadLayersModel(
|
193 | * tf.io.browserFiles([jsonUpload.files[0], weightsUpload.files[0]]));
|
194 | * ```
|
195 | *
|
196 | * @param pathOrIOHandler Can be either of the two formats
|
197 | * 1. A string path to the `ModelAndWeightsConfig` JSON describing
|
198 | * the model in the canonical TensorFlow.js format. For file://
|
199 | * (tfjs-node-only), http:// and https:// schemas, the path can be
|
200 | * either absolute or relative.
|
201 | * 2. An `tf.io.IOHandler` object that loads model artifacts with its `load`
|
202 | * method.
|
203 | * @param options Optional configuration arguments for the model loading,
|
204 | * including:
|
205 | * - `strict`: Require that the provided weights exactly match those required
|
206 | * by the layers. Default true. Passing false means that both extra
|
207 | * weights and missing weights will be silently ignored.
|
208 | * - `onProgress`: A function of the signature `(fraction: number) => void',
|
209 | * that can be used as the progress callback for the model loading.
|
210 | * @returns A `Promise` of `tf.LayersModel`, with the topology and weights
|
211 | * loaded.
|
212 | *
|
213 | * @doc {heading: 'Models', subheading: 'Loading'}
|
214 | */
|
215 | export function loadLayersModel(pathOrIOHandler, options) {
|
216 | if (options == null) {
|
217 | options = {};
|
218 | }
|
219 | return loadLayersModelInternal(pathOrIOHandler, options);
|
220 | }
|
221 | /**
|
222 | * Used to instantiate an input to a model as a `tf.SymbolicTensor`.
|
223 | *
|
224 | * Users should call the `input` factory function for
|
225 | * consistency with other generator functions.
|
226 | *
|
227 | * Example:
|
228 | *
|
229 | * ```js
|
230 | * // Defines a simple logistic regression model with 32 dimensional input
|
231 | * // and 3 dimensional output.
|
232 | * const x = tf.input({shape: [32]});
|
233 | * const y = tf.layers.dense({units: 3, activation: 'softmax'}).apply(x);
|
234 | * const model = tf.model({inputs: x, outputs: y});
|
235 | * model.predict(tf.ones([2, 32])).print();
|
236 | * ```
|
237 | *
|
238 | * Note: `input` is only necessary when using `model`. When using
|
239 | * `sequential`, specify `inputShape` for the first layer or use `inputLayer`
|
240 | * as the first layer.
|
241 | *
|
242 | * @doc {heading: 'Models', subheading: 'Inputs'}
|
243 | */
|
244 | export function input(config) {
|
245 | return Input(config);
|
246 | }
|
247 | export function registerCallbackConstructor(verbosityLevel, callbackConstructor) {
|
248 | CallbackConstructorRegistry.registerCallbackConstructor(verbosityLevel, callbackConstructor);
|
249 | }
|
250 | //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"exports.js","sourceRoot":"","sources":["../../../../../tfjs-layers/src/exports.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAQH,OAAO,EAA0B,2BAA2B,EAAC,MAAM,kBAAkB,CAAC;AAEtF,OAAO,EAAC,KAAK,GAAe,MAAM,sBAAsB,CAAC;AAEzD,OAAO,EAAC,WAAW,EAAC,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAC,uBAAuB,EAAE,UAAU,EAAiB,MAAM,UAAU,CAAC;AAE7E,wEAAwE;AACxE,wEAAwE;AACxE,kBAAkB;AAElB,2CAA2C;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,UAAU,KAAK,CAAC,IAAmB;IACvC,OAAO,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC;AAC/B,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,MAAM,UAAU,UAAU,CAAC,MAAuB;IAChD,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC;AAChC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0FG;AACH,MAAM,UAAU,eAAe,CAC3B,eAAoC,EACpC,OAAwB;IAC1B,IAAI,OAAO,IAAI,IAAI,EAAE;QACnB,OAAO,GAAG,EAAE,CAAC;KACd;IACD,OAAO,uBAAuB,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;AAC3D,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,KAAK,CAAC,MAAmB;IACvC,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC;AACvB,CAAC;AAED,MAAM,UAAU,2BAA2B,CACvC,cAAsB,EACtB,mBAA4C;IAC9C,2BAA2B,CAAC,2BAA2B,CACnD,cAAc,EAAE,mBAAmB,CAAC,CAAC;AAC3C,CAAC","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/**\n * Exported functions.\n */\n\nimport {io} from '@tensorflow/tfjs-core';\n\nimport {BaseCallbackConstructor, CallbackConstructorRegistry} from './base_callbacks';\nimport {ContainerArgs} from './engine/container';\nimport {Input, InputConfig,} from './engine/input_layer';\nimport {SymbolicTensor} from './engine/topology';\nimport {LayersModel} from './engine/training';\nimport {loadLayersModelInternal, Sequential, SequentialArgs} from './models';\n\n// TODO(cais): Add doc string to all the public static functions in this\n//   class; include exectuable JavaScript code snippets where applicable\n//   (b/74074458).\n\n// LayersModel and related factory methods.\n\n/**\n * A model is a data structure that consists of `Layers` and defines inputs\n * and outputs.\n *\n * The key difference between `tf.model` and `tf.sequential` is that\n * `tf.model` is more generic, supporting an arbitrary graph (without\n * cycles) of layers. `tf.sequential` is less generic and supports only a linear\n * stack of layers.\n *\n * When creating a `tf.LayersModel`, specify its input(s) and output(s). Layers\n * are used to wire input(s) to output(s).\n *\n * For example, the following code snippet defines a model consisting of\n * two `dense` layers, with 10 and 4 units, respectively.\n *\n * ```js\n * // Define input, which has a size of 5 (not including batch dimension).\n * const input = tf.input({shape: [5]});\n *\n * // First dense layer uses relu activation.\n * const denseLayer1 = tf.layers.dense({units: 10, activation: 'relu'});\n * // Second dense layer uses softmax activation.\n * const denseLayer2 = tf.layers.dense({units: 4, activation: 'softmax'});\n *\n * // Obtain the output symbolic tensor by applying the layers on the input.\n * const output = denseLayer2.apply(denseLayer1.apply(input));\n *\n * // Create the model based on the inputs.\n * const model = tf.model({inputs: input, outputs: output});\n *\n * // The model can be used for training, evaluation and prediction.\n * // For example, the following line runs prediction with the model on\n * // some fake data.\n * model.predict(tf.ones([2, 5])).print();\n * ```\n * See also:\n *   `tf.sequential`, `tf.loadLayersModel`.\n *\n * @doc {heading: 'Models', subheading: 'Creation'}\n */\nexport function model(args: ContainerArgs): LayersModel {\n  return new LayersModel(args);\n}\n\n/**\n * Creates a `tf.Sequential` model.  A sequential model is any model where the\n * outputs of one layer are the inputs to the next layer, i.e. the model\n * topology is a simple 'stack' of layers, with no branching or skipping.\n *\n * This means that the first layer passed to a `tf.Sequential` model should have\n * a defined input shape. What that means is that it should have received an\n * `inputShape` or `batchInputShape` argument, or for some type of layers\n * (recurrent, Dense...) an `inputDim` argument.\n *\n * The key difference between `tf.model` and `tf.sequential` is that\n * `tf.sequential` is less generic, supporting only a linear stack of layers.\n * `tf.model` is more generic and supports an arbitrary graph (without\n * cycles) of layers.\n *\n * Examples:\n *\n * ```js\n * const model = tf.sequential();\n *\n * // First layer must have an input shape defined.\n * model.add(tf.layers.dense({units: 32, inputShape: [50]}));\n * // Afterwards, TF.js does automatic shape inference.\n * model.add(tf.layers.dense({units: 4}));\n *\n * // Inspect the inferred shape of the model's output, which equals\n * // `[null, 4]`. The 1st dimension is the undetermined batch dimension; the\n * // 2nd is the output size of the model's last layer.\n * console.log(JSON.stringify(model.outputs[0].shape));\n * ```\n *\n * It is also possible to specify a batch size (with potentially undetermined\n * batch dimension, denoted by \"null\") for the first layer using the\n * `batchInputShape` key. The following example is equivalent to the above:\n *\n * ```js\n * const model = tf.sequential();\n *\n * // First layer must have a defined input shape\n * model.add(tf.layers.dense({units: 32, batchInputShape: [null, 50]}));\n * // Afterwards, TF.js does automatic shape inference.\n * model.add(tf.layers.dense({units: 4}));\n *\n * // Inspect the inferred shape of the model's output.\n * console.log(JSON.stringify(model.outputs[0].shape));\n * ```\n *\n * You can also use an `Array` of already-constructed `Layer`s to create\n * a `tf.Sequential` model:\n *\n * ```js\n * const model = tf.sequential({\n *   layers: [tf.layers.dense({units: 32, inputShape: [50]}),\n *            tf.layers.dense({units: 4})]\n * });\n * console.log(JSON.stringify(model.outputs[0].shape));\n * ```\n *\n * @doc {heading: 'Models', subheading: 'Creation'}\n */\nexport function sequential(config?: SequentialArgs): Sequential {\n  return new Sequential(config);\n}\n\n/**\n * Load a model composed of Layer objects, including its topology and optionally\n * weights. See the Tutorial named \"How to import a Keras Model\" for usage\n * examples.\n *\n * This method is applicable to:\n *\n * 1. Models created with the `tf.layers.*`, `tf.sequential`, and\n * `tf.model` APIs of TensorFlow.js and later saved with the\n * `tf.LayersModel.save` method.\n * 2. Models converted from Keras or TensorFlow tf.keras using the\n * [tensorflowjs_converter](https://github.com/tensorflow/tfjs/tree/master/tfjs-converter).\n *\n * This mode is *not* applicable to TensorFlow `SavedModel`s or their converted\n * forms. For those models, use `tf.loadGraphModel`.\n *\n * Example 1. Load a model from an HTTP server.\n *\n * ```js\n * const model = await tf.loadLayersModel(\n *     'https://storage.googleapis.com/tfjs-models/tfjs/iris_v1/model.json');\n * model.summary();\n * ```\n *\n * Example 2: Save `model`'s topology and weights to browser [local\n * storage](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage);\n * then load it back.\n *\n * ```js\n * const model = tf.sequential(\n *     {layers: [tf.layers.dense({units: 1, inputShape: [3]})]});\n * console.log('Prediction from original model:');\n * model.predict(tf.ones([1, 3])).print();\n *\n * const saveResults = await model.save('localstorage://my-model-1');\n *\n * const loadedModel = await tf.loadLayersModel('localstorage://my-model-1');\n * console.log('Prediction from loaded model:');\n * loadedModel.predict(tf.ones([1, 3])).print();\n * ```\n *\n * Example 3. Saving `model`'s topology and weights to browser\n * [IndexedDB](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API);\n * then load it back.\n *\n * ```js\n * const model = tf.sequential(\n *     {layers: [tf.layers.dense({units: 1, inputShape: [3]})]});\n * console.log('Prediction from original model:');\n * model.predict(tf.ones([1, 3])).print();\n *\n * const saveResults = await model.save('indexeddb://my-model-1');\n *\n * const loadedModel = await tf.loadLayersModel('indexeddb://my-model-1');\n * console.log('Prediction from loaded model:');\n * loadedModel.predict(tf.ones([1, 3])).print();\n * ```\n *\n * Example 4. Load a model from user-selected files from HTML\n * [file input\n * elements](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/file).\n *\n * ```js\n * // Note: this code snippet will not work without the HTML elements in the\n * //   page\n * const jsonUpload = document.getElementById('json-upload');\n * const weightsUpload = document.getElementById('weights-upload');\n *\n * const model = await tf.loadLayersModel(\n *     tf.io.browserFiles([jsonUpload.files[0], weightsUpload.files[0]]));\n * ```\n *\n * @param pathOrIOHandler Can be either of the two formats\n *   1. A string path to the `ModelAndWeightsConfig` JSON describing\n *      the model in the canonical TensorFlow.js format. For file://\n *      (tfjs-node-only), http:// and https:// schemas, the path can be\n *      either absolute or relative.\n *   2. An `tf.io.IOHandler` object that loads model artifacts with its `load`\n *      method.\n * @param options Optional configuration arguments for the model loading,\n *   including:\n *   - `strict`: Require that the provided weights exactly match those required\n *     by the layers.  Default true.  Passing false means that both extra\n *     weights and missing weights will be silently ignored.\n *   - `onProgress`: A function of the signature `(fraction: number) => void',\n *     that can be used as the progress callback for the model loading.\n * @returns A `Promise` of `tf.LayersModel`, with the topology and weights\n *     loaded.\n *\n * @doc {heading: 'Models', subheading: 'Loading'}\n */\nexport function loadLayersModel(\n    pathOrIOHandler: string|io.IOHandler,\n    options?: io.LoadOptions): Promise<LayersModel> {\n  if (options == null) {\n    options = {};\n  }\n  return loadLayersModelInternal(pathOrIOHandler, options);\n}\n\n/**\n * Used to instantiate an input to a model as a `tf.SymbolicTensor`.\n *\n * Users should call the `input` factory function for\n * consistency with other generator functions.\n *\n * Example:\n *\n * ```js\n * // Defines a simple logistic regression model with 32 dimensional input\n * // and 3 dimensional output.\n * const x = tf.input({shape: [32]});\n * const y = tf.layers.dense({units: 3, activation: 'softmax'}).apply(x);\n * const model = tf.model({inputs: x, outputs: y});\n * model.predict(tf.ones([2, 32])).print();\n * ```\n *\n * Note: `input` is only necessary when using `model`. When using\n * `sequential`, specify `inputShape` for the first layer or use `inputLayer`\n * as the first layer.\n *\n * @doc {heading: 'Models', subheading: 'Inputs'}\n */\nexport function input(config: InputConfig): SymbolicTensor {\n  return Input(config);\n}\n\nexport function registerCallbackConstructor(\n    verbosityLevel: number,\n    callbackConstructor: BaseCallbackConstructor): void {\n  CallbackConstructorRegistry.registerCallbackConstructor(\n      verbosityLevel, callbackConstructor);\n}\n"]} |
\ | No newline at end of file |