Newer
Older
{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "YHI3vyhv5p85"
},
"source": [
"# Exercise 1 : Conversion from Celsius to Fahrenheit (Simple Regression Analysis)"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "F8YVA_634OFk"
},
"source": [
"The problem we will solve is to convert from Celsius to Fahrenheit, where the approximate formula is:\n",
"\n",
"$$ f = c \\times 1.8 + 32 $$\n",
"\n",
"\n",
"Of course, it would be simple enough to create a conventional Python function that directly performs this calculation, but that wouldn't be machine learning.\n",
"\n",
"\n",
"Instead, we will give TensorFlow some sample Celsius values (0, 8, 15, 22, 38) and their corresponding Fahrenheit values (32, 46, 59, 72, 100).\n",
"Then, we will train a model that figures out the above formula through the training process. This is a _simple regression analysis_ problem."
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "fA93WUy1zzWf"
},
"source": [
"## Import dependencies\n",
"\n",
"First, import TensorFlow. Here, we're calling it `tf` for ease of use. We also tell it to only display errors.\n",
"\n",
"Next, import [NumPy](http://www.numpy.org/) as `np`. Numpy helps us to represent our data as highly performant lists."
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "X9uIpOS2zx7k"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
]
}
],
"source": [
"from __future__ import absolute_import, division, print_function, unicode_literals\n",
"import tensorflow as tf\n",
"print(tf.__version__)\n",
"import numpy as np"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "y_WQEM5MGmg3"
},
"outputs": [],
"source": [
"import logging\n",
"logger = tf.get_logger()\n",
"logger.setLevel(logging.ERROR)"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "AC3EQFi20buB"
},
"source": [
"## Set up training data\n",
"\n",
"As we saw before, supervised Machine Learning is all about figuring out an algorithm given a set of inputs and outputs. Since the task in this exercise is to create a model that can give the temperature in Fahrenheit when given the degrees in Celsius, we create two lists `celsius_q` and `fahrenheit_a` that we can use to train our model."
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
"metadata": {
"colab": {},
"colab_type": "code",
"id": "gg4pn6aI1vms"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"-40.0 degrees Celsius = -40.0 degrees Fahrenheit\n",
"-10.0 degrees Celsius = 14.0 degrees Fahrenheit\n",
"0.0 degrees Celsius = 32.0 degrees Fahrenheit\n",
"8.0 degrees Celsius = 46.0 degrees Fahrenheit\n",
"15.0 degrees Celsius = 59.0 degrees Fahrenheit\n",
"22.0 degrees Celsius = 72.0 degrees Fahrenheit\n",
"38.0 degrees Celsius = 100.0 degrees Fahrenheit\n"
]
}
],
"source": [
"celsius_q = np.array([-40, -10, 0, 8, 15, 22, 38], dtype=float)\n",
"fahrenheit_a = np.array([-40, 14, 32, 46, 59, 72, 100], dtype=float)\n",
"\n",
"for i,c in enumerate(celsius_q):\n",
" print(\"{} degrees Celsius = {} degrees Fahrenheit\".format(c, fahrenheit_a[i]))"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "wwJGmDrQ0EoB"
},
"source": [
"### Some Machine Learning terminology\n",
"\n",
" - **Feature** — The input(s) to our model. In this case, a single value — the degrees in Celsius.\n",
"\n",
" - **Labels/response variable** — The output our model predicts. In this case, a single value — the degrees in Fahrenheit. In a classification setting, we would predict labels (discrete classes), in a regression setting, we predict a continuous response variable, such as Fahrenheit.\n",
"\n",
" - **Example** — A pair of inputs/outputs used during training. In our case a pair of values from `celsius_q` and `fahrenheit_a` at a specific index, such as `(22,72)`.\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "VM7_9Klvq7MO"
},
"source": [
"## 1. Define the Network\n",
"\n",
"Next create the model. We will use the simplest possible model we can, a Dense network. Since the problem is straightforward, this network will require only a single layer, with a single neuron.\n",
"\n",
"### Build a layer\n",
"\n",
"We'll call the layer `l0` and create it by instantiating `tf.keras.layers.Dense` with the following configuration:\n",
"\n",
"* `input_shape=[1]` — This specifies that the input to this layer is a single value. That is, the shape is a one-dimensional array with one member. Since this is the first (and only) layer, that input shape is the input shape of the entire model. The single value is a floating point number, representing degrees Celsius.\n",
"\n",
"* `units=1` — This specifies the number of units in the layer. The number of units defines how many internal variables the layer has to try to learn how to solve the problem (more later). Since this is the final layer, it is also the size of the model's output — a single float value representing degrees Fahrenheit. (In a multi-layered network, the size and shape of the layer would need to match the `input_shape` of the next layer.)\n"
]
},
{
"cell_type": "code",
"metadata": {
"colab": {},
"colab_type": "code",
"id": "pRllo2HLfXiu"
},
"outputs": [],
"source": [
"l0 = tf.keras.layers.Dense(units=1, input_shape=[1])"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "_F00_J9duLBD"
},
"source": [
"### Assemble layers into the model\n",
"\n",
"Once layers are defined, they need to be assembled into a model. The Sequential model definition takes a list of layers as argument, specifying the calculation order from the input to the output.\n",
"\n",
"This model has just a single layer, `l0`."
]
},
{
"cell_type": "code",
"metadata": {
"colab": {},
"colab_type": "code",
"id": "cSp-GpLSuMRq"
},
"outputs": [],
"source": [
"model = tf.keras.Sequential([\n",
" tf.keras.layers.Dense(units=1, input_shape=[1])\n",
"])"
]
},
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
{
"cell_type": "code",
"execution_count": 106,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model: \"sequential_11\"\n",
"_________________________________________________________________\n",
" Layer (type) Output Shape Param # \n",
"=================================================================\n",
" dense_15 (Dense) (None, 1) 2 \n",
" \n",
"=================================================================\n",
"Total params: 2\n",
"Trainable params: 2\n",
"Non-trainable params: 0\n",
"_________________________________________________________________\n"
]
}
],
"source": [
"model.summary()"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "kiZG7uhm8qCF"
},
"source": [
"## 2. Compile the network, with loss and optimizer functions\n",
"\n",
"Before training, the model has to be compiled. When compiled for training, the model is given:\n",
"\n",
"- **Loss function** — A way of measuring how far off predictions are from the desired outcome. (The measured difference is called the \"loss\".)\n",
"\n",
"- **Optimizer function** — A way of adjusting internal values in order to reduce the loss.\n"
]
},
{
"cell_type": "code",
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
"metadata": {
"colab": {},
"colab_type": "code",
"id": "m8YQN1H41L-Y"
},
"outputs": [],
"source": [
"model.compile(loss='mean_squared_error',\n",
" optimizer=tf.keras.optimizers.Adam(0.1))"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "17M3Pqv4P52R"
},
"source": [
"These are used during training (`model.fit()`, below) to first calculate the loss at each point, and then improve it. In fact, the act of calculating the current loss of a model and then improving it is precisely what training is.\n",
"\n",
"During training, the optimizer function is used to calculate adjustments to the model's internal variables. The goal is to adjust the internal variables until the model (which is really a math function) mirrors the actual equation for converting Celsius to Fahrenheit.\n",
"\n",
"`TensorFlow` uses numerical analysis to perform this tuning, and all this complexity is hidden from you so we will not go into the details here. What is useful to know about these parameters are:\n",
"\n",
"The loss function ([mean squared error](https://en.wikipedia.org/wiki/Mean_squared_error)) and the optimizer ([Adam](https://machinelearningmastery.com/adam-optimization-algorithm-for-deep-learning/)) used here are standard for simple models like this one, but many others are available. It is not important to know how these specific functions work at this point.\n",
"\n",
"One part of the Optimizer you may need to think about when building your own models is the learning rate (`0.1` in the code above). This is the step size taken when adjusting values in the model. If the value is too small, it will take too many iterations to train the model. Too large, and accuracy goes down. Finding a good value often involves some trial and error, but the range is usually within 0.001 (default), and 0.1"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "c-Jk4dG91dvD"
},
"source": [
"## 3. Fit the model\n",
"\n",
"Train the model by calling the `fit` method.\n",
"\n",
"During training, the model takes in Celsius values, performs a calculation using the current internal variables (called \"weights\") and outputs values which are meant to be the Fahrenheit equivalent. Since the weights are initially set randomly, the output will not be close to the correct value. The difference between the actual output and the desired output is calculated using the loss function, and the optimizer function directs how the weights should be adjusted.\n",
"\n",
"This cycle of calculate, compare, adjust is controlled by the `fit` method. The first argument is the inputs, the second argument is the desired outputs. The `epochs` argument specifies how many times this cycle should be run, and the `verbose` argument controls how much output the method produces."
]
},
{
"cell_type": "code",
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
"metadata": {
"colab": {},
"colab_type": "code",
"id": "lpRrl7WK10Pq"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Finished training the model\n"
]
}
],
"source": [
"history = model.fit(celsius_q, fahrenheit_a, epochs=500, verbose=False)\n",
"print(\"Finished training the model\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "0-QsNCLD4MJZ"
},
"source": [
"## 4. Evaluate the Model - Display training statistics\n",
"\n",
"The `fit` method returns a history object. We can use this object to plot how the loss of our model goes down after each training epoch. A high loss means that the Fahrenheit degrees the model predicts is far from the corresponding value in `fahrenheit_a`.\n",
"\n",
"We'll use [Matplotlib](https://matplotlib.org/) to visualize this (you could use another tool). As you can see, our model improves very quickly at first, and then has a steady, slow improvement until it is very near \"perfect\" towards the end.\n",
"\n"
]
},
{
"cell_type": "code",
"metadata": {
"colab": {},
"colab_type": "code",
"id": "IeK6BzfbdO6_"
},
"outputs": [
{
"data": {
"text/plain": [
"[<matplotlib.lines.Line2D at 0x7ff9ec12a190>]"
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"import matplotlib.pyplot as plt\n",
"plt.xlabel('Epoch Number')\n",
"plt.ylabel(\"Loss Magnitude\")\n",
"plt.plot(history.history['loss'])"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "LtQGDMob5LOD"
},
"source": [
"## 5. Use the model to predict values\n",
"\n",
"Now you have a model that has been trained to learn the relationship between `celsius_q` and `fahrenheit_a`. You can use the predict method to have it calculate the Fahrenheit degrees for a previously unknown Celsius degrees.\n",
"\n",
"So, for example, if the Celsius value is 100, what do you think the Fahrenheit result will be? Take a guess before you run this code."
]
},
{
"cell_type": "code",
"metadata": {
"colab": {},
"colab_type": "code",
"id": "oxNzL4lS2Gui"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
]
}
],
"source": [
"print(model.predict([100.0]))"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "jApk6tZ1fBg1"
},
"source": [
"The correct answer is $100 \\times 1.8 + 32 = 212$, so our model is doing really well.\n",
"\n",
"### To review\n",
"\n",
"\n",
"* We created a model with a Dense layer\n",
"* We trained it with 3500 examples (7 pairs, over 500 epochs).\n",
"\n",
"Our model tuned the variables (weights) in the Dense layer until it was able to return the correct Fahrenheit value for any Celsius value. (Remember, 100 Celsius was not part of our training data.)\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "zRrOky5gm20Z"
},
"source": [
"## Looking at the layer weights\n",
"\n",
"Finally, let's print the internal variables of the Dense layer. "
]
},
{
"cell_type": "code",
"metadata": {
"colab": {},
"colab_type": "code",
"id": "kmIkVdkbnZJI"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"These are the layer variables: [array([[1.8242955]], dtype=float32), array([28.880667], dtype=float32)]\n"
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
]
}
],
"source": [
"print(\"These are the layer variables: {}\".format(model.get_weights()))"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "RSplSnMvnWC-"
},
"source": [
"The first variable is close to ~1.8 and the second to ~32. These values (1.8 and 32) are the actual variables in the real conversion formula.\n",
"\n",
"This is really close to the values in the conversion formula. We can show how a Dense layer works, but for a single neuron with a single input and a single output, the internal math looks the same as [the equation for a line](https://en.wikipedia.org/wiki/Linear_equation#Slope%E2%80%93intercept_form), $y = mx + b$, which has the same form as the conversion equation, $f = 1.8c + 32$.\n",
"\n",
"Since the form is the same, the variables should converge on the standard values of 1.8 and 32, which is exactly what happened.\n",
"\n",
"With additional neurons, additional inputs, and additional outputs, the formula becomes much more complex, but the idea is the same.\n",
"\n",
"### A little experiment\n",
"\n",
"Just for fun, what if we created more Dense layers with different units, which therefore also has more variables?"
]
},
{
"cell_type": "code",
"metadata": {
"colab": {},
"colab_type": "code",
"id": "Y2zTA-rDS5Xk"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Finished training the model\n",
"[[211.74742]]\n",
"Model predicts that 100 degrees Celsius is: [[211.74742]] degrees Fahrenheit\n",
"These are the l0 variables: [array([[0.5968949 , 0.02139384, 0.01172368, 0.35185102]], dtype=float32), array([ 3.484818 , -3.0073252, -2.7715163, 3.010582 ], dtype=float32)]\n",
"These are the l1 variables: [array([[ 0.20319672, -0.41102245, 0.7771168 , -0.7402758 ],\n",
" [-0.7281887 , 0.9473572 , -0.15004049, 0.12950596],\n",
" [-0.96478873, 0.05949384, -0.2531712 , 0.72464406],\n",
" [-0.10805991, -0.88057184, 1.0134443 , -0.15393376]],\n",
" dtype=float32), array([ 1.8714209, -3.126011 , 3.3828623, -2.6109185], dtype=float32)]\n",
"These are the l2 variables: [array([[ 0.23399544],\n",
" [-0.9353689 ],\n",
" [ 1.1917399 ],\n",
" [-0.6491724 ]], dtype=float32), array([3.2284596], dtype=float32)]\n"
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
]
}
],
"source": [
"l0 = tf.keras.layers.Dense(units=4, input_shape=[1])\n",
"l1 = tf.keras.layers.Dense(units=4)\n",
"l2 = tf.keras.layers.Dense(units=1)\n",
"model = tf.keras.Sequential([l0, l1, l2])\n",
"model.compile(loss='mean_squared_error', optimizer=tf.keras.optimizers.Adam(0.1))\n",
"model.fit(celsius_q, fahrenheit_a, epochs=500, verbose=False)\n",
"print(\"Finished training the model\")\n",
"print(model.predict([100.0]))\n",
"print(\"Model predicts that 100 degrees Celsius is: {} degrees Fahrenheit\".format(model.predict([100.0])))\n",
"print(\"These are the l0 variables: {}\".format(l0.get_weights()))\n",
"print(\"These are the l1 variables: {}\".format(l1.get_weights()))\n",
"print(\"These are the l2 variables: {}\".format(l2.get_weights()))"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "xrpFFlgYhCty"
},
"source": [
"As you can see, this model is also able to predict the corresponding Fahrenheit value really well. But when you look at the variables (weights) in the `l0` and `l1` layers, they are nothing even close to ~1.8 and ~32. The added complexity hides the \"simple\" form of the conversion equation.\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Exercise 2 : O-Rings seen with Logistic Regression"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This notebook calculates a logistic regression using Keras. It's basically meant to show the principles of Keras.\n",
"\n",
"### Datset\n",
"\n",
"We investigate the data set of the challenger flight with broken O-rings (`Y=1`\n",
") vs start temperature."
]
},
{
"cell_type": "code",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Text(0, 0.5, 'Broken O-rings')"
]
},
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"%matplotlib inline\n",
"import numpy as np\n",
"import tensorflow as tf\n",
"import matplotlib.pyplot as plt\n",
"import matplotlib.image as imgplot\n",
"import numpy as np\n",
"import pandas as pd\n",
"import tempfile\n",
"data = np.asarray(pd.read_csv('./challenger.txt', sep=','), dtype='float32')\n",
"plt.plot(data[:,0], data[:,1], 'o')\n",
"plt.axis([40, 85, -0.1, 1.2])\n",
"plt.xlabel('Temperature [F]')\n",
"plt.ylabel('Broken O-rings')"
]
},
{
"cell_type": "code",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0. 1. 0. 0. 0. 0. 0. 0. 1. 1. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 1. 0. 1.]\n"
]
}
],
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Mathematical Notes\n",
"\n",
"We are considering the likelihood $P(y_i=1|x_i)$ for the class $y_i=1$ given the $i-$th data point $x_i$ ($x_i$ could be a vector). This is given by:\n",
"\n",
"$\n",
"P(y_i=1 | x_i) = \\frac{e^{(b + x_i w)}}{1 + e^{(b + x_i w)}} = [1 + e^{-(b + x_i w)}]^{-1}\n",
"$\n",
"\n",
"If we have more than one data point, which we usually do, we have to apply the equation above to each of the N data points. In this case we can use a vectorized version with $x=(x_1,x_2,\\ldots,x_N)$ and $y=(y_1,y_2,\\ldots,y_N$)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Numpy code\n",
"This numpy code, shows the calculation for one value using `NumPy` (like a single forward pass)"
]
},
{
"cell_type": "code",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3.882916\n",
"[0.999 0.998 0.998 0.998 0.999 0.996 0.996 0.998 1. 0.999 0.998 0.988\n",
" 0.999 1. 0.999 0.993 0.998 0.978 0.992 0.985 0.993 0.992 1. ]\n"
]
}
],
"source": [
"# Data\n",
"N = len(data)\n",
"x = data[:,0]\n",
"y = data[:,1]\n",
"# Initial Value for the weights\n",
"w = -0.20\n",
"b = 20.0\n",
"p_1 = 1 / (1 + np.exp(-x*w - b))\n",
"# cross-entropy loss function\n",
"cross_entropy = -np.mean(y * np.log(p_1) + (1-y) * np.log(1-p_1))\n",
"print(cross_entropy)\n",
"print(np.round(p_1,3))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Better values from intuition\n",
"\n",
"Now lets try to find better values for $W$ and $b$. Lets assume $W$ is given with $-1$. We want the probability\n",
"for a dammage $P(y_i=1 | x_i)$ to be $0.5$.\n",
"Determine an appropriate value for $b$.\n",
"Hint: at which $x$ value should $P(y_i=1 | x_i)$ be $0.5$, look at the data. At this $x$ value the term $1 + e^{-(b + W’ x_i)}$ must be $2$.\n",
"\n",
"**Solution**\n",
"\n",
"$P(y=1 | x) = 0.5$ at $x \\approx 65$ \n",
"\n",
"$-(b + (-1) x_i) = 0 \\rightarrow b = 65$ "
]
},
{
"cell_type": "code",
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.9094435\n",
"[0.269 0.007 0.018 0.047 0.119 0.001 0. 0.007 1. 0.881 0.007 0.\n",
" 0.119 1. 0.119 0. 0.007 0. 0. 0. 0. 0. 0.999]\n"
]
},
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAAb/klEQVR4nO3de3hU9b3v8fc3kwQiIheJwYRE0CIIoQWbighbrbaVi/XS7nMqre1uty2nrezTy35s5dTH9tj21F09Z+vTWi3V1lZ3dat1W06lpT3VPm1R2URRERAFkUuQiyAIEkIu3/PHmtAhZC5JZmatrHxez8MzM2utmfXxJ3yy8ltrZszdERGR+CoJO4CIiBSWil5EJOZU9CIiMaeiFxGJORW9iEjMqehFRGIua9Gb2U/NbJeZvZRm/SfM7EUzW21mT5nZe/IfU0REeiuXI/p7gdkZ1m8CLnD3KcC3gcV5yCUiInlSmm0Dd/+zmY3NsP6plIfPAGPykEtERPIka9H30DXAb9OtNLMFwAKAIUOGvHfixIl53r2ISLw9++yzb7p7ZU+ek7eiN7P3ExT9rHTbuPtiklM7DQ0N3tjYmK/di4gMCGa2uafPyUvRm9m7gbuBOe6+Jx+vKSIi+dHnyyvNrA54FPiku7/S90giIpJPWY/ozewB4EJglJltA74JlAG4+13AjcDJwI/MDKDN3RsKFVhERHoml6tu5mdZ/1ngs3lLJCIieaV3xoqIxJyKXkQk5lT0IiIxp6IXEYk5Fb2ISMyp6EVEYk5FLyIScyp6EZGYU9GLiMScil5EJOZU9CIiMaeiFxGJORW9iEjMqehFRGJORS8iEnMqehGRmFPRi4jEnIpeRCTmVPQiIjGnohcRiTkVvYhIzKnoRURiTkUvIhJzKnoRkZhT0YuIxFxptg3M7KfApcAud6/vZr0BtwNzgUPAp939uXwHlfx5bFUTtyxbz/Z9zVQPr+C6SyZwxbSaUPcbVqbe5u2PbnhsNQ+s2Eq7Owkz5k+v5TtXTAk7VuzGOYqyFj1wL/BD4Bdp1s8Bxif/TAfuTN5KBD22qolFj66mubUdgKZ9zSx6dDVAQf9xZdovEEqmTMIap0K54bHV3P/MlqOP292PPg6z7OM2zlFl7p59I7OxwG/SHNH/GPiTuz+QfLweuNDd38j0mg1jyr3x2tG9Ci29d6Clle7+l5vB0EFlyQe5vFLKRmZ/W3bc/eB298FWWh06KMHd6MBwjJJEgjYSNLeX0EqCNkppI0GrJ6Csgr+bPBbKT4TyIcHtoBOD26GjYVgtDK+FwcN6Oxxpzbz5CZr2NR+3vGZ4Bcuvvyjv+yu0MxYtpb2b//EJMzZ+b24IiQJxG+diMLNn3b2hJ8/J5Yg+mxpga8rjbcllxxW9mS0AFgBMqjkJpn48D7uXnnh4+aa06/5x+jgg+w/+Y39SeMqyLvc7t/MO/vifWzCcEjooMT96P9HWQSntlNJOGe2U0kaZtTPEDjO47QBsexOOHIQj70Droe7zDBoGw8YEpT9iLIw7H8ZdEPxQ6KXt3ZRPpuVR113JZ1peLHEb56jKR9HnzN0XA4sBGhoanDk3F3P3AtzzQvojqH+cU7gjqB+sTb9fIP1R3ZdSMnW0B4XfcgAOvAH7tsD+rbBvK+zfFtzf9BdYcRckymHs38GZs+HMDwU/AHqgenhFt5mqk3n7m4RZ2iP6MMVtnKMqH1fdNAG1KY/HJJdJBF13yQQqyhLHLKsoS3DdJRNC22/OmUoSMPgkGFYDYxqg/iMw80sw71b4+IPwheXw9dfhU0vgnAWwbzP89jq4/T1wx3R44jvQcrDPefuj+dNre7S8WOI2zlGVjyP6JcBCM3uQ4CTs/mzz8xKezhNcxb7KIZf95iVTaTmcfkHw55Lvwp6N8MoyeHUZ/PlWeOlX8NG7oea9fc7bn3SecI3aVTdxG+eoynoy1sweAC4ERgE7gW8CZQDuflfy8sofArMJLq/8jLs3ZttxQ0ODNzZm3Uwkf15fDo8ugIM74MJFMOsrwW8JIv1Ib07G5nTVTSGo6CUUzfvg8a8GR/Z158FHfgzD68JOJZKz3hS93hkrA0vFcPjoPXDlYtixGu6cBasfCTuVSEGp6GXgMYP3fAy+8Fc4ZSL86hpY8t/p9g0GIjGgopeBa8RY+PRSmLEQnvs5rHk07EQiBaGil4EtUQofvAlOnQq/WxTM4YvEjIpepCQBH74N3tkNT3w77DQieaeiFwGongbn/DdYeQ9s09VgEi8qepFOF30Dhp4K//fL0N4WdhqRvFHRi3QaNBTm/AvsXA0r7gw7jUjeqOhFUp314eCD0J78X8GHponEgIpeJJUZzL0luL/0a7q2XmJBRS/S1fC64LNwXvktvPybsNOI9JmKXqQ7534BquqDo/qWA2GnEekTFb1IdxJlcOltwRec/ElfkCP9m4peJJ3a9wVfbrLqfl1uKf2ail4kk8lXwuF9sOWpsJOI9JqKXiSTMy6C0sHw8uNhJxHpNRW9SCblQ4Kyf/lxXWop/ZaKXiSbifNg/1Z444Wwk4j0iopeJJszZ4OVaPpG+i0VvUg2Q0ZB3QwVvfRbKnqRXEycB7vWwN7Xwk4i0mMqepFcTJwX3L68NNwcIr2gohfJxYixUDVF0zfSL6noRXI1cR5sfQYO7g47iUiP5FT0ZjbbzNab2QYzu76b9XVm9qSZrTKzF81sbv6jioRs4jzwDnjld2EnEemRrEVvZgngDmAOMAmYb2aTumx2A/CQu08DrgJ+lO+gIqEbPQWG1emji6XfyeWI/hxgg7u/5u5HgAeBy7ts48BJyfvDgO35iygSEWbBUf3GJ6HlYNhpRHKWS9HXAFtTHm9LLkv1LeBqM9sGLAX+qbsXMrMFZtZoZo27d2ueU/qhifOgvQU2/jHsJCI5y9fJ2PnAve4+BpgL3Gdmx722uy929wZ3b6isrMzTrkWKqG4GVIzQ1TfSr+RS9E1AbcrjMcllqa4BHgJw96eBwcCofAQUiZREKZw5Jzgh294adhqRnORS9CuB8WY2zszKCU62LumyzRbgYgAzO4ug6DU3I/E0cR4c3g+bl4edRCQnWYve3duAhcAyYB3B1TVrzOwmM7ssudk/A58zsxeAB4BPu+szXSWmzrgISis0fSP9RmkuG7n7UoKTrKnLbky5vxaYmd9oIhFVfgK86+Kg6Od8P7gaRyTC9M5Ykd6YOA/eboLtq8JOIpKVil6kNzo/o369PuRMok9FL9IbJ4yE0e+GrSvCTiKSlYpepLeqp8H2F/RdshJ5KnqR3qqeCi379WUkEnkqepHeOnVqcPvG82GmEMlKRS/SW6dMgkQ5bH8+7CQiGanoRXqrtByqJusSS4k8Fb1IX5w6Fd54USdkJdJU9CJ9UT1NJ2Ql8lT0In1RPTW41fSNRJiKXqQvKs+CxCBdeSORpqIX6YujJ2SfDzuJSFoqepG+qp4Kb7wAHR1hJxHplopepK+qp0HL2/DWprCTiHRLRS/SV53vkNUJWYkoFb1IX52SPCGropeIUtGL9FWiDEbXB/P0IhGkohfJh1OnBlfe6ISsRJCKXiQfqqfCkQN6h6xEkopeJB+qpwW3euOURJCKXiQfKifqhKxElopeJB8SZTB6it4hK5GkohfJF71DViJKRS+SL6dOTZ6Q3Rh2EpFj5FT0ZjbbzNab2QYzuz7NNv/VzNaa2Roz+2V+Y4r0A50nZDV9IxGTtejNLAHcAcwBJgHzzWxSl23GA4uAme4+Gfhy/qOKRFzlRCgdrCtvJHJyOaI/B9jg7q+5+xHgQeDyLtt8DrjD3d8CcPdd+Y0p0g8kSqGqXlfeSOTkUvQ1wNaUx9uSy1KdCZxpZsvN7Bkzm93dC5nZAjNrNLPG3bt39y6xSJRVTwu+Q1YnZCVC8nUythQYD1wIzAd+YmbDu27k7ovdvcHdGyorK/O0a5EIOfoOWZ2QlejIpeibgNqUx2OSy1JtA5a4e6u7bwJeISh+kYFFH1ksEZRL0a8ExpvZODMrB64ClnTZ5jGCo3nMbBTBVI4+9EMGns4TsrryRiIka9G7exuwEFgGrAMecvc1ZnaTmV2W3GwZsMfM1gJPAte5+55ChRaJrERp8h2yOqKX6CjNZSN3Xwos7bLsxpT7Dnw1+UdkYKueBs//MjghW6L3JEr49LdQJN9OnQpHDsKeDWEnEQFU9CL5Vz01uNX0jUSEil4k30ZNCE7I7ngx7CQigIpeJP8SpcHVNztfCjuJCKCiFymM0fWw4yVwDzuJiIpepCCqpsChN+HgzrCTiKjoRQpidH1wu0PTNxI+Fb1IIVRNDm53rg43hwgqepHCqBgBw2p1RC+RoKIXKZSqel15I5GgohcplNH18Oar0NocdhIZ4FT0IoVSVQ/eDrvWhZ1EBjgVvUihjJ4S3Gr6RkKmohcplBHjoGyITshK6FT0IoVSUhJcZqkjegmZil6kkPRRCBIBKnqRQqqqh5b9sH9r2ElkAFPRixRS5wlZzdNLiFT0IoV0yiTANE8voVLRixTSoBNh5DjYoc+8kfCo6EUKTR+FICFT0YsU2ugpsHcTtBwMO4kMUCp6kUKrqgccdq0NO4kMUCp6kUI7+iUkmqeXcORU9GY228zWm9kGM7s+w3YfNTM3s4b8RRTp54bVwuBhmqeX0GQtejNLAHcAc4BJwHwzm9TNdkOBLwEr8h1SpF8zC6ZvdC29hCSXI/pzgA3u/pq7HwEeBC7vZrtvA/8CHM5jPpF4qKqHnWugoyPsJDIA5VL0NUDq+7e3JZcdZWZnA7Xu/nimFzKzBWbWaGaNu3fv7nFYkX5rdD20vgNvbQo7iQxAfT4Za2YlwP8B/jnbtu6+2N0b3L2hsrKyr7sW6T+qkidkNU8vIcil6JuA2pTHY5LLOg0F6oE/mdnrwLnAEp2QFUlxyllgCV15I6HIpehXAuPNbJyZlQNXAUs6V7r7fncf5e5j3X0s8Axwmbs3FiSxSH9UVgGjxuuErIQia9G7exuwEFgGrAMecvc1ZnaTmV1W6IAisaGPQpCQlOaykbsvBZZ2WXZjmm0v7HsskRgaXQ8vPQLNb0HFiLDTyACid8aKFEtV55eFrwk3hww4KnqRYjn6UQiavpHiUtGLFMuJVXDCKNipK2+kuFT0IsVi9rcvCxcpIhW9SDFV1cOuddDeFnYSGUBU9CLFNHoKtLfAng1hJ5EBREUvUkzV04LbbSvDzSEDiopepJhGnRmckN28POwkMoCo6EWKyQzGzoTX/xp2EhlAVPQixXbaLNi/Fd7aHHYSGSBU9CLFNnZmcKvpGykSFb1IsVWeBRUjNX0jRaOiFym2khI47TwVvRSNil4kDGNnwb7NsG9r9m1F+khFLxKGsbOCW83TSxGo6EXCcMpkGDxc0zdSFCp6kTB0ztPriF6KQEUvEpbTZsLe1+Dt7WEnkZhT0YuEpXOe/nUd1UthqehFwjJ6CgwaBps1Ty+FpaIXCUtJAurO1RG9FJyKXiRMY2fBnlfhwI6wk0iMqehFwqTPvZEiUNGLhGn0e6B8qKZvpKByKnozm21m681sg5ld3836r5rZWjN70cz+aGan5T+qSAwlSqFuut44JQWVtejNLAHcAcwBJgHzzWxSl81WAQ3u/m7gEeD7+Q4qEltjZ8Gb6+Hg7rCTSEzlckR/DrDB3V9z9yPAg8DlqRu4+5Pufij58BlgTH5jisTYafrcGymsXIq+Bkj9iL1tyWXpXAP8ti+hRAaU6qlQNkTTN1Iwpfl8MTO7GmgALkizfgGwAKCuri6fuxbpvxJlwTy9juilQHI5om8CalMej0kuO4aZfQD4BnCZu7d090LuvtjdG9y9obKysjd5ReLptJmway28syfsJBJDuRT9SmC8mY0zs3LgKmBJ6gZmNg34MUHJ78p/TJGY0+fTSwFlLXp3bwMWAsuAdcBD7r7GzG4ys8uSm90CnAg8bGbPm9mSNC8nIt2pPhtKK1T0UhA5zdG7+1JgaZdlN6bc/0Cec4kMLKXlUHuO3jglBaF3xopExdhZsPMlfe6N5J2KXiQq6j8a3K68O9wcEjsqepGoOPkMmDgPVt4DRw5l314kRyp6kSiZsRCa98ILvww7icSIil4kSurODa7AefpH0NERdhqJCRW9SJSYwXkLYe9GeOV3YaeRmFDRi0TNWZfDsDp4+odhJ5GYUNGLRE2iFM79fPDmqabnwk4jMaCiF4miaZ+EQSfB03eEnURiQEUvEkWDT4KzPwVr/gP2bc2+vUgGKnqRqJr++eB2xV3h5pB+T0UvElXDa2HylfDcL+Dw22GnkX5MRS8SZTOuhZa3g7IX6SUVvUiU1ZwdfCnJirugvS3sNNJPqehFom7GQti/Fdb9Ouwk0k+p6EWi7szZcPK74C//Cq3NYaeRfkhFLxJ1JSVw8TeDz6r/909CW7dfySySlopepD+YdBl8+DbY8Ad4+DPQ3hp2IulHVPQi/cV7Pw1zboH1j8OvPquTs5KznL4zVkQiYvoCaG+B398ApYPgijuhJBF2Kok4Fb1If3PeP0HbYXjiO0HZX3p7MI8vkoaKXqQ/Ov+64KTsn2+BRDnMvTX4LHuRbqjoRfqr938jOLJ/6gdweD9c8HUYNT7sVBJBKnqR/soMPvjt4Ij+qR/A6odh/Ifg3C/A6e/XEb4cpYk9kf7MDC6+Eb6yBi5cBNtXwX1Xwo9mwLM/1xusBABz9+wbmc0GbgcSwN3ufnOX9YOAXwDvBfYAH3P31zO9ZkNDgzc2NvYytkj/9tiqJm5Ztp7t+5qpHl7BdZdM4IppNQB84idPs3zj3qPbzjxjJP/2uRk5PXdJ4yZeXHYPH2lZwqSSzbSUD2fQWXOgqp6fbTyBO9dWsMtPImHG/Om1fOeKKX3Om8v63r72DY+t5oEVW2l3z2vmQuUtBjN71t0bevScbEVvZgngFeCDwDZgJTDf3dembPNF4N3u/nkzuwq40t0/lul1VfQyUD22qolFj66mubX96LKKsgTf+8gUHm7cckzJd+os+0zPBVLWOeeWrOMzZX/g/MGvUdGy++j2u30Y6zrqWO+11NSdztz3TYITRkLFCKjovB0OibKsea+YVpN1fW/HonHzXu5/Zstxz7n63LqsZZ/7OOUvb7HKvlBFPwP4lrtfkny8CMDdv5eyzbLkNk+bWSmwA6j0DC+uopeBaubNT9C07/gplZrhFd0u7/T6zfMyPhdIu+7I/l28y7Zwlm1hom1hQslWJthWBluGd9haAkoHs7/VaPYyjngpLZTTSintGIlEKZNqRvBC0wEOt0O7l9BOCU5wbqCsrJQZp49Kniuwv93C0fMHf371TQ63th99TqfBZQlaWttxOG6dAZdMrjrmdbr60/rdx5Rxp4qy4D0H6dZdOKEy/Xhked1sz80Xu+rfelz0uZyMrQFSv8tsGzA93Tbu3mZm+4GTgTePCWi2AFgAUFdX15OcIrGxPU2Zp1ve1+du39eMM5TdPpmnmZyyxhlKM6u/1gDNb0HzXmjeB4f2wuF9wRU9bS38+i/rKaeVcmtjEEcop50SOki0dTCp/EQOth0iYR2UWjuDaMWS1WxtDocAD+qao8d9fvRmVNvbmHVzPNhG8mdCmmPFvYfSrwNGtx2A7n4GdL6ZON26PZm/4CXj62Z5bpiKetWNuy8GFkNwRF/MfYtERXWaI/d0y3N9LnR/RF89vIId+w/Tftwv2MYhGwIjxwHj0u7zx6vS/xax/FMX8bUMv2UsX3BRxv+ez2V4bveZIWHGxi/Ozfi61/TyN5/lX8ycN9PrZntu3lzb86upcrnqpgmoTXk8Jrms222SUzfDCE7KikgX110y4egUQqeKsgTXXTKBmWeM7PY5ncszPTfTuvnTa+lOuuW55s1lfW9fu1CZC5U3ynI5ol8JjDezcQSFfhXw8S7bLAH+AXga+HvgiUzz8yIDWedJu+6u3LhiWk3Gq24yPbdTutcFenUFS7Z95pKpt2NRqMyFyBtluV5eORe4jeDyyp+6+3fN7Cag0d2XmNlg4D5gGrAXuMrdX8v0mjoZKyLSc7256ianOXp3Xwos7bLsxpT7h4H/0pMdi4hIceidsSIiMaeiFxGJORW9iEjMqehFRGJORS8iEnMqehGRmFPRi4jEnIpeRCTmVPQiIjGnohcRiTkVvYhIzOX0oWYF2bHZAWB9KDtPbxRdviwlIqKYS5lyo0y5i2KuKGaa4O5De/KEon7xSBfre/oJbIVmZo1RywTRzKVMuVGm3EUxV1Qz9fQ5mroREYk5Fb2ISMyFWfSLQ9x3OlHMBNHMpUy5UabcRTFXLDKFdjJWRESKQ1M3IiIxp6IXEYm5ohW9mSXMbJWZ/Sb5eJyZrTCzDWb272ZWXqwsWXLda2abzOz55J+pRc7zupmtTu67MblspJn9wcxeTd6OiECmb5lZU8o4zS1ypuFm9oiZvWxm68xsRtjjlCFXaGNlZhNS9vu8mb1tZl8Oc6wyZAr779RXzGyNmb1kZg+Y2eCweypNph53VNHm6M3sq0ADcJK7X2pmDwGPuvuDZnYX8IK731mUMJlz3Qv8xt0fKXaWZJ7XgQZ3fzNl2feBve5+s5ldD4xw96+HnOlbwEF3v7VYObpk+jnwF3e/O/mP7wTgfxDiOGXI9WVCHKuUbAmgCZgOXEvIY9VNps8Q0jiZWQ3wV2CSuzcn+2kpMJeQeipDpgvpYUcV5YjezMYA84C7k48NuAjoDPpz4IpiZMmUK8IuJxgjCGmsosTMhgHnA/cAuPsRd99HyOOUIVdUXAxsdPfNROfvVGqmsJUCFWZWSvAD+g3C76mumbb35kWKNXVzG/A1oCP5+GRgn7u3JR9vA2qKlCVTrk7fNbMXzexfzWxQkTM58Hsze9bMFiSXVbn7G8n7O4CqCGQCWJgcp58WeZpkHLAb+JkF0253m9kQwh+ndLkgvLFKdRXwQPJ+2GPVKTUThDRO7t4E3ApsISj4/cCzhNhT3WVy998nV/eoowpe9GZ2KbDL3Z8t9L56IkOuRcBE4H3ASKDYv87OcvezgTnAtWZ2fupKD+bain1NbHeZ7gTOAKYS/CX830XMUwqcDdzp7tOAd4DrUzcIaZzS5QpzrABITiNdBjzcdV1IY9VdptDGKflD5XKCH9bVwBBgdrH2n2smM7uaXnRUMY7oZwKXJed5HyT4Veh2YHjy1xGAMQTzdMV0XC4zu9/d3/BAC/Az4Jxihkr+FMfddwH/kdz/TjM7FSB5uyvsTO6+093b3b0D+AnFHadtwDZ3X5F8/AhBwYY6TulyhTxWneYAz7n7zuTjsMfquEwhj9MHgE3uvtvdW4FHCToizJ7qLtN5vemoghe9uy9y9zHuPpbg17Qn3P0TwJPA3yc3+wfg14XOkkOuq1P+8hvBfNxLxcpkZkPMbGjnfeBDyf0vIRgjKPJYpcvUOU5JV1LEcXL3HcBWM5uQXHQxsJYQxylTrjDHKsV8jp0iCXWsko7JFPI4bQHONbMTkv/2O/9OhdlT3WVa16uOcvei/eFvZ4sBTgf+E9hA8KvboGJmyZDrCWB1cvDuB04sYo7TgReSf9YA30guPxn4I/Aq8P+AkRHIdF9ynF4kKI1Ti/z/bCrQmNz/Y8CIMMcpS66wx2oIsAcYlrIs1LFKkynscfqfwMvJf/v3AYPC7qk0mXrcUfoIBBGRmNM7Y0VEYk5FLyIScyp6EZGYU9GLiMScil5EJOZU9CIiMaeiFxGJuf8Pn37/6Rxd8c8AAAAASUVORK5CYII=\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"w_val = -1\n",
"b_val = 65\n",
"plt.plot(data[:,0], data[:,1], 'o')\n",
"plt.axis([40, 85, -0.1, 1.2])\n",
"x_pred = np.linspace(40,85)\n",
"x_pred = np.resize(x_pred,[len(x_pred),1])\n",
"y_pred = 1 / (1 + np.exp(-x_pred*w_val - b_val))\n",
"plt.plot(x_pred, y_pred)\n",
"\n",
"p_1 = 1 / (1 + np.exp(-x*w_val - b_val))\n",
"\n",
"# cross-entropy loss function\n",
"cross_entropy = -np.mean(y * np.log(p_1) + (1-y) * np.log(1-p_1))\n",
" \n",
"print(cross_entropy)\n",
"print(np.round(p_1,3))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can see that the value of the cross-entropy has decreased from 3.882916 to 0.9094435."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## TODO : determine the accuracy of this logistic regression model"
]
},
{
"cell_type": "code",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Accuracy: 0.8695652173913043\n"
]
}
],
"source": [
"y_pred = np.round(p_1, decimals=0).astype('int')\n",
"accuracy = np.mean(y==y_pred)\n",
"print(\"Accuracy: \", accuracy)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## TODO : set up a Keras model\n",
"\n",
"If there are two labels, we use `binary_crossentropy` as loss function. In this case, we use `sigmoid` as output layer."
]
},
{
"cell_type": "code",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"<keras.callbacks.History at 0x7ff9e419c450>"
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"l0 = tf.keras.layers.Dense(units=1, activation = tf.nn.sigmoid, input_shape=[1])\n",
"model = tf.keras.Sequential([l0])\n",
"model.compile(loss='binary_crossentropy', optimizer=tf.keras.optimizers.Adam(0.01), metrics=['accuracy'])\n",
"model.fit(x, y, epochs=10000, verbose=False)"
]
},
{
"cell_type": "code",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[<matplotlib.lines.Line2D at 0x7ff9ec0405d0>]"
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"plt.plot(data[:,0], data[:,1], 'o')\n",
"plt.axis([40, 85, -0.1, 1.2])\n",
"x_pred = np.linspace(40,85)\n",
"x_pred = np.resize(x_pred,[len(x_pred),1])\n",
"y_pred = model.predict(x_pred)\n",
"plt.plot(x_pred, y_pred)"
]
},
{
"cell_type": "code",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[array([[-0.23217289]], dtype=float32), array([15.043545], dtype=float32)]\n"
]
}
],
"source": [
"print(model.get_weights())"
]
},
{
"cell_type": "code",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Cross-entropy: 0.4416346\n",
"Accuracy: 0.8695652173913043\n"
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"w_val = model.get_weights()[0]\n",
"b_val = model.get_weights()[1]\n",
"plt.plot(data[:,0], data[:,1], 'o')\n",
"plt.axis([40, 85, -0.1, 1.2])\n",
"x_pred = np.linspace(40,85)\n",
"x_pred = np.resize(x_pred,[len(x_pred),1])\n",
"y_pred = 1 / (1 + np.exp(-x_pred*w_val - b_val))\n",
"plt.plot(x_pred, y_pred)\n",
"\n",
"p_1 = 1 / (1 + np.exp(-x*w_val - b_val))\n",
"\n",
"# cross-entropy loss function\n",
"cross_entropy = -np.mean(y * np.log(p_1) + (1-y) * np.log(1-p_1))\n",
"print(\"Cross-entropy: \", cross_entropy)\n",
"y_pred = np.round(p_1, decimals=0).astype('int')\n",
"accuracy = np.mean(y==y_pred)\n",
"print(\"Accuracy: \", accuracy)"
]
},
{
"cell_type": "code",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1/1 [==============================] - 0s 118ms/step - loss: 0.4416 - accuracy: 0.8696\n"
]
},
{
"data": {
"text/plain": [
"[0.4416346251964569, 0.8695651888847351]"
]
},
"execution_count": 96,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.evaluate(x, y)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The value of the cross-entropy loss function could be decreased from 0.9094435 to 0.4416346251964569"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Exercise 3 : MNIST and Multinomial Logistic Regression"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In this exercise we use multinomial logistic regression to predict the number of the handwritten digits of the MNIST dataset."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## TODO : read MNIST data and compute validation accuracy for a multinomial logistic regression model, see [Multinomial Logistic Regression](https://en.wikipedia.org/wiki/Multinomial_logistic_regression)\n",
"\n",
"If there are several labels, then we use `categorical_crossentropy` as loss function and the output layer should be a `softmax` layer."
]
},
{
"cell_type": "code",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n",
"11493376/11490434 [==============================] - 0s 0us/step\n",
"11501568/11490434 [==============================] - 0s 0us/step\n",
"1875/1875 [==============================] - 9s 5ms/step - loss: 320.4593 - accuracy: 0.8417 - val_loss: 242.9400 - val_accuracy: 0.8801\n",
"1875/1875 [==============================] - 8s 4ms/step - loss: 257.2356 - accuracy: 0.8691 - val_loss: 381.1338 - val_accuracy: 0.8126\n",
"1875/1875 [==============================] - 8s 5ms/step - loss: 246.9380 - accuracy: 0.8741 - val_loss: 225.4031 - val_accuracy: 0.8802\n",
"1875/1875 [==============================] - 8s 4ms/step - loss: 238.4442 - accuracy: 0.8784 - val_loss: 312.3720 - val_accuracy: 0.8513\n",
"1875/1875 [==============================] - 9s 5ms/step - loss: 238.5885 - accuracy: 0.8783 - val_loss: 195.5100 - val_accuracy: 0.9018\n",
"1875/1875 [==============================] - 9s 5ms/step - loss: 238.2655 - accuracy: 0.8773 - val_loss: 253.4705 - val_accuracy: 0.8795\n",
"1875/1875 [==============================] - 9s 5ms/step - loss: 237.9472 - accuracy: 0.8798 - val_loss: 250.7999 - val_accuracy: 0.8824\n",
"1875/1875 [==============================] - 8s 5ms/step - loss: 237.2793 - accuracy: 0.8802 - val_loss: 285.5836 - val_accuracy: 0.8707\n",
"1875/1875 [==============================] - 8s 4ms/step - loss: 235.1660 - accuracy: 0.8808 - val_loss: 277.7219 - val_accuracy: 0.8809\n",
"1875/1875 [==============================] - 9s 5ms/step - loss: 233.3158 - accuracy: 0.8822 - val_loss: 263.0470 - val_accuracy: 0.8765\n"
]
}
],
"source": [
"from __future__ import absolute_import, division, print_function, unicode_literals\n",
"from tensorflow.keras.datasets import mnist\n",
"from tensorflow.keras.utils import to_categorical\n",
"\n",
"\n",