Tag: TensorFlow

Cats Vs Dogs: A kaggle Challange.

So far we have learned how to use TensorFlow to implement a basic neural network, going up all the way to a basic Convolutional Neural Network. In this article, we’ll go much further by taking the ideas we’ve learned and applied them to a much bigger dataset of cats versus dogs on Kaggle. Yes, so we take the full Kaggle dataset of 25,000 cats versus dogs images. So we want to take a look at what it’s like to train a much larger data set, and that was like a data science challenge, not that long ago. Now, we’re going to learn that here, which I think is really helpful to get great results while operating on much bigger data sets.

What does it take to download a public dataset of the Internet, like cats versus dogs, and get a neural network to work on it? Data is messy, sometimes you find astonishing things like pictures of people holding cats or multiple cats or surprising things in data. For example, you might have some files that are zero length and they could be corrupt as a result. So it’s like using your Python skills, using your TensorFlow skills to be able to filter them out. Building a convolutional neural network to be able to spot things like we mentioned, a person holding a cat. So that’s some of the things we need to concentrate on. We’ll be using a very clean dataset that we’re using with cats versus dogs, but you’re going to hit some of those issues. In this article, you’ll learn the skills that you need to be able to deal with other datasets that may not be as clean as this one.

The reality is, there’s a lot of data cleaning, and having great tools to help with that data cleaning makes our workflow much more efficient. Definitely, in this article, you will get to practice all that, as well as train a pretty cool neural network to classify cats versus dogs. Please go ahead.

In this article, we’ll take our understanding of the Convolutional Neural Network to the next level by recognizing sophisticated real images of Cats and Dogs in order to classify an incoming image as one or the other. In particular, the handwriting recognition made your life a little easier by having all the images be the same size and shape, and they were all monochrome color. Real-world images aren’t like that — they’re in different shapes, aspect ratios, etc, and they’re usually in color!

So, as part of the task you need to process your data — not least resizing it to be uniform in shape.

You’ll follow these steps:

  1. Explore the Example Data of Cats and Dogs.
  2. Build and train a Neural Network to recognize the difference between the two.
  3. Evaluate Training and Validation accuracy.

Explore the Example Data

Let’s start by downloading our example data, a .zip of 2,000 JPG pictures of cats and dogs, and extracting it locally in /tmp.

NOTE: The 2,000 images used in this exercise are excerpted from the “Dogs vs. Cats” dataset available on Kaggle, which contains 25,000 images. Here, we use a subset of the full dataset to decrease training time.

!wget --no-check-certificate \
  https://storage.googleapis.com/mledu-datasets/cats_and_dogs_filtered.zip \
  -O /tmp/cats_and_dogs_filtered.zip

The following python code will use the OS library to use Operating System libraries, giving you access to the file system, and the zip file library allowing you to unzip the data.

import os
import zipfile

local_zip = '/tmp/cats_and_dogs_filtered.zip'

zip_ref = zipfile.ZipFile(local_zip, 'r')

zip_ref.extractall('/tmp')
zip_ref.close()

The contents of the .zip are extracted to the base directory /tmp/cats_and_dogs_filtered, which contains train and validation subdirectories for the training and validation datasets, which in turn each contain cats and dogs subdirectories.

In short: The training set is the data that is used to tell the neural network model that ‘this is what a cat looks like’, ‘this is what a dog looks like’ etc. The validation data set is images of cats and dogs that the neural network will not see as part of the training, so you can test how well or how badly it does in evaluating if an image contains a cat or a dog.

One thing to pay attention to in this sample: We do not explicitly label the images as cats or dogs. If you remember with the handwriting example earlier, we had labeled ‘this is a 1’, ‘this is a 7’ etc. Later you’ll see something called an ImageGenerator being used — and this is coded to read images from subdirectories, and automatically label them from the name of that subdirectory. So, for example, you will have a ‘training’ directory containing a ‘cats’ directory and a ‘dogs’ one. ImageGenerator will label the images appropriately for you, reducing a coding step.

