Format: application/octet-stream
1 {
2 "cells": [
3 {
4 "cell_type": "markdown",
5 "metadata": {
6 "id": "tUgsCvCHLksw"
7 },
8 "source": [
9 "#TensorFlow Core Learning Algorithms\n",
10 "In this notebook we will walk through 4 fundemental machine learning algorithms. We will apply each of these algorithms to unique problems and datasets before highlighting the use cases of each.\n",
11 "\n",
12 "The algorithms we will focus on include:\n",
13 "- Linear Regression\n",
14 "- Classification\n",
15 "- Clustering\n",
16 "- Hidden Markov Models\n",
17 "\n",
18 "It is worth noting that there are many tools within TensorFlow that could be used to solve the problems we will see below. I have chosen the tools that I belive give the most variety and are easiest to use."
19 ]
20 },
21 {
22 "cell_type": "markdown",
23 "metadata": {
24 "id": "mbdnKlcuMM4u"
25 },
26 "source": [
27 "##Linear Regression\n",
28 "Linear regression is one of the most basic forms of machine learning and is used to predict numeric values. \n",
29 "\n",
30 "In this tutorial we will use a linear model to predict the survival rate of passangers from the titanic dataset.\n",
31 "\n",
32 "*This section is based on the following documentation: https://www.tensorflow.org/tutorials/estimator/linear*\n"
33 ]
34 },
35 {
36 "cell_type": "markdown",
37 "metadata": {
38 "id": "wsJ-Iov1P4RK"
39 },
40 "source": [
41 "###How it Works\n",
42 "Before we dive in, I will provide a very surface level explination of the linear regression algorithm.\n",
43 "\n",
44 "Linear regression follows a very simple concept. If data points are related linearly, we can generate a line of best fit for these points and use it to predict future values.\n",
45 "\n",
46 "Let's take an example of a data set with one feature and one label.\n",
47 "\n"
48 ]
49 },
50 {
51 "cell_type": "code",
52 "execution_count": null,
53 "metadata": {
54 "colab": {
55 "base_uri": "https://localhost:8080/",
56 "height": 286
57 },
58 "id": "t4Hp-dYmR2jf",
59 "outputId": "db401a27-85b0-4ec2-a110-91c938f54bca"
60 },
61 "outputs": [
62 {
63 "data": {
64 "text/plain": [
65 "(0.0, 6.0, 0.0, 20.0)"
66 ]
67 },
68 "execution_count": 10,
69 "metadata": {
70 "tags": []
71 },
72 "output_type": "execute_result"
73 },
74 {
75 "data": {
76 "image/png": "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\n",
77 "text/plain": [
78 "<Figure size 432x288 with 1 Axes>"
79 ]
80 },
81 "metadata": {
82 "needs_background": "light",
83 "tags": []
84 },
85 "output_type": "display_data"
86 }
87 ],
88 "source": [
89 "import matplotlib.pyplot as plt\n",
90 "import numpy as np\n",
91 "\n",
92 "x = [1, 2, 2.5, 3, 4]\n",
93 "y = [1, 4, 7, 9, 15]\n",
94 "plt.plot(x, y, 'ro')\n",
95 "plt.axis([0, 6, 0, 20])"
96 ]
97 },
98 {
99 "cell_type": "markdown",
100 "metadata": {
101 "id": "2m1DTp22SLo3"
102 },
103 "source": [
104 "We can see that this data has a linear coorespondence. When the x value increases, so does the y. Because of this relation we can create a line of best fit for this dataset. In this example our line will only use one input variable, as we are working with two dimensions. In larger datasets with more features our line will have more features and inputs.\n",
105 "\n",
106 "\"Line of best fit refers to a line through a scatter plot of data points that best expresses the relationship between those points.\" (https://www.investopedia.com/terms/l/line-of-best-fit.asp)\n",
107 "\n",
108 "Here's a refresher on the equation of a line in 2D.\n",
109 "\n",
110 "$ y = mx + b $\n",
111 "\n",
112 "Here's an example of a line of best fit for this graph.\n",
113 "\n"
114 ]
115 },
116 {
117 "cell_type": "code",
118 "execution_count": null,
119 "metadata": {
120 "colab": {
121 "base_uri": "https://localhost:8080/",
122 "height": 269
123 },
124 "id": "Kv5eKLP_UYZi",
125 "outputId": "77c4f7fd-d343-4f60-a7a0-ebeecd253ef9"
126 },
127 "outputs": [
128 {
129 "data": {
130 "image/png": "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\n",
131 "text/plain": [
132 "<Figure size 432x288 with 1 Axes>"
133 ]
134 },
135 "metadata": {
136 "needs_background": "light",
137 "tags": []
138 },
139 "output_type": "display_data"
140 }
141 ],
142 "source": [
143 "plt.plot(x, y, 'ro')\n",
144 "plt.axis([0, 6, 0, 20])\n",
145 "plt.plot(np.unique(x), np.poly1d(np.polyfit(x, y, 1))(np.unique(x)))\n",
146 "plt.show()"
147 ]
148 },
149 {
150 "cell_type": "markdown",
151 "metadata": {
152 "id": "Hd3T50PLB4lV"
153 },
154 "source": [
155 "Once we've generated this line for our dataset, we can use its equation to predict future values. We just pass the features of the data point we would like to predict into the equation of the line and use the output as our prediction."
156 ]
157 },
158 {
159 "cell_type": "markdown",
160 "metadata": {
161 "id": "y02FbC56Nbx0"
162 },
163 "source": [
164 "### Setup and Imports\n",
165 "Before we get started we must install *sklearn* and import the following modules."
166 ]
167 },
168 {
169 "cell_type": "code",
170 "execution_count": null,
171 "metadata": {
172 "id": "p4xpuxwKHOGL"
173 },
174 "outputs": [],
175 "source": [
176 "!pip install -q sklearn"
177 ]
178 },
179 {
180 "cell_type": "code",
181 "execution_count": null,
182 "metadata": {
183 "colab": {
184 "base_uri": "https://localhost:8080/",
185 "height": 103
186 },
187 "id": "iI3zi2ZhQ3WB",
188 "outputId": "9b7fa093-1a82-481a-fabe-1cb44429919d"
189 },
190 "outputs": [
191 {
192 "name": "stdout",
193 "output_type": "stream",
194 "text": [
195 "`%tensorflow_version` only switches the major version: 1.x or 2.x.\n",
196 "You set: `2.x # this line is not required unless you are in a notebook`. This will be interpreted as: `2.x`.\n",
197 "\n",
198 "\n",
199 "TensorFlow is already loaded. Please restart the runtime to change versions.\n"
200 ]
201 }
202 ],
203 "source": [
204 "%tensorflow_version 2.x # this line is not required unless you are in a notebook"
205 ]
206 },
207 {
208 "cell_type": "code",
209 "execution_count": null,
210 "metadata": {
211 "id": "qcII_xj9Ntyo"
212 },
213 "outputs": [],
214 "source": [
215 "from __future__ import absolute_import, division, print_function, unicode_literals\n",
216 "\n",
217 "import numpy as np\n",
218 "import pandas as pd\n",
219 "import matplotlib.pyplot as plt\n",
220 "from IPython.display import clear_output\n",
221 "from six.moves import urllib\n",
222 "\n",
223 "import tensorflow.compat.v2.feature_column as fc\n",
224 "\n",
225 "import tensorflow as tf"
226 ]
227 },
228 {
229 "cell_type": "markdown",
230 "metadata": {
231 "id": "GltdTjiERfWi"
232 },
233 "source": [
234 "### Data\n",
235 "So, if you haven't realized by now a major part of machine learning is data! In fact, it's so important that most of what we do in this tutorial will focus on exploring, cleaning and selecting appropriate data.\n",
236 "\n",
237 "The dataset we will be focusing on here is the titanic dataset. It has tons of information about each passanger on the ship. Our first step is always to understand the data and explore it. So, let's do that!\n",
238 "\n",
239 "**Below we will load a dataset and learn how we can explore it using some built-in tools. **\n",
240 "\n"
241 ]
242 },
243 {
244 "cell_type": "code",
245 "execution_count": null,
246 "metadata": {
247 "id": "CpllWsKIOGOy"
248 },
249 "outputs": [],
250 "source": [
251 "# Load dataset.\n",
252 "dftrain = pd.read_csv('https://storage.googleapis.com/tf-datasets/titanic/train.csv') # training data\n",
253 "dfeval = pd.read_csv('https://storage.googleapis.com/tf-datasets/titanic/eval.csv') # testing data\n",
254 "y_train = dftrain.pop('survived')\n",
255 "y_eval = dfeval.pop('survived')"
256 ]
257 },
258 {
259 "cell_type": "markdown",
260 "metadata": {
261 "id": "1PJr5GosQBeY"
262 },
263 "source": [
264 "The ```pd.read_csv()``` method will return to us a new pandas *dataframe*. You can think of a dataframe like a table. In fact, we can actually have a look at the table representation.\n",
265 "\n",
266 "We've decided to pop the \"survived\" column from our dataset and store it in a new variable. This column simply tells us if the person survived our not.\n",
267 "\n",
268 "To look at the data we'll use the ```.head()``` method from pandas. This will show us the first 5 items in our dataframe."
269 ]
270 },
271 {
272 "cell_type": "code",
273 "execution_count": null,
274 "metadata": {
275 "colab": {
276 "base_uri": "https://localhost:8080/",
277 "height": 201
278 },
279 "id": "mKsXeWinQiVR",
280 "outputId": "b91f8b23-eb7b-4fa6-ccd7-aef6d9441afa"
281 },
282 "outputs": [
283 {
284 "data": {
285 "text/html": [
286 "<div>\n",
287 "<style scoped>\n",
288 " .dataframe tbody tr th:only-of-type {\n",
289 " vertical-align: middle;\n",
290 " }\n",
291 "\n",
292 " .dataframe tbody tr th {\n",
293 " vertical-align: top;\n",
294 " }\n",
295 "\n",
296 " .dataframe thead th {\n",
297 " text-align: right;\n",
298 " }\n",
299 "</style>\n",
300 "<table border=\"1\" class=\"dataframe\">\n",
301 " <thead>\n",
302 " <tr style=\"text-align: right;\">\n",
303 " <th></th>\n",
304 " <th>sex</th>\n",
305 " <th>age</th>\n",
306 " <th>n_siblings_spouses</th>\n",
307 " <th>parch</th>\n",
308 " <th>fare</th>\n",
309 " <th>class</th>\n",
310 " <th>deck</th>\n",
311 " <th>embark_town</th>\n",
312 " <th>alone</th>\n",
313 " </tr>\n",
314 " </thead>\n",
315 " <tbody>\n",
316 " <tr>\n",
317 " <th>0</th>\n",
318 " <td>male</td>\n",
319 " <td>22.0</td>\n",
320 " <td>1</td>\n",
321 " <td>0</td>\n",
322 " <td>7.2500</td>\n",
323 " <td>Third</td>\n",
324 " <td>unknown</td>\n",
325 " <td>Southampton</td>\n",
326 " <td>n</td>\n",
327 " </tr>\n",
328 " <tr>\n",
329 " <th>1</th>\n",
330 " <td>female</td>\n",
331 " <td>38.0</td>\n",
332 " <td>1</td>\n",
333 " <td>0</td>\n",
334 " <td>71.2833</td>\n",
335 " <td>First</td>\n",
336 " <td>C</td>\n",
337 " <td>Cherbourg</td>\n",
338 " <td>n</td>\n",
339 " </tr>\n",
340 " <tr>\n",
341 " <th>2</th>\n",
342 " <td>female</td>\n",
343 " <td>26.0</td>\n",
344 " <td>0</td>\n",
345 " <td>0</td>\n",
346 " <td>7.9250</td>\n",
347 " <td>Third</td>\n",
348 " <td>unknown</td>\n",
349 " <td>Southampton</td>\n",
350 " <td>y</td>\n",
351 " </tr>\n",
352 " <tr>\n",
353 " <th>3</th>\n",
354 " <td>female</td>\n",
355 " <td>35.0</td>\n",
356 " <td>1</td>\n",
357 " <td>0</td>\n",
358 " <td>53.1000</td>\n",
359 " <td>First</td>\n",
360 " <td>C</td>\n",
361 " <td>Southampton</td>\n",
362 " <td>n</td>\n",
363 " </tr>\n",
364 " <tr>\n",
365 " <th>4</th>\n",
366 " <td>male</td>\n",
367 " <td>28.0</td>\n",
368 " <td>0</td>\n",
369 " <td>0</td>\n",
370 " <td>8.4583</td>\n",
371 " <td>Third</td>\n",
372 " <td>unknown</td>\n",
373 " <td>Queenstown</td>\n",
374 " <td>y</td>\n",
375 " </tr>\n",
376 " </tbody>\n",
377 "</table>\n",
378 "</div>"
379 ],
380 "text/plain": [
381 " sex age n_siblings_spouses parch ... class deck embark_town alone\n",
382 "0 male 22.0 1 0 ... Third unknown Southampton n\n",
383 "1 female 38.0 1 0 ... First C Cherbourg n\n",
384 "2 female 26.0 0 0 ... Third unknown Southampton y\n",
385 "3 female 35.0 1 0 ... First C Southampton n\n",
386 "4 male 28.0 0 0 ... Third unknown Queenstown y\n",
387 "\n",
388 "[5 rows x 9 columns]"
389 ]
390 },
391 "execution_count": 16,
392 "metadata": {
393 "tags": []
394 },
395 "output_type": "execute_result"
396 }
397 ],
398 "source": [
399 "dftrain.head()"
400 ]
401 },
402 {
403 "cell_type": "markdown",
404 "metadata": {
405 "id": "eeVQGdpCRC1P"
406 },
407 "source": [
408 "And if we want a more statistical analysis of our data we can use the ```.describe()``` method."
409 ]
410 },
411 {
412 "cell_type": "code",
413 "execution_count": null,
414 "metadata": {
415 "colab": {
416 "base_uri": "https://localhost:8080/",
417 "height": 293
418 },
419 "id": "IkL2G42GRMf8",
420 "outputId": "ffb42606-8f18-48d2-aacf-120578212af7"
421 },
422 "outputs": [
423 {
424 "data": {
425 "text/html": [
426 "<div>\n",
427 "<style scoped>\n",
428 " .dataframe tbody tr th:only-of-type {\n",
429 " vertical-align: middle;\n",
430 " }\n",
431 "\n",
432 " .dataframe tbody tr th {\n",
433 " vertical-align: top;\n",
434 " }\n",
435 "\n",
436 " .dataframe thead th {\n",
437 " text-align: right;\n",
438 " }\n",
439 "</style>\n",
440 "<table border=\"1\" class=\"dataframe\">\n",
441 " <thead>\n",
442 " <tr style=\"text-align: right;\">\n",
443 " <th></th>\n",
444 " <th>age</th>\n",
445 " <th>n_siblings_spouses</th>\n",
446 " <th>parch</th>\n",
447 " <th>fare</th>\n",
448 " </tr>\n",
449 " </thead>\n",
450 " <tbody>\n",
451 " <tr>\n",
452 " <th>count</th>\n",
453 " <td>627.000000</td>\n",
454 " <td>627.000000</td>\n",
455 " <td>627.000000</td>\n",
456 " <td>627.000000</td>\n",
457 " </tr>\n",
458 " <tr>\n",
459 " <th>mean</th>\n",
460 " <td>29.631308</td>\n",
461 " <td>0.545455</td>\n",
462 " <td>0.379585</td>\n",
463 " <td>34.385399</td>\n",
464 " </tr>\n",
465 " <tr>\n",
466 " <th>std</th>\n",
467 " <td>12.511818</td>\n",
468 " <td>1.151090</td>\n",
469 " <td>0.792999</td>\n",
470 " <td>54.597730</td>\n",
471 " </tr>\n",
472 " <tr>\n",
473 " <th>min</th>\n",
474 " <td>0.750000</td>\n",
475 " <td>0.000000</td>\n",
476 " <td>0.000000</td>\n",
477 " <td>0.000000</td>\n",
478 " </tr>\n",
479 " <tr>\n",
480 " <th>25%</th>\n",
481 " <td>23.000000</td>\n",
482 " <td>0.000000</td>\n",
483 " <td>0.000000</td>\n",
484 " <td>7.895800</td>\n",
485 " </tr>\n",
486 " <tr>\n",
487 " <th>50%</th>\n",
488 " <td>28.000000</td>\n",
489 " <td>0.000000</td>\n",
490 " <td>0.000000</td>\n",
491 " <td>15.045800</td>\n",
492 " </tr>\n",
493 " <tr>\n",
494 " <th>75%</th>\n",
495 " <td>35.000000</td>\n",
496 " <td>1.000000</td>\n",
497 " <td>0.000000</td>\n",
498 " <td>31.387500</td>\n",
499 " </tr>\n",
500 " <tr>\n",
501 " <th>max</th>\n",
502 " <td>80.000000</td>\n",
503 " <td>8.000000</td>\n",
504 " <td>5.000000</td>\n",
505 " <td>512.329200</td>\n",
506 " </tr>\n",
507 " </tbody>\n",
508 "</table>\n",
509 "</div>"
510 ],
511 "text/plain": [
512 " age n_siblings_spouses parch fare\n",
513 "count 627.000000 627.000000 627.000000 627.000000\n",
514 "mean 29.631308 0.545455 0.379585 34.385399\n",
515 "std 12.511818 1.151090 0.792999 54.597730\n",
516 "min 0.750000 0.000000 0.000000 0.000000\n",
517 "25% 23.000000 0.000000 0.000000 7.895800\n",
518 "50% 28.000000 0.000000 0.000000 15.045800\n",
519 "75% 35.000000 1.000000 0.000000 31.387500\n",
520 "max 80.000000 8.000000 5.000000 512.329200"
521 ]
522 },
523 "execution_count": 17,
524 "metadata": {
525 "tags": []
526 },
527 "output_type": "execute_result"
528 }
529 ],
530 "source": [
531 "dftrain.describe()"
532 ]
533 },
534 {
535 "cell_type": "markdown",
536 "metadata": {
537 "id": "aX7FSzrQRXeC"
538 },
539 "source": [
540 "And since we talked so much about shapes in the previous tutorial let's have a look at that too!"
541 ]
542 },
543 {
544 "cell_type": "code",
545 "execution_count": null,
546 "metadata": {
547 "colab": {
548 "base_uri": "https://localhost:8080/",
549 "height": 34
550 },
551 "id": "tR1Oy1dISdjn",
552 "outputId": "94fb254b-0222-4b4b-d47c-73562f37571c"
553 },
554 "outputs": [
555 {
556 "data": {
557 "text/plain": [
558 "(627, 9)"
559 ]
560 },
561 "execution_count": 18,
562 "metadata": {
563 "tags": []
564 },
565 "output_type": "execute_result"
566 }
567 ],
568 "source": [
569 "dftrain.shape"
570 ]
571 },
572 {
573 "cell_type": "markdown",
574 "metadata": {
575 "id": "iIfLiSRMTeW4"
576 },
577 "source": [
578 "So have have 627 entries and 9 features, nice!\n",
579 "\n",
580 "Now let's have a look at our survival information."
581 ]
582 },
583 {
584 "cell_type": "code",
585 "execution_count": null,
586 "metadata": {
587 "colab": {
588 "base_uri": "https://localhost:8080/",
589 "height": 120
590 },
591 "id": "aX1lKW7TTh-E",
592 "outputId": "6b2efa46-40a8-4fae-bdd1-b828283daa0c"
593 },
594 "outputs": [
595 {
596 "data": {
597 "text/plain": [
598 "0 0\n",
599 "1 1\n",
600 "2 1\n",
601 "3 1\n",
602 "4 0\n",
603 "Name: survived, dtype: int64"
604 ]
605 },
606 "execution_count": 19,
607 "metadata": {
608 "tags": []
609 },
610 "output_type": "execute_result"
611 }
612 ],
613 "source": [
614 "y_train.head()"
615 ]
616 },
617 {
618 "cell_type": "markdown",
619 "metadata": {
620 "id": "ahqIyYPoTnRh"
621 },
622 "source": [
623 "Notice that each entry is either a 0 or 1. Can you guess which stands for survival? \n",
624 "\n",
625 "**And now because visuals are always valuable let's generate a few graphs of the data.**"
626 ]
627 },
628 {
629 "cell_type": "code",
630 "execution_count": null,
631 "metadata": {
632 "colab": {
633 "base_uri": "https://localhost:8080/",
634 "height": 282
635 },
636 "id": "Edndbw4sU5Wd",
637 "outputId": "42a09890-5513-4785-84d7-98af53216446"
638 },
639 "outputs": [
640 {
641 "data": {
642 "text/plain": [
643 "<matplotlib.axes._subplots.AxesSubplot at 0x7f680f2b4d68>"
644 ]
645 },
646 "execution_count": 20,
647 "metadata": {
648 "tags": []
649 },
650 "output_type": "execute_result"
651 },
652 {
653 "data": {
654 "image/png": "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\n",
655 "text/plain": [
656 "<Figure size 432x288 with 1 Axes>"
657 ]
658 },
659 "metadata": {
660 "needs_background": "light",
661 "tags": []
662 },
663 "output_type": "display_data"
664 }
665 ],
666 "source": [
667 "dftrain.age.hist(bins=20)"
668 ]
669 },
670 {
671 "cell_type": "code",
672 "execution_count": null,
673 "metadata": {
674 "colab": {
675 "base_uri": "https://localhost:8080/",
676 "height": 282
677 },
678 "id": "4SM_tYvyUtsw",
679 "outputId": "128bea12-3654-4692-e7cc-6279f8ed2079"
680 },
681 "outputs": [
682 {
683 "data": {
684 "text/plain": [
685 "<matplotlib.axes._subplots.AxesSubplot at 0x7f680f1bf400>"
686 ]
687 },
688 "execution_count": 21,
689 "metadata": {
690 "tags": []
691 },
692 "output_type": "execute_result"
693 },
694 {
695 "data": {
696 "image/png": "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\n",
697 "text/plain": [
698 "<Figure size 432x288 with 1 Axes>"
699 ]
700 },
701 "metadata": {
702 "needs_background": "light",
703 "tags": []
704 },
705 "output_type": "display_data"
706 }
707 ],
708 "source": [
709 "dftrain.sex.value_counts().plot(kind='barh')"
710 ]
711 },
712 {
713 "cell_type": "code",
714 "execution_count": null,
715 "metadata": {
716 "colab": {
717 "base_uri": "https://localhost:8080/",
718 "height": 282
719 },
720 "id": "WCv3ek2LU1Lw",
721 "outputId": "a71bfdd1-ebbf-44cf-ad1b-9ec992e2fcd7"
722 },
723 "outputs": [
724 {
725 "data": {
726 "text/plain": [
727 "<matplotlib.axes._subplots.AxesSubplot at 0x7f680f185b38>"
728 ]
729 },
730 "execution_count": 22,
731 "metadata": {
732 "tags": []
733 },
734 "output_type": "execute_result"
735 },
736 {
737 "data": {
738 "image/png": "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\n",
739 "text/plain": [
740 "<Figure size 432x288 with 1 Axes>"
741 ]
742 },
743 "metadata": {
744 "needs_background": "light",
745 "tags": []
746 },
747 "output_type": "display_data"
748 }
749 ],
750 "source": [
751 "dftrain['class'].value_counts().plot(kind='barh')"
752 ]
753 },
754 {
755 "cell_type": "code",
756 "execution_count": null,
757 "metadata": {
758 "colab": {
759 "base_uri": "https://localhost:8080/",
760 "height": 296
761 },
762 "id": "D4kPWqBYVDlj",
763 "outputId": "c4f858de-73e4-41a3-8928-e97a0e0e08ad"
764 },
765 "outputs": [
766 {
767 "data": {
768 "text/plain": [
769 "Text(0.5, 0, '% survive')"
770 ]
771 },
772 "execution_count": 23,
773 "metadata": {
774 "tags": []
775 },
776 "output_type": "execute_result"
777 },
778 {
779 "data": {
780 "image/png": "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\n",
781 "text/plain": [
782 "<Figure size 432x288 with 1 Axes>"
783 ]
784 },
785 "metadata": {
786 "needs_background": "light",
787 "tags": []
788 },
789 "output_type": "display_data"
790 }
791 ],
792 "source": [
793 "pd.concat([dftrain, y_train], axis=1).groupby('sex').survived.mean().plot(kind='barh').set_xlabel('% survive')"
794 ]
795 },
796 {
797 "cell_type": "markdown",
798 "metadata": {
799 "id": "l42qmk_bVHvD"
800 },
801 "source": [
802 "After analyzing this information, we should notice the following:\n",
803 "- Most passengers are in their 20's or 30's \n",
804 "- Most passengers are male\n",
805 "- Most passengers are in \"Third\" class\n",
806 "- Females have a much higher chance of survival\n",
807 "\n"
808 ]
809 },
810 {
811 "cell_type": "markdown",
812 "metadata": {
813 "id": "sIBZww6kOIAp"
814 },
815 "source": [
816 "### Training vs Testing Data\n",
817 "You may have noticed that we loaded **two different datasets** above. This is because when we train models, we need two sets of data: **training and testing**. \n",
818 "\n",
819 "The **training** data is what we feed to the model so that it can develop and learn. It is usually a much larger size than the testing data.\n",
820 "\n",
821 "The **testing** data is what we use to evaulate the model and see how well it is performing. We must use a seperate set of data that the model has not been trained on to evaluate it. Can you think of why this is?\n",
822 "\n",
823 "Well, the point of our model is to be able to make predictions on NEW data, data that we have never seen before. If we simply test the model on the data that it has already seen we cannot measure its accuracy accuratly. We can't be sure that the model hasn't simply memorized our training data. This is why we need our testing and training data to be seperate.\n",
824 "\n"
825 ]
826 },
827 {
828 "cell_type": "markdown",
829 "metadata": {
830 "id": "Ar_cXv2jV8A3"
831 },
832 "source": [
833 "###Feature Columns\n",
834 "In our dataset we have two different kinds of information: **Categorical and Numeric**\n",
835 "\n",
836 "Our **categorical data** is anything that is not numeric! For example, the sex column does not use numbers, it uses the words \"male\" and \"female\".\n",
837 "\n",
838 "Before we continue and create/train a model we must convet our categorical data into numeric data. We can do this by encoding each category with an integer (ex. male = 1, female = 2). \n",
839 "\n",
840 "Fortunately for us TensorFlow has some tools to help!"
841 ]
842 },
843 {
844 "cell_type": "code",
845 "execution_count": null,
846 "metadata": {
847 "colab": {
848 "base_uri": "https://localhost:8080/",
849 "height": 54
850 },
851 "id": "-lcnwG0VXF5h",
852 "outputId": "a4603a14-5903-4e75-a8cf-6a2ccca69946"
853 },
854 "outputs": [
855 {
856 "name": "stdout",
857 "output_type": "stream",
858 "text": [
859 "[VocabularyListCategoricalColumn(key='sex', vocabulary_list=('male', 'female'), dtype=tf.string, default_value=-1, num_oov_buckets=0), VocabularyListCategoricalColumn(key='n_siblings_spouses', vocabulary_list=(1, 0, 3, 4, 2, 5, 8), dtype=tf.int64, default_value=-1, num_oov_buckets=0), VocabularyListCategoricalColumn(key='parch', vocabulary_list=(0, 1, 2, 5, 3, 4), dtype=tf.int64, default_value=-1, num_oov_buckets=0), VocabularyListCategoricalColumn(key='class', vocabulary_list=('Third', 'First', 'Second'), dtype=tf.string, default_value=-1, num_oov_buckets=0), VocabularyListCategoricalColumn(key='deck', vocabulary_list=('unknown', 'C', 'G', 'A', 'B', 'D', 'F', 'E'), dtype=tf.string, default_value=-1, num_oov_buckets=0), VocabularyListCategoricalColumn(key='embark_town', vocabulary_list=('Southampton', 'Cherbourg', 'Queenstown', 'unknown'), dtype=tf.string, default_value=-1, num_oov_buckets=0), VocabularyListCategoricalColumn(key='alone', vocabulary_list=('n', 'y'), dtype=tf.string, default_value=-1, num_oov_buckets=0), NumericColumn(key='age', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None), NumericColumn(key='fare', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None)]\n"
860 ]
861 }
862 ],
863 "source": [
864 "CATEGORICAL_COLUMNS = ['sex', 'n_siblings_spouses', 'parch', 'class', 'deck',\n",
865 " 'embark_town', 'alone']\n",
866 "NUMERIC_COLUMNS = ['age', 'fare']\n",
867 "\n",
868 "feature_columns = []\n",
869 "for feature_name in CATEGORICAL_COLUMNS:\n",
870 " vocabulary = dftrain[feature_name].unique() # gets a list of all unique values from given feature column\n",
871 " feature_columns.append(tf.feature_column.categorical_column_with_vocabulary_list(feature_name, vocabulary))\n",
872 "\n",
873 "for feature_name in NUMERIC_COLUMNS:\n",
874 " feature_columns.append(tf.feature_column.numeric_column(feature_name, dtype=tf.float32))\n",
875 "\n",
876 "print(feature_columns)"
877 ]
878 },
879 {
880 "cell_type": "markdown",
881 "metadata": {
882 "id": "l-nazdZpXgAr"
883 },
884 "source": [
885 "Let's break this code down a little bit...\n",
886 "\n",
887 "Essentially what we are doing here is creating a list of features that are used in our dataset. \n",
888 "\n",
889 "The cryptic lines of code inside the ```append()``` create an object that our model can use to map string values like \"male\" and \"female\" to integers. This allows us to avoid manually having to encode our dataframes.\n",
890 "\n",
891 "*And here is some relevant documentation*\n",
892 "\n",
893 "https://www.tensorflow.org/api_docs/python/tf/feature_column/categorical_column_with_vocabulary_list?version=stable\n",
894 "\n"
895 ]
896 },
897 {
898 "cell_type": "markdown",
899 "metadata": {
900 "id": "UQlXWErlbhsG"
901 },
902 "source": [
903 "###The Training Process\n",
904 "So, we are almost done preparing our dataset and I feel as though it's a good time to explain how our model is trained. Specifically, how input data is fed to our model. \n",
905 "\n",
906 "For this specific model data is going to be streamed into it in small batches of 32. This means we will not feed the entire dataset to our model at once, but simply small batches of entries. We will feed these batches to our model multiple times according to the number of **epochs**. \n",
907 "\n",
908 "An **epoch** is simply one stream of our entire dataset. The number of epochs we define is the amount of times our model will see the entire dataset. We use multiple epochs in hope that after seeing the same data multiple times the model will better determine how to estimate it.\n",
909 "\n",
910 "Ex. if we have 10 ephocs, our model will see the same dataset 10 times. \n",
911 "\n",
912 "Since we need to feed our data in batches and multiple times, we need to create something called an **input function**. The input function simply defines how our dataset will be converted into batches at each epoch.\n",
913 "\n",
914 "\n",
915 "\n"
916 ]
917 },
918 {
919 "cell_type": "markdown",
920 "metadata": {
921 "id": "OO0mBu_WaVXp"
922 },
923 "source": [
924 "###Input Function\n",
925 "The TensorFlow model we are going to use requires that the data we pass it comes in as a ```tf.data.Dataset``` object. This means we must create a *input function* that can convert our current pandas dataframe into that object. \n",
926 "\n",
927 "Below you'll see a seemingly complicated input function, this is straight from the TensorFlow documentation (https://www.tensorflow.org/tutorials/estimator/linear). I've commented as much as I can to make it understandble, but you may want to refer to the documentation for a detailed explination of each method."
928 ]
929 },
930 {
931 "cell_type": "code",
932 "execution_count": null,
933 "metadata": {
934 "id": "I3qcbvOYbIwa"
935 },
936 "outputs": [],
937 "source": [
938 "def make_input_fn(data_df, label_df, num_epochs=10, shuffle=True, batch_size=32):\n",
939 " def input_function(): # inner function, this will be returned\n",
940 " ds = tf.data.Dataset.from_tensor_slices((dict(data_df), label_df)) # create tf.data.Dataset object with data and its label\n",
941 " if shuffle:\n",
942 " ds = ds.shuffle(1000) # randomize order of data\n",
943 " ds = ds.batch(batch_size).repeat(num_epochs) # split dataset into batches of 32 and repeat process for number of epochs\n",
944 " return ds # return a batch of the dataset\n",
945 " return input_function # return a function object for use\n",
946 "\n",
947 "train_input_fn = make_input_fn(dftrain, y_train) # here we will call the input_function that was returned to us to get a dataset object we can feed to the model\n",
948 "eval_input_fn = make_input_fn(dfeval, y_eval, num_epochs=1, shuffle=False)\n"
949 ]
950 },
951 {
952 "cell_type": "markdown",
953 "metadata": {
954 "id": "FXqlPst9fpx4"
955 },
956 "source": [
957 "###Creating the Model\n",
958 "In this tutorial we are going to use a linear estimator to utilize the linear regression algorithm. \n",
959 "\n",
960 "Creating one is pretty easy! Have a look below.\n",
961 "\n"
962 ]
963 },
964 {
965 "cell_type": "code",
966 "execution_count": null,
967 "metadata": {
968 "colab": {
969 "base_uri": "https://localhost:8080/",
970 "height": 192
971 },
972 "id": "q1Wo8brFf663",
973 "outputId": "73b78e55-1fc4-44b0-9fc6-33506a199db5"
974 },
975 "outputs": [
976 {
977 "name": "stdout",
978 "output_type": "stream",
979 "text": [
980 "INFO:tensorflow:Using default config.\n",
981 "WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmpupqmt1yp\n",
982 "INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpupqmt1yp', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true\n",
983 "graph_options {\n",
984 " rewrite_options {\n",
985 " meta_optimizer_iterations: ONE\n",
986 " }\n",
987 "}\n",
988 ", '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}\n"
989 ]
990 }
991 ],
992 "source": [
993 "linear_est = tf.estimator.LinearClassifier(feature_columns=feature_columns)\n",
994 "# We create a linear estimtor by passing the feature columns we created earlier"
995 ]
996 },
997 {
998 "cell_type": "markdown",
999 "metadata": {
1000 "id": "K5GPkW_CgDFy"
1001 },
1002 "source": [
1003 "###Training the Model\n",
1004 "Training the model is as easy as passing the input functions that we created earlier."
1005 ]
1006 },
1007 {
1008 "cell_type": "code",
1009 "execution_count": null,
1010 "metadata": {
1011 "colab": {
1012 "base_uri": "https://localhost:8080/",
1013 "height": 34
1014 },
1015 "id": "J11OJrlZgPhb",
1016 "outputId": "cd3c7099-fdde-45aa-b57b-f1c8d1d02024"
1017 },
1018 "outputs": [
1019 {
1020 "name": "stdout",
1021 "output_type": "stream",
1022 "text": [
1023 "0.7689394\n"
1024 ]
1025 }
1026 ],
1027 "source": [
1028 "linear_est.train(train_input_fn) # train\n",
1029 "result = linear_est.evaluate(eval_input_fn) # get model metrics/stats by testing on tetsing data\n",
1030 "\n",
1031 "clear_output() # clears consoke output\n",
1032 "print(result['accuracy']) # the result variable is simply a dict of stats about our model"
1033 ]
1034 },
1035 {
1036 "cell_type": "markdown",
1037 "metadata": {
1038 "id": "LisxO81tgi1n"
1039 },
1040 "source": [
1041 "And we now we have a model with a 74% accuracy (this will change each time)! Not crazy impressive but decent for our first try.\n",
1042 "\n",
1043 "Now let's see how we can actually use this model to make predicitons.\n",
1044 "\n",
1045 "We can use the ```.predict()``` method to get survival probabilities from the model. This method will return a list of dicts that store a predicition for each of the entries in our testing data set. Below we've used some pandas magic to plot a nice graph of the predictions.\n",
1046 "\n",
1047 "As you can see the survival rate is not very high :/"
1048 ]
1049 },
1050 {
1051 "cell_type": "code",
1052 "execution_count": null,
1053 "metadata": {
1054 "colab": {
1055 "base_uri": "https://localhost:8080/",
1056 "height": 525
1057 },
1058 "id": "JQz0Lj60hjLI",
1059 "outputId": "eec262fd-e206-46b6-d8d7-7c9067546f16"
1060 },
1061 "outputs": [
1062 {
1063 "name": "stdout",
1064 "output_type": "stream",
1065 "text": [
1066 "INFO:tensorflow:Calling model_fn.\n",
1067 "WARNING:tensorflow:Layer linear/linear_model is casting an input tensor from dtype float64 to the layer's dtype of float32, which is new behavior in TensorFlow 2. The layer has dtype float32 because it's dtype defaults to floatx.\n",
1068 "\n",
1069 "If you intended to run this layer in float32, you can safely ignore this warning. If in doubt, this warning is likely only an issue if you are porting a TensorFlow 1.X model to TensorFlow 2.\n",
1070 "\n",
1071 "To change all layers to have dtype float64 by default, call `tf.keras.backend.set_floatx('float64')`. To change just this layer, pass dtype='float64' to the layer constructor. If you are the author of this layer, you can disable autocasting by passing autocast=False to the base Layer constructor.\n",
1072 "\n",
1073 "INFO:tensorflow:Done calling model_fn.\n",
1074 "INFO:tensorflow:Graph was finalized.\n",
1075 "INFO:tensorflow:Restoring parameters from /tmp/tmpupqmt1yp/model.ckpt-200\n",
1076 "INFO:tensorflow:Running local_init_op.\n",
1077 "INFO:tensorflow:Done running local_init_op.\n"
1078 ]
1079 },
1080 {
1081 "data": {
1082 "text/plain": [
1083 "<matplotlib.axes._subplots.AxesSubplot at 0x7f6807c6ac18>"
1084 ]
1085 },
1086 "execution_count": 28,
1087 "metadata": {
1088 "tags": []
1089 },
1090 "output_type": "execute_result"
1091 },
1092 {
1093 "data": {
1094 "image/png": "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\n",
1095 "text/plain": [
1096 "<Figure size 432x288 with 1 Axes>"
1097 ]
1098 },
1099 "metadata": {
1100 "needs_background": "light",
1101 "tags": []
1102 },
1103 "output_type": "display_data"
1104 }
1105 ],
1106 "source": [
1107 "pred_dicts = list(linear_est.predict(eval_input_fn))\n",
1108 "probs = pd.Series([pred['probabilities'][1] for pred in pred_dicts])\n",
1109 "\n",
1110 "probs.plot(kind='hist', bins=20, title='predicted probabilities')"
1111 ]
1112 },
1113 {
1114 "cell_type": "markdown",
1115 "metadata": {
1116 "id": "CN_r0Vn8VOf5"
1117 },
1118 "source": [
1119 "That's it for linear regression! Now onto classification."
1120 ]
1121 },
1122 {
1123 "cell_type": "markdown",
1124 "metadata": {
1125 "id": "hG9gxhAqVTBT"
1126 },
1127 "source": [
1128 "##Classification\n",
1129 "Now that we've covered linear regression it is time to talk about classification. Where regression was used to predict a numeric value, classification is used to seperate data points into classes of different labels. In this example we will use a TensorFlow estimator to classify flowers.\n",
1130 "\n",
1131 "Since we've touched on how estimators work earlier, I'll go a bit quicker through this example. \n",
1132 "\n",
1133 "This section is based on the following guide from the TensorFlow website.\n",
1134 "https://www.tensorflow.org/tutorials/estimator/premade\n",
1135 "\n",
1136 "\n"
1137 ]
1138 },
1139 {
1140 "cell_type": "markdown",
1141 "metadata": {
1142 "id": "iWk2Kb7Sdk-T"
1143 },
1144 "source": [
1145 "###Imports and Setup"
1146 ]
1147 },
1148 {
1149 "cell_type": "code",
1150 "execution_count": null,
1151 "metadata": {
1152 "colab": {
1153 "base_uri": "https://localhost:8080/",
1154 "height": 103
1155 },
1156 "id": "eH4_xJaD605_",
1157 "outputId": "cbe50069-f9c1-489e-ebdb-e08af4d7cea5"
1158 },
1159 "outputs": [
1160 {
1161 "name": "stdout",
1162 "output_type": "stream",
1163 "text": [
1164 "`%tensorflow_version` only switches the major version: 1.x or 2.x.\n",
1165 "You set: `2.x # this line is not required unless you are in a notebook`. This will be interpreted as: `2.x`.\n",
1166 "\n",
1167 "\n",
1168 "TensorFlow is already loaded. Please restart the runtime to change versions.\n"
1169 ]
1170 }
1171 ],
1172 "source": [
1173 "%tensorflow_version 2.x # this line is not required unless you are in a notebook"
1174 ]
1175 },
1176 {
1177 "cell_type": "code",
1178 "execution_count": null,
1179 "metadata": {
1180 "id": "TMiLc6LPdoPm"
1181 },
1182 "outputs": [],
1183 "source": [
1184 "from __future__ import absolute_import, division, print_function, unicode_literals\n",
1185 "\n",
1186 "\n",
1187 "import tensorflow as tf\n",
1188 "\n",
1189 "import pandas as pd"
1190 ]
1191 },
1192 {
1193 "cell_type": "markdown",
1194 "metadata": {
1195 "id": "9zLNzmkGds1U"
1196 },
1197 "source": [
1198 "###Dataset\n",
1199 "This specific dataset seperates flowers into 3 different classes of species.\n",
1200 "- Setosa\n",
1201 "- Versicolor\n",
1202 "- Virginica\n",
1203 "\n",
1204 "The information about each flower is the following.\n",
1205 "- sepal length\n",
1206 "- sepal width\n",
1207 "- petal length\n",
1208 "- petal width"
1209 ]
1210 },
1211 {
1212 "cell_type": "code",
1213 "execution_count": null,
1214 "metadata": {
1215 "id": "puOQDTNKeCRC"
1216 },
1217 "outputs": [],
1218 "source": [
1219 "CSV_COLUMN_NAMES = ['SepalLength', 'SepalWidth', 'PetalLength', 'PetalWidth', 'Species']\n",
1220 "SPECIES = ['Setosa', 'Versicolor', 'Virginica']\n",
1221 "# Lets define some constants to help us later on"
1222 ]
1223 },
1224 {
1225 "cell_type": "code",
1226 "execution_count": null,
1227 "metadata": {
1228 "colab": {
1229 "base_uri": "https://localhost:8080/",
1230 "height": 106
1231 },
1232 "id": "oMW41Wd9eLIo",
1233 "outputId": "4950908e-de50-4839-a569-a1f5acf015f8"
1234 },
1235 "outputs": [
1236 {
1237 "name": "stdout",
1238 "output_type": "stream",
1239 "text": [
1240 "Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/iris_training.csv\n",
1241 "8192/2194 [================================================================================================================] - 0s 0us/step\n",
1242 "Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/iris_test.csv\n",
1243 "8192/573 [============================================================================================================================================================================================================================================================================================================================================================================================================================================] - 0s 0us/step\n"
1244 ]
1245 }
1246 ],
1247 "source": [
1248 "train_path = tf.keras.utils.get_file(\n",
1249 " \"iris_training.csv\", \"https://storage.googleapis.com/download.tensorflow.org/data/iris_training.csv\")\n",
1250 "test_path = tf.keras.utils.get_file(\n",
1251 " \"iris_test.csv\", \"https://storage.googleapis.com/download.tensorflow.org/data/iris_test.csv\")\n",
1252 "\n",
1253 "train = pd.read_csv(train_path, names=CSV_COLUMN_NAMES, header=0)\n",
1254 "test = pd.read_csv(test_path, names=CSV_COLUMN_NAMES, header=0)\n",
1255 "# Here we use keras (a module inside of TensorFlow) to grab our datasets and read them into a pandas dataframe"
1256 ]
1257 },
1258 {
1259 "cell_type": "markdown",
1260 "metadata": {
1261 "id": "4aHRWY47ecdr"
1262 },
1263 "source": [
1264 "Let's have a look at our data."
1265 ]
1266 },
1267 {
1268 "cell_type": "code",
1269 "execution_count": null,
1270 "metadata": {
1271 "colab": {
1272 "base_uri": "https://localhost:8080/",
1273 "height": 201
1274 },
1275 "id": "BQ9uo6KkegBH",
1276 "outputId": "ed4b9d06-06da-4014-f04d-95bc35dc64ba"
1277 },
1278 "outputs": [
1279 {
1280 "data": {
1281 "text/html": [
1282 "<div>\n",
1283 "<style scoped>\n",
1284 " .dataframe tbody tr th:only-of-type {\n",
1285 " vertical-align: middle;\n",
1286 " }\n",
1287 "\n",
1288 " .dataframe tbody tr th {\n",
1289 " vertical-align: top;\n",
1290 " }\n",
1291 "\n",
1292 " .dataframe thead th {\n",
1293 " text-align: right;\n",
1294 " }\n",
1295 "</style>\n",
1296 "<table border=\"1\" class=\"dataframe\">\n",
1297 " <thead>\n",
1298 " <tr style=\"text-align: right;\">\n",
1299 " <th></th>\n",
1300 " <th>SepalLength</th>\n",
1301 " <th>SepalWidth</th>\n",
1302 " <th>PetalLength</th>\n",
1303 " <th>PetalWidth</th>\n",
1304 " <th>Species</th>\n",
1305 " </tr>\n",
1306 " </thead>\n",
1307 " <tbody>\n",
1308 " <tr>\n",
1309 " <th>0</th>\n",
1310 " <td>6.4</td>\n",
1311 " <td>2.8</td>\n",
1312 " <td>5.6</td>\n",
1313 " <td>2.2</td>\n",
1314 " <td>2</td>\n",
1315 " </tr>\n",
1316 " <tr>\n",
1317 " <th>1</th>\n",
1318 " <td>5.0</td>\n",
1319 " <td>2.3</td>\n",
1320 " <td>3.3</td>\n",
1321 " <td>1.0</td>\n",
1322 " <td>1</td>\n",
1323 " </tr>\n",
1324 " <tr>\n",
1325 " <th>2</th>\n",
1326 " <td>4.9</td>\n",
1327 " <td>2.5</td>\n",
1328 " <td>4.5</td>\n",
1329 " <td>1.7</td>\n",
1330 " <td>2</td>\n",
1331 " </tr>\n",
1332 " <tr>\n",
1333 " <th>3</th>\n",
1334 " <td>4.9</td>\n",
1335 " <td>3.1</td>\n",
1336 " <td>1.5</td>\n",
1337 " <td>0.1</td>\n",
1338 " <td>0</td>\n",
1339 " </tr>\n",
1340 " <tr>\n",
1341 " <th>4</th>\n",
1342 " <td>5.7</td>\n",
1343 " <td>3.8</td>\n",
1344 " <td>1.7</td>\n",
1345 " <td>0.3</td>\n",
1346 " <td>0</td>\n",
1347 " </tr>\n",
1348 " </tbody>\n",
1349 "</table>\n",
1350 "</div>"
1351 ],
1352 "text/plain": [
1353 " SepalLength SepalWidth PetalLength PetalWidth Species\n",
1354 "0 6.4 2.8 5.6 2.2 2\n",
1355 "1 5.0 2.3 3.3 1.0 1\n",
1356 "2 4.9 2.5 4.5 1.7 2\n",
1357 "3 4.9 3.1 1.5 0.1 0\n",
1358 "4 5.7 3.8 1.7 0.3 0"
1359 ]
1360 },
1361 "execution_count": 33,
1362 "metadata": {
1363 "tags": []
1364 },
1365 "output_type": "execute_result"
1366 }
1367 ],
1368 "source": [
1369 "train.head()"
1370 ]
1371 },
1372 {
1373 "cell_type": "markdown",
1374 "metadata": {
1375 "id": "7PzWyoE9eu8H"
1376 },
1377 "source": [
1378 "Now we can pop the species column off and use that as our label."
1379 ]
1380 },
1381 {
1382 "cell_type": "code",
1383 "execution_count": null,
1384 "metadata": {
1385 "colab": {
1386 "base_uri": "https://localhost:8080/",
1387 "height": 201
1388 },
1389 "id": "fP_nlslke4U8",
1390 "outputId": "560a0559-ebf8-43a8-bca7-4fa25d9c06ce"
1391 },
1392 "outputs": [
1393 {
1394 "data": {
1395 "text/html": [
1396 "<div>\n",
1397 "<style scoped>\n",
1398 " .dataframe tbody tr th:only-of-type {\n",
1399 " vertical-align: middle;\n",
1400 " }\n",
1401 "\n",
1402 " .dataframe tbody tr th {\n",
1403 " vertical-align: top;\n",
1404 " }\n",
1405 "\n",
1406 " .dataframe thead th {\n",
1407 " text-align: right;\n",
1408 " }\n",
1409 "</style>\n",
1410 "<table border=\"1\" class=\"dataframe\">\n",
1411 " <thead>\n",
1412 " <tr style=\"text-align: right;\">\n",
1413 " <th></th>\n",
1414 " <th>SepalLength</th>\n",
1415 " <th>SepalWidth</th>\n",
1416 " <th>PetalLength</th>\n",
1417 " <th>PetalWidth</th>\n",
1418 " </tr>\n",
1419 " </thead>\n",
1420 " <tbody>\n",
1421 " <tr>\n",
1422 " <th>0</th>\n",
1423 " <td>6.4</td>\n",
1424 " <td>2.8</td>\n",
1425 " <td>5.6</td>\n",
1426 " <td>2.2</td>\n",
1427 " </tr>\n",
1428 " <tr>\n",
1429 " <th>1</th>\n",
1430 " <td>5.0</td>\n",
1431 " <td>2.3</td>\n",
1432 " <td>3.3</td>\n",
1433 " <td>1.0</td>\n",
1434 " </tr>\n",
1435 " <tr>\n",
1436 " <th>2</th>\n",
1437 " <td>4.9</td>\n",
1438 " <td>2.5</td>\n",
1439 " <td>4.5</td>\n",
1440 " <td>1.7</td>\n",
1441 " </tr>\n",
1442 " <tr>\n",
1443 " <th>3</th>\n",
1444 " <td>4.9</td>\n",
1445 " <td>3.1</td>\n",
1446 " <td>1.5</td>\n",
1447 " <td>0.1</td>\n",
1448 " </tr>\n",
1449 " <tr>\n",
1450 " <th>4</th>\n",
1451 " <td>5.7</td>\n",
1452 " <td>3.8</td>\n",
1453 " <td>1.7</td>\n",
1454 " <td>0.3</td>\n",
1455 " </tr>\n",
1456 " </tbody>\n",
1457 "</table>\n",
1458 "</div>"
1459 ],
1460 "text/plain": [
1461 " SepalLength SepalWidth PetalLength PetalWidth\n",
1462 "0 6.4 2.8 5.6 2.2\n",
1463 "1 5.0 2.3 3.3 1.0\n",
1464 "2 4.9 2.5 4.5 1.7\n",
1465 "3 4.9 3.1 1.5 0.1\n",
1466 "4 5.7 3.8 1.7 0.3"
1467 ]
1468 },
1469 "execution_count": 34,
1470 "metadata": {
1471 "tags": []
1472 },
1473 "output_type": "execute_result"
1474 }
1475 ],
1476 "source": [
1477 "train_y = train.pop('Species')\n",
1478 "test_y = test.pop('Species')\n",
1479 "train.head() # the species column is now gone"
1480 ]
1481 },
1482 {
1483 "cell_type": "code",
1484 "execution_count": null,
1485 "metadata": {
1486 "colab": {
1487 "base_uri": "https://localhost:8080/",
1488 "height": 34
1489 },
1490 "id": "3oVw2zRkfTXq",
1491 "outputId": "a25c814d-63e4-40da-9ac9-6efc326164b2"
1492 },
1493 "outputs": [
1494 {
1495 "data": {
1496 "text/plain": [
1497 "(120, 4)"
1498 ]
1499 },
1500 "execution_count": 35,
1501 "metadata": {
1502 "tags": []
1503 },
1504 "output_type": "execute_result"
1505 }
1506 ],
1507 "source": [
1508 "train.shape # we have 120 entires with 4 features"
1509 ]
1510 },
1511 {
1512 "cell_type": "markdown",
1513 "metadata": {
1514 "id": "V6ZWVZs8fg-H"
1515 },
1516 "source": [
1517 "###Input Function\n",
1518 "Remember that nasty input function we created earlier. Well we need to make another one here! Fortunatly for us this one is a little easier to digest."
1519 ]
1520 },
1521 {
1522 "cell_type": "code",
1523 "execution_count": null,
1524 "metadata": {
1525 "id": "K-NQRLv_fyhg"
1526 },
1527 "outputs": [],
1528 "source": [
1529 "def input_fn(features, labels, training=True, batch_size=256):\n",
1530 " # Convert the inputs to a Dataset.\n",
1531 " dataset = tf.data.Dataset.from_tensor_slices((dict(features), labels))\n",
1532 "\n",
1533 " # Shuffle and repeat if you are in training mode.\n",
1534 " if training:\n",
1535 " dataset = dataset.shuffle(1000).repeat()\n",
1536 " \n",
1537 " return dataset.batch(batch_size)\n"
1538 ]
1539 },
1540 {
1541 "cell_type": "markdown",
1542 "metadata": {
1543 "id": "FL--3OAnf4mO"
1544 },
1545 "source": [
1546 "###Feature Columns\n",
1547 "And you didn't think we forgot about the feature columns, did you?\n",
1548 "\n"
1549 ]
1550 },
1551 {
1552 "cell_type": "code",
1553 "execution_count": null,
1554 "metadata": {
1555 "colab": {
1556 "base_uri": "https://localhost:8080/",
1557 "height": 54
1558 },
1559 "id": "nErIJJbggQ5w",
1560 "outputId": "837852b1-97a0-4965-88fc-50883dfb558c"
1561 },
1562 "outputs": [
1563 {
1564 "name": "stdout",
1565 "output_type": "stream",
1566 "text": [
1567 "[NumericColumn(key='SepalLength', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None), NumericColumn(key='SepalWidth', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None), NumericColumn(key='PetalLength', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None), NumericColumn(key='PetalWidth', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None)]\n"
1568 ]
1569 }
1570 ],
1571 "source": [
1572 "# Feature columns describe how to use the input.\n",
1573 "my_feature_columns = []\n",
1574 "for key in train.keys():\n",
1575 " my_feature_columns.append(tf.feature_column.numeric_column(key=key))\n",
1576 "print(my_feature_columns)"
1577 ]
1578 },
1579 {
1580 "cell_type": "markdown",
1581 "metadata": {
1582 "id": "5kl1Wr_Xgpmv"
1583 },
1584 "source": [
1585 "###Building the Model\n",
1586 "And now we are ready to choose a model. For classification tasks there are variety of different estimators/models that we can pick from. Some options are listed below.\n",
1587 "- ```DNNClassifier``` (Deep Neural Network)\n",
1588 "- ```LinearClassifier```\n",
1589 "\n",
1590 "We can choose either model but the DNN seems to be the best choice. This is because we may not be able to find a linear coorespondence in our data. \n",
1591 "\n",
1592 "So let's build a model!"
1593 ]
1594 },
1595 {
1596 "cell_type": "code",
1597 "execution_count": null,
1598 "metadata": {
1599 "colab": {
1600 "base_uri": "https://localhost:8080/",
1601 "height": 192
1602 },
1603 "id": "n7YVQowgiDak",
1604 "outputId": "bd9457f3-7d30-456c-aa8b-3d160c0f751f"
1605 },
1606 "outputs": [
1607 {
1608 "name": "stdout",
1609 "output_type": "stream",
1610 "text": [
1611 "INFO:tensorflow:Using default config.\n",
1612 "WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmpqaqtrlgy\n",
1613 "INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpqaqtrlgy', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true\n",
1614 "graph_options {\n",
1615 " rewrite_options {\n",
1616 " meta_optimizer_iterations: ONE\n",
1617 " }\n",
1618 "}\n",
1619 ", '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}\n"
1620 ]
1621 }
1622 ],
1623 "source": [
1624 "# Build a DNN with 2 hidden layers with 30 and 10 hidden nodes each.\n",
1625 "classifier = tf.estimator.DNNClassifier(\n",
1626 " feature_columns=my_feature_columns,\n",
1627 " # Two hidden layers of 30 and 10 nodes respectively.\n",
1628 " hidden_units=[30, 10],\n",
1629 " # The model must choose between 3 classes.\n",
1630 " n_classes=3)"
1631 ]
1632 },
1633 {
1634 "cell_type": "markdown",
1635 "metadata": {
1636 "id": "jQ_SJAMuiF6p"
1637 },
1638 "source": [
1639 "What we've just done is created a deep neural network that has two hidden layers. These layers have 30 and 10 neurons respectively. This is the number of neurons the TensorFlow official tutorial uses so we'll stick with it. However, it is worth mentioning that the number of hidden neurons is an arbitrary number and many experiments and tests are usually done to determine the best choice for these values. Try playing around with the number of hidden neurons and see if your results change."
1640 ]
1641 },
1642 {
1643 "cell_type": "markdown",
1644 "metadata": {
1645 "id": "NBHnWYKTjV5D"
1646 },
1647 "source": [
1648 "###Training\n",
1649 "Now it's time to train the model!"
1650 ]
1651 },
1652 {
1653 "cell_type": "code",
1654 "execution_count": null,
1655 "metadata": {
1656 "colab": {
1657 "base_uri": "https://localhost:8080/",
1658 "height": 1000
1659 },
1660 "id": "INug63pCjaOw",
1661 "outputId": "3eb6211c-9fd1-4748-8e2e-31e64b4ec698"
1662 },
1663 "outputs": [
1664 {
1665 "name": "stdout",
1666 "output_type": "stream",
1667 "text": [
1668 "INFO:tensorflow:Calling model_fn.\n",
1669 "WARNING:tensorflow:Layer dnn is casting an input tensor from dtype float64 to the layer's dtype of float32, which is new behavior in TensorFlow 2. The layer has dtype float32 because it's dtype defaults to floatx.\n",
1670 "\n",
1671 "If you intended to run this layer in float32, you can safely ignore this warning. If in doubt, this warning is likely only an issue if you are porting a TensorFlow 1.X model to TensorFlow 2.\n",
1672 "\n",
1673 "To change all layers to have dtype float64 by default, call `tf.keras.backend.set_floatx('float64')`. To change just this layer, pass dtype='float64' to the layer constructor. If you are the author of this layer, you can disable autocasting by passing autocast=False to the base Layer constructor.\n",
1674 "\n",
1675 "INFO:tensorflow:Done calling model_fn.\n",
1676 "INFO:tensorflow:Create CheckpointSaverHook.\n",
1677 "INFO:tensorflow:Graph was finalized.\n",
1678 "INFO:tensorflow:Running local_init_op.\n",
1679 "INFO:tensorflow:Done running local_init_op.\n",
1680 "INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...\n",
1681 "INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpqaqtrlgy/model.ckpt.\n",
1682 "INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...\n",
1683 "INFO:tensorflow:loss = 1.1511875, step = 0\n",
1684 "INFO:tensorflow:global_step/sec: 497.034\n",
1685 "INFO:tensorflow:loss = 0.9358924, step = 100 (0.208 sec)\n",
1686 "INFO:tensorflow:global_step/sec: 636.632\n",
1687 "INFO:tensorflow:loss = 0.90521353, step = 200 (0.154 sec)\n",
1688 "INFO:tensorflow:global_step/sec: 654.875\n",
1689 "INFO:tensorflow:loss = 0.8495918, step = 300 (0.153 sec)\n",
1690 "INFO:tensorflow:global_step/sec: 651.748\n",
1691 "INFO:tensorflow:loss = 0.82983136, step = 400 (0.153 sec)\n",
1692 "INFO:tensorflow:global_step/sec: 655.704\n",
1693 "INFO:tensorflow:loss = 0.7790096, step = 500 (0.154 sec)\n",
1694 "INFO:tensorflow:global_step/sec: 667.452\n",
1695 "INFO:tensorflow:loss = 0.7574419, step = 600 (0.149 sec)\n",
1696 "INFO:tensorflow:global_step/sec: 675.438\n",
1697 "INFO:tensorflow:loss = 0.7266582, step = 700 (0.148 sec)\n",
1698 "INFO:tensorflow:global_step/sec: 666.098\n",
1699 "INFO:tensorflow:loss = 0.7117815, step = 800 (0.150 sec)\n",
1700 "INFO:tensorflow:global_step/sec: 659.401\n",
1701 "INFO:tensorflow:loss = 0.6849373, step = 900 (0.150 sec)\n",
1702 "INFO:tensorflow:global_step/sec: 664.227\n",
1703 "INFO:tensorflow:loss = 0.6696919, step = 1000 (0.150 sec)\n",
1704 "INFO:tensorflow:global_step/sec: 674.756\n",
1705 "INFO:tensorflow:loss = 0.6453049, step = 1100 (0.151 sec)\n",
1706 "INFO:tensorflow:global_step/sec: 664.265\n",
1707 "INFO:tensorflow:loss = 0.63444245, step = 1200 (0.150 sec)\n",
1708 "INFO:tensorflow:global_step/sec: 646.941\n",
1709 "INFO:tensorflow:loss = 0.61837286, step = 1300 (0.155 sec)\n",
1710 "INFO:tensorflow:global_step/sec: 675.566\n",
1711 "INFO:tensorflow:loss = 0.60927534, step = 1400 (0.149 sec)\n",
1712 "INFO:tensorflow:global_step/sec: 693.653\n",
1713 "INFO:tensorflow:loss = 0.59321785, step = 1500 (0.144 sec)\n",
1714 "INFO:tensorflow:global_step/sec: 643.728\n",
1715 "INFO:tensorflow:loss = 0.5786046, step = 1600 (0.155 sec)\n",
1716 "INFO:tensorflow:global_step/sec: 640.974\n",
1717 "INFO:tensorflow:loss = 0.5679003, step = 1700 (0.156 sec)\n",
1718 "INFO:tensorflow:global_step/sec: 668.473\n",
1719 "INFO:tensorflow:loss = 0.55420506, step = 1800 (0.147 sec)\n",
1720 "INFO:tensorflow:global_step/sec: 683.02\n",
1721 "INFO:tensorflow:loss = 0.51620936, step = 1900 (0.149 sec)\n",
1722 "INFO:tensorflow:global_step/sec: 668.192\n",
1723 "INFO:tensorflow:loss = 0.5385388, step = 2000 (0.149 sec)\n",
1724 "INFO:tensorflow:global_step/sec: 689.724\n",
1725 "INFO:tensorflow:loss = 0.523809, step = 2100 (0.143 sec)\n",
1726 "INFO:tensorflow:global_step/sec: 674.861\n",
1727 "INFO:tensorflow:loss = 0.50772285, step = 2200 (0.150 sec)\n",
1728 "INFO:tensorflow:global_step/sec: 645.258\n",
1729 "INFO:tensorflow:loss = 0.49664536, step = 2300 (0.155 sec)\n",
1730 "INFO:tensorflow:global_step/sec: 664.988\n",
1731 "INFO:tensorflow:loss = 0.49152842, step = 2400 (0.148 sec)\n",
1732 "INFO:tensorflow:global_step/sec: 676.346\n",
1733 "INFO:tensorflow:loss = 0.4791621, step = 2500 (0.150 sec)\n",
1734 "INFO:tensorflow:global_step/sec: 682.166\n",
1735 "INFO:tensorflow:loss = 0.46931824, step = 2600 (0.146 sec)\n",
1736 "INFO:tensorflow:global_step/sec: 632.973\n",
1737 "INFO:tensorflow:loss = 0.46762398, step = 2700 (0.159 sec)\n",
1738 "INFO:tensorflow:global_step/sec: 666.066\n",
1739 "INFO:tensorflow:loss = 0.44671822, step = 2800 (0.148 sec)\n",
1740 "INFO:tensorflow:global_step/sec: 663.873\n",
1741 "INFO:tensorflow:loss = 0.44892073, step = 2900 (0.151 sec)\n",
1742 "INFO:tensorflow:global_step/sec: 639.968\n",
1743 "INFO:tensorflow:loss = 0.44627833, step = 3000 (0.159 sec)\n",
1744 "INFO:tensorflow:global_step/sec: 676.9\n",
1745 "INFO:tensorflow:loss = 0.4288814, step = 3100 (0.147 sec)\n",
1746 "INFO:tensorflow:global_step/sec: 658.251\n",
1747 "INFO:tensorflow:loss = 0.43346274, step = 3200 (0.150 sec)\n",
1748 "INFO:tensorflow:global_step/sec: 664.476\n",
1749 "INFO:tensorflow:loss = 0.42365474, step = 3300 (0.153 sec)\n",
1750 "INFO:tensorflow:global_step/sec: 680.291\n",
1751 "INFO:tensorflow:loss = 0.41678685, step = 3400 (0.145 sec)\n",
1752 "INFO:tensorflow:global_step/sec: 682.509\n",
1753 "INFO:tensorflow:loss = 0.41475928, step = 3500 (0.150 sec)\n",
1754 "INFO:tensorflow:global_step/sec: 564.669\n",
1755 "INFO:tensorflow:loss = 0.40962964, step = 3600 (0.178 sec)\n",
1756 "INFO:tensorflow:global_step/sec: 643.631\n",
1757 "INFO:tensorflow:loss = 0.40175164, step = 3700 (0.154 sec)\n",
1758 "INFO:tensorflow:global_step/sec: 675.225\n",
1759 "INFO:tensorflow:loss = 0.39052343, step = 3800 (0.148 sec)\n",
1760 "INFO:tensorflow:global_step/sec: 666.891\n",
1761 "INFO:tensorflow:loss = 0.39769873, step = 3900 (0.150 sec)\n",
1762 "INFO:tensorflow:global_step/sec: 666.438\n",
1763 "INFO:tensorflow:loss = 0.386145, step = 4000 (0.148 sec)\n",
1764 "INFO:tensorflow:global_step/sec: 685.811\n",
1765 "INFO:tensorflow:loss = 0.39405277, step = 4100 (0.146 sec)\n",
1766 "INFO:tensorflow:global_step/sec: 682.425\n",
1767 "INFO:tensorflow:loss = 0.37922394, step = 4200 (0.148 sec)\n",
1768 "INFO:tensorflow:global_step/sec: 661.11\n",
1769 "INFO:tensorflow:loss = 0.37118322, step = 4300 (0.150 sec)\n",
1770 "INFO:tensorflow:global_step/sec: 670.221\n",
1771 "INFO:tensorflow:loss = 0.36706787, step = 4400 (0.149 sec)\n",
1772 "INFO:tensorflow:global_step/sec: 681.885\n",
1773 "INFO:tensorflow:loss = 0.3653447, step = 4500 (0.146 sec)\n",
1774 "INFO:tensorflow:global_step/sec: 682.826\n",
1775 "INFO:tensorflow:loss = 0.3557425, step = 4600 (0.147 sec)\n",
1776 "INFO:tensorflow:global_step/sec: 665.897\n",
1777 "INFO:tensorflow:loss = 0.36362734, step = 4700 (0.152 sec)\n",
1778 "INFO:tensorflow:global_step/sec: 671.864\n",
1779 "INFO:tensorflow:loss = 0.3526679, step = 4800 (0.149 sec)\n",
1780 "INFO:tensorflow:global_step/sec: 662.965\n",
1781 "INFO:tensorflow:loss = 0.35308143, step = 4900 (0.151 sec)\n",
1782 "INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 5000...\n",
1783 "INFO:tensorflow:Saving checkpoints for 5000 into /tmp/tmpqaqtrlgy/model.ckpt.\n",
1784 "INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 5000...\n",
1785 "INFO:tensorflow:Loss for final step: 0.34763944.\n"
1786 ]
1787 },
1788 {
1789 "data": {
1790 "text/plain": [
1791 "<tensorflow_estimator.python.estimator.canned.dnn.DNNClassifierV2 at 0x7f6807b4ca20>"
1792 ]
1793 },
1794 "execution_count": 39,
1795 "metadata": {
1796 "tags": []
1797 },
1798 "output_type": "execute_result"
1799 }
1800 ],
1801 "source": [
1802 "classifier.train(\n",
1803 " input_fn=lambda: input_fn(train, train_y, training=True),\n",
1804 " steps=5000)\n",
1805 "# We include a lambda to avoid creating an inner function previously"
1806 ]
1807 },
1808 {
1809 "cell_type": "markdown",
1810 "metadata": {
1811 "id": "57oNBLV1j0wc"
1812 },
1813 "source": [
1814 "The only thing to explain here is the **steps** argument. This simply tells the classifier to run for 5000 steps. Try modifiying this and seeing if your results change. Keep in mind that more is not always better."
1815 ]
1816 },
1817 {
1818 "cell_type": "markdown",
1819 "metadata": {
1820 "id": "5suI1lmskE7p"
1821 },
1822 "source": [
1823 "###Evaluation\n",
1824 "Now let's see how this trained model does!"
1825 ]
1826 },
1827 {
1828 "cell_type": "code",
1829 "execution_count": null,
1830 "metadata": {
1831 "colab": {
1832 "base_uri": "https://localhost:8080/",
1833 "height": 381
1834 },
1835 "id": "23rIrgbxkJUO",
1836 "outputId": "24767659-81cb-436f-a3c5-3fb19fcf53b2"
1837 },
1838 "outputs": [
1839 {
1840 "name": "stdout",
1841 "output_type": "stream",
1842 "text": [
1843 "INFO:tensorflow:Calling model_fn.\n",
1844 "WARNING:tensorflow:Layer dnn is casting an input tensor from dtype float64 to the layer's dtype of float32, which is new behavior in TensorFlow 2. The layer has dtype float32 because it's dtype defaults to floatx.\n",
1845 "\n",
1846 "If you intended to run this layer in float32, you can safely ignore this warning. If in doubt, this warning is likely only an issue if you are porting a TensorFlow 1.X model to TensorFlow 2.\n",
1847 "\n",
1848 "To change all layers to have dtype float64 by default, call `tf.keras.backend.set_floatx('float64')`. To change just this layer, pass dtype='float64' to the layer constructor. If you are the author of this layer, you can disable autocasting by passing autocast=False to the base Layer constructor.\n",
1849 "\n",
1850 "INFO:tensorflow:Done calling model_fn.\n",
1851 "INFO:tensorflow:Starting evaluation at 2020-06-19T18:22:07Z\n",
1852 "INFO:tensorflow:Graph was finalized.\n",
1853 "INFO:tensorflow:Restoring parameters from /tmp/tmpqaqtrlgy/model.ckpt-5000\n",
1854 "INFO:tensorflow:Running local_init_op.\n",
1855 "INFO:tensorflow:Done running local_init_op.\n",
1856 "INFO:tensorflow:Inference Time : 0.20221s\n",
1857 "INFO:tensorflow:Finished evaluation at 2020-06-19-18:22:08\n",
1858 "INFO:tensorflow:Saving dict for global step 5000: accuracy = 0.93333334, average_loss = 0.41360682, global_step = 5000, loss = 0.41360682\n",
1859 "INFO:tensorflow:Saving 'checkpoint_path' summary for global step 5000: /tmp/tmpqaqtrlgy/model.ckpt-5000\n",
1860 "\n",
1861 "Test set accuracy: 0.933\n",
1862 "\n"
1863 ]
1864 }
1865 ],
1866 "source": [
1867 "eval_result = classifier.evaluate(\n",
1868 " input_fn=lambda: input_fn(test, test_y, training=False))\n",
1869 "\n",
1870 "print('\\nTest set accuracy: {accuracy:0.3f}\\n'.format(**eval_result))"
1871 ]
1872 },
1873 {
1874 "cell_type": "markdown",
1875 "metadata": {
1876 "id": "4v1ZMe7jkXdp"
1877 },
1878 "source": [
1879 "Notice this time we didn't specify the number of steps. This is because during evaluation the model will only look at the testing data one time."
1880 ]
1881 },
1882 {
1883 "cell_type": "markdown",
1884 "metadata": {
1885 "id": "464HkZ6lknua"
1886 },
1887 "source": [
1888 "### Predictions\n",
1889 "Now that we have a trained model it's time to use it to make predictions. I've written a little script below that allows you to type the features of a flower and see a prediction for its class."
1890 ]
1891 },
1892 {
1893 "cell_type": "code",
1894 "execution_count": null,
1895 "metadata": {
1896 "colab": {
1897 "base_uri": "https://localhost:8080/",
1898 "height": 344
1899 },
1900 "id": "bQRLq4M1k1jm",
1901 "outputId": "f720852e-66e9-448e-bddf-ce33ce98cc61"
1902 },
1903 "outputs": [
1904 {
1905 "name": "stdout",
1906 "output_type": "stream",
1907 "text": [
1908 "Please type numeric values as prompted.\n",
1909 "SepalLength: 23\n",
1910 "SepalLength: 12\n",
1911 "SepalLength: 12\n",
1912 "SepalLength: 3\n",
1913 "SepalLength: 4\n",
1914 "SepalLength: 2\n",
1915 "SepalLength: 0.5\n",
1916 "SepalWidth: 2\n",
1917 "SepalWidth: 0.4\n",
1918 "PetalLength: 0.5\n",
1919 "PetalWidth: 0.3\n",
1920 "INFO:tensorflow:Calling model_fn.\n",
1921 "INFO:tensorflow:Done calling model_fn.\n",
1922 "INFO:tensorflow:Graph was finalized.\n",
1923 "INFO:tensorflow:Restoring parameters from /tmp/tmpqaqtrlgy/model.ckpt-5000\n",
1924 "INFO:tensorflow:Running local_init_op.\n",
1925 "INFO:tensorflow:Done running local_init_op.\n",
1926 "Prediction is \"Setosa\" (38.2%)\n"
1927 ]
1928 }
1929 ],
1930 "source": [
1931 "def input_fn(features, batch_size=256):\n",
1932 " # Convert the inputs to a Dataset without labels.\n",
1933 " return tf.data.Dataset.from_tensor_slices(dict(features)).batch(batch_size)\n",
1934 "\n",
1935 "features = ['SepalLength', 'SepalWidth', 'PetalLength', 'PetalWidth']\n",
1936 "predict = {}\n",
1937 "\n",
1938 "print(\"Please type numeric values as prompted.\")\n",
1939 "for feature in features:\n",
1940 " valid = True\n",
1941 " while valid: \n",
1942 " val = input(feature + \": \")\n",
1943 " if not val.isdigit(): valid = False\n",
1944 "\n",
1945 " predict[feature] = [float(val)]\n",
1946 "\n",
1947 "predictions = classifier.predict(input_fn=lambda: input_fn(predict))\n",
1948 "for pred_dict in predictions:\n",
1949 " class_id = pred_dict['class_ids'][0]\n",
1950 " probability = pred_dict['probabilities'][class_id]\n",
1951 "\n",
1952 " print('Prediction is \"{}\" ({:.1f}%)'.format(\n",
1953 " SPECIES[class_id], 100 * probability))\n"
1954 ]
1955 },
1956 {
1957 "cell_type": "code",
1958 "execution_count": null,
1959 "metadata": {
1960 "id": "-tRxhpmSr1FH"
1961 },
1962 "outputs": [],
1963 "source": [
1964 "# Here is some example input and expected classes you can try above\n",
1965 "expected = ['Setosa', 'Versicolor', 'Virginica']\n",
1966 "predict_x = {\n",
1967 " 'SepalLength': [5.1, 5.9, 6.9],\n",
1968 " 'SepalWidth': [3.3, 3.0, 3.1],\n",
1969 " 'PetalLength': [1.7, 4.2, 5.4],\n",
1970 " 'PetalWidth': [0.5, 1.5, 2.1],\n",
1971 "}"
1972 ]
1973 },
1974 {
1975 "cell_type": "markdown",
1976 "metadata": {
1977 "id": "ujwvc6ASsHID"
1978 },
1979 "source": [
1980 "And that's pretty much it for classification! "
1981 ]
1982 },
1983 {
1984 "cell_type": "markdown",
1985 "metadata": {
1986 "id": "d0dfaT4esRh3"
1987 },
1988 "source": [
1989 "##Clustering\n",
1990 "Now that we've covered regression and classification it's time to talk about clustering data! \n",
1991 "\n",
1992 "Clustering is a Machine Learning technique that involves the grouping of data points. In theory, data points that are in the same group should have similar properties and/or features, while data points in different groups should have highly dissimilar properties and/or features. (https://towardsdatascience.com/the-5-clustering-algorithms-data-scientists-need-to-know-a36d136ef68)\n",
1993 "\n",
1994 "Unfortunalty there are issues with the current version of TensorFlow and the implementation for KMeans. This means we cannot use KMeans without writing the algorithm from scratch. We aren't quite at that level yet, so we'll just explain the basics of clustering for now.\n",
1995 "\n",
1996 "####Basic Algorithm for K-Means.\n",
1997 "- Step 1: Randomly pick K points to place K centroids\n",
1998 "- Step 2: Assign all the data points to the centroids by distance. The closest centroid to a point is the one it is assigned to.\n",
1999 "- Step 3: Average all the points belonging to each centroid to find the middle of those clusters (center of mass). Place the corresponding centroids into that position.\n",
2000 "- Step 4: Reassign every point once again to the closest centroid.\n",
2001 "- Step 5: Repeat steps 3-4 until no point changes which centroid it belongs to.\n",
2002 "\n",
2003 "*Please refer to the video for an explanation of KMeans clustering.*"
2004 ]
2005 },
2006 {
2007 "cell_type": "markdown",
2008 "metadata": {
2009 "id": "sQ9iJrSbBTZB"
2010 },
2011 "source": [
2012 "##Hidden Markov Models\n",
2013 "\n",
2014 "\"The Hidden Markov Model is a finite set of states, each of which is associated with a (generally multidimensional) probability distribution []. Transitions among the states are governed by a set of probabilities called transition probabilities.\" (http://jedlik.phy.bme.hu/~gerjanos/HMM/node4.html)\n",
2015 "\n",
2016 "A hidden markov model works with probabilities to predict future events or states. In this section we will learn how to create a hidden markov model that can predict the weather.\n",
2017 "\n",
2018 "*This section is based on the following TensorFlow tutorial.* https://www.tensorflow.org/probability/api_docs/python/tfp/distributions/HiddenMarkovModel"
2019 ]
2020 },
2021 {
2022 "cell_type": "markdown",
2023 "metadata": {
2024 "id": "RKJSFk4NP0eq"
2025 },
2026 "source": [
2027 "###Data\n",
2028 "Let's start by discussing the type of data we use when we work with a hidden markov model. \n",
2029 "\n",
2030 "In the previous sections we worked with large datasets of 100's of different entries. For a markov model we are only interested in probability distributions that have to do with states. \n",
2031 "\n",
2032 "We can find these probabilities from large datasets or may already have these values. We'll run through an example in a second that should clear some things up, but let's discuss the components of a markov model.\n",
2033 "\n",
2034 "**States:** In each markov model we have a finite set of states. These states could be something like \"warm\" and \"cold\" or \"high\" and \"low\" or even \"red\", \"green\" and \"blue\". These states are \"hidden\" within the model, which means we do not direcly observe them.\n",
2035 "\n",
2036 "**Observations:** Each state has a particular outcome or observation associated with it based on a probability distribution. An example of this is the following: *On a hot day Tim has a 80% chance of being happy and a 20% chance of being sad.*\n",
2037 "\n",
2038 "**Transitions:** Each state will have a probability defining the likelyhood of transitioning to a different state. An example is the following: *a cold day has a 30% chance of being followed by a hot day and a 70% chance of being follwed by another cold day.*\n",
2039 "\n",
2040 "To create a hidden markov model we need.\n",
2041 "- States\n",
2042 "- Observation Distribution\n",
2043 "- Transition Distribution\n",
2044 "\n",
2045 "For our purpose we will assume we already have this information available as we attempt to predict the weather on a given day."
2046 ]
2047 },
2048 {
2049 "cell_type": "markdown",
2050 "metadata": {
2051 "id": "iK2QbOzr6jNJ"
2052 },
2053 "source": [
2054 "###Imports and Setup"
2055 ]
2056 },
2057 {
2058 "cell_type": "code",
2059 "execution_count": null,
2060 "metadata": {
2061 "colab": {
2062 "base_uri": "https://localhost:8080/",
2063 "height": 103
2064 },
2065 "id": "Suf1v8kJ6niA",
2066 "outputId": "f12c7178-cc43-42cd-92c3-8084d5d61637"
2067 },
2068 "outputs": [
2069 {
2070 "name": "stdout",
2071 "output_type": "stream",
2072 "text": [
2073 "`%tensorflow_version` only switches the major version: 1.x or 2.x.\n",
2074 "You set: `2.x # this line is not required unless you are in a notebook`. This will be interpreted as: `2.x`.\n",
2075 "\n",
2076 "\n",
2077 "TensorFlow is already loaded. Please restart the runtime to change versions.\n"
2078 ]
2079 }
2080 ],
2081 "source": [
2082 "%tensorflow_version 2.x # this line is not required unless you are in a notebook"
2083 ]
2084 },
2085 {
2086 "cell_type": "markdown",
2087 "metadata": {
2088 "id": "GN_Fkrx30xbb"
2089 },
2090 "source": [
2091 "Due to a version mismatch with tensorflow v2 and tensorflow_probability we need to install the most recent version of tensorflow_probability (see below)."
2092 ]
2093 },
2094 {
2095 "cell_type": "code",
2096 "execution_count": null,
2097 "metadata": {
2098 "colab": {
2099 "base_uri": "https://localhost:8080/",
2100 "height": 293
2101 },
2102 "id": "kawrMHKGBWyS",
2103 "outputId": "ad6d30ff-e53a-4776-825d-c18e2b0728cc"
2104 },
2105 "outputs": [
2106 {
2107 "name": "stdout",
2108 "output_type": "stream",
2109 "text": [
2110 "Collecting tensorflow_probability==0.8.0rc0\n",
2111 "\u001b[?25l Downloading https://files.pythonhosted.org/packages/b2/63/f54ce32063abaa682d779e44b49eb63fcf63c2422f978842fdeda794337d/tensorflow_probability-0.8.0rc0-py2.py3-none-any.whl (2.5MB)\n",
2112 "\u001b[K |████████████████████████████████| 2.5MB 2.7MB/s \n",
2113 "\u001b[?25hRequirement already satisfied, skipping upgrade: decorator in /usr/local/lib/python3.6/dist-packages (from tensorflow_probability==0.8.0rc0) (4.4.2)\n",
2114 "Collecting cloudpickle==1.1.1\n",
2115 " Downloading https://files.pythonhosted.org/packages/24/fb/4f92f8c0f40a0d728b4f3d5ec5ff84353e705d8ff5e3e447620ea98b06bd/cloudpickle-1.1.1-py2.py3-none-any.whl\n",
2116 "Requirement already satisfied, skipping upgrade: six>=1.10.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow_probability==0.8.0rc0) (1.12.0)\n",
2117 "Requirement already satisfied, skipping upgrade: numpy>=1.13.3 in /usr/local/lib/python3.6/dist-packages (from tensorflow_probability==0.8.0rc0) (1.18.5)\n",
2118 "\u001b[31mERROR: gym 0.17.2 has requirement cloudpickle<1.4.0,>=1.2.0, but you'll have cloudpickle 1.1.1 which is incompatible.\u001b[0m\n",
2119 "Installing collected packages: cloudpickle, tensorflow-probability\n",
2120 "Successfully installed cloudpickle-1.1.1 tensorflow-probability-0.8.0rc0\n"
2121 ]
2122 },
2123 {
2124 "data": {
2125 "application/vnd.colab-display-data+json": {
2126 "pip_warning": {
2127 "packages": [
2128 "cloudpickle"
2129 ]
2130 }
2131 }
2132 },
2133 "metadata": {
2134 "tags": []
2135 },
2136 "output_type": "display_data"
2137 }
2138 ],
2139 "source": [
2140 "!pip install tensorflow_probability==0.8.0rc0 --user --upgrade"
2141 ]
2142 },
2143 {
2144 "cell_type": "code",
2145 "execution_count": null,
2146 "metadata": {
2147 "id": "mEIk7FYD6lcF"
2148 },
2149 "outputs": [],
2150 "source": [
2151 "import tensorflow_probability as tfp # We are using a different module from tensorflow this time\n",
2152 "import tensorflow as tf"
2153 ]
2154 },
2155 {
2156 "cell_type": "markdown",
2157 "metadata": {
2158 "id": "ssOcn-nIOCcV"
2159 },
2160 "source": [
2161 "###Weather Model\n",
2162 "Taken direclty from the TensorFlow documentation (https://www.tensorflow.org/probability/api_docs/python/tfp/distributions/HiddenMarkovModel). \n",
2163 "\n",
2164 "We will model a simple weather system and try to predict the temperature on each day given the following information.\n",
2165 "1. Cold days are encoded by a 0 and hot days are encoded by a 1.\n",
2166 "2. The first day in our sequence has an 80% chance of being cold.\n",
2167 "3. A cold day has a 30% chance of being followed by a hot day.\n",
2168 "4. A hot day has a 20% chance of being followed by a cold day.\n",
2169 "5. On each day the temperature is\n",
2170 " normally distributed with mean and standard deviation 0 and 5 on\n",
2171 " a cold day and mean and standard deviation 15 and 10 on a hot day.\n",
2172 "\n",
2173 "If you're unfamiliar with **standard deviation** it can be put simply as the range of expected values. \n",
2174 "\n",
2175 "In this example, on a hot day the average temperature is 15 and ranges from 5 to 25.\n",
2176 "\n",
2177 "To model this in TensorFlow we will do the following.\n"
2178 ]
2179 },
2180 {
2181 "cell_type": "code",
2182 "execution_count": null,
2183 "metadata": {
2184 "id": "4LBLEJp4YlIf"
2185 },
2186 "outputs": [],
2187 "source": [
2188 "tfd = tfp.distributions # making a shortcut for later on\n",
2189 "initial_distribution = tfd.Categorical(probs=[0.2, 0.8]) # Refer to point 2 above\n",
2190 "transition_distribution = tfd.Categorical(probs=[[0.5, 0.5],\n",
2191 " [0.2, 0.8]]) # refer to points 3 and 4 above\n",
2192 "observation_distribution = tfd.Normal(loc=[0., 15.], scale=[5., 10.]) # refer to point 5 above\n",
2193 "\n",
2194 "# the loc argument represents the mean and the scale is the standard devitation"
2195 ]
2196 },
2197 {
2198 "cell_type": "markdown",
2199 "metadata": {
2200 "id": "-XtTg0l04mqc"
2201 },
2202 "source": [
2203 "We've now created distribution variables to model our system and it's time to create the hidden markov model."
2204 ]
2205 },
2206 {
2207 "cell_type": "code",
2208 "execution_count": null,
2209 "metadata": {
2210 "id": "P4M6cZww4mZk"
2211 },
2212 "outputs": [],
2213 "source": [
2214 "model = tfd.HiddenMarkovModel(\n",
2215 " initial_distribution=initial_distribution,\n",
2216 " transition_distribution=transition_distribution,\n",
2217 " observation_distribution=observation_distribution,\n",
2218 " num_steps=7)"
2219 ]
2220 },
2221 {
2222 "cell_type": "markdown",
2223 "metadata": {
2224 "id": "DJ0XIA2M5gqD"
2225 },
2226 "source": [
2227 "The number of steps represents the number of days that we would like to predict information for. In this case we've chosen 7, an entire week.\n",
2228 "\n",
2229 "To get the **expected temperatures** on each day we can do the following."
2230 ]
2231 },
2232 {
2233 "cell_type": "code",
2234 "execution_count": null,
2235 "metadata": {
2236 "colab": {
2237 "base_uri": "https://localhost:8080/",
2238 "height": 34
2239 },
2240 "id": "plVVG4fi55Jv",
2241 "outputId": "cef2d0a3-0edf-4226-ad65-43245933109f"
2242 },
2243 "outputs": [
2244 {
2245 "name": "stdout",
2246 "output_type": "stream",
2247 "text": [
2248 "[12. 11.1 10.83 10.748999 10.724699 10.71741 10.715222]\n"
2249 ]
2250 }
2251 ],
2252 "source": [
2253 "mean = model.mean()\n",
2254 "\n",
2255 "# due to the way TensorFlow works on a lower level we need to evaluate part of the graph\n",
2256 "# from within a session to see the value of this tensor\n",
2257 "\n",
2258 "# in the new version of tensorflow we need to use tf.compat.v1.Session() rather than just tf.Session()\n",
2259 "with tf.compat.v1.Session() as sess: \n",
2260 " print(mean.numpy())"
2261 ]
2262 },
2263 {
2264 "cell_type": "markdown",
2265 "metadata": {
2266 "id": "RzzUGR12AkiF"
2267 },
2268 "source": [
2269 "##Conclusion\n",
2270 "So that's it for the core learning algorithms in TensorFlow. Hopefully you've learned about a few interesting tools that are easy to use! To practice I'd encourage you to try out some of these algorithms on different datasets."
2271 ]
2272 },
2273 {
2274 "cell_type": "markdown",
2275 "metadata": {
2276 "id": "IEeIRxlbx0wY"
2277 },
2278 "source": [
2279 "##Sources\n",
2280 "\n",
2281 "1. Chen, James. “Line Of Best Fit.” Investopedia, Investopedia, 29 Jan. 2020, www.investopedia.com/terms/l/line-of-best-fit.asp.\n",
2282 "2. “Tf.feature_column.categorical_column_with_vocabulary_list.” TensorFlow, www.tensorflow.org/api_docs/python/tf/feature_column/categorical_column_with_vocabulary_list?version=stable.\n",
2283 "3. “Build a Linear Model with Estimators : TensorFlow Core.” TensorFlow, www.tensorflow.org/tutorials/estimator/linear.\n",
2284 "4. Staff, EasyBib. “The Free Automatic Bibliography Composer.” EasyBib, Chegg, 1 Jan. 2020, www.easybib.com/project/style/mla8?id=1582473656_5e52a1b8c84d52.80301186.\n",
2285 "5. Seif, George. “The 5 Clustering Algorithms Data Scientists Need to Know.” Medium, Towards Data Science, 14 Sept. 2019, https://towardsdatascience.com/the-5-clustering-algorithms-data-scientists-need-to-know-a36d136ef68.\n",
2286 "6. Definition of Hidden Markov Model, http://jedlik.phy.bme.hu/~gerjanos/HMM/node4.html.\n",
2287 "7. “Tfp.distributions.HiddenMarkovModel : TensorFlow Probability.” TensorFlow, www.tensorflow.org/probability/api_docs/python/tfp/distributions/HiddenMarkovModel."
2288 ]
2289 }
2290 ],
2291 "metadata": {
2292 "colab": {
2293 "collapsed_sections": [
2294 "sIBZww6kOIAp",
2295 "UQlXWErlbhsG"
2296 ],
2297 "name": "Core Learning Algorithms.ipynb",
2298 "provenance": []
2299 },
2300 "kernelspec": {
2301 "display_name": "Python 3",
2302 "language": "python",
2303 "name": "python3"
2304 },
2305 "language_info": {
2306 "codemirror_mode": {
2307 "name": "ipython",
2308 "version": 3
2309 },
2310 "file_extension": ".py",
2311 "mimetype": "text/x-python",
2312 "name": "python",
2313 "nbconvert_exporter": "python",
2314 "pygments_lexer": "ipython3",
2315 "version": "3.8.8"
2316 }
2317 },
2318 "nbformat": 4,
2319 "nbformat_minor": 1
2320 }
2321