11 |
12 | Learn about core concepts in TensorFlow.js such as tensors, operations, models, layers and training.
13 | Also learn a few useful tips about memory management and writing "tidy" code.
14 |
15 |
21 |
22 | This guide provides a number of resources for getting started with the different domains involved in programming with TensorFlow.js.
23 |
24 |
25 | ## Training Models
26 |
27 |
28 |
29 | This tutorial demonstrates building a small toy model completely from scratch using TensorFlow.js operations. We will fit a curve to some synthetic data that we generate using a polynomial function.
30 |
31 |
32 |
33 | This tutorial shows how to build a convolutional neural network to recognize
34 | handwritten digits in images (MNIST). We will use the TensorFlow.js layers API
35 | to construct, train, and evaluate the model.
36 |
37 |
38 |
39 | This tutorial explains how to train a neural network to make predictions from
40 | webcam data. We'll use those predictions to play [Pac-Man](https://en.wikipedia.org/wiki/Pac-Man)!
41 |
42 |
48 |
49 | This tutorial explains how to save `tf.Model`s to various destinations such as the web browser's Local Storage and load them back.
50 |
51 | ## Working with Pre-trained Models
52 |
53 |
58 |
59 | This tutorial explains how to convert and serve an existing TensorFlow SavedModel to run in the browser.
60 |
61 |
62 | ## Advanced Topics
63 |
64 |
65 |
66 | This tutorial explains how to create a custom WebGL operation that can be used alongside other Tensorflow.js operations.
67 |
--------------------------------------------------------------------------------
/themes/dljs/layout/partials/header.hbs:
--------------------------------------------------------------------------------
1 |
2 |
3 |
39 |
40 |
41 |
75 |
--------------------------------------------------------------------------------
/source/_data/api/0.12.5/tfjs-converter.json:
--------------------------------------------------------------------------------
1 | {
2 | "docs": {
3 | "headings": [
4 | {
5 | "name": "Models",
6 | "description": "",
7 | "subheadings": [
8 | {
9 | "name": "Classes",
10 | "symbols": [
11 | {
12 | "docInfo": {
13 | "heading": "Models",
14 | "subheading": "Classes"
15 | },
16 | "symbolName": "FrozenModel",
17 | "documentation": "A `FrozenModel` is a directed, acyclic graph of built from\nSavedModel GraphDef and allows inference exeuction.",
18 | "fileName": "#32",
19 | "githubUrl": "https://github.com/tensorflow/tfjs-converter/blob/v0.5.7/src/executor/frozen_model.ts#L32-L245",
20 | "methods": [],
21 | "isClass": true,
22 | "inheritsFrom": "tfc.InferenceModel"
23 | }
24 | ]
25 | },
26 | {
27 | "name": "Loading",
28 | "symbols": [
29 | {
30 | "docInfo": {
31 | "heading": "Models",
32 | "subheading": "Loading"
33 | },
34 | "symbolName": "loadFrozenModel",
35 | "paramStr": "(modelUrl, weightsManifestUrl, requestOption?)",
36 | "parameters": [
37 | {
38 | "name": "modelUrl",
39 | "documentation": "url for the model file generated by scripts/convert.py\nscript.",
40 | "type": "string",
41 | "optional": false,
42 | "isConfigParam": false
43 | },
44 | {
45 | "name": "weightsManifestUrl",
46 | "documentation": "",
47 | "type": "string",
48 | "optional": false,
49 | "isConfigParam": false
50 | },
51 | {
52 | "name": "requestOption",
53 | "documentation": "options for Request, which allows to send credentials\nand custom headers.",
54 | "type": "RequestInit",
55 | "optional": true,
56 | "isConfigParam": false
57 | }
58 | ],
59 | "returnType": "Promise",
60 | "documentation": "Load the frozen model through url.\n\nExample of loading the MobileNetV2 model and making a prediction with a zero\ninput.\n\n```js\nconst GOOGLE_CLOUD_STORAGE_DIR =\n 'https://storage.googleapis.com/tfjs-models/savedmodel/';\nconst MODEL_FILE_URL = 'mobilenet_v2_1.0_224/tensorflowjs_model.pb';\nconst WEIGHT_MANIFEST_FILE_URL =\n 'mobilenet_v2_1.0_224/weights_manifest.json';\nconst model = await tf.loadFrozenModel(MODEL_URL, WEIGHTS_URL);\nconst zeros = tf.zeros([1, 224, 224, 3]);\nmodel.predict(zeros);\n```",
61 | "fileName": "#272",
62 | "githubUrl": "https://github.com/tensorflow/tfjs-converter/blob/v0.5.7/src/executor/frozen_model.ts#L272-L278",
63 | "isFunction": true
64 | }
65 | ]
66 | }
67 | ]
68 | }
69 | ]
70 | },
71 | "docLinkAliases": {}
72 | }
--------------------------------------------------------------------------------
/source/_data/api/0.13.0/tfjs-converter.json:
--------------------------------------------------------------------------------
1 | {
2 | "docs": {
3 | "headings": [
4 | {
5 | "name": "Models",
6 | "description": "",
7 | "subheadings": [
8 | {
9 | "name": "Classes",
10 | "symbols": [
11 | {
12 | "docInfo": {
13 | "heading": "Models",
14 | "subheading": "Classes"
15 | },
16 | "symbolName": "FrozenModel",
17 | "documentation": "A `FrozenModel` is a directed, acyclic graph of built from\nSavedModel GraphDef and allows inference exeuction.",
18 | "fileName": "#32",
19 | "githubUrl": "https://github.com/tensorflow/tfjs-converter/blob/v0.6.0/src/executor/frozen_model.ts#L32-L260",
20 | "methods": [],
21 | "isClass": true,
22 | "inheritsFrom": "tfc.InferenceModel"
23 | }
24 | ]
25 | },
26 | {
27 | "name": "Loading",
28 | "symbols": [
29 | {
30 | "docInfo": {
31 | "heading": "Models",
32 | "subheading": "Loading"
33 | },
34 | "symbolName": "loadFrozenModel",
35 | "paramStr": "(modelUrl, weightsManifestUrl, requestOption?)",
36 | "parameters": [
37 | {
38 | "name": "modelUrl",
39 | "documentation": "url for the model file generated by scripts/convert.py\nscript.",
40 | "type": "string",
41 | "optional": false,
42 | "isConfigParam": false
43 | },
44 | {
45 | "name": "weightsManifestUrl",
46 | "documentation": "",
47 | "type": "string",
48 | "optional": false,
49 | "isConfigParam": false
50 | },
51 | {
52 | "name": "requestOption",
53 | "documentation": "options for Request, which allows to send credentials\nand custom headers.",
54 | "type": "RequestInit",
55 | "optional": true,
56 | "isConfigParam": false
57 | }
58 | ],
59 | "returnType": "Promise",
60 | "documentation": "Load the frozen model through url.\n\nExample of loading the MobileNetV2 model and making a prediction with a zero\ninput.\n\n```js\nconst GOOGLE_CLOUD_STORAGE_DIR =\n 'https://storage.googleapis.com/tfjs-models/savedmodel/';\nconst MODEL_URL = 'mobilenet_v2_1.0_224/tensorflowjs_model.pb';\nconst WEIGHTS_URL =\n 'mobilenet_v2_1.0_224/weights_manifest.json';\nconst model = await tf.loadFrozenModel(GOOGLE_CLOUD_STORAGE_DIR + MODEL_URL,\n GOOGLE_CLOUD_STORAGE_DIR + WEIGHTS_URL);\nconst zeros = tf.zeros([1, 224, 224, 3]);\nmodel.predict(zeros).print();\n```",
61 | "fileName": "#288",
62 | "githubUrl": "https://github.com/tensorflow/tfjs-converter/blob/v0.6.0/src/executor/frozen_model.ts#L288-L294",
63 | "isFunction": true
64 | }
65 | ]
66 | }
67 | ]
68 | }
69 | ]
70 | },
71 | "docLinkAliases": {}
72 | }
--------------------------------------------------------------------------------
/source/_data/api/0.13.3/tfjs-converter.json:
--------------------------------------------------------------------------------
1 | {
2 | "docs": {
3 | "headings": [
4 | {
5 | "name": "Models",
6 | "description": "",
7 | "subheadings": [
8 | {
9 | "name": "Classes",
10 | "symbols": [
11 | {
12 | "docInfo": {
13 | "heading": "Models",
14 | "subheading": "Classes"
15 | },
16 | "symbolName": "FrozenModel",
17 | "documentation": "A `FrozenModel` is a directed, acyclic graph of built from\nSavedModel GraphDef and allows inference exeuction.",
18 | "fileName": "#32",
19 | "githubUrl": "https://github.com/tensorflow/tfjs-converter/blob/v0.6.5/src/executor/frozen_model.ts#L32-L260",
20 | "methods": [],
21 | "isClass": true,
22 | "inheritsFrom": "tfc.InferenceModel"
23 | }
24 | ]
25 | },
26 | {
27 | "name": "Loading",
28 | "symbols": [
29 | {
30 | "docInfo": {
31 | "heading": "Models",
32 | "subheading": "Loading"
33 | },
34 | "symbolName": "loadFrozenModel",
35 | "paramStr": "(modelUrl, weightsManifestUrl, requestOption?)",
36 | "parameters": [
37 | {
38 | "name": "modelUrl",
39 | "documentation": "url for the model file generated by scripts/convert.py\nscript.",
40 | "type": "string",
41 | "optional": false,
42 | "isConfigParam": false
43 | },
44 | {
45 | "name": "weightsManifestUrl",
46 | "documentation": "",
47 | "type": "string",
48 | "optional": false,
49 | "isConfigParam": false
50 | },
51 | {
52 | "name": "requestOption",
53 | "documentation": "options for Request, which allows to send credentials\nand custom headers.",
54 | "type": "RequestInit",
55 | "optional": true,
56 | "isConfigParam": false
57 | }
58 | ],
59 | "returnType": "Promise",
60 | "documentation": "Load the frozen model through url.\n\nExample of loading the MobileNetV2 model and making a prediction with a zero\ninput.\n\n```js\nconst GOOGLE_CLOUD_STORAGE_DIR =\n 'https://storage.googleapis.com/tfjs-models/savedmodel/';\nconst MODEL_URL = 'mobilenet_v2_1.0_224/tensorflowjs_model.pb';\nconst WEIGHTS_URL =\n 'mobilenet_v2_1.0_224/weights_manifest.json';\nconst model = await tf.loadFrozenModel(GOOGLE_CLOUD_STORAGE_DIR + MODEL_URL,\n GOOGLE_CLOUD_STORAGE_DIR + WEIGHTS_URL);\nconst zeros = tf.zeros([1, 224, 224, 3]);\nmodel.predict(zeros).print();\n```",
61 | "fileName": "#288",
62 | "githubUrl": "https://github.com/tensorflow/tfjs-converter/blob/v0.6.5/src/executor/frozen_model.ts#L288-L294",
63 | "isFunction": true
64 | }
65 | ]
66 | }
67 | ]
68 | }
69 | ]
70 | },
71 | "docLinkAliases": {}
72 | }
--------------------------------------------------------------------------------
/source/faq/index.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: faq
3 | date: 2018-03-19 17:38:08
4 | bannerText: Frequently Asked Questions
5 | ---
6 |
7 | ## Does TensorFlow.js support Node.js?
8 |
9 | Yes! We recently released node.js bindings for TensorFlow. This allows the same JavaScript code to work on both the browser and node.js, while binding to the underlying TensorFlow C implementation in node. You can follow it's development [on GitHub](https://github.com/tensorflow/tfjs-node) or try out our [NPM package](https://www.npmjs.com/package/@tensorflow/tfjs-node)
10 |
11 | ## Can I import a TensorFlow or Keras model into the browser?
12 |
13 | Yes! We have two tutorials for importing TensorFlow models. One for the [TensorFlow SavedModel](https://github.com/tensorflow/tfjs-converter) format, and one for importing [Keras HDF5 models](../tutorials/import-keras.html).
14 |
15 | ## Can I export my model from the browser?
16 |
17 | Since Version 0.11.1, you can export the topology and weights of `tf.Model`s to, or load them back
18 | from, browser Local Storage and IndexedDB. You can also trigger downloading of `tf.Model`s as
19 | files or load `tf.Model`s from user-selected files in the browser. In addition, `tf.Model`s can be
20 | sent to HTTP servers through `multipart/form-data` requests. See the
21 | [tutorial page](../tutorials/model-save-load.html) for more details.
22 |
23 | We are currently working on these additional features for model import/export:
24 | * Exporting and importing models in Node.js
25 | * Exporting `tf.FrozenModel`s (i.e., models converted from TensorFlow `SavedModel`s).
26 |
27 | ## How does this relate to TensorFlow?
28 |
29 | TensorFlow.js has an API similar to the TensorFlow Python API, however it does not support all of the functionality of the TensorFlow Python API. We are working hard to achieve API parity where it makes sense but also strive to provide an idiomatic JS API.
30 |
31 | ## How does TensorFlow.js performance compare to the Python version?
32 |
33 | In our experience, for inference, TensorFlow.js with WebGL is 1.5-2x slower than TensorFlow Python with AVX. For training, we have seen small models train faster in the browser and large models train up to 10-15x slower in the browser, compared to TensorFlow Python with AVX.
34 |
35 | Please take a look at [this benchmark](https://github.com/tensorflow/tfjs-layers/blob/master/integration_tests/benchmarks/index.html) to get more detailed performance measurements.
36 |
37 | ## What is the difference between TensorFlow.js and deeplearn.js?
38 |
39 | TensorFlow.js is an ecosystem of JavaScript tools for machine learning that evolved from deeplearn.js. deeplearn.js is now called TensorFlow.js Core. TensorFlow.js also includes a Layers API—a higher level library for building machine learning models—as well as tools for automatically porting TensorFlow SavedModels and Keras HDF5 models.
40 |
41 | ## I still have some questions
42 |
43 | Please feel free to look at our [issues tracker](https://github.com/tensorflow/tfjs/issues) and file a bug there. We also have a community mailing list for people to ask questions, get technical help, and share what they are doing with TensorFlow.js! To keep up to date with TensorFlow.js news follow us on twitter or join the announcement only mailing list.
44 |
45 |
--------------------------------------------------------------------------------
/source/tutorials/import-keras.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: import-keras
3 | date: 2018-03-22 16:04:23
4 | ---
5 |
6 | # Importing a Keras model into TensorFlow.js
7 |
8 | Keras models (typically created via the Python API) may be saved in [one of several formats](https://keras.io/getting-started/faq/#how-can-i-save-a-keras-model). The "whole model" format can be converted to TensorFlow.js Layers format, which can be loaded directly into TensorFlow.js for inference or for further training.
9 |
10 | The target TensorFlow.js Layers format is a directory containing a `model.json` file and a set of sharded weight files in binary format. The `model.json` file contains both the model topology (aka "architecture" or "graph": a description of the layers and how they are connected) and a manifest of the weight files.
11 |
12 | ## Requirements
13 | The conversion procedure requires a Python environment; you may want to keep an isolated one using [pipenv](https://github.com/pypa/pipenv) or [virtualenv](https://virtualenv.pypa.io). To install the converter, use `pip install tensorflowjs`.
14 |
15 | Importing a Keras model into TensorFlow.js is a two-step process. First, convert an existing Keras model to TF.js Layers format, and then load it into TensorFlow.js.
16 |
17 | ## Step 1. Convert an existing Keras model to TF.js Layers format
18 |
19 | Keras models are usually saved via `model.save(filepath)`, which produces a single HDF5 (.h5) file containing both the model topology and the weights. To convert such a file to TF.js Layers format, run the following command, where _`path/to/my_model.h5`_ is the source Keras .h5 file and _`path/to/tfjs_target_dir`_ is the target output directory for the TF.js files:
20 |
21 |
22 | ```sh
23 | # bash
24 |
25 | tensorflowjs_converter --input_format keras \
26 | path/to/my_model.h5 \
27 | path/to/tfjs_target_dir
28 | ```
29 |
30 | ## Alternative: Use the Python API to export directly to TF.js Layers format
31 |
32 | If you have a Keras model in Python, you can export it directly to the TensorFlow.js Layers format as follows:
33 |
34 | ```py
35 | # Python
36 |
37 | import tensorflowjs as tfjs
38 |
39 | def train(...):
40 | model = keras.models.Sequential() # for example
41 | ...
42 | model.compile(...)
43 | model.fit(...)
44 | tfjs.converters.save_keras_model(model, tfjs_target_dir)
45 | ```
46 |
47 | ## Step 2: Load the model into TensorFlow.js
48 |
49 | Use a web server to serve the converted model files you generated in Step 1. Note that you may need to configure your server to [allow Cross-Origin Resource Sharing (CORS)](https://enable-cors.org/), in order to allow fetching the files in JavaScript.
50 |
51 | Then load the model into TensorFlow.js by providing the URL to the model.json file:
52 |
53 | ```js
54 | // JavaScript
55 |
56 | import * as tf from '@tensorflow/tfjs';
57 |
58 | const model = await tf.loadModel('https://foo.bar/tfjs_artifacts/model.json');
59 | ```
60 |
61 | Now the model is ready for inference, evaluation, or re-training. For instance, the loaded model can be immediately used to make a prediction:
62 |
63 | ```js
64 | // JavaScript
65 |
66 | const example = tf.fromPixels(webcamElement); // for example
67 | const prediction = model.predict(example);
68 | ```
69 |
70 | Many of the [TensorFlow.js Examples](https://github.com/tensorflow/tfjs-examples) take this approach, using pretrained models that have been converted and hosted on Google Cloud Storage.
71 |
72 | Note that you refer to the entire model using the `model.json` filename. `loadModel(...)` fetches `model.json`, and then makes additional HTTP(S) requests to obtain the sharded weight files referenced in the `model.json` weight manifest. This approach allows all of these files to be cached by the browser (and perhaps by additional caching servers on the internet), because the `model.json` and the weight shards are each smaller than the typical cache file size limit. Thus a model is likely to load more quickly on subsequent occasions.
73 |
74 | ## Supported features
75 |
76 | TensorFlow.js Layers currently only supports Keras models using standard Keras constructs.
77 | Models using unsupported ops or layers—e.g. custom layers, Lambda layers, custom losses, or custom metrics—cannot be automatically imported, because they depend on Python code that cannot be reliably translated into JavaScript.
78 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # js.tensorflow.org
2 |
3 | This repo is for the website for TensorFlow.js. The site is built using Hexo (a static site generator) that puts static assets in to the `public` folder.
4 |
5 | ## Development Setup
6 |
7 | You need node.js, yarn, and git to use this repo effectively. Note that it clones the repos for tfjs-core and tfjs-layers (as git submodules) in order to build API docs.
8 |
9 | After checking out this repo run
10 |
11 | ```
12 | yarn prep
13 | ```
14 |
15 | This will download the two git submodules (or if you have already downloaded them before **will pull down changes from master**) and then install the project dependencies. `yarn prep` does the following: ``. Once this is done run
16 |
17 | ```
18 | yarn serve
19 | ```
20 |
21 | To start a dev server for the site. You should be able to make changes to the site and see them reflected in the dev server
22 |
23 | When you pull new commits from git you should run `yarn prep` again.
24 |
25 | ## Making Changes
26 |
27 | There are two broad classes of changes you might want to make, site content/design and API documentation changes.
28 |
29 | ### Site Content/Design
30 |
31 | Page layouts are stored in a custom hexo theme in the `themes/dljs` folder. This is also where JavaScript that will be included in pages is stored. Page content is written in markdown and stored in the `source` folder (though pages with complex layout define most of their content in a layout file).
32 |
33 | Changing files in these two locations should immediately be reflected in the dev server when using `yarn serve`.
34 |
35 | ### API Documentation
36 |
37 | Updating the API docs is a bit more involved as they are built from the sources of tfjs-core and tfjs-layers. The template for api docs is `api.hbs` and each version of the docs has a corresponding folder in `_data`. Files in `_data` are automatically generated and shouldn't be edited.
38 |
39 | To edit the docs and see changes reflected in the site you can edit the repositories that are located in `libs`. Note that these submodules behave like *regular git repositories* and have an origin pointing to the canonical repository for `tfjs-core` and `tfjs-layers`. Making an API doc change involves making a commit to the subproject repo and to this one. You may need to add a new git remote in the submodule if you want to make a PR from a fork of tfjs-website repo. Make sure to do `git checkout master` or make a new branch for your changes.
40 |
41 | There are two ways to regenerate the docs json.
42 |
43 | During local development (e.g. if you have changes in libs), run:
44 |
45 | ```
46 | yarn build-api
47 | ```
48 |
49 | This will build a version of the api known as `local`. It will be accessible at `http://localhost:4000/api/local/`. This content is not checked in, nor is it linked to
50 | anywhere on the site, but it is suitable for testing changes to docs.
51 |
52 | Once the your changes have been accepted into the repo in question (either tfjs-core or tfjs-layers), you can run `yarn prep` again in this repo (tfjs-website) to sync everything up (pull the most recent commits from master for each). You can then commit the **new submodule info** in the tfjs-website repo.
53 |
54 | Once you are done you can do a full production build of the site using:
55 |
56 | ```
57 | yarn build-prod
58 | ```
59 |
60 | Note that this command will do a number of things that will **modify your working tree**. Its purpose is to build a new production build suitable for deployment to the site, as such it only builds docs that are in a released version of tfjs-layers and tfjs-core. The version it builds is driven off of the `@tensorflow/tfjs` dependency in package.json. **Build prod cannot build your local doc changes into the site**. To do this it will do a checkout of `libs/tfjs-core` and `libs/tfjs-layers` that correspond to the dependencies listed for `@tensorflow/tfjs`. This will modify your working tree (in libs).
61 |
62 | In both these cases starting the dev server and refreshing the page should allow you to see changes.
63 |
64 | In addition to `http://localhost:4000/api/local/`, the build also provides `http://localhost:4000/api/latest/` which points to the last **production** version of the docs that have been built. `latest` will never point to `local`
65 |
66 |
67 | ### Deployment
68 |
69 | To build the site run
70 |
71 | ```
72 | yarn build-prod
73 | ```
74 |
75 | Deployment instructions are available internally. Contact @tafsiri for access. (Googlers only)
76 |
--------------------------------------------------------------------------------
/source/_data/api/0.14.1/tfjs-converter.json:
--------------------------------------------------------------------------------
1 | {
2 | "docs": {
3 | "headings": [
4 | {
5 | "name": "Models",
6 | "description": "",
7 | "subheadings": [
8 | {
9 | "name": "Classes",
10 | "symbols": [
11 | {
12 | "docInfo": {
13 | "heading": "Models",
14 | "subheading": "Classes"
15 | },
16 | "symbolName": "FrozenModel",
17 | "documentation": "A `tf.FrozenModel` is a directed, acyclic graph of built from\nSavedModel GraphDef and allows inference exeuction.",
18 | "fileName": "#35",
19 | "githubUrl": "https://github.com/tensorflow/tfjs-converter/blob/v0.7.1/src/executor/frozen_model.ts#L35-L265",
20 | "methods": [],
21 | "isClass": true,
22 | "inheritsFrom": "tfc.InferenceModel"
23 | }
24 | ]
25 | },
26 | {
27 | "name": "Loading",
28 | "symbols": [
29 | {
30 | "docInfo": {
31 | "heading": "Models",
32 | "subheading": "Loading"
33 | },
34 | "symbolName": "loadFrozenModel",
35 | "paramStr": "(modelUrl, weightsManifestUrl, requestOption?)",
36 | "parameters": [
37 | {
38 | "name": "modelUrl",
39 | "documentation": "url for the model file generated by scripts/convert.py\nscript.",
40 | "type": "string",
41 | "optional": false,
42 | "isConfigParam": false
43 | },
44 | {
45 | "name": "weightsManifestUrl",
46 | "documentation": "",
47 | "type": "string",
48 | "optional": false,
49 | "isConfigParam": false
50 | },
51 | {
52 | "name": "requestOption",
53 | "documentation": "options for Request, which allows to send credentials\nand custom headers.",
54 | "type": "RequestInit",
55 | "optional": true,
56 | "isConfigParam": false
57 | }
58 | ],
59 | "returnType": "Promise",
60 | "documentation": "Load the frozen model through url.\n\nExample of loading the MobileNetV2 model and making a prediction with a zero\ninput.\n\n```js\nconst GOOGLE_CLOUD_STORAGE_DIR =\n 'https://storage.googleapis.com/tfjs-models/savedmodel/';\nconst MODEL_URL = 'mobilenet_v2_1.0_224/tensorflowjs_model.pb';\nconst WEIGHTS_URL =\n 'mobilenet_v2_1.0_224/weights_manifest.json';\nconst model = await tf.loadFrozenModel(GOOGLE_CLOUD_STORAGE_DIR + MODEL_URL,\n GOOGLE_CLOUD_STORAGE_DIR + WEIGHTS_URL);\nconst zeros = tf.zeros([1, 224, 224, 3]);\nmodel.predict(zeros).print();\n```",
61 | "fileName": "#293",
62 | "githubUrl": "https://github.com/tensorflow/tfjs-converter/blob/v0.7.1/src/executor/frozen_model.ts#L293-L299",
63 | "isFunction": true
64 | },
65 | {
66 | "docInfo": {
67 | "heading": "Models",
68 | "subheading": "Loading"
69 | },
70 | "symbolName": "loadTfHubModule",
71 | "paramStr": "(tfhubModuleUrl, requestOption?)",
72 | "parameters": [
73 | {
74 | "name": "tfhubModuleUrl",
75 | "documentation": "",
76 | "type": "string",
77 | "optional": false,
78 | "isConfigParam": false
79 | },
80 | {
81 | "name": "requestOption",
82 | "documentation": "options for Request, which allows to send credentials\nand custom headers.",
83 | "type": "RequestInit",
84 | "optional": true,
85 | "isConfigParam": false
86 | }
87 | ],
88 | "returnType": "Promise",
89 | "documentation": "Load the frozen model hosted by TF-Hub.\n\nExample of loading the MobileNetV2 model and making a prediction with a zero\ninput.\n\n```js\nconst TFHUB_MOBILENET =\n 'https://tfhub.dev/google/imagenet/mobilenet_v2_140_224/classification/2';\nconst model = await tf.loadTfHubModule(TFHUB_MOBILENET);\nconst zeros = tf.zeros([1, 224, 224, 3]);\nmodel.predict(zeros).print();\n```",
90 | "fileName": "#321",
91 | "githubUrl": "https://github.com/tensorflow/tfjs-converter/blob/v0.7.1/src/executor/frozen_model.ts#L321-L330",
92 | "isFunction": true
93 | }
94 | ]
95 | }
96 | ]
97 | }
98 | ]
99 | },
100 | "docLinkAliases": {}
101 | }
--------------------------------------------------------------------------------
/themes/dljs/source/js/codeSnippets.js:
--------------------------------------------------------------------------------
1 | // There isn't a standard way to get line numbers reliably, we attempt to
2 | // parse out a few formats we have seen.
3 | // Note we do not use e.lineNumber as it is not reliable (especially in the
4 | // context of eval)
5 | function getLineNumber(error) {
6 | try {
7 | // firefox
8 | const firefoxRegex = /eval:(\d+):\d+/;
9 | if (error.stack.match(firefoxRegex)) {
10 | const res = error.stack.match(firefoxRegex);
11 | return parseInt(res[1], 10);
12 | }
13 |
14 | // chrome
15 | const chromeRegex = /eval.+:(\d+):\d+/;
16 | if (error.stack.match(chromeRegex)) {
17 | const res = error.stack.match(chromeRegex);
18 | return parseInt(res[1], 10);
19 | }
20 |
21 | } catch (e) {
22 | return;
23 | }
24 |
25 | // We found nothing
26 | return;
27 | }
28 |
29 | async function executeCodeSnippet(consoleLogElement, codeSnippet) {
30 | consoleLogElement.innerText = '';
31 | var oldLog = console.log;
32 | console.log = function(...values) {
33 | let logStrs = [];
34 | for (let i = 0; i < values.length; i++) {
35 | const value = values[i];
36 |
37 | let logStr;
38 | if (value.toString == null) {
39 | logStr = value;
40 | } else {
41 | const toStr = value.toString();
42 |
43 | if (toStr === '[object Object]') {
44 | logStr = JSON.stringify(value, null, 2);
45 | } else {
46 | logStr = toStr;
47 | }
48 | logStrs.push(logStr);
49 | }
50 | }
51 | consoleLogElement.innerHTML += logStrs.join(' ') + '\n';
52 | };
53 |
54 | function reportError(e) {
55 | var errorMessage = '\n
82 | {{!-- Footer --}}
83 | {{> footer }}
84 |
85 |
126 |
127 |
128 |
--------------------------------------------------------------------------------
/source/tutorials/custom-webgl-op.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: custom-webgl-op
3 | date: 2018-08-02 16:07:20
4 | ---
5 |
6 | ### Sections
7 | ---
8 | * [Creating custom WebGL operations](#tutorial)
9 | * [GLSL functions provided by Tensorflow.js](#stdlib)
10 |
11 |
12 | # Creating custom WebGL operations
13 |
14 | To define custom WebGL operations, all we have to do is create an object that implements `tf.webgl.GPGPUProgram`.
15 |
16 | This interface is defined as:
17 | ```ts
18 | interface GPGPUProgram {
19 | variableNames: string[];
20 | outputShape: number[];
21 | userCode: string;
22 | supportsBroadcasting?: boolean;
23 | }
24 | ```
25 |
26 | For a contrived example, lets implement an operation that computes `f(x) = x * x + x`.
27 |
28 | The GLSL code for this would be:
29 | ```glsl
30 | void main() {
31 | float x = getXAtOutCoords();
32 | float value = x * x + x;
33 | setOutput(value);
34 | }
35 | ```
36 |
37 | where `getXAtOutCoords` and `setOutput` are [provided by Tensorflow.js](#stdlib) to the shader.
38 | Note that the main function is called for each value in the output tensor.
39 |
40 |
41 | The full GPGPUProgram definition would be:
42 | ```js
43 | const squareAndAddKernel = inputShape => ({
44 | variableNames: ['X'],
45 | outputShape: inputShape.slice(),
46 | userCode: `
47 | void main() {
48 | float x = getXAtOutCoords();
49 | float value = x * x + x;
50 | setOutput(value);
51 | }
52 | `
53 | })
54 | ```
55 |
56 | To run this op, you would use `tf.ENV.backend.compileAndRun(program: GPGPUProgram, inputs: tf.Tensor[]): tf.Tensor`. Note that this will be undefined if the backend isn't the webgl backend.
57 |
58 | ```js
59 | const x = tf.tensor([1, 2, 3, 4]);
60 | const program = squareAndAddKernel(x.shape);
61 |
62 | const result = tf.ENV.backend.compileAndRun(program, [x]);
63 | ```
64 |
65 | However, we probably also want to define the gradients for this op, so that gradients can be backpropagated through it.
66 |
67 | To do this, we use [tf.customGrad](https://js.tensorflow.org/api/latest/#customGrad).
68 |
69 | ```js
70 | const squareAndAddBackpropKernel = inputShape => ({
71 | variableNames: ['X'],
72 | outputShape: inputShape.slice(),
73 | userCode: `
74 | void main() {
75 | float x = getXAtOutCoords();
76 | float value = 2.0 * x + 1.0;
77 | setOutput(value);
78 | }
79 | `
80 | });
81 |
82 |
83 | const squareAndAdd = tf.customGrad(x => {
84 | const backend = tf.ENV.backend;
85 | const program = squareAndAddKernel(x.shape);
86 | const backpropProgram = squareAndAddBackpropKernel(x.shape);
87 |
88 | const value = backend.compileAndRun(program, [x]);
89 |
90 | const gradFunc = dy =>
91 | [backend.compileAndRun(backpropProgram, [x]).mul(dy)];
92 | return {value, gradFunc};
93 | });
94 | ```
95 |
96 | We can then use this as:
97 |
98 | ```js
99 | const x = tf.tensor([1, 2, 3, 4]);
100 |
101 | const value = squareAndAdd(x);
102 |
103 | const grads = tf.grad(x => squareAndAdd(x));
104 | const dx = grads(x);
105 |
106 | // value == [2, 6, 12, 20]
107 | // dx == [3, 5, 7, 9]
108 | ```
109 |
110 | Or more concisely:
111 |
112 | ```js
113 | const {value, grad} = tf.valueAndGrad(squareAndAdd)(x);
114 | ```
115 |
116 | # GLSL functions generated by Tensorflow.js
117 |
118 | Tensorflow.js generates functions you can use to read from the input tensors and write to the output tensor, as well as additional numeric utility functions. These are prepended to your code by the [Shader Compiler](https://github.com/tensorflow/tfjs-core/blob/master/src/kernels/webgl/shader_compiler.ts).
119 |
120 | * `void setOutput(float value)`
121 |
122 | * Sets the output value for the coordinate where the fragment shader is run on (equivalent to `gl_FragCoord = vec4(value, 0.0, 0.0, 0.0)`).
123 |
124 | * `indexType getOutputCoords()`
125 |
126 | * Where `indexType` is one of `int | ivec2 | ivec3 | ivec4 | ivec5 | ivec6`.
127 |
128 | * Returns an `int` if the output tensor is rank-0 or rank-1, otherwise returns an `ivecN` where N == rank. This is the coordinate of the cell in the output tensor this program will write to.
129 |
130 |
131 | * Tensorflow.js generates GLSL functions to sample from the input tensors. These are of the form:
132 |
133 | ```glsl
134 | float get{VarName}AtOutCoords()
135 |
136 | float get{VarName}() // rank-0 input
137 | float get{VarName}(int x) // rank-1 input
138 | float get{VarName}(int x, int y) // rank-2 input
139 | float get{VarName}(int x, int y, int z) // rank-3 input
140 | float get{VarName}(int x, int y, int z, int w) // rank-4 input
141 | // continue as above for rank-5 & rank-6
142 |
143 | // For example, for rank-2 Tensor named x:
144 | // float getX(int x, int y)
145 | ```
146 |
147 | Where `VarName` is a variable name as defined in the `variableNames` array of your `GPGPUProgram` in **with the first letter captialised**.
148 | This means that for a variable named `matrix`, TF.js will generate `getMatrix`.
149 |
150 | Many of these functions are depended on the rank of the input tensors, so in your `GPGPUProgram` you'll often want to emit different code based on the ranks of the `inputShape`s.
151 | For instance, if `get{VarName}AtOutCoords()` didn't exist, we might have written `squareAndAddKernel` as:
152 |
153 | ```js
154 | const squareAndAddKernel = inputShape => ({
155 | const variableNames = ['X']
156 | const outputShape = inputShape.slice()
157 | const rank = outputShape.length
158 |
159 | const coordSnippets = ['',
160 | 'coords',
161 | 'coords.x, coords.y',
162 | 'coords.x, coords.y, coords.z',
163 | 'coords.x, coords.y, coords.z, coords.w']
164 |
165 | const coordType = rank < 2 ? 'int' : `ivec${rank}`
166 |
167 | const userCode = `
168 | void main() {
169 | ${coordType} coords = getOutputCoords();
170 | float x = getX(${coordSnippets[rank]});
171 | setOutput(x * x + x);
172 | }`
173 |
174 | return {variableNames, outputShape, userCode}
175 | })
176 | ```
177 |
178 | * `bool isNaN(float val)`
179 |
180 | * `true` if val is a `NaN`, otherwise false.
181 |
182 | * `int round(float value)`
183 |
184 | * Round `value` to the nearest integer.
185 |
186 | * `int imod(int x, int y)`
187 |
188 | * Same as `float mod(float x, float y)` but for ints, since GLSL doesn't provide us one.
189 |
190 | * `float random(float seed)`
191 |
192 | * Returns a pseudo-random number, based on Dave Hoskins's formula in https://www.shadertoy.com/view/4djSRW.
193 |
194 |
--------------------------------------------------------------------------------
/source/tutorials/import-saved-model.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: import-saved-model
3 | date: 2018-06-13 12:33:23
4 | ---
5 |
6 | # Importing a TensorFlow GraphDef based Models into TensorFlow.js
7 |
8 | TensorFlow GraphDef based models (typically created via the Python API) may be saved in one of following formats:
9 | 1. TensorFlow [SavedModel](https://www.tensorflow.org/programmers_guide/saved_model#overview_of_saving_and_restoring_models)
10 | 2. [Frozen Model](https://www.tensorflow.org/mobile/prepare_models#how_do_you_get_a_model_you_can_use_on_mobile)
11 | 3. [Session Bundle](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/contrib/session_bundle/README.md)
12 | 4. [Tensorflow Hub module](https://www.tensorflow.org/hub/)
13 |
14 | All of above formats can be converted by [TensorFlow.js converter](https://github.com/tensorflow/tfjs-converter) to TensorFlow.js web friendly format, which can be loaded directly into TensorFlow.js for inference.
15 |
16 | (Note: TensorFlow has deprecated session bundle format, please migrate your models to SavedModel format.)
17 |
18 | ## Requirements
19 | The conversion procedure requires a Python environment; you may want to keep an isolated one using [pipenv](https://github.com/pypa/pipenv) or [virtualenv](https://virtualenv.pypa.io). To install the converter, and run following:
20 |
21 | ```bash
22 | pip install tensorflowjs
23 | ```
24 |
25 | Importing a TensorFlow models into TensorFlow.js is a two-step process. First, convert an existing model to TensorFlow.js web format, and then load it into TensorFlow.js.
26 |
27 | ## Step 1. Convert an existing TensorFlow model to TensorFlow.js Web format
28 |
29 | Run the converter script provided by the pip package:
30 |
31 | Usage:
32 | SavedModel example:
33 |
34 | ```bash
35 | tensorflowjs_converter \
36 | --input_format=tf_saved_model \
37 | --output_node_names='MobilenetV1/Predictions/Reshape_1' \
38 | --saved_model_tags=serve \
39 | /mobilenet/saved_model \
40 | /mobilenet/web_model
41 | ```
42 |
43 | Frozen model example:
44 |
45 | ```bash
46 | tensorflowjs_converter \
47 | --input_format=tf_frozen_model \
48 | --output_node_names='MobilenetV1/Predictions/Reshape_1' \
49 | /mobilenet/frozen_model.pb \
50 | /mobilenet/web_model
51 | ```
52 |
53 | Session bundle model example:
54 |
55 | ```bash
56 | tensorflowjs_converter \
57 | --input_format=tf_session_bundle \
58 | --output_node_names='MobilenetV1/Predictions/Reshape_1' \
59 | /mobilenet/session_bundle \
60 | /mobilenet/web_model
61 | ```
62 |
63 | Tensorflow Hub module example:
64 |
65 | ```bash
66 | tensorflowjs_converter \
67 | --input_format=tf_hub \
68 | 'https://tfhub.dev/google/imagenet/mobilenet_v1_100_224/classification/1' \
69 | /mobilenet/web_model
70 | ```
71 |
72 | |Positional Arguments | Description |
73 | |---|---|
74 | |`input_path` | Full path of the saved model directory, session bundle directory, frozen model file or TensorFlow Hub module handle or path.|
75 | |`output_path` | Path for all output artifacts.|
76 |
77 | | Options | Description
78 | |---|---|
79 | |`--input_format` | The format of input model, use tf_saved_model for SavedModel, tf_frozen_model for frozen model, tf_session_bundle for session bundle, tf_hub for TensorFlow Hub module and keras for Keras HDF5. |
80 | |`--output_node_names`| The names of the output nodes, separated by commas.|
81 | |`--saved_model_tags` | Only applicable to SavedModel conversion, Tags of the MetaGraphDef to load, in comma separated format. Defaults to `serve`.|
82 | |`--signature_name` | Only applicable to TensorFlow Hub module conversion, signature to load. Defaults to `default`. See https://www.tensorflow.org/hub/common_signatures/.|
83 |
84 | Use following command to get the detail help message:
85 |
86 | ```bash
87 | tensorflowjs_converter --help
88 | ```
89 |
90 | ### Converter generated files
91 |
92 | The conversion script above produces 3 types of files:
93 |
94 | * `web_model.pb` (the dataflow graph)
95 | * `weights_manifest.json` (weight manifest file)
96 | * `group1-shard\*of\*` (collection of binary weight files)
97 |
98 | For example, here is the MobileNet model converted and served in
99 | following location:
100 |
101 | ```html
102 | https://storage.cloud.google.com/tfjs-models/savedmodel/mobilenet_v1_1.0_224/optimized_model.pb
103 | https://storage.cloud.google.com/tfjs-models/savedmodel/mobilenet_v1_1.0_224/weights_manifest.json
104 | https://storage.cloud.google.com/tfjs-models/savedmodel/mobilenet_v1_1.0_224/group1-shard1of5
105 | ...
106 | https://storage.cloud.google.com/tfjs-models/savedmodel/mobilenet_v1_1.0_224/group1-shard5of5
107 | ```
108 |
109 | ## Step 2: Loading and running in the browser
110 |
111 | 1. Install the tfjs-converter npm package
112 |
113 | `yarn add @tensorflow/tfjs` or `npm install @tensorflow/tfjs`
114 |
115 | 2. Instantiate the [FrozenModel class](https://github.com/tensorflow/tfjs-converter/blob/master/src/executor/frozen_model.ts) and run inference.
116 |
117 | ```js
118 | import * as tf from '@tensorflow/tfjs';
119 | import {loadFrozenModel} from '@tensorflow/tfjs-converter';
120 |
121 | const MODEL_URL = 'https://.../mobilenet/web_model.pb';
122 | const WEIGHTS_URL = 'https://.../mobilenet/weights_manifest.json';
123 |
124 | const model = await loadFrozenModel(MODEL_URL, WEIGHTS_URL);
125 | const cat = document.getElementById('cat');
126 | model.execute({input: tf.fromPixels(cat)});
127 | ```
128 |
129 | Check out our working [MobileNet demo](https://github.com/tensorflow/tfjs-converter/tree/master/demo/mobilenet).
130 |
131 | If your server requests credentials for accessing the model files, you can provide the optional RequestOption param, which will be directly passed to the fetch function call.
132 |
133 | ```js
134 | const model = await loadFrozenModel(MODEL_URL, WEIGHTS_URL,
135 | {credentials: 'include'});
136 | ```
137 |
138 | Please see [fetch() documentation](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch) for details.
139 |
140 | ## Supported operations
141 |
142 | Currently TensorFlow.js only supports a limited set of TensorFlow Ops. See the
143 | [full list](https://github.com/tensorflow/tfjs-converter/blob/master/docs/supported_ops.md).
144 | If your model uses any unsupported ops, the `tensorflowjs_converter` script will fail and
145 | produce a list of the unsupported ops in your model. Please file [issues](https://github.com/tensorflow/tfjs/issues) to let us
146 | know what ops you need support for.
147 |
148 | ## Loading the weights only
149 |
150 | If you prefer to load the weights only, you can use follow code snippet.
151 |
152 | ```js
153 | import * as tf from '@tensorflow/tfjs';
154 |
155 | const weightManifestUrl = "https://example.org/model/weights_manifest.json";
156 |
157 | const manifest = await fetch(weightManifestUrl);
158 | this.weightManifest = await manifest.json();
159 | const weightMap = await tf.io.loadWeights(
160 | this.weightManifest, "https://example.org/model");
161 |
--------------------------------------------------------------------------------
/source/demos/index.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: all-demos
3 | align: center
4 | date: 2018-12-10 10:38:08
5 | bannerText: All Demos
6 | ---
7 |
8 | {% raw %}
9 |
10 |
156 | A collection of over 15 short examples
157 | of different deep learning tasks. These examples
158 | can be great starting points for your own projects.
159 |
160 | Also check out the gallery
161 | to see what others in
162 | the community have created with TensorFlow.js.
163 |
We have utility functions for common cases like Scalar, 1D,",
12 | "2D, 3D and 4D tensors, as well a number of functions to initialize",
13 | "tensors in ways useful for machine learning.
TensorFlow.js provides several operations",
34 | "to slice or extract parts of a tensor, or join multiple",
35 | "tensors together."]
36 | }
37 | ]
38 | },
39 | {
40 | "name": "Models",
41 | "description": ["
Models are one of the primary abstractions used in",
42 | "TensorFlow.js Layers. Models can be trained, evaluated, and used",
43 | "for prediction. A model's state (topology, and optionally, trained",
44 | "weights) can be restored from various formats.
",
45 | "
Models are a collection of Layers, see Model Creation for",
46 | "for details about how Layers can be connected.
Sequential — Easiest, works if the models is a",
52 | "simple stack of each layer's input resting on the top of the",
53 | "previous layer's output.
",
54 | "
Model — Offers more control if the layers need to be",
55 | "wired together in graph-like ways — multiple 'towers',",
56 | "layers that skip a layer, etc.
Layers are the primary building block for ",
72 | "constructing a Model. Each layer will typically perform some",
73 | "computation to transform its input to its output.
",
74 | "
Layers will automatically take care of creating and initializing",
75 | "the various internal variables/weights they need to function.
To perform mathematical computation on Tensors, we use",
114 | "operations. Tensors are immutable, so all operations always return",
115 | "new Tensors and never modify input Tensors.
We also provide an API to do perform training, and",
126 | "compute gradients. We compute gradients eagerly, users provide a function",
127 | "that is a combination of operations and we automatically differentiate",
128 | "that function's output with respect to its inputs.",
129 | "
For those familiar with TensorFlow, the API we expose exactly mirrors",
130 | "the TensorFlow Eager API.",
131 | "
TensorFlow.js can run mathematical operations on",
150 | "different backends. Currently, we support WebGL and JavaScript",
151 | "CPU. By default, we choose the 'best' backend available, but",
152 | "allow users to customize their backend.
Constraints are added to attributes",
158 | "of a Layer (such as weights, kernels, or biases) at",
159 | "construction time to clamp, or otherwise enforce an allowed range,",
160 | "of values for different components of the Layer.
Regularizers can be attached to various components",
173 | "of a Layer to add a 'scoring' function to help drive weights, or ",
174 | "other trainable values, away from excessively large values. They're",
175 | "typically used to promote a notion that a 'simpler' model is better",
176 | "than a complicated model, assuming equal performance.
We have utility functions for common cases like Scalar, 1D,",
12 | "2D, 3D and 4D tensors, as well a number of functions to initialize",
13 | "tensors in ways useful for machine learning.
TensorFlow.js provides several operations",
34 | "to slice or extract parts of a tensor, or join multiple",
35 | "tensors together."]
36 | }
37 | ]
38 | },
39 | {
40 | "name": "Models",
41 | "description": ["
Models are one of the primary abstractions used in",
42 | "TensorFlow.js Layers. Models can be trained, evaluated, and used",
43 | "for prediction. A model's state (topology, and optionally, trained",
44 | "weights) can be restored from various formats.
",
45 | "
Models are a collection of Layers, see Model Creation for",
46 | "details about how Layers can be connected.
Sequential — Easiest, works if the models is a",
52 | "simple stack of each layer's input resting on the top of the",
53 | "previous layer's output.
",
54 | "
Model — Offers more control if the layers need to be",
55 | "wired together in graph-like ways — multiple 'towers',",
56 | "layers that skip a layer, etc.
Layers are the primary building block for ",
72 | "constructing a Model. Each layer will typically perform some",
73 | "computation to transform its input to its output.
",
74 | "
Layers will automatically take care of creating and initializing",
75 | "the various internal variables/weights they need to function.
To perform mathematical computation on Tensors, we use",
118 | "operations. Tensors are immutable, so all operations always return",
119 | "new Tensors and never modify input Tensors.
We also provide an API to do perform training, and",
130 | "compute gradients. We compute gradients eagerly, users provide a function",
131 | "that is a combination of operations and we automatically differentiate",
132 | "that function's output with respect to its inputs.",
133 | "
For those familiar with TensorFlow, the API we expose exactly mirrors",
134 | "the TensorFlow Eager API.",
135 | "
TensorFlow.js can run mathematical operations on",
154 | "different backends. Currently, we support WebGL and JavaScript",
155 | "CPU. By default, we choose the 'best' backend available, but",
156 | "allow users to customize their backend.
Constraints are added to attributes",
162 | "of a Layer (such as weights, kernels, or biases) at",
163 | "construction time to clamp, or otherwise enforce an allowed range,",
164 | "of values for different components of the Layer.
Regularizers can be attached to various components",
177 | "of a Layer to add a 'scoring' function to help drive weights, or ",
178 | "other trainable values, away from excessively large values. They're",
179 | "typically used to promote a notion that a 'simpler' model is better",
180 | "than a complicated model, assuming equal performance.
We have utility functions for common cases like Scalar, 1D,",
12 | "2D, 3D and 4D tensors, as well a number of functions to initialize",
13 | "tensors in ways useful for machine learning.
TensorFlow.js provides several operations",
34 | "to slice or extract parts of a tensor, or join multiple",
35 | "tensors together."]
36 | }
37 | ]
38 | },
39 | {
40 | "name": "Models",
41 | "description": ["
Models are one of the primary abstractions used in",
42 | "TensorFlow.js Layers. Models can be trained, evaluated, and used",
43 | "for prediction. A model's state (topology, and optionally, trained",
44 | "weights) can be restored from various formats.
",
45 | "
Models are a collection of Layers, see Model Creation for",
46 | "details about how Layers can be connected.
Sequential — Easiest, works if the models is a",
52 | "simple stack of each layer's input resting on the top of the",
53 | "previous layer's output.
",
54 | "
Model — Offers more control if the layers need to be",
55 | "wired together in graph-like ways — multiple 'towers',",
56 | "layers that skip a layer, etc.
Layers are the primary building block for ",
72 | "constructing a Model. Each layer will typically perform some",
73 | "computation to transform its input to its output.
",
74 | "
Layers will automatically take care of creating and initializing",
75 | "the various internal variables/weights they need to function.
To perform mathematical computation on Tensors, we use",
118 | "operations. Tensors are immutable, so all operations always return",
119 | "new Tensors and never modify input Tensors.
We also provide an API to do perform training, and",
130 | "compute gradients. We compute gradients eagerly, users provide a function",
131 | "that is a combination of operations and we automatically differentiate",
132 | "that function's output with respect to its inputs.",
133 | "
For those familiar with TensorFlow, the API we expose exactly mirrors",
134 | "the TensorFlow Eager API.",
135 | "
TensorFlow.js can run mathematical operations on",
154 | "different backends. Currently, we support WebGL and JavaScript",
155 | "CPU. By default, we choose the 'best' backend available, but",
156 | "allow users to customize their backend.
Constraints are added to attributes",
162 | "of a Layer (such as weights, kernels, or biases) at",
163 | "construction time to clamp, or otherwise enforce an allowed range,",
164 | "of values for different components of the Layer.
Regularizers can be attached to various components",
177 | "of a Layer to add a 'scoring' function to help drive weights, or ",
178 | "other trainable values, away from excessively large values. They're",
179 | "typically used to promote a notion that a 'simpler' model is better",
180 | "than a complicated model, assuming equal performance.
We have utility functions for common cases like Scalar, 1D,",
12 | "2D, 3D and 4D tensors, as well a number of functions to initialize",
13 | "tensors in ways useful for machine learning.
TensorFlow.js provides several operations",
34 | "to slice or extract parts of a tensor, or join multiple",
35 | "tensors together."]
36 | }
37 | ]
38 | },
39 | {
40 | "name": "Models",
41 | "description": ["
Models are one of the primary abstractions used in",
42 | "TensorFlow.js Layers. Models can be trained, evaluated, and used",
43 | "for prediction. A model's state (topology, and optionally, trained",
44 | "weights) can be restored from various formats.
",
45 | "
Models are a collection of Layers, see Model Creation for",
46 | "details about how Layers can be connected.
Sequential — Easiest, works if the models is a",
52 | "simple stack of each layer's input resting on the top of the",
53 | "previous layer's output.
",
54 | "
Model — Offers more control if the layers need to be",
55 | "wired together in graph-like ways — multiple 'towers',",
56 | "layers that skip a layer, etc.
Layers are the primary building block for ",
72 | "constructing a Model. Each layer will typically perform some",
73 | "computation to transform its input to its output.
",
74 | "
Layers will automatically take care of creating and initializing",
75 | "the various internal variables/weights they need to function.
To perform mathematical computation on Tensors, we use",
118 | "operations. Tensors are immutable, so all operations always return",
119 | "new Tensors and never modify input Tensors.
We also provide an API to do perform training, and",
130 | "compute gradients. We compute gradients eagerly, users provide a function",
131 | "that is a combination of operations and we automatically differentiate",
132 | "that function's output with respect to its inputs.",
133 | "
For those familiar with TensorFlow, the API we expose exactly mirrors",
134 | "the TensorFlow Eager API.",
135 | "
TensorFlow.js can run mathematical operations on",
154 | "different backends. Currently, we support WebGL and JavaScript",
155 | "CPU. By default, we choose the 'best' backend available, but",
156 | "allow users to customize their backend.
Constraints are added to attributes",
162 | "of a Layer (such as weights, kernels, or biases) at",
163 | "construction time to clamp, or otherwise enforce an allowed range,",
164 | "of values for different components of the Layer.
Regularizers can be attached to various components",
177 | "of a Layer to add a 'scoring' function to help drive weights, or ",
178 | "other trainable values, away from excessively large values. They're",
179 | "typically used to promote a notion that a 'simpler' model is better",
180 | "than a complicated model, assuming equal performance.
We have utility functions for common cases like Scalar, 1D,",
12 | "2D, 3D and 4D tensors, as well a number of functions to initialize",
13 | "tensors in ways useful for machine learning.
TensorFlow.js provides several operations",
34 | "to slice or extract parts of a tensor, or join multiple",
35 | "tensors together."]
36 | }
37 | ]
38 | },
39 | {
40 | "name": "Models",
41 | "description": ["
Models are one of the primary abstractions used in",
42 | "TensorFlow.js Layers. Models can be trained, evaluated, and used",
43 | "for prediction. A model's state (topology, and optionally, trained",
44 | "weights) can be restored from various formats.
",
45 | "
Models are a collection of Layers, see Model Creation for",
46 | "details about how Layers can be connected.
Sequential — Easiest, works if the models is a",
52 | "simple stack of each layer's input resting on the top of the",
53 | "previous layer's output.
",
54 | "
Model — Offers more control if the layers need to be",
55 | "wired together in graph-like ways — multiple 'towers',",
56 | "layers that skip a layer, etc.
Layers are the primary building block for ",
72 | "constructing a Model. Each layer will typically perform some",
73 | "computation to transform its input to its output.
",
74 | "
Layers will automatically take care of creating and initializing",
75 | "the various internal variables/weights they need to function.
To perform mathematical computation on Tensors, we use",
118 | "operations. Tensors are immutable, so all operations always return",
119 | "new Tensors and never modify input Tensors.
We also provide an API to do perform training, and",
130 | "compute gradients. We compute gradients eagerly, users provide a function",
131 | "that is a combination of operations and we automatically differentiate",
132 | "that function's output with respect to its inputs.",
133 | "
For those familiar with TensorFlow, the API we expose exactly mirrors",
134 | "the TensorFlow Eager API.",
135 | "
TensorFlow.js can run mathematical operations on",
154 | "different backends. Currently, we support WebGL and JavaScript",
155 | "CPU. By default, we choose the 'best' backend available, but",
156 | "allow users to customize their backend.
Constraints are added to attributes",
162 | "of a Layer (such as weights, kernels, or biases) at",
163 | "construction time to clamp, or otherwise enforce an allowed range,",
164 | "of values for different components of the Layer.
Regularizers can be attached to various components",
177 | "of a Layer to add a 'scoring' function to help drive weights, or ",
178 | "other trainable values, away from excessively large values. They're",
179 | "typically used to promote a notion that a 'simpler' model is better",
180 | "than a complicated model, assuming equal performance.
We have utility functions for common cases like Scalar, 1D,",
12 | "2D, 3D and 4D tensors, as well a number of functions to initialize",
13 | "tensors in ways useful for machine learning.
TensorFlow.js provides several operations",
34 | "to slice or extract parts of a tensor, or join multiple",
35 | "tensors together."]
36 | }
37 | ]
38 | },
39 | {
40 | "name": "Models",
41 | "description": ["
Models are one of the primary abstractions used in",
42 | "TensorFlow.js Layers. Models can be trained, evaluated, and used",
43 | "for prediction. A model's state (topology, and optionally, trained",
44 | "weights) can be restored from various formats.
",
45 | "
Models are a collection of Layers, see Model Creation for",
46 | "details about how Layers can be connected.
Sequential — Easiest, works if the models is a",
52 | "simple stack of each layer's input resting on the top of the",
53 | "previous layer's output.
",
54 | "
Model — Offers more control if the layers need to be",
55 | "wired together in graph-like ways — multiple 'towers',",
56 | "layers that skip a layer, etc.
Layers are the primary building block for ",
72 | "constructing a Model. Each layer will typically perform some",
73 | "computation to transform its input to its output.
",
74 | "
Layers will automatically take care of creating and initializing",
75 | "the various internal variables/weights they need to function.
To perform mathematical computation on Tensors, we use",
118 | "operations. Tensors are immutable, so all operations always return",
119 | "new Tensors and never modify input Tensors.
We also provide an API to do perform training, and",
130 | "compute gradients. We compute gradients eagerly, users provide a function",
131 | "that is a combination of operations and we automatically differentiate",
132 | "that function's output with respect to its inputs.",
133 | "
For those familiar with TensorFlow, the API we expose exactly mirrors",
134 | "the TensorFlow Eager API.",
135 | "
TensorFlow.js can run mathematical operations on",
154 | "different backends. Currently, we support WebGL and JavaScript",
155 | "CPU. By default, we choose the 'best' backend available, but",
156 | "allow users to customize their backend.
Constraints are added to attributes",
162 | "of a Layer (such as weights, kernels, or biases) at",
163 | "construction time to clamp, or otherwise enforce an allowed range,",
164 | "of values for different components of the Layer.
Regularizers can be attached to various components",
177 | "of a Layer to add a 'scoring' function to help drive weights, or ",
178 | "other trainable values, away from excessively large values. They're",
179 | "typically used to promote a notion that a 'simpler' model is better",
180 | "than a complicated model, assuming equal performance.
We have utility functions for common cases like Scalar, 1D,",
12 | "2D, 3D and 4D tensors, as well a number of functions to initialize",
13 | "tensors in ways useful for machine learning.
TensorFlow.js provides several operations",
34 | "to slice or extract parts of a tensor, or join multiple",
35 | "tensors together."]
36 | }
37 | ]
38 | },
39 | {
40 | "name": "Models",
41 | "description": ["
Models are one of the primary abstractions used in",
42 | "TensorFlow.js Layers. Models can be trained, evaluated, and used",
43 | "for prediction. A model's state (topology, and optionally, trained",
44 | "weights) can be restored from various formats.
",
45 | "
Models are a collection of Layers, see Model Creation for",
46 | "details about how Layers can be connected.
Sequential — Easiest, works if the models is a",
52 | "simple stack of each layer's input resting on the top of the",
53 | "previous layer's output.
",
54 | "
Model — Offers more control if the layers need to be",
55 | "wired together in graph-like ways — multiple 'towers',",
56 | "layers that skip a layer, etc.
Layers are the primary building block for ",
72 | "constructing a Model. Each layer will typically perform some",
73 | "computation to transform its input to its output.
",
74 | "
Layers will automatically take care of creating and initializing",
75 | "the various internal variables/weights they need to function.
To perform mathematical computation on Tensors, we use",
118 | "operations. Tensors are immutable, so all operations always return",
119 | "new Tensors and never modify input Tensors.
We also provide an API to do perform training, and",
130 | "compute gradients. We compute gradients eagerly, users provide a function",
131 | "that is a combination of operations and we automatically differentiate",
132 | "that function's output with respect to its inputs.",
133 | "
For those familiar with TensorFlow, the API we expose exactly mirrors",
134 | "the TensorFlow Eager API.",
135 | "
TensorFlow.js can run mathematical operations on",
154 | "different backends. Currently, we support WebGL and JavaScript",
155 | "CPU. By default, we choose the 'best' backend available, but",
156 | "allow users to customize their backend.
Constraints are added to attributes",
162 | "of a Layer (such as weights, kernels, or biases) at",
163 | "construction time to clamp, or otherwise enforce an allowed range,",
164 | "of values for different components of the Layer.
Regularizers can be attached to various components",
177 | "of a Layer to add a 'scoring' function to help drive weights, or ",
178 | "other trainable values, away from excessively large values. They're",
179 | "typically used to promote a notion that a 'simpler' model is better",
180 | "than a complicated model, assuming equal performance.
We have utility functions for common cases like Scalar, 1D,",
12 | "2D, 3D and 4D tensors, as well a number of functions to initialize",
13 | "tensors in ways useful for machine learning.
TensorFlow.js provides several operations",
34 | "to slice or extract parts of a tensor, or join multiple",
35 | "tensors together."]
36 | }
37 | ]
38 | },
39 | {
40 | "name": "Models",
41 | "description": ["
Models are one of the primary abstractions used in",
42 | "TensorFlow.js Layers. Models can be trained, evaluated, and used",
43 | "for prediction. A model's state (topology, and optionally, trained",
44 | "weights) can be restored from various formats.
",
45 | "
Models are a collection of Layers, see Model Creation for",
46 | "for details about how Layers can be connected.
Sequential — Easiest, works if the models is a",
52 | "simple stack of each layer's input resting on the top of the",
53 | "previous layer's output.
",
54 | "
Model — Offers more control if the layers need to be",
55 | "wired together in graph-like ways — multiple 'towers',",
56 | "layers that skip a layer, etc.
Layers are the primary building block for ",
72 | "constructing a Model. Each layer will typically perform some",
73 | "computation to transform its input to its output.
",
74 | "
Layers will automatically take care of creating and initializing",
75 | "the various internal variables/weights they need to function.
To perform mathematical computation on Tensors, we use",
118 | "operations. Tensors are immutable, so all operations always return",
119 | "new Tensors and never modify input Tensors.
We also provide an API to do perform training, and",
130 | "compute gradients. We compute gradients eagerly, users provide a function",
131 | "that is a combination of operations and we automatically differentiate",
132 | "that function's output with respect to its inputs.",
133 | "
For those familiar with TensorFlow, the API we expose exactly mirrors",
134 | "the TensorFlow Eager API.",
135 | "
TensorFlow.js can run mathematical operations on",
154 | "different backends. Currently, we support WebGL and JavaScript",
155 | "CPU. By default, we choose the 'best' backend available, but",
156 | "allow users to customize their backend.
Constraints are added to attributes",
162 | "of a Layer (such as weights, kernels, or biases) at",
163 | "construction time to clamp, or otherwise enforce an allowed range,",
164 | "of values for different components of the Layer.
Regularizers can be attached to various components",
177 | "of a Layer to add a 'scoring' function to help drive weights, or ",
178 | "other trainable values, away from excessively large values. They're",
179 | "typically used to promote a notion that a 'simpler' model is better",
180 | "than a complicated model, assuming equal performance.
We have utility functions for common cases like Scalar, 1D,",
12 | "2D, 3D and 4D tensors, as well a number of functions to initialize",
13 | "tensors in ways useful for machine learning.
TensorFlow.js provides several operations",
34 | "to slice or extract parts of a tensor, or join multiple",
35 | "tensors together."]
36 | }
37 | ]
38 | },
39 | {
40 | "name": "Models",
41 | "description": ["
Models are one of the primary abstractions used in",
42 | "TensorFlow.js Layers. Models can be trained, evaluated, and used",
43 | "for prediction. A model's state (topology, and optionally, trained",
44 | "weights) can be restored from various formats.
",
45 | "
Models are a collection of Layers, see Model Creation for",
46 | "details about how Layers can be connected.
Sequential — Easiest, works if the models is a",
52 | "simple stack of each layer's input resting on the top of the",
53 | "previous layer's output.
",
54 | "
Model — Offers more control if the layers need to be",
55 | "wired together in graph-like ways — multiple 'towers',",
56 | "layers that skip a layer, etc.
Layers are the primary building block for ",
72 | "constructing a Model. Each layer will typically perform some",
73 | "computation to transform its input to its output.
",
74 | "
Layers will automatically take care of creating and initializing",
75 | "the various internal variables/weights they need to function.
To perform mathematical computation on Tensors, we use",
118 | "operations. Tensors are immutable, so all operations always return",
119 | "new Tensors and never modify input Tensors.
We also provide an API to do perform training, and",
130 | "compute gradients. We compute gradients eagerly, users provide a function",
131 | "that is a combination of operations and we automatically differentiate",
132 | "that function's output with respect to its inputs.",
133 | "
For those familiar with TensorFlow, the API we expose exactly mirrors",
134 | "the TensorFlow Eager API.",
135 | "
TensorFlow.js can run mathematical operations on",
154 | "different backends. Currently, we support WebGL and JavaScript",
155 | "CPU. By default, we choose the 'best' backend available, but",
156 | "allow users to customize their backend.
Constraints are added to attributes",
162 | "of a Layer (such as weights, kernels, or biases) at",
163 | "construction time to clamp, or otherwise enforce an allowed range,",
164 | "of values for different components of the Layer.
Regularizers can be attached to various components",
177 | "of a Layer to add a 'scoring' function to help drive weights, or ",
178 | "other trainable values, away from excessively large values. They're",
179 | "typically used to promote a notion that a 'simpler' model is better",
180 | "than a complicated model, assuming equal performance.
We have utility functions for common cases like Scalar, 1D,",
12 | "2D, 3D and 4D tensors, as well a number of functions to initialize",
13 | "tensors in ways useful for machine learning.
TensorFlow.js provides several operations",
34 | "to slice or extract parts of a tensor, or join multiple",
35 | "tensors together."]
36 | }
37 | ]
38 | },
39 | {
40 | "name": "Models",
41 | "description": ["
Models are one of the primary abstractions used in",
42 | "TensorFlow.js Layers. Models can be trained, evaluated, and used",
43 | "for prediction. A model's state (topology, and optionally, trained",
44 | "weights) can be restored from various formats.
",
45 | "
Models are a collection of Layers, see Model Creation for",
46 | "details about how Layers can be connected.
Sequential — Easiest, works if the models is a",
52 | "simple stack of each layer's input resting on the top of the",
53 | "previous layer's output.
",
54 | "
Model — Offers more control if the layers need to be",
55 | "wired together in graph-like ways — multiple 'towers',",
56 | "layers that skip a layer, etc.
Layers are the primary building block for ",
72 | "constructing a Model. Each layer will typically perform some",
73 | "computation to transform its input to its output.
",
74 | "
Layers will automatically take care of creating and initializing",
75 | "the various internal variables/weights they need to function.
To perform mathematical computation on Tensors, we use",
118 | "operations. Tensors are immutable, so all operations always return",
119 | "new Tensors and never modify input Tensors.
We also provide an API to do perform training, and",
130 | "compute gradients. We compute gradients eagerly, users provide a function",
131 | "that is a combination of operations and we automatically differentiate",
132 | "that function's output with respect to its inputs.",
133 | "
For those familiar with TensorFlow, the API we expose exactly mirrors",
134 | "the TensorFlow Eager API.",
135 | "
TensorFlow.js can run mathematical operations on",
154 | "different backends. Currently, we support WebGL and JavaScript",
155 | "CPU. By default, we choose the 'best' backend available, but",
156 | "allow users to customize their backend.
Constraints are added to attributes",
162 | "of a Layer (such as weights, kernels, or biases) at",
163 | "construction time to clamp, or otherwise enforce an allowed range,",
164 | "of values for different components of the Layer.
Regularizers can be attached to various components",
177 | "of a Layer to add a 'scoring' function to help drive weights, or ",
178 | "other trainable values, away from excessively large values. They're",
179 | "typically used to promote a notion that a 'simpler' model is better",
180 | "than a complicated model, assuming equal performance.
5 | {{/if}}
6 |
7 |
8 | // Define a model for linear regression.
9 | const model = tf.sequential();
10 | model.add(tf.layers.dense({units: 1, inputShape: [1]}));
11 |
12 | model.compile({loss: 'meanSquaredError', optimizer: 'sgd'});
13 |
14 | // Generate some synthetic data for training.
15 | const xs = tf.tensor2d([1, 2, 3, 4], [4, 1]);
16 | const ys = tf.tensor2d([1, 3, 5, 7], [4, 1]);
17 |
18 | // Train the model using the data.
19 | model.fit(xs, ys, {epochs: 10}).then(() => {
20 | // Use the model to do inference on a data point the model hasn't seen before:
21 | model.predict(tf.tensor2d([5], [1, 1])).print();
22 | // Open the browser devtools to see the output
23 | });
24 |
25 |
26 |
27 | import * as tf from '@tensorflow/tfjs';
28 |
29 | // Define a model for linear regression.
30 | const model = tf.sequential();
31 | model.add(tf.layers.dense({units: 1, inputShape: [1]}));
32 |
33 | model.compile({loss: 'meanSquaredError', optimizer: 'sgd'});
34 |
35 | // Generate some synthetic data for training.
36 | const xs = tf.tensor2d([1, 2, 3, 4], [4, 1]);
37 | const ys = tf.tensor2d([1, 3, 5, 7], [4, 1]);
38 |
39 | // Train the model using the data.
40 | model.fit(xs, ys, {epochs: 10}).then(() => {
41 | // Use the model to do inference on a data point the model hasn't seen before:
42 | model.predict(tf.tensor2d([5], [1, 1])).print();
43 | // Open the browser devtools to see the output
44 | });
45 |
46 |
47 |
48 | const tf = require('@tensorflow/tfjs');
49 |
50 | // Optional Load the binding:
51 | // Use '@tensorflow/tfjs-node-gpu' if running with GPU.
52 | require('@tensorflow/tfjs-node');
53 |
54 | // Train a simple model:
55 | const model = tf.sequential();
56 | model.add(tf.layers.dense({units: 100, activation: 'relu', inputShape: [10]}));
57 | model.add(tf.layers.dense({units: 1, activation: 'linear'}));
58 | model.compile({optimizer: 'sgd', loss: 'meanSquaredError'});
59 |
60 | const xs = tf.randomNormal([100, 10]);
61 | const ys = tf.randomNormal([100, 1]);
62 |
63 | model.fit(xs, ys, {
64 | epochs: 100,
65 | callbacks: {
66 | onEpochEnd: (epoch, log) => console.log(`Epoch ${epoch}: loss = ${log.loss}`);
67 | }
68 | });
69 |
70 | {{!-- // clang-format on --}}
71 |
72 |
73 |
74 |
75 |
Browser setup
76 |
77 |
78 | There are two main ways to get TensorFlow.js in your browser based projects: via
79 |
80 | script tags
81 | or by installing it from
82 | NPM
83 | and using a build tool like
84 | Parcel,
85 | WebPack, or
86 | Rollup.
87 |
88 |
89 |
90 | If you are new to web development, or have never heard of tools like webpack or parcel, we recommend you
91 | use the script tag approach. If you are more experienced or want to write larger programs it might be
92 | worthwhile to explore using build tools.
93 |
94 |
95 |
Usage via Script Tag
96 |
Add the following script tag to your main HTML file.
We have utility functions for common cases like Scalar, 1D,",
14 | "2D, 3D and 4D tensors, as well a number of functions to initialize",
15 | "tensors in ways useful for machine learning.
TensorFlow.js provides several operations",
53 | "to slice or extract parts of a tensor, or join multiple",
54 | "tensors together."
55 | ]
56 | }
57 | ]
58 | },
59 | {
60 | "name": "Models",
61 | "description": [
62 | "
Models are one of the primary abstractions used in",
63 | "TensorFlow.js Layers. Models can be trained, evaluated, and used",
64 | "for prediction. A model's state (topology, and optionally, trained",
65 | "weights) can be restored from various formats.
",
66 | "
Models are a collection of Layers, see Model Creation for",
67 | "details about how Layers can be connected.
Sequential — Easiest, works if the models is a",
75 | "simple stack of each layer's input resting on the top of the",
76 | "previous layer's output.
",
77 | "
Model — Offers more control if the layers need to be",
78 | "wired together in graph-like ways — multiple 'towers',",
79 | "layers that skip a layer, etc.
Layers are the primary building block for ",
100 | "constructing a Model. Each layer will typically perform some",
101 | "computation to transform its input to its output.
",
102 | "
Layers will automatically take care of creating and initializing",
103 | "the various internal variables/weights they need to function.
To perform mathematical computation on Tensors, we use",
148 | "operations. Tensors are immutable, so all operations always return",
149 | "new Tensors and never modify input Tensors.
We also provide an API to do perform training, and",
188 | "compute gradients. We compute gradients eagerly, users provide a function",
189 | "that is a combination of operations and we automatically differentiate",
190 | "that function's output with respect to its inputs.",
191 | "
For those familiar with TensorFlow, the API we expose exactly mirrors",
192 | "the TensorFlow Eager API.",
193 | "
TensorFlow.js can run mathematical operations on",
245 | "different backends. Currently, we support WebGL and JavaScript",
246 | "CPU. By default, we choose the 'best' backend available, but",
247 | "allow users to customize their backend.
Constraints are added to attributes",
255 | "of a Layer (such as weights, kernels, or biases) at",
256 | "construction time to clamp, or otherwise enforce an allowed range,",
257 | "of values for different components of the Layer.
Regularizers can be attached to various components",
274 | "of a Layer to add a 'scoring' function to help drive weights, or ",
275 | "other trainable values, away from excessively large values. They're",
276 | "typically used to promote a notion that a 'simpler' model is better",
277 | "than a complicated model, assuming equal performance.
We have utility functions for common cases like Scalar, 1D,",
14 | "2D, 3D and 4D tensors, as well a number of functions to initialize",
15 | "tensors in ways useful for machine learning.
TensorFlow.js provides several operations",
53 | "to slice or extract parts of a tensor, or join multiple",
54 | "tensors together."
55 | ]
56 | }
57 | ]
58 | },
59 | {
60 | "name": "Models",
61 | "description": [
62 | "
Models are one of the primary abstractions used in",
63 | "TensorFlow.js Layers. Models can be trained, evaluated, and used",
64 | "for prediction. A model's state (topology, and optionally, trained",
65 | "weights) can be restored from various formats.
",
66 | "
Models are a collection of Layers, see Model Creation for",
67 | "details about how Layers can be connected.
Sequential — Easiest, works if the models is a",
75 | "simple stack of each layer's input resting on the top of the",
76 | "previous layer's output.
",
77 | "
Model — Offers more control if the layers need to be",
78 | "wired together in graph-like ways — multiple 'towers',",
79 | "layers that skip a layer, etc.
Layers are the primary building block for ",
100 | "constructing a Model. Each layer will typically perform some",
101 | "computation to transform its input to its output.
",
102 | "
Layers will automatically take care of creating and initializing",
103 | "the various internal variables/weights they need to function.
To perform mathematical computation on Tensors, we use",
148 | "operations. Tensors are immutable, so all operations always return",
149 | "new Tensors and never modify input Tensors.
We also provide an API to do perform training, and",
188 | "compute gradients. We compute gradients eagerly, users provide a function",
189 | "that is a combination of operations and we automatically differentiate",
190 | "that function's output with respect to its inputs.",
191 | "
For those familiar with TensorFlow, the API we expose exactly mirrors",
192 | "the TensorFlow Eager API.",
193 | "
TensorFlow.js can run mathematical operations on",
245 | "different backends. Currently, we support WebGL and JavaScript",
246 | "CPU. By default, we choose the 'best' backend available, but",
247 | "allow users to customize their backend.
Constraints are added to attributes",
255 | "of a Layer (such as weights, kernels, or biases) at",
256 | "construction time to clamp, or otherwise enforce an allowed range,",
257 | "of values for different components of the Layer.
Regularizers can be attached to various components",
274 | "of a Layer to add a 'scoring' function to help drive weights, or ",
275 | "other trainable values, away from excessively large values. They're",
276 | "typically used to promote a notion that a 'simpler' model is better",
277 | "than a complicated model, assuming equal performance.
We have utility functions for common cases like Scalar, 1D,",
14 | "2D, 3D and 4D tensors, as well a number of functions to initialize",
15 | "tensors in ways useful for machine learning.
TensorFlow.js provides several operations",
53 | "to slice or extract parts of a tensor, or join multiple",
54 | "tensors together."
55 | ]
56 | }
57 | ]
58 | },
59 | {
60 | "name": "Models",
61 | "description": [
62 | "
Models are one of the primary abstractions used in",
63 | "TensorFlow.js Layers. Models can be trained, evaluated, and used",
64 | "for prediction. A model's state (topology, and optionally, trained",
65 | "weights) can be restored from various formats.
",
66 | "
Models are a collection of Layers, see Model Creation for",
67 | "details about how Layers can be connected.
Sequential — Easiest, works if the models is a",
75 | "simple stack of each layer's input resting on the top of the",
76 | "previous layer's output.
",
77 | "
Model — Offers more control if the layers need to be",
78 | "wired together in graph-like ways — multiple 'towers',",
79 | "layers that skip a layer, etc.
Layers are the primary building block for ",
100 | "constructing a Model. Each layer will typically perform some",
101 | "computation to transform its input to its output.
",
102 | "
Layers will automatically take care of creating and initializing",
103 | "the various internal variables/weights they need to function.
To perform mathematical computation on Tensors, we use",
148 | "operations. Tensors are immutable, so all operations always return",
149 | "new Tensors and never modify input Tensors.
We also provide an API to do perform training, and",
188 | "compute gradients. We compute gradients eagerly, users provide a function",
189 | "that is a combination of operations and we automatically differentiate",
190 | "that function's output with respect to its inputs.",
191 | "
For those familiar with TensorFlow, the API we expose exactly mirrors",
192 | "the TensorFlow Eager API.",
193 | "
TensorFlow.js can run mathematical operations on",
245 | "different backends. Currently, we support WebGL and JavaScript",
246 | "CPU. By default, we choose the 'best' backend available, but",
247 | "allow users to customize their backend.
Constraints are added to attributes",
255 | "of a Layer (such as weights, kernels, or biases) at",
256 | "construction time to clamp, or otherwise enforce an allowed range,",
257 | "of values for different components of the Layer.
Regularizers can be attached to various components",
274 | "of a Layer to add a 'scoring' function to help drive weights, or ",
275 | "other trainable values, away from excessively large values. They're",
276 | "typically used to promote a notion that a 'simpler' model is better",
277 | "than a complicated model, assuming equal performance.
32 | 
55 | 
78 | 
101 | 
126 | 
146 | 
173 |