Let’s define each of these directories:

base_dir = '/tmp/cats_and_dogs_filtered'

train_dir = os.path.join(base_dir, 'train')
validation_dir = os.path.join(base_dir, 'validation')

# Directory with our training cat/dog pictures
train_cats_dir = os.path.join(train_dir, 'cats')
train_dogs_dir = os.path.join(train_dir, 'dogs')

# Directory with our validation cat/dog pictures
validation_cats_dir = os.path.join(validation_dir, 'cats')
validation_dogs_dir = os.path.join(validation_dir, 'dogs')

We can find out the total number of cat and dog images in the train and validation directories:

print('total training cat images :', len(os.listdir(train_cats_dir)))
print('total training dog images :', len(os.listdir(train_dogs_dir)))

print('total validation cat images :', len(os.listdir(validation_cats_dir)))
print('total validation dog images :', len(os.listdir(validation_dogs_dir)))

For both cats and dogs, we have 1,000 training images and 500 validation images.

Now let’s take a look at a few pictures to get a better sense of what the cat and dog datasets look like. First, configure the matplot parameters:

%matplotlib inline

import matplotlib.image as mpimg
import matplotlib.pyplot as plt

# Parameters for our graph; we'll output images in a 4x4 configuration
nrows = 4
ncols = 4

pic_index = 0 # Index for iterating over images

Now, display a batch of 8 cat and 8 dog pictures. You can rerun the cell to see a fresh batch each time:

# Set up matplotlib fig, and size it to fit 4x4 pics
fig = plt.gcf()
fig.set_size_inches(ncols*4, nrows*4)

pic_index+=8

next_cat_pix = [os.path.join(train_cats_dir, fname) 
                for fname in train_cat_fnames[ pic_index-8:pic_index] 
               ]

next_dog_pix = [os.path.join(train_dogs_dir, fname) 
                for fname in train_dog_fnames[ pic_index-8:pic_index]
               ]

for i, img_path in enumerate(next_cat_pix+next_dog_pix):
  # Set up subplot; subplot indices start at 1
  sp = plt.subplot(nrows, ncols, i + 1)
  sp.axis('Off') # Don't show axes (or gridlines)

  img = mpimg.imread(img_path)
  plt.imshow(img)

plt.show()
Batch of 8 dogs and 8 cats.

It may not be obvious from looking at the images in this grid, but important note here, and a significant difference is that these images come in all shapes and sizes. These are color and in a variety of shapes. Before training a Neural network with them you’ll need to tweak the images. You’ll see that in the next section.

Ok, now that you have an idea of what your data looks like, the next step is to define the model that will be trained to recognize cats or dogs from these images

Building a Small Model from Scratch to Get to ~72% Accuracy

In the previous section, you saw that the images were in a variety of shapes and sizes. In order to train a neural network to handle them, you’ll need them to be in a uniform size. We’ve chosen 150×150 for this, and you’ll see the code that preprocesses the images to that shape shortly.

But before we continue, let’s start defining the model:

Step 1 will be to import tensorflow

Next, we will define a Sequential layer as before, adding some convolutional layers first. Note the input shape parameter this time. In the earlier example, it was 28x28x1, because the image was 28×28 in greyscale (8 bits, 1 byte for color depth). This time it is 150×150 for the size and 3 (24 bits, 3 bytes) for the color depth.

We then add a couple of convolutional layers as in the previous example and flatten the final result to feed into the densely connected layers.

Finally we add the densely connected layers.

Note that because we are facing a two-class classification problem, i.e. a binary classification problem, we will end our network with a sigmoid activation, so that the output of our network will be a single scalar between 0 and 1, encoding the probability that the current image is class 1 (as opposed to class 0).

