From fc318b6bc3e544807edef837b2b1f2c3545b8275 Mon Sep 17 00:00:00 2001 From: mhjensen Date: Fri, 29 Oct 2021 10:10:39 +0200 Subject: [PATCH] week42 --- doc/pub/week43/ipynb/week43.ipynb | 2823 ++++++++++++++++++++--------- 1 file changed, 1999 insertions(+), 824 deletions(-) diff --git a/doc/pub/week43/ipynb/week43.ipynb b/doc/pub/week43/ipynb/week43.ipynb index 90d362561..0c07095ae 100644 --- a/doc/pub/week43/ipynb/week43.ipynb +++ b/doc/pub/week43/ipynb/week43.ipynb @@ -2,10 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "9e4136dc", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "\n", @@ -14,10 +11,7 @@ }, { "cell_type": "markdown", - "id": "d104a88e", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "# Week 43: Deep Learning: Recurrent Neural Networks and other Deep Learning Methods. Principal Component analysis\n", "**Morten Hjorth-Jensen**, Department of Physics, University of Oslo and Department of Physics and Astronomy and National Superconducting Cyclotron Laboratory, Michigan State University\n", @@ -29,10 +23,7 @@ }, { "cell_type": "markdown", - "id": "8370cb8d", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Plans for week 43\n", "\n", @@ -57,10 +48,7 @@ }, { "cell_type": "markdown", - "id": "1ebf17ba", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Reading Recommendations\n", "\n", @@ -71,10 +59,7 @@ }, { "cell_type": "markdown", - "id": "bb7f3ffe", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Summary on Deep Learning Methods\n", "\n", @@ -85,10 +70,7 @@ }, { "cell_type": "markdown", - "id": "b9612ead", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## CNNs in brief\n", "\n", @@ -116,10 +98,7 @@ }, { "cell_type": "markdown", - "id": "f5e61390", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Recurrent neural networks: Overarching view\n", "\n", @@ -143,10 +122,7 @@ }, { "cell_type": "markdown", - "id": "346dd8a7", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Set up of an RNN\n", "\n", @@ -155,23 +131,262 @@ }, { "cell_type": "markdown", - "id": "47167efe", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## A simple example" ] }, { "cell_type": "code", - "execution_count": 1, - "id": "3a1aa47c", - "metadata": { - "collapsed": false, - "editable": true - }, - "outputs": [], + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential_4\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "simple_rnn_2 (SimpleRNN) (None, 32) 1184 \n", + "_________________________________________________________________\n", + "dense_6 (Dense) (None, 8) 264 \n", + "_________________________________________________________________\n", + "dense_7 (Dense) (None, 1) 9 \n", + "=================================================================\n", + "Total params: 1,457\n", + "Trainable params: 1,457\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n", + "Epoch 1/100\n", + "50/50 - 0s - loss: 2.1758\n", + "Epoch 2/100\n", + "50/50 - 0s - loss: 0.5257\n", + "Epoch 3/100\n", + "50/50 - 0s - loss: 0.3998\n", + "Epoch 4/100\n", + "50/50 - 0s - loss: 0.3943\n", + "Epoch 5/100\n", + "50/50 - 0s - loss: 0.3904\n", + "Epoch 6/100\n", + "50/50 - 0s - loss: 0.3860\n", + "Epoch 7/100\n", + "50/50 - 0s - loss: 0.3852\n", + "Epoch 8/100\n", + "50/50 - 0s - loss: 0.3847\n", + "Epoch 9/100\n", + "50/50 - 0s - loss: 0.3828\n", + "Epoch 10/100\n", + "50/50 - 0s - loss: 0.3824\n", + "Epoch 11/100\n", + "50/50 - 0s - loss: 0.3817\n", + "Epoch 12/100\n", + "50/50 - 0s - loss: 0.3803\n", + "Epoch 13/100\n", + "50/50 - 0s - loss: 0.3800\n", + "Epoch 14/100\n", + "50/50 - 0s - loss: 0.3811\n", + "Epoch 15/100\n", + "50/50 - 0s - loss: 0.3805\n", + "Epoch 16/100\n", + "50/50 - 0s - loss: 0.3776\n", + "Epoch 17/100\n", + "50/50 - 0s - loss: 0.3772\n", + "Epoch 18/100\n", + "50/50 - 0s - loss: 0.3765\n", + "Epoch 19/100\n", + "50/50 - 0s - loss: 0.3780\n", + "Epoch 20/100\n", + "50/50 - 0s - loss: 0.3777\n", + "Epoch 21/100\n", + "50/50 - 0s - loss: 0.3759\n", + "Epoch 22/100\n", + "50/50 - 0s - loss: 0.3751\n", + "Epoch 23/100\n", + "50/50 - 0s - loss: 0.3755\n", + "Epoch 24/100\n", + "50/50 - 0s - loss: 0.3745\n", + "Epoch 25/100\n", + "50/50 - 0s - loss: 0.3729\n", + "Epoch 26/100\n", + "50/50 - 0s - loss: 0.3728\n", + "Epoch 27/100\n", + "50/50 - 0s - loss: 0.3730\n", + "Epoch 28/100\n", + "50/50 - 0s - loss: 0.3736\n", + "Epoch 29/100\n", + "50/50 - 0s - loss: 0.3703\n", + "Epoch 30/100\n", + "50/50 - 0s - loss: 0.3721\n", + "Epoch 31/100\n", + "50/50 - 0s - loss: 0.3723\n", + "Epoch 32/100\n", + "50/50 - 0s - loss: 0.3717\n", + "Epoch 33/100\n", + "50/50 - 0s - loss: 0.3703\n", + "Epoch 34/100\n", + "50/50 - 0s - loss: 0.3711\n", + "Epoch 35/100\n", + "50/50 - 0s - loss: 0.3693\n", + "Epoch 36/100\n", + "50/50 - 0s - loss: 0.3710\n", + "Epoch 37/100\n", + "50/50 - 0s - loss: 0.3674\n", + "Epoch 38/100\n", + "50/50 - 0s - loss: 0.3691\n", + "Epoch 39/100\n", + "50/50 - 0s - loss: 0.3686\n", + "Epoch 40/100\n", + "50/50 - 0s - loss: 0.3685\n", + "Epoch 41/100\n", + "50/50 - 0s - loss: 0.3676\n", + "Epoch 42/100\n", + "50/50 - 0s - loss: 0.3675\n", + "Epoch 43/100\n", + "50/50 - 0s - loss: 0.3670\n", + "Epoch 44/100\n", + "50/50 - 0s - loss: 0.3668\n", + "Epoch 45/100\n", + "50/50 - 0s - loss: 0.3668\n", + "Epoch 46/100\n", + "50/50 - 0s - loss: 0.3661\n", + "Epoch 47/100\n", + "50/50 - 0s - loss: 0.3655\n", + "Epoch 48/100\n", + "50/50 - 0s - loss: 0.3653\n", + "Epoch 49/100\n", + "50/50 - 0s - loss: 0.3620\n", + "Epoch 50/100\n", + "50/50 - 0s - loss: 0.3631\n", + "Epoch 51/100\n", + "50/50 - 0s - loss: 0.3644\n", + "Epoch 52/100\n", + "50/50 - 0s - loss: 0.3657\n", + "Epoch 53/100\n", + "50/50 - 0s - loss: 0.3631\n", + "Epoch 54/100\n", + "50/50 - 0s - loss: 0.3631\n", + "Epoch 55/100\n", + "50/50 - 0s - loss: 0.3639\n", + "Epoch 56/100\n", + "50/50 - 0s - loss: 0.3624\n", + "Epoch 57/100\n", + "50/50 - 0s - loss: 0.3625\n", + "Epoch 58/100\n", + "50/50 - 0s - loss: 0.3617\n", + "Epoch 59/100\n", + "50/50 - 0s - loss: 0.3620\n", + "Epoch 60/100\n", + "50/50 - 0s - loss: 0.3623\n", + "Epoch 61/100\n", + "50/50 - 0s - loss: 0.3609\n", + "Epoch 62/100\n", + "50/50 - 0s - loss: 0.3608\n", + "Epoch 63/100\n", + "50/50 - 0s - loss: 0.3611\n", + "Epoch 64/100\n", + "50/50 - 0s - loss: 0.3614\n", + "Epoch 65/100\n", + "50/50 - 0s - loss: 0.3596\n", + "Epoch 66/100\n", + "50/50 - 0s - loss: 0.3588\n", + "Epoch 67/100\n", + "50/50 - 0s - loss: 0.3591\n", + "Epoch 68/100\n", + "50/50 - 0s - loss: 0.3588\n", + "Epoch 69/100\n", + "50/50 - 0s - loss: 0.3589\n", + "Epoch 70/100\n", + "50/50 - 0s - loss: 0.3590\n", + "Epoch 71/100\n", + "50/50 - 0s - loss: 0.3583\n", + "Epoch 72/100\n", + "50/50 - 0s - loss: 0.3583\n", + "Epoch 73/100\n", + "50/50 - 0s - loss: 0.3592\n", + "Epoch 74/100\n", + "50/50 - 0s - loss: 0.3575\n", + "Epoch 75/100\n", + "50/50 - 0s - loss: 0.3577\n", + "Epoch 76/100\n", + "50/50 - 0s - loss: 0.3560\n", + "Epoch 77/100\n", + "50/50 - 0s - loss: 0.3572\n", + "Epoch 78/100\n", + "50/50 - 0s - loss: 0.3545\n", + "Epoch 79/100\n", + "50/50 - 0s - loss: 0.3579\n", + "Epoch 80/100\n", + "50/50 - 0s - loss: 0.3583\n", + "Epoch 81/100\n", + "50/50 - 0s - loss: 0.3559\n", + "Epoch 82/100\n", + "50/50 - 0s - loss: 0.3574\n", + "Epoch 83/100\n", + "50/50 - 0s - loss: 0.3561\n", + "Epoch 84/100\n", + "50/50 - 0s - loss: 0.3535\n", + "Epoch 85/100\n", + "50/50 - 0s - loss: 0.3540\n", + "Epoch 86/100\n", + "50/50 - 0s - loss: 0.3571\n", + "Epoch 87/100\n", + "50/50 - 0s - loss: 0.3548\n", + "Epoch 88/100\n", + "50/50 - 0s - loss: 0.3548\n", + "Epoch 89/100\n", + "50/50 - 0s - loss: 0.3527\n", + "Epoch 90/100\n", + "50/50 - 0s - loss: 0.3541\n", + "Epoch 91/100\n", + "50/50 - 0s - loss: 0.3551\n", + "Epoch 92/100\n", + "50/50 - 0s - loss: 0.3542\n", + "Epoch 93/100\n", + "50/50 - 0s - loss: 0.3538\n", + "Epoch 94/100\n", + "50/50 - 0s - loss: 0.3542\n", + "Epoch 95/100\n", + "50/50 - 0s - loss: 0.3530\n", + "Epoch 96/100\n", + "50/50 - 0s - loss: 0.3536\n", + "Epoch 97/100\n", + "50/50 - 0s - loss: 0.3534\n", + "Epoch 98/100\n", + "50/50 - 0s - loss: 0.3530\n", + "Epoch 99/100\n", + "50/50 - 0s - loss: 0.3521\n", + "Epoch 100/100\n", + "50/50 - 0s - loss: 0.3523\n", + "0.3476317524909973\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "%matplotlib inline\n", "\n", @@ -247,10 +462,7 @@ }, { "cell_type": "markdown", - "id": "c56fca8e", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## An extrapolation example\n", "\n", @@ -263,11 +475,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "1abc480a", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "\n", @@ -302,10 +510,7 @@ }, { "cell_type": "markdown", - "id": "b0564261", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Formatting the Data\n", "\n", @@ -346,11 +551,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "433a8f93", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "# FORMAT_DATA\n", @@ -429,10 +630,7 @@ }, { "cell_type": "markdown", - "id": "c73b0bfb", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Predicting New Points With A Trained Recurrent Neural Network" ] @@ -440,12 +638,379 @@ { "cell_type": "code", "execution_count": 4, - "id": "b1ad9290", - "metadata": { - "collapsed": false, - "editable": true - }, - "outputs": [], + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"functional_1\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "input_1 (InputLayer) [(None, 2, 1)] 0 \n", + "_________________________________________________________________\n", + "RNN (SimpleRNN) (None, 200) 40400 \n", + "_________________________________________________________________\n", + "dense (Dense) (None, 1) 201 \n", + "=================================================================\n", + "Total params: 40,601\n", + "Trainable params: 40,601\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n", + "Epoch 1/150\n", + "1/1 [==============================] - 0s 295ms/step - loss: 0.1436 - val_loss: 0.1590\n", + "Epoch 2/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0553 - val_loss: 0.0208\n", + "Epoch 3/150\n", + "1/1 [==============================] - 0s 49ms/step - loss: 0.0093 - val_loss: 0.0075\n", + "Epoch 4/150\n", + "1/1 [==============================] - 0s 31ms/step - loss: 0.0013 - val_loss: 0.0697\n", + "Epoch 5/150\n", + "1/1 [==============================] - 0s 50ms/step - loss: 0.0174 - val_loss: 0.1306\n", + "Epoch 6/150\n", + "1/1 [==============================] - 0s 31ms/step - loss: 0.0342 - val_loss: 0.1464\n", + "Epoch 7/150\n", + "1/1 [==============================] - 0s 51ms/step - loss: 0.0383 - val_loss: 0.1216\n", + "Epoch 8/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 0.0310 - val_loss: 0.0783\n", + "Epoch 9/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0189 - val_loss: 0.0370\n", + "Epoch 10/150\n", + "1/1 [==============================] - 0s 48ms/step - loss: 0.0080 - val_loss: 0.0098\n", + "Epoch 11/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0017 - val_loss: 1.1034e-04\n", + "Epoch 12/150\n", + "1/1 [==============================] - 0s 26ms/step - loss: 6.9480e-04 - val_loss: 0.0042\n", + "Epoch 13/150\n", + "1/1 [==============================] - 0s 21ms/step - loss: 0.0035 - val_loss: 0.0148\n", + "Epoch 14/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 0.0078 - val_loss: 0.0246\n", + "Epoch 15/150\n", + "1/1 [==============================] - 0s 42ms/step - loss: 0.0113 - val_loss: 0.0289\n", + "Epoch 16/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 0.0127 - val_loss: 0.0266\n", + "Epoch 17/150\n", + "1/1 [==============================] - 0s 21ms/step - loss: 0.0118 - val_loss: 0.0194\n", + "Epoch 18/150\n", + "1/1 [==============================] - 0s 23ms/step - loss: 0.0091 - val_loss: 0.0105\n", + "Epoch 19/150\n", + "1/1 [==============================] - 0s 44ms/step - loss: 0.0057 - val_loss: 0.0033\n", + "Epoch 20/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 0.0026 - val_loss: 8.0273e-05\n", + "Epoch 21/150\n", + "1/1 [==============================] - 0s 33ms/step - loss: 7.6223e-04 - val_loss: 0.0015\n", + "Epoch 22/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 3.4487e-04 - val_loss: 0.0065\n", + "Epoch 23/150\n", + "1/1 [==============================] - 0s 43ms/step - loss: 0.0011 - val_loss: 0.0130\n", + "Epoch 24/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0026 - val_loss: 0.0182\n", + "Epoch 25/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 0.0038 - val_loss: 0.0204\n", + "Epoch 26/150\n", + "1/1 [==============================] - 0s 44ms/step - loss: 0.0044 - val_loss: 0.0191\n", + "Epoch 27/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 0.0042 - val_loss: 0.0149\n", + "Epoch 28/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0032 - val_loss: 0.0095\n", + "Epoch 29/150\n", + "1/1 [==============================] - 0s 34ms/step - loss: 0.0019 - val_loss: 0.0046\n", + "Epoch 30/150\n", + "1/1 [==============================] - 0s 21ms/step - loss: 8.2796e-04 - val_loss: 0.0013\n", + "Epoch 31/150\n", + "1/1 [==============================] - 0s 21ms/step - loss: 2.0898e-04 - val_loss: 2.3623e-05\n", + "Epoch 32/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 1.4937e-04 - val_loss: 4.7888e-04\n", + "Epoch 33/150\n", + "1/1 [==============================] - 0s 65ms/step - loss: 5.1629e-04 - val_loss: 0.0018\n", + "Epoch 34/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 0.0011 - val_loss: 0.0031\n", + "Epoch 35/150\n", + "1/1 [==============================] - 0s 41ms/step - loss: 0.0015 - val_loss: 0.0036\n", + "Epoch 36/150\n", + "1/1 [==============================] - 0s 21ms/step - loss: 0.0016 - val_loss: 0.0033\n", + "Epoch 37/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 0.0015 - val_loss: 0.0023\n", + "Epoch 38/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0010 - val_loss: 0.0011\n", + "Epoch 39/150\n", + "1/1 [==============================] - 0s 37ms/step - loss: 5.7003e-04 - val_loss: 2.2496e-04\n", + "Epoch 40/150\n", + "1/1 [==============================] - 0s 24ms/step - loss: 1.9264e-04 - val_loss: 1.4810e-05\n", + "Epoch 41/150\n", + "1/1 [==============================] - 0s 25ms/step - loss: 2.3879e-05 - val_loss: 4.6021e-04\n", + "Epoch 42/150\n", + "1/1 [==============================] - 0s 47ms/step - loss: 7.5834e-05 - val_loss: 0.0013\n", + "Epoch 43/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 2.7179e-04 - val_loss: 0.0021\n", + "Epoch 44/150\n", + "1/1 [==============================] - 0s 26ms/step - loss: 4.8896e-04 - val_loss: 0.0025\n", + "Epoch 45/150\n", + "1/1 [==============================] - 0s 23ms/step - loss: 6.1614e-04 - val_loss: 0.0024\n", + "Epoch 46/150\n", + "1/1 [==============================] - 0s 21ms/step - loss: 5.9956e-04 - val_loss: 0.0018\n", + "Epoch 47/150\n", + "1/1 [==============================] - 0s 47ms/step - loss: 4.5749e-04 - val_loss: 0.0011\n", + "Epoch 48/150\n", + "1/1 [==============================] - 0s 41ms/step - loss: 2.6084e-04 - val_loss: 3.9345e-04\n", + "Epoch 49/150\n", + "1/1 [==============================] - 0s 25ms/step - loss: 9.3401e-05 - val_loss: 4.0833e-05\n", + "Epoch 50/150\n", + "1/1 [==============================] - 0s 23ms/step - loss: 1.2952e-05 - val_loss: 3.9010e-05\n", + "Epoch 51/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 3.0284e-05 - val_loss: 2.7843e-04\n", + "Epoch 52/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 1.1243e-04 - val_loss: 5.7199e-04\n", + "Epoch 53/150\n", + "1/1 [==============================] - 0s 34ms/step - loss: 2.0447e-04 - val_loss: 7.4973e-04\n", + "Epoch 54/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 2.5731e-04 - val_loss: 7.2967e-04\n", + "Epoch 55/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 2.4820e-04 - val_loss: 5.3823e-04\n", + "Epoch 56/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 1.8651e-04 - val_loss: 2.7938e-04\n", + "Epoch 57/150\n", + "1/1 [==============================] - 0s 21ms/step - loss: 1.0427e-04 - val_loss: 7.3842e-05\n", + "Epoch 58/150\n", + "1/1 [==============================] - 0s 48ms/step - loss: 3.8139e-05 - val_loss: 1.6914e-11\n", + "Epoch 59/150\n", + "1/1 [==============================] - 0s 56ms/step - loss: 1.1848e-05 - val_loss: 6.3061e-05\n", + "Epoch 60/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 2.7064e-05 - val_loss: 2.0306e-04\n", + "Epoch 61/150\n", + "1/1 [==============================] - 0s 51ms/step - loss: 6.5894e-05 - val_loss: 3.3295e-04\n", + "Epoch 62/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 1.0236e-04 - val_loss: 3.8443e-04\n", + "Epoch 63/150\n", + "1/1 [==============================] - 0s 70ms/step - loss: 1.1618e-04 - val_loss: 3.3796e-04\n", + "Epoch 64/150\n", + "1/1 [==============================] - 0s 44ms/step - loss: 1.0177e-04 - val_loss: 2.2428e-04\n", + "Epoch 65/150\n", + "1/1 [==============================] - 0s 47ms/step - loss: 6.8577e-05 - val_loss: 1.0093e-04\n", + "Epoch 66/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 3.3949e-05 - val_loss: 1.9456e-05\n", + "Epoch 67/150\n", + "1/1 [==============================] - 0s 58ms/step - loss: 1.3139e-05 - val_loss: 1.1826e-06\n", + "Epoch 68/150\n", + "1/1 [==============================] - 0s 83ms/step - loss: 1.2061e-05 - val_loss: 3.2427e-05\n", + "Epoch 69/150\n", + "1/1 [==============================] - 0s 44ms/step - loss: 2.5910e-05 - val_loss: 7.8148e-05\n", + "Epoch 70/150\n", + "1/1 [==============================] - 0s 53ms/step - loss: 4.3395e-05 - val_loss: 1.0407e-04\n", + "Epoch 71/150\n", + "1/1 [==============================] - 0s 55ms/step - loss: 5.3509e-05 - val_loss: 9.4624e-05\n", + "Epoch 72/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 5.1030e-05 - val_loss: 5.8121e-05\n", + "Epoch 73/150\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1/1 [==============================] - 0s 55ms/step - loss: 3.8193e-05 - val_loss: 1.8544e-05\n", + "Epoch 74/150\n", + "1/1 [==============================] - 0s 43ms/step - loss: 2.2298e-05 - val_loss: 1.0798e-07\n", + "Epoch 75/150\n", + "1/1 [==============================] - 0s 44ms/step - loss: 1.1105e-05 - val_loss: 1.3731e-05\n", + "Epoch 76/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 8.7124e-06 - val_loss: 5.2292e-05\n", + "Epoch 77/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 1.3989e-05 - val_loss: 9.6052e-05\n", + "Epoch 78/150\n", + "1/1 [==============================] - 0s 33ms/step - loss: 2.2016e-05 - val_loss: 1.2410e-04\n", + "Epoch 79/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 2.7321e-05 - val_loss: 1.2494e-04\n", + "Epoch 80/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 2.6906e-05 - val_loss: 1.0080e-04\n", + "Epoch 81/150\n", + "1/1 [==============================] - 0s 70ms/step - loss: 2.1459e-05 - val_loss: 6.4254e-05\n", + "Epoch 82/150\n", + "1/1 [==============================] - 0s 56ms/step - loss: 1.4349e-05 - val_loss: 3.0273e-05\n", + "Epoch 83/150\n", + "1/1 [==============================] - 0s 70ms/step - loss: 9.3221e-06 - val_loss: 8.6054e-06\n", + "Epoch 84/150\n", + "1/1 [==============================] - 0s 74ms/step - loss: 8.3716e-06 - val_loss: 5.1048e-07\n", + "Epoch 85/150\n", + "1/1 [==============================] - 0s 93ms/step - loss: 1.0931e-05 - val_loss: 7.0451e-07\n", + "Epoch 86/150\n", + "1/1 [==============================] - 0s 78ms/step - loss: 1.4623e-05 - val_loss: 2.3780e-06\n", + "Epoch 87/150\n", + "1/1 [==============================] - 0s 57ms/step - loss: 1.6888e-05 - val_loss: 1.8350e-06\n", + "Epoch 88/150\n", + "1/1 [==============================] - 0s 68ms/step - loss: 1.6444e-05 - val_loss: 1.4416e-07\n", + "Epoch 89/150\n", + "1/1 [==============================] - 0s 124ms/step - loss: 1.3783e-05 - val_loss: 1.3598e-06\n", + "Epoch 90/150\n", + "1/1 [==============================] - 0s 94ms/step - loss: 1.0594e-05 - val_loss: 8.9608e-06\n", + "Epoch 91/150\n", + "1/1 [==============================] - 0s 57ms/step - loss: 8.5934e-06 - val_loss: 2.2965e-05\n", + "Epoch 92/150\n", + "1/1 [==============================] - 0s 80ms/step - loss: 8.5377e-06 - val_loss: 3.9449e-05\n", + "Epoch 93/150\n", + "1/1 [==============================] - 0s 121ms/step - loss: 9.9442e-06 - val_loss: 5.2560e-05\n", + "Epoch 94/150\n", + "1/1 [==============================] - 0s 77ms/step - loss: 1.1579e-05 - val_loss: 5.7598e-05\n", + "Epoch 95/150\n", + "1/1 [==============================] - 0s 47ms/step - loss: 1.2301e-05 - val_loss: 5.3279e-05\n", + "Epoch 96/150\n", + "1/1 [==============================] - 0s 102ms/step - loss: 1.1718e-05 - val_loss: 4.2006e-05\n", + "Epoch 97/150\n", + "1/1 [==============================] - 0s 161ms/step - loss: 1.0290e-05 - val_loss: 2.8229e-05\n", + "Epoch 98/150\n", + "1/1 [==============================] - 0s 130ms/step - loss: 8.9065e-06 - val_loss: 1.6116e-05\n", + "Epoch 99/150\n", + "1/1 [==============================] - 0s 58ms/step - loss: 8.2860e-06 - val_loss: 7.8794e-06\n", + "Epoch 100/150\n", + "1/1 [==============================] - 0s 111ms/step - loss: 8.5701e-06 - val_loss: 3.5245e-06\n", + "Epoch 101/150\n", + "1/1 [==============================] - 0s 75ms/step - loss: 9.3395e-06 - val_loss: 1.8229e-06\n", + "Epoch 102/150\n", + "1/1 [==============================] - 0s 52ms/step - loss: 9.9627e-06 - val_loss: 1.6167e-06\n", + "Epoch 103/150\n", + "1/1 [==============================] - 0s 44ms/step - loss: 1.0016e-05 - val_loss: 2.5882e-06\n", + "Epoch 104/150\n", + "1/1 [==============================] - 0s 91ms/step - loss: 9.5046e-06 - val_loss: 5.1155e-06\n", + "Epoch 105/150\n", + "1/1 [==============================] - 0s 95ms/step - loss: 8.7867e-06 - val_loss: 9.5206e-06\n", + "Epoch 106/150\n", + "1/1 [==============================] - 0s 75ms/step - loss: 8.2901e-06 - val_loss: 1.5357e-05\n", + "Epoch 107/150\n", + "1/1 [==============================] - 0s 129ms/step - loss: 8.2360e-06 - val_loss: 2.1271e-05\n", + "Epoch 108/150\n", + "1/1 [==============================] - 0s 83ms/step - loss: 8.5361e-06 - val_loss: 2.5535e-05\n", + "Epoch 109/150\n", + "1/1 [==============================] - 0s 108ms/step - loss: 8.8994e-06 - val_loss: 2.6874e-05\n", + "Epoch 110/150\n", + "1/1 [==============================] - 0s 63ms/step - loss: 9.0511e-06 - val_loss: 2.5049e-05\n", + "Epoch 111/150\n", + "1/1 [==============================] - 0s 51ms/step - loss: 8.9024e-06 - val_loss: 2.0902e-05\n", + "Epoch 112/150\n", + "1/1 [==============================] - 0s 125ms/step - loss: 8.5749e-06 - val_loss: 1.5838e-05\n", + "Epoch 113/150\n", + "1/1 [==============================] - 0s 57ms/step - loss: 8.2853e-06 - val_loss: 1.1186e-05\n", + "Epoch 114/150\n", + "1/1 [==============================] - 0s 94ms/step - loss: 8.1910e-06 - val_loss: 7.7262e-06\n", + "Epoch 115/150\n", + "1/1 [==============================] - 0s 60ms/step - loss: 8.2974e-06 - val_loss: 5.6475e-06\n", + "Epoch 116/150\n", + "1/1 [==============================] - 0s 107ms/step - loss: 8.4817e-06 - val_loss: 4.7956e-06\n", + "Epoch 117/150\n", + "1/1 [==============================] - 0s 58ms/step - loss: 8.5936e-06 - val_loss: 4.9800e-06\n", + "Epoch 118/150\n", + "1/1 [==============================] - 0s 50ms/step - loss: 8.5593e-06 - val_loss: 6.1072e-06\n", + "Epoch 119/150\n", + "1/1 [==============================] - 0s 60ms/step - loss: 8.4142e-06 - val_loss: 8.0997e-06\n", + "Epoch 120/150\n", + "1/1 [==============================] - 0s 61ms/step - loss: 8.2622e-06 - val_loss: 1.0720e-05\n", + "Epoch 121/150\n", + "1/1 [==============================] - 0s 62ms/step - loss: 8.1944e-06 - val_loss: 1.3478e-05\n", + "Epoch 122/150\n", + "1/1 [==============================] - 0s 74ms/step - loss: 8.2304e-06 - val_loss: 1.5738e-05\n", + "Epoch 123/150\n", + "1/1 [==============================] - 0s 75ms/step - loss: 8.3185e-06 - val_loss: 1.6943e-05\n", + "Epoch 124/150\n", + "1/1 [==============================] - 0s 60ms/step - loss: 8.3815e-06 - val_loss: 1.6847e-05\n", + "Epoch 125/150\n", + "1/1 [==============================] - 0s 46ms/step - loss: 8.3741e-06 - val_loss: 1.5600e-05\n", + "Epoch 126/150\n", + "1/1 [==============================] - 0s 47ms/step - loss: 8.3067e-06 - val_loss: 1.3650e-05\n", + "Epoch 127/150\n", + "1/1 [==============================] - 0s 63ms/step - loss: 8.2296e-06 - val_loss: 1.1542e-05\n", + "Epoch 128/150\n", + "1/1 [==============================] - 0s 53ms/step - loss: 8.1908e-06 - val_loss: 9.7292e-06\n", + "Epoch 129/150\n", + "1/1 [==============================] - 0s 66ms/step - loss: 8.2044e-06 - val_loss: 8.4828e-06\n", + "Epoch 130/150\n", + "1/1 [==============================] - 0s 45ms/step - loss: 8.2463e-06 - val_loss: 7.9015e-06\n", + "Epoch 131/150\n", + "1/1 [==============================] - 0s 66ms/step - loss: 8.2778e-06 - val_loss: 7.9855e-06\n", + "Epoch 132/150\n", + "1/1 [==============================] - 0s 69ms/step - loss: 8.2749e-06 - val_loss: 8.6731e-06\n", + "Epoch 133/150\n", + "1/1 [==============================] - 0s 72ms/step - loss: 8.2417e-06 - val_loss: 9.8407e-06\n", + "Epoch 134/150\n", + "1/1 [==============================] - 0s 103ms/step - loss: 8.2036e-06 - val_loss: 1.1287e-05\n", + "Epoch 135/150\n", + "1/1 [==============================] - 0s 65ms/step - loss: 8.1849e-06 - val_loss: 1.2730e-05\n", + "Epoch 136/150\n", + "1/1 [==============================] - 0s 53ms/step - loss: 8.1921e-06 - val_loss: 1.3871e-05\n", + "Epoch 137/150\n", + "1/1 [==============================] - 0s 56ms/step - loss: 8.2129e-06 - val_loss: 1.4471e-05\n", + "Epoch 138/150\n", + "1/1 [==============================] - 0s 67ms/step - loss: 8.2277e-06 - val_loss: 1.4441e-05\n", + "Epoch 139/150\n", + "1/1 [==============================] - 0s 73ms/step - loss: 8.2251e-06 - val_loss: 1.3852e-05\n", + "Epoch 140/150\n", + "1/1 [==============================] - 0s 53ms/step - loss: 8.2080e-06 - val_loss: 1.2911e-05\n", + "Epoch 141/150\n", + "1/1 [==============================] - 0s 52ms/step - loss: 8.1895e-06 - val_loss: 1.1868e-05\n", + "Epoch 142/150\n", + "1/1 [==============================] - 0s 45ms/step - loss: 8.1817e-06 - val_loss: 1.0956e-05\n", + "Epoch 143/150\n", + "1/1 [==============================] - 0s 54ms/step - loss: 8.1867e-06 - val_loss: 1.0332e-05\n", + "Epoch 144/150\n", + "1/1 [==============================] - 0s 33ms/step - loss: 8.1974e-06 - val_loss: 1.0078e-05\n", + "Epoch 145/150\n", + "1/1 [==============================] - 0s 50ms/step - loss: 8.2036e-06 - val_loss: 1.0202e-05\n", + "Epoch 146/150\n", + "1/1 [==============================] - 0s 58ms/step - loss: 8.2006e-06 - val_loss: 1.0651e-05\n", + "Epoch 147/150\n", + "1/1 [==============================] - 0s 49ms/step - loss: 8.1913e-06 - val_loss: 1.1321e-05\n", + "Epoch 148/150\n", + "1/1 [==============================] - 0s 59ms/step - loss: 8.1828e-06 - val_loss: 1.2068e-05\n", + "Epoch 149/150\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1/1 [==============================] - 0s 33ms/step - loss: 8.1800e-06 - val_loss: 1.2732e-05\n", + "Epoch 150/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 8.1836e-06 - val_loss: 1.3175e-05\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MSE: 9.859417493404956e-05\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time: 13.58325680200005\n" + ] + } + ], "source": [ "def test_rnn (x1, y_test, plot_min, plot_max):\n", " \"\"\"\n", @@ -542,10 +1107,7 @@ }, { "cell_type": "markdown", - "id": "e9246f10", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Other Things to Try\n", "\n", @@ -564,12 +1126,375 @@ { "cell_type": "code", "execution_count": 5, - "id": "7adcce2b", - "metadata": { - "collapsed": false, - "editable": true - }, - "outputs": [], + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"functional_3\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "input_2 (InputLayer) [(None, 2, 1)] 0 \n", + "_________________________________________________________________\n", + "RNN1 (SimpleRNN) (None, 2, 500) 251000 \n", + "_________________________________________________________________\n", + "RNN2 (SimpleRNN) (None, 500) 500500 \n", + "_________________________________________________________________\n", + "dense (Dense) (None, 1) 501 \n", + "=================================================================\n", + "Total params: 752,001\n", + "Trainable params: 752,001\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n", + "Epoch 1/150\n", + "1/1 [==============================] - 0s 412ms/step - loss: 0.7929 - val_loss: 4.2304\n", + "Epoch 2/150\n", + "1/1 [==============================] - 0s 34ms/step - loss: 6.1896 - val_loss: 0.2852\n", + "Epoch 3/150\n", + "1/1 [==============================] - 0s 63ms/step - loss: 0.9566 - val_loss: 1.5611\n", + "Epoch 4/150\n", + "1/1 [==============================] - 0s 26ms/step - loss: 0.7265 - val_loss: 4.2267\n", + "Epoch 5/150\n", + "1/1 [==============================] - 0s 46ms/step - loss: 2.7122 - val_loss: 3.2776\n", + "Epoch 6/150\n", + "1/1 [==============================] - 0s 98ms/step - loss: 1.9700 - val_loss: 1.1291\n", + "Epoch 7/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 0.4521 - val_loss: 0.0508\n", + "Epoch 8/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 0.0805 - val_loss: 0.1618\n", + "Epoch 9/150\n", + "1/1 [==============================] - 0s 51ms/step - loss: 0.7219 - val_loss: 0.4477\n", + "Epoch 10/150\n", + "1/1 [==============================] - 0s 150ms/step - loss: 1.2333 - val_loss: 0.3424\n", + "Epoch 11/150\n", + "1/1 [==============================] - 0s 60ms/step - loss: 1.0571 - val_loss: 0.0631\n", + "Epoch 12/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 0.4957 - val_loss: 0.0421\n", + "Epoch 13/150\n", + "1/1 [==============================] - 0s 47ms/step - loss: 0.0891 - val_loss: 0.4318\n", + "Epoch 14/150\n", + "1/1 [==============================] - 0s 45ms/step - loss: 0.0970 - val_loss: 0.9960\n", + "Epoch 15/150\n", + "1/1 [==============================] - 0s 97ms/step - loss: 0.3734 - val_loss: 1.3523\n", + "Epoch 16/150\n", + "1/1 [==============================] - 0s 53ms/step - loss: 0.5905 - val_loss: 1.3009\n", + "Epoch 17/150\n", + "1/1 [==============================] - 0s 45ms/step - loss: 0.5579 - val_loss: 0.9301\n", + "Epoch 18/150\n", + "1/1 [==============================] - 0s 52ms/step - loss: 0.3358 - val_loss: 0.4811\n", + "Epoch 19/150\n", + "1/1 [==============================] - 0s 91ms/step - loss: 0.1155 - val_loss: 0.1573\n", + "Epoch 20/150\n", + "1/1 [==============================] - 0s 112ms/step - loss: 0.0425 - val_loss: 0.0190\n", + "Epoch 21/150\n", + "1/1 [==============================] - 0s 55ms/step - loss: 0.1228 - val_loss: 0.0012\n", + "Epoch 22/150\n", + "1/1 [==============================] - 0s 186ms/step - loss: 0.2506 - val_loss: 0.0092\n", + "Epoch 23/150\n", + "1/1 [==============================] - 0s 217ms/step - loss: 0.3100 - val_loss: 0.0021\n", + "Epoch 24/150\n", + "1/1 [==============================] - 0s 124ms/step - loss: 0.2612 - val_loss: 0.0083\n", + "Epoch 25/150\n", + "1/1 [==============================] - 0s 227ms/step - loss: 0.1513 - val_loss: 0.0786\n", + "Epoch 26/150\n", + "1/1 [==============================] - 0s 97ms/step - loss: 0.0619 - val_loss: 0.2292\n", + "Epoch 27/150\n", + "1/1 [==============================] - 0s 138ms/step - loss: 0.0450 - val_loss: 0.4176\n", + "Epoch 28/150\n", + "1/1 [==============================] - 0s 93ms/step - loss: 0.0921 - val_loss: 0.5661\n", + "Epoch 29/150\n", + "1/1 [==============================] - 0s 186ms/step - loss: 0.1510 - val_loss: 0.6115\n", + "Epoch 30/150\n", + "1/1 [==============================] - 0s 80ms/step - loss: 0.1715 - val_loss: 0.5429\n", + "Epoch 31/150\n", + "1/1 [==============================] - 0s 134ms/step - loss: 0.1410 - val_loss: 0.4008\n", + "Epoch 32/150\n", + "1/1 [==============================] - 0s 181ms/step - loss: 0.0864 - val_loss: 0.2473\n", + "Epoch 33/150\n", + "1/1 [==============================] - 0s 83ms/step - loss: 0.0474 - val_loss: 0.1291\n", + "Epoch 34/150\n", + "1/1 [==============================] - 0s 91ms/step - loss: 0.0456 - val_loss: 0.0612\n", + "Epoch 35/150\n", + "1/1 [==============================] - 0s 80ms/step - loss: 0.0721 - val_loss: 0.0329\n", + "Epoch 36/150\n", + "1/1 [==============================] - 0s 49ms/step - loss: 0.0995 - val_loss: 0.0291\n", + "Epoch 37/150\n", + "1/1 [==============================] - 0s 189ms/step - loss: 0.1048 - val_loss: 0.0450\n", + "Epoch 38/150\n", + "1/1 [==============================] - 0s 189ms/step - loss: 0.0856 - val_loss: 0.0857\n", + "Epoch 39/150\n", + "1/1 [==============================] - 0s 136ms/step - loss: 0.0583 - val_loss: 0.1540\n", + "Epoch 40/150\n", + "1/1 [==============================] - 0s 163ms/step - loss: 0.0425 - val_loss: 0.2389\n", + "Epoch 41/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0462 - val_loss: 0.3159\n", + "Epoch 42/150\n", + "1/1 [==============================] - 0s 95ms/step - loss: 0.0615 - val_loss: 0.3585\n", + "Epoch 43/150\n", + "1/1 [==============================] - 0s 67ms/step - loss: 0.0731 - val_loss: 0.3531\n", + "Epoch 44/150\n", + "1/1 [==============================] - 0s 241ms/step - loss: 0.0715 - val_loss: 0.3059\n", + "Epoch 45/150\n", + "1/1 [==============================] - 0s 125ms/step - loss: 0.0590 - val_loss: 0.2375\n", + "Epoch 46/150\n", + "1/1 [==============================] - 0s 217ms/step - loss: 0.0460 - val_loss: 0.1710\n", + "Epoch 47/150\n", + "1/1 [==============================] - 0s 86ms/step - loss: 0.0417 - val_loss: 0.1212\n", + "Epoch 48/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0470 - val_loss: 0.0930\n", + "Epoch 49/150\n", + "1/1 [==============================] - 0s 125ms/step - loss: 0.0551 - val_loss: 0.0851\n", + "Epoch 50/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 0.0584 - val_loss: 0.0952\n", + "Epoch 51/150\n", + "1/1 [==============================] - 0s 51ms/step - loss: 0.0543 - val_loss: 0.1219\n", + "Epoch 52/150\n", + "1/1 [==============================] - 0s 98ms/step - loss: 0.0468 - val_loss: 0.1618\n", + "Epoch 53/150\n", + "1/1 [==============================] - 0s 99ms/step - loss: 0.0419 - val_loss: 0.2067\n", + "Epoch 54/150\n", + "1/1 [==============================] - 0s 118ms/step - loss: 0.0427 - val_loss: 0.2445\n", + "Epoch 55/150\n", + "1/1 [==============================] - 0s 107ms/step - loss: 0.0470 - val_loss: 0.2637\n", + "Epoch 56/150\n", + "1/1 [==============================] - 0s 111ms/step - loss: 0.0501 - val_loss: 0.2591\n", + "Epoch 57/150\n", + "1/1 [==============================] - 0s 84ms/step - loss: 0.0493 - val_loss: 0.2344\n", + "Epoch 58/150\n", + "1/1 [==============================] - 0s 68ms/step - loss: 0.0456 - val_loss: 0.1993\n", + "Epoch 59/150\n", + "1/1 [==============================] - 0s 43ms/step - loss: 0.0422 - val_loss: 0.1650\n", + "Epoch 60/150\n", + "1/1 [==============================] - 0s 41ms/step - loss: 0.0417 - val_loss: 0.1392\n", + "Epoch 61/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0438 - val_loss: 0.1258\n", + "Epoch 62/150\n", + "1/1 [==============================] - 0s 53ms/step - loss: 0.0458 - val_loss: 0.1253\n", + "Epoch 63/150\n", + "1/1 [==============================] - 0s 49ms/step - loss: 0.0459 - val_loss: 0.1368\n", + "Epoch 64/150\n", + "1/1 [==============================] - 0s 43ms/step - loss: 0.0440 - val_loss: 0.1574\n", + "Epoch 65/150\n", + "1/1 [==============================] - ETA: 0s - loss: 0.042 - 0s 41ms/step - loss: 0.0420 - val_loss: 0.1823\n", + "Epoch 66/150\n", + "1/1 [==============================] - 0s 37ms/step - loss: 0.0415 - val_loss: 0.2050\n", + "Epoch 67/150\n", + "1/1 [==============================] - 0s 72ms/step - loss: 0.0425 - val_loss: 0.2189\n", + "Epoch 68/150\n", + "1/1 [==============================] - 0s 50ms/step - loss: 0.0437 - val_loss: 0.2203\n", + "Epoch 69/150\n", + "1/1 [==============================] - 0s 47ms/step - loss: 0.0438 - val_loss: 0.2098\n", + "Epoch 70/150\n", + "1/1 [==============================] - 0s 41ms/step - loss: 0.0429 - val_loss: 0.1918\n", + "Epoch 71/150\n", + "1/1 [==============================] - 0s 60ms/step - loss: 0.0417 - val_loss: 0.1723\n", + "Epoch 72/150\n", + "1/1 [==============================] - ETA: 0s - loss: 0.041 - 0s 52ms/step - loss: 0.0414 - val_loss: 0.1565\n", + "Epoch 73/150\n", + "1/1 [==============================] - 0s 87ms/step - loss: 0.0420 - val_loss: 0.1478\n", + "Epoch 74/150\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1/1 [==============================] - 0s 88ms/step - loss: 0.0426 - val_loss: 0.1472\n", + "Epoch 75/150\n", + "1/1 [==============================] - 0s 72ms/step - loss: 0.0427 - val_loss: 0.1543\n", + "Epoch 76/150\n", + "1/1 [==============================] - 0s 33ms/step - loss: 0.0421 - val_loss: 0.1667\n", + "Epoch 77/150\n", + "1/1 [==============================] - 0s 49ms/step - loss: 0.0415 - val_loss: 0.1809\n", + "Epoch 78/150\n", + "1/1 [==============================] - 0s 72ms/step - loss: 0.0414 - val_loss: 0.1930\n", + "Epoch 79/150\n", + "1/1 [==============================] - 0s 46ms/step - loss: 0.0417 - val_loss: 0.1994\n", + "Epoch 80/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 0.0420 - val_loss: 0.1985\n", + "Epoch 81/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0420 - val_loss: 0.1913\n", + "Epoch 82/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 0.0416 - val_loss: 0.1806\n", + "Epoch 83/150\n", + "1/1 [==============================] - 0s 43ms/step - loss: 0.0413 - val_loss: 0.1699\n", + "Epoch 84/150\n", + "1/1 [==============================] - 0s 37ms/step - loss: 0.0413 - val_loss: 0.1620\n", + "Epoch 85/150\n", + "1/1 [==============================] - 0s 44ms/step - loss: 0.0415 - val_loss: 0.1589\n", + "Epoch 86/150\n", + "1/1 [==============================] - 0s 43ms/step - loss: 0.0417 - val_loss: 0.1608\n", + "Epoch 87/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0416 - val_loss: 0.1667\n", + "Epoch 88/150\n", + "1/1 [==============================] - 0s 41ms/step - loss: 0.0413 - val_loss: 0.1748\n", + "Epoch 89/150\n", + "1/1 [==============================] - 0s 36ms/step - loss: 0.0412 - val_loss: 0.1825\n", + "Epoch 90/150\n", + "1/1 [==============================] - 0s 37ms/step - loss: 0.0413 - val_loss: 0.1875\n", + "Epoch 91/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0414 - val_loss: 0.1884\n", + "Epoch 92/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0414 - val_loss: 0.1853\n", + "Epoch 93/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0413 - val_loss: 0.1795\n", + "Epoch 94/150\n", + "1/1 [==============================] - 0s 31ms/step - loss: 0.0412 - val_loss: 0.1731\n", + "Epoch 95/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0411 - val_loss: 0.1680\n", + "Epoch 96/150\n", + "1/1 [==============================] - 0s 37ms/step - loss: 0.0412 - val_loss: 0.1656\n", + "Epoch 97/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 0.0412 - val_loss: 0.1663\n", + "Epoch 98/150\n", + "1/1 [==============================] - 0s 36ms/step - loss: 0.0412 - val_loss: 0.1696\n", + "Epoch 99/150\n", + "1/1 [==============================] - 0s 43ms/step - loss: 0.0411 - val_loss: 0.1743\n", + "Epoch 100/150\n", + "1/1 [==============================] - 0s 48ms/step - loss: 0.0411 - val_loss: 0.1788\n", + "Epoch 101/150\n", + "1/1 [==============================] - 0s 44ms/step - loss: 0.0411 - val_loss: 0.1817\n", + "Epoch 102/150\n", + "1/1 [==============================] - 0s 43ms/step - loss: 0.0411 - val_loss: 0.1821\n", + "Epoch 103/150\n", + "1/1 [==============================] - 0s 25ms/step - loss: 0.0411 - val_loss: 0.1802\n", + "Epoch 104/150\n", + "1/1 [==============================] - 0s 44ms/step - loss: 0.0411 - val_loss: 0.1767\n", + "Epoch 105/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0410 - val_loss: 0.1729\n", + "Epoch 106/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0410 - val_loss: 0.1701\n", + "Epoch 107/150\n", + "1/1 [==============================] - 0s 42ms/step - loss: 0.0410 - val_loss: 0.1690\n", + "Epoch 108/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0410 - val_loss: 0.1697\n", + "Epoch 109/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0410 - val_loss: 0.1719\n", + "Epoch 110/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0409 - val_loss: 0.1748\n", + "Epoch 111/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 0.0409 - val_loss: 0.1772\n", + "Epoch 112/150\n", + "1/1 [==============================] - 0s 46ms/step - loss: 0.0409 - val_loss: 0.1784\n", + "Epoch 113/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0409 - val_loss: 0.1781\n", + "Epoch 114/150\n", + "1/1 [==============================] - 0s 34ms/step - loss: 0.0409 - val_loss: 0.1765\n", + "Epoch 115/150\n", + "1/1 [==============================] - 0s 43ms/step - loss: 0.0409 - val_loss: 0.1743\n", + "Epoch 116/150\n", + "1/1 [==============================] - 0s 57ms/step - loss: 0.0408 - val_loss: 0.1721\n", + "Epoch 117/150\n", + "1/1 [==============================] - 0s 41ms/step - loss: 0.0408 - val_loss: 0.1708\n", + "Epoch 118/150\n", + "1/1 [==============================] - 0s 31ms/step - loss: 0.0408 - val_loss: 0.1707\n", + "Epoch 119/150\n", + "1/1 [==============================] - 0s 34ms/step - loss: 0.0408 - val_loss: 0.1716\n", + "Epoch 120/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0408 - val_loss: 0.1732\n", + "Epoch 121/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0408 - val_loss: 0.1748\n", + "Epoch 122/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0408 - val_loss: 0.1758\n", + "Epoch 123/150\n", + "1/1 [==============================] - 0s 44ms/step - loss: 0.0408 - val_loss: 0.1760\n", + "Epoch 124/150\n", + "1/1 [==============================] - 0s 41ms/step - loss: 0.0407 - val_loss: 0.1753\n", + "Epoch 125/150\n", + "1/1 [==============================] - 0s 36ms/step - loss: 0.0407 - val_loss: 0.1740\n", + "Epoch 126/150\n", + "1/1 [==============================] - 0s 45ms/step - loss: 0.0407 - val_loss: 0.1726\n", + "Epoch 127/150\n", + "1/1 [==============================] - 0s 48ms/step - loss: 0.0407 - val_loss: 0.1716\n", + "Epoch 128/150\n", + "1/1 [==============================] - 0s 49ms/step - loss: 0.0407 - val_loss: 0.1713\n", + "Epoch 129/150\n", + "1/1 [==============================] - 0s 42ms/step - loss: 0.0407 - val_loss: 0.1717\n", + "Epoch 130/150\n", + "1/1 [==============================] - 0s 45ms/step - loss: 0.0406 - val_loss: 0.1726\n", + "Epoch 131/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 0.0406 - val_loss: 0.1735\n", + "Epoch 132/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 0.0406 - val_loss: 0.1742\n", + "Epoch 133/150\n", + "1/1 [==============================] - 0s 36ms/step - loss: 0.0406 - val_loss: 0.1743\n", + "Epoch 134/150\n", + "1/1 [==============================] - 0s 36ms/step - loss: 0.0406 - val_loss: 0.1739\n", + "Epoch 135/150\n", + "1/1 [==============================] - 0s 37ms/step - loss: 0.0406 - val_loss: 0.1731\n", + "Epoch 136/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0405 - val_loss: 0.1722\n", + "Epoch 137/150\n", + "1/1 [==============================] - 0s 31ms/step - loss: 0.0405 - val_loss: 0.1716\n", + "Epoch 138/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 0.0405 - val_loss: 0.1714\n", + "Epoch 139/150\n", + "1/1 [==============================] - 0s 33ms/step - loss: 0.0405 - val_loss: 0.1716\n", + "Epoch 140/150\n", + "1/1 [==============================] - 0s 34ms/step - loss: 0.0405 - val_loss: 0.1721\n", + "Epoch 141/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 0.0405 - val_loss: 0.1726\n", + "Epoch 142/150\n", + "1/1 [==============================] - 0s 24ms/step - loss: 0.0404 - val_loss: 0.1730\n", + "Epoch 143/150\n", + "1/1 [==============================] - 0s 46ms/step - loss: 0.0404 - val_loss: 0.1730\n", + "Epoch 144/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0404 - val_loss: 0.1727\n", + "Epoch 145/150\n", + "1/1 [==============================] - 0s 48ms/step - loss: 0.0404 - val_loss: 0.1722\n", + "Epoch 146/150\n", + "1/1 [==============================] - 0s 45ms/step - loss: 0.0404 - val_loss: 0.1716\n", + "Epoch 147/150\n", + "1/1 [==============================] - 0s 31ms/step - loss: 0.0404 - val_loss: 0.1712\n", + "Epoch 148/150\n", + "1/1 [==============================] - 0s 37ms/step - loss: 0.0403 - val_loss: 0.1711\n", + "Epoch 149/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 0.0403 - val_loss: 0.1712\n", + "Epoch 150/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 0.0403 - val_loss: 0.1715\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MSE: 0.32987443739398026\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time: 16.73896743699993\n" + ] + } + ], "source": [ "def rnn_2layers(length_of_sequences, batch_size = None, stateful = False):\n", " \"\"\"\n", @@ -661,10 +1586,7 @@ }, { "cell_type": "markdown", - "id": "343bbbf8", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Other Types of Recurrent Neural Networks\n", "\n", @@ -687,12 +1609,736 @@ { "cell_type": "code", "execution_count": 6, - "id": "b7d92f8e", - "metadata": { - "collapsed": false, - "editable": true - }, - "outputs": [], + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"functional_5\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "input_3 (InputLayer) [(None, 2, 1)] 0 \n", + "_________________________________________________________________\n", + "dnn (Dense) (None, 2, 125) 250 \n", + "_________________________________________________________________\n", + "dnn1 (Dense) (None, 2, 125) 15750 \n", + "_________________________________________________________________\n", + "RNN1 (GRU) (None, 2, 250) 282750 \n", + "_________________________________________________________________\n", + "RNN (GRU) (None, 250) 376500 \n", + "_________________________________________________________________\n", + "dense (Dense) (None, 1) 251 \n", + "=================================================================\n", + "Total params: 675,501\n", + "Trainable params: 675,501\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n", + "Epoch 1/150\n", + "1/1 [==============================] - 3s 3s/step - loss: 0.2459 - val_loss: 0.5916\n", + "Epoch 2/150\n", + "1/1 [==============================] - 0s 37ms/step - loss: 0.1814 - val_loss: 0.4204\n", + "Epoch 3/150\n", + "1/1 [==============================] - 0s 34ms/step - loss: 0.1217 - val_loss: 0.2498\n", + "Epoch 4/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0651 - val_loss: 0.0961\n", + "Epoch 5/150\n", + "1/1 [==============================] - 0s 37ms/step - loss: 0.0202 - val_loss: 0.0052\n", + "Epoch 6/150\n", + "1/1 [==============================] - 0s 33ms/step - loss: 0.0067 - val_loss: 0.0246\n", + "Epoch 7/150\n", + "1/1 [==============================] - 0s 23ms/step - loss: 0.0370 - val_loss: 0.0467\n", + "Epoch 8/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0512 - val_loss: 0.0230\n", + "Epoch 9/150\n", + "1/1 [==============================] - 0s 47ms/step - loss: 0.0349 - val_loss: 0.0012\n", + "Epoch 10/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 0.0145 - val_loss: 0.0077\n", + "Epoch 11/150\n", + "1/1 [==============================] - 0s 23ms/step - loss: 0.0052 - val_loss: 0.0372\n", + "Epoch 12/150\n", + "1/1 [==============================] - 0s 25ms/step - loss: 0.0074 - val_loss: 0.0711\n", + "Epoch 13/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 0.0148 - val_loss: 0.0945\n", + "Epoch 14/150\n", + "1/1 [==============================] - 0s 33ms/step - loss: 0.0210 - val_loss: 0.1011\n", + "Epoch 15/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 0.0231 - val_loss: 0.0918\n", + "Epoch 16/150\n", + "1/1 [==============================] - 0s 33ms/step - loss: 0.0207 - val_loss: 0.0712\n", + "Epoch 17/150\n", + "1/1 [==============================] - 0s 26ms/step - loss: 0.0153 - val_loss: 0.0460\n", + "Epoch 18/150\n", + "1/1 [==============================] - 0s 25ms/step - loss: 0.0093 - val_loss: 0.0227\n", + "Epoch 19/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 0.0047 - val_loss: 0.0068\n", + "Epoch 20/150\n", + "1/1 [==============================] - 0s 51ms/step - loss: 0.0033 - val_loss: 3.4433e-04\n", + "Epoch 21/150\n", + "1/1 [==============================] - 0s 61ms/step - loss: 0.0049 - val_loss: 9.2360e-04\n", + "Epoch 22/150\n", + "1/1 [==============================] - 0s 36ms/step - loss: 0.0077 - val_loss: 0.0030\n", + "Epoch 23/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 0.0092 - val_loss: 0.0027\n", + "Epoch 24/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 0.0080 - val_loss: 6.9127e-04\n", + "Epoch 25/150\n", + "1/1 [==============================] - 0s 36ms/step - loss: 0.0050 - val_loss: 1.9104e-04\n", + "Epoch 26/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 0.0023 - val_loss: 0.0034\n", + "Epoch 27/150\n", + "1/1 [==============================] - 0s 24ms/step - loss: 0.0013 - val_loss: 0.0094\n", + "Epoch 28/150\n", + "1/1 [==============================] - 0s 23ms/step - loss: 0.0021 - val_loss: 0.0148\n", + "Epoch 29/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 0.0034 - val_loss: 0.0163\n", + "Epoch 30/150\n", + "1/1 [==============================] - 0s 26ms/step - loss: 0.0040 - val_loss: 0.0134\n", + "Epoch 31/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 0.0035 - val_loss: 0.0080\n", + "Epoch 32/150\n", + "1/1 [==============================] - 0s 25ms/step - loss: 0.0021 - val_loss: 0.0028\n", + "Epoch 33/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 7.3969e-04 - val_loss: 1.5004e-04\n", + "Epoch 34/150\n", + "1/1 [==============================] - 0s 34ms/step - loss: 1.6207e-04 - val_loss: 6.6636e-04\n", + "Epoch 35/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 5.1019e-04 - val_loss: 0.0030\n", + "Epoch 36/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 0.0013 - val_loss: 0.0047\n", + "Epoch 37/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 0.0017 - val_loss: 0.0045\n", + "Epoch 38/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 0.0014 - val_loss: 0.0028\n", + "Epoch 39/150\n", + "1/1 [==============================] - 0s 25ms/step - loss: 6.4460e-04 - val_loss: 8.6078e-04\n", + "Epoch 40/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 1.2983e-04 - val_loss: 2.2151e-05\n", + "Epoch 41/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 1.9911e-04 - val_loss: 1.9486e-04\n", + "Epoch 42/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 6.3458e-04 - val_loss: 4.8740e-04\n", + "Epoch 43/150\n", + "1/1 [==============================] - 0s 26ms/step - loss: 9.3033e-04 - val_loss: 3.7949e-04\n", + "Epoch 44/150\n", + "1/1 [==============================] - 0s 25ms/step - loss: 8.5355e-04 - val_loss: 6.7120e-05\n", + "Epoch 45/150\n", + "1/1 [==============================] - 0s 24ms/step - loss: 5.2232e-04 - val_loss: 7.0160e-05\n", + "Epoch 46/150\n", + "1/1 [==============================] - 0s 23ms/step - loss: 2.0992e-04 - val_loss: 6.8212e-04\n", + "Epoch 47/150\n", + "1/1 [==============================] - 0s 24ms/step - loss: 1.2155e-04 - val_loss: 0.0017\n", + "Epoch 48/150\n", + "1/1 [==============================] - 0s 26ms/step - loss: 2.4763e-04 - val_loss: 0.0024\n", + "Epoch 49/150\n", + "1/1 [==============================] - 0s 23ms/step - loss: 4.1076e-04 - val_loss: 0.0024\n", + "Epoch 50/150\n", + "1/1 [==============================] - 0s 23ms/step - loss: 4.4072e-04 - val_loss: 0.0018\n", + "Epoch 51/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 3.1263e-04 - val_loss: 9.0781e-04\n", + "Epoch 52/150\n", + "1/1 [==============================] - 0s 22ms/step - loss: 1.3905e-04 - val_loss: 2.4609e-04\n", + "Epoch 53/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 4.8406e-05 - val_loss: 4.7002e-06\n", + "Epoch 54/150\n", + "1/1 [==============================] - 0s 34ms/step - loss: 7.8703e-05 - val_loss: 6.2516e-05\n", + "Epoch 55/150\n", + "1/1 [==============================] - 0s 54ms/step - loss: 1.6784e-04 - val_loss: 1.7051e-04\n", + "Epoch 56/150\n", + "1/1 [==============================] - 0s 33ms/step - loss: 2.2388e-04 - val_loss: 1.6819e-04\n", + "Epoch 57/150\n", + "1/1 [==============================] - 0s 26ms/step - loss: 1.9981e-04 - val_loss: 7.0431e-05\n", + "Epoch 58/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.2012e-04 - val_loss: 8.4147e-07\n", + "Epoch 59/150\n", + "1/1 [==============================] - 0s 43ms/step - loss: 4.9334e-05 - val_loss: 5.4515e-05\n", + "Epoch 60/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 3.5776e-05 - val_loss: 2.0730e-04\n", + "Epoch 61/150\n", + "1/1 [==============================] - 0s 26ms/step - loss: 7.5536e-05 - val_loss: 3.4037e-04\n", + "Epoch 62/150\n", + "1/1 [==============================] - 0s 25ms/step - loss: 1.2285e-04 - val_loss: 3.4944e-04\n", + "Epoch 63/150\n", + "1/1 [==============================] - 0s 23ms/step - loss: 1.3372e-04 - val_loss: 2.3383e-04\n", + "Epoch 64/150\n", + "1/1 [==============================] - 0s 26ms/step - loss: 1.0235e-04 - val_loss: 8.6398e-05\n", + "Epoch 65/150\n", + "1/1 [==============================] - 0s 48ms/step - loss: 5.9468e-05 - val_loss: 5.2679e-06\n", + "Epoch 66/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 3.9819e-05 - val_loss: 1.6195e-05\n", + "Epoch 67/150\n", + "1/1 [==============================] - 0s 26ms/step - loss: 5.2337e-05 - val_loss: 6.8741e-05\n", + "Epoch 68/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 7.7707e-05 - val_loss: 9.4354e-05\n", + "Epoch 69/150\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1/1 [==============================] - 0s 22ms/step - loss: 8.9585e-05 - val_loss: 6.7121e-05\n", + "Epoch 70/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 7.7443e-05 - val_loss: 1.8356e-05\n", + "Epoch 71/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 5.2544e-05 - val_loss: 9.2296e-07\n", + "Epoch 72/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 3.5097e-05 - val_loss: 3.9134e-05\n", + "Epoch 73/150\n", + "1/1 [==============================] - 0s 36ms/step - loss: 3.5848e-05 - val_loss: 1.0789e-04\n", + "Epoch 74/150\n", + "1/1 [==============================] - 0s 31ms/step - loss: 4.8196e-05 - val_loss: 1.5660e-04\n", + "Epoch 75/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 5.6552e-05 - val_loss: 1.5293e-04\n", + "Epoch 76/150\n", + "1/1 [==============================] - 0s 34ms/step - loss: 5.1625e-05 - val_loss: 1.0569e-04\n", + "Epoch 77/150\n", + "1/1 [==============================] - ETA: 0s - loss: 3.7896e-0 - 0s 70ms/step - loss: 3.7896e-05 - val_loss: 4.9928e-05\n", + "Epoch 78/150\n", + "1/1 [==============================] - 0s 41ms/step - loss: 2.7312e-05 - val_loss: 1.4021e-05\n", + "Epoch 79/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 2.7054e-05 - val_loss: 1.6037e-06\n", + "Epoch 80/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 3.3979e-05 - val_loss: 7.5208e-08\n", + "Epoch 81/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 3.9157e-05 - val_loss: 9.3825e-07\n", + "Epoch 82/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 3.6976e-05 - val_loss: 9.5715e-06\n", + "Epoch 83/150\n", + "1/1 [==============================] - 0s 43ms/step - loss: 2.9646e-05 - val_loss: 3.6446e-05\n", + "Epoch 84/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 2.3816e-05 - val_loss: 8.1070e-05\n", + "Epoch 85/150\n", + "1/1 [==============================] - 0s 23ms/step - loss: 2.3655e-05 - val_loss: 1.2629e-04\n", + "Epoch 86/150\n", + "1/1 [==============================] - 0s 26ms/step - loss: 2.7370e-05 - val_loss: 1.4947e-04\n", + "Epoch 87/150\n", + "1/1 [==============================] - 0s 23ms/step - loss: 2.9688e-05 - val_loss: 1.3981e-04\n", + "Epoch 88/150\n", + "1/1 [==============================] - 0s 26ms/step - loss: 2.7706e-05 - val_loss: 1.0555e-04\n", + "Epoch 89/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 2.3302e-05 - val_loss: 6.5640e-05\n", + "Epoch 90/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 2.0261e-05 - val_loss: 3.5309e-05\n", + "Epoch 91/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 2.0124e-05 - val_loss: 1.8839e-05\n", + "Epoch 92/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 2.0996e-05 - val_loss: 1.3031e-05\n", + "Epoch 93/150\n", + "1/1 [==============================] - 0s 34ms/step - loss: 2.0826e-05 - val_loss: 1.4356e-05\n", + "Epoch 94/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 1.8456e-05 - val_loss: 2.1605e-05\n", + "Epoch 95/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 1.5420e-05 - val_loss: 3.3404e-05\n", + "Epoch 96/150\n", + "1/1 [==============================] - 0s 36ms/step - loss: 1.3717e-05 - val_loss: 4.5286e-05\n", + "Epoch 97/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 1.3811e-05 - val_loss: 5.0996e-05\n", + "Epoch 98/150\n", + "1/1 [==============================] - 0s 44ms/step - loss: 1.4040e-05 - val_loss: 4.6975e-05\n", + "Epoch 99/150\n", + "1/1 [==============================] - 0s 36ms/step - loss: 1.3070e-05 - val_loss: 3.5183e-05\n", + "Epoch 100/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.0985e-05 - val_loss: 2.1387e-05\n", + "Epoch 101/150\n", + "1/1 [==============================] - 0s 41ms/step - loss: 8.9800e-06 - val_loss: 1.0795e-05\n", + "Epoch 102/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 8.0619e-06 - val_loss: 5.0830e-06\n", + "Epoch 103/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 7.9066e-06 - val_loss: 3.0830e-06\n", + "Epoch 104/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 7.5559e-06 - val_loss: 3.3720e-06\n", + "Epoch 105/150\n", + "1/1 [==============================] - 0s 48ms/step - loss: 6.4755e-06 - val_loss: 5.5870e-06\n", + "Epoch 106/150\n", + "1/1 [==============================] - 0s 26ms/step - loss: 5.0697e-06 - val_loss: 9.4721e-06\n", + "Epoch 107/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 4.1050e-06 - val_loss: 1.3526e-05\n", + "Epoch 108/150\n", + "1/1 [==============================] - 0s 42ms/step - loss: 3.8140e-06 - val_loss: 1.5349e-05\n", + "Epoch 109/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 3.7134e-06 - val_loss: 1.3554e-05\n", + "Epoch 110/150\n", + "1/1 [==============================] - 0s 44ms/step - loss: 3.2463e-06 - val_loss: 9.0553e-06\n", + "Epoch 111/150\n", + "1/1 [==============================] - 0s 24ms/step - loss: 2.4171e-06 - val_loss: 4.2990e-06\n", + "Epoch 112/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 1.6975e-06 - val_loss: 1.2437e-06\n", + "Epoch 113/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 1.4188e-06 - val_loss: 1.2897e-07\n", + "Epoch 114/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 1.4262e-06 - val_loss: 2.8905e-09\n", + "Epoch 115/150\n", + "1/1 [==============================] - 0s 25ms/step - loss: 1.4010e-06 - val_loss: 9.3237e-09\n", + "Epoch 116/150\n", + "1/1 [==============================] - 0s 33ms/step - loss: 1.1720e-06 - val_loss: 2.2759e-08\n", + "Epoch 117/150\n", + "1/1 [==============================] - 0s 24ms/step - loss: 8.5655e-07 - val_loss: 2.8287e-07\n", + "Epoch 118/150\n", + "1/1 [==============================] - 0s 24ms/step - loss: 7.0005e-07 - val_loss: 7.5326e-07\n", + "Epoch 119/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 7.4991e-07 - val_loss: 1.0362e-06\n", + "Epoch 120/150\n", + "1/1 [==============================] - 0s 43ms/step - loss: 8.3788e-07 - val_loss: 8.4355e-07\n", + "Epoch 121/150\n", + "1/1 [==============================] - 0s 24ms/step - loss: 8.0805e-07 - val_loss: 3.5684e-07\n", + "Epoch 122/150\n", + "1/1 [==============================] - 0s 24ms/step - loss: 6.8867e-07 - val_loss: 2.4035e-08\n", + "Epoch 123/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 6.1946e-07 - val_loss: 7.6225e-08\n", + "Epoch 124/150\n", + "1/1 [==============================] - 0s 26ms/step - loss: 6.6130e-07 - val_loss: 3.3510e-07\n", + "Epoch 125/150\n", + "1/1 [==============================] - 0s 24ms/step - loss: 7.3329e-07 - val_loss: 4.7476e-07\n", + "Epoch 126/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 7.3150e-07 - val_loss: 3.7326e-07\n", + "Epoch 127/150\n", + "1/1 [==============================] - 0s 23ms/step - loss: 6.5657e-07 - val_loss: 1.6763e-07\n", + "Epoch 128/150\n", + "1/1 [==============================] - 0s 54ms/step - loss: 5.9636e-07 - val_loss: 3.2703e-08\n", + "Epoch 129/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 6.0735e-07 - val_loss: 2.8053e-10\n", + "Epoch 130/150\n", + "1/1 [==============================] - 0s 34ms/step - loss: 6.5086e-07 - val_loss: 7.9485e-10\n", + "Epoch 131/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 6.5255e-07 - val_loss: 2.3137e-09\n", + "Epoch 132/150\n", + "1/1 [==============================] - 0s 37ms/step - loss: 5.9585e-07 - val_loss: 3.9751e-08\n", + "Epoch 133/150\n", + "1/1 [==============================] - 0s 33ms/step - loss: 5.3182e-07 - val_loss: 1.2380e-07\n", + "Epoch 134/150\n", + "1/1 [==============================] - 0s 36ms/step - loss: 5.0810e-07 - val_loss: 1.8855e-07\n", + "Epoch 135/150\n", + "1/1 [==============================] - 0s 25ms/step - loss: 5.1436e-07 - val_loss: 1.6322e-07\n", + "Epoch 136/150\n", + "1/1 [==============================] - 0s 25ms/step - loss: 5.0666e-07 - val_loss: 6.8375e-08\n", + "Epoch 137/150\n", + "1/1 [==============================] - 0s 25ms/step - loss: 4.6750e-07 - val_loss: 2.2341e-09\n", + "Epoch 138/150\n", + "1/1 [==============================] - 0s 47ms/step - loss: 4.2218e-07 - val_loss: 3.0562e-08\n", + "Epoch 139/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 3.9951e-07 - val_loss: 1.1665e-07\n", + "Epoch 140/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 3.9564e-07 - val_loss: 1.7170e-07\n", + "Epoch 141/150\n", + "1/1 [==============================] - 0s 23ms/step - loss: 3.8535e-07 - val_loss: 1.5209e-07\n", + "Epoch 142/150\n", + "1/1 [==============================] - 0s 23ms/step - loss: 3.5834e-07 - val_loss: 9.0639e-08\n", + "Epoch 143/150\n", + "1/1 [==============================] - 0s 25ms/step - loss: 3.3026e-07 - val_loss: 4.0133e-08\n", + "Epoch 144/150\n", + "1/1 [==============================] - 0s 24ms/step - loss: 3.1858e-07 - val_loss: 1.9955e-08\n", + "Epoch 145/150\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1/1 [==============================] - 0s 23ms/step - loss: 3.1980e-07 - val_loss: 2.4949e-08\n", + "Epoch 146/150\n", + "1/1 [==============================] - 0s 22ms/step - loss: 3.1672e-07 - val_loss: 6.4898e-08\n", + "Epoch 147/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 3.0214e-07 - val_loss: 1.6476e-07\n", + "Epoch 148/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 2.8628e-07 - val_loss: 3.2307e-07\n", + "Epoch 149/150\n", + "1/1 [==============================] - 0s 37ms/step - loss: 2.8069e-07 - val_loss: 4.8641e-07\n", + "Epoch 150/150\n", + "1/1 [==============================] - 0s 49ms/step - loss: 2.8351e-07 - val_loss: 5.8262e-07\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MSE: 0.00010894005066464408\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time: 17.877047406999964\n", + "Model: \"functional_7\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "input_4 (InputLayer) [(None, 1, 1)] 0 \n", + "_________________________________________________________________\n", + "RNN (SimpleRNN) (None, 200) 40400 \n", + "_________________________________________________________________\n", + "dense (Dense) (None, 1) 201 \n", + "=================================================================\n", + "Total params: 40,601\n", + "Trainable params: 40,601\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n", + "Epoch 1/150\n", + "1/1 [==============================] - 0s 209ms/step - loss: 0.5978 - val_loss: 0.9408\n", + "Epoch 2/150\n", + "1/1 [==============================] - 0s 31ms/step - loss: 0.3017 - val_loss: 0.4897\n", + "Epoch 3/150\n", + "1/1 [==============================] - 0s 54ms/step - loss: 0.1129 - val_loss: 0.1984\n", + "Epoch 4/150\n", + "1/1 [==============================] - 0s 44ms/step - loss: 0.0251 - val_loss: 0.0485\n", + "Epoch 5/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 0.0195 - val_loss: 0.0017\n", + "Epoch 6/150\n", + "1/1 [==============================] - 0s 34ms/step - loss: 0.0619 - val_loss: 0.0066\n", + "Epoch 7/150\n", + "1/1 [==============================] - 0s 36ms/step - loss: 0.1122 - val_loss: 0.0206\n", + "Epoch 8/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 0.1420 - val_loss: 0.0235\n", + "Epoch 9/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.1424 - val_loss: 0.0148\n", + "Epoch 10/150\n", + "1/1 [==============================] - 0s 44ms/step - loss: 0.1192 - val_loss: 0.0036\n", + "Epoch 11/150\n", + "1/1 [==============================] - 0s 37ms/step - loss: 0.0838 - val_loss: 5.1260e-04\n", + "Epoch 12/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 0.0481 - val_loss: 0.0134\n", + "Epoch 13/150\n", + "1/1 [==============================] - 0s 24ms/step - loss: 0.0210 - val_loss: 0.0445\n", + "Epoch 14/150\n", + "1/1 [==============================] - 0s 37ms/step - loss: 0.0073 - val_loss: 0.0900\n", + "Epoch 15/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 0.0072 - val_loss: 0.1409\n", + "Epoch 16/150\n", + "1/1 [==============================] - 0s 23ms/step - loss: 0.0170 - val_loss: 0.1862\n", + "Epoch 17/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 0.0305 - val_loss: 0.2160\n", + "Epoch 18/150\n", + "1/1 [==============================] - 0s 24ms/step - loss: 0.0417 - val_loss: 0.2246\n", + "Epoch 19/150\n", + "1/1 [==============================] - 0s 31ms/step - loss: 0.0464 - val_loss: 0.2121\n", + "Epoch 20/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 0.0436 - val_loss: 0.1827\n", + "Epoch 21/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 0.0348 - val_loss: 0.1436\n", + "Epoch 22/150\n", + "1/1 [==============================] - 0s 31ms/step - loss: 0.0232 - val_loss: 0.1024\n", + "Epoch 23/150\n", + "1/1 [==============================] - 0s 36ms/step - loss: 0.0124 - val_loss: 0.0656\n", + "Epoch 24/150\n", + "1/1 [==============================] - 0s 42ms/step - loss: 0.0050 - val_loss: 0.0370\n", + "Epoch 25/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 0.0024 - val_loss: 0.0180\n", + "Epoch 26/150\n", + "1/1 [==============================] - 0s 41ms/step - loss: 0.0042 - val_loss: 0.0073\n", + "Epoch 27/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 0.0086 - val_loss: 0.0025\n", + "Epoch 28/150\n", + "1/1 [==============================] - 0s 36ms/step - loss: 0.0134 - val_loss: 8.6603e-04\n", + "Epoch 29/150\n", + "1/1 [==============================] - 0s 23ms/step - loss: 0.0165 - val_loss: 5.6722e-04\n", + "Epoch 30/150\n", + "1/1 [==============================] - 0s 36ms/step - loss: 0.0169 - val_loss: 0.0010\n", + "Epoch 31/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0147 - val_loss: 0.0028\n", + "Epoch 32/150\n", + "1/1 [==============================] - 0s 22ms/step - loss: 0.0108 - val_loss: 0.0066\n", + "Epoch 33/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 0.0066 - val_loss: 0.0134\n", + "Epoch 34/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0035 - val_loss: 0.0228\n", + "Epoch 35/150\n", + "1/1 [==============================] - 0s 31ms/step - loss: 0.0022 - val_loss: 0.0338\n", + "Epoch 36/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 0.0027 - val_loss: 0.0446\n", + "Epoch 37/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 0.0044 - val_loss: 0.0532\n", + "Epoch 38/150\n", + "1/1 [==============================] - 0s 25ms/step - loss: 0.0062 - val_loss: 0.0579\n", + "Epoch 39/150\n", + "1/1 [==============================] - 0s 34ms/step - loss: 0.0075 - val_loss: 0.0580\n", + "Epoch 40/150\n", + "1/1 [==============================] - 0s 25ms/step - loss: 0.0076 - val_loss: 0.0538\n", + "Epoch 41/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 0.0066 - val_loss: 0.0465\n", + "Epoch 42/150\n", + "1/1 [==============================] - 0s 31ms/step - loss: 0.0050 - val_loss: 0.0376\n", + "Epoch 43/150\n", + "1/1 [==============================] - 0s 46ms/step - loss: 0.0034 - val_loss: 0.0288\n", + "Epoch 44/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 0.0023 - val_loss: 0.0213\n", + "Epoch 45/150\n", + "1/1 [==============================] - 0s 37ms/step - loss: 0.0020 - val_loss: 0.0155\n", + "Epoch 46/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 0.0024 - val_loss: 0.0116\n", + "Epoch 47/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 0.0032 - val_loss: 0.0095\n", + "Epoch 48/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 0.0038 - val_loss: 0.0088\n", + "Epoch 49/150\n", + "1/1 [==============================] - 0s 36ms/step - loss: 0.0040 - val_loss: 0.0094\n", + "Epoch 50/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 0.0038 - val_loss: 0.0113\n", + "Epoch 51/150\n", + "1/1 [==============================] - 0s 26ms/step - loss: 0.0032 - val_loss: 0.0143\n", + "Epoch 52/150\n", + "1/1 [==============================] - 0s 36ms/step - loss: 0.0025 - val_loss: 0.0183\n", + "Epoch 53/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 0.0019 - val_loss: 0.0230\n", + "Epoch 54/150\n", + "1/1 [==============================] - 0s 33ms/step - loss: 0.0017 - val_loss: 0.0278\n", + "Epoch 55/150\n", + "1/1 [==============================] - 0s 36ms/step - loss: 0.0018 - val_loss: 0.0319\n", + "Epoch 56/150\n", + "1/1 [==============================] - 0s 47ms/step - loss: 0.0021 - val_loss: 0.0347\n", + "Epoch 57/150\n", + "1/1 [==============================] - 0s 36ms/step - loss: 0.0024 - val_loss: 0.0359\n", + "Epoch 58/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0025 - val_loss: 0.0353\n", + "Epoch 59/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 0.0024 - val_loss: 0.0333\n", + "Epoch 60/150\n", + "1/1 [==============================] - 0s 41ms/step - loss: 0.0021 - val_loss: 0.0302\n", + "Epoch 61/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 0.0018 - val_loss: 0.0268\n", + "Epoch 62/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 0.0016 - val_loss: 0.0235\n", + "Epoch 63/150\n", + "1/1 [==============================] - 0s 50ms/step - loss: 0.0015 - val_loss: 0.0207\n", + "Epoch 64/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 0.0016 - val_loss: 0.0187\n", + "Epoch 65/150\n", + "1/1 [==============================] - 0s 25ms/step - loss: 0.0017 - val_loss: 0.0176\n", + "Epoch 66/150\n", + "1/1 [==============================] - 0s 56ms/step - loss: 0.0018 - val_loss: 0.0173\n", + "Epoch 67/150\n", + "1/1 [==============================] - 0s 95ms/step - loss: 0.0018 - val_loss: 0.0178\n", + "Epoch 68/150\n", + "1/1 [==============================] - 0s 48ms/step - loss: 0.0017 - val_loss: 0.0190\n", + "Epoch 69/150\n", + "1/1 [==============================] - 0s 75ms/step - loss: 0.0016 - val_loss: 0.0207\n", + "Epoch 70/150\n", + "1/1 [==============================] - 0s 108ms/step - loss: 0.0015 - val_loss: 0.0227\n", + "Epoch 71/150\n", + "1/1 [==============================] - 0s 97ms/step - loss: 0.0014 - val_loss: 0.0246\n", + "Epoch 72/150\n", + "1/1 [==============================] - 0s 36ms/step - loss: 0.0014 - val_loss: 0.0262\n", + "Epoch 73/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 0.0014 - val_loss: 0.0273\n", + "Epoch 74/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0015 - val_loss: 0.0275\n", + "Epoch 75/150\n", + "1/1 [==============================] - 0s 91ms/step - loss: 0.0015 - val_loss: 0.0271\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 76/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 0.0015 - val_loss: 0.0260\n", + "Epoch 77/150\n", + "1/1 [==============================] - 0s 34ms/step - loss: 0.0014 - val_loss: 0.0245\n", + "Epoch 78/150\n", + "1/1 [==============================] - 0s 20ms/step - loss: 0.0013 - val_loss: 0.0228\n", + "Epoch 79/150\n", + "1/1 [==============================] - 0s 22ms/step - loss: 0.0013 - val_loss: 0.0212\n", + "Epoch 80/150\n", + "1/1 [==============================] - 0s 26ms/step - loss: 0.0013 - val_loss: 0.0198\n", + "Epoch 81/150\n", + "1/1 [==============================] - 0s 20ms/step - loss: 0.0013 - val_loss: 0.0188\n", + "Epoch 82/150\n", + "1/1 [==============================] - 0s 19ms/step - loss: 0.0013 - val_loss: 0.0183\n", + "Epoch 83/150\n", + "1/1 [==============================] - 0s 23ms/step - loss: 0.0013 - val_loss: 0.0181\n", + "Epoch 84/150\n", + "1/1 [==============================] - 0s 20ms/step - loss: 0.0013 - val_loss: 0.0184\n", + "Epoch 85/150\n", + "1/1 [==============================] - 0s 20ms/step - loss: 0.0012 - val_loss: 0.0189\n", + "Epoch 86/150\n", + "1/1 [==============================] - 0s 19ms/step - loss: 0.0012 - val_loss: 0.0196\n", + "Epoch 87/150\n", + "1/1 [==============================] - 0s 20ms/step - loss: 0.0012 - val_loss: 0.0202\n", + "Epoch 88/150\n", + "1/1 [==============================] - 0s 23ms/step - loss: 0.0012 - val_loss: 0.0208\n", + "Epoch 89/150\n", + "1/1 [==============================] - 0s 20ms/step - loss: 0.0012 - val_loss: 0.0211\n", + "Epoch 90/150\n", + "1/1 [==============================] - 0s 19ms/step - loss: 0.0012 - val_loss: 0.0212\n", + "Epoch 91/150\n", + "1/1 [==============================] - 0s 22ms/step - loss: 0.0012 - val_loss: 0.0209\n", + "Epoch 92/150\n", + "1/1 [==============================] - 0s 22ms/step - loss: 0.0011 - val_loss: 0.0203\n", + "Epoch 93/150\n", + "1/1 [==============================] - 0s 20ms/step - loss: 0.0011 - val_loss: 0.0196\n", + "Epoch 94/150\n", + "1/1 [==============================] - 0s 21ms/step - loss: 0.0011 - val_loss: 0.0188\n", + "Epoch 95/150\n", + "1/1 [==============================] - 0s 18ms/step - loss: 0.0011 - val_loss: 0.0180\n", + "Epoch 96/150\n", + "1/1 [==============================] - 0s 20ms/step - loss: 0.0011 - val_loss: 0.0174\n", + "Epoch 97/150\n", + "1/1 [==============================] - 0s 20ms/step - loss: 0.0011 - val_loss: 0.0170\n", + "Epoch 98/150\n", + "1/1 [==============================] - 0s 20ms/step - loss: 0.0011 - val_loss: 0.0167\n", + "Epoch 99/150\n", + "1/1 [==============================] - 0s 20ms/step - loss: 0.0011 - val_loss: 0.0167\n", + "Epoch 100/150\n", + "1/1 [==============================] - 0s 20ms/step - loss: 0.0010 - val_loss: 0.0168\n", + "Epoch 101/150\n", + "1/1 [==============================] - 0s 19ms/step - loss: 0.0010 - val_loss: 0.0170\n", + "Epoch 102/150\n", + "1/1 [==============================] - 0s 20ms/step - loss: 0.0010 - val_loss: 0.0173\n", + "Epoch 103/150\n", + "1/1 [==============================] - 0s 22ms/step - loss: 0.0010 - val_loss: 0.0175\n", + "Epoch 104/150\n", + "1/1 [==============================] - 0s 21ms/step - loss: 9.9409e-04 - val_loss: 0.0177\n", + "Epoch 105/150\n", + "1/1 [==============================] - 0s 24ms/step - loss: 9.8795e-04 - val_loss: 0.0177\n", + "Epoch 106/150\n", + "1/1 [==============================] - 0s 26ms/step - loss: 9.8146e-04 - val_loss: 0.0176\n", + "Epoch 107/150\n", + "1/1 [==============================] - 0s 22ms/step - loss: 9.7321e-04 - val_loss: 0.0174\n", + "Epoch 108/150\n", + "1/1 [==============================] - 0s 21ms/step - loss: 9.6321e-04 - val_loss: 0.0171\n", + "Epoch 109/150\n", + "1/1 [==============================] - 0s 23ms/step - loss: 9.5266e-04 - val_loss: 0.0167\n", + "Epoch 110/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 9.4298e-04 - val_loss: 0.0163\n", + "Epoch 111/150\n", + "1/1 [==============================] - 0s 23ms/step - loss: 9.3489e-04 - val_loss: 0.0160\n", + "Epoch 112/150\n", + "1/1 [==============================] - 0s 21ms/step - loss: 9.2814e-04 - val_loss: 0.0157\n", + "Epoch 113/150\n", + "1/1 [==============================] - 0s 20ms/step - loss: 9.2177e-04 - val_loss: 0.0156\n", + "Epoch 114/150\n", + "1/1 [==============================] - 0s 20ms/step - loss: 9.1486e-04 - val_loss: 0.0155\n", + "Epoch 115/150\n", + "1/1 [==============================] - 0s 19ms/step - loss: 9.0708e-04 - val_loss: 0.0156\n", + "Epoch 116/150\n", + "1/1 [==============================] - 0s 22ms/step - loss: 8.9881e-04 - val_loss: 0.0156\n", + "Epoch 117/150\n", + "1/1 [==============================] - 0s 19ms/step - loss: 8.9075e-04 - val_loss: 0.0157\n", + "Epoch 118/150\n", + "1/1 [==============================] - 0s 21ms/step - loss: 8.8344e-04 - val_loss: 0.0158\n", + "Epoch 119/150\n", + "1/1 [==============================] - 0s 21ms/step - loss: 8.7692e-04 - val_loss: 0.0158\n", + "Epoch 120/150\n", + "1/1 [==============================] - 0s 18ms/step - loss: 8.7082e-04 - val_loss: 0.0158\n", + "Epoch 121/150\n", + "1/1 [==============================] - 0s 19ms/step - loss: 8.6463e-04 - val_loss: 0.0156\n", + "Epoch 122/150\n", + "1/1 [==============================] - 0s 19ms/step - loss: 8.5807e-04 - val_loss: 0.0155\n", + "Epoch 123/150\n", + "1/1 [==============================] - 0s 19ms/step - loss: 8.5123e-04 - val_loss: 0.0153\n", + "Epoch 124/150\n", + "1/1 [==============================] - 0s 19ms/step - loss: 8.4443e-04 - val_loss: 0.0150\n", + "Epoch 125/150\n", + "1/1 [==============================] - 0s 19ms/step - loss: 8.3799e-04 - val_loss: 0.0148\n", + "Epoch 126/150\n", + "1/1 [==============================] - 0s 18ms/step - loss: 8.3199e-04 - val_loss: 0.0146\n", + "Epoch 127/150\n", + "1/1 [==============================] - 0s 19ms/step - loss: 8.2629e-04 - val_loss: 0.0145\n", + "Epoch 128/150\n", + "1/1 [==============================] - 0s 20ms/step - loss: 8.2064e-04 - val_loss: 0.0144\n", + "Epoch 129/150\n", + "1/1 [==============================] - 0s 18ms/step - loss: 8.1485e-04 - val_loss: 0.0143\n", + "Epoch 130/150\n", + "1/1 [==============================] - 0s 18ms/step - loss: 8.0893e-04 - val_loss: 0.0143\n", + "Epoch 131/150\n", + "1/1 [==============================] - 0s 20ms/step - loss: 8.0304e-04 - val_loss: 0.0143\n", + "Epoch 132/150\n", + "1/1 [==============================] - 0s 21ms/step - loss: 7.9735e-04 - val_loss: 0.0143\n", + "Epoch 133/150\n", + "1/1 [==============================] - 0s 19ms/step - loss: 7.9190e-04 - val_loss: 0.0143\n", + "Epoch 134/150\n", + "1/1 [==============================] - 0s 20ms/step - loss: 7.8665e-04 - val_loss: 0.0142\n", + "Epoch 135/150\n", + "1/1 [==============================] - 0s 19ms/step - loss: 7.8146e-04 - val_loss: 0.0141\n", + "Epoch 136/150\n", + "1/1 [==============================] - 0s 19ms/step - loss: 7.7625e-04 - val_loss: 0.0140\n", + "Epoch 137/150\n", + "1/1 [==============================] - 0s 19ms/step - loss: 7.7100e-04 - val_loss: 0.0138\n", + "Epoch 138/150\n", + "1/1 [==============================] - 0s 19ms/step - loss: 7.6578e-04 - val_loss: 0.0137\n", + "Epoch 139/150\n", + "1/1 [==============================] - 0s 20ms/step - loss: 7.6069e-04 - val_loss: 0.0135\n", + "Epoch 140/150\n", + "1/1 [==============================] - 0s 20ms/step - loss: 7.5574e-04 - val_loss: 0.0134\n", + "Epoch 141/150\n", + "1/1 [==============================] - 0s 19ms/step - loss: 7.5092e-04 - val_loss: 0.0133\n", + "Epoch 142/150\n", + "1/1 [==============================] - 0s 18ms/step - loss: 7.4617e-04 - val_loss: 0.0132\n", + "Epoch 143/150\n", + "1/1 [==============================] - 0s 18ms/step - loss: 7.4141e-04 - val_loss: 0.0131\n", + "Epoch 144/150\n", + "1/1 [==============================] - 0s 18ms/step - loss: 7.3667e-04 - val_loss: 0.0131\n", + "Epoch 145/150\n", + "1/1 [==============================] - 0s 19ms/step - loss: 7.3196e-04 - val_loss: 0.0130\n", + "Epoch 146/150\n", + "1/1 [==============================] - 0s 20ms/step - loss: 7.2734e-04 - val_loss: 0.0130\n", + "Epoch 147/150\n", + "1/1 [==============================] - 0s 18ms/step - loss: 7.2282e-04 - val_loss: 0.0130\n", + "Epoch 148/150\n", + "1/1 [==============================] - 0s 20ms/step - loss: 7.1838e-04 - val_loss: 0.0129\n", + "Epoch 149/150\n", + "1/1 [==============================] - 0s 19ms/step - loss: 7.1398e-04 - val_loss: 0.0128\n", + "Epoch 150/150\n", + "1/1 [==============================] - 0s 18ms/step - loss: 7.0961e-04 - val_loss: 0.0127\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time: 7.055008993000001\n" + ] + } + ], "source": [ "def lstm_2layers(length_of_sequences, batch_size = None, stateful = False):\n", " \"\"\"\n", @@ -888,10 +2534,7 @@ }, { "cell_type": "markdown", - "id": "f8cca3f0", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Generative Models\n", "\n", @@ -912,10 +2555,7 @@ }, { "cell_type": "markdown", - "id": "69427a7b", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Generative Adversarial Networks\n", "\n", @@ -932,10 +2572,7 @@ }, { "cell_type": "markdown", - "id": "4c134a8f", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "\n", "
\n", @@ -950,10 +2587,7 @@ }, { "cell_type": "markdown", - "id": "f02c8236", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Discriminator\n", "The discriminator attempts to distinguish between samples drawn from the\n", @@ -965,10 +2599,7 @@ }, { "cell_type": "markdown", - "id": "1670d775", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "\n", "
\n", @@ -983,10 +2614,7 @@ }, { "cell_type": "markdown", - "id": "be0984ce", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "indicating the probability that $x$ is a real training example rather than a\n", "fake sample the generator has generated. The simplest way to formulate the\n", @@ -996,10 +2624,7 @@ }, { "cell_type": "markdown", - "id": "6dbb10b7", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "\n", "
\n", @@ -1014,10 +2639,7 @@ }, { "cell_type": "markdown", - "id": "19054ff7", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "determines the reward for the discriminator, while the generator gets the\n", "conjugate reward" @@ -1025,10 +2647,7 @@ }, { "cell_type": "markdown", - "id": "af0db997", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "\n", "
\n", @@ -1043,10 +2662,7 @@ }, { "cell_type": "markdown", - "id": "ca1b339f", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Learning Process\n", "\n", @@ -1070,10 +2686,7 @@ }, { "cell_type": "markdown", - "id": "e1bd5507", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## More about the Learning Process\n", "\n", @@ -1082,10 +2695,7 @@ }, { "cell_type": "markdown", - "id": "5809cef1", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "\n", "
\n", @@ -1101,20 +2711,14 @@ }, { "cell_type": "markdown", - "id": "234ec234", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "The default choice for $v$ is" ] }, { "cell_type": "markdown", - "id": "3a694706", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "\n", "
\n", @@ -1131,10 +2735,7 @@ }, { "cell_type": "markdown", - "id": "3bbfef3d", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "The main motivation for the design of GANs is that the learning process requires\n", "neither approximate inference (variational autoencoders for example) nor\n", @@ -1143,10 +2744,7 @@ }, { "cell_type": "markdown", - "id": "a9b4bebb", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "\n", "
\n", @@ -1161,10 +2759,7 @@ }, { "cell_type": "markdown", - "id": "48dda622", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "is convex in $\\theta^{(g)} then the procedure is guaranteed to converge and is\n", "asymptotically consistent\n", @@ -1173,10 +2768,7 @@ }, { "cell_type": "markdown", - "id": "944b3b08", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Additional References\n", "This is in\n", @@ -1194,10 +2786,7 @@ }, { "cell_type": "markdown", - "id": "3d914ca3", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Writing Our First Generative Adversarial Network\n", "Let us now move on to actually implementing a GAN in tensorflow. We will study\n", @@ -1211,11 +2800,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "f5e18490", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "import os\n", @@ -1229,10 +2814,7 @@ }, { "cell_type": "markdown", - "id": "e225976e", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "Next we define our hyperparameters and import our data the usual way" ] @@ -1240,12 +2822,17 @@ { "cell_type": "code", "execution_count": 8, - "id": "196ebe09", - "metadata": { - "collapsed": false, - "editable": true - }, - "outputs": [], + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n", + "11493376/11490434 [==============================] - 1s 0us/step\n" + ] + } + ], "source": [ "BUFFER_SIZE = 60000\n", "BATCH_SIZE = 256\n", @@ -1266,10 +2853,7 @@ }, { "cell_type": "markdown", - "id": "719c96c3", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## MNIST and GANs\n", "\n", @@ -1278,13 +2862,39 @@ }, { "cell_type": "code", - "execution_count": 9, - "id": "fa659e09", - "metadata": { - "collapsed": false, - "editable": true - }, - "outputs": [], + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "Invalid shape (28, 28, 1) for image data", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_images\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'Greys'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36mimshow\u001b[0;34m(X, cmap, norm, aspect, interpolation, alpha, vmin, vmax, origin, extent, shape, filternorm, filterrad, imlim, resample, url, data, **kwargs)\u001b[0m\n\u001b[1;32m 2643\u001b[0m \u001b[0mfilterrad\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m4.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimlim\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcbook\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdeprecation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_deprecated_parameter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2644\u001b[0m resample=None, url=None, *, data=None, **kwargs):\n\u001b[0;32m-> 2645\u001b[0;31m __ret = gca().imshow(\n\u001b[0m\u001b[1;32m 2646\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcmap\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnorm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maspect\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0maspect\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2647\u001b[0m \u001b[0minterpolation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minterpolation\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malpha\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0malpha\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvmin\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/__init__.py\u001b[0m in \u001b[0;36minner\u001b[0;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1563\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0minner\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1564\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1565\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msanitize_sequence\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1566\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1567\u001b[0m \u001b[0mbound\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_sig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/cbook/deprecation.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 356\u001b[0m \u001b[0;34mf\"%(removal)s. If any parameter follows {name!r}, they \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 357\u001b[0m f\"should be pass as keyword, not positionally.\")\n\u001b[0;32m--> 358\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 359\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 360\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/cbook/deprecation.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 356\u001b[0m \u001b[0;34mf\"%(removal)s. If any parameter follows {name!r}, they \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 357\u001b[0m f\"should be pass as keyword, not positionally.\")\n\u001b[0;32m--> 358\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 359\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 360\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/axes/_axes.py\u001b[0m in \u001b[0;36mimshow\u001b[0;34m(self, X, cmap, norm, aspect, interpolation, alpha, vmin, vmax, origin, extent, shape, filternorm, filterrad, imlim, resample, url, **kwargs)\u001b[0m\n\u001b[1;32m 5624\u001b[0m resample=resample, **kwargs)\n\u001b[1;32m 5625\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 5626\u001b[0;31m \u001b[0mim\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5627\u001b[0m \u001b[0mim\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_alpha\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0malpha\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5628\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mim\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_clip_path\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/image.py\u001b[0m in \u001b[0;36mset_data\u001b[0;34m(self, A)\u001b[0m\n\u001b[1;32m 696\u001b[0m if not (self._A.ndim == 2\n\u001b[1;32m 697\u001b[0m or self._A.ndim == 3 and self._A.shape[-1] in [3, 4]):\n\u001b[0;32m--> 698\u001b[0;31m raise TypeError(\"Invalid shape {} for image data\"\n\u001b[0m\u001b[1;32m 699\u001b[0m .format(self._A.shape))\n\u001b[1;32m 700\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: Invalid shape (28, 28, 1) for image data" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "plt.imshow(train_images[0], cmap='Greys')\n", "plt.show()" @@ -1292,10 +2902,7 @@ }, { "cell_type": "markdown", - "id": "24ebf7ca", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "Now we define our two models. This is where the 'magic' happens. There are a\n", "huge amount of possible formulations for both models. A lot of engineering and\n", @@ -1310,12 +2917,8 @@ }, { "cell_type": "code", - "execution_count": 10, - "id": "0ac5ef66", - "metadata": { - "collapsed": false, - "editable": true - }, + "execution_count": 11, + "metadata": {}, "outputs": [], "source": [ "def generator_model():\n", @@ -1379,10 +2982,7 @@ }, { "cell_type": "markdown", - "id": "222ec5a7", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "And there we have our 'simple' generator model. Now we move on to defining our\n", "discriminator model $d$, which is a convolutional neural network based image\n", @@ -1391,12 +2991,8 @@ }, { "cell_type": "code", - "execution_count": 11, - "id": "0267c4c9", - "metadata": { - "collapsed": false, - "editable": true - }, + "execution_count": 12, + "metadata": {}, "outputs": [], "source": [ "def discriminator_model():\n", @@ -1432,10 +3028,7 @@ }, { "cell_type": "markdown", - "id": "ae3ba7d8", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Other Models\n", "Let us take a look at our models. **Note**: double click images for bigger view." @@ -1443,13 +3036,21 @@ }, { "cell_type": "code", - "execution_count": 12, - "id": "95781b75", - "metadata": { - "collapsed": false, - "editable": true - }, - "outputs": [], + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "generator = generator_model()\n", "plot_model(generator, show_shapes=True, rankdir='LR')" @@ -1457,13 +3058,21 @@ }, { "cell_type": "code", - "execution_count": 13, - "id": "3f855e77", - "metadata": { - "collapsed": false, - "editable": true - }, - "outputs": [], + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "discriminator = discriminator_model()\n", "plot_model(discriminator, show_shapes=True, rankdir='LR')" @@ -1471,22 +3080,15 @@ }, { "cell_type": "markdown", - "id": "e0e7bd27", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "Next we need a few helper objects we will use in training" ] }, { "cell_type": "code", - "execution_count": 14, - "id": "59bb0c37", - "metadata": { - "collapsed": false, - "editable": true - }, + "execution_count": 15, + "metadata": {}, "outputs": [], "source": [ "cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)\n", @@ -1496,10 +3098,7 @@ }, { "cell_type": "markdown", - "id": "e6cb22fa", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "The first object, *cross_entropy* is our loss function and the two others are\n", "our optimizers. Notice we use the same learning rate for both $g$ and $d$. This\n", @@ -1511,11 +3110,7 @@ { "cell_type": "code", "execution_count": 15, - "id": "63a699a5", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "def generator_loss(fake_output):\n", @@ -1527,11 +3122,7 @@ { "cell_type": "code", "execution_count": 16, - "id": "5b636638", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "def discriminator_loss(real_output, fake_output):\n", @@ -1544,10 +3135,7 @@ }, { "cell_type": "markdown", - "id": "4a066399", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "Next we define a kind of seed to help us compare the learning process over\n", "multiple training epochs." @@ -1556,11 +3144,7 @@ { "cell_type": "code", "execution_count": 17, - "id": "38fa9670", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "noise_dimension = 100\n", @@ -1570,10 +3154,7 @@ }, { "cell_type": "markdown", - "id": "952075b2", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Training Step\n", "\n", @@ -1586,11 +3167,7 @@ { "cell_type": "code", "execution_count": 18, - "id": "4593ee4a", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "@tf.function\n", @@ -1620,10 +3197,7 @@ }, { "cell_type": "markdown", - "id": "ce992974", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "Next we define a helper function to produce an output over our training epochs\n", "to see the predictive progression of our generator model. **Note**: I am including\n", @@ -1633,11 +3207,7 @@ { "cell_type": "code", "execution_count": 19, - "id": "672a23fb", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "def generate_and_save_images(model, epoch, test_input):\n", @@ -1658,10 +3228,7 @@ }, { "cell_type": "markdown", - "id": "9df7b988", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Checkpoints\n", "Setting up checkpoints to periodically save our model during training so that\n", @@ -1672,11 +3239,7 @@ { "cell_type": "code", "execution_count": 20, - "id": "6e694f63", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "# Setting up checkpoints to save model during training\n", @@ -1690,10 +3253,7 @@ }, { "cell_type": "markdown", - "id": "2e26e344", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "Now we define our training loop" ] @@ -1701,11 +3261,7 @@ { "cell_type": "code", "execution_count": 21, - "id": "4c7bfb5c", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "def train(dataset, epochs):\n", @@ -1741,10 +3297,7 @@ }, { "cell_type": "markdown", - "id": "c31b8886", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "To train simply call this function. **Warning**: this might take a long time so\n", "there is a folder of a pretrained network already included in the repository." @@ -1753,11 +3306,7 @@ { "cell_type": "code", "execution_count": 22, - "id": "5c3ceecc", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "train(train_dataset, EPOCHS)" @@ -1765,10 +3314,7 @@ }, { "cell_type": "markdown", - "id": "1488c63e", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "And here is the result of training our model for 100 epochs\n", "\n", @@ -1779,11 +3325,7 @@ { "cell_type": "code", "execution_count": 23, - "id": "ded4863e", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "from IPython.display import HTML\n", @@ -1796,10 +3338,7 @@ }, { "cell_type": "markdown", - "id": "dfbb89de", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "\n", "\n", @@ -1810,11 +3349,7 @@ { "cell_type": "code", "execution_count": 24, - "id": "721d44fc", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir))\n", @@ -1827,10 +3362,7 @@ }, { "cell_type": "markdown", - "id": "35327b57", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Exploring the Latent Space\n", "\n", @@ -1843,11 +3375,7 @@ { "cell_type": "code", "execution_count": 25, - "id": "d040b995", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "def generate_latent_points(number=100, scale_means=1, scale_stds=1):\n", @@ -1871,11 +3399,7 @@ { "cell_type": "code", "execution_count": 26, - "id": "c7a8629e", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "def plot_result(generated_images, number=100):\n", @@ -1894,11 +3418,7 @@ { "cell_type": "code", "execution_count": 27, - "id": "cf34d964", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "generated_images = generate_images(generate_latent_points())\n", @@ -1907,10 +3427,7 @@ }, { "cell_type": "markdown", - "id": "bc7aa984", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Getting Results\n", "We see that the generator generates images that look like MNIST\n", @@ -1923,11 +3440,7 @@ { "cell_type": "code", "execution_count": 28, - "id": "13a7fdc9", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "plot_number = 225\n", @@ -1950,10 +3463,7 @@ }, { "cell_type": "markdown", - "id": "e51970e2", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "Again, we have found something interesting. *Moving* around using our means\n", "takes us from digit to digit, while *moving* around using our standard\n", @@ -1965,11 +3475,7 @@ { "cell_type": "code", "execution_count": 29, - "id": "7b1ca907", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "plot_number = 400\n", @@ -1981,10 +3487,7 @@ }, { "cell_type": "markdown", - "id": "1191de87", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "A pretty cool result! We see that our generator indeed has learned a\n", "distribution which qualitatively looks a whole lot like the MNIST dataset." @@ -1992,10 +3495,7 @@ }, { "cell_type": "markdown", - "id": "666fbc96", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Interpolating Between MNIST Digits\n", "Another interesting way to explore the latent space of our generator model is by\n", @@ -2010,11 +3510,7 @@ { "cell_type": "code", "execution_count": 30, - "id": "6554e8ba", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "def interpolation(point_1, point_2, n_steps=10):\n", @@ -2028,10 +3524,7 @@ }, { "cell_type": "markdown", - "id": "758c51ec", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "Now we have all we need to do our interpolation analysis." ] @@ -2039,11 +3532,7 @@ { "cell_type": "code", "execution_count": 31, - "id": "329aff93", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "plot_number = 100\n", @@ -2063,10 +3552,7 @@ }, { "cell_type": "markdown", - "id": "ee48a3e3", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Basic ideas of the Principal Component Analysis (PCA)\n", "\n", @@ -2090,10 +3576,7 @@ }, { "cell_type": "markdown", - "id": "31b60416", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Introducing the Covariance and Correlation functions\n", "\n", @@ -2106,10 +3589,7 @@ }, { "cell_type": "markdown", - "id": "24fd278f", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\boldsymbol{C}[\\boldsymbol{x},\\boldsymbol{y}] = \\begin{bmatrix} \\mathrm{cov}[\\boldsymbol{x},\\boldsymbol{x}] & \\mathrm{cov}[\\boldsymbol{x},\\boldsymbol{y}] \\\\\n", @@ -2120,20 +3600,14 @@ }, { "cell_type": "markdown", - "id": "7ed9a4d0", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "where for example" ] }, { "cell_type": "markdown", - "id": "481c3a49", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\mathrm{cov}[\\boldsymbol{x},\\boldsymbol{y}] =\\frac{1}{n} \\sum_{i=0}^{n-1}(x_i- \\overline{x})(y_i- \\overline{y}).\n", @@ -2142,20 +3616,14 @@ }, { "cell_type": "markdown", - "id": "0a0b935f", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "With this definition and recalling that the variance is defined as" ] }, { "cell_type": "markdown", - "id": "cd71ce41", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\mathrm{var}[\\boldsymbol{x}]=\\frac{1}{n} \\sum_{i=0}^{n-1}(x_i- \\overline{x})^2,\n", @@ -2164,20 +3632,14 @@ }, { "cell_type": "markdown", - "id": "21e0692f", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "we can rewrite the covariance matrix as" ] }, { "cell_type": "markdown", - "id": "26244cfc", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\boldsymbol{C}[\\boldsymbol{x},\\boldsymbol{y}] = \\begin{bmatrix} \\mathrm{var}[\\boldsymbol{x}] & \\mathrm{cov}[\\boldsymbol{x},\\boldsymbol{y}] \\\\\n", @@ -2188,10 +3650,7 @@ }, { "cell_type": "markdown", - "id": "fabdcf9c", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "The covariance takes values between zero and infinity and may thus\n", "lead to problems with loss of numerical precision for particularly\n", @@ -2202,10 +3661,7 @@ }, { "cell_type": "markdown", - "id": "b4d74679", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\mathrm{corr}[\\boldsymbol{x},\\boldsymbol{y}]=\\frac{\\mathrm{cov}[\\boldsymbol{x},\\boldsymbol{y}]}{\\sqrt{\\mathrm{var}[\\boldsymbol{x}] \\mathrm{var}[\\boldsymbol{y}]}}.\n", @@ -2214,10 +3670,7 @@ }, { "cell_type": "markdown", - "id": "0aa5905f", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "The correlation function is then given by values $\\mathrm{corr}[\\boldsymbol{x},\\boldsymbol{y}]\n", "\\in [-1,1]$. This avoids eventual problems with too large values. We\n", @@ -2227,10 +3680,7 @@ }, { "cell_type": "markdown", - "id": "2f4129c6", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\boldsymbol{K}[\\boldsymbol{x},\\boldsymbol{y}] = \\begin{bmatrix} 1 & \\mathrm{corr}[\\boldsymbol{x},\\boldsymbol{y}] \\\\\n", @@ -2241,10 +3691,7 @@ }, { "cell_type": "markdown", - "id": "3027012b", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "In the above example this is the function we constructed using **pandas**.\n", "\n", @@ -2254,10 +3701,7 @@ }, { "cell_type": "markdown", - "id": "54d8b7a3", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\boldsymbol{X}=\\begin{bmatrix}\n", @@ -2273,10 +3717,7 @@ }, { "cell_type": "markdown", - "id": "344380b2", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "with $\\boldsymbol{X}\\in {\\mathbb{R}}^{n\\times p}$, with the predictors/features $p$ refering to the column numbers and the\n", "entries $n$ being the row elements.\n", @@ -2285,10 +3726,7 @@ }, { "cell_type": "markdown", - "id": "fb7b5c50", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\boldsymbol{X}=\\begin{bmatrix} \\boldsymbol{x}_0 & \\boldsymbol{x}_1 & \\boldsymbol{x}_2 & \\dots & \\dots & \\boldsymbol{x}_{p-1}\\end{bmatrix},\n", @@ -2297,20 +3735,14 @@ }, { "cell_type": "markdown", - "id": "038eccbe", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "with a given vector" ] }, { "cell_type": "markdown", - "id": "0c2000c1", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\boldsymbol{x}_i^T = \\begin{bmatrix}x_{0,i} & x_{1,i} & x_{2,i}& \\dots & \\dots x_{n-1,i}\\end{bmatrix}.\n", @@ -2319,10 +3751,7 @@ }, { "cell_type": "markdown", - "id": "3c5d57ee", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "With these definitions, we can now rewrite our $2\\times 2$\n", "correaltion/covariance matrix in terms of a moe general design/feature\n", @@ -2332,10 +3761,7 @@ }, { "cell_type": "markdown", - "id": "2b5d5a89", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\boldsymbol{C}[\\boldsymbol{x}] = \\begin{bmatrix}\n", @@ -2351,20 +3777,14 @@ }, { "cell_type": "markdown", - "id": "769337f5", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "and the correlation matrix" ] }, { "cell_type": "markdown", - "id": "6ff30260", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\boldsymbol{K}[\\boldsymbol{x}] = \\begin{bmatrix}\n", @@ -2380,10 +3800,7 @@ }, { "cell_type": "markdown", - "id": "0048416d", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "The Numpy function **np.cov** calculates the covariance elements using\n", "the factor $1/(n-1)$ instead of $1/n$ since it assumes we do not have\n", @@ -2394,10 +3811,7 @@ }, { "cell_type": "markdown", - "id": "3aa41181", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\boldsymbol{W} = \\begin{bmatrix} x_0 & y_0 \\\\\n", @@ -2412,10 +3826,7 @@ }, { "cell_type": "markdown", - "id": "6acc0269", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "which in turn is converted into into the $2\\times 2$ covariance matrix\n", "$\\boldsymbol{C}$ via the Numpy function **np.cov()**. We note that we can also calculate\n", @@ -2427,11 +3838,7 @@ { "cell_type": "code", "execution_count": 32, - "id": "793b05e5", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "# Importing various packages\n", @@ -2448,10 +3855,7 @@ }, { "cell_type": "markdown", - "id": "aa29370a", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Correlation Matrix\n", "\n", @@ -2465,11 +3869,7 @@ { "cell_type": "code", "execution_count": 33, - "id": "2af5fcad", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", @@ -2497,10 +3897,7 @@ }, { "cell_type": "markdown", - "id": "b1f2d467", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "We see that the matrix elements along the diagonal are one as they\n", "should be and that the matrix is symmetric. Furthermore, diagonalizing\n", @@ -2514,11 +3911,7 @@ { "cell_type": "code", "execution_count": 34, - "id": "a42aa184", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", @@ -2538,10 +3931,7 @@ }, { "cell_type": "markdown", - "id": "998af2ad", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "We expand this model to the Franke function discussed above." ] @@ -2549,11 +3939,7 @@ { "cell_type": "code", "execution_count": 35, - "id": "761bebfd", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "# Common imports\n", @@ -2603,10 +3989,7 @@ }, { "cell_type": "markdown", - "id": "eda72f1d", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "We note here that the covariance is zero for the first rows and\n", "columns since all matrix elements in the design matrix were set to one\n", @@ -2620,10 +4003,7 @@ }, { "cell_type": "markdown", - "id": "8280ba9e", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\boldsymbol{C}[\\boldsymbol{x}] = \\frac{1}{n}\\boldsymbol{X}^T\\boldsymbol{X}= \\mathbb{E}[\\boldsymbol{X}^T\\boldsymbol{X}].\n", @@ -2632,20 +4012,14 @@ }, { "cell_type": "markdown", - "id": "a588c93a", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "To see this let us simply look at a design matrix $\\boldsymbol{X}\\in {\\mathbb{R}}^{2\\times 2}$" ] }, { "cell_type": "markdown", - "id": "e648daf2", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\boldsymbol{X}=\\begin{bmatrix}\n", @@ -2659,20 +4033,14 @@ }, { "cell_type": "markdown", - "id": "3eb90e09", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "If we then compute the expectation value" ] }, { "cell_type": "markdown", - "id": "06b59d6e", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\mathbb{E}[\\boldsymbol{X}^T\\boldsymbol{X}] = \\frac{1}{n}\\boldsymbol{X}^T\\boldsymbol{X}=\\begin{bmatrix}\n", @@ -2684,20 +4052,14 @@ }, { "cell_type": "markdown", - "id": "1f2ec834", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "which is just" ] }, { "cell_type": "markdown", - "id": "17e9a028", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\boldsymbol{C}[\\boldsymbol{x}_0,\\boldsymbol{x}_1] = \\boldsymbol{C}[\\boldsymbol{x}]=\\begin{bmatrix} \\mathrm{var}[\\boldsymbol{x}_0] & \\mathrm{cov}[\\boldsymbol{x}_0,\\boldsymbol{x}_1] \\\\\n", @@ -2708,10 +4070,7 @@ }, { "cell_type": "markdown", - "id": "b2798b55", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "where we wrote $$\\boldsymbol{C}[\\boldsymbol{x}_0,\\boldsymbol{x}_1] = \\boldsymbol{C}[\\boldsymbol{x}]$$ to indicate that this the covariance of the vectors $\\boldsymbol{x}$ of the design/feature matrix $\\boldsymbol{X}$.\n", "\n", @@ -2720,10 +4079,7 @@ }, { "cell_type": "markdown", - "id": "a82c0fde", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Towards the PCA theorem\n", "\n", @@ -2732,10 +4088,7 @@ }, { "cell_type": "markdown", - "id": "0eacd686", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\boldsymbol{C}[\\boldsymbol{x}] = \\frac{1}{n}\\boldsymbol{X}^T\\boldsymbol{X}= \\mathbb{E}[\\boldsymbol{X}^T\\boldsymbol{X}].\n", @@ -2744,10 +4097,7 @@ }, { "cell_type": "markdown", - "id": "12723688", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "Let us now assume that we can perform a series of orthogonal transformations where we employ some orthogonal matrices $\\boldsymbol{S}$.\n", "These matrices are defined as $\\boldsymbol{S}\\in {\\mathbb{R}}^{p\\times p}$ and obey the orthogonality requirements $\\boldsymbol{S}\\boldsymbol{S}^T=\\boldsymbol{S}^T\\boldsymbol{S}=\\boldsymbol{I}$. The matrix can be written out in terms of the column vectors $\\boldsymbol{s}_i$ as $\\boldsymbol{S}=[\\boldsymbol{s}_0,\\boldsymbol{s}_1,\\dots,\\boldsymbol{s}_{p-1}]$ and $\\boldsymbol{s}_i \\in {\\mathbb{R}}^{p}$.\n", @@ -2759,10 +4109,7 @@ }, { "cell_type": "markdown", - "id": "cb518537", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\boldsymbol{C}[\\boldsymbol{y}] = \\mathbb{E}[\\boldsymbol{S}^T\\boldsymbol{X}^T\\boldsymbol{X}T\\boldsymbol{S}]=\\boldsymbol{S}^T\\boldsymbol{C}[\\boldsymbol{x}]\\boldsymbol{S},\n", @@ -2771,20 +4118,14 @@ }, { "cell_type": "markdown", - "id": "e2f1b04b", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "since the matrix $\\boldsymbol{S}$ is not a data dependent matrix. Multiplying with $\\boldsymbol{S}$ from the left we have" ] }, { "cell_type": "markdown", - "id": "5b32fcaa", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\boldsymbol{S}\\boldsymbol{C}[\\boldsymbol{y}] = \\boldsymbol{C}[\\boldsymbol{x}]\\boldsymbol{S},\n", @@ -2793,20 +4134,14 @@ }, { "cell_type": "markdown", - "id": "aeccea3f", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "and since $\\boldsymbol{C}[\\boldsymbol{y}]$ is diagonal we have for a given eigenvalue $i$ of the covariance matrix that" ] }, { "cell_type": "markdown", - "id": "6f904380", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\boldsymbol{S}_i\\lambda_i = \\boldsymbol{C}[\\boldsymbol{x}]\\boldsymbol{S}_i.\n", @@ -2815,10 +4150,7 @@ }, { "cell_type": "markdown", - "id": "4df11981", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "In the derivation of the PCA theorem we will assume that the eigenvalues are ordered in descending order, that is\n", "$\\lambda_0 > \\lambda_1 > \\dots > \\lambda_{p-1}$. \n", @@ -2838,10 +4170,7 @@ }, { "cell_type": "markdown", - "id": "1ebf8b82", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "### The Algorithm before theorem\n", "\n", @@ -2851,10 +4180,7 @@ }, { "cell_type": "markdown", - "id": "1a7043ce", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\boldsymbol{X}=\\begin{bmatrix}\n", @@ -2870,10 +4196,7 @@ }, { "cell_type": "markdown", - "id": "a89299c2", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "* Center the data by subtracting the mean value for each column. This leads to a new matrix $\\boldsymbol{X}\\rightarrow \\overline{\\boldsymbol{X}}$.\n", "\n", @@ -2888,10 +4211,7 @@ }, { "cell_type": "markdown", - "id": "95f17b4e", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "### Writing our own PCA code\n", "\n", @@ -2901,10 +4221,7 @@ }, { "cell_type": "markdown", - "id": "b8c26b70", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\mu = (-1,2) \\qquad \\Sigma = \\begin{bmatrix} 4 & 2 \\\\\n", @@ -2915,10 +4232,7 @@ }, { "cell_type": "markdown", - "id": "7401bbc1", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "Note that the mean refers to each column of data. \n", "We will generate $n = 10000$ points $X = \\{ x_1, \\ldots, x_N \\}$ from\n", @@ -2931,11 +4245,7 @@ { "cell_type": "code", "execution_count": 36, - "id": "e0023c95", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", @@ -2950,10 +4260,7 @@ }, { "cell_type": "markdown", - "id": "e334c5f7", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "Now we are going to implement the PCA algorithm. We will break it down into various substeps.\n", "\n", @@ -2962,10 +4269,7 @@ }, { "cell_type": "markdown", - "id": "b07b0314", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\mu_n = \\frac{1}{n} \\sum_{i=1}^n x_i\n", @@ -2974,20 +4278,14 @@ }, { "cell_type": "markdown", - "id": "f71e86d6", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "and the mean-centered data $\\bar{X} = \\{ \\bar{x}_1, \\ldots, \\bar{x}_n \\}$ takes the form" ] }, { "cell_type": "markdown", - "id": "926bcafc", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\bar{x}_i = x_i - \\mu_n.\n", @@ -2996,10 +4294,7 @@ }, { "cell_type": "markdown", - "id": "6b2d4702", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "When you are done with these steps, print out $\\mu_n$ to verify it is\n", "close to $\\mu$ and plot your mean centered data to verify it is\n", @@ -3010,11 +4305,7 @@ { "cell_type": "code", "execution_count": 37, - "id": "c3c8bf1e", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "df = pd.DataFrame(X)\n", @@ -3026,10 +4317,7 @@ }, { "cell_type": "markdown", - "id": "2ac3ddac", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "Alternatively, we could use the functions we discussed\n", "earlier for scaling the data set. That is, we could have used the\n", @@ -3046,10 +4334,7 @@ }, { "cell_type": "markdown", - "id": "f56584dd", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\Sigma_n = \\frac{1}{n-1} \\sum_{i=1}^n \\bar{x}_i^T \\bar{x}_i = \\frac{1}{n-1} \\sum_{i=1}^n (x_i - \\mu_n)^T (x_i - \\mu_n)\n", @@ -3058,10 +4343,7 @@ }, { "cell_type": "markdown", - "id": "6c2ce2aa", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "where the data points $x_i \\in \\mathbb{R}^p$ (here in this example $p = 2$) are column vectors and $x^T$ is the transpose of $x$.\n", "We can write our own code or simply use either the functionaly of **numpy** or that of **pandas**, as follows" @@ -3070,11 +4352,7 @@ { "cell_type": "code", "execution_count": 38, - "id": "7a18be5a", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "print(df.cov())\n", @@ -3083,10 +4361,7 @@ }, { "cell_type": "markdown", - "id": "688247c5", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "Note that the way we define the covariance matrix here has a factor $n-1$ instead of $n$. This is included in the **cov()** function by **numpy** and **pandas**. \n", "Our own code here is not very elegant and asks for obvious improvements. It is tailored to this specific $2\\times 2$ covariance matrix." @@ -3095,11 +4370,7 @@ { "cell_type": "code", "execution_count": 39, - "id": "42375598", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "# extract the relevant columns from the centered design matrix of dim n x 2\n", @@ -3119,10 +4390,7 @@ }, { "cell_type": "markdown", - "id": "b76022a5", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "Depending on the number of points $n$, we will get results that are close to the covariance values defined above.\n", "The plot shows how the data are clustered around a line with slope close to one. Is this expected? Try to change the covariance and the mean values. For example, try to make the variance of the first element much larger than that of the second diagonal element. Try also to shrink the covariance (the non-diagonal elements) and see how the data points are distributed." @@ -3130,10 +4398,7 @@ }, { "cell_type": "markdown", - "id": "e5ddffef", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "### Diagonalize the sample covariance matrix to obtain the principal components\n", "\n", @@ -3154,10 +4419,7 @@ }, { "cell_type": "markdown", - "id": "9ada7465", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "x_i \\approx \\tilde{x}_i = \\mu_n + \\langle x_i, v_0 \\rangle v_0\n", @@ -3166,10 +4428,7 @@ }, { "cell_type": "markdown", - "id": "dd26c194", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "where $v_0$ is the first principal component. \n", "\n", @@ -3184,11 +4443,7 @@ { "cell_type": "code", "execution_count": 40, - "id": "37271c22", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "# diagonalize and obtain eigenvalues, not necessarily sorted\n", @@ -3216,20 +4471,14 @@ }, { "cell_type": "markdown", - "id": "15dc0374", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "This code does not contain all the above elements, but it shows how we can use **Scikit-Learn** to extract the eigenvector which corresponds to the largest eigenvalue. Try to address the questions we pose before the above code. Try also to change the values of the covariance matrix by making one of the diagonal elements much larger than the other. What do you observe then?" ] }, { "cell_type": "markdown", - "id": "a8df7b8d", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Classical PCA Theorem\n", "\n", @@ -3264,10 +4513,7 @@ }, { "cell_type": "markdown", - "id": "10e688c2", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "J(\\boldsymbol{w}_0)= \\boldsymbol{w}_0^T\\boldsymbol{C}[\\boldsymbol{x}]\\boldsymbol{w}_0+\\lambda_0(1-\\boldsymbol{w}_0^T\\boldsymbol{w}_0).\n", @@ -3276,20 +4522,14 @@ }, { "cell_type": "markdown", - "id": "fb9cdee1", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "Taking the derivative with respect to $\\boldsymbol{w}_0$ we obtain" ] }, { "cell_type": "markdown", - "id": "572a2afd", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\frac{\\partial J(\\boldsymbol{w}_0)}{\\partial \\boldsymbol{w}_0}= 2\\boldsymbol{C}[\\boldsymbol{x}]\\boldsymbol{w}_0-2\\lambda_0\\boldsymbol{w}_0=0,\n", @@ -3298,20 +4538,14 @@ }, { "cell_type": "markdown", - "id": "0b3b1443", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "meaning that" ] }, { "cell_type": "markdown", - "id": "4f843c0f", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\boldsymbol{C}[\\boldsymbol{x}]\\boldsymbol{w}_0=\\lambda_0\\boldsymbol{w}_0.\n", @@ -3320,20 +4554,14 @@ }, { "cell_type": "markdown", - "id": "9377ac1a", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "**The direction that maximizes the variance (or minimizes the construction error) is an eigenvector of the covariance matrix**! If we left multiply with $\\boldsymbol{w}_0^T$ we have the variance of the projected data is" ] }, { "cell_type": "markdown", - "id": "5e55acbb", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "\\boldsymbol{w}_0^T\\boldsymbol{C}[\\boldsymbol{x}]\\boldsymbol{w}_0=\\lambda_0.\n", @@ -3342,10 +4570,7 @@ }, { "cell_type": "markdown", - "id": "641f1b5f", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "If we want to maximize the variance (minimize the construction error)\n", "we simply pick the eigenvector of the covariance matrix with the\n", @@ -3368,10 +4593,7 @@ }, { "cell_type": "markdown", - "id": "74b89bb2", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Geometric Interpretation and link with Singular Value Decomposition\n", "\n", @@ -3387,11 +4609,7 @@ { "cell_type": "code", "execution_count": 41, - "id": "6c2f9cd6", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", @@ -3422,10 +4640,7 @@ }, { "cell_type": "markdown", - "id": "98f9ecc3", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "PCA assumes that the dataset is centered around the origin. Scikit-Learn’s PCA classes take care of centering\n", "the data for you. However, if you implement PCA yourself (as in the preceding example), or if you use other libraries, don’t\n", @@ -3439,11 +4654,7 @@ { "cell_type": "code", "execution_count": 42, - "id": "e54ecfa4", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "W2 = V.T[:, :2]\n", @@ -3452,10 +4663,7 @@ }, { "cell_type": "markdown", - "id": "8491b24a", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## PCA and scikit-learn\n", "\n", @@ -3467,11 +4675,7 @@ { "cell_type": "code", "execution_count": 43, - "id": "9d8c4782", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "#thereafter we do a PCA with Scikit-learn\n", @@ -3483,10 +4687,7 @@ }, { "cell_type": "markdown", - "id": "12a9e878", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "After fitting the PCA transformer to the dataset, you can access the principal components using the\n", "components variable (note that it contains the PCs as horizontal vectors, so, for example, the first\n", @@ -3496,11 +4697,7 @@ { "cell_type": "code", "execution_count": 44, - "id": "e10fe641", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "pca.components_.T[:, 0]" @@ -3508,10 +4705,7 @@ }, { "cell_type": "markdown", - "id": "d59e8f5c", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "Another very useful piece of information is the explained variance ratio of each principal component,\n", "available via the $explained\\_variance\\_ratio$ variable. It indicates the proportion of the dataset’s\n", @@ -3520,10 +4714,7 @@ }, { "cell_type": "markdown", - "id": "19553389", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Back to the Cancer Data\n", "We can now repeat the above but applied to real data, in this case our breast cancer data.\n", @@ -3533,11 +4724,7 @@ { "cell_type": "code", "execution_count": 45, - "id": "6b5b8d42", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", @@ -3572,10 +4759,7 @@ }, { "cell_type": "markdown", - "id": "7e50dc25", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "We see that our training data after the PCA decomposition has a performance similar to the non-scaled data. \n", "\n", @@ -3590,11 +4774,7 @@ { "cell_type": "code", "execution_count": 46, - "id": "473fbedc", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "pca = PCA()\n", @@ -3605,10 +4785,7 @@ }, { "cell_type": "markdown", - "id": "670ccca8", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "You could then set $n\\_components=d$ and run PCA again. However, there is a much better option: instead\n", "of specifying the number of principal components you want to preserve, you can set $n\\_components$ to be\n", @@ -3618,11 +4795,7 @@ { "cell_type": "code", "execution_count": 47, - "id": "45f40681", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "pca = PCA(n_components=0.95)\n", @@ -3631,10 +4804,7 @@ }, { "cell_type": "markdown", - "id": "93686a53", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "### Incremental PCA\n", "\n", @@ -3647,10 +4817,7 @@ }, { "cell_type": "markdown", - "id": "0038db65", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "### Randomized PCA\n", "\n", @@ -3662,10 +4829,7 @@ }, { "cell_type": "markdown", - "id": "0bb96452", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "### Kernel PCA\n", "\n", @@ -3683,11 +4847,7 @@ { "cell_type": "code", "execution_count": 48, - "id": "8fb0a10c", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "from sklearn.decomposition import KernelPCA\n", @@ -3697,10 +4857,7 @@ }, { "cell_type": "markdown", - "id": "e8276c18", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Other techniques\n", "\n", @@ -3717,7 +4874,25 @@ ] } ], - "metadata": {}, + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, "nbformat": 4, "nbformat_minor": 5 }