![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\"){kind=icon}
Source: cognitiveclass.ai
7 | 8 | This is the first part of a series where I will be posting many blog posts about coding Machine Learning and Deep Learning algorithms. I believe in hands-on coding so we will have many exercises and demos which you can try yourself too. I would recommend you to play around with these exercises and change the hyper-parameters and experiment with the code. That is the best way to learn and code efficiently. If you don’t know what hyper-parameters are don’t worry. We will walk through Tensor Flow’s core capabilities and then also explore high level API’s in TensorFlow and so on. 9 | 10 | ## Is this series for me? 11 | 12 | If you are a person who is looking to get started with Tensor Flow, Machine Learning and Deep Learning but don’t have any knowledge about Machine Learning you can do this. 13 | If you already know about Machine Learning and Deep Learning and don’t know about Tensor Flow you can follow these. As you might be using some other frameworks or libraries like Caffe, Theano, CNTK, Apple ML or PyTorch and might also be knowing about the maths behind it you can skip the sections marked OPTIONAL. 14 | If you know about the basics of Tensor Flow then you can skip some of the blog posts. 15 | 16 | ## Is any software setup needed? 17 | 18 | No!! 19 | 20 | Not at all, you don’t need to install any software at all to complete the exercises and follow the code at all. We will be using [Google Colaboratory](http://colab.research.google.com/). Colaboratory is a research tool for machine learning education and research. It’s a Jupyter notebook environment that requires no setup to use. Colaboratory works with most major browsers and is most thoroughly tested with the latest versions of [Chrome](https://www.google.com/chrome/browser/desktop/index.html), [Firefox](https://www.mozilla.org/en-US/firefox/), and [Safari](https://www.apple.com/safari/). And what more, it is completely free to use. All Colaboratory notebooks are stored in Google Drive. Colaboratory notebooks can be shared just as you would with Google Docs or Sheets. Simply click the Share button at the top right of any Colaboratory notebook, or follow these Google Drive [file sharing instructions](https://support.google.com/drive/answer/2494822?co=GENIE.Platform%3DDesktop&hl=en). Before, you ask me Colaboratory is really reliable and fast too. 21 | 22 | However, you can also use a local development environment preferably Jupyter Notebooks but we will not be covering how to set up the local environment in these blogs. 23 | 24 | ## Which Version of Tensor Flow? 25 | 26 | The answer to this question is that in this blog we will cover both. If you are using Colab notebooks add this code. 27 | 28 | ```python 29 | try: 30 | # %tensorflow_version only exists in Colab. 31 | %tensorflow_version 2.x 32 | except Exception: 33 | pass 34 | 35 | import tensorflow as tf 36 | ``` 37 | 38 | ## Introduction 39 | 40 | Coding has been the bread and butter for developers since the dawn of computing. We’re used to creating applications by breaking down requirements into composable problems that can then be coded against. So for example, if we have to write an application that figures out a stock analytic, maybe the price divided by the ratio, we can usually write code to get the values from a data source, do the calculation and then return the result. Or if we’re writing a game we can usually figure out the rules. For example, if the ball hits the brick then the brick should vanish and the ball should rebound. But if the ball falls off the bottom of the screen then maybe the player loses their life. 41 | 42 | We can represent that with this diagram. Rules and data go in answers come out. Rules are expressed in a programming language and data can come from a variety of sources from local variables up to databases. Machine learning rearranges this diagram where we put answers in data in and then we get rules out. So instead of us as developers figuring out the rules when should the brick be removed, when should the player’s life end, or what’s the desired analytic for any other concept, 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. 43 | 44 |  45 |Traditional Programming vs Machine Learning
46 | 47 | So consider this example, activity recognition. If I’m building a device that detects if somebody is say walking and I have data about their speed, I might write code like this and if they’re running well that’s a faster speed so I could adapt my code to this and if they’re biking, well that’s not too bad either. I can adapt my code like this. But then I have to do golf recognition too, now my concept becomes broken. But not only that, doing it by speed alone of course is quite naive. We walk and run at different speeds uphill and downhill and other people walk and run at different speeds to us. 48 | 49 |  50 |A traditional programming logic
51 | 52 | The new paradigm is that I get lots and lots of examples and then I have labels on those examples and I use the data to say this is what walking looks like, this is what running looks like, this is what biking looks like and yes, even this is what golfing looks like. So, then it becomes answers and data in with rules being inferred by the machine. A machine learning algorithm then figures out the specific patterns in each set of data that determines the distinctiveness of each. That’s what’s so powerful and exciting about this programming paradigm. It’s more than just a new way of doing the same old thing. It opens up new possibilities that were infeasible to do before. 53 | 54 | So, now I am going to show you the basics of creating a neural network for doing this type of pattern recognition. A neural network is just a slightly more advanced implementation of machine learning and we call that deep learning. But fortunately it's actually very easy to code. So, we're just going to jump straight into deep learning. We'll start with a simple one and then we'll move on to one that does computer vision in about 10 lines of code. 55 | Hello Neural Networks 56 | 57 | To show how that works, let’s take a look at a set of numbers and see if you can determine the pattern between them. Okay, here are the numbers. 58 | 59 | x = -1, 0, 1, 2, 3, 4 60 | 61 | y = -3, -1, 1, 3, 5, 7 62 | 63 | You easily figure this out `y = 2x — 1` 64 | 65 | You probably tried that out with a couple of other values and see that it fits. Congratulations, you’ve just done the basics of machine learning in your head. 66 | 67 | Okay, here’s our first line of code. This is written using Python and TensorFlow and an API in TensorFlow called keras. Keras makes it really easy to define neural networks. A neural network is basically a set of functions which can learn patterns. 68 | 69 | ```python 70 | model = keras.Sequential([keras.layers.Dense(units = 1, input_shape = [1])]) 71 | ``` 72 | 73 | The simplest possible neural network is one that has only one neuron in it, and that’s what this line of code does. In keras we use the word Dense to define a layer of connected neurons. There is only one Dense here means that there is only one layer and there is only single unit in it so there is only one neuron. Successive layers in keras are defined in a sequence so the word Sequential . You define the shape of what's input to the neural network in the first and in this case the only layer, and you can see that our input shape is super simple. It's just one value. You've probably seen that for machine learning, you need to know and use a lot of math, calculus probability and the like. It's really good to understand that as you want to optimize your models but the nice thing for now about TensorFlow and keras is that a lot of that math is implemented for you in functions. There are two function roles that you should be aware of though and these are loss functions and optimizers. 74 | 75 | ```python 76 | model.compile(optimizer = 'sgd', loss = 'mean_squared_error') 77 | ``` 78 | 79 | This lines defines that for us. So, lets understand what it is. 80 | 81 | Understand it like this the neural network has no idea of the relation between `X` and `Y` so it makes a random guess say `y=x+3` . It will then use the data that it knows about, that’s the set of Xs and Ys that we’ve already seen to measure how good or how bad its guess was. The loss function measures this and then gives the data to the optimizer which figures out the next guess. So the optimizer thinks about how good or how badly the guess was done using the data from the loss function. Then the logic is that each guess should be better than the one before. As the guesses get better and better, an accuracy approaches 100 percent, the term convergence is used. 82 | 83 | Here we have used the loss function as mean squared error and optimizer as SGD or stochactic gradient descent. 84 | 85 | Our next step is to represent the known data. These are the Xs and the Ys that you saw earlier. The np.array is using a Python library called numpy that makes data representation particularly enlists much easier. So here you can see we have one list for the Xs and another one for the Ys. The training takes place in the fit command. Here we’re asking the model to figure out how to fit the X values to the Y values. The epochs equals 500 value means that it will go through the training loop 500 times. This training loop is what we described earlier. Make a guess, measure how good or how bad the guesses with the loss function, then use the optimizer and the data to make another guess and repeat this. When the model has finished training, it will then give you back values using the predict method. 86 | 87 | Here’s the code of what we talked about. 88 | 89 | ```python 90 | xs = np.array([-1.0, 0.0, 1.0, 2.0, 3.0, 4.0], dtype=float) 91 | ys = np.array([-3.0, -1.0, 1.0, 3.0, 5.0, 7.0], dtype=float)model.fit(xs, ys, epochs=500) 92 | print(model.predict([10.0])) 93 | ``` 94 | 95 | So, what output do you except — 19, right? 96 | 97 | But when you try this in the workbook yourself you will see it gives me a value close to 19 not 19. Like you might receive- 98 | 99 | ```python 100 | [[18.987219]] 101 | ``` 102 | 103 | Why do you think this happens because the equation is `y = 2x-1` . 104 | 105 | There are two main reasons: 106 | 107 | The first is that you trained it using very little data. There’s only six points. Those six points are linear but there’s no guarantee that for every X, the relationship will be Y equals 2X minus 1. There’s a very high probability that Y equals 19 for X equals 10, but the neural network isn’t positive. So it will figure out a realistic value for Y. The the second main reason. When using neural networks, as they try to figure out the answers for everything, they deal in probability. You’ll see that a lot and you’ll have to adjust how you handle answers to fit. Keep that in mind as you work through the code. Okay, enough talking. Now let’s get hands-on and write the code that we just saw and then we can run it. 108 | 109 | ## Hands-on Hello with Neural Nets 110 | 111 | If you have used Jupyter before you will find Colab easy to use. If you have not used Colab before consider watching this intro to it. 112 | 113 | Introduction to Google Colab 114 | 115 | [](https://www.youtube.com/watch?v=inN8seMm7UI) 116 |Introduction to Google Colab
117 | 118 | Now you know how to use Colab so let’s get started. 119 | 120 | If you are using Jupyter Notebooks in your local environment download the code file [here](https://github.com/Rishit-dagli/Deep-Learning-With-TensorFlow-Blog-series/blob/master/Part%201-Getting%20started%20with%20TensorFlow%20and%20Deep%20Learning/Hello_Neural_Nets.ipynb). 121 | 122 | If you are using Colab follow the link [here](https://colab.research.google.com/github/Rishit-dagli/Artificial-Intelligence_resources-and-notebooks/blob/master/Hello_Neural_Nets.ipynb). You need to sign in with your Google account to run the code and receive a hosted run time. 123 | 124 | I recommend you to spend some time with the notebook and try changing the epochs and see the effect on loss and accuracy and experiment with the code. 125 | 126 | ## Exercise — 1 127 | 128 | In this exercise you’ll try to build a neural network that predicts the price of a house according to a simple formula. So, imagine if house pricing was as easy as a house costs 50k + 50k per bedroom, so that a 1 bedroom house costs 100k, a 2 bedroom house costs 150k etc. How would you create a neural network that learns this relationship so that it would predict a 7 bedroom house as costing close to 400k etc. 129 | 130 | Hint: Your network might work better if you scale the house price down. You don’t have to give the answer 400…it might be better to create something that predicts the number 4, and then your answer is in the ‘hundreds of thousands’ etc. 131 | 132 | Note: The maximum error allowed is 400 dollars 133 | 134 | Make a new Colab Notebook and write your solution for this exercise and try it with some numbers the model has not seen. 135 | 136 | ## My Solution 137 | 138 | Wonderful, you just created a neural net all by yourself and some of you must be feeling like this (it’s perfectly ok)- 139 | 140 |  141 |Source: me.me
142 | 143 | Let’s see my solution to this. 144 | 145 | ```python 146 | def house_model(y_new): 147 | xs=[] 148 | ys=[] 149 | for i in range(1,10): 150 | xs.append(i) 151 | ys.append((1+float(i))*50) 152 | 153 | xs=np.array(xs,dtype=float) 154 | ys=np.array(ys, dtype=float)model = keras.Sequential([keras.layers.Dense(units = 1, input_shape = [1])]) 155 | model.compile(optimizer='sgd', loss='mean_squared_error') 156 | 157 | model.fit(xs, ys, epochs = 4500) 158 | return (model.predict(y_new)[0]/100) 159 | ``` 160 | 161 | And this gives me the answer to the required tolerate limit. 162 | 163 | Here’s the Solution to this exercise — [here](https://github.com/Rishit-dagli/Deep-Learning-With-TensorFlow-Blog-series/blob/master/Part%201-Getting%20started%20with%20TensorFlow%20and%20Deep%20Learning/Excercise_1_Solution.ipynb) 164 | 165 | If you want to try this out in Colab you can go to the link and click open on colab button. 166 | 167 | That was it, the basics. You even created a neural net all by yourself and made pretty accurate predictions too. Next, we will see about using some image classifiers with Tensor Flow so, stay tuned and explore till then. 168 | 169 | Some useful resources for further reading 170 | 171 | * Learn more about Colab [here](https://colab.research.google.com/notebooks/welcome.ipynb) 172 | * TensorFlow website [here](https://www.tensorflow.org/) 173 | * TensorFlow docs [here](https://github.com/tensorflow/docs) 174 | * GitHub repository [here](https://github.com/tensorflow/tensorflow) 175 | * A wonderful Neural Nets research paper [here](https://www.sciencedirect.com/science/article/abs/pii/S0893608014002135) 176 | * A wonderful visualization tool by TensorFlow [here](http://projector.tensorflow.org/) 177 | * TensorFlow models and data sets [here](https://www.tensorflow.org/resources/models-datasets) 178 | 179 | Some TensorFlow research papers 180 | 181 | * Large scale Machine Learning with TensorFlow [here](http://download.tensorflow.org/paper/whitepaper2015.pdf) 182 | * A Deep Level Understanding of Recurrent Neural Network & LSTM with Practical Implementation in Keras & Tensorflow [here](https://www.academia.edu/41209114/A_Deep_Level_Understanding_of_Recurrent_Neural_Network_and_LSTM_with_Practical_Implementation_in_Keras_and_Tensorflow) 183 | 184 | ## About Me 185 | 186 | Hi everyone I am Rishit Dagli 187 | 188 | [Twitter](https://twitter.com/rishit_dagli) 189 | 190 | [Website](https://rishit.tech/) 191 | 192 | If you want to ask me some questions, report any mistake, suggest improvements, give feedback you are free to do so by emailing me at — 193 | 194 | * [rishit.dagli@gmail.com](mailto:rishit.dagli@gmail.com) 195 | 196 | * [hello@rishit.tech](mailto:hello@rishit.tech) 197 | 198 | -------------------------------------------------------------------------------- /Part 2-Computer Vision with TensorFlow/Callbacks_example_Notebook.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "name": "Callbacks example Notebook.ipynb", 7 | "provenance": [], 8 | "collapsed_sections": [], 9 | "include_colab_link": true 10 | }, 11 | "kernelspec": { 12 | "name": "python3", 13 | "display_name": "Python 3" 14 | } 15 | }, 16 | "cells": [ 17 | { 18 | "cell_type": "markdown", 19 | "metadata": { 20 | "id": "view-in-github", 21 | "colab_type": "text" 22 | }, 23 | "source": [ 24 | ""
25 | ]
26 | },
27 | {
28 | "cell_type": "code",
29 | "metadata": {
30 | "id": "N9-BCmi15L93",
31 | "colab_type": "code",
32 | "colab": {}
33 | },
34 | "source": [
35 | "import tensorflow as tf\n",
36 | "\n",
37 | "class myCallback(tf.keras.callbacks.Callback):\n",
38 | " def on_epoch_end(self, epoch, logs={}):\n",
39 | " if(logs.get('acc') > 0.6):\n",
40 | " print(\"\\nReached 60% accuracy so cancelling training!\")\n",
41 | " self.model.stop_training = True\n",
42 | "\n",
43 | "mnist = tf.keras.datasets.fashion_mnist\n",
44 | "\n",
45 | "(x_train, y_train),(x_test, y_test) = mnist.load_data()\n",
46 | "x_train, x_test = x_train / 255.0, x_test / 255.0\n",
47 | "\n",
48 | "callbacks = myCallback()\n",
49 | "\n",
50 | "model = tf.keras.models.Sequential([\n",
51 | " tf.keras.layers.Flatten(input_shape=(28, 28)),\n",
52 | " tf.keras.layers.Dense(512, activation=tf.nn.relu),\n",
53 | " tf.keras.layers.Dense(10, activation=tf.nn.softmax)\n",
54 | "])\n",
55 | "model.compile(optimizer='adam',\n",
56 | " loss='sparse_categorical_crossentropy',\n",
57 | " metrics=['accuracy'])\n",
58 | "\n",
59 | "model.fit(x_train, y_train, epochs=10, callbacks=[callbacks])"
60 | ],
61 | "execution_count": 0,
62 | "outputs": []
63 | }
64 | ]
65 | }
--------------------------------------------------------------------------------
/Part 2-Computer Vision with TensorFlow/Computer_vision_examples_Notebook.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "nbformat": 4,
3 | "nbformat_minor": 0,
4 | "metadata": {
5 | "colab": {
6 | "name": "Computer vision examples Notebook.ipynb",
7 | "provenance": [],
8 | "collapsed_sections": [],
9 | "include_colab_link": true
10 | },
11 | "kernelspec": {
12 | "name": "python3",
13 | "display_name": "Python 3"
14 | }
15 | },
16 | "cells": [
17 | {
18 | "cell_type": "markdown",
19 | "metadata": {
20 | "id": "view-in-github",
21 | "colab_type": "text"
22 | },
23 | "source": [
24 | ""
25 | ]
26 | },
27 | {
28 | "cell_type": "markdown",
29 | "metadata": {
30 | "id": "qnyTxjK_GbOD",
31 | "colab_type": "text"
32 | },
33 | "source": [
34 | "# Beyond Hello Neural Nets, A Computer Vision Example\n",
35 | "\n",
36 | "In the previous exercise you saw how to create a neural network that figured out the problem you were trying to solve. This gave an explicit example of learned behavior. Of course, in that instance, it was a bit of overkill because it would have been easier to write the function $Y=2x-1$ directly, instead of bothering with using Machine Learning to learn the relationship between X and Y for a fixed set of values, and extending that for all values.\n",
37 | "\n",
38 | "But what about a scenario where writing rules like that is much more difficult -- for example a computer vision problem? Let's take a look at a scenario where we can recognize different items of clothing, trained from a dataset containing 10 different types."
39 | ]
40 | },
41 | {
42 | "cell_type": "markdown",
43 | "metadata": {
44 | "id": "H41FYgtlHPjW",
45 | "colab_type": "text"
46 | },
47 | "source": [
48 | "## Start Coding\n",
49 | "\n",
50 | "Let's start with our import of TensorFlow"
51 | ]
52 | },
53 | {
54 | "cell_type": "code",
55 | "metadata": {
56 | "id": "q3KzJyjv3rnA",
57 | "colab_type": "code",
58 | "outputId": "2e0ae277-b2e5-4a1d-b153-a6542b6c68e9",
59 | "colab": {
60 | "base_uri": "https://localhost:8080/",
61 | "height": 54
62 | }
63 | },
64 | "source": [
65 | "try:\n",
66 | " %tensorflow_version 2.x\n",
67 | "except Exception:\n",
68 | " pass\n",
69 | "import tensorflow as tf\n",
70 | "print(tf.__version__)"
71 | ],
72 | "execution_count": 0,
73 | "outputs": [
74 | {
75 | "output_type": "stream",
76 | "text": [
77 | "TensorFlow 2.x selected.\n",
78 | "2.1.0-rc1\n"
79 | ],
80 | "name": "stdout"
81 | }
82 | ]
83 | },
84 | {
85 | "cell_type": "markdown",
86 | "metadata": {
87 | "id": "n_n1U5do3u_F",
88 | "colab_type": "text"
89 | },
90 | "source": [
91 | "The Fashion MNIST data is available directly in the tf.keras datasets API. You load it like this:"
92 | ]
93 | },
94 | {
95 | "cell_type": "code",
96 | "metadata": {
97 | "id": "PmxkHFpt31bM",
98 | "colab_type": "code",
99 | "colab": {}
100 | },
101 | "source": [
102 | "mnist = tf.keras.datasets.fashion_mnist"
103 | ],
104 | "execution_count": 0,
105 | "outputs": []
106 | },
107 | {
108 | "cell_type": "markdown",
109 | "metadata": {
110 | "id": "GuoLQQBT4E-_",
111 | "colab_type": "text"
112 | },
113 | "source": [
114 | "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.\n"
115 | ]
116 | },
117 | {
118 | "cell_type": "code",
119 | "metadata": {
120 | "id": "BTdRgExe4TRB",
121 | "colab_type": "code",
122 | "colab": {}
123 | },
124 | "source": [
125 | "(training_images, training_labels), (test_images, test_labels) = mnist.load_data()"
126 | ],
127 | "execution_count": 0,
128 | "outputs": []
129 | },
130 | {
131 | "cell_type": "markdown",
132 | "metadata": {
133 | "id": "rw395ROx4f5Q",
134 | "colab_type": "text"
135 | },
136 | "source": [
137 | "What does 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 42...that's a a different boot than the one at index 0\n"
138 | ]
139 | },
140 | {
141 | "cell_type": "code",
142 | "metadata": {
143 | "id": "FPc9d3gJ3jWF",
144 | "colab_type": "code",
145 | "outputId": "cb7fd9ae-fcad-4d3e-81ad-0d3635c1fd1a",
146 | "colab": {
147 | "base_uri": "https://localhost:8080/",
148 | "height": 1000
149 | }
150 | },
151 | "source": [
152 | "import matplotlib.pyplot as plt\n",
153 | "plt.imshow(training_images[0])\n",
154 | "print(training_labels[0])\n",
155 | "print(training_images[0])"
156 | ],
157 | "execution_count": 0,
158 | "outputs": [
159 | {
160 | "output_type": "stream",
161 | "text": [
162 | "9\n",
163 | "[[0. 0. 0. 0. 0. 0.\n",
164 | " 0. 0. 0. 0. 0. 0.\n",
165 | " 0. 0. 0. 0. 0. 0.\n",
166 | " 0. 0. 0. 0. 0. 0.\n",
167 | " 0. 0. 0. 0. ]\n",
168 | " [0. 0. 0. 0. 0. 0.\n",
169 | " 0. 0. 0. 0. 0. 0.\n",
170 | " 0. 0. 0. 0. 0. 0.\n",
171 | " 0. 0. 0. 0. 0. 0.\n",
172 | " 0. 0. 0. 0. ]\n",
173 | " [0. 0. 0. 0. 0. 0.\n",
174 | " 0. 0. 0. 0. 0. 0.\n",
175 | " 0. 0. 0. 0. 0. 0.\n",
176 | " 0. 0. 0. 0. 0. 0.\n",
177 | " 0. 0. 0. 0. ]\n",
178 | " [0. 0. 0. 0. 0. 0.\n",
179 | " 0. 0. 0. 0. 0. 0.\n",
180 | " 0.00392157 0. 0. 0.05098039 0.28627451 0.\n",
181 | " 0. 0.00392157 0.01568627 0. 0. 0.\n",
182 | " 0. 0.00392157 0.00392157 0. ]\n",
183 | " [0. 0. 0. 0. 0. 0.\n",
184 | " 0. 0. 0. 0. 0. 0.\n",
185 | " 0.01176471 0. 0.14117647 0.53333333 0.49803922 0.24313725\n",
186 | " 0.21176471 0. 0. 0. 0.00392157 0.01176471\n",
187 | " 0.01568627 0. 0. 0.01176471]\n",
188 | " [0. 0. 0. 0. 0. 0.\n",
189 | " 0. 0. 0. 0. 0. 0.\n",
190 | " 0.02352941 0. 0.4 0.8 0.69019608 0.5254902\n",
191 | " 0.56470588 0.48235294 0.09019608 0. 0. 0.\n",
192 | " 0. 0.04705882 0.03921569 0. ]\n",
193 | " [0. 0. 0. 0. 0. 0.\n",
194 | " 0. 0. 0. 0. 0. 0.\n",
195 | " 0. 0. 0.60784314 0.9254902 0.81176471 0.69803922\n",
196 | " 0.41960784 0.61176471 0.63137255 0.42745098 0.25098039 0.09019608\n",
197 | " 0.30196078 0.50980392 0.28235294 0.05882353]\n",
198 | " [0. 0. 0. 0. 0. 0.\n",
199 | " 0. 0. 0. 0. 0. 0.00392157\n",
200 | " 0. 0.27058824 0.81176471 0.8745098 0.85490196 0.84705882\n",
201 | " 0.84705882 0.63921569 0.49803922 0.4745098 0.47843137 0.57254902\n",
202 | " 0.55294118 0.34509804 0.6745098 0.25882353]\n",
203 | " [0. 0. 0. 0. 0. 0.\n",
204 | " 0. 0. 0. 0.00392157 0.00392157 0.00392157\n",
205 | " 0. 0.78431373 0.90980392 0.90980392 0.91372549 0.89803922\n",
206 | " 0.8745098 0.8745098 0.84313725 0.83529412 0.64313725 0.49803922\n",
207 | " 0.48235294 0.76862745 0.89803922 0. ]\n",
208 | " [0. 0. 0. 0. 0. 0.\n",
209 | " 0. 0. 0. 0. 0. 0.\n",
210 | " 0. 0.71764706 0.88235294 0.84705882 0.8745098 0.89411765\n",
211 | " 0.92156863 0.89019608 0.87843137 0.87058824 0.87843137 0.86666667\n",
212 | " 0.8745098 0.96078431 0.67843137 0. ]\n",
213 | " [0. 0. 0. 0. 0. 0.\n",
214 | " 0. 0. 0. 0. 0. 0.\n",
215 | " 0. 0.75686275 0.89411765 0.85490196 0.83529412 0.77647059\n",
216 | " 0.70588235 0.83137255 0.82352941 0.82745098 0.83529412 0.8745098\n",
217 | " 0.8627451 0.95294118 0.79215686 0. ]\n",
218 | " [0. 0. 0. 0. 0. 0.\n",
219 | " 0. 0. 0. 0.00392157 0.01176471 0.\n",
220 | " 0.04705882 0.85882353 0.8627451 0.83137255 0.85490196 0.75294118\n",
221 | " 0.6627451 0.89019608 0.81568627 0.85490196 0.87843137 0.83137255\n",
222 | " 0.88627451 0.77254902 0.81960784 0.20392157]\n",
223 | " [0. 0. 0. 0. 0. 0.\n",
224 | " 0. 0. 0. 0. 0.02352941 0.\n",
225 | " 0.38823529 0.95686275 0.87058824 0.8627451 0.85490196 0.79607843\n",
226 | " 0.77647059 0.86666667 0.84313725 0.83529412 0.87058824 0.8627451\n",
227 | " 0.96078431 0.46666667 0.65490196 0.21960784]\n",
228 | " [0. 0. 0. 0. 0. 0.\n",
229 | " 0. 0. 0. 0.01568627 0. 0.\n",
230 | " 0.21568627 0.9254902 0.89411765 0.90196078 0.89411765 0.94117647\n",
231 | " 0.90980392 0.83529412 0.85490196 0.8745098 0.91764706 0.85098039\n",
232 | " 0.85098039 0.81960784 0.36078431 0. ]\n",
233 | " [0. 0. 0.00392157 0.01568627 0.02352941 0.02745098\n",
234 | " 0.00784314 0. 0. 0. 0. 0.\n",
235 | " 0.92941176 0.88627451 0.85098039 0.8745098 0.87058824 0.85882353\n",
236 | " 0.87058824 0.86666667 0.84705882 0.8745098 0.89803922 0.84313725\n",
237 | " 0.85490196 1. 0.30196078 0. ]\n",
238 | " [0. 0.01176471 0. 0. 0. 0.\n",
239 | " 0. 0. 0. 0.24313725 0.56862745 0.8\n",
240 | " 0.89411765 0.81176471 0.83529412 0.86666667 0.85490196 0.81568627\n",
241 | " 0.82745098 0.85490196 0.87843137 0.8745098 0.85882353 0.84313725\n",
242 | " 0.87843137 0.95686275 0.62352941 0. ]\n",
243 | " [0. 0. 0. 0. 0.07058824 0.17254902\n",
244 | " 0.32156863 0.41960784 0.74117647 0.89411765 0.8627451 0.87058824\n",
245 | " 0.85098039 0.88627451 0.78431373 0.80392157 0.82745098 0.90196078\n",
246 | " 0.87843137 0.91764706 0.69019608 0.7372549 0.98039216 0.97254902\n",
247 | " 0.91372549 0.93333333 0.84313725 0. ]\n",
248 | " [0. 0.22352941 0.73333333 0.81568627 0.87843137 0.86666667\n",
249 | " 0.87843137 0.81568627 0.8 0.83921569 0.81568627 0.81960784\n",
250 | " 0.78431373 0.62352941 0.96078431 0.75686275 0.80784314 0.8745098\n",
251 | " 1. 1. 0.86666667 0.91764706 0.86666667 0.82745098\n",
252 | " 0.8627451 0.90980392 0.96470588 0. ]\n",
253 | " [0.01176471 0.79215686 0.89411765 0.87843137 0.86666667 0.82745098\n",
254 | " 0.82745098 0.83921569 0.80392157 0.80392157 0.80392157 0.8627451\n",
255 | " 0.94117647 0.31372549 0.58823529 1. 0.89803922 0.86666667\n",
256 | " 0.7372549 0.60392157 0.74901961 0.82352941 0.8 0.81960784\n",
257 | " 0.87058824 0.89411765 0.88235294 0. ]\n",
258 | " [0.38431373 0.91372549 0.77647059 0.82352941 0.87058824 0.89803922\n",
259 | " 0.89803922 0.91764706 0.97647059 0.8627451 0.76078431 0.84313725\n",
260 | " 0.85098039 0.94509804 0.25490196 0.28627451 0.41568627 0.45882353\n",
261 | " 0.65882353 0.85882353 0.86666667 0.84313725 0.85098039 0.8745098\n",
262 | " 0.8745098 0.87843137 0.89803922 0.11372549]\n",
263 | " [0.29411765 0.8 0.83137255 0.8 0.75686275 0.80392157\n",
264 | " 0.82745098 0.88235294 0.84705882 0.7254902 0.77254902 0.80784314\n",
265 | " 0.77647059 0.83529412 0.94117647 0.76470588 0.89019608 0.96078431\n",
266 | " 0.9372549 0.8745098 0.85490196 0.83137255 0.81960784 0.87058824\n",
267 | " 0.8627451 0.86666667 0.90196078 0.2627451 ]\n",
268 | " [0.18823529 0.79607843 0.71764706 0.76078431 0.83529412 0.77254902\n",
269 | " 0.7254902 0.74509804 0.76078431 0.75294118 0.79215686 0.83921569\n",
270 | " 0.85882353 0.86666667 0.8627451 0.9254902 0.88235294 0.84705882\n",
271 | " 0.78039216 0.80784314 0.72941176 0.70980392 0.69411765 0.6745098\n",
272 | " 0.70980392 0.80392157 0.80784314 0.45098039]\n",
273 | " [0. 0.47843137 0.85882353 0.75686275 0.70196078 0.67058824\n",
274 | " 0.71764706 0.76862745 0.8 0.82352941 0.83529412 0.81176471\n",
275 | " 0.82745098 0.82352941 0.78431373 0.76862745 0.76078431 0.74901961\n",
276 | " 0.76470588 0.74901961 0.77647059 0.75294118 0.69019608 0.61176471\n",
277 | " 0.65490196 0.69411765 0.82352941 0.36078431]\n",
278 | " [0. 0. 0.29019608 0.74117647 0.83137255 0.74901961\n",
279 | " 0.68627451 0.6745098 0.68627451 0.70980392 0.7254902 0.7372549\n",
280 | " 0.74117647 0.7372549 0.75686275 0.77647059 0.8 0.81960784\n",
281 | " 0.82352941 0.82352941 0.82745098 0.7372549 0.7372549 0.76078431\n",
282 | " 0.75294118 0.84705882 0.66666667 0. ]\n",
283 | " [0.00784314 0. 0. 0. 0.25882353 0.78431373\n",
284 | " 0.87058824 0.92941176 0.9372549 0.94901961 0.96470588 0.95294118\n",
285 | " 0.95686275 0.86666667 0.8627451 0.75686275 0.74901961 0.70196078\n",
286 | " 0.71372549 0.71372549 0.70980392 0.69019608 0.65098039 0.65882353\n",
287 | " 0.38823529 0.22745098 0. 0. ]\n",
288 | " [0. 0. 0. 0. 0. 0.\n",
289 | " 0. 0.15686275 0.23921569 0.17254902 0.28235294 0.16078431\n",
290 | " 0.1372549 0. 0. 0. 0. 0.\n",
291 | " 0. 0. 0. 0. 0. 0.\n",
292 | " 0. 0. 0. 0. ]\n",
293 | " [0. 0. 0. 0. 0. 0.\n",
294 | " 0. 0. 0. 0. 0. 0.\n",
295 | " 0. 0. 0. 0. 0. 0.\n",
296 | " 0. 0. 0. 0. 0. 0.\n",
297 | " 0. 0. 0. 0. ]\n",
298 | " [0. 0. 0. 0. 0. 0.\n",
299 | " 0. 0. 0. 0. 0. 0.\n",
300 | " 0. 0. 0. 0. 0. 0.\n",
301 | " 0. 0. 0. 0. 0. 0.\n",
302 | " 0. 0. 0. 0. ]]\n"
303 | ],
304 | "name": "stdout"
305 | },
306 | {
307 | "output_type": "display_data",
308 | "data": {
309 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD4CAYAAAAq5pAIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ngg==\n",
310 | "text/plain": [
311 | ""
24 | ]
25 | },
26 | {
27 | "cell_type": "markdown",
28 | "metadata": {
29 | "id": "I5tcbh0IWTmQ",
30 | "colab_type": "text"
31 | },
32 | "source": [
33 | "\n",
34 | "You learned how to do classificaiton using Fashion MNIST, a data set containing items of clothing. There's another, similar dataset called MNIST which has items of handwriting - the digits 0 through 9.\n",
35 | "Write an MNIST classifier that trains to 99% accuracy or above, and does it without a fixed number of epochs - i.e. you should stop training once you reach that level of accuracy.\n",
36 | "\n",
37 | "Some notes:\n",
38 | "\n",
39 | "1. It should succeed in less than 10 epochs, so it is okay to change epochs = to 10, but nothing larger\n",
40 | "2. When it reaches 99% or greater it should print out the string \"Reached 99% accuracy so cancelling training!\"\n",
41 | "\n",
42 | "Use this code line to get MNIST handwriting data set:\n",
43 | "\n",
44 | "```\n",
45 | "mnist = tf.keras.datasets.mnist\n",
46 | "```\n",
47 | "\n"
48 | ]
49 | },
50 | {
51 | "cell_type": "code",
52 | "metadata": {
53 | "id": "aXwpXnljWIji",
54 | "colab_type": "code",
55 | "colab": {}
56 | },
57 | "source": [
58 | "# YOUR CODE SHOULD START HERE\n",
59 | "# YOUR CODE SHOULD END HERE\n",
60 | "import tensorflow as tf\n",
61 | "mnist = tf.keras.datasets.mnist\n",
62 | "\n",
63 | "(x_train, y_train),(x_test, y_test) = mnist.load_data()\n",
64 | "# YOUR CODE SHOULD START HERE\n",
65 | "\n",
66 | "# YOUR CODE SHOULD END HERE\n",
67 | "model = tf.keras.models.Sequential([\n",
68 | "# YOUR CODE SHOULD START HERE\n",
69 | " \n",
70 | "# YOUR CODE SHOULD END HERE\n",
71 | "])\n",
72 | "\n",
73 | "model.compile(optimizer='adam',\n",
74 | " loss='sparse_categorical_crossentropy',\n",
75 | " metrics=['accuracy'])\n",
76 | "\n",
77 | "# YOUR CODE SHOULD START HERE\n",
78 | "# YOUR CODE SHOULD END HERE"
79 | ],
80 | "execution_count": 0,
81 | "outputs": []
82 | }
83 | ]
84 | }
--------------------------------------------------------------------------------
/Part 2-Computer Vision with TensorFlow/Excercise2_solution.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "nbformat": 4,
3 | "nbformat_minor": 0,
4 | "metadata": {
5 | "colab": {
6 | "name": "Excercise2_solution.ipynb",
7 | "provenance": [],
8 | "authorship_tag": "ABX9TyMSE3HNT4DRkyfFTeuF+fhi",
9 | "include_colab_link": true
10 | },
11 | "kernelspec": {
12 | "name": "python3",
13 | "display_name": "Python 3"
14 | }
15 | },
16 | "cells": [
17 | {
18 | "cell_type": "markdown",
19 | "metadata": {
20 | "id": "view-in-github",
21 | "colab_type": "text"
22 | },
23 | "source": [
24 | ""
25 | ]
26 | },
27 | {
28 | "cell_type": "code",
29 | "metadata": {
30 | "id": "nyV34YajcGuP",
31 | "colab_type": "code",
32 | "colab": {}
33 | },
34 | "source": [
35 | "def train_mnist():\n",
36 | " # Please write your code only where you are indicated.\n",
37 | " # please do not remove # model fitting inline comments.\n",
38 | "\n",
39 | " # YOUR CODE SHOULD START HERE\n",
40 | " class myCallback(tf.keras.callbacks.Callback):\n",
41 | " def on_epoch_end(self, epoch, logs={}):\n",
42 | " if(logs.get('acc')>0.99):\n",
43 | " print(\"/nReached 99% accuracy so cancelling training!\")\n",
44 | " self.model.stop_training = True\n",
45 | " # YOUR CODE SHOULD END HERE\n",
46 | "\n",
47 | " mnist = tf.keras.datasets.mnist\n",
48 | "\n",
49 | " (x_train, y_train),(x_test, y_test) = mnist.load_data()\n",
50 | " # YOUR CODE SHOULD START HERE\n",
51 | " x_train, x_test = x_train / 255.0, x_test / 255.0\n",
52 | " \n",
53 | "\n",
54 | " callbacks = myCallback()\n",
55 | " # YOUR CODE SHOULD END HERE\n",
56 | " model = tf.keras.models.Sequential([\n",
57 | " # YOUR CODE SHOULD START HERE\n",
58 | " tf.keras.layers.Flatten(input_shape=(28, 28)),\n",
59 | " tf.keras.layers.Dense(512, activation=tf.nn.relu),\n",
60 | " tf.keras.layers.Dense(10, activation=tf.nn.softmax)\n",
61 | " # YOUR CODE SHOULD END HERE\n",
62 | " ])\n",
63 | "\n",
64 | " model.compile(optimizer='adam',\n",
65 | " loss='sparse_categorical_crossentropy',\n",
66 | " metrics=['accuracy'])\n",
67 | " \n",
68 | " # model fitting\n",
69 | " history = model.fit(# YOUR CODE SHOULD START HERE\n",
70 | " x_train,\n",
71 | " y_train,\n",
72 | " epochs=10,\n",
73 | " callbacks=[callbacks]\n",
74 | " # YOUR CODE SHOULD END HERE\n",
75 | " )\n",
76 | " # model fitting\n",
77 | " return history.epoch, history.history['acc'][-1]"
78 | ],
79 | "execution_count": 0,
80 | "outputs": []
81 | }
82 | ]
83 | }
--------------------------------------------------------------------------------
/Part 2-Computer Vision with TensorFlow/README.md:
--------------------------------------------------------------------------------
1 | # Computer Vision with TensorFlow
2 |
3 | This same blog is availaible on Medium [here](https://medium.com/@rishit.dagli/computer-vision-with-tensorflow-part-2-57e95cd0551)
4 |
5 | 
6 | Source: cognitiveclass.ai
7 | 8 | This is the second part of the series where I post about TensorFlow for Deep Learning and Machine Learning. 9 | In the earlier blog post you learned all about how Machine Learning and Deep Learning is a new programming paradigm. 10 | This time you’re going to take that to the next level by beginning to solve problems of computer vision with just a few lines of 11 | code! I believe in hands-on coding so we will have many exercises and demos which you can try yourself too. I would recommend 12 | you to play around with these exercises and change the hyper-parameters and experiment with the code. We will also be working with 13 | some real life data sets and apply the discussed algorithms on them too. If you have not read the previous article consider 14 | reading it once before you read this one [here](https://medium.com/@rishit.dagli/computer-vision-with-tensorflow-part-2-57e95cd0551). 15 | 16 | ## Introduction 17 | 18 | So fitting straight lines seems like the “Hello, world” most basic implementation learning algorithm. 19 | But one of the most amazing things about machine learning is that, 20 | that core of the idea of fitting the x and y relationship is what lets us do amazing things like, have computers look at the 21 | picture and do activity recognition, or look at the picture and tell us, is this a dress, or a pair of pants, or a pair of shoes; 22 | really hard for humans, and amazing that computers can now use this to do these things as well. Right, like computer vision is a 23 | really hard problem to solve, right? Because you’re saying like dress or shoes. It’s like how would I write rules for that? 24 | How would I say, if this pixel then it’s a shoe, if that pixel then its a dress. It’s really hard to do, so the labeled samples 25 | are the right way to go. One of the non-intuitive things about vision is that it’s so easy for a person to look at you and say, 26 | you’re wearing a shirt, it’s so hard for a computer to figure it out. 27 | 28 | Because it’s so easy for humans to recognize objects, it’s almost difficult to understand why this is a complicated thing 29 | for a computer to do. What the computer has to do is look at all numbers, all the pixel brightness value, 30 | saying look at all of these numbers saying, these numbers correspond to a black shirt, and it’s amazing that with machine 31 | and deep learning computers are getting really good at this. 32 | 33 | ## Computer Vision 34 | 35 | Computer vision is the field of having a computer understand and label what is present in an image. 36 | When you look at this image below, you can interpret what a shirt is or what a shoe is, but how would you 37 | program for that? If an extra terrestrial who had never seen clothing walked into the room with you, how would 38 | you explain the shoes to him? It’s really difficult, if not impossible to do right? And it’s the same problem with 39 | computer vision. 40 | So one way to solve that is to use lots of pictures of clothing and tell the computer 41 | what that’s a picture of and then have the computer figure out the patterns that give you the difference between a shoe, 42 | and a shirt, and a handbag, and a coat. 43 | 44 |  45 |Image example
46 | 47 | ## Let’s Get started 48 | 49 | Fortunately, there’s a data set called Fashion MNIST 50 | (not to be confused with handwriting MNIST data set- that’s your excercise) which gives a 70,000 51 | images spread across 10 different items of clothing. These images have been scaled down to 28 by 28 pixels. 52 | Now usually, the smaller the better because the computer has less processing to do. But of course, 53 | you need to retain enough information to be sure that the features and the object can still be distinguished. 54 | If you look at the image you can still tell the difference between shirts, shoes, and handbags. 55 | So this size does seem to be ideal, and it makes it great for training a neural network. The images are also in gray scale, 56 | so the amount of information is also reduced. Each pixel can be represented in values from zero to 255 and so it’s 57 | only one byte per pixel. With 28 by 28 pixels in an image, only 784 bytes are needed to store the entire image. 58 | Despite that, we can still see what’s in the image below and in this case, it’s an ankle boot, right? 59 | 60 |  61 |An image from the dataset
62 | 63 | You can know more about the fashion MNIST data set at this GitHub repository [here](https://github.com/zalandoresearch/fashion-mnist). 64 | You can also download the data set from [here](https://github.com/zalandoresearch/fashion-mnist). 65 | 66 | So what will handling this look like in code? 67 | In the previous blog post, you learned about TensorFlow and Keras, and how to define a simple neural network with them. 68 | Here, you are going to use them to go a little deeper but the overall API should look familiar. 69 | The one big difference will be in the data. The last time you had just your six pairs of numbers, so you could hard code it. 70 | This time you have to load 70,000 images off the disk, so there will be a bit of code to handle that. Fortunately, 71 | it’s still quite simple because Fashion MNIST is available as a data set with an API call in TensorFlow. 72 | 73 | ```python 74 | fashion_mnist = keras.datasets.fashion_mnist 75 | (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data() 76 | ``` 77 | 78 | Consider the code `fashion_mnist.load_data()` . 79 | What we are doing here is creating an object of type MNIST and loading it from the `Keras` data base. 80 | Now, on this class we are running a method called `load_data()` which will return four lists to us `train_images` , 81 | `train_labels` , `test_images` and `test_labels` . 82 | Now, what are these you might wonder. 83 | So, when building a neural network like this, it's a nice strategy to use some of your data to train the neural network and 84 | similar data that the model hasn't yet seen to test how good it is at recognizing the images. 85 | So in the Fashion MNIST data set, 60,000 of the 70,000 images are used to train the network, 86 | and then 10,000 images, one that it hasn't previously seen, 87 | can be used to test just how good or how bad the model is performing. So this code will give you those sets. 88 | 89 |  90 |An image from data set and the code used
91 | 92 | So for example, the training data will contain images like this one, and a label that describes the image like this. 93 | While this image is an ankle boot, the label describing it is the number nine. 94 | Now, why do you think that is? There’s two main reasons. 95 | First, of course, is that computers do better with numbers than they do with texts. 96 | Second, importantly, is that this is something that can help us reduce bias. 97 | If we labeled it as an ankle boot, we would be of course biasing towards English speakers. 98 | But with it being a numeric label, we can then refer to it in our appropriate language be it English, Hindi, 99 | German, Mandarin or here, even Irish. You can learn more about bias and techniques to avoid it here. 100 | 101 | Coding a Neural Network for this 102 | 103 | Okay. So now we will look at the code for the neural network definition. 104 | Remember last time we had a sequential with just one layer in it. Now we have three layers. 105 | 106 | ```python 107 | model = keras.Sequential([ keras.layers.Flatten(input_shape = (28, 28)), 108 | keras.layers.Dense(128, activation = tf.nn.relu), 109 | keras.layers.Dense(10, activation = tf.nn.softmax) 110 | ]) 111 | ``` 112 | 113 | The important things to look at are the first and the last layers. 114 | The last layer has 10 neurons in it because we have ten classes of clothing in the data set. 115 | They should always match. The first layer is a flatten layer with the input shaping 28 by 28. 116 | Now, if you remember our images are 28 by 28, so we’re specifying that this is the shape that we 117 | should expect the data to be in. Flatten takes this 28 by 28 square and turns it into a simple linear array. 118 | The interesting stuff happens in the middle layer, sometimes also called a hidden layer. This is a 128 neurons in it, 119 | and I’d like you to think about these as variables in a function. Maybe call them x1, x2 x3, etc. 120 | Now, there exists a rule that incorporates all of these that turns the 784 values of an ankle boot into the value nine, 121 | and similar for all of the other 70,000. 122 | 123 |  124 |A neural net layer
125 | 126 | So, what the neural net does is it figure out `w0` , `w1` , `w2` … `w n` such that `(x1 * w1) + (x2 * w2) ... (x128 * w128) = y` 127 | 128 | You’ll see that it’s doing something very, very similar to what we did earlier when we figured out `y = 2x — 1`. In that case the two, 129 | was the weight of `x`. So, I’m saying `y = w1 * x1`, etc. 130 | The important thing now is to get the code working, so you can see a classification scenario for yourself. 131 | You can also tune the neural network by adding, removing and changing layer size to see the impact. 132 | 133 | As we discussed earlier to finish this example and writing the complete code we will use Tensor Flow 2.x, 134 | before that we will explore few Google Colaboratory tips as that is what you might be using. 135 | However, you can also use Jupyter Notebooks preferably on your local environment. 136 | 137 | ## Colab Tips (OPTIONAL) 138 | 139 | * Map your Google Drive 140 | 141 | On Colab notebooks you can access your Google Drive as a network mapped drive in the Colab VM runtime. 142 | 143 | ```python 144 | #You can access to your Drive files using this path "/content 145 | # /gdrive/My Drive/" 146 | 147 | from google.colab import drive 148 | drive.mount('/content/gdrive') 149 | ``` 150 | 151 | * Work with your files transparently in your computer 152 | 153 | You can sync a Google Drive folder in your computer. Along with the previous tip, your local files will be 154 | available locally in your Colab notebook. 155 | 156 | * Clean your root folder on Google Drive 157 | 158 | There’s some resources from Google that explains that having a lot of files in your root folder 159 | can affect the process of mapping the unit. If you have a lot of files in your root folder on Drive, 160 | create a new folder and move all of them there. I suppose that having a lot of folders on the root folder will 161 | have similar impact. 162 | 163 | * Hardware acceleration 164 | 165 | For some applications you might need a hardware accelerator like a GPU or a TPU. 166 | Let’s say you are building a CNN or so 1 epoch might be 90–100 seconds on a CPU but just 5–6 seconds on a 167 | GPU and in milliseconds on a TPU. So, this is definetely helpful. You can go to- 168 | 169 | ``` 170 | Runtime > Change Runtime Type > Select your hardware accelerator 171 | ``` 172 | 173 | * A fun feature 174 | 175 | This is called power level. Power level is an April fools joke feature that adds sparks and combos to cell editing. 176 | Access using- 177 | 178 | ``` 179 | Tools > Settings > Miscellaneous > Select Power 180 | ``` 181 | 182 | Example of high power 183 | 184 |  185 |Example of high power
186 | 187 | ## Walk through the notebook 188 | 189 | The notebook is availaible [here](https://github.com/Rishit-dagli/Deep-Learning-With-TensorFlow-Blog-series/blob/master/Part%202-Computer%20Vision%20with%20TensorFlow/Computer_vision_examples_Notebook.ipynb). If you are using local development environment, download this notebook; 190 | if you are using Colab click the `open in colab` button. We will also see some excercises in this notebook. 191 | 192 | Import tensorflow 2.0 in Colab- 193 | 194 | ```python 195 | try: 196 | # %tensorflow_version only exists in Colab. 197 | %tensorflow_version 2.x 198 | except Exception: 199 | pass 200 | 201 | import tensorflow as tf 202 | ``` 203 | 204 | First we use the above code to import TensorFlow 2.x, 205 | If you are using local development environment you do not need lines 1–5. 206 | 207 | Then, as discussed we use this code to get the data set. 208 | 209 | ```python 210 | fashion_mnist = keras.datasets.fashion_mnist 211 | (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data() 212 | ``` 213 | 214 | We will now use matplotlib to view a sample image from the dataset. 215 | 216 | ```python 217 | import matplotlib.pyplot as plt 218 | plt.imshow(training_images[0]) 219 | ``` 220 | 221 | You can change the 0 to other values to get other images as you might have guessed. 222 | You’ll notice that all of the values in the number are between 0 and 255. If we are training a neural network, 223 | for various reasons it’s easier if we treat all values as between 0 and 1, a process called ‘normalizing’ and fortunately 224 | in Python it’s easy to normalize a list like this without looping. You do it like this: 225 | 226 | ```python 227 | training_images = training_images / 255.0 228 | test_images = test_images / 255.0 229 | ``` 230 | 231 | Now in the next code block in the notebook we have defines the same neural net we earlier discussed about. 232 | Ok so you might have noticed a change we use `softmax` function. Softmax takes a set of values, and effectively picks 233 | 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]`, 234 | 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]` — 235 | The goal is to save a lot of coding! 236 | 237 | We can then try to fit the training images to the training labels. We’ll just do it for 10 epochs to be quick. 238 | We spend about 50 seconds training it over five epochs and we end up with a loss of about 0.205. 239 | That means it’s pretty accurate in guessing the relationship between the images and their labels. 240 | That’s not great, but considering it was done in just 50 seconds with a very basic neural network, it’s not bad either. 241 | But a better measure of performance can be seen by trying the test data. These are images that the network has not yet seen. 242 | You would expect performance to be worse, but if it’s much worse, you have a problem. As you can see, it’s about 0.32 loss, 243 | meaning it’s a little bit less accurate on the test set. It’s not great either, but we know we’re doing something right. 244 | 245 | I have some questions and excercises for you 8 in all and I recommend you to go through all of them, 246 | you will also be exploring the same example with more neurons and thinngs like that. So have fun coding. 247 | 248 | You just made a complete fashion fashion MNIST algorithm which can predict with a pretty 249 | good accuracy the images of fashion items. 250 | 251 | ## Callbacks (Very important) 252 | 253 | How can I stop training when I reach a point that I want to be at? What do I always have to hard code it to go for certain number of epochs? So in every epoch, you can callback to a code function, having checked the metrics. If they’re what you want to say, then you can cancel the training at that point. 254 | 255 | Callback code- 256 | 257 | ```python 258 | class myCallback(tf.keras.callbacks.Callback): 259 | def on_epoch_end(self, epoch, logs = {}): 260 | if logs.get('loss') < 0.7: 261 | print("\n Low loss so cancelling the training") 262 | self.model.stop_training = True 263 | 264 | ``` 265 | 266 | It’s implemented as a separate class, but that can be in-line with your other code. It doesn’t need to be in a separate file. In it, we’ll implement the on_epoch_end function, which gets called by the callback whenever the epoch ends. It also sends a logs object which contains lots of great information about the current state of training. For example, the current loss is available in the logs, so we can query it for certain amount. For example, here I’m checking if the loss is less than 0.7 and canceling the training itself. Now that we have our callback, let’s return to the rest of the code, and there are two modifications that we need to make. First, we instantiate the class that we just created, we do that with this code. 267 | 268 | ```python 269 | callbacks = myCallback() 270 | ``` 271 | 272 | Then, in my `model.fit`, I used the callbacks parameter and pass it this instance of the class. 273 | 274 | ```python 275 | model.fit(training_images, training_labels, epochs = 10, callbacks = [callbacks]) 276 | ``` 277 | 278 | And now we pass the callback object to the callback argument of the `model.fit()` . 279 | 280 | Use this notebook to explore more and see this code in action [here](https://github.com/Rishit-dagli/Deep-Learning-With-TensorFlow-Blog-series/blob/master/Part%202-Computer%20Vision%20with%20TensorFlow/Callbacks_example_Notebook.ipynb). This notebook contains all the modifications we talked about. 281 | 282 | ## Excercise 2 283 | 284 | You learned how to do classificaiton using Fashion MNIST, a data set containing items of clothing. There’s another, similar dataset called MNIST which has items of handwriting — the digits 0 through 9. 285 | 286 | Write an MNIST classifier that trains to 99% accuracy or above, and does it without a fixed number of epochs — i.e. you should stop training once you reach that level of accuracy. 287 | 288 | Some notes: 289 | 290 | * It should succeed in less than 10 epochs, so it is okay to change epochs = to 10, but nothing larger 291 | * When it reaches 99% or greater it should print out the string “Reached 99% accuracy so cancelling training!” 292 | 293 | Use this code line to get MNIST handwriting data set: 294 | 295 | ```python 296 | mnist = tf.keras.datasets.mnist 297 | ``` 298 | 299 | Here’s a Colab notebook with the question and some strater code already written — [here](https://github.com/Rishit-dagli/Deep-Learning-With-TensorFlow-Blog-series/blob/master/Part%202-Computer%20Vision%20with%20TensorFlow/Excercise2_question.ipynb) 300 | 301 | ## My Solution 302 | 303 | Wonderful! 😃 , you just coded for a handwriting recognizer with a 99% accuracy (that’s good) in less than 10 epochs. Let explore my solution for this. 304 | 305 | Excercise 2 Solution- 306 | 307 | ```python 308 | def train_mnist(): 309 | # Please write your code only where you are indicated. 310 | # please do not remove # model fitting inline comments. 311 | 312 | # YOUR CODE SHOULD START HERE 313 | class myCallback(tf.keras.callbacks.Callback): 314 | def on_epoch_end(self, epoch, logs={}): 315 | if(logs.get('acc')>0.99): 316 | print("/nReached 99% accuracy so cancelling training!") 317 | self.model.stop_training = True 318 | # YOUR CODE SHOULD END HERE 319 | 320 | mnist = tf.keras.datasets.mnist 321 | 322 | (x_train, y_train),(x_test, y_test) = mnist.load_data() 323 | # YOUR CODE SHOULD START HERE 324 | x_train, x_test = x_train / 255.0, x_test / 255.0 325 | 326 | 327 | callbacks = myCallback() 328 | # YOUR CODE SHOULD END HERE 329 | model = tf.keras.models.Sequential([ 330 | # YOUR CODE SHOULD START HERE 331 | tf.keras.layers.Flatten(input_shape=(28, 28)), 332 | tf.keras.layers.Dense(512, activation=tf.nn.relu), 333 | tf.keras.layers.Dense(10, activation=tf.nn.softmax) 334 | # YOUR CODE SHOULD END HERE 335 | ]) 336 | 337 | model.compile(optimizer='adam', 338 | loss='sparse_categorical_crossentropy', 339 | metrics=['accuracy']) 340 | 341 | # model fitting 342 | history = model.fit(# YOUR CODE SHOULD START HERE 343 | x_train, 344 | y_train, 345 | epochs=10, 346 | callbacks=[callbacks] 347 | # YOUR CODE SHOULD END HERE 348 | ) 349 | # model fitting 350 | return history.epoch, history.history['acc'][-1] 351 | ``` 352 | 353 | I will just go through the important parts. 354 | 355 | The callback class- 356 | 357 | ```python 358 | class myCallback(tf.keras.callbacks.Callback): 359 | def on_epoch_end(self, epoch, logs={}): 360 | if(logs.get('acc')>0.99): 361 | print("/nReached 99% accuracy so cancelling training!") 362 | self.model.stop_training = True 363 | ``` 364 | 365 | The main neural net code- 366 | 367 | ```python 368 | model = tf.keras.models.Sequential([ 369 | tf.keras.layers.Flatten(input_shape=(28, 28)), 370 | tf.keras.layers.Dense(512, activation=tf.nn.relu), 371 | tf.keras.layers.Dense(10, activation=tf.nn.softmax)]) 372 | 373 | model.compile(optimizer='adam', 374 | loss='sparse_categorical_crossentropy', 375 | metrics=['accuracy']) 376 | 377 | history = model.fit(x_train, y_train, epochs=10, callbacks=[callbacks]) 378 | ``` 379 | 380 | So, all you had to do was play around with the code and this gets done in just 5 epochs. 381 | 382 | The solution notebook is availaible [here](https://github.com/Rishit-dagli/Deep-Learning-With-TensorFlow-Blog-series/blob/master/Part%202-Computer%20Vision%20with%20TensorFlow/Excercise2_solution.ipynb). 383 | 384 | ## About Me 385 | 386 | Hi everyone I am Rishit Dagli 387 | 388 | [Twitter](https://twitter.com/rishit_dagli) 389 | 390 | [Website](https://rishit.tech/) 391 | 392 | If you want to ask me some questions, report any mistake, suggest improvements, give feedback you are free to do so by emailing me at — 393 | 394 | * [rishit.dagli@gmail.com](mailto:rishit.dagli@gmail.com) 395 | 396 | * [hello@rishit.tech](mailto:hello@rishit.tech) 397 | 398 | 399 | -------------------------------------------------------------------------------- /Part 3-Using Convolutional Neural Networks with TensorFlow/README.md: -------------------------------------------------------------------------------- 1 | # Using Convolutional Neural Networks with TensorFlow 2 | 3 | The same blog is availaible on Medium [here](https://medium.com/@rishit.dagli/using-convolutional-neural-networks-with-tensorflow-part-3-35de28a5621) 4 | 5 |  6 | Source: Cognitiveclass.ai 7 | 8 | All the code used here is available in my GitHub repository 9 | [here](https://github.com/Rishit-dagli/Deep-Learning-With-TensorFlow-Blog-series/). 10 | 11 | ***** 12 | 13 | This is the third part of the series where I post about TensorFlow for Deep 14 | Learning and Machine Learning. In the earlier blog post you saw a basic Neural 15 | Network for Computer Vision. It did the job nicely, but it was a little naive in 16 | its approach. This time you’re going to improve on that using Convolutional 17 | Neural Networks(CNN). I believe in hands-on coding so we will have many 18 | exercises and demos which you can try yourself too. I would recommend you to 19 | play around with these exercises and change the hyper-parameters and experiment 20 | with the code. We will also be working with some real life data sets and apply 21 | the discussed algorithms on them too. If you have not read the previous article 22 | consider reading it once before you read this one 23 | [here](https://medium.com/@rishit.dagli/computer-vision-with-tensorflow-part-2-57e95cd0551). 24 | 25 | ### Introduction 26 | 27 | I think it’s really cool that you’re already able to implement a neural network 28 | to do this fashion classification task. It’s just amazing that large data sets 29 | like this are readily available to you which makes it really easy to learn. And 30 | in this case we saw with just a few lines of code, we were able to build a DNN, 31 | deep neural net that allowed you to do this classification of clothing and we 32 | got reasonable accuracy with it but it was a little bit of a naive algorithm 33 | that we used, right? We’re looking at each and every pixel in every image, but 34 | maybe there are ways that we can make it better but maybe looking at features of 35 | what makes a shoe a shoe and what makes a handbag a handbag. What do you think? 36 | You might think something like if I have a shoelace in the picture it could be a 37 | shoe and if there is a handle it may be a handbag. 38 | 39 | So, one of the ideas that make these neural networks work much better is to use 40 | convolutional neural networks, where instead of looking at every single pixel 41 | and say, getting the pixel values and then figuring out, “is this a shoe or is 42 | this a hand bag? I don’t know.” But instead you can look at a picture and say, 43 | “Ok, I see shoelaces and a sole.” Then, it’s probably shoe or say, “I see a 44 | handle and rectangular bag beneath that.” Probably a handbag. What’s really 45 | interesting about convolutions is that they sound very complicated but they’re 46 | actually quite straightforward. It is essentially just a filter that you pass 47 | over an image in the same way as if you’re doing some sharpening. If you have 48 | ever done image processing, it can spot features within the image just like we 49 | talked about. With the same paradigm of just data labels, we can let a neural 50 | network figure out for itself that it should look for shoe laces and soles or 51 | handles in bags and then just learn how to detect these things by itself. So we 52 | will also see how good or bad it works in comparison to our earlier approach for 53 | Fashion MNIST? 54 | 55 | So, now we will know about convolutional neural networks and get to use it to 56 | build a much better fashion classifier. 57 | 58 | ***** 59 | 60 | ### What are Convolutions and Poolings 61 | 62 | In the DNN approach, in just a couple of minutes, you’re able to train it to 63 | classify with pretty high accuracy on the training set, but a little less on the 64 | test set. Now, one of the things that you would have seen when you looked at the 65 | images is that there’s a lot of wasted space in each image. While there are only 66 | 784 pixels, it will be interesting to see if there was a way that we could 67 | condense the image down to the important features that distinguish what makes it 68 | a shoe, or a handbag, or a shirt. That’s where convolutions come in. So, what’s 69 | convolution at all? 70 | 71 |  72 | How filters work? 73 | 74 | If you have ever done any kind of image processing, it usually involves having a 75 | filter and passing that filter over the image in order to change the underlying 76 | image. The process works a little bit like this. For every pixel, take its 77 | value, and take a look at the value of its neighbors. If our filter is three by 78 | three, then we can take a look at the immediate neighbor, so that you have a 79 | corresponding 3 by 3 grid. Then to get the new value for the pixel, we simply 80 | multiply each neighbor by the corresponding value in the filter. So, for 81 | example, in this case, our pixel has the value 192, and its upper left neighbor 82 | has the value 0. The upper left value and the filter is -1, so we multiply 0 by 83 | -1. Then we would do the same for the upper neighbor. Its value is 64 and the 84 | corresponding filter value was 0, so we’d multiply those out. 85 | 86 | Repeat this for each neighbor and each corresponding filter value, and would 87 | then have the new pixel with the sum of each of the neighbor values multiplied 88 | by the corresponding filter value, and that’s a convolution. It’s really as 89 | simple as that. The idea here is that some convolutions will change the image in 90 | such a way that certain features in the image get emphasized. 91 | 92 | So, for example, if you look at this filter, then the vertical lines in the 93 | image really pop out. Don’t worry we will do a hands-on for this later. 94 | 95 |  96 | A filter which pops out vertical lines 97 | 98 | With this filter, the horizontal lines pop out. 99 | 100 |  101 | A filter which pops out horizontal lines 102 | 103 | Now, that’s a very basic introduction to what convolutions do, and when combined 104 | with something called pooling, they can become really powerful. 105 | 106 | Now what’s pooling then? pooling is a way of compressing an image. A quick and 107 | easy way to do this, is to go over the image of 4 pixels at a time, that is, the 108 | current pixel and its neighbors underneath and to the right of it. 109 | 110 |  111 | a 4 x 4 pooling 112 | 113 | Of these 4, pick the biggest value and keep just that. So, for example, you can 114 | see it here. My 16 pixels on the left are turned into the four pixels on the 115 | right, by looking at them in 2 by 2 grids and picking the biggest value. This 116 | will preserve the features that were highlighted by the convolution, while 117 | simultaneously quartering the size of the image. We have the horizontal and 118 | vertical axes too. 119 | 120 | ***** 121 | 122 | ### Coding for convolutions and max pooling 123 | 124 | These layers are available as 125 | 126 | * [Conv2D](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Conv2D) and 127 | * [MaxPooling2D](https://www.tensorflow.org/api_docs/python/tf/keras/layers/MaxPool2D?version=stable) 128 | 129 | in TensorFlow. 130 | 131 | We don’t have to do all the math for filtering and compressing, we simply define 132 | convolutional and pooling layers to do the job for us. 133 | 134 | So here’s our code from the earlier example, where we defined out a neural 135 | network to have an input layer in the shape of our data, and output layer in the 136 | shape of the number of categories we’re trying to define, and a hidden layer in 137 | the middle. The Flatten takes our square 28 by 28 images and turns them into a 138 | one dimensional array. 139 | 140 | model = tf.keras.models.Sequential([ 141 | 142 | tf.keras.layers.Flatten(input_shape=(28, 28)), 143 | tf.keras.layers.Dense(128, activation = tf.nn.relu, 144 | tf.keras.layers.Dense(10, activation = tf.nn.softmax 145 | 146 | ]) 147 | 148 | To add convolutions to this, you use code like this. 149 | 150 | model = tf.keras.models.Sequential([ 151 | 152 | tf.keras.layers.Conv2D(64, (3,3), activation='relu', input_shape=(28, 28, 1)), 153 | 154 | tf.keras.layers.MaxPooling2D(2, 2), 155 | 156 | tf.keras.layers.Conv2D(64, (3,3), activation='relu'), 157 | 158 | tf.keras.layers.MaxPooling2D(2,2), 159 | 160 | tf.keras.layers.Flatten(), 161 | 162 | tf.keras.layers.Dense(128, activation='relu'), 163 | 164 | tf.keras.layers.Dense(10, activation='softmax') 165 | 166 | ]) 167 | 168 | You’ll see that the last three lines are the same, the `Flatten`, the `Dense` 169 | hidden layer with 128 neurons, and the `Dense` output layer with 10 neurons. 170 | What’s different is what has been added on top of this. Let’s take a look at 171 | this, line by line. 172 | 173 | tf.keras.layers.Conv2D(64, (3,3), activation='relu', input_shape=(28, 28, 1)) 174 | 175 | Here we’re specifying the first convolution. We’re asking `keras` to generate 64 176 | filters for us. These filters are 3 by 3, their activation is `relu`, which 177 | means the negative values will be thrown way, and finally the input shape is as 178 | before, the 28 by 28. That extra 1 just means that we are tallying using a 179 | single byte for color depth. As we saw before our image is our gray scale, so we 180 | just use one byte. Now, of course, you might wonder what the 64 filters are. 181 | It’s a little beyond the scope of this blog to define them, but they for now you 182 | can understand that they are not random. They start with a set of known good 183 | filters in a similar way to the pattern fitting that you saw earlier, and the 184 | ones that work from that set are learned over time. 185 | 186 | tf.keras.layers.MaxPooling2D(2, 2) 187 | 188 | This next line of code will then create a pooling layer. It’s max-pooling 189 | because we’re going to take the maximum value. We’re saying it’s a two-by-two 190 | pool, so for every four pixels, the biggest one will survive as shown earlier. 191 | We then add another convolutional layer, and another max-pooling layer so that 192 | the network can learn another set of convolutions on top of the existing one, 193 | and then again, pool to reduce the size. So, by the time the image gets to the 194 | flatten to go into the dense layers, it’s already much smaller. It’s being 195 | quartered, and then quartered again. So, its content has been greatly 196 | simplified, the goal being that the convolutions will filter it to the features 197 | that determine the output. 198 | 199 | A really useful method on the model is the `model.summary` method. This allows 200 | you to inspect the layers of the model, and see the journey of the image through 201 | the convolutions, and here is the output. 202 | 203 |  204 | Output of model.summary 205 | 206 | It’s a nice table showing us the layers, and some details about them including 207 | the output shape. It’s important to keep an eye on the output shape column. When 208 | you first look at this, it can be a little bit confusing and feel like a bug. 209 | After all, isn’t the data 28 by 28, so why is the output, 26 by 26? The key to 210 | this is remembering that the filter is a 3 by 3 filter. Consider what happens 211 | when you start scanning through an image starting on the top left. So, you can’t 212 | calculate the filter for the pixel in the top left, because it doesn’t have any 213 | neighbors above it or to its left. In a similar fashion, the next pixel to the 214 | right won’t work either because it doesn’t have any neighbors above it. So, 215 | logically, the first pixel that you can do calculations on is this one, because 216 | this one of course has all 8 neighbors that a three by 3 filter needs. This when 217 | you think about it, means that you can’t use a 1 pixel margin all around the 218 | image, so the output of the convolution will be 2 pixels smaller on `x`, and 2 219 | pixels smaller on `y`. If your filter is five-by-five for similar reasons, your 220 | output will be four smaller on `x`, and four smaller on `y`. So, that’s `y` with 221 | a three by three filter, our output from the 28 by 28 image, is now 26 by 26, 222 | we’ve removed that one pixel on `x` and `y`, and each of the borders. 223 | 224 | So, now our output gets reduced from 26 by 26, to 13 by 13. The convolutions 225 | will then operate on that, and of course, we lose the 1 pixel margin as before, 226 | so we’re down to 11 by 11, add another 2 by 2 max-pooling to have this rounding 227 | down, and went down, down to 5 by 5 images. So, now our dense neural network is 228 | the same as before, but it’s being fed with five-by-five images instead of 28 by 229 | 28 ones. 230 | 231 | But remember, it’s not just one compressed 5 by 5 image instead of the original 232 | 28 by 28, there are a number of convolutions per image that we specified, in 233 | this case 64. So, there are 64 new images of 5 by 5 that had been fed in. 234 | Flatten that out and you have 25 pixels times 64, which is 1600. So, you can see 235 | that the new flattened layer has 1,600 elements in it, as opposed to the 784 236 | that you had previously. This number is impacted by the parameters that you set 237 | when defining the convolutional 2D layers. Later when you experiment, you’ll see 238 | what the impact of setting what other values for the number of convolutions will 239 | be, and in particular, you can see what happens when you’re feeding less than 240 | 784 over all pixels in. Training should be faster, but is there a sweet spot 241 | where it’s more accurate? 242 | 243 | ***** 244 | 245 | To know more about this, implement this on a real life data set and even 246 | visualize the journey of an image through a CNN please head on to the next blog. 247 | 248 | ***** 249 | 250 | ### About Me 251 | 252 | Hi everyone I am Rishit Dagli 253 | 254 | [Twitter](https://twitter.com/rishit_dagli) 255 | 256 | [Website](https://rishit.tech/) 257 | 258 | If you want to ask me some questions, report any mistake, suggest improvements, 259 | give feedback you are free to do so by emailing me at — 260 | 261 | * [rishit.dagli@gmail.com](mailto:rishit.dagli@gmail.com) 262 | * [hello@rishit.tech](mailto:hello@rishit.tech) 263 | -------------------------------------------------------------------------------- /Part 4-Extending what Convolutional Neural Nets can do/CNN_with_Fashion_MNIST_Notebook.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "name": "CNN with Fashion MNIST Notebook.ipynb", 7 | "provenance": [], 8 | "collapsed_sections": [], 9 | "include_colab_link": true 10 | }, 11 | "kernelspec": { 12 | "name": "python3", 13 | "display_name": "Python 3" 14 | }, 15 | "accelerator": "GPU" 16 | }, 17 | "cells": [ 18 | { 19 | "cell_type": "markdown", 20 | "metadata": { 21 | "id": "view-in-github", 22 | "colab_type": "text" 23 | }, 24 | "source": [ 25 | ""
26 | ]
27 | },
28 | {
29 | "cell_type": "markdown",
30 | "metadata": {
31 | "id": "R6gHiH-I7uFa",
32 | "colab_type": "text"
33 | },
34 | "source": [
35 | "#Improving Computer Vision Accuracy using Convolutions\n",
36 | "\n",
37 | "In the previous lessons you saw how to do fashion recognition using a Deep Neural Network (DNN) containing three layers -- the input layer (in the shape of the data), the output layer (in the shape of the desired output) and a hidden layer. You experimented with the impact of different sized of hidden layer, number of training epochs etc on the final accuracy.\n",
38 | "\n",
39 | "For convenience, here's the entire code again. Run it and take a note of the test accuracy that is printed out at the end. "
40 | ]
41 | },
42 | {
43 | "cell_type": "code",
44 | "metadata": {
45 | "id": "xcsRtq9OLorS",
46 | "colab_type": "code",
47 | "outputId": "44de9249-667e-419f-c46d-9b96257019c5",
48 | "colab": {
49 | "base_uri": "https://localhost:8080/",
50 | "height": 507
51 | }
52 | },
53 | "source": [
54 | "import tensorflow as tf\n",
55 | "mnist = tf.keras.datasets.fashion_mnist\n",
56 | "(training_images, training_labels), (test_images, test_labels) = mnist.load_data()\n",
57 | "training_images=training_images / 255.0\n",
58 | "test_images=test_images / 255.0\n",
59 | "model = tf.keras.models.Sequential([\n",
60 | " tf.keras.layers.Flatten(),\n",
61 | " tf.keras.layers.Dense(128, activation=tf.nn.relu),\n",
62 | " tf.keras.layers.Dense(10, activation=tf.nn.softmax)\n",
63 | "])\n",
64 | "model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])\n",
65 | "model.fit(training_images, training_labels, epochs=5)\n",
66 | "\n",
67 | "test_loss = model.evaluate(test_images, test_labels)"
68 | ],
69 | "execution_count": 0,
70 | "outputs": [
71 | {
72 | "output_type": "display_data",
73 | "data": {
74 | "text/html": [
75 | "\n",
76 | "The default version of TensorFlow in Colab will soon switch to TensorFlow 2.x.
\n",
77 | "We recommend you upgrade now \n",
78 | "or ensure your notebook will continue to use TensorFlow 1.x via the %tensorflow_version 1.x magic:\n",
79 | "more info.
"
24 | ]
25 | },
26 | {
27 | "cell_type": "markdown",
28 | "metadata": {
29 | "id": "I5tcbh0IWTmQ",
30 | "colab_type": "text"
31 | },
32 | "source": [
33 | "\n",
34 | "You learned how to do classificaiton using Fashion MNIST, a data set containing items of clothing. There's another, similar dataset called MNIST which has items of handwriting - the digits 0 through 9.\n",
35 | "Write an MNIST classifier that trains to 99% accuracy or above, and does it without a fixed number of epochs - i.e. you should stop training once you reach that level of accuracy.\n",
36 | "\n",
37 | "Some notes:\n",
38 | "\n",
39 | "1. It should succeed in less than 10 epochs, so it is okay to change epochs = to 10, but nothing larger\n",
40 | "2. When it reaches 99% or greater it should print out the string \"Reached 99% accuracy so cancelling training!\"\n",
41 | "\n",
42 | "Use this code line to get MNIST handwriting data set:\n",
43 | "\n",
44 | "```\n",
45 | "mnist = tf.keras.datasets.mnist\n",
46 | "```\n",
47 | "\n"
48 | ]
49 | },
50 | {
51 | "cell_type": "code",
52 | "metadata": {
53 | "id": "aXwpXnljWIji",
54 | "colab_type": "code",
55 | "colab": {}
56 | },
57 | "source": [
58 | "# YOUR CODE SHOULD START HERE\n",
59 | "# YOUR CODE SHOULD END HERE\n",
60 | "import tensorflow as tf\n",
61 | "mnist = tf.keras.datasets.mnist\n",
62 | "\n",
63 | "(x_train, y_train),(x_test, y_test) = mnist.load_data()\n",
64 | "# YOUR CODE SHOULD START HERE\n",
65 | "\n",
66 | "# YOUR CODE SHOULD END HERE\n",
67 | "model = tf.keras.models.Sequential([\n",
68 | "# YOUR CODE SHOULD START HERE\n",
69 | " \n",
70 | "# YOUR CODE SHOULD END HERE\n",
71 | "])\n",
72 | "\n",
73 | "model.compile(optimizer='adam',\n",
74 | " loss='sparse_categorical_crossentropy',\n",
75 | " metrics=['accuracy'])\n",
76 | "\n",
77 | "# YOUR CODE SHOULD START HERE\n",
78 | "# YOUR CODE SHOULD END HERE"
79 | ],
80 | "execution_count": 0,
81 | "outputs": []
82 | }
83 | ]
84 | }
--------------------------------------------------------------------------------
/Part 4-Extending what Convolutional Neural Nets can do/Excercise2_solution.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "nbformat": 4,
3 | "nbformat_minor": 0,
4 | "metadata": {
5 | "colab": {
6 | "name": "Excercise2_solution.ipynb",
7 | "provenance": [],
8 | "authorship_tag": "ABX9TyMSE3HNT4DRkyfFTeuF+fhi",
9 | "include_colab_link": true
10 | },
11 | "kernelspec": {
12 | "name": "python3",
13 | "display_name": "Python 3"
14 | }
15 | },
16 | "cells": [
17 | {
18 | "cell_type": "markdown",
19 | "metadata": {
20 | "id": "view-in-github",
21 | "colab_type": "text"
22 | },
23 | "source": [
24 | ""
25 | ]
26 | },
27 | {
28 | "cell_type": "code",
29 | "metadata": {
30 | "id": "nyV34YajcGuP",
31 | "colab_type": "code",
32 | "colab": {}
33 | },
34 | "source": [
35 | "def train_mnist():\n",
36 | " # Please write your code only where you are indicated.\n",
37 | " # please do not remove # model fitting inline comments.\n",
38 | "\n",
39 | " # YOUR CODE SHOULD START HERE\n",
40 | " class myCallback(tf.keras.callbacks.Callback):\n",
41 | " def on_epoch_end(self, epoch, logs={}):\n",
42 | " if(logs.get('acc')>0.99):\n",
43 | " print(\"/nReached 99% accuracy so cancelling training!\")\n",
44 | " self.model.stop_training = True\n",
45 | " # YOUR CODE SHOULD END HERE\n",
46 | "\n",
47 | " mnist = tf.keras.datasets.mnist\n",
48 | "\n",
49 | " (x_train, y_train),(x_test, y_test) = mnist.load_data()\n",
50 | " # YOUR CODE SHOULD START HERE\n",
51 | " x_train, x_test = x_train / 255.0, x_test / 255.0\n",
52 | " \n",
53 | "\n",
54 | " callbacks = myCallback()\n",
55 | " # YOUR CODE SHOULD END HERE\n",
56 | " model = tf.keras.models.Sequential([\n",
57 | " # YOUR CODE SHOULD START HERE\n",
58 | " tf.keras.layers.Flatten(input_shape=(28, 28)),\n",
59 | " tf.keras.layers.Dense(512, activation=tf.nn.relu),\n",
60 | " tf.keras.layers.Dense(10, activation=tf.nn.softmax)\n",
61 | " # YOUR CODE SHOULD END HERE\n",
62 | " ])\n",
63 | "\n",
64 | " model.compile(optimizer='adam',\n",
65 | " loss='sparse_categorical_crossentropy',\n",
66 | " metrics=['accuracy'])\n",
67 | " \n",
68 | " # model fitting\n",
69 | " history = model.fit(# YOUR CODE SHOULD START HERE\n",
70 | " x_train,\n",
71 | " y_train,\n",
72 | " epochs=10,\n",
73 | " callbacks=[callbacks]\n",
74 | " # YOUR CODE SHOULD END HERE\n",
75 | " )\n",
76 | " # model fitting\n",
77 | " return history.epoch, history.history['acc'][-1]"
78 | ],
79 | "execution_count": 0,
80 | "outputs": []
81 | }
82 | ]
83 | }
--------------------------------------------------------------------------------
/Part 4-Extending what Convolutional Neural Nets can do/README.md:
--------------------------------------------------------------------------------
1 | ### Extending what Convolutional Neural Nets can do
2 |
3 | The same blog is avaliaible on Medium [here](https://medium.com/@rishit.dagli/extending-what-convolutional-nets-can-do-251f3021529c)
4 |
5 | 
6 | Source: Cognitiveclass.ai
7 |
8 | ### Table of contents
9 |
10 | 1. [Get started with TensorFlow and Deep
11 | Learning](https://medium.com/@rishit.dagli/get-started-with-tensorflow-and-deep-learning-part-1-72c7d67f99fc)
12 | 1. [Computer Vision with
13 | TensorFlow](https://medium.com/@rishit.dagli/computer-vision-with-tensorflow-part-2-57e95cd0551)
14 | 1. [Using Convolutional Neural Networks with
15 | TensorFlow](https://medium.com/@rishit.dagli/using-convolutional-neural-networks-with-tensorflow-part-3-35de28a5621)
16 | 1. [Extending what Convolutional Neural Nets can
17 | do](https://medium.com/@rishit.dagli/extending-what-convolutional-nets-can-do-251f3021529c)
18 |
19 | All the code used here is available in my GitHub repository
20 | [here](https://github.com/Rishit-dagli/Deep-Learning-With-TensorFlow-Blog-series/).
21 |
22 | *****
23 |
24 | This is the fourth part of the series where I post about TensorFlow for Deep
25 | Learning and Machine Learning. In the earlier blog post you saw a convolutional
26 | Neural Network for Computer Vision. It did the job pretty nicely. This time
27 | you’re going to improve your skills with some real life data sets and apply the
28 | discussed algorithms on them too. I believe in hands-on coding so we will have
29 | many exercises and demos which you can try yourself too. I would recommend you
30 | to play around with these exercises and change the hyper-parameters and
31 | experiment with the code. We will also be working. If you have not read the
32 | previous article consider reading it once before you read this one
33 | [here](https://medium.com/@rishit.dagli/computer-vision-with-tensorflow-part-2-57e95cd0551).
34 | This one is more like a continuation of that.
35 |
36 | *****
37 |
38 | ### Hands on with CNN
39 |
40 | You can find the notebook used by me
41 | [here](https://github.com/Rishit-dagli/Artificial-Intelligence_resources-and-notebooks/blob/master/CNN_with_Fashion_MNIST_Notebook.ipynb).
42 | Again, you can download the notebook if you are using a local environment and if
43 | you are using Colab, you can click on `opeen in colab` button.
44 |
45 | This is a really nice way to improve our image recognition performance. Let’s
46 | now look at it in action using a notebook. Here’s the same neural network that
47 | you used before for loading the set of images of clothing and then classifying
48 | them. By the end of epoch five, you can see the loss is around 0.34, meaning,
49 | your accuracy is pretty good on the training data.
50 |
51 | 
52 | Output with DNN
53 |
54 | It took just a few seconds to train, so that’s not bad. With the test data as
55 | before and as expected, the losses a little higher and thus, the accuracy is a
56 | little lower.
57 |
58 | So now, you can see the code that adds convolutions and pooling. We’re going to
59 | do 2 convolutional layers each with 64 convolutions, and each followed by a max
60 | pooling layer.
61 |
62 | You can see that we defined our convolutions to be three-by-three and our pools
63 | to be two-by-two. Let’s train. The first thing you’ll notice is that the
64 | training is much slower. For every image, 64 convolutions are being tried, and
65 | then the image is compressed and then another 64 convolutions, and then it’s
66 | compressed again, and then it’s passed through the DNN, and that’s for 60,000
67 | images that this is happening on each epoch. So it might take a few minutes
68 | instead of a few seconds. To remedy this what you can do is use a GPU. How to do
69 | that in Colab?
70 |
71 | All you need to do is Runtime > Change Runtime Type > GPU. A single layer would
72 | now take approximately 5–6 seconds.
73 |
74 | 
75 | Output with the Convolutions and max poolings
76 |
77 | Now that it’s done, you can see that the loss has improved a little it’s 0.25
78 | now. In this case, it’s brought our accuracy up a bit for both our test data and
79 | with our training data. That’s pretty cool, right?
80 |
81 | Now, this is a really fun visualization of the journey of an image through the
82 | convolutions. First, I’ll print out the first 100 test labels. The number 9 as
83 | we saw earlier is a shoe or boots. I picked out a few instances of this whether
84 | the zero, the 23rd and the 28th labels are all nine. So let’s take a look at
85 | their journey.
86 |
87 | 
88 | The visualization
89 |
90 | The Keras API gives us each convolution and each pooling and each dense, etc. as
91 | a layer. So with the layers API, I can take a look at each layer’s outputs, so
92 | I’ll create a list of each layer’s output. I can then treat each item in the
93 | layer as an individual activation model if I want to see the results of just
94 | that layer. Now, by looping through the layers, I can display the journey of the
95 | image through the first convolution and then the first pooling and then the
96 | second convolution and then the second pooling. Note how the size of the image
97 | is changing by looking at the axes. If I set the convolution number to one, we
98 | can see that it almost immediately detects the laces area as a common feature
99 | between the shoes.
100 |
101 | So, for example, if I change the third image to be one, which looks like a
102 | handbag, you’ll see that it also has a bright line near the bottom that could
103 | look like the soul of the shoes, but by the time it gets through the
104 | convolutions, that’s lost, and that area for the laces doesn’t even show up at
105 | all. So this convolution definitely helps me separate issue from a handbag.
106 | Again, if I said it’s a two, it appears to be trousers, but the feature that
107 | detected something that the shoes had in common fails again. Also, if I changed
108 | my third image back to that for shoe, but I tried a different convolution
109 | number, you’ll see that for convolution two, it didn’t really find any common
110 | features. To see commonality in a different image, try images two, three, and
111 | five. These all appear to be trousers. Convolutions two and four seem to detect
112 | this vertical feature as something they all have in common. If I again go to the
113 | list and find three labels that are the same, in this case six, I can see what
114 | they signify. When I run it, I can see that they appear to be shirts.
115 | Convolution four doesn’t do a whole lot, so let’s try five. We can kind of see
116 | that the color appears to light up in this case.
117 |
118 | There are some exercises at the bottom of the notebook check them out.
119 |
120 | *****
121 |
122 | ### How convolutions work, hands-on ?(OPTIONAL)
123 |
124 | We willcreate a little pooling algorithm, so you can visualize its impact.
125 | There’s a notebook that you can play with too, and I’ll step through that here.
126 | Here’s the notebook for playing with convolutions[
127 | here](https://github.com/Rishit-dagli/Artificial-Intelligence_resources-and-notebooks/blob/master/Convolutions_from_scratch.ipynb).
128 | It does use a few Python libraries that you may not be familiar with such as
129 | `cv2`. It also has `Matplotlib `that we used before. If you haven’t used them,
130 | they’re really quite intuitive for this task and they’re very very easy to
131 | learn. So first, we’ll set up our inputs and in particular, import the misc
132 | library from `SciPy`. Now, this is a nice shortcut for us because `misc.ascent`
133 | returns a nice image that we can play with, and we don’t have to worry about
134 | managing our own.
135 |
136 | `Matplotlib` contains the code for drawing an image and it will render it right
137 | in the browser with Colab. Here, we can see the ascent image from `SciPy`. Next
138 | up, we’ll take a copy of the image, and we’ll add it with our homemade
139 | convolutions, and we’ll create variables to keep track of the `x` and `y`
140 | dimensions of the image. So we can see here that it’s a 512 by 512 image. So
141 | now, let’s create a convolution as a three by three array. We’ll load it with
142 | values that are pretty good for detecting sharp edges first. Here’s where we’ll
143 | create the convolution.
144 |
145 | We then iterate over the image, leaving a one pixel margin. You’ll see that the
146 | loop starts at one and not zero, and it ends at size x minus one and size y
147 | minus one. In the loop, it will then calculate the convolution value by looking
148 | at the pixel and its neighbors, and then by multiplying them out by the values
149 | determined by the filter, before finally summing it all up.
150 |
151 | 
152 | Vertical line filter
153 |
154 | Let’s run it. It takes just a few seconds, so when it’s done, let’s draw the
155 | results. We can see that only certain features made it through the filter. I’ve
156 | provided a couple more filters, so let’s try them. This first one is really
157 | great at spotting vertical lines. So when I run it, and plot the results, we can
158 | see that the vertical lines in the image made it through. It’s really cool
159 | because they’re not just straight up and down, they are vertical in perspective
160 | within the perspective of the image itself. Similarly, this filter works well
161 | for horizontal lines. So when I run it, and then plot the results, we can see
162 | that a lot of the horizontal lines made it through. Now, let’s take a look at
163 | pooling, and in this case, Max pooling, which takes pixels in chunks of four and
164 | only passes through the biggest value. I run the code and then render the
165 | output. We can see that the features of the image are maintained, but look
166 | closely at the axes, and we can see that the size has been halved from the 500’s
167 | to the 250's.
168 |
169 | 
170 | With pooling
171 |
172 | *****
173 |
174 | ### Excercise 3
175 |
176 | Now you need to apply this to MNIST Handwrting recognition we will revisit that
177 | from last blog post. You need to improve MNIST to 99.8% accuracy or more using
178 | only a single convolutional layer and a single MaxPooling 2D. You should stop
179 | training once the accuracy goes above this amount. It should happen in less than
180 | 20 epochs, so it’s ok to hard code the number of epochs for training, but your
181 | training must end once it hits the above metric. If it doesn’t, then you’ll need
182 | to redesign your layers.
183 |
184 | When 99.8% accuracy has been hit, you should print out the string “Reached 99.8%
185 | accuracy so cancelling training!”. Yes this is just optional (You can also print
186 | out something like “I’m getting bored and won’t train any more” 🤣)
187 |
188 | The question notebook is available —
189 | [here](https://github.com/Rishit-dagli/Artificial-Intelligence_resources-and-notebooks/blob/master/Exercise_3_Question.ipynb)
190 |
191 | ### My Solution
192 |
193 | Wonderful! 😃 , you just coded for a handwriting recognizer with a 99.8%
194 | accuracy (that’s good) in less than 20 epochs. Let explore my solution for this.
195 |
196 | My solution
197 |
198 | The callback class (This is the simplest)
199 |
200 | class myCallback(tf.keras.callbacks.Callback):
201 |
202 | def on_epoch_end(self, epoch, logs={}):
203 |
204 | if(logs.get('acc')>0.998):
205 |
206 | print("/n Reached 99.8% accuracy so cancelling training!")
207 |
208 | self.model.stop_training = True
209 |
210 | The main CNN code
211 |
212 | training_images=training_images.reshape(60000, 28, 28, 1)
213 | test_images=test_images.reshape(10000, 28, 28, 1)
214 | training_images = training_images / 255.0
215 | test_images = test_images / 255.0
216 | # YOUR CODE ENDS HERE
217 |
218 | model = tf.keras.models.Sequential([
219 | # YOUR CODE STARTS HERE
220 | tf.keras.layers.Conv2D(64, (3,3), activation='relu', input_shape=(28, 28, 1)),
221 | tf.keras.layers.MaxPooling2D(2, 2),
222 | tf.keras.layers.Flatten(),
223 | tf.keras.layers.Dense(256, activation='relu'),
224 | tf.keras.layers.Dense(10, activation='softmax')
225 | # YOUR CODE ENDS HERE
226 | ])
227 |
228 | So, all you had to do was play around the code and get this done in just 7
229 | epochs.
230 |
231 | 
232 | My output
233 |
234 | The solution notebook is available
235 | [here](https://github.com/Rishit-dagli/Artificial-Intelligence_resources-and-notebooks/blob/master/Excercise_3_Solution.ipynb)
236 |
237 | I hope this was helpful for you and you learned about visualizing CNNs and
238 | applying them on a real life data set, you also created a handwritten number
239 | recognizer all by yourself with a wonderful accuracy. That’s pretty good
240 |
241 | *****
242 |
243 | ### About Me
244 |
245 | Hi everyone I am Rishit Dagli
246 |
247 | [Twitter](https://twitter.com/rishit_dagli)
248 |
249 | [Website](https://rishit.tech/)
250 |
251 | If you want to ask me some questions, report any mistake, suggest improvements,
252 | give feedback you are free to do so by emailing me at —
253 |
254 | * [rishit.dagli@gmail.com](mailto:rishit.dagli@gmail.com)
255 | * [hello@rishit.tech](mailto:hello@rishit.tech)
256 |
--------------------------------------------------------------------------------
/Part 5-Working with Complex Image data for CNNs/README.md:
--------------------------------------------------------------------------------
1 |
2 | ## Working with Complex Image data for CNNs
3 |
4 | The same blog is avaliaible on Medium [here](https://medium.com/@rishit.dagli/working-with-complex-image-data-for-cnns-187fb4526893)
5 |
6 | 
7 |
8 | ## Table of contents
9 |
10 | 1. [Get started with TensorFlow and Deep Learning](https://medium.com/@rishit.dagli/get-started-with-tensorflow-and-deep-learning-part-1-72c7d67f99fc)
11 |
12 | 2. [Computer Vision with TensorFlow](https://medium.com/@rishit.dagli/computer-vision-with-tensorflow-part-2-57e95cd0551)
13 |
14 | 3. [Using Convolutional Neural Networks with TensorFlow](https://medium.com/@rishit.dagli/using-convolutional-neural-networks-with-tensorflow-part-3-35de28a5621)
15 |
16 | 4. [Extending what Convolutional Neural Nets can do](https://medium.com/@rishit.dagli/extending-what-convolutional-nets-can-do-251f3021529c)
17 |
18 | 5. [Working with Complex Image data for CNNs](https://medium.com/@rishit.dagli/working-with-complex-image-data-for-cnns-187fb4526893)
19 |
20 | All the code used here is available in my GitHub repository [here](https://github.com/Rishit-dagli/Deep-Learning-With-TensorFlow-Tutorials).
21 |
22 | This is the fifth part of the series where I post about TensorFlow for Deep Learning and Machine Learning. In the earlier blog post, you saw how you could apply a Convolutional Neural Network for Computer Vision with some real-life data sets. It did the job pretty nicely. This time you’re going to work with more complex data and do even more with the data. I believe in hands-on coding so we will have many exercises and demos which you can try yourself too. I would recommend you to play around with these exercises and change the hyper-parameters and experiment with the code. We will also be working. If you have not read the previous article consider reading it once before you read this one [here](https://medium.com/@rishit.dagli/extending-what-convolutional-nets-can-do-251f3021529c). This one is more like a continuation of that.
23 |
24 | ## Reading the Data
25 |
26 | In the previous blog post, we worked with MNIST data which was pretty simple, grayscaled 28 X 28 images, and the thing you want to classify is centered in the image. Real-life data is different, it has more complex images, your subject might be anywhere in the image not necessarily centered. Our dataset had very uniform images too. This time we’ll also work on a larger dataset.
27 | We’ll be using the [Cats vs Dogs dataset](https://www.kaggle.com/c/dogs-vs-cats) to try out these things for ourselves. TensorFlow has something called [ImageDataGenerator](https://www.tensorflow.org/api_docs/python/tf/keras/preprocessing/image/ImageDataGenerator) which simplifies things for us and allows us to directly read the images and place them. So you would first have two directories called train and validation directory, each of the directories would have two subdirectories Cats and Dogs each of which would have the respective images and auto label them for us. Here’s how the directory structure looks-
28 |
29 | 
30 |
31 | Let’s now see this in code. The ImageDataGenerator is present in tensorflow.keras.preprocessing.image so first let’s go ahead and import it-
32 |
33 | from tensorflow.keras.preprocessing.image import ImageDataGenerator
34 |
35 | Once you do this you can now use the ImageDataGenerator -
36 |
37 | train_image_generator = ImageDataGenerator(rescale=1./255)
38 |
39 | train_data_gen = train_iamge_generator.flow_from_directory(
40 | batch_size=batch_size,
41 | directory=train_dir,
42 | shuffle=True,
43 | target_size=(IMG_HEIGHT,IMG_WIDTH)
44 | class_mode='binary')
45 |
46 | We first pass in rescale=1./255 to normalize the images, you can then call the flow_from_directory the method from that directory and its sub-directories. So in this case taking the above diagram as a reference, you would pass in the Training directory.
47 |
48 | Images in your data might be of different sizes to convert or resize them all into one size by the target_size . This is a very important step as all inputs to the neural network should be of the size. A nice thing about this code is that the images are resized for you as they’re loaded. So you don’t need to preprocess thousands of images on your file system you instead to do it in runtime.
49 |
50 | The images will be loaded for training and validation in batches where it’s more efficient than doing it one by one. You can specify this by the batch_size , there are a lot of factors to consider when specifying a batch size which we will not be discussing in this blog post. But you can experiment with different sizes to see the impact on the performance.
51 |
52 | This is a binary classifier that is it picks between two different things; cats and dogs so we specify that here by the class_mode.
53 |
54 | And that’s all you need to read your data and auto label them according to their directories and also do some processing in run time. SO let’s do the same for validation data too-
55 |
56 | validation_image_generator = ImageDataGenerator(rescale=1./255)
57 | val_data_gen = validation_imadata_generator.flow_from_directory(
58 | batch_size=batch_size,
59 | directory= validation_dir,
60 | shuffle=True,
61 | target_size=(IMG_HEIGHT,IMG_WIDTH)
62 | class_mode='binary')
63 |
64 | ## Training the model
65 |
66 | Another great thing about ImageDataGenerator is there is little or almost no change while building and training the model, so let's build a sample model for the dogs vs cats problem and then compile it.
67 |
68 | model = Sequential([
69 | Conv2D(16, (3,3), padding='same', activation='relu',
70 | input_shape=(IMG_HEIGHT, IMG_WIDTH ,3)),
71 | MaxPooling2D(2,2),
72 | Conv2D(32, (3,3), padding='same', activation='relu'),
73 | MaxPooling2D(2,2),
74 | Conv2D(64, (3,3), padding='same', activation='relu'),
75 | MaxPooling2D(2,2),
76 | Flatten(),
77 | Dense(512, activation='relu'),
78 | Dense(1, activation='sigmoid')])
79 |
80 | model.compile(optimizer='adam',
81 | loss='binary_crossentropy',
82 | metrics=['accuracy'])
83 |
84 | You can see that you don't have to do any changes while compiling your model to make it work with ImageDataGenerator , let’s get to the training part now.
85 |
86 | history = model.fit_generator(
87 | train_data_gen,
88 | steps_per_epoch=total_train//batch_size,
89 | epochs=epochs,
90 | validation_data=val_data_gen,
91 | validation_steps=total_val//batch_size
92 | )
93 |
94 | A difference you would see here is instead of passing the training data directly after loading it, I now pass the train_data_gen which reads the data from the disk using ImageDataGenerator and performs the transformations on it. And you can do the same with the validation data too.
95 |
96 | ## Trying out for yourself
97 |
98 | All the code we just talked about is implemented in [this notebook](https://github.com/Rishit-dagli/Deep-Learning-With-TensorFlow-Tutorials/tree/master/Part%205-Working%20with%20Complex%20Image%20data%20for%C2%A0CNNs). The model we will build is not yet a perfect or suitable model and suffers from overfitting, we will see how we can tackle this problem in the next blog in this series.
99 |
100 | You can use the Open in Colab button to directly open the notebook in Colab or even download it and run it on your system.
101 |
102 | ## About Me
103 |
104 | Hi everyone I am Rishit Dagli
105 |
106 | [Twitter](https://twitter.com/rishit_dagli)
107 |
108 | [Website](https://rishit.tech/)
109 |
110 | If you want to ask me some questions, report any mistake, suggest improvements, give feedback you are free to do so by emailing me at —
111 |
112 | * [rishit.dagli@gmail.com](mailto:rishit.dagli@gmail.com)
113 |
114 | * [hello@rishit.tech](mailto:hello@rishit.tech)
115 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Deep-Learning-With-TensorFlow [](https://twitter.com/intent/tweet?text=Wow:&url=https%3A%2F%2Fgithub.com%2FRishit-dagli%2FDeep-Learning-With-TensorFlow-Blog-series)
2 |
3 | [](https://colab.research.google.com/github/Rishit-dagli/Deep-Learning-With-TensorFlow)
4 | [](https://mybinder.org/v2/gh/Rishit-dagli/Deep-Learning-With-TensorFlow/master)
5 |
6 | [](https://github.com/Rishit-dagli/Deep-Learning-With-TensorFlow-Blog-series/blob/master/LICENSE)
7 | [](https://github.com/Rishit-dagli)
8 | [](https://twitter.com/intent/follow?screen_name=rishit_dagli)
9 |
10 | Consider leaving a :star: if you like this series of tutorials.
11 |
12 | This repo gets you started with Deep Learning with TensorFlow. This will be all about about coding Machine Learning and Deep Learning algorithms. I believe in hands-on coding
13 | so we will have many exercises and demos which you can try yourself too. You would first have a blog to read to and have one or many Jupyter Notebooks which you can try and also
14 | have excercises which you can do. These blogs are also availaible as a blog series on [Medium](http://bit.ly/dlwithtf).
15 |
16 | > More parts coming soon!
17 |
18 | ## Table of Contents
19 |
20 | - [Getting started with TensorFlow and Deep Learning](https://github.com/Rishit-dagli/Deep-Learning-With-TensorFlow/tree/master/Part%201-Getting%20started%20with%20TensorFlow%20and%20Deep%20Learning)
21 | - [Computer Vision with TensorFlow](https://github.com/Rishit-dagli/Deep-Learning-With-TensorFlow/tree/master/Part%202-Computer%20Vision%20with%20TensorFlow)
22 | - [Using Convolutional Neural Networks with TensorFlow](https://github.com/Rishit-dagli/Deep-Learning-With-TensorFlow/tree/master/Part%203-Using%20Convolutional%20Neural%20Networks%20with%20TensorFlow)
23 | - [Extending what Convolutional Neural Nets can do](https://github.com/Rishit-dagli/Deep-Learning-With-TensorFlow/tree/master/Part%204-Extending%20what%20Convolutional%20Neural%20Nets%20can%20do)
24 | - [Working with Complex Image data for CNNs](https://github.com/Rishit-dagli/Deep-Learning-With-TensorFlow/tree/master/Part%205-Working%20with%20Complex%20Image%20data%20for%C2%A0CNNs)
25 |
26 | ## Do you need any setup?
27 |
28 | No! You would not need any hardware or software setup to work your way around these tutorials, each of the notebooks have a button  which you can use to open it in [Google Colab](https://colab.research.google.com/) (We'll often refer to this as just Colab) right in your browser :rocket: . If you do not know about Google Colab head on to the [first part](https://github.com/Rishit-dagli/Deep-Learning-With-TensorFlow/tree/master/Part%201-Getting%20started%20with%20TensorFlow%20and%20Deep%20Learning) which also gives an intro about Colab. If you are more comfortable with using [Binder](https://mybinder.org/) you can use this button [](https://mybinder.org/v2/gh/Rishit-dagli/Deep-Learning-With-TensorFlow/master) to open this repo in Binder.
29 |
30 | ## Why should you be learning this?
31 |
32 | To keep the tutorials concise and to-the-point I have not included this in the tutorials itself.
33 | If you are a newbie to Machine Learning you would most likely wonder why would you be interested in any of this? However, if you have worked with same other ML Framework or library and want to know about TensorFlow you can simply skip this section.
34 |
35 | Artificial Intelligence has revolutionized the way people think, learn, and work in almost every field. You most probably make more use of this than you would imagine. Think about games, the famous YouTube recommendation algorithm or Google Photos identifying faces or identifying if an image is a person or an animal (You will be making a similar program in [Part-5](https://github.com/Rishit-dagli/Deep-Learning-With-TensorFlow/tree/master/Part%205-Working%20with%20Complex%20Image%20data%20for%C2%A0CNNs) ) all powered by Machine Learning. In these tutorials you will be exploring more of the practical aspect of this :smiley: .
36 |
37 | To know more about where AI could be used give [this](https://hackernoon.com/10-reasons-why-you-should-learn-artificial-intelligence-5v6q30vo) blog by Ben Cryer a read.
38 |
--------------------------------------------------------------------------------