model = tf.keras.models.Sequential([
    # Note the input shape is the desired size of the image 150x150 with 3 bytes color
    tf.keras.layers.Conv2D(16, (3,3), activation='relu', input_shape=(150, 150, 3)),
    tf.keras.layers.MaxPooling2D(2,2),
    tf.keras.layers.Conv2D(32, (3,3), activation='relu'),
    tf.keras.layers.MaxPooling2D(2,2), 
    tf.keras.layers.Conv2D(64, (3,3), activation='relu'), 
    tf.keras.layers.MaxPooling2D(2,2),
    # Flatten the results to feed into a DNN
    tf.keras.layers.Flatten(), 
    # 512 neuron hidden layer
    tf.keras.layers.Dense(512, activation='relu'), 
    # Only 1 output neuron. It will contain a value from 0-1 where 0 for 1 class ('cats') and 1 for the other ('dogs')
    tf.keras.layers.Dense(1, activation='sigmoid')  
])

The model.summary() method call prints a summary of the NN

model.summary()

The “output shape” column shows how the size of your feature map evolves in each successive layer. The convolution layers reduce the size of the feature maps by a bit due to padding, and each pooling layer halves the dimensions.

Next, we’ll configure the specifications for model training. We will train our model with the loss because it’s a binary classification problem and our final activation is a sigmoid. We will use the rmsprop optimizer with a learning rate of 0.001. During training, we will want to monitor classification accuracy.

NOTE: In this case, using the RMSprop optimization algorithm is preferable to stochastic gradient descent (SGD), because RMSprop automates learning-rate tuning for us. (Other optimizers, such as Adam and Adagrad, also automatically adapt the learning rate during training, and would work equally well here.)

from tensorflow.keras.optimizers import RMSprop

model.compile(optimizer=RMSprop(lr=0.001),
              loss='binary_crossentropy',
              metrics = ['accuracy'])

Data Preprocessing

Let’s set up data generators that will read pictures in our source folders, convert them to tensors, and feed them (with their labels) to our network. We’ll have one generator for the training images and one for the validation images. Our generators will yield batches of 20 images of size 150×150 and their labels (binary).

As you may already know, data that goes into neural networks should usually be normalized in some way to make it more amenable to processing by the network. (It is uncommon to feed raw pixels into a convent.) In our case, we will preprocess our images by normalizing the pixel values to be in the [0, 1] range (originally all values are in the [0, 255] range).

In Keras, this can be done via the keras.preprocessing.image.ImageDataGenerator class using the rescale parameter. This ImageDataGenerator the class allows you to instantiate generators of augmented image batches (and their labels) via .flow(data, labels) or .flow_from_directory(directory). These generators can then be used with the Keras model methods that accept data generators as inputs: fit, evaluate_generator, and predict_generator.

from tensorflow.keras.preprocessing.image import ImageDataGenerator

# All images will be rescaled by 1./255.
train_datagen = ImageDataGenerator( rescale = 1.0/255. )
test_datagen  = ImageDataGenerator( rescale = 1.0/255. )

# --------------------
# Flow training images in batches of 20 using train_datagen generator
# --------------------
train_generator = train_datagen.flow_from_directory(train_dir,
                                                    batch_size=20,
                                                    class_mode='binary',
                                                    target_size=(150, 150))     
# --------------------
# Flow validation images in batches of 20 using test_datagen generator
# --------------------
validation_generator =  test_datagen.flow_from_directory(validation_dir,
                                                         batch_size=20,
                                                         class_mode  = 'binary',
                                                         target_size = (150, 150))

Training

Let’s train on all 2,000 images available, for 15 epochs, and validate on all 1,000 test images.

Do note the values per epoch.

You’ll see 4 values per epoch — Loss, Accuracy, Validation Loss and Validation Accuracy.

Loss and Accuracy are a great indication of the progress of training. It’s making a guess as to the classification of the training data, and then measuring it against the known label, calculating the result. Accuracy is the portion of correct guesses. The Validation accuracy is the measurement with the data that has not been used in training. As expected this would be a bit lower. You’ll learn about why this occurs in the section on overfitting later in this course.

