# AI News, Calculate Column Sum In TensorFlow

## Calculate Column Sum In TensorFlow

In this video, we’re going to do a column sum in TensorFlow using tf.reduce_sum to get the sum of all the elements in the columns of a tensor.

First, let’s create a TensorFlow tensor variable that will hold random numbers between 0 to 10 that are of the data type int32.

We see that it’s a tensor that has the shape of 2x3x4, the data type is int32, and it is a TensorFlow tensor.

Now that we’ve created the TensorFlow variable, it’s time to run the computational graph.

And even though we know the shape of the tensor because we defined it using the initializer initially, let’s check it just in case.

That means it’s two matrices that are three rows by four columns.

Since we want to do a column sum, we’ll have to tell the TensorFlow reduction operation which dimension we want to reduce across.

When we do a column sum, it means that we want to reduce the sum across the rows so that we end up with one row that has the result of the summation down each column, which means that we’ll want to use the second dimension.

However, because Python is 0 indexed, it means that we’ll use the number 1 instead of the number 2.

Let’s now use the tf.reduce_sum operation on our random_int_var_one_ex Python variable across the second dimension.

Let’s now manually do a sum across a few columns to make sure the results make sense.

Finally, we close the TensorFlow session to release the TensorFlow resources used within the session.

That is how you do a column sum in TensorFlow using TensorFlow’s reduce sum operation to get the sum of all the elements in the columns of a tensor.

In this video, we’re going to do a column sum in TensorFlow using tf.reduce_sum to get the sum of all the elements in the columns of a tensor.

First, let’s create a TensorFlow tensor variable that will hold random numbers between 0 to 10 that are of the data type int32.

We see that it’s a tensor that has the shape of 2x3x4, the data type is int32, and it is a TensorFlow tensor.

Now that we’ve created the TensorFlow variable, it’s time to run the computational graph.

And even though we know the shape of the tensor because we defined it using the initializer initially, let’s check it just in case.

That means it’s two matrices that are three rows by four columns.

Since we want to do a column sum, we’ll have to tell the TensorFlow reduction operation which dimension we want to reduce across.

When we do a column sum, it means that we want to reduce the sum across the rows so that we end up with one row that has the result of the summation down each column, which means that we’ll want to use the second dimension.

However, because Python is 0 indexed, it means that we’ll use the number 1 instead of the number 2.

Let’s now use the tf.reduce_sum operation on our random_int_var_one_ex Python variable across the second dimension.

Let’s now manually do a sum across a few columns to make sure the results make sense.

That is how you do a column sum in TensorFlow using TensorFlow’s reduce sum operation to get the sum of all the elements in the columns of a tensor.

## Detecting fake banknotes using TensorFlow

When using neural network and deep learning-based systems, it’s usually a good idea to standardise our data.

We don’t need to standardise the Class attribute, so let’s create a separate dataframe to store the other features.

Next, let’s fit a StandardScaler object from the Scikit-learn library on the independent variables and store the transformed data in a new dataframe called scaled_features.

Now that we have our independent and dependent variables, let’s use Scikit-learn’s train_test_split to split our data into a training and a test set.

A high rate means that the network changes its mind more quickly, and a lower rate means that it is reluctant to change.

We will be using batch learning, and a batch size of 100 means that we will update our weights using back-propagation after every 100 predictions.

This includes the number of nodes for each layer in our model (namely the input layer, the hidden layer(s), and the output layer).

Our network will have 3 layers (2 hidden layers and an output layer, excluding the input layer).

## Not another MNIST tutorial with TensorFlow

Check out the tutorial session 'Getting up and running with TensorFlow' at the AI Conference in New York City, April 29 to May 2, 2018. Hurry—early price ends March 16.

Open a terminal and type in: To begin, we will open up python in our terminal and import the MNIST data set: First, let’s define a couple of functions that will assign the amount of training and test data we will load from the data set.

You will need to copy and paste each function and hit enter twice in your terminal: And we’ll define some simple functions for resizing and displaying the data: Now, we’ll get down to the business of building and training our model.

In the example below, the array represents a 7: So, let’s pull up a random image using one of our custom functions that takes the flattened data, reshapes it, displays the example, and prints the associated label (note: you have to close the window matplot opens to continue using Python): Here is what multiple training examples look like to the classifier in their flattened form.

Of course, instead of pixels, our classifier sees values from zero to one representing pixel intensity: Until this point, we actually have not been using TensorFlow at all.

TensorFlow, in a sense, creates a directed acyclic graph (flow chart) which you later feed with data and run in a session: Next, we can define a placeholder.

