Now that we have introduced how TensorFlow creates tensors, and uses variables and placeholders, we will introduce how to act on these objects in a computational graph. From this, we can set up a simple classifier and see how well it performs.

Now that we can put objects into our computational graph, we will introduce operations that act on such objects.

To start a graph, we load TensorFlow and create a session, as follows:

import tensorflow as tf 
sess = tf.Session() 

In this example, we will combine what we have learned and feed each number in a list into an operation in a graph and print the output:

First, we declare our tensors and placeholders. Here, we will create a NumPy array to feed into our operation:

import numpy as np 
x_vals = np...

In this recipe, we will learn how to put multiple operations on the same computational graph.

It's important to know how to chain operations together. This will set up layered operations in the computational graph. For a demonstration, we will multiply a placeholder by two matrices and then perform addition. We will feed in two matrices in the form of a three-dimensional NumPy array:

import tensorflow as tf 
sess = tf.Session() 

It is also important to note how the data will change shape as it passes through...

Now that we have covered multiple operations, we will cover how to connect various layers that have data propagating through them.

In this recipe, we will introduce how to best connect various layers, including custom layers. The data we will generate and use will be representative of small random images. It is best to understand this type of operation with a simple example and see how we can use some built-in layers to perform calculations. The first layer we will explore is called a moving window. We will perform a small moving window average across a 2D image and then the second layer will be a custom operation layer.

In this section, we will see that the computational graph can...

Loss functions are very important for machine learning algorithms. They measure the distance between the model outputs and the target (truth) values. In this recipe, we show various loss function implementations in TensorFlow.

In order to optimize our machine learning algorithms, we will need to evaluate the outcomes. Evaluating outcomes in TensorFlow depends on specifying a loss function. A loss function tells TensorFlow how good or bad the predictions are compared to the desired result. In most cases, we will have a set of data and a target on which to train our algorithm. The loss function compares the target to the prediction and gives a numerical distance between the two.

For...

One of the benefits of using TensorFlow is that it can keep track of operations and automatically update model variables based on back propagation. In this recipe, we will introduce how to use this aspect to our advantage when training machine learning models.

Now, we will introduce how to change our variables in the model in such a way that a loss function is minimized. We have learned how to use objects and operations, and create loss functions that will measure the distance between our predictions and targets. Now, we just have to tell TensorFlow how to back propagate errors through our computational graph to update the variables and minimize the loss function. This is done via...

While TensorFlow updates our model variables according to back propagation, it can operate on anything from one-datum observation to a large batch of data at once. Operating on one training example can make for a very erratic learning process, while using too large a batch can be computationally expensive. Choosing the right type of training is crucial for getting our machine learning algorithms to converge to a solution.

In order for TensorFlow to compute the variable gradients for back propagation to work, we have to measure the loss on a sample or multiple samples. Stochastic training only works on one randomly sampled data-target pair at a time, just as we did in...

In this section, we will combine everything we have illustrated so far and create a classifier for the iris dataset.

The iris dataset is described in more detail in the Working with data sources recipe in Chapter 1, Getting Started with TensorFlow. We will load this data and make a simple binary classifier to predict whether a flower is the species Iris setosa or not. To be clear, this dataset has three species, but we will only predict whether a flower is a single species, I. setosa or not, giving us a binary classifier. We will start by loading the libraries and data, then transform the target accordingly.

We have already learned how to train a regression and classification algorithm in TensorFlow. After this, we must be able to evaluate the model's predictions to determine how well it did.

Evaluating models is very important and every subsequent model will have some form of model evaluation. Using TensorFlow, we must build this feature into the computational graph and call it while our model is training and/or after it has finished training.

Evaluating models during training gives us an insight into the algorithm and may give us hints to debug it, improve it, or change models entirely. While evaluation during training isn't always necessary, we will show how to do it with both regression...