history = model.fit(train_generator,
                              validation_data=validation_generator,
                              steps_per_epoch=100,
                              epochs=15,
                              validation_steps=50,
                              verbose=2)

Evaluating Accuracy and Loss for the Model


Let’s plot the training/validation accuracy and loss as collected during training:

#-----------------------------------------------------------
# Retrieve a list of list results on training and test data
# sets for each training epoch
#-----------------------------------------------------------
acc      = history.history[     'accuracy' ]
val_acc  = history.history[ 'val_accuracy' ]
loss     = history.history[    'loss' ]
val_loss = history.history['val_loss' ]

epochs   = range(len(acc)) # Get number of epochs

#------------------------------------------------
# Plot training and validation accuracy per epoch
#------------------------------------------------
plt.plot  ( epochs,     acc )
plt.plot  ( epochs, val_acc )
plt.title ('Training and validation accuracy')
plt.figure()

#------------------------------------------------
# Plot training and validation loss per epoch
#------------------------------------------------
plt.plot  ( epochs,     loss )
plt.plot  ( epochs, val_loss )
plt.title ('Training and validation loss'   )

As you can see, we are overfitting like it’s getting out of fashion. Our training accuracy (in blue) gets close to 100% (!) while our validation accuracy (in green) stalls as 70%. Our validation loss reaches its minimum after only five epochs.

Since we have a relatively small number of training examples (2000), overfitting should be our number one concern. Overfitting happens when a model exposed to too few examples learns patterns that do not generalize to new data, i.e. when the model starts using irrelevant features for making predictions. For instance, if you, as a human, only see three images of people who are lumberjacks, and three images of people who are sailors, and among them, the only person wearing a cap is a lumberjack, you might start thinking that wearing a cap is a sign of being a lumberjack as opposed to a sailor. You would then make a pretty lousy lumberjack/sailor classifier.

Overfitting is the central problem in machine learning: given that we are fitting the parameters of our model to a given dataset, how can we make sure that the representations learned by the model will be applied to data never seen before? How do we avoid learning things that are specific to the training data?

In the next exercise, we’ll look at ways to prevent overfitting in the cat vs. dog classification model.

Is it Shirt or Shoe? Easy coding to distinguish.

Before going to discuss how computer identifies and labels objects let’s understand what is computer vision in detail.

“Computer vision is the field of having a computer  understand and label what is present in an image(i.e, this is a dog or cat without being explicitly programmed) and then figure out the patterns.”

You can interpret  what a shirt is or what a shoe is, but how would you program for that? if an extra terrestrial who had never seen clothing walked into the room with you, how would you explain the shoes to him? It’s really difficult, if not impossible to do right? And it’s the same problem with computer vision. 

So one way to solve that is to use lots of pictures of clothing and tell the computer what that’s a picture of and then have the computer figure out the patterns that give you the difference between a shoe, and a shirt, and a handbag, and a coat.

For example, take a computer vision problem? Let’s take a look at a scenario where we can recognize different items of clothing, trained from a data set containing 10 different types.

Fashion-MNIST is available as a data set with an API call in TensorFlow(Tensorflow has in-built data sets available for learning purposes we just need to import them) but before that let’s start with our import of TensorFlow.

import tensorflow as tf
print(tf.__version__)

The Fashion MNIST data is available directly in the tf.keras datasets API. You load it like below.

mnist = tf.keras.datasets.fashion_mnist

In the MNIST data set, 60,000 of the 70,000 images are used to train the network, and then 10,000 images, one that it hasn’t previously seen, can be used to test just how good or how bad it is performing.

Calling load_data on this object will give you two sets of two lists, these will be the training and testing values for the graphics that contain the clothing items and their labels.

(training_images, training_labels), (test_images, test_labels) = mnist.load_data()