It is not initialized and contains no data.” Here, we define our x placeholder as the variable to feed our x_train data into: When we assign None to our placeholder, it means the placeholder can be fed as many examples as you want to give it.

We make our prediction by multiplying each flattened digit by our weight and then adding our bias: First, let’s ignore the softmax and look what's inside the softmax function.

If you know your matrix multiplication, you would understand that this computes properly and that x * W + b results in a Number of Training Examples Fed (m) x Number of Classes (n) matrix.

The goal is to minimize your loss: This function is taking the log of all our predictions y (whose values range from 0 to 1) and element wise multiplying by the example’s true value y_.

If the log function for each value is close to zero, it will make the value a large negative number (i.e., -np.log(0.01) = 4.6), and if it is close to 1, it will make the value a small negative number (i.e., -np.log(0.99) = 0.1).

We are essentially penalizing the classifier with a very large number if the prediction is confidently incorrect and a very small number if the prediction is confidendently correct.

Here is a simple made up python example of a softmax prediction that is very confident that the digit is a 3: Let’s create an array label of '3' as a ground truth to compare to our softmax function: Can you guess what value our loss function gives us?

At any point, you can re run all the code starting from here and try different values: We can now initialize all variables so that they can be used by our TensorFlow graph: Now, we need to train our classifier using gradient descent.

The variable training will perform the gradient descent optimizer with a chosen LEARNING_RATE in order to try to minimize our loss function cross_entropy: Now, we’ll define a loop that repeats TRAIN_STEPS times;

If a teacher were to give students a practice exam and use that same exam for the final exam, you would have a very biased measure of students’ knowledge: In order to visualize what gradient descent is doing, you have to imagine the loss as being a 784 dimensional graph based on y_ and y, which contains different values of x, W, and b.

To explain things more simply in two-dimensions, we will use y = x^2: For each step in the loop, depending on how large the cross_entropy is the classifier will move a LEARNING_RATE step toward where it thinks cross_entropy’s value will be smaller.

the model, once trained, doesn’t take up that much room to store or computing power to calculate.) Our classifier makes its prediction by comparing how similar or different the digit is to the red and blue.

So, now that we have our cheat sheet, let’s load one example and apply our classifier to that one example: Let’s look at our predictor y: This gives us a (1x10) matrix with each column containing one probability: But this is not very useful for us.

So, let us now take our knowledge to create a function to make predictions on a random digit in this data set: And now try the function out: Can you find any that guessed incorrectly?

Lecture 7: Introduction to TensorFlow

Lecture 7 covers Tensorflow. TensorFlow is an open source software library for numerical computation using data flow graphs. It was originally developed by researchers and engineers working...

Sequence Models and the RNN API (TensorFlow Dev Summit 2017)

In this talk, Eugene Brevdo discusses the creation of flexible and high-performance sequence-to-sequence models. He covers reading and batching sequence data, the RNN API, fully dynamic calculation...

TensorFlow High-Level APIs: Models in a Box (TensorFlow Dev Summit 2017)

TensorFlow allows you to define models using both low, as well as high-level abstractions. In this talk, Martin Wicke introduces Layers, Estimators, and Canned Estimators for defining models,...

Dimensionality Reduction - The Math of Intelligence #5

Most of the datasets you'll find will have more than 3 dimensions. How are you supposed to understand visualize n-dimensional data? Enter dimensionality reduction techniques. We'll go over...

How to Use Tensorflow for Classification (LIVE)

In this live session I'll introduce & give an overview of Google's Deep Learning library, Tensorflow. Then we'll use it to build a neural network capable of predicting housing prices, with...

How to implement CapsNets using TensorFlow

This video will show you how to implement a Capsule Network in TensorFlow. You will learn more about CapsNets, as well as tips & tricks on using TensorFlow more efficiently. Hope you like it!...

The Best Way to Visualize a Dataset Easily

In this video, we'll visualize a dataset of body metrics collected by giving people a fitness tracking device. We'll go over the steps necessary to preprocess the data, then use a technique...

Random Forests - The Math of Intelligence (Week 6)

This is one of the most used machine learning models ever. Random Forests can be used for both regression and classification, and our use case will be to assess whether someone is credible...

How to Simulate a Self-Driving Car

We're going to use Udacity's car simulator app as an environment to create our own autonomous agent! We'll use Keras to train a convolutional neural network on images from the car's cameras...

Visualizing a Decision Tree - Machine Learning Recipes #2

Last episode, we treated our Decision Tree as a blackbox. In this episode, we'll build one on a real dataset, add code to visualize it, and practice reading it - so you can see how it works...