In this chapter, as a prerequisite, you need to prepare the following libraries or frameworks in your environment:

• A web browser (Chrome is recommended): TensorFlow.js primarily runs on web browsers.
• The Node.js environment, which contains a node package manager (npm): Node.js is necessary since it resolves dependencies so that we can run TensorFlow.js.
• TypeScript compiler: TensorFlow.js and its application are often written in TypeScript.
• Python (3.x is recommended): We need this so that we can run Python-dependent tools such as tfjs-converter and the TensorFlow Python API.

If you are unsure about how to build the environment, please look at the Further reading section, which can be found at the end of this chapter. You will find these resources useful while you set up these prerequisites.

Machine learning technology was invented in the 1950s. Back then, there was no such period where machine learning was the exciting field in computer science that it currently is. However, thanks to breakthroughs in areas of deep learning and artificial intelligence, a huge amount of resources in terms of money and manpower have been devoted to help research it. For example, it isn't unusual to use an extensive amount of computing power that's leveraged by GPUs in laboratories in universities. Nowadays, industries and academics are cooperating to make progress in the computer science field. We are living in an era that's creating and facing large-scale data like never before. The importance of machine learning mainly comes from the demand for providing value by making use of this large-scale data. Machine learning technology gives...

Before diving into TensorFlow.js itself, we need to be familiar with the idea of operation graphs, or calculation graphs, which are common constructs that we'll use to build machine learning models alongside modern frameworks such as TensorFlow. In these frameworks, the data is represented as a tensor. A tensor is a data structure that represents an arbitrary dimensional array. Those of you who have used the NumPy library in Python may already be familiar with this concept. In NumPy, ndarray is commonly used to display various kinds of data in machine learning, such as images and audio, regardless of whether it's structured or unstructured.

Modern machine learning frameworks, including TensorFlow, illustrates the fact that machine learning models are operation graphs of tensors. An operation graph is defined as a chain that's used for the manipulation...

TensorFlow.js is a framework that we can use to construct machine learning models that are compatible with TensorFlow Python APIs. Unlike TensorFlow Python APIs, TensorFlow.js can be seamlessly integrated with the web so that we can quickly run machine learning algorithms on any platform. It was originally invented by Google and published as a piece of open source software known initially as deeplearn.js. Thanks to the contributions of developers, it is one of the most actively developed projects in the TensorFlow family.

But why is TensorFlow.js so important to developers who are trying to create machine learning applications...

There are two ways we can set up the TensorFlow.js environment:

• Use the minified JavaScript code that's distributed in the CDN
• Use the bundled package that's distributed by package managers such as npm

Typically, TensorFlow.js should be used on a web platform. Since the prebuilt file is distributed by the global content distribution network (CDN) service, we need to add a script tag to the web application:

<script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs/dist/tf.min.js"></script>

TensorFlow.js' classes can be found under the tf namespace. The CDN service works fast and is stable enough to provide such static resources to users. This is the easiest way to use TensorFlow.js.

If you want to serve your application in an environment where a public network isn't available, then you need to import TensorFlow...

The low-level API is flexible and allows us to construct the operation graph at the lowest level. It is also known as TensorFlow.js Core (https://github.com/tensorflow/tfjs-core).

This API allows us to access kernel implementations for each backend directly. Fundamentally, other high-level libraries and ecosystems depend on the Core API. Being familiar with the Core API will help us implement an efficient machine learning model with TensorFlow.js. Although the code base of the Core API was initially separated, TensorFlow.js is now managed by the mono repository. This means we can access any type of API solely from the root of the namespace of the library. Therefore, if we were to use tf as the reference to the root namespace, we can import it as follows:

import * as tf from '@tensorflow/tfjs'; 

In the previous section, we described how to use the Core API of TensorFlow.js, which allows us to construct any operation graph as we like. But this is not always the best choice. You may find yourself in a situation where a high-level API is more relevant when we want to build an application quickly. The Layers API is a Keras-like high-level API that's used to create models in an intrinsic way. You may already be familiar with the style of the Layers API if you've used Keras to construct machine learning models in the past.

There are two ways we can construct a machine learning model with the Layers API:

• By using the sequential model API
• By using the functional model API

As you may have already noticed, the Layers API has been made to look similar to the Keras API. Those of you who are already familiar with Keras will be able to use the Layers API...

In this chapter, we have learned about the benefits of constructing a machine learning model on the web and how to use TensorFlow.js to build it. There are two ways we can build a model with TensorFlow.js. The first way is to use the Core API, which helps us build flexible models and optimize their performance as much as possible. The other way is to use the Layers API. This API is similar to Keras, which means we can construct deep learning models more intuitively. We don't need to construct our own model if it is already publicly available.

We also learned that it's possible to import an existing model into TensorFlow.js by using tfjs-converter. By completing this chapter, you know how to construct your own models with TensorFlow.js and import existing models into TensorFlow.js.

In the next chapter, we will learn how to import pretrained models into TensorFlow...

1. What is the benefit of building a machine learning model on the web?
2. When we give the TensorHub model to tfjs-converter, what type of format will be generated?
   1. Layers model
   2. Graph model
3. How many ways can we release the memory that's been allocated to a tensor in a model in TensorFlow.js?
4. How can we inspect the structure of the model?
5. Describe the major difference between the Core API and the Layers API. When should we use them?
6. Construct a multilayer perceptron with the following layers:
   • The input is a vector with 784 elements.
   • The first intermediate layer is a fully connected layer whose output is a rectified linear unit and has a size of 32.
   • The second intermediate layer is a fully connected layer whose output is a rectified linear unit and has a size of 16.
   • The output is a softmax layer.
7. Is it possible to save a model that contains a custom layer?

Refer to the following resources to learn more about the topics that were covered in this chapter:

• tfjs-converter: https://github.com/tensorflow/tfjs-converter
• Tensors and operations: https://www.tensorflow.org/js/guide/tensors_operations
• Models and layers: https://www.tensorflow.org/js/guide/models_and_layers
• TypeScript: https://www.typescriptlang.org/
• Federated learning: https://www.tensorflow.org/federated/federated_learning
• Teachable machine: https://teachablemachine.withgoogle.com/