What do these values look like? Let’s print a training image, and a training label to see…Experiment with different indices in the array. For example, also take a look at index 0.

import numpy as np
np.set_printoptions(linewidth=200)
import matplotlib.pyplot as plt
plt.imshow(training_images[0])
print(training_labels[0])
print(training_images[0])

If you notice that all of the values in the number are between 0 and 255. If we are training a neural network, for various reasons it’s easier if we treat all values as between 0 and 1, a process called ‘normalizing‘…and fortunately in Python it’s easy to normalize a list like this without looping. 

training_images  = training_images / 255.0
test_images = test_images / 255.0

Now you might be wondering why there are 2 sets…training and testing — remember the idea is to have 1 set of data for training, and then another set of data for testing…that the model hasn’t yet seen…to see how good it would be at classifying values. After all, when you’re done, you’re going to want to try it out with data that it hadn’t previously seen!

Let’s now design the model. There are quite a few new concepts here but don’t worry, you’ll get the hang of them by reading the description below.

model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), 
                                    tf.keras.layers.Dense(128, activation=tf.nn.relu), 
                                    tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

Sequential: That defines a SEQUENCE of layers in the neural network.

Flatten: Remember earlier where our images were a square when you printed them out? Flatten just takes that square and turns it into a 1-dimensional set.

Dense: Adds a layer of neurons.

Each layer of neurons needs an activation function to tell them what to do. There are lots of options, but just use these for now.

Relu effectively means “If X>0 return X, else return 0” — so what it does it only passes values 0 or greater to the next layer in the network.

Softmax takes a set of values, and effectively picks the biggest one, so, for example, if the output of the last layer looks like [0.1, 0.1, 0.05, 0.1, 9.5, 0.1, 0.05, 0.05, 0.05], it saves you from fishing through it looking for the biggest value, and turns it into [0,0,0,0,1,0,0,0,0] — The goal is to save a lot of coding! as well as time.

The next thing to do, now the model is defined, is to actually build it. You do this by compiling it with an optimizer and loss function as before — and then you train it by calling *model.fit * asking it to fit your training data to your training labels — i.e. have it figure out the relationship between the training data and its actual labels, so in future, if you have data that looks like the training data, then it can make a prediction for what that data would look like.

model.compile(optimizer = tf.optimizers.Adam(),
              loss = 'sparse_categorical_crossentropy',
              metrics=['accuracy'])

model.fit(training_images, training_labels, epochs=5)

Once it’s done training — you should see an accuracy value at the end of the final epoch. It might look something like 0.8142. This tells you that your neural network is about 81% accurate in classifying the training data. I.E., it figured out a pattern match between the image and the labels that worked 81% of the time. Not great, but not bad considering it was only trained for 5 epochs and done quite quickly.

But how would it work with unseen data? That’s why we have the test images.

We can call the function model.evaluate, and pass in the two sets, and it will report back the loss for each. Let’s take a look.

model.evaluate(test_images, test_labels)

An accuracy that was returned was about .7971, which means it was about 79% accurate. As expected it probably would not do as well with unseen data as it did with data it was trained on! As we move further, there are ways to improve this.

To explore further, let’s create a set of classifications for each of the test images, and then prints the first entry in the classifications.

classifications = model.predict(test_images)

print(classifications[0])

[8.9938662e-10, 1.9189129e-05, 1.6107211e-19, 4.0872710e-09, 2.3770831e-16, 1.9478011e-01, 4.6645251e-13, 1.3415834e-01, 5.3518648e-05, 6.7098886e-01]


The output of the model is a list of 10 numbers. These numbers are a probability that the value being classified is the corresponding value, i.e., the first value in the list is the probability that the image is of a ‘0’ (T-shirt/top), the next is a ‘1’ (Trouser), etc. Notice that they are all VERY LOW probabilities.

For the 9 (Ankle boot), the probability was in the ’90s, i.e. the neural network is telling us that it’s almost certainly a 7. The 10th element on the list is the biggest, and the ankle boot is labeled 9. The list has the 10th element being the highest value means that the Neural Network has predicted that the item it is classifying is most likely an ankle boot.

We came to the end, so far we have loaded data, built a model, and fed with training data we predicted ankle boot. A few key points to consider are:

Increase the number of neurons — The impact is training takes longer but results are accurate. By adding more Neurons we have to do more calculations, slowing down the process, but in this case, they have a good impact — we do get more accurate. That doesn’t mean it’s always a case of ‘more is better’, you can hit the law of diminishing returns very quickly!

Remove the Flatten() layer. Why do you think that’s the case you get an error about the shape of the data. It may seem vague right now, but it reinforces the rule of thumb that the first layer in your network should be the same shape as your data. Right now our data is 28×28 images, and 28 layers of 28 neurons would be infeasible, so it makes more sense to ‘flatten’ that 28,28 into a 784×1. Instead of writing all the code to handle that ourselves, we add the Flatten() layer at the beginning, and when the arrays are loaded into the model later, they’ll automatically be flattened for us.

Change final (output) layers — You get an error as soon as it finds an unexpected value. Another rule of thumb — the number of neurons in the last layer should match the number of classes you are classifying for. In this case, it’s the digits 0-9, so there are 10 of them, hence you should have 10 neurons in your final layer.

Consider the effects of additional layers in the network — There isn’t a significant impact — because this is relatively simple data. For far more complex data (including color images to be classified as flowers), extra layers are often necessary.

 The impact of training for more or fewer epochs — you might see the loss value stops decreasing, and sometimes increases. This is a side effect of something called ‘over-fitting’ and you need to keep an eye out for when training neural networks. There’s no point in wasting your time training if you aren’t improving your loss, right!

Callbacks — stop the training when I reach the desired value?’ — i.e. 95% accuracy might be enough for you, and if you reach that after 3 epochs, why sit around waiting for it to finish a lot more epochs…So how would you fix that? Like any other program…you have callbacks! Let’s see them in action…

Still, have any doubts? feel free to contact us.

Why Tensor?

TensorFlow is an open-source end-to-end platform for machine learning. It provides a comprehensive ecosystem of tools for developers, enterprises, and researchers who want to push the state-of-the-art of machine learning and build scalable machine learning-powered applications. TensorFlow was designed to help you learn to build models easily. With an intuitive easy-to-use set of APIs that makes it simple for you to learn and implement Machine Learning, Deep Learning and Scientific Computing.

TensorFlow provides a rich collection of tools for building models. These include data pre-processing, data ingestion, model evaluation, visualization and serving.

  • Data pre-processing the most important step in the data mining process, even though data preparation and filtering process take a significant amount of time. Often, given high value, because to deal with faulty Data-Collection methods resulting in missing values, out-of-range values (e.g., age: 1000). To say a few data pre-processing steps include normalization, transformation, treating missing values etc.,
  • Data ingestion plays a key role by allowing companies to move, store, integrate and further analyze data across many sources to make predictions and plan for upcoming needs despite many data ingestion challenges includes slow, complex and expensive.
  • A model evaluation which helps to find out the best model that represents our data as well as how well it will predict. With evaluation metrics, we can measure the goodness of fit between our model and data which emphasises prediction accuracy and to compare different models.
  • Visualization: TensorBoard is a suite of web applications for examining and understanding model graphs to track and visualize loss and accuracy. TensorBoard supports five visualizations i.e., to display images, text, audio, histograms and graphs.
  • Serving: TensorFlow serving is designed for production environments. TensorFlow Serving makes it easy to deploy new algorithms.

But it’s not just for building models. You can easily train and deploy your model anywhere with TensorFlow. It’s designed to be highly portable, running on a variety of devices and platforms. It can scale from a single CPU to a GPU or cluster of GPUs, all the way up to a multi-node TPU infrastructure. TensorFlow also allows for powerful experimentation with the flexibility to quickly implement state-of-the-art models, TensorFlow can power your research into new techniques to solve novel problems and solves everyday machine learning problems. From healthcare to social networks and e-commerce, TensorFlow can fit into any industry to solve their biggest problems.

Some case studies

  • Airbnb improves the guest experience by using TensorFlow to classify images and detect objects at scale.
  • Carousell uses TensorFlow to improve the buyer and seller experience.
  • Coca-Cola used TensorFlow to achieve a long-sought frictionless proof-of-purchase capability.
  • Paypal is using TensorFlow to stay at the cutting edge of Fraud Detection.

Some other use cases include diagnosis of diabetic retinopathy, helping rural farmers spot diseased plants, and predicting extreme weather conditions with fast debugging and the ability to apply state of the art ML models. And to top it all off, TensorFlow derives its roadmap from the needs of its users.

“How machine learning works is that the model will guess the relationship between the numbers”.

Basic Hello World example

Let’s walk through a basic Hello world example of building a machine learning model:

Take a look at these numbers

X = -1, 0, 1, 2, 3, 4,

Y = -3, -1, 1, 3, 5, 7

Can you see the relation between X and Y values?

It is actually Y = 2X – 1.

So, if u see it how did you get that, maybe you noticed Y value increases by 2 and X value increases by only 1. And then you may have seen when X was 0 then Y was -1, we figured Y = 2X – 1. We guessed this and this could work with all the remaining numbers this is the principle all machine leaning works on.

Let’s write a machine learning code that figures out what matches these numbers to each other.

Let’s define the model before writing the simplest possible neural network. A model is a trained neural network which in this case, is a single layer indicated by the ‘keras.layers.Dense code’. What is dense? A dense is a layer of connected neurons.

model = keras.Sequential([keras.layers.Dense(units=1, input_shape=[1])])

This layer has a single neuron in it, indicated by units = 1. We also feed a single value into the neural network which is the X value and we will have the neural network predict what the Y would be for that X. That is why input_shape is one value

model.compile(optimizer = ‘sgd’, loss = ‘mean_squared_error’)

Before compiling model we should know about two functions i.e., the loss and optimizer. These are the key to machine learning. How machine learning works is that the model will guess the relationship between the numbers.

For example, it might guess that Y = 5X + 5. And when training, it will then calculate how good or how bad that guess is, using loss function. And then, it will use the optimizer function to generate another guess. The logic is that the combination of these two functions will slowly get us closer and closer to the correct formula.


xs = np.array([ -1.0, 0.0, 1.0, 2.0, 3.0, 4.0], dtype = float)

ys = np.array([-3.0, -1.0, 1.0, 3.0, 5.0, 7.0], dtype = float)

model.fit(xs, ys, epochs = 500)

In this case, it will go through that loop 500 times, making a guess, calculating how accurate that guess is and then using the optimizer to enhance that guess, and so on. The data itself is set up as an array of Xs and Ys, and our process of matching them to each other is in the fit method of the model. We say, “fit the Xs to the Ys and try this 500 times.”

When it’s done, we will have a trained model. So, now you can try to predict a Y value for a given X.

print(model.predict([10.0]))

Predict the Y when X equals to 10. You might think that the answer is 19, right? But it isn’t. It’s something like 18.9998. It is close to 19, but it’s not quite there. Why do you think that would be?

Well, the computer was trained to match only six pairs of numbers. It looks like a straight-line relationship between them, for those six, but it may not be a straight line for values outside of those six. There’s a very high probability that it is a straight line, but we cannot be certain. And this probability is built into the prediction, so it is telling us very close to 19, instead of exactly 19.

So far, we have learned what is TensorFlow, what tools TensorFlow provides and how to use them and use cases of TensorFlow in real-world which drives impactful solutions to the ultra-modern problems and demonstration of building a basic machine learning model in TensorFlow.

A preparatory guide on Machine Learning.

A gentle introduction to ML

So, the industry right now is exploding, right? There’s Deep Learning and Machine Learning skills are becoming ever more important and opening up whole new plots. Machine learning and AI is no longer just a technical thing limited to the software industry it’s becoming prominent in every industry in a steady manner.

With Deep Learning, Machine Learning one of the best tools you can use to implement these algorithms is TensorFlow.

Learning algorithms can be quite complicated, and today, programming frameworks like TensorFlow, PyTorch, Caffe and many others can save you a lot of time in coding and debugging volumes of codes.


Coding has been the fuel for many brains since the rise of the computers. We have been building applications by decomposing problems with optimal solutions that can then be coded against. Say for example if we’re writing a snake game we usually figure out rules, if snake swallows the object then the object should vanish and again new object should appear for the snake to swallow. But if the snake hits the walls then the player loses their life. We can represent with this diagram

In conventional programming, Rules and Data are fed Results will be generated. Rules and data go in Results come out. Rules are expressed in a programming language i.e., syntax and data range from a text file all the way up to video file it may be any data.

Machine learning makes our lives easier by flipping the axes. In machine learning algorithm Results and Data are fed and Rules will be generated.

So, instead of us as developers figuring out the rules when should the snake swallow, when should the player’s life end, what we will do is, we can get a bunch of examples for what we want to see and then have the computer figure out the rules. Now, this is particularly valuable for problems that you can’t solve by figuring the rules out for yourself.

Consider this example, Impact app; https://impactapp.in/ you raise money by walking or jogging or exercising/running and money goes to various charitable causes… an app that detects if somebody is say walking and we have data about their speed, we might write code like this

 if(velocity<4)
 {
 activity=walking;
  }

And if they’re moving well that’s a faster speed so we could adapt to code to this.

if(velocity<4)
{
activity=walking;
 }
else
{
activity=jogging;
}

If they’re running, well that’s not too bad either we can code like this.

if(velocity<4)
{
 activity=walking;
 }  
else if(velocity<15)
{
 activity=jogging;
  } 
  else 
  {
   activity=running;
  }

We walk and run at different speeds but what if a person runs like “Usian Bolt” 27.7380 miles per hour. Now, these concepts become broken, Impact app may assumes he is on a running vehicle but actually he is a speedster. Not only that if we consider only speed is quite not sufficient to estimate status but also results may not be accurate. Ultimately machine learning is very similar to this so, instead of trying to express the problem as rules when often that is impossible, we have to compromise. So, what we have to do is get lots and lots of examples and label and use this data to say this is what walking looks like, this is what jogging looks like, this is what running looks like. So, then it becomes Results and Data in with Rules being inferred by the machine as shown in fig 2.

Machine learning is all about a computer learning the patterns that distinguish things. Like for Impact app, it was the pattern of walking, jogging and running that can be learned from various sensors on a device. We will tell a computer what the data represents (i.e. this data is for walking, this data is for running), this process is called Labelling data. Computer distinguishes these activities as walking, jogging, running. These metrics may vary but this is the basic idea behind the devices.

Walking
Computer distinguishes this activity as walking.
Jogging
Computer recognises this activity as jogging.

A machine learning algorithm then figures out the specific patterns in each set of data that determines the distinctiveness of each.

Labelling follows the same for running as well.

This activity is inferred as running by the computer.

“Machine Learning represents a new paradigm in programming, where instead of programming explicit rules in a language such as C or C++, you build a system which is trained on data to infer the rules itself”.

With this programming paradigm we can just do any old thing in a new feasible way. Neural Network which is the pillar of doing this type of pattern recognition. A Neural Network is slightly more advanced implementation of machine learning and we call that as Deep Learning. So far we have learned what Machine Learning is how computer recognises patters to discriminate things and how it will label data to identify things.