From c83875547d129ee6cf77a94da22ba1ffe2a03681 Mon Sep 17 00:00:00 2001 From: Abhay-sisodia <84870507+Abhay-sisodia@users.noreply.github.com> Date: Mon, 6 Jun 2022 00:02:09 +0530 Subject: [PATCH 1/8] Add files via upload --- Assignment 1/A1_200014.ipynb | 415 +++++++++++++++++++++++++++++++++++ 1 file changed, 415 insertions(+) create mode 100644 Assignment 1/A1_200014.ipynb diff --git a/Assignment 1/A1_200014.ipynb b/Assignment 1/A1_200014.ipynb new file mode 100644 index 0000000..bf74b73 --- /dev/null +++ b/Assignment 1/A1_200014.ipynb @@ -0,0 +1,415 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "RB2d1J1f1CF7" + }, + "source": [ + "### **Aim** \n", + "The motive of this assignment is to make predictions using **Linear Regression**. To make sure you truly understand how the underlying algorithm works, you are to implement it from scratch." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "a_S80lf6H4Xv" + }, + "source": [ + "### Generating the dataset \n", + "Run the cell below to create the dataset. It further splits the available data into training and testing. Please do not edit this cell.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "yX0zqXcHIQHP" + }, + "outputs": [], + "source": [ + "from sklearn import datasets\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "# Generate the data\n", + "X, y = datasets.make_regression(n_samples=100, n_features=5, noise=20, random_state=4)\n", + "\n", + "# Split the data\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1234)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "RtfsiLS2lSNE", + "outputId": "34abfc93-00ef-4d97-fe0b-bba7b379a3d5" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(80, 5)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Zj4rrRXGJBXy" + }, + "source": [ + "### Visualizing the data \n", + "Use `matplotlib` to visualize the given data." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 265 + }, + "id": "zxfi8dkBJOUi", + "outputId": "36da82de-2237-4c7a-ef2f-d4c3af420e94" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Variation of x columns with y.\n", + "\n", + "for i in range(1,5):\n", + " plt.scatter(X_train[:,i-1:i],y_train)\n", + "\n", + "\n", + "\n", + "# Your code here" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Uvu0DfOapTSr", + "outputId": "b3a66cb0-e692-44fa-c031-4f4c7ef6a152" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(80, 1)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "# weight=np.random.rand((X_train.shape[1],1));\n", + "# bias=np.ones((y_train.shape[0],y_train.shape[1]));\n", + "\n", + "weight=np.random.rand(X_train.shape[1],1);\n", + "bias=np.random.rand(X_train.shape[0],1);\n", + "bias.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "r7vndSBAJceF" + }, + "source": [ + "You should be able to see the linear relations between `y` and the features in vector `X`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b4I9Z3epNvBM" + }, + "source": [ + "### Gradient Descent Review \n", + "1. #### Cost function\n", + "Define the `cost function` to measure the difference between predictions and target outputs. Here, we are working with first degree polynomial, so derivatives are easy to calculate. ( Linear function `y = wx +b` ) \n", + "\n", + "$$Error = \\frac{1}{N}\\sum_{i=1}^N (y_i - \\overline{y}_i)^2 = \\frac{1}{N}\\sum_{i=1}^N (y_i - (x_iw+b))^2 $$ \n", + "\n", + " where `N` is the number of samples \n", + " \n", + "\n", + "\n", + "2. #### Compute the derivative\n", + "$$\\frac{\\delta Error}{\\delta w} = \\frac{2}{N}\\sum_{i=1}^N -x_i(y_i -(m x_i +b )) $$\n", + "$$\\frac{\\delta Error}{\\delta b} = \\frac{2}{N}\\sum_{i=1}^N -(y_i -(m x_i +b )) $$\n", + "3.

Update current parameters

\n", + "$$ w:= w- learning\\_rate \\cdot \\frac{\\delta Error}{\\delta w} $$ \n", + "$$ b:= b- learning\\_rate \\cdot \\frac{\\delta Error}{\\delta b} $$ \n", + "4.

Repeat until it fits good enough

\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kBtUcOVnJu-I" + }, + "source": [ + "### Model definition\n", + "\n", + "Complete the functions in the class below. Hints provided at appropriate places." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "dGnFNPJx3I28" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "class LinearRegression:\n", + "\n", + " # The __init__ is called when we make any object of our class. Here, you are to specify the default values for \n", + " # Learning Rate, Number of Iterations, Weights and Biases. It doesn't return anything.\n", + " # Hint: Google what a `self pointer` is and figure out how it can be used here.\n", + " def __init__(self, learning_rate=0.001, n_iters=1000):\n", + " # Your code here\n", + "\n", + " # self.weight=np.random.rand((X_train.shape[1],1));\n", + "\n", + " # self.bias=np.ones((y_train.shape[0],y_train.shape[1]));\n", + "\n", + " self.weight=np.random.rand(X_train.shape[1],1);\n", + " self.bias=np.random.rand(X_train.shape[0],1);\n", + "\n", + "\n", + "\n", + "\n", + " # Uncomment this when you're done with this function\n", + "\n", + "\n", + " # The following function would be the heart of the model. This is where the training would happen. \n", + " # You're supposed to iterate and keep on updating the weights and biases according to the steps of Gradient Descent.\n", + " def fit(self, x, y):\n", + " # Gradient Descent code goes here\n", + " \n", + " w=self.weight;\n", + " b=self.bias;\n", + "\n", + " def CostFunction(x,y,w,b):\n", + " \n", + " cost = np.sum((((x.dot(weight) + bias) - y) ** 2) / (2*len(y)))\n", + " return cost\n", + " # For every iteration\n", + " \n", + " def GradientDescent(x, y, w, b, learning_rate, n_iters):\n", + " cost_list = [0] * n_iters\n", + " for epoch in range(n_iters):\n", + " z = x.dot(w) + b\n", + " loss = z - y\n", + " weight_gradient = x.T.dot(loss) / len(y)\n", + " bias_gradient = np.sum(loss) / len(y)\n", + " w = w - learning_rate*weight_gradient\n", + " b = b - learning_rate*bias_gradient\n", + " cost = CostFunction(x, y, w, b)\n", + " cost_list[epoch] = cost\n", + " \n", + " return w, b, cost_list\n", + "\n", + "\n", + "\n", + " # Computing the gradient\n", + " # Uncomment this when you're done with this function\n", + " \n", + " \n", + " # This function will be called after our model has been trained and we are predicting on unseen data\n", + " # What is our prediction? Just return that\n", + " def predict(self, X):\n", + " # Code goes here\n", + "\n", + " return np.dot(X_train,self.weight)+ self.bias\n", + "\n", + " pass # Uncomment this when you're done with this function" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EvyInkTKPn7W" + }, + "source": [ + "### Initializing, Training & Predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "nvItUpAkHTiv" + }, + "outputs": [], + "source": [ + "# Now, we make an object of our custom class.\n", + "regressor = LinearRegression() # You may pass the custom parameters or let the default values take it ahead\n", + "\n", + "# Call the fit method on the object to train (pass appropriate part of dataset)\n", + "regressor.fit(X_train,y_train)\n", + "\n", + "# Now, let's see our what our model predicts\n", + "predictions = regressor.predict(X_train) # pass appropriate part of dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "_-Ch0MWVweVE", + "outputId": "5d40d134-6ea0-4c2c-e647-9cac5330edd3" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(20,)" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tzK6cq8eRD4Q" + }, + "source": [ + "### Evaluate the model \n", + "\n", + "Return [Mean Squared Error](https://en.wikipedia.org/wiki/Mean_squared_error) & [R2 Score](https://www.ncl.ac.uk/webtemplate/ask-assets/external/maths-resources/statistics/regression-and-correlation/coefficient-of-determination-r-squared.html#:~:text=%C2%AFy) from the functions below." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "WqkrvDzcRF5m", + "outputId": "d8ef6b33-68b9-490e-f097-98b641b271d2" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MSE: 11550.865625513232\n", + "Accuracy: 0.003021769072843905\n" + ] + } + ], + "source": [ + "def mean_squared_error(y_true, y_pred):\n", + " # return the mean squared error\n", + " from sklearn.metrics import mean_squared_error\n", + " \n", + " return mean_squared_error(y_true, y_pred)\n", + "\n", + " pass # Uncomment this when you're done with this function\n", + "\n", + "\n", + "def r2_score(y_true, y_pred):\n", + " # return the r2 score\n", + " from sklearn.metrics import r2_score\n", + " return r2_score(y_true, y_pred)\n", + "\n", + " return \n", + "\n", + " pass # Uncomment this when you're done with this function\n", + " \n", + "\n", + "mse = mean_squared_error(y_train,predictions) # Pass appropriate parts of dataset\n", + "print(\"MSE:\", mse)\n", + "\n", + "accu = r2_score(y_train,predictions) # Pass appropriate parts of dataset\n", + "print(\"Accuracy:\", accu)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "rbXiKeW7wGs7" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "Copy of CV with TF: Assignment 1.ipynb", + "provenance": [] + }, + "interpreter": { + "hash": "d32dd9972e4becc079854756227bbaf57600491c52d25499cfd0dde1c0f41dcc" + }, + "kernelspec": { + "display_name": "Python 3.9.6 64-bit", + "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.9.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From 3e27ac40668bfe64731339a9f1a5772ee5a306ec Mon Sep 17 00:00:00 2001 From: Abhay-sisodia <84870507+Abhay-sisodia@users.noreply.github.com> Date: Tue, 14 Jun 2022 15:54:43 +0530 Subject: [PATCH 2/8] Add files via upload --- A2_200014.ipynb | 1090 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1090 insertions(+) create mode 100644 A2_200014.ipynb diff --git a/A2_200014.ipynb b/A2_200014.ipynb new file mode 100644 index 0000000..973ca6c --- /dev/null +++ b/A2_200014.ipynb @@ -0,0 +1,1090 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "UxcaEbrCy1g_" + }, + "source": [ + "# Assigment 2: Deep Learning" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "h2JON-_Oy79w" + }, + "source": [ + "## Generate Dataset\n", + "\n", + "This is the same code from Assignment 1" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "hgpG3WDuypfa" + }, + "outputs": [], + "source": [ + "from sklearn import datasets\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "# Generate the data\n", + "x, y = datasets.make_regression(n_samples=100, n_features=5, noise=5, random_state=4)\n", + "\n", + "\n", + "# Split the data\n", + "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=1234)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "H6yGzfrTyqcs", + "outputId": "60310a69-fdbc-4da7-8dcf-573e8a2ef598" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(80, 6)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "y_train=y_train.reshape(-1,1)\n", + "z_train=np.concatenate((x_train,y_train),axis=1)\n", + "z_train.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ZFK06IAqz7JU", + "outputId": "11d0d9a8-0102-4b5a-e00c-64f2958be46a" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "-261.6982943912921" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_train.min()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "r6it-Rm7zD1Y" + }, + "source": [ + "## Visualize Dataset\n", + "This is the same code from Assignment 1" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "UautPVj1yzaQ", + "outputId": "c1ceed4c-fa2f-4a3d-f9ba-547b66f1c1c8" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Visualizing the train dataset \n", + "import matplotlib.pyplot as plt\n", + "fig, axs = plt.subplots(5,figsize=(20,30))\n", + "\n", + "for i in range(5):\n", + " axs[i].scatter(x_train[:,i],y_train)\n", + "\n", + "\n", + "\n", + "\n", + "# Your code here" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "erZ1XReZ1QzO", + "outputId": "db319adf-ff5f-4dbe-af6f-ed1bf8c8239a" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Represents what is the value counts of different values in the target column in training dataset\n", + "import seaborn as sns\n", + "plt.figure(figsize=(2,20))\n", + "sns.heatmap(y_train,cmap='viridis')\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XMXb9lTyzGHE" + }, + "source": [ + "## Model Definition\n", + "\n", + "Using TensorFlow, build a model with the following definition:\n", + "> Input of shape 5 \\\\\n", + "> Dense of shape 5 \\\\\n", + "> Dense of shape 5 \\\\\n", + "> Dense of shape 1 \\\\\n", + "\n", + "Use Mean Square Error Loss and Stochaistic Gradient Descent (SGD) Optimizer\n", + "\n", + "Use Gradient Decay with appropriate parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "r32N1xK2ziOs" + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "\n", + "\n", + "def build_model():\n", + " model=tf.keras.models.Sequential([\n", + " tf.keras.layers.InputLayer(input_shape=5) ,\n", + " tf.keras.layers.Dense(5,activation='relu'),\n", + " tf.keras.layers.Dense(5,activation='relu'),\n", + " tf.keras.layers.Dense(1)\n", + "\n", + " ])\n", + "\n", + " optimi=tf.keras.optimizers.SGD( learning_rate=0.01)\n", + "\n", + "\n", + " model.compile(loss='mean_squared_error',optimizer=optimi,metrics=['mse'])\n", + " return model\n", + "\n", + "model=build_model()\n", + "\n", + "\n", + "\n", + "# Your code here" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "yIQ0mPVfrUzy", + "outputId": "daba414e-804c-4d68-adf0-f360943225fa" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " dense (Dense) (None, 5) 30 \n", + " \n", + " dense_1 (Dense) (None, 5) 30 \n", + " \n", + " dense_2 (Dense) (None, 1) 6 \n", + " \n", + "=================================================================\n", + "Total params: 66\n", + "Trainable params: 66\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0pL-Eg_8rzsm", + "outputId": "2e1dd950-09bc-4254-d3dd-7486d02010e4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/100\n", + "2/2 [==============================] - 1s 306ms/step - loss: 12262.9619 - mse: 12262.9619 - val_loss: 11092.0488 - val_mse: 11092.0488\n", + "Epoch 2/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 14371.0664 - mse: 14371.0664 - val_loss: 7165.2935 - val_mse: 7165.2935\n", + "Epoch 3/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12583.0078 - mse: 12583.0078 - val_loss: 7146.7114 - val_mse: 7146.7114\n", + "Epoch 4/100\n", + "2/2 [==============================] - 0s 48ms/step - loss: 12578.8672 - mse: 12578.8672 - val_loss: 7129.0264 - val_mse: 7129.0264\n", + "Epoch 5/100\n", + "2/2 [==============================] - 0s 54ms/step - loss: 12573.8975 - mse: 12573.8975 - val_loss: 7111.7861 - val_mse: 7111.7861\n", + "Epoch 6/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12572.4795 - mse: 12572.4795 - val_loss: 7095.2236 - val_mse: 7095.2236\n", + "Epoch 7/100\n", + "2/2 [==============================] - 0s 47ms/step - loss: 12567.2871 - mse: 12567.2871 - val_loss: 7079.9390 - val_mse: 7079.9390\n", + "Epoch 8/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12563.1133 - mse: 12563.1133 - val_loss: 7065.2163 - val_mse: 7065.2163\n", + "Epoch 9/100\n", + "2/2 [==============================] - 0s 47ms/step - loss: 12560.5127 - mse: 12560.5127 - val_loss: 7051.2412 - val_mse: 7051.2412\n", + "Epoch 10/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12570.8369 - mse: 12570.8369 - val_loss: 7037.2227 - val_mse: 7037.2227\n", + "Epoch 11/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12555.1982 - mse: 12555.1982 - val_loss: 7024.4541 - val_mse: 7024.4541\n", + "Epoch 12/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12553.8750 - mse: 12553.8750 - val_loss: 7012.1353 - val_mse: 7012.1353\n", + "Epoch 13/100\n", + "2/2 [==============================] - 0s 39ms/step - loss: 12557.2422 - mse: 12557.2422 - val_loss: 7000.1250 - val_mse: 7000.1250\n", + "Epoch 14/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12549.5371 - mse: 12549.5371 - val_loss: 6989.2041 - val_mse: 6989.2041\n", + "Epoch 15/100\n", + "2/2 [==============================] - 0s 39ms/step - loss: 12549.4453 - mse: 12549.4453 - val_loss: 6978.8999 - val_mse: 6978.8999\n", + "Epoch 16/100\n", + "2/2 [==============================] - 0s 40ms/step - loss: 12547.2168 - mse: 12547.2168 - val_loss: 6968.6260 - val_mse: 6968.6260\n", + "Epoch 17/100\n", + "2/2 [==============================] - 0s 39ms/step - loss: 12549.8320 - mse: 12549.8320 - val_loss: 6958.6318 - val_mse: 6958.6318\n", + "Epoch 18/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12542.8301 - mse: 12542.8301 - val_loss: 6949.4780 - val_mse: 6949.4780\n", + "Epoch 19/100\n", + "2/2 [==============================] - 0s 40ms/step - loss: 12542.5918 - mse: 12542.5918 - val_loss: 6940.5669 - val_mse: 6940.5669\n", + "Epoch 20/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12540.4268 - mse: 12540.4268 - val_loss: 6932.1987 - val_mse: 6932.1987\n", + "Epoch 21/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12549.0176 - mse: 12549.0176 - val_loss: 6923.7275 - val_mse: 6923.7275\n", + "Epoch 22/100\n", + "2/2 [==============================] - 0s 40ms/step - loss: 12551.0293 - mse: 12551.0293 - val_loss: 6915.5625 - val_mse: 6915.5625\n", + "Epoch 23/100\n", + "2/2 [==============================] - 0s 50ms/step - loss: 12538.0781 - mse: 12538.0781 - val_loss: 6908.1865 - val_mse: 6908.1865\n", + "Epoch 24/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12543.6709 - mse: 12543.6709 - val_loss: 6900.8511 - val_mse: 6900.8511\n", + "Epoch 25/100\n", + "2/2 [==============================] - 0s 46ms/step - loss: 12539.5977 - mse: 12539.5977 - val_loss: 6894.5586 - val_mse: 6894.5586\n", + "Epoch 26/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12539.6719 - mse: 12539.6719 - val_loss: 6887.9038 - val_mse: 6887.9038\n", + "Epoch 27/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12538.1367 - mse: 12538.1367 - val_loss: 6881.5728 - val_mse: 6881.5728\n", + "Epoch 28/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12542.5918 - mse: 12542.5918 - val_loss: 6875.3584 - val_mse: 6875.3584\n", + "Epoch 29/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12533.7070 - mse: 12533.7070 - val_loss: 6869.7583 - val_mse: 6869.7583\n", + "Epoch 30/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12548.0664 - mse: 12548.0664 - val_loss: 6863.9131 - val_mse: 6863.9131\n", + "Epoch 31/100\n", + "2/2 [==============================] - 0s 47ms/step - loss: 12532.1807 - mse: 12532.1807 - val_loss: 6858.8984 - val_mse: 6858.8984\n", + "Epoch 32/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12531.9277 - mse: 12531.9277 - val_loss: 6854.0508 - val_mse: 6854.0508\n", + "Epoch 33/100\n", + "2/2 [==============================] - 0s 59ms/step - loss: 12537.1016 - mse: 12537.1016 - val_loss: 6849.8359 - val_mse: 6849.8359\n", + "Epoch 34/100\n", + "2/2 [==============================] - 0s 38ms/step - loss: 12532.6133 - mse: 12532.6133 - val_loss: 6845.2505 - val_mse: 6845.2505\n", + "Epoch 35/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12538.8633 - mse: 12538.8633 - val_loss: 6840.6216 - val_mse: 6840.6216\n", + "Epoch 36/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12531.0820 - mse: 12531.0820 - val_loss: 6836.4883 - val_mse: 6836.4883\n", + "Epoch 37/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12533.3271 - mse: 12533.3271 - val_loss: 6832.3882 - val_mse: 6832.3882\n", + "Epoch 38/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12530.0039 - mse: 12530.0039 - val_loss: 6828.8008 - val_mse: 6828.8008\n", + "Epoch 39/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12529.7305 - mse: 12529.7305 - val_loss: 6825.2300 - val_mse: 6825.2300\n", + "Epoch 40/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12532.9531 - mse: 12532.9531 - val_loss: 6822.1538 - val_mse: 6822.1538\n", + "Epoch 41/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12545.0898 - mse: 12545.0898 - val_loss: 6819.2314 - val_mse: 6819.2314\n", + "Epoch 42/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12530.6523 - mse: 12530.6523 - val_loss: 6815.5562 - val_mse: 6815.5562\n", + "Epoch 43/100\n", + "2/2 [==============================] - 0s 40ms/step - loss: 12526.3711 - mse: 12526.3711 - val_loss: 6809.5137 - val_mse: 6809.5137\n", + "Epoch 44/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12515.4746 - mse: 12515.4746 - val_loss: 6797.6768 - val_mse: 6797.6768\n", + "Epoch 45/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12492.8398 - mse: 12492.8398 - val_loss: 6772.5537 - val_mse: 6772.5537\n", + "Epoch 46/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12305.8164 - mse: 12305.8164 - val_loss: 6718.9775 - val_mse: 6718.9775\n", + "Epoch 47/100\n", + "2/2 [==============================] - 0s 40ms/step - loss: 11177.3145 - mse: 11177.3145 - val_loss: 38427.1367 - val_mse: 38427.1367\n", + "Epoch 48/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 37039.4844 - mse: 37039.4844 - val_loss: 12114.6426 - val_mse: 12114.6426\n", + "Epoch 49/100\n", + "2/2 [==============================] - 0s 46ms/step - loss: 379740.7188 - mse: 379740.7188 - val_loss: 6984.1729 - val_mse: 6984.1729\n", + "Epoch 50/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12546.5430 - mse: 12546.5430 - val_loss: 6973.8364 - val_mse: 6973.8364\n", + "Epoch 51/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12557.4473 - mse: 12557.4473 - val_loss: 6963.4180 - val_mse: 6963.4180\n", + "Epoch 52/100\n", + "2/2 [==============================] - 0s 47ms/step - loss: 12543.7080 - mse: 12543.7080 - val_loss: 6954.1152 - val_mse: 6954.1152\n", + "Epoch 53/100\n", + "2/2 [==============================] - 0s 76ms/step - loss: 12544.0078 - mse: 12544.0078 - val_loss: 6945.3711 - val_mse: 6945.3711\n", + "Epoch 54/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12556.0166 - mse: 12556.0166 - val_loss: 6937.4219 - val_mse: 6937.4219\n", + "Epoch 55/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12555.8555 - mse: 12555.8555 - val_loss: 6929.8418 - val_mse: 6929.8418\n", + "Epoch 56/100\n", + "2/2 [==============================] - 0s 46ms/step - loss: 12539.0918 - mse: 12539.0918 - val_loss: 6921.9487 - val_mse: 6921.9487\n", + "Epoch 57/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12545.1680 - mse: 12545.1680 - val_loss: 6914.0068 - val_mse: 6914.0068\n", + "Epoch 58/100\n", + "2/2 [==============================] - 0s 48ms/step - loss: 12538.1182 - mse: 12538.1182 - val_loss: 6906.6826 - val_mse: 6906.6826\n", + "Epoch 59/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12536.4043 - mse: 12536.4043 - val_loss: 6899.8540 - val_mse: 6899.8540\n", + "Epoch 60/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12545.4170 - mse: 12545.4170 - val_loss: 6893.7852 - val_mse: 6893.7852\n", + "Epoch 61/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12540.1338 - mse: 12540.1338 - val_loss: 6887.1465 - val_mse: 6887.1465\n", + "Epoch 62/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12535.9805 - mse: 12535.9805 - val_loss: 6881.3438 - val_mse: 6881.3438\n", + "Epoch 63/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12533.7822 - mse: 12533.7822 - val_loss: 6875.5820 - val_mse: 6875.5820\n", + "Epoch 64/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12534.3340 - mse: 12534.3340 - val_loss: 6869.9229 - val_mse: 6869.9229\n", + "Epoch 65/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12544.7490 - mse: 12544.7490 - val_loss: 6864.1406 - val_mse: 6864.1406\n", + "Epoch 66/100\n", + "2/2 [==============================] - 0s 48ms/step - loss: 12532.7070 - mse: 12532.7070 - val_loss: 6859.2402 - val_mse: 6859.2402\n", + "Epoch 67/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12540.0264 - mse: 12540.0264 - val_loss: 6854.8760 - val_mse: 6854.8760\n", + "Epoch 68/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12532.3975 - mse: 12532.3975 - val_loss: 6850.1201 - val_mse: 6850.1201\n", + "Epoch 69/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12539.5771 - mse: 12539.5771 - val_loss: 6846.1504 - val_mse: 6846.1504\n", + "Epoch 70/100\n", + "2/2 [==============================] - 0s 48ms/step - loss: 12534.7676 - mse: 12534.7676 - val_loss: 6842.2109 - val_mse: 6842.2109\n", + "Epoch 71/100\n", + "2/2 [==============================] - 0s 47ms/step - loss: 12535.3730 - mse: 12535.3730 - val_loss: 6837.8101 - val_mse: 6837.8101\n", + "Epoch 72/100\n", + "2/2 [==============================] - 0s 40ms/step - loss: 12530.4844 - mse: 12530.4844 - val_loss: 6834.0049 - val_mse: 6834.0049\n", + "Epoch 73/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12535.9141 - mse: 12535.9141 - val_loss: 6830.6431 - val_mse: 6830.6431\n", + "Epoch 74/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12529.7637 - mse: 12529.7637 - val_loss: 6827.0908 - val_mse: 6827.0908\n", + "Epoch 75/100\n", + "2/2 [==============================] - 0s 46ms/step - loss: 12537.2832 - mse: 12537.2832 - val_loss: 6824.0693 - val_mse: 6824.0693\n", + "Epoch 76/100\n", + "2/2 [==============================] - 0s 46ms/step - loss: 12560.0615 - mse: 12560.0615 - val_loss: 6821.5796 - val_mse: 6821.5796\n", + "Epoch 77/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12534.9043 - mse: 12534.9043 - val_loss: 6818.0249 - val_mse: 6818.0249\n", + "Epoch 78/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12530.1738 - mse: 12530.1738 - val_loss: 6814.8101 - val_mse: 6814.8101\n", + "Epoch 79/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12530.2627 - mse: 12530.2627 - val_loss: 6811.7124 - val_mse: 6811.7124\n", + "Epoch 80/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12531.0273 - mse: 12531.0273 - val_loss: 6809.1479 - val_mse: 6809.1479\n", + "Epoch 81/100\n", + "2/2 [==============================] - 0s 54ms/step - loss: 12528.5293 - mse: 12528.5293 - val_loss: 6806.4868 - val_mse: 6806.4868\n", + "Epoch 82/100\n", + "2/2 [==============================] - 0s 48ms/step - loss: 12528.3770 - mse: 12528.3770 - val_loss: 6803.9165 - val_mse: 6803.9165\n", + "Epoch 83/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12530.9883 - mse: 12530.9883 - val_loss: 6801.2090 - val_mse: 6801.2090\n", + "Epoch 84/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12528.4297 - mse: 12528.4297 - val_loss: 6798.7744 - val_mse: 6798.7744\n", + "Epoch 85/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12542.8262 - mse: 12542.8262 - val_loss: 6797.0767 - val_mse: 6797.0767\n", + "Epoch 86/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12527.9600 - mse: 12527.9600 - val_loss: 6794.8916 - val_mse: 6794.8916\n", + "Epoch 87/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12527.9473 - mse: 12527.9473 - val_loss: 6792.7568 - val_mse: 6792.7568\n", + "Epoch 88/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12532.5371 - mse: 12532.5371 - val_loss: 6790.4355 - val_mse: 6790.4355\n", + "Epoch 89/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12530.3691 - mse: 12530.3691 - val_loss: 6788.7583 - val_mse: 6788.7583\n", + "Epoch 90/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12536.0205 - mse: 12536.0205 - val_loss: 6786.4990 - val_mse: 6786.4990\n", + "Epoch 91/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12528.2305 - mse: 12528.2305 - val_loss: 6784.8643 - val_mse: 6784.8643\n", + "Epoch 92/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12538.0020 - mse: 12538.0020 - val_loss: 6782.7163 - val_mse: 6782.7163\n", + "Epoch 93/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12529.5488 - mse: 12529.5488 - val_loss: 6780.9121 - val_mse: 6780.9121\n", + "Epoch 94/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12530.9824 - mse: 12530.9824 - val_loss: 6779.1187 - val_mse: 6779.1187\n", + "Epoch 95/100\n", + "2/2 [==============================] - 0s 46ms/step - loss: 12529.6895 - mse: 12529.6895 - val_loss: 6777.8877 - val_mse: 6777.8877\n", + "Epoch 96/100\n", + "2/2 [==============================] - 0s 40ms/step - loss: 12530.5879 - mse: 12530.5879 - val_loss: 6776.2295 - val_mse: 6776.2295\n", + "Epoch 97/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12527.2910 - mse: 12527.2910 - val_loss: 6774.9199 - val_mse: 6774.9199\n", + "Epoch 98/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12533.8867 - mse: 12533.8867 - val_loss: 6774.0078 - val_mse: 6774.0078\n", + "Epoch 99/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12530.3994 - mse: 12530.3994 - val_loss: 6772.5107 - val_mse: 6772.5107\n", + "Epoch 100/100\n", + "2/2 [==============================] - 0s 50ms/step - loss: 12527.2217 - mse: 12527.2217 - val_loss: 6771.3604 - val_mse: 6771.3604\n" + ] + } + ], + "source": [ + "results=model.fit(x_train,y_train,epochs=100,validation_split=0.2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jmeP6vt3z0oA" + }, + "source": [ + "## Plot Loss\n", + "\n", + "Using matplotlib visualise how the loss (both validation and training) is changing, use this information to retrain the model with appropriate parameters.
We ideally want the loss to be constant over the last few iterations." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "id": "RQTNqPHm0mOi", + "outputId": "a2aa2f5d-d682-4afa-b3e9-457edfd64ccd" + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
lossmseval_lossval_mseepoch
9512530.58789112530.5878916776.2294926776.22949295
9612527.29101612527.2910166774.9199226774.91992296
9712533.88671912533.8867196774.0078126774.00781297
9812530.39941412530.3994146772.5107426772.51074298
9912527.22168012527.2216806771.3603526771.36035299
\n", + "
" + ], + "text/plain": [ + " loss mse val_loss val_mse epoch\n", + "95 12530.587891 12530.587891 6776.229492 6776.229492 95\n", + "96 12527.291016 12527.291016 6774.919922 6774.919922 96\n", + "97 12533.886719 12533.886719 6774.007812 6774.007812 97\n", + "98 12530.399414 12530.399414 6772.510742 6772.510742 98\n", + "99 12527.221680 12527.221680 6771.360352 6771.360352 99" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "res=pd.DataFrame(results.history)\n", + "res['epoch']=results.epoch\n", + "res.tail()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "ubeaG8e9t7im", + "outputId": "f763ebb3-d143-484d-b333-ccda2479bdb7" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYkAAAD4CAYAAAAZ1BptAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAl40lEQVR4nO3df5xU9X3v8ddnZhcwmvDLDTEsFow0BhVBN4Ihrb8aRdNe1IfhSk0kxoYm0Whjm2h8pLGa0Ic+aqvFa01MQNHkitSYK6lYwlWjsbcSFiUoYOoKWpYgID81BNiZ+dw/zndgdnZmd3b3rDtn9v18POaxZz7ne37t2Z3PfH+cc8zdERERKSXV3zsgIiLVS0lCRETKUpIQEZGylCRERKQsJQkRESmrrr93IG5HH320jx07tr93Q0QkUVatWvW2uzcUx2suSYwdO5bm5ub+3g0RkUQxszdLxdXcJCIiZSlJiIhIWUoSIiJSVs31SYjIwNHW1kZrayv79+/v711JjCFDhtDY2Eh9fX1F5ZUkRCSxWltbef/738/YsWMxs/7enarn7uzYsYPW1lbGjRtX0TJqbhKRxNq/fz8jR45UgqiQmTFy5Mhu1byUJEQk0ZQguqe7vy8lCZE+8PO1b7HtHbWTS/IpSYjELJPN8aUfrWLxyk39vSvyHjjqqKP6exf6lJKESMwyOSfncDCT6+9dEek1JQmRmLVlo+SQyempjwPV6tWrmTp1KhMnTuTiiy9m165dAMybN48JEyYwceJELrvsMgCeffZZJk2axKRJk5g8eTLvvPNOf+56BxoCKxKzbEgOWSWJ99QtP1vLut/ujXWdEz78AW7+sxO7vdwVV1zB3XffzZlnnsm3v/1tbrnlFu666y5uu+02Nm7cyODBg9m9ezcAd9xxB/fccw/Tpk3j3XffZciQIbEeQ2+pJiESs3wNQjWJgWnPnj3s3r2bM888E4DZs2fz3HPPATBx4kQuv/xyfvSjH1FXF31HnzZtGtdffz3z5s1j9+7dh+LVorr2RqQGZLKqSfSHnnzjf6898cQTPPfcc/zsZz9j7ty5vPzyy9x44418+tOfZunSpUybNo1ly5Zxwgkn9PeuHqKahEjMMrlcu58ysAwdOpThw4fzy1/+EoCHHnqIM888k1wux6ZNmzj77LO5/fbb2bNnD++++y6vv/46J598MjfccAMf//jHefXVV/v5CNpTTUIkZuqTGFj27dtHY2PjoffXX389Cxcu5Etf+hL79u3juOOO4/777yebzfLZz36WPXv24O5ce+21DBs2jL/927/lmWeeIZVKceKJJ3LBBRf049F0pCQhErO20NyUb3aS2pYrU2N84YUXOsSef/75DrG777479n2Kk5qbRGKmmoTUEiUJkZgd7pNQkpDkU5IQiZlGN0ktUZIQidnh6yQ0ukmSr8skYWZDzOxXZvZrM1trZreE+ANmttHMVofXpBA3M5tnZi1mtsbMTi1Y12wzey28ZhfETzOzl8My8yzcy9bMRpjZ8lB+uZkNj/03IBIz9UlILamkJnEAOMfdTwEmAdPNbGqY93V3nxReq0PsAmB8eM0B7oXoAx+4GZgCnA7cXPChfy/wxYLlpof4jcBT7j4eeCq8F6lqGd27SWpIl0nCI++Gt/Xh1dlf/wzgwbDcC8AwMzsGOB9Y7u473X0XsJwo4RwDfMDdX3B3Bx4ELipY18IwvbAgLlK1MqpJSA2pqE/CzNJmthrYRvRBvyLMmhualO40s8EhNhoovJF+a4h1Fm8tEQcY5e5bwvRbwKgy+zfHzJrNrHn79u2VHJJIn8knB10nUfvOPvtsli1b1i5211138eUvf7lk+bPOOovm5uay6xs7dixvv/12rPvYWxUlCXfPuvskoBE43cxOAr4JnAB8HBgB3NBXOxn2wSlTg3H3+9y9yd2bGhoa+nI3RLqUv1W4ahK1b9asWSxatKhdbNGiRcyaNauf9ih+3bri2t13m9kzwHR3vyOED5jZ/cDfhPebgTEFizWG2GbgrKL4L0K8sUR5gK1mdoy7bwnNUtu6s78i/SGr0U3948kb4a2X413nh06GC24rO/vSSy/lW9/6FgcPHmTQoEG88cYb/Pa3v+Xhhx/m+uuv5/e//z2XXnopt9xyS4934Y033uALX/gCb7/9Ng0NDdx///0ce+yx/Ou//iu33HIL6XSaoUOH8txzz7F27VquvPJKDh48SC6X4yc/+Qnjx4/v8bahstFNDWY2LEwfAXwKeDV8aBNGIl0EvBIWWQJcEUY5TQX2hCajZcB5ZjY8dFifBywL8/aa2dSwriuAxwvWlR8FNbsgLlK11CcxcIwYMYLTTz+dJ598EohqETNnzmTu3Lk0NzezZs0ann32WdasWdPjbXz1q19l9uzZrFmzhssvv5xrr70WgFtvvZVly5bx61//miVLlgDwve99j+uuu47Vq1fT3Nzc7p5SPVVJTeIYYKGZpYmSymJ3/zcze9rMGgADVgNfCuWXAhcCLcA+4EoAd99pZt8BVoZyt7r7zjD9FeAB4AjgyfACuA1YbGZXAW8CM3t4nCLvmXwNok19Eu+tTr7x96V8k9OMGTNYtGgR8+fPZ/Hixdx3331kMhm2bNnCunXrmDhxYo/W/5//+Z889thjAHzuc5/jG9/4BhA9h+Lzn/88M2fO5JJLLgHgjDPOYO7cubS2tnLJJZf0uhYBFSQJd18DTC4RP6dMeQeuLjNvAbCgRLwZOKlEfAdwblf7KFJNdMX1wDJjxgy+9rWv8eKLL7Jv3z5GjBjBHXfcwcqVKxk+fDif//zn2b9/f+zb/d73vseKFSt44oknOO2001i1ahV//ud/zpQpU3jiiSe48MIL+f73v88555T8qK6YrrgWiZn6JAaWo446irPPPpsvfOELzJo1i71793LkkUcydOhQtm7deqgpqqc+8YlPHOoc//GPf8wf/dEfAfD6668zZcoUbr31VhoaGti0aRMbNmzguOOO49prr2XGjBm9aubK063CRWLWpj6JAWfWrFlcfPHFLFq0iBNOOIHJkydzwgknMGbMGKZNm9atdU2cOJFUKvr+PnPmTO6++26uvPJK/uEf/uFQxzXA17/+dV577TXcnXPPPZdTTjmF22+/nYceeoj6+no+9KEPcdNNN/X62CxqHaodTU1N3tk4ZJG+9sB/bOTvfraOxuFH8PwNvavqS+fWr1/Pxz72sf7ejcQp9Xszs1Xu3lRcVs1NIjHT6CapJWpuEonZ4bvAKklIaVOmTOHAgQPtYg899BAnn3xyP+1ReUoSIjHTXWDfW+5OuHF0YqxYsaLrQn2ku10Mam4SiVnm0DOuNbqprw0ZMoQdO3Z0+4NvoHJ3duzYwZAhQypeRjUJkZjlh76qJtH3GhsbaW1tRTf2rNyQIUO6dSW2koRIzNQn8d6pr69n3Lhx/b0bNU3NTSIxU5+E1BIlCZGYtRU8mU5t5ZJ0ShIiMSusQagyIUmnJCESs8K+CN2/SZJOSUIkZoVDX9UvIUmnJCESs/Y1CSUJSTYlCZGYFdYesnrwkCSckoRIzDJZ1SSkdlTyjOshZvYrM/u1ma01s1tCfJyZrTCzFjN7xMwGhfjg8L4lzB9bsK5vhvhvzOz8gvj0EGsxsxsL4iW3IVLNCjur1SchSVdJTeIAcI67nwJMAqab2VTgduBOdz8e2AVcFcpfBewK8TtDOcxsAnAZcCIwHfgXM0uHZ2ffA1wATABmhbJ0sg2RqpXV6CapIV0mCY+8G97Wh5cD5wCPhvhC4KIwPSO8J8w/16JbNM4AFrn7AXffCLQAp4dXi7tvcPeDwCJgRlim3DZEqlZbQXOTahKSdBX1SYRv/KuBbcBy4HVgt7tnQpFWYHSYHg1sAgjz9wAjC+NFy5SLj+xkGyJVK6vRTVJDKkoS7p5190lAI9E3/xP6cqe6y8zmmFmzmTXrbpDS3wqbmDIa3SQJ163RTe6+G3gGOAMYZmb5u8g2ApvD9GZgDECYPxTYURgvWqZcfEcn2yjer/vcvcndmxoaGrpzSCKxaz+6SX0SkmyVjG5qMLNhYfoI4FPAeqJkcWkoNht4PEwvCe8J85/26C5nS4DLwuinccB44FfASmB8GMk0iKhze0lYptw2RKpWYROT+iQk6Sp5nsQxwMIwCikFLHb3fzOzdcAiM/su8BIwP5SfDzxkZi3ATqIPfdx9rZktBtYBGeBqd88CmNk1wDIgDSxw97VhXTeU2YZI1crmnJRFN/dTn4QkXZdJwt3XAJNLxDcQ9U8Ux/cDnymzrrnA3BLxpcDSSrchUs3asjkG16X5fVtWNQlJPF1xLRKzbM4ZUh/9a6njWpJOSUIkZtmcM7gufWhaJMmUJERi1pbLMThfk9DoJkk4JQmRmGWzzhDVJKRGKEmIxCyT84KahJKEJJuShEjMMjnVJKR2KEmIxCyTzakmITVDSUIkZu1HN6njWpJNSUIkZm2FfRK6TkISTklCJGZZ9UlIDVGSEImRu0fNTeqTkBqhJCESo3xSGFwX/WupJiFJpyQhEqN8UhhSHzU3qSYhSackIRKjjjUJjW6SZFOSEIlRJhslhfwQWNUkJOmUJERilDnU3BRqEhoCKwmnJCESo3yfxKA6jW6S2qAkIRKjttDcVJ9KkU6ZRjdJ4nWZJMxsjJk9Y2brzGytmV0X4n9nZpvNbHV4XViwzDfNrMXMfmNm5xfEp4dYi5ndWBAfZ2YrQvwRMxsU4oPD+5Ywf2ysRy8Ss3xSqEsb6ZTRpo5rSbhKahIZ4K/dfQIwFbjazCaEeXe6+6TwWgoQ5l0GnAhMB/7FzNJmlgbuAS4AJgCzCtZze1jX8cAu4KoQvwrYFeJ3hnIiVSvfvJROGXUpU5+EJF6XScLdt7j7i2H6HWA9MLqTRWYAi9z9gLtvBFqA08Orxd03uPtBYBEww8wMOAd4NCy/ELioYF0Lw/SjwLmhvEhVyt+rqS40N6lPQpKuW30SoblnMrAihK4xszVmtsDMhofYaGBTwWKtIVYuPhLY7e6Zoni7dYX5e0L54v2aY2bNZta8ffv27hySSKzyjyutS4eahJKEJFzFScLMjgJ+AvyVu+8F7gU+AkwCtgD/2Bc7WAl3v8/dm9y9qaGhob92Q+Rwn0TKSKdSqklI4lWUJMysnihB/NjdHwNw963unnX3HPADouYkgM3AmILFG0OsXHwHMMzM6ori7dYV5g8N5UWqUlu2qE9CHdeScJWMbjJgPrDe3f+pIH5MQbGLgVfC9BLgsjAyaRwwHvgVsBIYH0YyDSLq3F7i7g48A1walp8NPF6wrtlh+lLg6VBepCrlaxL1afVJSG2o67oI04DPAS+b2eoQu4lodNIkwIE3gL8EcPe1ZrYYWEc0Mupqd88CmNk1wDIgDSxw97VhfTcAi8zsu8BLREmJ8PMhM2sBdhIlFpGqle+TSKeMurT6JCT5ukwS7v48UGpE0dJOlpkLzC0RX1pqOXffwOHmqsL4fuAzXe2jSLU4PLrJVJOQmqArrkVidPhiuhT1qZSuk5DEU5IQiVEmp5qE1BYlCZEY5W8VfrhPQqObJNmUJERilDk0ukk1CakNShIiMcoeundTSldcS01QkhCJUf5W4eqTkFqhJCESo8JbhdelUqpJSOIpSYjEqPBW4apJSC1QkhCJUeZQc1NK926SmqAkIRKjTNGT6TK6mE4STklCJEaFtwrXvZukFihJiMSofZ+EOq4l+ZQkRGKUb16qD30S6riWpFOSEIlRNpfDDFL50U1ZdVxLsilJiMSoLefUpaI766smIbVASUIkRtmcU5eK/q3Sui2H1AAlCZEYZbKqSUhtqeQZ12PM7BkzW2dma83suhAfYWbLzey18HN4iJuZzTOzFjNbY2anFqxrdij/mpnNLoifZmYvh2Xmhedql92GSLXK5HKk01GS0OgmqQWV1CQywF+7+wRgKnC1mU0AbgSecvfxwFPhPcAFwPjwmgPcC9EHPnAzMIXoUaU3F3zo3wt8sWC56SFebhsiVSlT0NxUl7ZDz7wWSaouk4S7b3H3F8P0O8B6YDQwA1gYii0ELgrTM4AHPfICMMzMjgHOB5a7+0533wUsB6aHeR9w9xfc3YEHi9ZVahsiVSlb0NykPgmpBd3qkzCzscBkYAUwyt23hFlvAaPC9GhgU8FirSHWWby1RJxOtlG8X3PMrNnMmrdv396dQxKJVVsuR1p9ElJDKk4SZnYU8BPgr9x9b+G8UAPo0/+Gzrbh7ve5e5O7NzU0NPTlboh0Kptz6tP5JJHCHXJKFJJgFSUJM6snShA/dvfHQnhraCoi/NwW4puBMQWLN4ZYZ/HGEvHOtiFSlTI5P1yTCMlCtQlJskpGNxkwH1jv7v9UMGsJkB+hNBt4vCB+RRjlNBXYE5qMlgHnmdnw0GF9HrAszNtrZlPDtq4oWlepbYhUpUw21+46CUD9EpJodRWUmQZ8DnjZzFaH2E3AbcBiM7sKeBOYGeYtBS4EWoB9wJUA7r7TzL4DrAzlbnX3nWH6K8ADwBHAk+FFJ9sQqUrZnB+qQeQ7sKMRTul+3CuRnusySbj784CVmX1uifIOXF1mXQuABSXizcBJJeI7Sm1DpFplcu1HN4FqEpJsuuJaJEaZrLcb3QTqk5BkU5IQiVEml6Mune+TiH6qJiFJpiQhEqNs0V1gQTUJSTYlCZEYtRU0Nx3qk9BzriXBlCREYhRdTHf43k2A7t8kiaYkIRKjwovpNLpJaoGShEiMoovp1CchtUNJQiRG0cV0Gt0ktUNJQiRGGY1ukhqjJCESo0w2V6JPQh3XklxKEiIxyrS7VXj0s01DYCXBlCREYpTV6CapMUoSIjFqK7hVuJ4nIbVASUIkRtl2d4HNj25Sn4Qkl5KESIwyOSdd/DwJ9UlIgilJiMRIz5OQWqMkIRITdw/NTaFPQtdJSA1QkhCJSb7GcOhiurSuuJbk6zJJmNkCM9tmZq8UxP7OzDab2erwurBg3jfNrMXMfmNm5xfEp4dYi5ndWBAfZ2YrQvwRMxsU4oPD+5Ywf2xsRy3SB/I1hg59EkoSkmCV1CQeAKaXiN/p7pPCaymAmU0ALgNODMv8i5mlzSwN3ANcAEwAZoWyALeHdR0P7AKuCvGrgF0hfmcoJ1K18smgPpW/d5OuuJbk6zJJuPtzwM4K1zcDWOTuB9x9I9ACnB5eLe6+wd0PAouAGWZmwDnAo2H5hcBFBetaGKYfBc4N5UWqUv7hQnrGtdSS3vRJXGNma0Jz1PAQGw1sKijTGmLl4iOB3e6eKYq3W1eYvyeU78DM5phZs5k1b9++vReHJNJzbaHGkL+ITqObpBb0NEncC3wEmARsAf4xrh3qCXe/z92b3L2poaGhP3dFBrDDHdepdj91nYQkWY+ShLtvdfesu+eAHxA1JwFsBsYUFG0MsXLxHcAwM6srirdbV5g/NJQXqUqZotFN+Q5s1SQkyXqUJMzsmIK3FwP5kU9LgMvCyKRxwHjgV8BKYHwYyTSIqHN7ibs78AxwaVh+NvB4wbpmh+lLgadDeZGqlMlGzU3qk5BaUtdVATN7GDgLONrMWoGbgbPMbBLgwBvAXwK4+1ozWwysAzLA1e6eDeu5BlgGpIEF7r42bOIGYJGZfRd4CZgf4vOBh8yshajj/LLeHqxIXzpUk+jQJ6HRTZJcXSYJd59VIjy/RCxffi4wt0R8KbC0RHwDh5urCuP7gc90tX8i1aK4TyJtqklI8umKa5GYtBU1N6VSRsrUJyHJpiQhEpN8Msg/mQ6iWoVqEpJkShIiMTl0W47U4SSRTplqEpJoShIiMclfD5Hvk4imTddJSKIpSYjEJFN0xTVE10podJMkmZKESEyKbxWen25Tc5MkmJKESEwy2TJ9EmpukgRTkhCJyaFbhacL+yQ0ukmSTUlCJCb5voeOo5vUJyHJpSQhEpO2bOk+CdUkJMmUJERicqjjuqC5SddJSNIpSYjEpPhW4RAlDNUkJMmUJERiUnyrcIgShmoSkmRKEiIxKb5VOEQJQzUJSTIlCZGYFN8qPJrW6CZJNiUJkZgU3yo8P617N0mSKUmIxKTkrcLT6pOQZOsySZjZAjPbZmavFMRGmNlyM3st/Bwe4mZm88ysxczWmNmpBcvMDuVfM7PZBfHTzOzlsMw8s+hxXuW2IVKtSt8qXKObJNkqqUk8AEwvit0IPOXu44GnwnuAC4Dx4TUHuBeiD3yiZ2NPIXpU6c0FH/r3Al8sWG56F9sQqUrlbhWumoQkWZdJwt2fA3YWhWcAC8P0QuCigviDHnkBGGZmxwDnA8vdfae77wKWA9PDvA+4+wvu7sCDResqtQ2RqpTN5TAr0SehJCEJ1tM+iVHuviVMvwWMCtOjgU0F5VpDrLN4a4l4Z9vowMzmmFmzmTVv3769B4cj0nuZnLe7kA40ukmSr9cd16EG0Kdflbrahrvf5+5N7t7U0NDQl7siUlYm5+1qEaCahCRfT5PE1tBURPi5LcQ3A2MKyjWGWGfxxhLxzrYhUpUyWac+1f5fSn0SknQ9TRJLgPwIpdnA4wXxK8Iop6nAntBktAw4z8yGhw7r84BlYd5eM5saRjVdUbSuUtsQqUrZXI50urgmkdJ1EpJodV0VMLOHgbOAo82slWiU0m3AYjO7CngTmBmKLwUuBFqAfcCVAO6+08y+A6wM5W5193xn+FeIRlAdATwZXnSyDZGq1Fa2T0JJQpKryyTh7rPKzDq3RFkHri6zngXAghLxZuCkEvEdpbYhUq2yWW83/BUgnVafhCSbrrgWiUmpjmuNbpKkU5IQiUkml2t3B1jQ6CZJPiUJkZiUq0mo41qSTElCJCbZEkNg06mUOq4l0ZQkRGKSyeVK1yTUJyEJpiQhEpNMzkv2SeQccqpNSEIpSYjEJJPteJ1E/tkSWVeSkGRSkhCJSSaX63idRHivfglJKiUJkZhky4xuAjQMVhJLSUIkJm3Z0n0SEI18EkkiJQmRmGRL3bspna9JaISTJJOShEhMoovpivskQk1CzU2SUEoSIjHJZHOHRjPlqU9Ckk5JQiQmpTquNbpJkk5JQiQm5Z5xnZ8nkkRKEiIxyWRz1KXL9Umo41qSSUlCJCaqSUgtUpIQiUnpPomQJHSdhCRUr5KEmb1hZi+b2Wozaw6xEWa23MxeCz+Hh7iZ2TwzazGzNWZ2asF6Zofyr5nZ7IL4aWH9LWFZ67gXItWhLZujvqi5KX+dhDquJaniqEmc7e6T3L0pvL8ReMrdxwNPhfcAFwDjw2sOcC9ESQW4GZgCnA7cnE8socwXC5abHsP+ivSJzkY3qblJkqovmptmAAvD9ELgooL4gx55ARhmZscA5wPL3X2nu+8ClgPTw7wPuPsL7u7AgwXrEqk6nfVJqCYhSdXbJOHAz81slZnNCbFR7r4lTL8FjArTo4FNBcu2hlhn8dYS8Q7MbI6ZNZtZ8/bt23tzPCI9Vu55EtE8jW6SZKrr5fKfdPfNZvZBYLmZvVo4093dzPr8K5S73wfcB9DU1KSvbPKec/fQ3FTUJ6GahCRcr2oS7r45/NwG/JSoT2FraCoi/NwWim8GxhQs3hhincUbS8RFqk4+CRQ3N6U1BFYSrsdJwsyONLP356eB84BXgCVAfoTSbODxML0EuCKMcpoK7AnNUsuA88xseOiwPg9YFubtNbOpYVTTFQXrEqkq+SRQ3NyUfwiRhsBKUvWmuWkU8NMwKrUO+N/u/u9mthJYbGZXAW8CM0P5pcCFQAuwD7gSwN13mtl3gJWh3K3uvjNMfwV4ADgCeDK8RKpOpouahK64lqTqcZJw9w3AKSXiO4BzS8QduLrMuhYAC0rEm4GTerqPIn0q2wa/uA2mfpmsDQXo2CeRVnOTJJuuuBbpqU0r4Jd3wJpHOJiNagrFtwrX8yQk6ZQkRHrqrVein60reW3bOwCMGfG+dkXq1SchCdfbIbAiA9fWl6Ofm1by4shdAJw6Zni7ImndlkMSTjUJkZ7K1yT2trJhQwvHf/Aohr6vvl0R3QVWkk5JQqQnshnYth6OPQMA27ySU48d1qGYRjdJ0ilJiPTEjhbIHoBTZuGpQfxh26uc9gfDOxRTTUKSTn0SIj2xNTQ1jT6VHUM/xqk7XmPYsR2ThEY3SdKpJiHSE1tfgVQ9HP1RXk1/lJNTG/nIiEEditXpVuGScEoSIj3x1ivQ8FGoG8Qv9o1jCG2ktq3tUEw1CUk6JQmRntj6Cow6ib3721i6K9yHsnVlh2J1enypJJyShEh3/W4HvLMFPnQSq/97N7/1kRw44kMlk0QqZZhpdJMkl5KESHflL6IbdSKr3tyFGaSOPR02/apk8bqUqU9CEkujmwoczOR49r+289OXWtn49j7+ePzRfGrCKCYfO7zDs4tlANsa+h5GncyLv9jAR0e9n/o/OB1+swTe3QZHfbBd8XTK1CchiaUkETz0f5t55D/W88rvRzDyyEEc/8GjmP/8Rr7/3AYG16UYlC6odJXJF+XSSLidOtGNcEvPtwpzUHdTlZVYceF+lPvo6mw7pdbZleJjz68jv6aefIR2dy+8gv2IYu23YgYpg8F1aYbUp7hh/9N8vG4EP13zO1b/927+bNKHofH0qPjrT8Mpl7XbRn0qxf3/7w0ead5EscJNdfU76Op4u/o7KyxTbt35Jcv9nrqr1FKVnGt3D+ercB8gZdbt816JUvuU307+0Mv9Wrv6H+rJ/1hP3T1rMp84/uhY16kkEXxiw13MZDkbP/lNPjL9q9TXpdm7v41f/GY7azbtJv9F0Muc8k7+L7vU2T91u3LdXm/5eYX/88V/rPl/zlKfCz05TscxrMM/W/HvstS/f37ZUvGe6Go/Co/v8IeUk8vBgUyWA5kcH3lzI69kjuXmJVGNYsq4EfDhP4SGE2DJtVA3BE686NB6vvWnH2Pdb/eWOIZS+1fa4Q/vys5Ld85dufNQ6vcU1zmqZD1m0e/DzA4ljVxv/tG6ULjt/L5X8nstXja/fOG5KjW/O8qd92JHv39wt9ZbCav0AyopmpqavLm5ufsL7t4ES66BDb+A486GC++A940IZ8YO/4TS013NL54+9J7Kzr5Uh2wb/P2H8SlfZuuUm3hzx+9oGjsiao7ctxMenhXdQvz8v4czvtLfeytSMTNb5e5NHeJKEgXcoXk+/Pzb0Pa7eHesYlYiaRTGipNMqUTTkzKl4pSJl9i/svO6sb12xbu7njJlKl5v0fKFv28DLBW9PAe73oBLfgATZ3ZctO338NgXYf3Poovtyp634u2U2Pc+OV+9OVcdNtK9db2X5Stevpvr6vb3uR58AezNl8YZ98DYT/Zo0XJJouqbm8xsOvDPQBr4obvf1ocbg4//BRz/J/BfPwfPhvqmF9Q7S013Np8S8fAeDi9fPH2oWPH8UuvzovLltlmmTE/jXc3r1nopXaZX26pwvR2KFJ0P9yg55F/HfiL6Gyml/gj4zEJYdT/saS2/32XPdal9iul89eZcdbZ/3T4XcZUvU7wnBSv6stzNL9Q9+gLeyy/tQ4b1bvkSqromYWZp4L+ATwGtRM/BnuXu68ot06uahIjIAFWuJlHt10mcDrS4+wZ3PwgsAmb08z6JiAwY1Z4kRgOF4wZbQ6wdM5tjZs1m1rx9+/b3bOdERGpdtSeJirj7fe7e5O5NDQ0N/b07IiI1o9qTxGZgTMH7xhATEZH3QLUniZXAeDMbZ2aDgMuAJf28TyIiA0ZVD4F194yZXQMsIxoCu8DdO960X0RE+kRVJwkAd18KLO3v/RARGYiqvblJRET6UVVfTNcTZrYdeLOHix8NvB3j7iTFQDzugXjMMDCPeyAeM3T/uP/A3TsMD625JNEbZtZc6orDWjcQj3sgHjMMzOMeiMcM8R23mptERKQsJQkRESlLSaK9+/p7B/rJQDzugXjMMDCPeyAeM8R03OqTEBGRslSTEBGRspQkRESkLCWJwMymm9lvzKzFzG7s7/3pC2Y2xsyeMbN1ZrbWzK4L8RFmttzMXgs/h/f3vsbNzNJm9pKZ/Vt4P87MVoTz/Ui4N1hNMbNhZvaomb1qZuvN7IxaP9dm9rXwt/2KmT1sZkNq8Vyb2QIz22ZmrxTESp5bi8wLx7/GzE7tzraUJDj0BLx7gAuACcAsM5vQv3vVJzLAX7v7BGAqcHU4zhuBp9x9PPBUeF9rrgPWF7y/HbjT3Y8HdgFX9cte9a1/Bv7d3U8ATiE6/po912Y2GrgWaHL3k4ju93YZtXmuHwCmF8XKndsLgPHhNQe4tzsbUpKIDIgn4Ln7Fnd/MUy/Q/ShMZroWBeGYguBi/plB/uImTUCnwZ+GN4bcA7waChSi8c8FPhjYD6Aux90993U+Lkmuh/dEWZWB7wP2EINnmt3fw7YWRQud25nAA965AVgmJkdU+m2lCQiFT0Br5aY2VhgMrACGOXuW8Kst4BR/bVffeQu4BtALrwfCex290x4X4vnexywHbg/NLP90MyOpIbPtbtvBu4A/psoOewBVlH75zqv3Lnt1eebksQAZGZHAT8B/srd9xbO82hMdM2MizazPwW2ufuq/t6X91gdcCpwr7tPBn5HUdNSDZ7r4UTfmscBHwaOpGOTzIAQ57lVkogMmCfgmVk9UYL4sbs/FsJb89XP8HNbf+1fH5gG/A8ze4OoGfEcorb6YaFJAmrzfLcCre6+Irx/lChp1PK5/hNgo7tvd/c24DGi81/r5zqv3Lnt1eebkkRkQDwBL7TFzwfWu/s/FcxaAswO07OBx9/rfesr7v5Nd29097FE5/Vpd78ceAa4NBSrqWMGcPe3gE1m9tEQOhdYRw2fa6Jmpqlm9r7wt54/5po+1wXKndslwBVhlNNUYE9Bs1SXdMV1YGYXErVd55+AN7d/9yh+ZvZJ4JfAyxxun7+JqF9iMXAs0W3WZ7p7cadY4pnZWcDfuPufmtlxRDWLEcBLwGfd/UA/7l7szGwSUWf9IGADcCXRF8OaPddmdgvwP4lG8r0E/AVR+3tNnWszexg4i+h24FuBm4H/Q4lzGxLm/yJqetsHXOnuzRVvS0lCRETKUXOTiIiUpSQhIiJlKUmIiEhZShIiIlKWkoSIiJSlJCEiImUpSYiISFn/Hyv6lfNdObSZAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(res['epoch'],res['loss'])\n", + "plt.plot(res['epoch'],res['val_loss'])\n", + "plt.legend([\"Loss\",\"Val_Loss\"])\n", + "# plt.xlim(0,80)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IVrR_vXA7kOt" + }, + "source": [ + "## Evaluation Metrics\n", + "Use the R2 Score function implemented in the first assignment to evaluate the performance of the model." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "id": "-lOHpD8-7ggm" + }, + "outputs": [], + "source": [ + "# Insert the function for R2 Score\n", + "\n", + "def r2_score_predictor(y_true,y_pred):\n", + " from sklearn.metrics import r2_score\n", + " r=r2_score(y_true,y_pred)\n", + " return r\n", + "predictions=model.predict(x_test)\n", + "r=r2_score_predictor(y_test,predictions)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "SCApVNjtzbv8", + "outputId": "f108f6c9-9479-442a-f7f4-2c087c3986da" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The r2_score value is -0.0909121073526411\n" + ] + } + ], + "source": [ + "print(\"The r2_score value is \",r)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CHqzF1OU0pBg" + }, + "source": [ + "## Your own custom model\n", + "Build a custom model of your own choice.
\n", + "Describe it in detail in Markdown/Latex in the cell below.
\n", + "Visualise the loss, as before." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jF8oTUqq0y0g" + }, + "source": [ + "Your text here" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn import datasets\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "# Generate the data\n", + "x_2, y_2 = datasets.make_regression(n_samples=1000, n_features=5, noise=5, random_state=4)\n", + "\n", + "\n", + "# Split the data\n", + "x_train_2, x_test_2, y_train_2, y_test_2 = train_test_split(x_2, y_2, test_size=0.2, random_state=1234)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Instead of using SGD optimizer we can use Adam optimizer to get better results." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "1XOk5hJu0oSQ" + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "model_2=tf.keras.models.Sequential([\n", + " tf.keras.layers.InputLayer(input_shape=5) ,\n", + " tf.keras.layers.Dense(30,activation='relu'),\n", + " tf.keras.layers.Dense(30,activation='relu'),\n", + " tf.keras.layers.Dense(1)\n", + "\n", + " ])\n", + "\n", + "optimi=tf.keras.optimizers.Adam( learning_rate=0.01)\n", + "\n", + "\n", + "model_2.compile(loss='mean_squared_error',optimizer=optimi,metrics=tf.keras.metrics.Accuracy())\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " dense (Dense) (None, 30) 180 \n", + " \n", + " dense_1 (Dense) (None, 30) 930 \n", + " \n", + " dense_2 (Dense) (None, 1) 31 \n", + " \n", + "=================================================================\n", + "Total params: 1,141\n", + "Trainable params: 1,141\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "model_2.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "aS0ROZa402Lo", + "outputId": "c852055e-ec4f-4272-ad30-e068b76c623f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/20\n", + "20/20 [==============================] - 1s 17ms/step - loss: 22293.0352 - accuracy: 0.0000e+00 - val_loss: 22968.2930 - val_accuracy: 0.0000e+00\n", + "Epoch 2/20\n", + "20/20 [==============================] - 0s 5ms/step - loss: 16845.7617 - accuracy: 0.0000e+00 - val_loss: 11418.9531 - val_accuracy: 0.0000e+00\n", + "Epoch 3/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 4155.4365 - accuracy: 0.0000e+00 - val_loss: 745.3987 - val_accuracy: 0.0000e+00\n", + "Epoch 4/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 621.0253 - accuracy: 0.0000e+00 - val_loss: 412.5599 - val_accuracy: 0.0000e+00\n", + "Epoch 5/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 308.1701 - accuracy: 0.0000e+00 - val_loss: 312.2416 - val_accuracy: 0.0000e+00\n", + "Epoch 6/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 240.7342 - accuracy: 0.0000e+00 - val_loss: 267.2795 - val_accuracy: 0.0000e+00\n", + "Epoch 7/20\n", + "20/20 [==============================] - 0s 5ms/step - loss: 207.0453 - accuracy: 0.0000e+00 - val_loss: 246.7999 - val_accuracy: 0.0000e+00\n", + "Epoch 8/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 185.6382 - accuracy: 0.0000e+00 - val_loss: 233.2929 - val_accuracy: 0.0000e+00\n", + "Epoch 9/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 172.4978 - accuracy: 0.0000e+00 - val_loss: 238.8235 - val_accuracy: 0.0000e+00\n", + "Epoch 10/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 154.8446 - accuracy: 0.0000e+00 - val_loss: 173.0536 - val_accuracy: 0.0000e+00\n", + "Epoch 11/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 129.1207 - accuracy: 0.0000e+00 - val_loss: 134.6592 - val_accuracy: 0.0000e+00\n", + "Epoch 12/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 121.6438 - accuracy: 0.0000e+00 - val_loss: 122.1448 - val_accuracy: 0.0000e+00\n", + "Epoch 13/20\n", + "20/20 [==============================] - 0s 5ms/step - loss: 100.9714 - accuracy: 0.0000e+00 - val_loss: 108.3006 - val_accuracy: 0.0000e+00\n", + "Epoch 14/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 88.0066 - accuracy: 0.0000e+00 - val_loss: 93.5628 - val_accuracy: 0.0000e+00\n", + "Epoch 15/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 74.2823 - accuracy: 0.0000e+00 - val_loss: 83.5923 - val_accuracy: 0.0000e+00\n", + "Epoch 16/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 67.1191 - accuracy: 0.0000e+00 - val_loss: 84.6325 - val_accuracy: 0.0000e+00\n", + "Epoch 17/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 59.6604 - accuracy: 0.0000e+00 - val_loss: 64.3586 - val_accuracy: 0.0000e+00\n", + "Epoch 18/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 50.1667 - accuracy: 0.0000e+00 - val_loss: 57.6406 - val_accuracy: 0.0000e+00\n", + "Epoch 19/20\n", + "20/20 [==============================] - 0s 8ms/step - loss: 45.9919 - accuracy: 0.0000e+00 - val_loss: 50.3901 - val_accuracy: 0.0000e+00\n", + "Epoch 20/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 43.3895 - accuracy: 0.0000e+00 - val_loss: 46.8216 - val_accuracy: 0.0000e+00\n" + ] + } + ], + "source": [ + "results_2=model_2.fit(x_train_2,y_train_2,epochs=20,validation_split=0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "id": "-v9c8bWtxbgP", + "outputId": "19e97d03-36e9-4893-ace2-3da787fe8f49" + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
lossaccuracyval_lossval_accuracyepoch
1567.1190570.084.6324620.015
1659.6604310.064.3586040.016
1750.1667180.057.6405750.017
1845.9919090.050.3900990.018
1943.3894840.046.8216480.019
\n", + "
" + ], + "text/plain": [ + " loss accuracy val_loss val_accuracy epoch\n", + "15 67.119057 0.0 84.632462 0.0 15\n", + "16 59.660431 0.0 64.358604 0.0 16\n", + "17 50.166718 0.0 57.640575 0.0 17\n", + "18 45.991909 0.0 50.390099 0.0 18\n", + "19 43.389484 0.0 46.821648 0.0 19" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "res_2=pd.DataFrame(results_2.history)\n", + "res_2['epoch']=results_2.epoch\n", + "res_2.tail()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "6xWw8yxhxxmt", + "outputId": "4acfcf6e-3e59-48e7-fabe-3bac990417b3" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(res_2['epoch'],res_2['loss'])\n", + "plt.plot(res_2['epoch'],res_2['val_loss'])\n", + "plt.legend([\"Val_Loss\",\"Loss\"])\n", + "# plt.xlim(0,80)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "id": "FeWhnbAV0PUX" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "r2_score is 0.9978912555372441\n" + ] + } + ], + "source": [ + "# R2 score calculation\n", + "\n", + "from sklearn.metrics import r2_score\n", + "predic=model_2.predict(x_test_2)\n", + "r2_sco=r2_score(y_test_2,predic)\n", + "print(\"r2_score is \",r2_sco)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "r2_score coming close to 1 signify that our model is performing very well on the test data set ." + ] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "Copy of CVusingTF_Assgn2.ipynb", + "provenance": [] + }, + "interpreter": { + "hash": "d32dd9972e4becc079854756227bbaf57600491c52d25499cfd0dde1c0f41dcc" + }, + "kernelspec": { + "display_name": "Python 3.9.6 64-bit", + "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.9.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From 4f1504a6db3318533cbb546b29104d2da61223a8 Mon Sep 17 00:00:00 2001 From: Abhay-sisodia <84870507+Abhay-sisodia@users.noreply.github.com> Date: Tue, 14 Jun 2022 15:56:28 +0530 Subject: [PATCH 3/8] Add files via upload --- Assignment_2/A2_200014.ipynb | 1090 ++++++++++++++++++++++++++++++++++ 1 file changed, 1090 insertions(+) create mode 100644 Assignment_2/A2_200014.ipynb diff --git a/Assignment_2/A2_200014.ipynb b/Assignment_2/A2_200014.ipynb new file mode 100644 index 0000000..973ca6c --- /dev/null +++ b/Assignment_2/A2_200014.ipynb @@ -0,0 +1,1090 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "UxcaEbrCy1g_" + }, + "source": [ + "# Assigment 2: Deep Learning" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "h2JON-_Oy79w" + }, + "source": [ + "## Generate Dataset\n", + "\n", + "This is the same code from Assignment 1" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "hgpG3WDuypfa" + }, + "outputs": [], + "source": [ + "from sklearn import datasets\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "# Generate the data\n", + "x, y = datasets.make_regression(n_samples=100, n_features=5, noise=5, random_state=4)\n", + "\n", + "\n", + "# Split the data\n", + "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=1234)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "H6yGzfrTyqcs", + "outputId": "60310a69-fdbc-4da7-8dcf-573e8a2ef598" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(80, 6)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "y_train=y_train.reshape(-1,1)\n", + "z_train=np.concatenate((x_train,y_train),axis=1)\n", + "z_train.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ZFK06IAqz7JU", + "outputId": "11d0d9a8-0102-4b5a-e00c-64f2958be46a" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "-261.6982943912921" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_train.min()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "r6it-Rm7zD1Y" + }, + "source": [ + "## Visualize Dataset\n", + "This is the same code from Assignment 1" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "UautPVj1yzaQ", + "outputId": "c1ceed4c-fa2f-4a3d-f9ba-547b66f1c1c8" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Visualizing the train dataset \n", + "import matplotlib.pyplot as plt\n", + "fig, axs = plt.subplots(5,figsize=(20,30))\n", + "\n", + "for i in range(5):\n", + " axs[i].scatter(x_train[:,i],y_train)\n", + "\n", + "\n", + "\n", + "\n", + "# Your code here" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "erZ1XReZ1QzO", + "outputId": "db319adf-ff5f-4dbe-af6f-ed1bf8c8239a" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Represents what is the value counts of different values in the target column in training dataset\n", + "import seaborn as sns\n", + "plt.figure(figsize=(2,20))\n", + "sns.heatmap(y_train,cmap='viridis')\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XMXb9lTyzGHE" + }, + "source": [ + "## Model Definition\n", + "\n", + "Using TensorFlow, build a model with the following definition:\n", + "> Input of shape 5 \\\\\n", + "> Dense of shape 5 \\\\\n", + "> Dense of shape 5 \\\\\n", + "> Dense of shape 1 \\\\\n", + "\n", + "Use Mean Square Error Loss and Stochaistic Gradient Descent (SGD) Optimizer\n", + "\n", + "Use Gradient Decay with appropriate parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "r32N1xK2ziOs" + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "\n", + "\n", + "def build_model():\n", + " model=tf.keras.models.Sequential([\n", + " tf.keras.layers.InputLayer(input_shape=5) ,\n", + " tf.keras.layers.Dense(5,activation='relu'),\n", + " tf.keras.layers.Dense(5,activation='relu'),\n", + " tf.keras.layers.Dense(1)\n", + "\n", + " ])\n", + "\n", + " optimi=tf.keras.optimizers.SGD( learning_rate=0.01)\n", + "\n", + "\n", + " model.compile(loss='mean_squared_error',optimizer=optimi,metrics=['mse'])\n", + " return model\n", + "\n", + "model=build_model()\n", + "\n", + "\n", + "\n", + "# Your code here" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "yIQ0mPVfrUzy", + "outputId": "daba414e-804c-4d68-adf0-f360943225fa" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " dense (Dense) (None, 5) 30 \n", + " \n", + " dense_1 (Dense) (None, 5) 30 \n", + " \n", + " dense_2 (Dense) (None, 1) 6 \n", + " \n", + "=================================================================\n", + "Total params: 66\n", + "Trainable params: 66\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0pL-Eg_8rzsm", + "outputId": "2e1dd950-09bc-4254-d3dd-7486d02010e4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/100\n", + "2/2 [==============================] - 1s 306ms/step - loss: 12262.9619 - mse: 12262.9619 - val_loss: 11092.0488 - val_mse: 11092.0488\n", + "Epoch 2/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 14371.0664 - mse: 14371.0664 - val_loss: 7165.2935 - val_mse: 7165.2935\n", + "Epoch 3/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12583.0078 - mse: 12583.0078 - val_loss: 7146.7114 - val_mse: 7146.7114\n", + "Epoch 4/100\n", + "2/2 [==============================] - 0s 48ms/step - loss: 12578.8672 - mse: 12578.8672 - val_loss: 7129.0264 - val_mse: 7129.0264\n", + "Epoch 5/100\n", + "2/2 [==============================] - 0s 54ms/step - loss: 12573.8975 - mse: 12573.8975 - val_loss: 7111.7861 - val_mse: 7111.7861\n", + "Epoch 6/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12572.4795 - mse: 12572.4795 - val_loss: 7095.2236 - val_mse: 7095.2236\n", + "Epoch 7/100\n", + "2/2 [==============================] - 0s 47ms/step - loss: 12567.2871 - mse: 12567.2871 - val_loss: 7079.9390 - val_mse: 7079.9390\n", + "Epoch 8/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12563.1133 - mse: 12563.1133 - val_loss: 7065.2163 - val_mse: 7065.2163\n", + "Epoch 9/100\n", + "2/2 [==============================] - 0s 47ms/step - loss: 12560.5127 - mse: 12560.5127 - val_loss: 7051.2412 - val_mse: 7051.2412\n", + "Epoch 10/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12570.8369 - mse: 12570.8369 - val_loss: 7037.2227 - val_mse: 7037.2227\n", + "Epoch 11/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12555.1982 - mse: 12555.1982 - val_loss: 7024.4541 - val_mse: 7024.4541\n", + "Epoch 12/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12553.8750 - mse: 12553.8750 - val_loss: 7012.1353 - val_mse: 7012.1353\n", + "Epoch 13/100\n", + "2/2 [==============================] - 0s 39ms/step - loss: 12557.2422 - mse: 12557.2422 - val_loss: 7000.1250 - val_mse: 7000.1250\n", + "Epoch 14/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12549.5371 - mse: 12549.5371 - val_loss: 6989.2041 - val_mse: 6989.2041\n", + "Epoch 15/100\n", + "2/2 [==============================] - 0s 39ms/step - loss: 12549.4453 - mse: 12549.4453 - val_loss: 6978.8999 - val_mse: 6978.8999\n", + "Epoch 16/100\n", + "2/2 [==============================] - 0s 40ms/step - loss: 12547.2168 - mse: 12547.2168 - val_loss: 6968.6260 - val_mse: 6968.6260\n", + "Epoch 17/100\n", + "2/2 [==============================] - 0s 39ms/step - loss: 12549.8320 - mse: 12549.8320 - val_loss: 6958.6318 - val_mse: 6958.6318\n", + "Epoch 18/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12542.8301 - mse: 12542.8301 - val_loss: 6949.4780 - val_mse: 6949.4780\n", + "Epoch 19/100\n", + "2/2 [==============================] - 0s 40ms/step - loss: 12542.5918 - mse: 12542.5918 - val_loss: 6940.5669 - val_mse: 6940.5669\n", + "Epoch 20/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12540.4268 - mse: 12540.4268 - val_loss: 6932.1987 - val_mse: 6932.1987\n", + "Epoch 21/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12549.0176 - mse: 12549.0176 - val_loss: 6923.7275 - val_mse: 6923.7275\n", + "Epoch 22/100\n", + "2/2 [==============================] - 0s 40ms/step - loss: 12551.0293 - mse: 12551.0293 - val_loss: 6915.5625 - val_mse: 6915.5625\n", + "Epoch 23/100\n", + "2/2 [==============================] - 0s 50ms/step - loss: 12538.0781 - mse: 12538.0781 - val_loss: 6908.1865 - val_mse: 6908.1865\n", + "Epoch 24/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12543.6709 - mse: 12543.6709 - val_loss: 6900.8511 - val_mse: 6900.8511\n", + "Epoch 25/100\n", + "2/2 [==============================] - 0s 46ms/step - loss: 12539.5977 - mse: 12539.5977 - val_loss: 6894.5586 - val_mse: 6894.5586\n", + "Epoch 26/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12539.6719 - mse: 12539.6719 - val_loss: 6887.9038 - val_mse: 6887.9038\n", + "Epoch 27/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12538.1367 - mse: 12538.1367 - val_loss: 6881.5728 - val_mse: 6881.5728\n", + "Epoch 28/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12542.5918 - mse: 12542.5918 - val_loss: 6875.3584 - val_mse: 6875.3584\n", + "Epoch 29/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12533.7070 - mse: 12533.7070 - val_loss: 6869.7583 - val_mse: 6869.7583\n", + "Epoch 30/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12548.0664 - mse: 12548.0664 - val_loss: 6863.9131 - val_mse: 6863.9131\n", + "Epoch 31/100\n", + "2/2 [==============================] - 0s 47ms/step - loss: 12532.1807 - mse: 12532.1807 - val_loss: 6858.8984 - val_mse: 6858.8984\n", + "Epoch 32/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12531.9277 - mse: 12531.9277 - val_loss: 6854.0508 - val_mse: 6854.0508\n", + "Epoch 33/100\n", + "2/2 [==============================] - 0s 59ms/step - loss: 12537.1016 - mse: 12537.1016 - val_loss: 6849.8359 - val_mse: 6849.8359\n", + "Epoch 34/100\n", + "2/2 [==============================] - 0s 38ms/step - loss: 12532.6133 - mse: 12532.6133 - val_loss: 6845.2505 - val_mse: 6845.2505\n", + "Epoch 35/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12538.8633 - mse: 12538.8633 - val_loss: 6840.6216 - val_mse: 6840.6216\n", + "Epoch 36/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12531.0820 - mse: 12531.0820 - val_loss: 6836.4883 - val_mse: 6836.4883\n", + "Epoch 37/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12533.3271 - mse: 12533.3271 - val_loss: 6832.3882 - val_mse: 6832.3882\n", + "Epoch 38/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12530.0039 - mse: 12530.0039 - val_loss: 6828.8008 - val_mse: 6828.8008\n", + "Epoch 39/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12529.7305 - mse: 12529.7305 - val_loss: 6825.2300 - val_mse: 6825.2300\n", + "Epoch 40/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12532.9531 - mse: 12532.9531 - val_loss: 6822.1538 - val_mse: 6822.1538\n", + "Epoch 41/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12545.0898 - mse: 12545.0898 - val_loss: 6819.2314 - val_mse: 6819.2314\n", + "Epoch 42/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12530.6523 - mse: 12530.6523 - val_loss: 6815.5562 - val_mse: 6815.5562\n", + "Epoch 43/100\n", + "2/2 [==============================] - 0s 40ms/step - loss: 12526.3711 - mse: 12526.3711 - val_loss: 6809.5137 - val_mse: 6809.5137\n", + "Epoch 44/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12515.4746 - mse: 12515.4746 - val_loss: 6797.6768 - val_mse: 6797.6768\n", + "Epoch 45/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12492.8398 - mse: 12492.8398 - val_loss: 6772.5537 - val_mse: 6772.5537\n", + "Epoch 46/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12305.8164 - mse: 12305.8164 - val_loss: 6718.9775 - val_mse: 6718.9775\n", + "Epoch 47/100\n", + "2/2 [==============================] - 0s 40ms/step - loss: 11177.3145 - mse: 11177.3145 - val_loss: 38427.1367 - val_mse: 38427.1367\n", + "Epoch 48/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 37039.4844 - mse: 37039.4844 - val_loss: 12114.6426 - val_mse: 12114.6426\n", + "Epoch 49/100\n", + "2/2 [==============================] - 0s 46ms/step - loss: 379740.7188 - mse: 379740.7188 - val_loss: 6984.1729 - val_mse: 6984.1729\n", + "Epoch 50/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12546.5430 - mse: 12546.5430 - val_loss: 6973.8364 - val_mse: 6973.8364\n", + "Epoch 51/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12557.4473 - mse: 12557.4473 - val_loss: 6963.4180 - val_mse: 6963.4180\n", + "Epoch 52/100\n", + "2/2 [==============================] - 0s 47ms/step - loss: 12543.7080 - mse: 12543.7080 - val_loss: 6954.1152 - val_mse: 6954.1152\n", + "Epoch 53/100\n", + "2/2 [==============================] - 0s 76ms/step - loss: 12544.0078 - mse: 12544.0078 - val_loss: 6945.3711 - val_mse: 6945.3711\n", + "Epoch 54/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12556.0166 - mse: 12556.0166 - val_loss: 6937.4219 - val_mse: 6937.4219\n", + "Epoch 55/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12555.8555 - mse: 12555.8555 - val_loss: 6929.8418 - val_mse: 6929.8418\n", + "Epoch 56/100\n", + "2/2 [==============================] - 0s 46ms/step - loss: 12539.0918 - mse: 12539.0918 - val_loss: 6921.9487 - val_mse: 6921.9487\n", + "Epoch 57/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12545.1680 - mse: 12545.1680 - val_loss: 6914.0068 - val_mse: 6914.0068\n", + "Epoch 58/100\n", + "2/2 [==============================] - 0s 48ms/step - loss: 12538.1182 - mse: 12538.1182 - val_loss: 6906.6826 - val_mse: 6906.6826\n", + "Epoch 59/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12536.4043 - mse: 12536.4043 - val_loss: 6899.8540 - val_mse: 6899.8540\n", + "Epoch 60/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12545.4170 - mse: 12545.4170 - val_loss: 6893.7852 - val_mse: 6893.7852\n", + "Epoch 61/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12540.1338 - mse: 12540.1338 - val_loss: 6887.1465 - val_mse: 6887.1465\n", + "Epoch 62/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12535.9805 - mse: 12535.9805 - val_loss: 6881.3438 - val_mse: 6881.3438\n", + "Epoch 63/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12533.7822 - mse: 12533.7822 - val_loss: 6875.5820 - val_mse: 6875.5820\n", + "Epoch 64/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12534.3340 - mse: 12534.3340 - val_loss: 6869.9229 - val_mse: 6869.9229\n", + "Epoch 65/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12544.7490 - mse: 12544.7490 - val_loss: 6864.1406 - val_mse: 6864.1406\n", + "Epoch 66/100\n", + "2/2 [==============================] - 0s 48ms/step - loss: 12532.7070 - mse: 12532.7070 - val_loss: 6859.2402 - val_mse: 6859.2402\n", + "Epoch 67/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12540.0264 - mse: 12540.0264 - val_loss: 6854.8760 - val_mse: 6854.8760\n", + "Epoch 68/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12532.3975 - mse: 12532.3975 - val_loss: 6850.1201 - val_mse: 6850.1201\n", + "Epoch 69/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12539.5771 - mse: 12539.5771 - val_loss: 6846.1504 - val_mse: 6846.1504\n", + "Epoch 70/100\n", + "2/2 [==============================] - 0s 48ms/step - loss: 12534.7676 - mse: 12534.7676 - val_loss: 6842.2109 - val_mse: 6842.2109\n", + "Epoch 71/100\n", + "2/2 [==============================] - 0s 47ms/step - loss: 12535.3730 - mse: 12535.3730 - val_loss: 6837.8101 - val_mse: 6837.8101\n", + "Epoch 72/100\n", + "2/2 [==============================] - 0s 40ms/step - loss: 12530.4844 - mse: 12530.4844 - val_loss: 6834.0049 - val_mse: 6834.0049\n", + "Epoch 73/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12535.9141 - mse: 12535.9141 - val_loss: 6830.6431 - val_mse: 6830.6431\n", + "Epoch 74/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12529.7637 - mse: 12529.7637 - val_loss: 6827.0908 - val_mse: 6827.0908\n", + "Epoch 75/100\n", + "2/2 [==============================] - 0s 46ms/step - loss: 12537.2832 - mse: 12537.2832 - val_loss: 6824.0693 - val_mse: 6824.0693\n", + "Epoch 76/100\n", + "2/2 [==============================] - 0s 46ms/step - loss: 12560.0615 - mse: 12560.0615 - val_loss: 6821.5796 - val_mse: 6821.5796\n", + "Epoch 77/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12534.9043 - mse: 12534.9043 - val_loss: 6818.0249 - val_mse: 6818.0249\n", + "Epoch 78/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12530.1738 - mse: 12530.1738 - val_loss: 6814.8101 - val_mse: 6814.8101\n", + "Epoch 79/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12530.2627 - mse: 12530.2627 - val_loss: 6811.7124 - val_mse: 6811.7124\n", + "Epoch 80/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12531.0273 - mse: 12531.0273 - val_loss: 6809.1479 - val_mse: 6809.1479\n", + "Epoch 81/100\n", + "2/2 [==============================] - 0s 54ms/step - loss: 12528.5293 - mse: 12528.5293 - val_loss: 6806.4868 - val_mse: 6806.4868\n", + "Epoch 82/100\n", + "2/2 [==============================] - 0s 48ms/step - loss: 12528.3770 - mse: 12528.3770 - val_loss: 6803.9165 - val_mse: 6803.9165\n", + "Epoch 83/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12530.9883 - mse: 12530.9883 - val_loss: 6801.2090 - val_mse: 6801.2090\n", + "Epoch 84/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12528.4297 - mse: 12528.4297 - val_loss: 6798.7744 - val_mse: 6798.7744\n", + "Epoch 85/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12542.8262 - mse: 12542.8262 - val_loss: 6797.0767 - val_mse: 6797.0767\n", + "Epoch 86/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12527.9600 - mse: 12527.9600 - val_loss: 6794.8916 - val_mse: 6794.8916\n", + "Epoch 87/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12527.9473 - mse: 12527.9473 - val_loss: 6792.7568 - val_mse: 6792.7568\n", + "Epoch 88/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12532.5371 - mse: 12532.5371 - val_loss: 6790.4355 - val_mse: 6790.4355\n", + "Epoch 89/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12530.3691 - mse: 12530.3691 - val_loss: 6788.7583 - val_mse: 6788.7583\n", + "Epoch 90/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12536.0205 - mse: 12536.0205 - val_loss: 6786.4990 - val_mse: 6786.4990\n", + "Epoch 91/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12528.2305 - mse: 12528.2305 - val_loss: 6784.8643 - val_mse: 6784.8643\n", + "Epoch 92/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12538.0020 - mse: 12538.0020 - val_loss: 6782.7163 - val_mse: 6782.7163\n", + "Epoch 93/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12529.5488 - mse: 12529.5488 - val_loss: 6780.9121 - val_mse: 6780.9121\n", + "Epoch 94/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12530.9824 - mse: 12530.9824 - val_loss: 6779.1187 - val_mse: 6779.1187\n", + "Epoch 95/100\n", + "2/2 [==============================] - 0s 46ms/step - loss: 12529.6895 - mse: 12529.6895 - val_loss: 6777.8877 - val_mse: 6777.8877\n", + "Epoch 96/100\n", + "2/2 [==============================] - 0s 40ms/step - loss: 12530.5879 - mse: 12530.5879 - val_loss: 6776.2295 - val_mse: 6776.2295\n", + "Epoch 97/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12527.2910 - mse: 12527.2910 - val_loss: 6774.9199 - val_mse: 6774.9199\n", + "Epoch 98/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12533.8867 - mse: 12533.8867 - val_loss: 6774.0078 - val_mse: 6774.0078\n", + "Epoch 99/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12530.3994 - mse: 12530.3994 - val_loss: 6772.5107 - val_mse: 6772.5107\n", + "Epoch 100/100\n", + "2/2 [==============================] - 0s 50ms/step - loss: 12527.2217 - mse: 12527.2217 - val_loss: 6771.3604 - val_mse: 6771.3604\n" + ] + } + ], + "source": [ + "results=model.fit(x_train,y_train,epochs=100,validation_split=0.2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jmeP6vt3z0oA" + }, + "source": [ + "## Plot Loss\n", + "\n", + "Using matplotlib visualise how the loss (both validation and training) is changing, use this information to retrain the model with appropriate parameters.
We ideally want the loss to be constant over the last few iterations." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "id": "RQTNqPHm0mOi", + "outputId": "a2aa2f5d-d682-4afa-b3e9-457edfd64ccd" + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
lossmseval_lossval_mseepoch
9512530.58789112530.5878916776.2294926776.22949295
9612527.29101612527.2910166774.9199226774.91992296
9712533.88671912533.8867196774.0078126774.00781297
9812530.39941412530.3994146772.5107426772.51074298
9912527.22168012527.2216806771.3603526771.36035299
\n", + "
" + ], + "text/plain": [ + " loss mse val_loss val_mse epoch\n", + "95 12530.587891 12530.587891 6776.229492 6776.229492 95\n", + "96 12527.291016 12527.291016 6774.919922 6774.919922 96\n", + "97 12533.886719 12533.886719 6774.007812 6774.007812 97\n", + "98 12530.399414 12530.399414 6772.510742 6772.510742 98\n", + "99 12527.221680 12527.221680 6771.360352 6771.360352 99" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "res=pd.DataFrame(results.history)\n", + "res['epoch']=results.epoch\n", + "res.tail()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "ubeaG8e9t7im", + "outputId": "f763ebb3-d143-484d-b333-ccda2479bdb7" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(res['epoch'],res['loss'])\n", + "plt.plot(res['epoch'],res['val_loss'])\n", + "plt.legend([\"Loss\",\"Val_Loss\"])\n", + "# plt.xlim(0,80)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IVrR_vXA7kOt" + }, + "source": [ + "## Evaluation Metrics\n", + "Use the R2 Score function implemented in the first assignment to evaluate the performance of the model." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "id": "-lOHpD8-7ggm" + }, + "outputs": [], + "source": [ + "# Insert the function for R2 Score\n", + "\n", + "def r2_score_predictor(y_true,y_pred):\n", + " from sklearn.metrics import r2_score\n", + " r=r2_score(y_true,y_pred)\n", + " return r\n", + "predictions=model.predict(x_test)\n", + "r=r2_score_predictor(y_test,predictions)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "SCApVNjtzbv8", + "outputId": "f108f6c9-9479-442a-f7f4-2c087c3986da" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The r2_score value is -0.0909121073526411\n" + ] + } + ], + "source": [ + "print(\"The r2_score value is \",r)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CHqzF1OU0pBg" + }, + "source": [ + "## Your own custom model\n", + "Build a custom model of your own choice.
\n", + "Describe it in detail in Markdown/Latex in the cell below.
\n", + "Visualise the loss, as before." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jF8oTUqq0y0g" + }, + "source": [ + "Your text here" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn import datasets\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "# Generate the data\n", + "x_2, y_2 = datasets.make_regression(n_samples=1000, n_features=5, noise=5, random_state=4)\n", + "\n", + "\n", + "# Split the data\n", + "x_train_2, x_test_2, y_train_2, y_test_2 = train_test_split(x_2, y_2, test_size=0.2, random_state=1234)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Instead of using SGD optimizer we can use Adam optimizer to get better results." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "1XOk5hJu0oSQ" + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "model_2=tf.keras.models.Sequential([\n", + " tf.keras.layers.InputLayer(input_shape=5) ,\n", + " tf.keras.layers.Dense(30,activation='relu'),\n", + " tf.keras.layers.Dense(30,activation='relu'),\n", + " tf.keras.layers.Dense(1)\n", + "\n", + " ])\n", + "\n", + "optimi=tf.keras.optimizers.Adam( learning_rate=0.01)\n", + "\n", + "\n", + "model_2.compile(loss='mean_squared_error',optimizer=optimi,metrics=tf.keras.metrics.Accuracy())\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " dense (Dense) (None, 30) 180 \n", + " \n", + " dense_1 (Dense) (None, 30) 930 \n", + " \n", + " dense_2 (Dense) (None, 1) 31 \n", + " \n", + "=================================================================\n", + "Total params: 1,141\n", + "Trainable params: 1,141\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "model_2.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "aS0ROZa402Lo", + "outputId": "c852055e-ec4f-4272-ad30-e068b76c623f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/20\n", + "20/20 [==============================] - 1s 17ms/step - loss: 22293.0352 - accuracy: 0.0000e+00 - val_loss: 22968.2930 - val_accuracy: 0.0000e+00\n", + "Epoch 2/20\n", + "20/20 [==============================] - 0s 5ms/step - loss: 16845.7617 - accuracy: 0.0000e+00 - val_loss: 11418.9531 - val_accuracy: 0.0000e+00\n", + "Epoch 3/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 4155.4365 - accuracy: 0.0000e+00 - val_loss: 745.3987 - val_accuracy: 0.0000e+00\n", + "Epoch 4/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 621.0253 - accuracy: 0.0000e+00 - val_loss: 412.5599 - val_accuracy: 0.0000e+00\n", + "Epoch 5/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 308.1701 - accuracy: 0.0000e+00 - val_loss: 312.2416 - val_accuracy: 0.0000e+00\n", + "Epoch 6/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 240.7342 - accuracy: 0.0000e+00 - val_loss: 267.2795 - val_accuracy: 0.0000e+00\n", + "Epoch 7/20\n", + "20/20 [==============================] - 0s 5ms/step - loss: 207.0453 - accuracy: 0.0000e+00 - val_loss: 246.7999 - val_accuracy: 0.0000e+00\n", + "Epoch 8/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 185.6382 - accuracy: 0.0000e+00 - val_loss: 233.2929 - val_accuracy: 0.0000e+00\n", + "Epoch 9/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 172.4978 - accuracy: 0.0000e+00 - val_loss: 238.8235 - val_accuracy: 0.0000e+00\n", + "Epoch 10/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 154.8446 - accuracy: 0.0000e+00 - val_loss: 173.0536 - val_accuracy: 0.0000e+00\n", + "Epoch 11/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 129.1207 - accuracy: 0.0000e+00 - val_loss: 134.6592 - val_accuracy: 0.0000e+00\n", + "Epoch 12/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 121.6438 - accuracy: 0.0000e+00 - val_loss: 122.1448 - val_accuracy: 0.0000e+00\n", + "Epoch 13/20\n", + "20/20 [==============================] - 0s 5ms/step - loss: 100.9714 - accuracy: 0.0000e+00 - val_loss: 108.3006 - val_accuracy: 0.0000e+00\n", + "Epoch 14/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 88.0066 - accuracy: 0.0000e+00 - val_loss: 93.5628 - val_accuracy: 0.0000e+00\n", + "Epoch 15/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 74.2823 - accuracy: 0.0000e+00 - val_loss: 83.5923 - val_accuracy: 0.0000e+00\n", + "Epoch 16/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 67.1191 - accuracy: 0.0000e+00 - val_loss: 84.6325 - val_accuracy: 0.0000e+00\n", + "Epoch 17/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 59.6604 - accuracy: 0.0000e+00 - val_loss: 64.3586 - val_accuracy: 0.0000e+00\n", + "Epoch 18/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 50.1667 - accuracy: 0.0000e+00 - val_loss: 57.6406 - val_accuracy: 0.0000e+00\n", + "Epoch 19/20\n", + "20/20 [==============================] - 0s 8ms/step - loss: 45.9919 - accuracy: 0.0000e+00 - val_loss: 50.3901 - val_accuracy: 0.0000e+00\n", + "Epoch 20/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 43.3895 - accuracy: 0.0000e+00 - val_loss: 46.8216 - val_accuracy: 0.0000e+00\n" + ] + } + ], + "source": [ + "results_2=model_2.fit(x_train_2,y_train_2,epochs=20,validation_split=0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "id": "-v9c8bWtxbgP", + "outputId": "19e97d03-36e9-4893-ace2-3da787fe8f49" + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
lossaccuracyval_lossval_accuracyepoch
1567.1190570.084.6324620.015
1659.6604310.064.3586040.016
1750.1667180.057.6405750.017
1845.9919090.050.3900990.018
1943.3894840.046.8216480.019
\n", + "
" + ], + "text/plain": [ + " loss accuracy val_loss val_accuracy epoch\n", + "15 67.119057 0.0 84.632462 0.0 15\n", + "16 59.660431 0.0 64.358604 0.0 16\n", + "17 50.166718 0.0 57.640575 0.0 17\n", + "18 45.991909 0.0 50.390099 0.0 18\n", + "19 43.389484 0.0 46.821648 0.0 19" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "res_2=pd.DataFrame(results_2.history)\n", + "res_2['epoch']=results_2.epoch\n", + "res_2.tail()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "6xWw8yxhxxmt", + "outputId": "4acfcf6e-3e59-48e7-fabe-3bac990417b3" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(res_2['epoch'],res_2['loss'])\n", + "plt.plot(res_2['epoch'],res_2['val_loss'])\n", + "plt.legend([\"Val_Loss\",\"Loss\"])\n", + "# plt.xlim(0,80)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "id": "FeWhnbAV0PUX" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "r2_score is 0.9978912555372441\n" + ] + } + ], + "source": [ + "# R2 score calculation\n", + "\n", + "from sklearn.metrics import r2_score\n", + "predic=model_2.predict(x_test_2)\n", + "r2_sco=r2_score(y_test_2,predic)\n", + "print(\"r2_score is \",r2_sco)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "r2_score coming close to 1 signify that our model is performing very well on the test data set ." + ] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "Copy of CVusingTF_Assgn2.ipynb", + "provenance": [] + }, + "interpreter": { + "hash": "d32dd9972e4becc079854756227bbaf57600491c52d25499cfd0dde1c0f41dcc" + }, + "kernelspec": { + "display_name": "Python 3.9.6 64-bit", + "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.9.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From 8e5ee34746281d1c506368ef348f26f75a92d069 Mon Sep 17 00:00:00 2001 From: Abhay-sisodia <84870507+Abhay-sisodia@users.noreply.github.com> Date: Tue, 14 Jun 2022 15:56:49 +0530 Subject: [PATCH 4/8] Delete A2_200014.ipynb --- A2_200014.ipynb | 1090 ----------------------------------------------- 1 file changed, 1090 deletions(-) delete mode 100644 A2_200014.ipynb diff --git a/A2_200014.ipynb b/A2_200014.ipynb deleted file mode 100644 index 973ca6c..0000000 --- a/A2_200014.ipynb +++ /dev/null @@ -1,1090 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "UxcaEbrCy1g_" - }, - "source": [ - "# Assigment 2: Deep Learning" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "h2JON-_Oy79w" - }, - "source": [ - "## Generate Dataset\n", - "\n", - "This is the same code from Assignment 1" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "id": "hgpG3WDuypfa" - }, - "outputs": [], - "source": [ - "from sklearn import datasets\n", - "from sklearn.model_selection import train_test_split\n", - "\n", - "# Generate the data\n", - "x, y = datasets.make_regression(n_samples=100, n_features=5, noise=5, random_state=4)\n", - "\n", - "\n", - "# Split the data\n", - "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=1234)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "H6yGzfrTyqcs", - "outputId": "60310a69-fdbc-4da7-8dcf-573e8a2ef598" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(80, 6)" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import numpy as np\n", - "y_train=y_train.reshape(-1,1)\n", - "z_train=np.concatenate((x_train,y_train),axis=1)\n", - "z_train.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "ZFK06IAqz7JU", - "outputId": "11d0d9a8-0102-4b5a-e00c-64f2958be46a" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "-261.6982943912921" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "y_train.min()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "r6it-Rm7zD1Y" - }, - "source": [ - "## Visualize Dataset\n", - "This is the same code from Assignment 1" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "UautPVj1yzaQ", - "outputId": "c1ceed4c-fa2f-4a3d-f9ba-547b66f1c1c8" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "# Visualizing the train dataset \n", - "import matplotlib.pyplot as plt\n", - "fig, axs = plt.subplots(5,figsize=(20,30))\n", - "\n", - "for i in range(5):\n", - " axs[i].scatter(x_train[:,i],y_train)\n", - "\n", - "\n", - "\n", - "\n", - "# Your code here" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "erZ1XReZ1QzO", - "outputId": "db319adf-ff5f-4dbe-af6f-ed1bf8c8239a" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "# Represents what is the value counts of different values in the target column in training dataset\n", - "import seaborn as sns\n", - "plt.figure(figsize=(2,20))\n", - "sns.heatmap(y_train,cmap='viridis')\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "XMXb9lTyzGHE" - }, - "source": [ - "## Model Definition\n", - "\n", - "Using TensorFlow, build a model with the following definition:\n", - "> Input of shape 5 \\\\\n", - "> Dense of shape 5 \\\\\n", - "> Dense of shape 5 \\\\\n", - "> Dense of shape 1 \\\\\n", - "\n", - "Use Mean Square Error Loss and Stochaistic Gradient Descent (SGD) Optimizer\n", - "\n", - "Use Gradient Decay with appropriate parameters" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "id": "r32N1xK2ziOs" - }, - "outputs": [], - "source": [ - "import tensorflow as tf\n", - "from tensorflow import keras\n", - "\n", - "\n", - "def build_model():\n", - " model=tf.keras.models.Sequential([\n", - " tf.keras.layers.InputLayer(input_shape=5) ,\n", - " tf.keras.layers.Dense(5,activation='relu'),\n", - " tf.keras.layers.Dense(5,activation='relu'),\n", - " tf.keras.layers.Dense(1)\n", - "\n", - " ])\n", - "\n", - " optimi=tf.keras.optimizers.SGD( learning_rate=0.01)\n", - "\n", - "\n", - " model.compile(loss='mean_squared_error',optimizer=optimi,metrics=['mse'])\n", - " return model\n", - "\n", - "model=build_model()\n", - "\n", - "\n", - "\n", - "# Your code here" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "yIQ0mPVfrUzy", - "outputId": "daba414e-804c-4d68-adf0-f360943225fa" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model: \"sequential\"\n", - "_________________________________________________________________\n", - " Layer (type) Output Shape Param # \n", - "=================================================================\n", - " dense (Dense) (None, 5) 30 \n", - " \n", - " dense_1 (Dense) (None, 5) 30 \n", - " \n", - " dense_2 (Dense) (None, 1) 6 \n", - " \n", - "=================================================================\n", - "Total params: 66\n", - "Trainable params: 66\n", - "Non-trainable params: 0\n", - "_________________________________________________________________\n" - ] - } - ], - "source": [ - "model.summary()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "0pL-Eg_8rzsm", - "outputId": "2e1dd950-09bc-4254-d3dd-7486d02010e4" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 1/100\n", - "2/2 [==============================] - 1s 306ms/step - loss: 12262.9619 - mse: 12262.9619 - val_loss: 11092.0488 - val_mse: 11092.0488\n", - "Epoch 2/100\n", - "2/2 [==============================] - 0s 45ms/step - loss: 14371.0664 - mse: 14371.0664 - val_loss: 7165.2935 - val_mse: 7165.2935\n", - "Epoch 3/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12583.0078 - mse: 12583.0078 - val_loss: 7146.7114 - val_mse: 7146.7114\n", - "Epoch 4/100\n", - "2/2 [==============================] - 0s 48ms/step - loss: 12578.8672 - mse: 12578.8672 - val_loss: 7129.0264 - val_mse: 7129.0264\n", - "Epoch 5/100\n", - "2/2 [==============================] - 0s 54ms/step - loss: 12573.8975 - mse: 12573.8975 - val_loss: 7111.7861 - val_mse: 7111.7861\n", - "Epoch 6/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12572.4795 - mse: 12572.4795 - val_loss: 7095.2236 - val_mse: 7095.2236\n", - "Epoch 7/100\n", - "2/2 [==============================] - 0s 47ms/step - loss: 12567.2871 - mse: 12567.2871 - val_loss: 7079.9390 - val_mse: 7079.9390\n", - "Epoch 8/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12563.1133 - mse: 12563.1133 - val_loss: 7065.2163 - val_mse: 7065.2163\n", - "Epoch 9/100\n", - "2/2 [==============================] - 0s 47ms/step - loss: 12560.5127 - mse: 12560.5127 - val_loss: 7051.2412 - val_mse: 7051.2412\n", - "Epoch 10/100\n", - "2/2 [==============================] - 0s 42ms/step - loss: 12570.8369 - mse: 12570.8369 - val_loss: 7037.2227 - val_mse: 7037.2227\n", - "Epoch 11/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12555.1982 - mse: 12555.1982 - val_loss: 7024.4541 - val_mse: 7024.4541\n", - "Epoch 12/100\n", - "2/2 [==============================] - 0s 42ms/step - loss: 12553.8750 - mse: 12553.8750 - val_loss: 7012.1353 - val_mse: 7012.1353\n", - "Epoch 13/100\n", - "2/2 [==============================] - 0s 39ms/step - loss: 12557.2422 - mse: 12557.2422 - val_loss: 7000.1250 - val_mse: 7000.1250\n", - "Epoch 14/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12549.5371 - mse: 12549.5371 - val_loss: 6989.2041 - val_mse: 6989.2041\n", - "Epoch 15/100\n", - "2/2 [==============================] - 0s 39ms/step - loss: 12549.4453 - mse: 12549.4453 - val_loss: 6978.8999 - val_mse: 6978.8999\n", - "Epoch 16/100\n", - "2/2 [==============================] - 0s 40ms/step - loss: 12547.2168 - mse: 12547.2168 - val_loss: 6968.6260 - val_mse: 6968.6260\n", - "Epoch 17/100\n", - "2/2 [==============================] - 0s 39ms/step - loss: 12549.8320 - mse: 12549.8320 - val_loss: 6958.6318 - val_mse: 6958.6318\n", - "Epoch 18/100\n", - "2/2 [==============================] - 0s 41ms/step - loss: 12542.8301 - mse: 12542.8301 - val_loss: 6949.4780 - val_mse: 6949.4780\n", - "Epoch 19/100\n", - "2/2 [==============================] - 0s 40ms/step - loss: 12542.5918 - mse: 12542.5918 - val_loss: 6940.5669 - val_mse: 6940.5669\n", - "Epoch 20/100\n", - "2/2 [==============================] - 0s 42ms/step - loss: 12540.4268 - mse: 12540.4268 - val_loss: 6932.1987 - val_mse: 6932.1987\n", - "Epoch 21/100\n", - "2/2 [==============================] - 0s 45ms/step - loss: 12549.0176 - mse: 12549.0176 - val_loss: 6923.7275 - val_mse: 6923.7275\n", - "Epoch 22/100\n", - "2/2 [==============================] - 0s 40ms/step - loss: 12551.0293 - mse: 12551.0293 - val_loss: 6915.5625 - val_mse: 6915.5625\n", - "Epoch 23/100\n", - "2/2 [==============================] - 0s 50ms/step - loss: 12538.0781 - mse: 12538.0781 - val_loss: 6908.1865 - val_mse: 6908.1865\n", - "Epoch 24/100\n", - "2/2 [==============================] - 0s 45ms/step - loss: 12543.6709 - mse: 12543.6709 - val_loss: 6900.8511 - val_mse: 6900.8511\n", - "Epoch 25/100\n", - "2/2 [==============================] - 0s 46ms/step - loss: 12539.5977 - mse: 12539.5977 - val_loss: 6894.5586 - val_mse: 6894.5586\n", - "Epoch 26/100\n", - "2/2 [==============================] - 0s 45ms/step - loss: 12539.6719 - mse: 12539.6719 - val_loss: 6887.9038 - val_mse: 6887.9038\n", - "Epoch 27/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12538.1367 - mse: 12538.1367 - val_loss: 6881.5728 - val_mse: 6881.5728\n", - "Epoch 28/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12542.5918 - mse: 12542.5918 - val_loss: 6875.3584 - val_mse: 6875.3584\n", - "Epoch 29/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12533.7070 - mse: 12533.7070 - val_loss: 6869.7583 - val_mse: 6869.7583\n", - "Epoch 30/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12548.0664 - mse: 12548.0664 - val_loss: 6863.9131 - val_mse: 6863.9131\n", - "Epoch 31/100\n", - "2/2 [==============================] - 0s 47ms/step - loss: 12532.1807 - mse: 12532.1807 - val_loss: 6858.8984 - val_mse: 6858.8984\n", - "Epoch 32/100\n", - "2/2 [==============================] - 0s 41ms/step - loss: 12531.9277 - mse: 12531.9277 - val_loss: 6854.0508 - val_mse: 6854.0508\n", - "Epoch 33/100\n", - "2/2 [==============================] - 0s 59ms/step - loss: 12537.1016 - mse: 12537.1016 - val_loss: 6849.8359 - val_mse: 6849.8359\n", - "Epoch 34/100\n", - "2/2 [==============================] - 0s 38ms/step - loss: 12532.6133 - mse: 12532.6133 - val_loss: 6845.2505 - val_mse: 6845.2505\n", - "Epoch 35/100\n", - "2/2 [==============================] - 0s 42ms/step - loss: 12538.8633 - mse: 12538.8633 - val_loss: 6840.6216 - val_mse: 6840.6216\n", - "Epoch 36/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12531.0820 - mse: 12531.0820 - val_loss: 6836.4883 - val_mse: 6836.4883\n", - "Epoch 37/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12533.3271 - mse: 12533.3271 - val_loss: 6832.3882 - val_mse: 6832.3882\n", - "Epoch 38/100\n", - "2/2 [==============================] - 0s 45ms/step - loss: 12530.0039 - mse: 12530.0039 - val_loss: 6828.8008 - val_mse: 6828.8008\n", - "Epoch 39/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12529.7305 - mse: 12529.7305 - val_loss: 6825.2300 - val_mse: 6825.2300\n", - "Epoch 40/100\n", - "2/2 [==============================] - 0s 42ms/step - loss: 12532.9531 - mse: 12532.9531 - val_loss: 6822.1538 - val_mse: 6822.1538\n", - "Epoch 41/100\n", - "2/2 [==============================] - 0s 42ms/step - loss: 12545.0898 - mse: 12545.0898 - val_loss: 6819.2314 - val_mse: 6819.2314\n", - "Epoch 42/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12530.6523 - mse: 12530.6523 - val_loss: 6815.5562 - val_mse: 6815.5562\n", - "Epoch 43/100\n", - "2/2 [==============================] - 0s 40ms/step - loss: 12526.3711 - mse: 12526.3711 - val_loss: 6809.5137 - val_mse: 6809.5137\n", - "Epoch 44/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12515.4746 - mse: 12515.4746 - val_loss: 6797.6768 - val_mse: 6797.6768\n", - "Epoch 45/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12492.8398 - mse: 12492.8398 - val_loss: 6772.5537 - val_mse: 6772.5537\n", - "Epoch 46/100\n", - "2/2 [==============================] - 0s 42ms/step - loss: 12305.8164 - mse: 12305.8164 - val_loss: 6718.9775 - val_mse: 6718.9775\n", - "Epoch 47/100\n", - "2/2 [==============================] - 0s 40ms/step - loss: 11177.3145 - mse: 11177.3145 - val_loss: 38427.1367 - val_mse: 38427.1367\n", - "Epoch 48/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 37039.4844 - mse: 37039.4844 - val_loss: 12114.6426 - val_mse: 12114.6426\n", - "Epoch 49/100\n", - "2/2 [==============================] - 0s 46ms/step - loss: 379740.7188 - mse: 379740.7188 - val_loss: 6984.1729 - val_mse: 6984.1729\n", - "Epoch 50/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12546.5430 - mse: 12546.5430 - val_loss: 6973.8364 - val_mse: 6973.8364\n", - "Epoch 51/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12557.4473 - mse: 12557.4473 - val_loss: 6963.4180 - val_mse: 6963.4180\n", - "Epoch 52/100\n", - "2/2 [==============================] - 0s 47ms/step - loss: 12543.7080 - mse: 12543.7080 - val_loss: 6954.1152 - val_mse: 6954.1152\n", - "Epoch 53/100\n", - "2/2 [==============================] - 0s 76ms/step - loss: 12544.0078 - mse: 12544.0078 - val_loss: 6945.3711 - val_mse: 6945.3711\n", - "Epoch 54/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12556.0166 - mse: 12556.0166 - val_loss: 6937.4219 - val_mse: 6937.4219\n", - "Epoch 55/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12555.8555 - mse: 12555.8555 - val_loss: 6929.8418 - val_mse: 6929.8418\n", - "Epoch 56/100\n", - "2/2 [==============================] - 0s 46ms/step - loss: 12539.0918 - mse: 12539.0918 - val_loss: 6921.9487 - val_mse: 6921.9487\n", - "Epoch 57/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12545.1680 - mse: 12545.1680 - val_loss: 6914.0068 - val_mse: 6914.0068\n", - "Epoch 58/100\n", - "2/2 [==============================] - 0s 48ms/step - loss: 12538.1182 - mse: 12538.1182 - val_loss: 6906.6826 - val_mse: 6906.6826\n", - "Epoch 59/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12536.4043 - mse: 12536.4043 - val_loss: 6899.8540 - val_mse: 6899.8540\n", - "Epoch 60/100\n", - "2/2 [==============================] - 0s 45ms/step - loss: 12545.4170 - mse: 12545.4170 - val_loss: 6893.7852 - val_mse: 6893.7852\n", - "Epoch 61/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12540.1338 - mse: 12540.1338 - val_loss: 6887.1465 - val_mse: 6887.1465\n", - "Epoch 62/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12535.9805 - mse: 12535.9805 - val_loss: 6881.3438 - val_mse: 6881.3438\n", - "Epoch 63/100\n", - "2/2 [==============================] - 0s 42ms/step - loss: 12533.7822 - mse: 12533.7822 - val_loss: 6875.5820 - val_mse: 6875.5820\n", - "Epoch 64/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12534.3340 - mse: 12534.3340 - val_loss: 6869.9229 - val_mse: 6869.9229\n", - "Epoch 65/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12544.7490 - mse: 12544.7490 - val_loss: 6864.1406 - val_mse: 6864.1406\n", - "Epoch 66/100\n", - "2/2 [==============================] - 0s 48ms/step - loss: 12532.7070 - mse: 12532.7070 - val_loss: 6859.2402 - val_mse: 6859.2402\n", - "Epoch 67/100\n", - "2/2 [==============================] - 0s 45ms/step - loss: 12540.0264 - mse: 12540.0264 - val_loss: 6854.8760 - val_mse: 6854.8760\n", - "Epoch 68/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12532.3975 - mse: 12532.3975 - val_loss: 6850.1201 - val_mse: 6850.1201\n", - "Epoch 69/100\n", - "2/2 [==============================] - 0s 41ms/step - loss: 12539.5771 - mse: 12539.5771 - val_loss: 6846.1504 - val_mse: 6846.1504\n", - "Epoch 70/100\n", - "2/2 [==============================] - 0s 48ms/step - loss: 12534.7676 - mse: 12534.7676 - val_loss: 6842.2109 - val_mse: 6842.2109\n", - "Epoch 71/100\n", - "2/2 [==============================] - 0s 47ms/step - loss: 12535.3730 - mse: 12535.3730 - val_loss: 6837.8101 - val_mse: 6837.8101\n", - "Epoch 72/100\n", - "2/2 [==============================] - 0s 40ms/step - loss: 12530.4844 - mse: 12530.4844 - val_loss: 6834.0049 - val_mse: 6834.0049\n", - "Epoch 73/100\n", - "2/2 [==============================] - 0s 41ms/step - loss: 12535.9141 - mse: 12535.9141 - val_loss: 6830.6431 - val_mse: 6830.6431\n", - "Epoch 74/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12529.7637 - mse: 12529.7637 - val_loss: 6827.0908 - val_mse: 6827.0908\n", - "Epoch 75/100\n", - "2/2 [==============================] - 0s 46ms/step - loss: 12537.2832 - mse: 12537.2832 - val_loss: 6824.0693 - val_mse: 6824.0693\n", - "Epoch 76/100\n", - "2/2 [==============================] - 0s 46ms/step - loss: 12560.0615 - mse: 12560.0615 - val_loss: 6821.5796 - val_mse: 6821.5796\n", - "Epoch 77/100\n", - "2/2 [==============================] - 0s 45ms/step - loss: 12534.9043 - mse: 12534.9043 - val_loss: 6818.0249 - val_mse: 6818.0249\n", - "Epoch 78/100\n", - "2/2 [==============================] - 0s 42ms/step - loss: 12530.1738 - mse: 12530.1738 - val_loss: 6814.8101 - val_mse: 6814.8101\n", - "Epoch 79/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12530.2627 - mse: 12530.2627 - val_loss: 6811.7124 - val_mse: 6811.7124\n", - "Epoch 80/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12531.0273 - mse: 12531.0273 - val_loss: 6809.1479 - val_mse: 6809.1479\n", - "Epoch 81/100\n", - "2/2 [==============================] - 0s 54ms/step - loss: 12528.5293 - mse: 12528.5293 - val_loss: 6806.4868 - val_mse: 6806.4868\n", - "Epoch 82/100\n", - "2/2 [==============================] - 0s 48ms/step - loss: 12528.3770 - mse: 12528.3770 - val_loss: 6803.9165 - val_mse: 6803.9165\n", - "Epoch 83/100\n", - "2/2 [==============================] - 0s 41ms/step - loss: 12530.9883 - mse: 12530.9883 - val_loss: 6801.2090 - val_mse: 6801.2090\n", - "Epoch 84/100\n", - "2/2 [==============================] - 0s 42ms/step - loss: 12528.4297 - mse: 12528.4297 - val_loss: 6798.7744 - val_mse: 6798.7744\n", - "Epoch 85/100\n", - "2/2 [==============================] - 0s 45ms/step - loss: 12542.8262 - mse: 12542.8262 - val_loss: 6797.0767 - val_mse: 6797.0767\n", - "Epoch 86/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12527.9600 - mse: 12527.9600 - val_loss: 6794.8916 - val_mse: 6794.8916\n", - "Epoch 87/100\n", - "2/2 [==============================] - 0s 41ms/step - loss: 12527.9473 - mse: 12527.9473 - val_loss: 6792.7568 - val_mse: 6792.7568\n", - "Epoch 88/100\n", - "2/2 [==============================] - 0s 41ms/step - loss: 12532.5371 - mse: 12532.5371 - val_loss: 6790.4355 - val_mse: 6790.4355\n", - "Epoch 89/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12530.3691 - mse: 12530.3691 - val_loss: 6788.7583 - val_mse: 6788.7583\n", - "Epoch 90/100\n", - "2/2 [==============================] - 0s 42ms/step - loss: 12536.0205 - mse: 12536.0205 - val_loss: 6786.4990 - val_mse: 6786.4990\n", - "Epoch 91/100\n", - "2/2 [==============================] - 0s 41ms/step - loss: 12528.2305 - mse: 12528.2305 - val_loss: 6784.8643 - val_mse: 6784.8643\n", - "Epoch 92/100\n", - "2/2 [==============================] - 0s 45ms/step - loss: 12538.0020 - mse: 12538.0020 - val_loss: 6782.7163 - val_mse: 6782.7163\n", - "Epoch 93/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12529.5488 - mse: 12529.5488 - val_loss: 6780.9121 - val_mse: 6780.9121\n", - "Epoch 94/100\n", - "2/2 [==============================] - 0s 41ms/step - loss: 12530.9824 - mse: 12530.9824 - val_loss: 6779.1187 - val_mse: 6779.1187\n", - "Epoch 95/100\n", - "2/2 [==============================] - 0s 46ms/step - loss: 12529.6895 - mse: 12529.6895 - val_loss: 6777.8877 - val_mse: 6777.8877\n", - "Epoch 96/100\n", - "2/2 [==============================] - 0s 40ms/step - loss: 12530.5879 - mse: 12530.5879 - val_loss: 6776.2295 - val_mse: 6776.2295\n", - "Epoch 97/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12527.2910 - mse: 12527.2910 - val_loss: 6774.9199 - val_mse: 6774.9199\n", - "Epoch 98/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12533.8867 - mse: 12533.8867 - val_loss: 6774.0078 - val_mse: 6774.0078\n", - "Epoch 99/100\n", - "2/2 [==============================] - 0s 41ms/step - loss: 12530.3994 - mse: 12530.3994 - val_loss: 6772.5107 - val_mse: 6772.5107\n", - "Epoch 100/100\n", - "2/2 [==============================] - 0s 50ms/step - loss: 12527.2217 - mse: 12527.2217 - val_loss: 6771.3604 - val_mse: 6771.3604\n" - ] - } - ], - "source": [ - "results=model.fit(x_train,y_train,epochs=100,validation_split=0.2)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "jmeP6vt3z0oA" - }, - "source": [ - "## Plot Loss\n", - "\n", - "Using matplotlib visualise how the loss (both validation and training) is changing, use this information to retrain the model with appropriate parameters.
We ideally want the loss to be constant over the last few iterations." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 206 - }, - "id": "RQTNqPHm0mOi", - "outputId": "a2aa2f5d-d682-4afa-b3e9-457edfd64ccd" - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
lossmseval_lossval_mseepoch
9512530.58789112530.5878916776.2294926776.22949295
9612527.29101612527.2910166774.9199226774.91992296
9712533.88671912533.8867196774.0078126774.00781297
9812530.39941412530.3994146772.5107426772.51074298
9912527.22168012527.2216806771.3603526771.36035299
\n", - "
" - ], - "text/plain": [ - " loss mse val_loss val_mse epoch\n", - "95 12530.587891 12530.587891 6776.229492 6776.229492 95\n", - "96 12527.291016 12527.291016 6774.919922 6774.919922 96\n", - "97 12533.886719 12533.886719 6774.007812 6774.007812 97\n", - "98 12530.399414 12530.399414 6772.510742 6772.510742 98\n", - "99 12527.221680 12527.221680 6771.360352 6771.360352 99" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import pandas as pd\n", - "res=pd.DataFrame(results.history)\n", - "res['epoch']=results.epoch\n", - "res.tail()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 282 - }, - "id": "ubeaG8e9t7im", - "outputId": "f763ebb3-d143-484d-b333-ccda2479bdb7" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYkAAAD4CAYAAAAZ1BptAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAl40lEQVR4nO3df5xU9X3v8ddnZhcwmvDLDTEsFow0BhVBN4Ihrb8aRdNe1IfhSk0kxoYm0Whjm2h8pLGa0Ic+aqvFa01MQNHkitSYK6lYwlWjsbcSFiUoYOoKWpYgID81BNiZ+dw/zndgdnZmd3b3rDtn9v18POaxZz7ne37t2Z3PfH+cc8zdERERKSXV3zsgIiLVS0lCRETKUpIQEZGylCRERKQsJQkRESmrrr93IG5HH320jx07tr93Q0QkUVatWvW2uzcUx2suSYwdO5bm5ub+3g0RkUQxszdLxdXcJCIiZSlJiIhIWUoSIiJSVs31SYjIwNHW1kZrayv79+/v711JjCFDhtDY2Eh9fX1F5ZUkRCSxWltbef/738/YsWMxs/7enarn7uzYsYPW1lbGjRtX0TJqbhKRxNq/fz8jR45UgqiQmTFy5Mhu1byUJEQk0ZQguqe7vy8lCZE+8PO1b7HtHbWTS/IpSYjELJPN8aUfrWLxyk39vSvyHjjqqKP6exf6lJKESMwyOSfncDCT6+9dEek1JQmRmLVlo+SQyempjwPV6tWrmTp1KhMnTuTiiy9m165dAMybN48JEyYwceJELrvsMgCeffZZJk2axKRJk5g8eTLvvPNOf+56BxoCKxKzbEgOWSWJ99QtP1vLut/ujXWdEz78AW7+sxO7vdwVV1zB3XffzZlnnsm3v/1tbrnlFu666y5uu+02Nm7cyODBg9m9ezcAd9xxB/fccw/Tpk3j3XffZciQIbEeQ2+pJiESs3wNQjWJgWnPnj3s3r2bM888E4DZs2fz3HPPATBx4kQuv/xyfvSjH1FXF31HnzZtGtdffz3z5s1j9+7dh+LVorr2RqQGZLKqSfSHnnzjf6898cQTPPfcc/zsZz9j7ty5vPzyy9x44418+tOfZunSpUybNo1ly5Zxwgkn9PeuHqKahEjMMrlcu58ysAwdOpThw4fzy1/+EoCHHnqIM888k1wux6ZNmzj77LO5/fbb2bNnD++++y6vv/46J598MjfccAMf//jHefXVV/v5CNpTTUIkZuqTGFj27dtHY2PjoffXX389Cxcu5Etf+hL79u3juOOO4/777yebzfLZz36WPXv24O5ce+21DBs2jL/927/lmWeeIZVKceKJJ3LBBRf049F0pCQhErO20NyUb3aS2pYrU2N84YUXOsSef/75DrG777479n2Kk5qbRGKmmoTUEiUJkZgd7pNQkpDkU5IQiZlGN0ktUZIQidnh6yQ0ukmSr8skYWZDzOxXZvZrM1trZreE+ANmttHMVofXpBA3M5tnZi1mtsbMTi1Y12wzey28ZhfETzOzl8My8yzcy9bMRpjZ8lB+uZkNj/03IBIz9UlILamkJnEAOMfdTwEmAdPNbGqY93V3nxReq0PsAmB8eM0B7oXoAx+4GZgCnA7cXPChfy/wxYLlpof4jcBT7j4eeCq8F6lqGd27SWpIl0nCI++Gt/Xh1dlf/wzgwbDcC8AwMzsGOB9Y7u473X0XsJwo4RwDfMDdX3B3Bx4ELipY18IwvbAgLlK1MqpJSA2pqE/CzNJmthrYRvRBvyLMmhualO40s8EhNhoovJF+a4h1Fm8tEQcY5e5bwvRbwKgy+zfHzJrNrHn79u2VHJJIn8knB10nUfvOPvtsli1b1i5211138eUvf7lk+bPOOovm5uay6xs7dixvv/12rPvYWxUlCXfPuvskoBE43cxOAr4JnAB8HBgB3NBXOxn2wSlTg3H3+9y9yd2bGhoa+nI3RLqUv1W4ahK1b9asWSxatKhdbNGiRcyaNauf9ih+3bri2t13m9kzwHR3vyOED5jZ/cDfhPebgTEFizWG2GbgrKL4L0K8sUR5gK1mdoy7bwnNUtu6s78i/SGr0U3948kb4a2X413nh06GC24rO/vSSy/lW9/6FgcPHmTQoEG88cYb/Pa3v+Xhhx/m+uuv5/e//z2XXnopt9xyS4934Y033uALX/gCb7/9Ng0NDdx///0ce+yx/Ou//iu33HIL6XSaoUOH8txzz7F27VquvPJKDh48SC6X4yc/+Qnjx4/v8bahstFNDWY2LEwfAXwKeDV8aBNGIl0EvBIWWQJcEUY5TQX2hCajZcB5ZjY8dFifBywL8/aa2dSwriuAxwvWlR8FNbsgLlK11CcxcIwYMYLTTz+dJ598EohqETNnzmTu3Lk0NzezZs0ann32WdasWdPjbXz1q19l9uzZrFmzhssvv5xrr70WgFtvvZVly5bx61//miVLlgDwve99j+uuu47Vq1fT3Nzc7p5SPVVJTeIYYKGZpYmSymJ3/zcze9rMGgADVgNfCuWXAhcCLcA+4EoAd99pZt8BVoZyt7r7zjD9FeAB4AjgyfACuA1YbGZXAW8CM3t4nCLvmXwNok19Eu+tTr7x96V8k9OMGTNYtGgR8+fPZ/Hixdx3331kMhm2bNnCunXrmDhxYo/W/5//+Z889thjAHzuc5/jG9/4BhA9h+Lzn/88M2fO5JJLLgHgjDPOYO7cubS2tnLJJZf0uhYBFSQJd18DTC4RP6dMeQeuLjNvAbCgRLwZOKlEfAdwblf7KFJNdMX1wDJjxgy+9rWv8eKLL7Jv3z5GjBjBHXfcwcqVKxk+fDif//zn2b9/f+zb/d73vseKFSt44oknOO2001i1ahV//ud/zpQpU3jiiSe48MIL+f73v88555T8qK6YrrgWiZn6JAaWo446irPPPpsvfOELzJo1i71793LkkUcydOhQtm7deqgpqqc+8YlPHOoc//GPf8wf/dEfAfD6668zZcoUbr31VhoaGti0aRMbNmzguOOO49prr2XGjBm9aubK063CRWLWpj6JAWfWrFlcfPHFLFq0iBNOOIHJkydzwgknMGbMGKZNm9atdU2cOJFUKvr+PnPmTO6++26uvPJK/uEf/uFQxzXA17/+dV577TXcnXPPPZdTTjmF22+/nYceeoj6+no+9KEPcdNNN/X62CxqHaodTU1N3tk4ZJG+9sB/bOTvfraOxuFH8PwNvavqS+fWr1/Pxz72sf7ejcQp9Xszs1Xu3lRcVs1NIjHT6CapJWpuEonZ4bvAKklIaVOmTOHAgQPtYg899BAnn3xyP+1ReUoSIjHTXWDfW+5OuHF0YqxYsaLrQn2ku10Mam4SiVnm0DOuNbqprw0ZMoQdO3Z0+4NvoHJ3duzYwZAhQypeRjUJkZjlh76qJtH3GhsbaW1tRTf2rNyQIUO6dSW2koRIzNQn8d6pr69n3Lhx/b0bNU3NTSIxU5+E1BIlCZGYtRU8mU5t5ZJ0ShIiMSusQagyIUmnJCESs8K+CN2/SZJOSUIkZoVDX9UvIUmnJCESs/Y1CSUJSTYlCZGYFdYesnrwkCSckoRIzDJZ1SSkdlTyjOshZvYrM/u1ma01s1tCfJyZrTCzFjN7xMwGhfjg8L4lzB9bsK5vhvhvzOz8gvj0EGsxsxsL4iW3IVLNCjur1SchSVdJTeIAcI67nwJMAqab2VTgduBOdz8e2AVcFcpfBewK8TtDOcxsAnAZcCIwHfgXM0uHZ2ffA1wATABmhbJ0sg2RqpXV6CapIV0mCY+8G97Wh5cD5wCPhvhC4KIwPSO8J8w/16JbNM4AFrn7AXffCLQAp4dXi7tvcPeDwCJgRlim3DZEqlZbQXOTahKSdBX1SYRv/KuBbcBy4HVgt7tnQpFWYHSYHg1sAgjz9wAjC+NFy5SLj+xkGyJVK6vRTVJDKkoS7p5190lAI9E3/xP6cqe6y8zmmFmzmTXrbpDS3wqbmDIa3SQJ163RTe6+G3gGOAMYZmb5u8g2ApvD9GZgDECYPxTYURgvWqZcfEcn2yjer/vcvcndmxoaGrpzSCKxaz+6SX0SkmyVjG5qMLNhYfoI4FPAeqJkcWkoNht4PEwvCe8J85/26C5nS4DLwuinccB44FfASmB8GMk0iKhze0lYptw2RKpWYROT+iQk6Sp5nsQxwMIwCikFLHb3fzOzdcAiM/su8BIwP5SfDzxkZi3ATqIPfdx9rZktBtYBGeBqd88CmNk1wDIgDSxw97VhXTeU2YZI1crmnJRFN/dTn4QkXZdJwt3XAJNLxDcQ9U8Ux/cDnymzrrnA3BLxpcDSSrchUs3asjkG16X5fVtWNQlJPF1xLRKzbM4ZUh/9a6njWpJOSUIkZtmcM7gufWhaJMmUJERi1pbLMThfk9DoJkk4JQmRmGWzzhDVJKRGKEmIxCyT84KahJKEJJuShEjMMjnVJKR2KEmIxCyTzakmITVDSUIkZu1HN6njWpJNSUIkZm2FfRK6TkISTklCJGZZ9UlIDVGSEImRu0fNTeqTkBqhJCESo3xSGFwX/WupJiFJpyQhEqN8UhhSHzU3qSYhSackIRKjjjUJjW6SZFOSEIlRJhslhfwQWNUkJOmUJERilDnU3BRqEhoCKwmnJCESo3yfxKA6jW6S2qAkIRKjttDcVJ9KkU6ZRjdJ4nWZJMxsjJk9Y2brzGytmV0X4n9nZpvNbHV4XViwzDfNrMXMfmNm5xfEp4dYi5ndWBAfZ2YrQvwRMxsU4oPD+5Ywf2ysRy8Ss3xSqEsb6ZTRpo5rSbhKahIZ4K/dfQIwFbjazCaEeXe6+6TwWgoQ5l0GnAhMB/7FzNJmlgbuAS4AJgCzCtZze1jX8cAu4KoQvwrYFeJ3hnIiVSvfvJROGXUpU5+EJF6XScLdt7j7i2H6HWA9MLqTRWYAi9z9gLtvBFqA08Orxd03uPtBYBEww8wMOAd4NCy/ELioYF0Lw/SjwLmhvEhVyt+rqS40N6lPQpKuW30SoblnMrAihK4xszVmtsDMhofYaGBTwWKtIVYuPhLY7e6Zoni7dYX5e0L54v2aY2bNZta8ffv27hySSKzyjyutS4eahJKEJFzFScLMjgJ+AvyVu+8F7gU+AkwCtgD/2Bc7WAl3v8/dm9y9qaGhob92Q+Rwn0TKSKdSqklI4lWUJMysnihB/NjdHwNw963unnX3HPADouYkgM3AmILFG0OsXHwHMMzM6ori7dYV5g8N5UWqUlu2qE9CHdeScJWMbjJgPrDe3f+pIH5MQbGLgVfC9BLgsjAyaRwwHvgVsBIYH0YyDSLq3F7i7g48A1walp8NPF6wrtlh+lLg6VBepCrlaxL1afVJSG2o67oI04DPAS+b2eoQu4lodNIkwIE3gL8EcPe1ZrYYWEc0Mupqd88CmNk1wDIgDSxw97VhfTcAi8zsu8BLREmJ8PMhM2sBdhIlFpGqle+TSKeMurT6JCT5ukwS7v48UGpE0dJOlpkLzC0RX1pqOXffwOHmqsL4fuAzXe2jSLU4PLrJVJOQmqArrkVidPhiuhT1qZSuk5DEU5IQiVEmp5qE1BYlCZEY5W8VfrhPQqObJNmUJERilDk0ukk1CakNShIiMcoeundTSldcS01QkhCJUf5W4eqTkFqhJCESo8JbhdelUqpJSOIpSYjEqPBW4apJSC1QkhCJUeZQc1NK926SmqAkIRKjTNGT6TK6mE4STklCJEaFtwrXvZukFihJiMSofZ+EOq4l+ZQkRGKUb16qD30S6riWpFOSEIlRNpfDDFL50U1ZdVxLsilJiMSoLefUpaI766smIbVASUIkRtmcU5eK/q3Sui2H1AAlCZEYZbKqSUhtqeQZ12PM7BkzW2dma83suhAfYWbLzey18HN4iJuZzTOzFjNbY2anFqxrdij/mpnNLoifZmYvh2Xmhedql92GSLXK5HKk01GS0OgmqQWV1CQywF+7+wRgKnC1mU0AbgSecvfxwFPhPcAFwPjwmgPcC9EHPnAzMIXoUaU3F3zo3wt8sWC56SFebhsiVSlT0NxUl7ZDz7wWSaouk4S7b3H3F8P0O8B6YDQwA1gYii0ELgrTM4AHPfICMMzMjgHOB5a7+0533wUsB6aHeR9w9xfc3YEHi9ZVahsiVSlb0NykPgmpBd3qkzCzscBkYAUwyt23hFlvAaPC9GhgU8FirSHWWby1RJxOtlG8X3PMrNnMmrdv396dQxKJVVsuR1p9ElJDKk4SZnYU8BPgr9x9b+G8UAPo0/+Gzrbh7ve5e5O7NzU0NPTlboh0Kptz6tP5JJHCHXJKFJJgFSUJM6snShA/dvfHQnhraCoi/NwW4puBMQWLN4ZYZ/HGEvHOtiFSlTI5P1yTCMlCtQlJskpGNxkwH1jv7v9UMGsJkB+hNBt4vCB+RRjlNBXYE5qMlgHnmdnw0GF9HrAszNtrZlPDtq4oWlepbYhUpUw21+46CUD9EpJodRWUmQZ8DnjZzFaH2E3AbcBiM7sKeBOYGeYtBS4EWoB9wJUA7r7TzL4DrAzlbnX3nWH6K8ADwBHAk+FFJ9sQqUrZnB+qQeQ7sKMRTul+3CuRnusySbj784CVmX1uifIOXF1mXQuABSXizcBJJeI7Sm1DpFplcu1HN4FqEpJsuuJaJEaZrLcb3QTqk5BkU5IQiVEml6Mune+TiH6qJiFJpiQhEqNs0V1gQTUJSTYlCZEYtRU0Nx3qk9BzriXBlCREYhRdTHf43k2A7t8kiaYkIRKjwovpNLpJaoGShEiMoovp1CchtUNJQiRG0cV0Gt0ktUNJQiRGGY1ukhqjJCESo0w2V6JPQh3XklxKEiIxyrS7VXj0s01DYCXBlCREYpTV6CapMUoSIjFqK7hVuJ4nIbVASUIkRtl2d4HNj25Sn4Qkl5KESIwyOSdd/DwJ9UlIgilJiMRIz5OQWqMkIRITdw/NTaFPQtdJSA1QkhCJSb7GcOhiurSuuJbk6zJJmNkCM9tmZq8UxP7OzDab2erwurBg3jfNrMXMfmNm5xfEp4dYi5ndWBAfZ2YrQvwRMxsU4oPD+5Ywf2xsRy3SB/I1hg59EkoSkmCV1CQeAKaXiN/p7pPCaymAmU0ALgNODMv8i5mlzSwN3ANcAEwAZoWyALeHdR0P7AKuCvGrgF0hfmcoJ1K18smgPpW/d5OuuJbk6zJJuPtzwM4K1zcDWOTuB9x9I9ACnB5eLe6+wd0PAouAGWZmwDnAo2H5hcBFBetaGKYfBc4N5UWqUv7hQnrGtdSS3vRJXGNma0Jz1PAQGw1sKijTGmLl4iOB3e6eKYq3W1eYvyeU78DM5phZs5k1b9++vReHJNJzbaHGkL+ITqObpBb0NEncC3wEmARsAf4xrh3qCXe/z92b3L2poaGhP3dFBrDDHdepdj91nYQkWY+ShLtvdfesu+eAHxA1JwFsBsYUFG0MsXLxHcAwM6srirdbV5g/NJQXqUqZotFN+Q5s1SQkyXqUJMzsmIK3FwP5kU9LgMvCyKRxwHjgV8BKYHwYyTSIqHN7ibs78AxwaVh+NvB4wbpmh+lLgadDeZGqlMlGzU3qk5BaUtdVATN7GDgLONrMWoGbgbPMbBLgwBvAXwK4+1ozWwysAzLA1e6eDeu5BlgGpIEF7r42bOIGYJGZfRd4CZgf4vOBh8yshajj/LLeHqxIXzpUk+jQJ6HRTZJcXSYJd59VIjy/RCxffi4wt0R8KbC0RHwDh5urCuP7gc90tX8i1aK4TyJtqklI8umKa5GYtBU1N6VSRsrUJyHJpiQhEpN8Msg/mQ6iWoVqEpJkShIiMTl0W47U4SSRTplqEpJoShIiMclfD5Hvk4imTddJSKIpSYjEJFN0xTVE10podJMkmZKESEyKbxWen25Tc5MkmJKESEwy2TJ9EmpukgRTkhCJyaFbhacL+yQ0ukmSTUlCJCb5voeOo5vUJyHJpSQhEpO2bOk+CdUkJMmUJERicqjjuqC5SddJSNIpSYjEpPhW4RAlDNUkJMmUJERiUnyrcIgShmoSkmRKEiIxKb5VOEQJQzUJSTIlCZGYFN8qPJrW6CZJNiUJkZgU3yo8P617N0mSKUmIxKTkrcLT6pOQZOsySZjZAjPbZmavFMRGmNlyM3st/Bwe4mZm88ysxczWmNmpBcvMDuVfM7PZBfHTzOzlsMw8s+hxXuW2IVKtSt8qXKObJNkqqUk8AEwvit0IPOXu44GnwnuAC4Dx4TUHuBeiD3yiZ2NPIXpU6c0FH/r3Al8sWG56F9sQqUrlbhWumoQkWZdJwt2fA3YWhWcAC8P0QuCigviDHnkBGGZmxwDnA8vdfae77wKWA9PDvA+4+wvu7sCDResqtQ2RqpTN5TAr0SehJCEJ1tM+iVHuviVMvwWMCtOjgU0F5VpDrLN4a4l4Z9vowMzmmFmzmTVv3769B4cj0nuZnLe7kA40ukmSr9cd16EG0Kdflbrahrvf5+5N7t7U0NDQl7siUlYm5+1qEaCahCRfT5PE1tBURPi5LcQ3A2MKyjWGWGfxxhLxzrYhUpUyWac+1f5fSn0SknQ9TRJLgPwIpdnA4wXxK8Iop6nAntBktAw4z8yGhw7r84BlYd5eM5saRjVdUbSuUtsQqUrZXI50urgmkdJ1EpJodV0VMLOHgbOAo82slWiU0m3AYjO7CngTmBmKLwUuBFqAfcCVAO6+08y+A6wM5W5193xn+FeIRlAdATwZXnSyDZGq1Fa2T0JJQpKryyTh7rPKzDq3RFkHri6zngXAghLxZuCkEvEdpbYhUq2yWW83/BUgnVafhCSbrrgWiUmpjmuNbpKkU5IQiUkml2t3B1jQ6CZJPiUJkZiUq0mo41qSTElCJCbZEkNg06mUOq4l0ZQkRGKSyeVK1yTUJyEJpiQhEpNMzkv2SeQccqpNSEIpSYjEJJPteJ1E/tkSWVeSkGRSkhCJSSaX63idRHivfglJKiUJkZhky4xuAjQMVhJLSUIkJm3Z0n0SEI18EkkiJQmRmGRL3bspna9JaISTJJOShEhMoovpivskQk1CzU2SUEoSIjHJZHOHRjPlqU9Ckk5JQiQmpTquNbpJkk5JQiQm5Z5xnZ8nkkRKEiIxyWRz1KXL9Umo41qSSUlCJCaqSUgtUpIQiUnpPomQJHSdhCRUr5KEmb1hZi+b2Wozaw6xEWa23MxeCz+Hh7iZ2TwzazGzNWZ2asF6Zofyr5nZ7IL4aWH9LWFZ67gXItWhLZujvqi5KX+dhDquJaniqEmc7e6T3L0pvL8ReMrdxwNPhfcAFwDjw2sOcC9ESQW4GZgCnA7cnE8socwXC5abHsP+ivSJzkY3qblJkqovmptmAAvD9ELgooL4gx55ARhmZscA5wPL3X2nu+8ClgPTw7wPuPsL7u7AgwXrEqk6nfVJqCYhSdXbJOHAz81slZnNCbFR7r4lTL8FjArTo4FNBcu2hlhn8dYS8Q7MbI6ZNZtZ8/bt23tzPCI9Vu55EtE8jW6SZKrr5fKfdPfNZvZBYLmZvVo4093dzPr8K5S73wfcB9DU1KSvbPKec/fQ3FTUJ6GahCRcr2oS7r45/NwG/JSoT2FraCoi/NwWim8GxhQs3hhincUbS8RFqk4+CRQ3N6U1BFYSrsdJwsyONLP356eB84BXgCVAfoTSbODxML0EuCKMcpoK7AnNUsuA88xseOiwPg9YFubtNbOpYVTTFQXrEqkq+SRQ3NyUfwiRhsBKUvWmuWkU8NMwKrUO+N/u/u9mthJYbGZXAW8CM0P5pcCFQAuwD7gSwN13mtl3gJWh3K3uvjNMfwV4ADgCeDK8RKpOpouahK64lqTqcZJw9w3AKSXiO4BzS8QduLrMuhYAC0rEm4GTerqPIn0q2wa/uA2mfpmsDQXo2CeRVnOTJJuuuBbpqU0r4Jd3wJpHOJiNagrFtwrX8yQk6ZQkRHrqrVein60reW3bOwCMGfG+dkXq1SchCdfbIbAiA9fWl6Ofm1by4shdAJw6Zni7ImndlkMSTjUJkZ7K1yT2trJhQwvHf/Aohr6vvl0R3QVWkk5JQqQnshnYth6OPQMA27ySU48d1qGYRjdJ0ilJiPTEjhbIHoBTZuGpQfxh26uc9gfDOxRTTUKSTn0SIj2xNTQ1jT6VHUM/xqk7XmPYsR2ThEY3SdKpJiHSE1tfgVQ9HP1RXk1/lJNTG/nIiEEditXpVuGScEoSIj3x1ivQ8FGoG8Qv9o1jCG2ktq3tUEw1CUk6JQmRntj6Cow6ib3721i6K9yHsnVlh2J1enypJJyShEh3/W4HvLMFPnQSq/97N7/1kRw44kMlk0QqZZhpdJMkl5KESHflL6IbdSKr3tyFGaSOPR02/apk8bqUqU9CEkujmwoczOR49r+289OXWtn49j7+ePzRfGrCKCYfO7zDs4tlANsa+h5GncyLv9jAR0e9n/o/OB1+swTe3QZHfbBd8XTK1CchiaUkETz0f5t55D/W88rvRzDyyEEc/8GjmP/8Rr7/3AYG16UYlC6odJXJF+XSSLidOtGNcEvPtwpzUHdTlZVYceF+lPvo6mw7pdbZleJjz68jv6aefIR2dy+8gv2IYu23YgYpg8F1aYbUp7hh/9N8vG4EP13zO1b/927+bNKHofH0qPjrT8Mpl7XbRn0qxf3/7w0ead5EscJNdfU76Op4u/o7KyxTbt35Jcv9nrqr1FKVnGt3D+ercB8gZdbt816JUvuU307+0Mv9Wrv6H+rJ/1hP3T1rMp84/uhY16kkEXxiw13MZDkbP/lNPjL9q9TXpdm7v41f/GY7azbtJv9F0Muc8k7+L7vU2T91u3LdXm/5eYX/88V/rPl/zlKfCz05TscxrMM/W/HvstS/f37ZUvGe6Go/Co/v8IeUk8vBgUyWA5kcH3lzI69kjuXmJVGNYsq4EfDhP4SGE2DJtVA3BE686NB6vvWnH2Pdb/eWOIZS+1fa4Q/vys5Ld85dufNQ6vcU1zmqZD1m0e/DzA4ljVxv/tG6ULjt/L5X8nstXja/fOG5KjW/O8qd92JHv39wt9ZbCav0AyopmpqavLm5ufsL7t4ES66BDb+A486GC++A940IZ8YO/4TS013NL54+9J7Kzr5Uh2wb/P2H8SlfZuuUm3hzx+9oGjsiao7ctxMenhXdQvz8v4czvtLfeytSMTNb5e5NHeJKEgXcoXk+/Pzb0Pa7eHesYlYiaRTGipNMqUTTkzKl4pSJl9i/svO6sb12xbu7njJlKl5v0fKFv28DLBW9PAe73oBLfgATZ3ZctO338NgXYf3Poovtyp634u2U2Pc+OV+9OVcdNtK9db2X5Stevpvr6vb3uR58AezNl8YZ98DYT/Zo0XJJouqbm8xsOvDPQBr4obvf1ocbg4//BRz/J/BfPwfPhvqmF9Q7S013Np8S8fAeDi9fPH2oWPH8UuvzovLltlmmTE/jXc3r1nopXaZX26pwvR2KFJ0P9yg55F/HfiL6Gyml/gj4zEJYdT/saS2/32XPdal9iul89eZcdbZ/3T4XcZUvU7wnBSv6stzNL9Q9+gLeyy/tQ4b1bvkSqromYWZp4L+ATwGtRM/BnuXu68ot06uahIjIAFWuJlHt10mcDrS4+wZ3PwgsAmb08z6JiAwY1Z4kRgOF4wZbQ6wdM5tjZs1m1rx9+/b3bOdERGpdtSeJirj7fe7e5O5NDQ0N/b07IiI1o9qTxGZgTMH7xhATEZH3QLUniZXAeDMbZ2aDgMuAJf28TyIiA0ZVD4F194yZXQMsIxoCu8DdO960X0RE+kRVJwkAd18KLO3v/RARGYiqvblJRET6UVVfTNcTZrYdeLOHix8NvB3j7iTFQDzugXjMMDCPeyAeM3T/uP/A3TsMD625JNEbZtZc6orDWjcQj3sgHjMMzOMeiMcM8R23mptERKQsJQkRESlLSaK9+/p7B/rJQDzugXjMMDCPeyAeM8R03OqTEBGRslSTEBGRspQkRESkLCWJwMymm9lvzKzFzG7s7/3pC2Y2xsyeMbN1ZrbWzK4L8RFmttzMXgs/h/f3vsbNzNJm9pKZ/Vt4P87MVoTz/Ui4N1hNMbNhZvaomb1qZuvN7IxaP9dm9rXwt/2KmT1sZkNq8Vyb2QIz22ZmrxTESp5bi8wLx7/GzE7tzraUJDj0BLx7gAuACcAsM5vQv3vVJzLAX7v7BGAqcHU4zhuBp9x9PPBUeF9rrgPWF7y/HbjT3Y8HdgFX9cte9a1/Bv7d3U8ATiE6/po912Y2GrgWaHL3k4ju93YZtXmuHwCmF8XKndsLgPHhNQe4tzsbUpKIDIgn4Ln7Fnd/MUy/Q/ShMZroWBeGYguBi/plB/uImTUCnwZ+GN4bcA7waChSi8c8FPhjYD6Aux90993U+Lkmuh/dEWZWB7wP2EINnmt3fw7YWRQud25nAA965AVgmJkdU+m2lCQiFT0Br5aY2VhgMrACGOXuW8Kst4BR/bVffeQu4BtALrwfCex290x4X4vnexywHbg/NLP90MyOpIbPtbtvBu4A/psoOewBVlH75zqv3Lnt1eebksQAZGZHAT8B/srd9xbO82hMdM2MizazPwW2ufuq/t6X91gdcCpwr7tPBn5HUdNSDZ7r4UTfmscBHwaOpGOTzIAQ57lVkogMmCfgmVk9UYL4sbs/FsJb89XP8HNbf+1fH5gG/A8ze4OoGfEcorb6YaFJAmrzfLcCre6+Irx/lChp1PK5/hNgo7tvd/c24DGi81/r5zqv3Lnt1eebkkRkQDwBL7TFzwfWu/s/FcxaAswO07OBx9/rfesr7v5Nd29097FE5/Vpd78ceAa4NBSrqWMGcPe3gE1m9tEQOhdYRw2fa6Jmpqlm9r7wt54/5po+1wXKndslwBVhlNNUYE9Bs1SXdMV1YGYXErVd55+AN7d/9yh+ZvZJ4JfAyxxun7+JqF9iMXAs0W3WZ7p7cadY4pnZWcDfuPufmtlxRDWLEcBLwGfd/UA/7l7szGwSUWf9IGADcCXRF8OaPddmdgvwP4lG8r0E/AVR+3tNnWszexg4i+h24FuBm4H/Q4lzGxLm/yJqetsHXOnuzRVvS0lCRETKUXOTiIiUpSQhIiJlKUmIiEhZShIiIlKWkoSIiJSlJCEiImUpSYiISFn/Hyv6lfNdObSZAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(res['epoch'],res['loss'])\n", - "plt.plot(res['epoch'],res['val_loss'])\n", - "plt.legend([\"Loss\",\"Val_Loss\"])\n", - "# plt.xlim(0,80)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "IVrR_vXA7kOt" - }, - "source": [ - "## Evaluation Metrics\n", - "Use the R2 Score function implemented in the first assignment to evaluate the performance of the model." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "id": "-lOHpD8-7ggm" - }, - "outputs": [], - "source": [ - "# Insert the function for R2 Score\n", - "\n", - "def r2_score_predictor(y_true,y_pred):\n", - " from sklearn.metrics import r2_score\n", - " r=r2_score(y_true,y_pred)\n", - " return r\n", - "predictions=model.predict(x_test)\n", - "r=r2_score_predictor(y_test,predictions)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "SCApVNjtzbv8", - "outputId": "f108f6c9-9479-442a-f7f4-2c087c3986da" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The r2_score value is -0.0909121073526411\n" - ] - } - ], - "source": [ - "print(\"The r2_score value is \",r)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "CHqzF1OU0pBg" - }, - "source": [ - "## Your own custom model\n", - "Build a custom model of your own choice.
\n", - "Describe it in detail in Markdown/Latex in the cell below.
\n", - "Visualise the loss, as before." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "jF8oTUqq0y0g" - }, - "source": [ - "Your text here" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "from sklearn import datasets\n", - "from sklearn.model_selection import train_test_split\n", - "\n", - "# Generate the data\n", - "x_2, y_2 = datasets.make_regression(n_samples=1000, n_features=5, noise=5, random_state=4)\n", - "\n", - "\n", - "# Split the data\n", - "x_train_2, x_test_2, y_train_2, y_test_2 = train_test_split(x_2, y_2, test_size=0.2, random_state=1234)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Instead of using SGD optimizer we can use Adam optimizer to get better results." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "id": "1XOk5hJu0oSQ" - }, - "outputs": [], - "source": [ - "import tensorflow as tf\n", - "model_2=tf.keras.models.Sequential([\n", - " tf.keras.layers.InputLayer(input_shape=5) ,\n", - " tf.keras.layers.Dense(30,activation='relu'),\n", - " tf.keras.layers.Dense(30,activation='relu'),\n", - " tf.keras.layers.Dense(1)\n", - "\n", - " ])\n", - "\n", - "optimi=tf.keras.optimizers.Adam( learning_rate=0.01)\n", - "\n", - "\n", - "model_2.compile(loss='mean_squared_error',optimizer=optimi,metrics=tf.keras.metrics.Accuracy())\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model: \"sequential\"\n", - "_________________________________________________________________\n", - " Layer (type) Output Shape Param # \n", - "=================================================================\n", - " dense (Dense) (None, 30) 180 \n", - " \n", - " dense_1 (Dense) (None, 30) 930 \n", - " \n", - " dense_2 (Dense) (None, 1) 31 \n", - " \n", - "=================================================================\n", - "Total params: 1,141\n", - "Trainable params: 1,141\n", - "Non-trainable params: 0\n", - "_________________________________________________________________\n" - ] - } - ], - "source": [ - "model_2.summary()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "aS0ROZa402Lo", - "outputId": "c852055e-ec4f-4272-ad30-e068b76c623f" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 1/20\n", - "20/20 [==============================] - 1s 17ms/step - loss: 22293.0352 - accuracy: 0.0000e+00 - val_loss: 22968.2930 - val_accuracy: 0.0000e+00\n", - "Epoch 2/20\n", - "20/20 [==============================] - 0s 5ms/step - loss: 16845.7617 - accuracy: 0.0000e+00 - val_loss: 11418.9531 - val_accuracy: 0.0000e+00\n", - "Epoch 3/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 4155.4365 - accuracy: 0.0000e+00 - val_loss: 745.3987 - val_accuracy: 0.0000e+00\n", - "Epoch 4/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 621.0253 - accuracy: 0.0000e+00 - val_loss: 412.5599 - val_accuracy: 0.0000e+00\n", - "Epoch 5/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 308.1701 - accuracy: 0.0000e+00 - val_loss: 312.2416 - val_accuracy: 0.0000e+00\n", - "Epoch 6/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 240.7342 - accuracy: 0.0000e+00 - val_loss: 267.2795 - val_accuracy: 0.0000e+00\n", - "Epoch 7/20\n", - "20/20 [==============================] - 0s 5ms/step - loss: 207.0453 - accuracy: 0.0000e+00 - val_loss: 246.7999 - val_accuracy: 0.0000e+00\n", - "Epoch 8/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 185.6382 - accuracy: 0.0000e+00 - val_loss: 233.2929 - val_accuracy: 0.0000e+00\n", - "Epoch 9/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 172.4978 - accuracy: 0.0000e+00 - val_loss: 238.8235 - val_accuracy: 0.0000e+00\n", - "Epoch 10/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 154.8446 - accuracy: 0.0000e+00 - val_loss: 173.0536 - val_accuracy: 0.0000e+00\n", - "Epoch 11/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 129.1207 - accuracy: 0.0000e+00 - val_loss: 134.6592 - val_accuracy: 0.0000e+00\n", - "Epoch 12/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 121.6438 - accuracy: 0.0000e+00 - val_loss: 122.1448 - val_accuracy: 0.0000e+00\n", - "Epoch 13/20\n", - "20/20 [==============================] - 0s 5ms/step - loss: 100.9714 - accuracy: 0.0000e+00 - val_loss: 108.3006 - val_accuracy: 0.0000e+00\n", - "Epoch 14/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 88.0066 - accuracy: 0.0000e+00 - val_loss: 93.5628 - val_accuracy: 0.0000e+00\n", - "Epoch 15/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 74.2823 - accuracy: 0.0000e+00 - val_loss: 83.5923 - val_accuracy: 0.0000e+00\n", - "Epoch 16/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 67.1191 - accuracy: 0.0000e+00 - val_loss: 84.6325 - val_accuracy: 0.0000e+00\n", - "Epoch 17/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 59.6604 - accuracy: 0.0000e+00 - val_loss: 64.3586 - val_accuracy: 0.0000e+00\n", - "Epoch 18/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 50.1667 - accuracy: 0.0000e+00 - val_loss: 57.6406 - val_accuracy: 0.0000e+00\n", - "Epoch 19/20\n", - "20/20 [==============================] - 0s 8ms/step - loss: 45.9919 - accuracy: 0.0000e+00 - val_loss: 50.3901 - val_accuracy: 0.0000e+00\n", - "Epoch 20/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 43.3895 - accuracy: 0.0000e+00 - val_loss: 46.8216 - val_accuracy: 0.0000e+00\n" - ] - } - ], - "source": [ - "results_2=model_2.fit(x_train_2,y_train_2,epochs=20,validation_split=0.2)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 206 - }, - "id": "-v9c8bWtxbgP", - "outputId": "19e97d03-36e9-4893-ace2-3da787fe8f49" - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
lossaccuracyval_lossval_accuracyepoch
1567.1190570.084.6324620.015
1659.6604310.064.3586040.016
1750.1667180.057.6405750.017
1845.9919090.050.3900990.018
1943.3894840.046.8216480.019
\n", - "
" - ], - "text/plain": [ - " loss accuracy val_loss val_accuracy epoch\n", - "15 67.119057 0.0 84.632462 0.0 15\n", - "16 59.660431 0.0 64.358604 0.0 16\n", - "17 50.166718 0.0 57.640575 0.0 17\n", - "18 45.991909 0.0 50.390099 0.0 18\n", - "19 43.389484 0.0 46.821648 0.0 19" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import pandas as pd\n", - "res_2=pd.DataFrame(results_2.history)\n", - "res_2['epoch']=results_2.epoch\n", - "res_2.tail()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 282 - }, - "id": "6xWw8yxhxxmt", - "outputId": "4acfcf6e-3e59-48e7-fabe-3bac990417b3" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "plt.plot(res_2['epoch'],res_2['loss'])\n", - "plt.plot(res_2['epoch'],res_2['val_loss'])\n", - "plt.legend([\"Val_Loss\",\"Loss\"])\n", - "# plt.xlim(0,80)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "id": "FeWhnbAV0PUX" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2_score is 0.9978912555372441\n" - ] - } - ], - "source": [ - "# R2 score calculation\n", - "\n", - "from sklearn.metrics import r2_score\n", - "predic=model_2.predict(x_test_2)\n", - "r2_sco=r2_score(y_test_2,predic)\n", - "print(\"r2_score is \",r2_sco)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "r2_score coming close to 1 signify that our model is performing very well on the test data set ." - ] - } - ], - "metadata": { - "colab": { - "collapsed_sections": [], - "name": "Copy of CVusingTF_Assgn2.ipynb", - "provenance": [] - }, - "interpreter": { - "hash": "d32dd9972e4becc079854756227bbaf57600491c52d25499cfd0dde1c0f41dcc" - }, - "kernelspec": { - "display_name": "Python 3.9.6 64-bit", - "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.9.6" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} From ebdb39a39a3ce4894f11b010b0731c59bfac775f Mon Sep 17 00:00:00 2001 From: Abhay-sisodia <84870507+Abhay-sisodia@users.noreply.github.com> Date: Tue, 14 Jun 2022 15:58:48 +0530 Subject: [PATCH 5/8] Delete Assignment_2 directory --- Assignment_2/A2_200014.ipynb | 1090 ---------------------------------- 1 file changed, 1090 deletions(-) delete mode 100644 Assignment_2/A2_200014.ipynb diff --git a/Assignment_2/A2_200014.ipynb b/Assignment_2/A2_200014.ipynb deleted file mode 100644 index 973ca6c..0000000 --- a/Assignment_2/A2_200014.ipynb +++ /dev/null @@ -1,1090 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "UxcaEbrCy1g_" - }, - "source": [ - "# Assigment 2: Deep Learning" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "h2JON-_Oy79w" - }, - "source": [ - "## Generate Dataset\n", - "\n", - "This is the same code from Assignment 1" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "id": "hgpG3WDuypfa" - }, - "outputs": [], - "source": [ - "from sklearn import datasets\n", - "from sklearn.model_selection import train_test_split\n", - "\n", - "# Generate the data\n", - "x, y = datasets.make_regression(n_samples=100, n_features=5, noise=5, random_state=4)\n", - "\n", - "\n", - "# Split the data\n", - "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=1234)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "H6yGzfrTyqcs", - "outputId": "60310a69-fdbc-4da7-8dcf-573e8a2ef598" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(80, 6)" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import numpy as np\n", - "y_train=y_train.reshape(-1,1)\n", - "z_train=np.concatenate((x_train,y_train),axis=1)\n", - "z_train.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "ZFK06IAqz7JU", - "outputId": "11d0d9a8-0102-4b5a-e00c-64f2958be46a" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "-261.6982943912921" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "y_train.min()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "r6it-Rm7zD1Y" - }, - "source": [ - "## Visualize Dataset\n", - "This is the same code from Assignment 1" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "UautPVj1yzaQ", - "outputId": "c1ceed4c-fa2f-4a3d-f9ba-547b66f1c1c8" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "# Visualizing the train dataset \n", - "import matplotlib.pyplot as plt\n", - "fig, axs = plt.subplots(5,figsize=(20,30))\n", - "\n", - "for i in range(5):\n", - " axs[i].scatter(x_train[:,i],y_train)\n", - "\n", - "\n", - "\n", - "\n", - "# Your code here" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "erZ1XReZ1QzO", - "outputId": "db319adf-ff5f-4dbe-af6f-ed1bf8c8239a" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAALEAAAReCAYAAACYdNGBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABG0klEQVR4nO3debhcVZn2/+/NYIROSEiQMAoRiDa2/kACaDfKJINTVBRBuhVwiK2NIwr4wk/FbhH0BQQEBUQijo2ogDIoKqMSiCJzICAICRIFEkBFBZLn/WPvE3cOp2pVnap9qtap+3Nd57Kyd23PA9fDzqq171pLEYFZzlbrdQFmnXITW/bcxJY9N7Flz01s2XMTW/bWqPsXvODoEz2HV7M7Pvlh9bqGXvKd2LLnJrbsuYkte25iy17yg52kFwCvBzYuDz0AXBgRC+oszKxVTe/Ekg4HvgMIuL78EfBtSUc0uW6OpF9J+tWjv7q2m/WaPYOapdgkLQReGBFPDTv+LOC2iNgq9Qs8xVY/T7E1twLYaITjG5bnzHouNSb+EPAzSXcBi8pjzwW2BA6psS6zljVt4oi4VNJMYAdW/WA3PyKW112cWSuSsxMRsQKYNwa1mI2K54kte7UHgN70xqvr/hXGh3tdQE/5TmzZcxNb9tzElj03sWXPTWzZcxNb9kbdxJIObnJuZYrtN+fdO9pfYdaSTu7ERzc6ERFnRMSsiJi17ZtndPArzNKaPuyQdHOjU8D07pdj1r7UE7vpwF7AsmHHBfyylorM2pRq4h8BEyPixuEnJF1RR0Fm7UpFMd/Z5NwB3S/HrH2eYrPs1Z5iu+TUl9f9KwbeZ07vdQW95TuxZc9NbNlzE1v23MSWvWQTS3qBpN0lTRx2fO/6yjJrXWoZqw8AFwDvB26V9PrK6WPqLMysVak78buB7SLiDcAuwP8v6YPluYZLJ1VTbA8v8FpsVq9UE68WEX8GiIjfUTTyqySdQJMmrqbY1vvnl3WrVrMRpZr4D5K2GfpD2dCvBdYDXlRjXWYtSzXx24El1QMR8XREvB14RW1VmbUhFQBa3OTcL7pfjln7PE9s2as9ADR5v4Y3c7Ou8J3Ysucmtuy5iS17bmLLnpvYstfKZow7ABER8yVtDewN3BERF9denVkLUim2TwInA1+S9Fngi8A/AUdIOrLJdSsDQL//UaP1V8y6I7UZ4y3ANsAEisfPm0TE45LWAq6LiBenfsGuPz/UmzHW7PLdjvdmjE08HRHLI+IJ4LcR8ThARPwVb8ZofSLVxE9KWrt8vd3QQUmTcRNbn0h9sHtFRPwdVu5nN2RN4MDaqjJrQyrF9vcGxx8GHq6lIrM2eZ7Ysld7im3Ch9aq+1fYgM9i+k5s2XMTW/bcxJY9N7Flr+0mlnROHYWYjVZq96QLhx8CdpU0BSAiZtdUl1nLUlNsmwC3A18BgqKJZwHHN7tI0hxgDsDWG7+KTae+pPNKzRpIDSdmAb8GjgQei4grgL9GxJURcWWji6rLWLmBrW6px84rgBMlfbf83z+krjEbay01ZLkS0L6SXgM8Xm9JZu1p664aERcBF9VUi9moeJ7YsucmtuzV/iHtrgOn1v0rbMD5TmzZcxNb9tzElj03sWWvrQ92knYCdgBujYif1FOSWXtSy1hdX3n9boplrCYBn5R0RJPrVi5j9fg872Nn9UoNJ9asvJ4D7BERRwN7Av/e6KJqAGidl3ofO6tXajixmqR1KZpdEfEQQET8RdLTtVdn1oJUE0+miGIKCEkbRsSD5WblA72InfWPVBRz8wanVgBv7Ho1ZqMwqsfO5SqZ93a5FrNR8TyxZa/2ANAbX3ld3b/CBpzvxJY9N7Flz01s2XMTW/bcxJa9VABoR0nrlK/XknS0pB9KOq7cfMas51J34q8CT5SvT6J4DH1ceezsRhdVU2w3n/fbrhRq1kgyABQRQ0GfWRExtCbVNZJubHRRRJwBnAHw0Zv282aMVqvUnfhWSQeXr2+SNAtA0kzgqVorM2tRqonfBews6bfA1sC1ku4BzizPmfVcKsX2GHBQ+eFuRvn+xRHxh7EozqwVrS4o+DhwU821mI2K54kte7Wn2G5atlHdv8IGnO/Elj03sWXPTWzZcxNb9lIBoA9I2nSsijEbjdSd+L+B6yRdLel9kp4zFkWZtSPVxPdQbMj438B2wO2SLpV0oKRJjS6qptgW//CWLpZr9kypJo6IWBERP4mIdwIbAacBe1M0eKOLVq7FtsnrXtTFcs2eKfWwY5WlqiLiKeBC4EJJa9dWlVkbUnfi/RqdKFcBMuu5pk0cEQvHqhCz0fI8sWWv9gDQ7659bt2/wnbpdQG95TuxZc9NbNlzE1v23MSWPTexZa/p7ISkZwH7A7+PiJ9KOgD4V2ABcEb5BM+sp1J34rOB1wAflPR1YF/gOmB74CuNLqoGgB673psxWr1S88QviogXS1oDeADYKCKWS/oGTb7CX13GaqvPnuhlrKxWqTvxauWQYhKwNsWCggATWHW3UbOeSd2JzwLuAFYHjgS+Wy5j9VLgOzXXZtaS1DJWJ0r63/L17yWdA7wSODMirm92rdlYSWYnIuL3ldePAufVWZBZuzxPbNmrPcW2+cvur/tX2IDzndiy5ya27LmJLXtuYste8oOdpOcB+wCbAsuBhcC3ytXjzXouuRYb8GXg2RShnwkUzTxP0i51F2fWitRw4t3AqyLifyie1L0wIo6kWAHoxEYXeRkrG0utjImHhhwTgIkAEXE/TQJAXsbKxlJqTPwVYL6k64CXU2yJS7k65tKaazNrSSoAdJKknwL/DBwfEXeUxx8CXjEG9ZkltRIAug24bQxqMRsVzxNb9moPAN11/wZ1/wobcL4TW/bcxJY9N7Flz01s2UtlJyZLOlbSHZKWSnpE0oLy2JQxqtGsqdSd+FxgGbBLREyNiGnAruWxc+suzqwVqSbePCKOi4glQwciYklEHAds1uiiagDoT5df161azUaUauL7JB0mafrQAUnTJR0OLGp0UTUANGnXHbtVq9mIWtkCbBpwZTkmXgpcAUylWFzQrOdSAaBlwOHlzyokHUyxaqZZT3UyxXZ016ow60Bqke2bG50Cpjc4ZzamUgGg6cBeFFNqVQJ+WUtFZm1KNfGPgIkRcePwE5KuaOUXnPnyuW0XZe16xkeWgZL6YPfOJucO6H45Zu1zdsKy5ya27LmJLXujbmJJl3SzELPRSs0Tv6TRKWCbrldjNgqpKbb5wJUUTTvclEYXSZoDzAH44Gc24DVvbfhWs44povFeiZJuBd4YEXeNcG5RRGya+gWX3fvP3oyxZnvMWDDSTWZgpMbEn2rynvd3txSz0Uk97Gi23de6Xa7FbFScYrPsOcVm2XOKzbJXe4rt+Nn7tF+VtWWPAV+M3yk2y56zE5Y9N7FlL7WM1TqSPivp65IOGHbutHpLM2tN6k58NsVMxPeA/SV9T9KE8txLa63MrEWpJt4iIo6IiPMjYjZwA/BzSdOaXVRdxmrR0t90rVizkaSaeIKkle+JiM8AZwJXUawMNKLqMlabTt22O5WaNZBq4h8Cu1UPRMRc4FDgyZpqMmtLap74sAbHL5V0TD0lmbXHASDLngNAlj0HgCx7tQeA7tlvvfarMmuDA0CWPWcnLHtuYsuem9iyl0qxbSDpS5JOlTRN0qck3SLpXEkbjlWRZs2k7sRzgdsptvu6HPgr8GrgauDLtVZm1qJUE0+PiFMi4lhgSrkx46KIOIUWN2N8bP61XS3YbLhUE1fPnzPs3OqNLqqm2CZv/7JRF2fWilQTXyBpIkBEHDV0UNKWwJ11FmbWqtTDjk80OH63pIvqKcmsPU6xWfacYrPsOcVm2as9xbbmix5rvyqzNjjFZtlzdsKy5ya27LXdxJLWr6MQs9FKTbFNHX4IuF7SthQ7Ly2trTKzFqVmJx4G7ht2bGOK5awCeF4dRZm1IzWc+BhFRmJ2RMyIiBnA4vJ1wwauptiW/fjX3azX7BmaNnFEHA+8C/iEpBMkTaK4AzdVTbGtu9d2XSrVbGTJD3YRsTgi9gWuAC4D1q67KLN2tDw7EREXArsCrwSQdHBdRZm1o60ptoj4a0TcWv7RKTbrC06xWfZqT7H97W9rjqIss9bVnmIzq5tTbJY9B4Ase25iy15qGau9K68nSzpL0s2SviXJsxPWF1J34urmMscDDwKvA+YDp9dVlFk72hlOzIqIoyLivog4Edi80RurAaDHfzq/4yLNmklNsa0v6SMU88LrSFJEDAWAGv4HEBFnAGcAbPG/n0kGhsw6kboTnwlMAiYCXwPWg2LJV+DGWisza1FqnnjEfERELJF0eT0lmbXHy1hZ9hwAsux5GSvLXu0BoEO3+Wn7VVmbjux1AT3lAJBlz9kJy56b2LI3mmWsptVRiNlopVJsx0oaeko3S9I9wHWS7pO085hUaJaQuhO/JiIeLl9/HtgvIrYE9qBItZn1XKqJ15A0NIOxVkTMB4iIhcCERhdVU2zX/O/vu1Sq2chSTXwacLGk3YBLJZ0kaWdJR9MkAFRdxmqn/TbqYrlmz5SaJz5F0i3Ae4GZ5fu3As4H/rv26sxakHpiR0RcQbEO2yrKZazO7n5JZu1xis2y5xSbZc8pNste7Sm2465+dftVWVve9/xeV9BbTrFZ9hwAsuy5iS17qQDQDZKOkrTFWBVk1q7UnXhdYApwuaTrJX1Ykp8jW19JNfGyiPhoRDwXOJTikfMNki6XNKfRRdUA0J+vmtfNes2eoZ3dk66OiPdR7Ch6HPCyJu9dGQCa+IqXdqFMs8ZS88QLhx+IiOXApeWPWc+ldhTdv9E572Nn/cIBIMueA0CWPQeALHu1B4D2mfXr9qsya4MDQJY9Zycse25iy56b2LKXSrHNKnMS35C0qaTLJD0mab6kbceqSLNmWlk85XPARRRTaqdHxGTgiPKcWc+lmnjNiLgkIr4NREScR/HiZ8CzG11UTbHd8r3fdrFcs2dKNfHfJO0paV8gJL0BoFwRc3mji6opthe9yXl6q1fqYcd/UgwnVlA8uXuvpLnAA8C76y3NrDWpFNtNEbFXRLwqIu6IiA9GxJSIeCEw4F8Ut37hFJtlzyk2y55TbJa92lNsP/jF9u1XZW05cZteV9BbTrFZ9pydsOy5iS17bmLLXirFNlHSpyXdVqbXHpI0T9JBY1SfWVLqTvxN4B6KabajgZOBtwG7Sjqm5trMWpJq4s0jYm5ELI6IE4DZEXEXcDCwT6OLqim2P13jtdisXqkm/ouknQAkzQaWAkTECooHHiOqptgm7eS12KxeraTYviJpK+A24B0Akp4DnFpzbWYtST3suBnYYYTjD0n6U21VmbXBKTbLnlNslr3aU2xr/97PU6xetafYzOrmFJtlz3/XW/ZS2YnJko6VdIekpZIekbSgPDZljGo0ayp1Jz6X4kPdLhExNSKmAbuWx86tuzizVrSSnTguIpYMHYiIJRFxHLBZvaWZtSbVxPdJOkzSyjlhSdMlHQ4sanRRNQC07DfXdqtWsxGlmng/YBpwpaRlkpYCVwBTgbc0uqgaAFp324Z7Npp1RWqKbZmks4HLgHkR8eehc5L2xhsyWh9IzU58ALgAOAS4VdLrK6cdire+kHpi925gu4j4s6TNgfMkbR4RJ9EkT2w2llJNvNrQECIifidpF4pG3gw3sfWJ1Ae7P0jaZugPZUO/FlgPeFGNdZm1LHUnfjvwdPVARDwNvF3S6a38guf85qlRlmbWmtTsxOIm537R/XLM2ucAkGXPTWzZG3UTS7qkm4WYjVbqO3YvaXQK2Kbr1ZiNQmp2Yj5wJSPPCU/pejVmo5Bq4gXAe8qlq1YhqWmKDZgDsNUL92HD5+7YUZFmzaTGxJ9q8p73N7qommJzA1vdUvvYnQdI0u6SJg47/bf6yjJrXasptvfjFJv1KafYLHtOsVn2nGKz7NWeYrv/gOWjLM2sNU6xWfYcALLspabY1pH0WUlfl3TAsHOn1VuaWWtSd+KzKWYhvgfsL+l7kiaU57yjjPWFVBNvERFHRMT5ETEbuAH4uaRpY1CbWUtSTTxB0sr3RMRngDOBqyhWBhrRKvvY/fz67lRq1kCqiX8I7FY9EBFzgUOBJxtdtMo+drs9Y/Mls65KBYAOAxYPDwBFxKXAB+ouzqwVqdmJ99M4APSZOgsza1Xqid0cHACyPucAkGXPASDLXu0BID08If0msw44AGTZcwDIsucmtuyl5ok3kPQlSadKmibpU5JukXSupA3HqkizZlJ34rnA7RTbfV0O/BV4NXA18OVaKzNrUaqJp0fEKRFxLDCl3JhxUUScgjdjtD6RauLq+XOGnVu90UXVFNvjv/RmjFavVBNfMBT8iYijhg5K2hK4s9FF1RTbOv/qzRitXqkU2yeATUZIsd0NfKXu4sxa0UmKzctYWV9wis2y5xSbZc8pNste7Sm2ja5aMcrSrGUf6nUBveUUm2Wv7QCQpPXrKMRstFJbgE0dfgi4XtK2gCJiaW2VmbUoNSZ+GLhv2LGNKVYCCuB5dRRl1o7UcOJjFI+XZ0fEjIiYASwuX7uBrS+kHjsfD7wL+ISkEyRNorgDm/WN5Ae7iFgcEfsCVwCXAWunrqmm2JbcO6/zKs2aSDaxpBdI2h34ObAr8Mry+N6Nrqmm2DaY4RVgrV5t7WMH7BkRt5anHQCyvuB97Cx7DgBZ9hwAsuzVHgB65F8afhXPrCscALLseQUgy56b2LKXmifeu/J6sqSzJN0s6VuSptdfnlla6k5cfaBxPPAg8DpgPtDSBzuzuqVmJ6pmRcQ25esTJR1YQz1mbUvdideX9BFJhwLrSKo+4Gh4bTUA9OgNXsbK6pVq4jOBScBE4GsUDzmQtAFwY6OLqgGgKS/xMlZWr9Q88dGSXkDxbY7rKo+gl0j61lgUaJbiZawse17GyrLnFJtlzyk2y17tKba/r+dlrKxeTrFZ9hwAsuyNZi22aXUUYjZaqXniYyUNPaWbJeke4DpJ90naeUwqNEtI3YlfExEPl68/D+wXEVsCe1Ck2sx6LtXEa0ga+vC3VkTMB4iIhcCEWisza1GqiU8DLpa0G3CppJMk7SzpaJoEgFbdjNHLWFm9FNF8fcDyKd17gZkUU3KLgPOBsyPiqdQveN7Jx3sBwprd84FDB/rpaSuh+CXAGVRSbLDyq0uX1lWYWavaWovNKTbrR16LzbLnFJtlzyk2y17tKbYVEzw5YfVyis2y5xSbZS81xXaDpKMkbTFWBZm1K3UnXheYAlwu6XpJH5a0Uf1lmbUu1cTLIuKjEfFc4FBgK+AGSZdLmlN/eWZpLY+JI+LqiHgfxUIqxwENl/apBoD+dLUDQFavVBMvHH4gIpZHxKURcXCji6rLWE16ufexs3qltsXdf2gzRkkTq+eabcZoNpaazhOXy1gdAiwAzpL0wYi4oDx9DE6x9bUVS2Z2/KRptQ0W9n28wMtYjWMr6HzNjxweJDgANI4tj86buJ1V2HvFASDLXu0BoOe/oGH8wmq2gsEIXzkANI51Y0ycgxyGPDZKyxNfAh4vcvjwadZUKsU2q8xJfEPSppIuk/SYpPmSth2rIm10VhAd/+QgNZw4DfgkRZLtl8CHI2IPSbuX57w1Uh9bnkkTdio1nFgzIi6JiG8DERHnUbz4GfDs2quzjgzKnTjVxH+TtKekfYGQ9AaAckXM5Y0uqqbYFv/wlu5VazaC1HDiP4HPASuAvYD3SpoLPECxJsWIIuIMilWD2OvKD+Xxn/M4NCizE6l54pskfQjYCFgcER8EPghOseVgMGaJW1vG6gd4GassLSc6/slBK8tYzXKKLU/L8+jBjjnFZtlzim0cW9GFnxzUnmK7+9fPHWVp1rIGWwAtH4O/LCVtCpwDTAcCOCMiTpI0FfhfYHPgd8BbImKZJAEnAa8GngAOiogbOqkh9R27xRGxpME5p9j63Iro/KcFTwOHRsTWwEuB/5K0NXAE8LOI2Ar4WflngFdRLP2wFcU3h77U6T+nA0DWkYh4cOhOGhF/ovg+5sbA64GvlW/7GvCG8vXrgXOiMA+YImnDTmpITbFNlPRpSbeVwZ+HJM2TdFAnv9TGxnLU8U/16Wv503DRnHIGa1vgOmB6RDxYnlpCMdyAosEXVS5bXB4btdSY+JsU88R7AW8B/gn4DnCUpJkR8X86+eVWr26MiatPX5spl3T4HvChiHi8GPqu/P8ISbVN+KWGE5tHxNxybHwCMDsi7gIOBvapqyjrjhWhjn9aIWlNigb+ZkR8vzz8h6FhQvm/fyyPPwBsWrl8k/LYqKWa+C+SdioLmQ0sBYiIFXie2IBytuEsYEF5oxtyIXBg+fpAig2Mho6/XYWXAo9Vhh2jkhpOvBc4U9JWwG3AO8vCnwOc2uiictw0B2C9N7+ZdV7m2HEvjMUUG/BvwNuAWyTdWB77P8CxwLmS3gncRzEcBbiYYnrtbooptobLobWqlQDQgRQD73mVp3cPSXrGOm2V61aOo7Y44YQBefjZf5aPweRTRFxD47+Vdx/h/QH8VzdraDUAdAgOAGVnrMbEveYAkGXPAaBxbIzGxD3nANA4tjxW6/gnB7UHgP5lh3tGWZp1asWApAq8jNU45uGEWSa8Fts4lsuYtlOp7Q7WoHhK90aKbzxD8Zz7AuCsiHiq3vKsEysGZDiRuhN/HXgU+BRFZA6KwMaBwDeA/eoqzDo3Fk/s+kGqibeLiJnDji0G5jV77Gw2llL/qS6VtK+kle+TtJqk/YBljS6qBql/d+Ft3arV2jQo88SpKvcH3gwskbSwvPsuocgS79/ooupmjJvPfmH3qrW2rGC1jn9ykJon/p2kE4Djgd8CL6BYzvX2iLh3DOqzDizPJMDTqdTsxCcpvp26BnAZsANwBXCEpG0j4jO1V2iWkPpg92ZgG2ACxTBik/L7U/+X4suAbuI+5tmJwtMRsRx4QtJvI+JxgIj4q6RcFogZWCsy+WDWqVQTPylp7Yh4Athu6KCkyeSzytHA8p248IqI+Dus/HLokDX5x5cAm7rxTi9jVbudel1Ab6VmJ/7e4PjDwMO1VGRd49kJy14u87ydchOPY7k8cevUqP8pJSWXNrLeWoE6/slB6mHH1EanKBbAMOu51HDiIYrVW6r/SUb55/XrKsq6Y1CGE6kmvgfYPSLuH35C0qIR3j90buUyVlPftg8Td96xoyJtdAZlnjj1T/kFYN0G5z7X6KJqis0N3DuDsgJQaruDU4EJkrYHkLS1pI9IenVEnDImFZoltJxik3QZsCNwOU6xZWFQhhNOsY1jDgAVnGLL2KAsnlJ7iu2fpj3RQXlmabWn2Kx3PJzAKbbceThh2RuUO3Fqu4PVJb1H0n9L+rdh546qtzSz1qT+Uz2dYvvrR4CTy6/vD/E+dn3Oi6cUdoiIAyLiCxQPOiZK+r6kCXi7g743KFHMVBM/a+hFRDwdEXOAm4CfAxMbXVRdxmrZT37dnUqtbb4TF34lae/qgYg4Gjgb2LzRRdUA0Lp7btfobVYzB4CAiPgPikUFVwkAAb+PiDXHokCzFAeAxjEHgAoOAGUsl+FApxwAGscG5Sv7qX/KJyWtXb72MlbWl2oPAD3xwKRRlmad8gpAOACUO4+JLXsOAJllIjVPvDZwCMWCKadQbDazD3AH8OmI+HPtFdqoDUqeOHUnngtMB2YAFwGzgM9ThH++VGtl1rFBeeycGhPPjIi3SBLwIPDKiAhJ11AEgayPeUxcEREBXFz+79Cfo9H7qym2P10zrzuVmjXQSoptIkBEvGPooKQtgD81uqiaYpu000u7U6m1bVDyxKl54ndJ2kFSRMR8SVsDewN3Ai8fkwpt1Pywg6YptsMpgkEOAPWxQRkTO8U2juUyu9Cp1H+qT0fE8nIFoFVSbDgAZH3CmzGOY7l8MOtU7Sm2Zy0bjHFZPxqL4YSkrwKvBf4YEf9SHpsK/C/F9zB/B7wlIpaVzxtOotjv5QngoIi4odMaUt+xa5hii4hbOv3lVq8VsVrHPy2YSzFjVXUE8LOI2Ar4WflnKCYJtip/5tClp76+TVpHIuIqYOmww68Hvla+/hrwhsrxc6IwD5giacNOa2i7iSUt7PSX2tjoRnai+vS1/JnTwq+eHhEPlq+XUORvADYGqhsWLS6PdSQ1T/wn/vF4eWiAtfbQ8YhYp9MCrD7d+GAXEWcAo954s8zaNIwodEPqg93ZwBTgYxHxBwBJ90bEjDqLsu7o4TzxHyRtGBEPlsOFP5bHHwA2rbxvk/JYR1If7D5A8Wny25I+IGk1mgR/hlT/Cnps/rWd1mj5uZB/zF4dCFxQOf52FV4KPFYZdoxackwcEb8GXln+8Urg2S1cszIANHn7l3VYoo3WWOSJJX0buBZ4vqTFkt4JHAvsIekuit45tnz7xRQbfN4NnAm8rxv/nMnv2EnagWJoc7Kk3wC7lvvYXdyNAqw+YzGciIi3Nji1+wjvDeC/ul1DuwGgHYAr8DJWWRiU7IQDQJY9L2M1jjk7UXAAKGMeThQ6DgCtPmL6wsaCmxgvY2V58DJW45jvxJa9QWni1GaML668XlPSUZIulHRMZd1i61MR6vgnB60sYzXkWGBL4HhgLeDLNdVkXeJ1JwrVf4rdge0j4ilJV+FlrKxPpO7EkyXtI+lNwISIeAraW8bq0RucYuuVQVlQMNXEVwKvo/gi4DxJ0wEkbUCTKbZqim3KS5xi65VBGROn5okPlrQjsGJoGStJ/w7cERHPSClZf8nlTtopp9gse06xjWO5DAc65RTbOObhRMEptoxFrd8x7h/1L2PVcClus+5wim0cy+WJW6ccABrH/MHOsjcoH+xSKbZDJK1Xvt5S0lWSHpV0naQXjU2JZs2lHju/txz/QrES0IkRMYVizw6n2PpcROc/OUgNJ6rn14+IHwBExBWSJtVXlnXDoIyJU3fi8yTNlfQ84AeSPiRpM0kHA/c3uqiaYnvkFqfYesUBICAijpR0EPBtYAuKx89zgPOBf29y3crlQP+/D52YyV9K48+gfLBrZXbiduCQMsX2Qoql7RdExGP1lmbWGqfYxrFcPph1yim2cSyXMW2nnGIbx9zEhY5TbOvd/LcOyjNLqz3FZr0zIENip9jGMw8nLH8DcitOBYC+L+k/JE0cq4LM2pV67LwjxZam90s6V9IbJT2r/rKsGwblsXOqif8YEW+m2C39h8C7gQcknS1pz7qLs84MSoot1cQBEBGPR8TXI+LVwAsoHnQc0eiiagDogd9f371qrS2+Exf+PPxARDwSEV+OiN0aXVRdxmrjjXbouEizZlJTbK+obMY4X9LWFAGgO7wZYwYyuZN2qt0A0I7A5TgAlIVcxrSdcgBoPHMTAw4AZS2XD2adSn2we7KyN4eXsbK+VHsAaK8vXjXK0qx1Hx/5sIcTDgDlblCGEw4AjWcDcidOjYnN+l4qxfY8SV+V9D+SJko6U9Ktkr4rafMxqtFGTV346X+tbMY4n+Lx8zzgDoqHH5cCX621MutcdOEnA6kmnhQRX4qIY4F1IuL4iFgUEWcB645BfdYJNzEAKyTNLPMTa0uaBcUKmcDqjS6qptiuO3dRF8s1e6bU7MRhFDniFRTh+I+Xm5ZPpsgWj6i6jNXnbn9VJv89j0OeYoOI+Jmkt/OPzRiXUYyJb3eKrf85AISXscqemxhwis0y4BTbeOYxMeDNGLMmDyeALqTYPjr1t6MszTo2Bk0saW+K/VxWB75SPlMYU06xjWc1DyckrQ6cCuwBLAbmS7owIm6v9RcP4wCQdWIH4O6IuCcingS+A7x+rItIBYBWk/QOSRdJuknSDZK+I2mXsSnPOtKFx87Vp6/lz5zKb9gYqD6SXVweG1OpMfFZwH3AZymm2x4HrgaOkvSiiDil5vqsE10YE1efvvarVBNvFxEHl6+vkTQvIj4h6SrgRsBN3M/q/2D3ALBp5c+blMfGVGpM/JSkLQAkvQR4ElZ+4Gv4r6j6V9AZX/cmS+PYfGArSTPKhSb3By4c6yJSd+KPAZdL+nv53v0BJD0H+FGji6p/Ba1YMnNAZiv7UM2zExHxtKRDgB9TTLF9NSJuq/WXjiA1xfZzSftRPLmbL2lrSR+hWMbqsLEp0UZrLB52lEGwnobBHAAazwbk70AHgCx7qQ92T0fE8jI7sUoACGcnrE84ADSOOQBU6DgAtNtts0dZmrXqig0anHAU0wEgy4OXsRrPPJyw7LmJQdIawDuBNwIblYcfAC4AzoqIp+otzzrhD3aFrwOPAp+iiNlBEfI4EPgGsF9dhVkXuImBIsU2c9ixxcA8SQtrqsmsLamHHUsl7Stp5fvKoPx+wLJGF1VTbL//0c3dqtXa5bXYgCK19mbgD5IWSrqL4vHzPuW5EVU3Y9zotS/uXrXWFkXnPzlIzRP/jnLcK2laefikiPiPmuuybvDDDpA0UsB5t6HjEeHHcdZzqQ92mwC3A1+hGCEJ2B44vua6rBsyGQ50KjUmngX8GjgSeCwirgD+GhFXRsSVdRdnnfGYmJWhnxMlfbf83z+krrE+kkkTdqqlhoyIxcC+kl5D8bX9lsUJ64+mLmvH7r0uoLfauqtGxEXARTXVYl2Wy3CgUx4ajGcD0sSjXotNUl+vCmMMzBO71Dzx1EangFd3vxyz9qWGEw9RrMVWffQzNF/sT2x9zmPiwj3A7hFx//ATkrxBnfWF1Jj4CzTeOfRzjS6qptgevP+60dZmnRqQMXHTJo6IUyPipuoxSeeU5xquiFlNsW343B27U6m1zU/sGDEAJGBXSVPAASDrD6kx8abAbawaAJqFA0B5yORO2qnUmHg7HADK14CMiR0AGsdyGdN2qvYA0LMP+/1o6jJrmQNA45nvxJY7DycsfwPSxKnNGFeX9B5J/y3p34adO6re0sxak5piOx3YGXgEOFnSCZVz+9RWlXXHgEyxpZp4h4g4ICK+AOwITJT0fUkTWDXZZn1oUB47p5r4WUMvIuLpiJgD3AT8HJjY6KJqAGjxD2/pTqXWPt+JAfiVpL2rByLiaOBsYPNGF1UDQJu87kWdV2nWROqJ3TOWq5J0TkS8nSJPYf0skztpp5xiG8dyGdN2yim28WxAmtgptnFsUGYnnGKz7NWeYrvvkUbf+rfaZXIn7ZRTbOOZm9hyNyiPVEe9jJVZv0jNE68NHELxF9MpFJvN7APcAXw6Iv5ce4U2egMynEjdiecC04EZFGPhWcDnKf6m+lKtlVnHPMVWmBkRb5Ek4EHglRERkq6hCAJZP8ukCTvV0pg4IgK4uPzfoT83/FdUTbE9+pNfdadSswZaSbFNBIiIdwwdlLQF8KdGF1VTbFP2nNWdSq19jmJCRLxr+Ie3MsX2W+DltVZmHfOYmHSKDXCKrZ9l0oSdcorNsucU2zg2KMOJ1Jh4RUScCBwMHCnpi/hRdT56/MFO0r6SbpO0QtKsYec+LuluSXdK2qtyfO/y2N2Sjmjl99SeYtv0zf6iaO1WjHy4D+6kt1I84T29elDS1hRPf18IbAT8VNLM8vSpwB7AYmC+pAsj4vZmv8QptvGsx00cEQsAimdlq3g98J2I+Dtwr6S7gR3Kc3dHxD3ldd8p39u0iR0Asl7YGKhuXLS4PNboeFNtj28lLYyImel3Ws914U4saQ4wp3LojIg4o3L+p8AGI1x6ZERc0HkFaal54j/xj38VQ38nrD10PCLWqbM460w3xsRlwzbcPTYiXjmK/9sHKKZvh2xSHqPJ8YZSw4mzgfOBrSJiUkRMAu4vX7uB+13/Pna+ENhf0gRJM4CtgOuB+cBWkmZIehbFh7/hD9yeITXF9gHgJODbkj4gaTVa+EdbZRmrYoxuA0jSGyUtBl4GXCTpxwARcRtwLsUHtkuB/4qI5RHxNEV+/cfAAuDc8r3Nf08ZTEsVs1r5f74vsEVEbNTqP8geq+3b+4mece6yFd8d8ZtIs951Qsf/7n/1lY/0/becWo1iroiIk4G3ABPqLcm6pn+HE13VbgAIYMLQcS9j1d/64GHHmEhNsW1CMW6pBoC2xwEg6yOp4cQsHADKl4cTXsYqdx5OVHQSAPrb63ccTV3WDW7iZ3IAyPqRhwbjmIcTlr8BaeLUZowvrrxeU9JRki6UdEy5xJX1MX89qTC38vpYYEuKOeK1gC/XVJN1S0TnPxlIDSeqz813B7aPiKckXYWXsbI+kboTTy6TSG8CJkTEU0Bby1gt+d28LpZr7fBwonAVxQIprwXmSZoOIGkD4OFGF1WXsdpg85d2rVhrk5/YQUQcNPxYZTPG3esqyrpDDb4FPd6MJsW2mzdjtH4ymmWsnGLLRSbDgU55GatxbFA+2DnFNp5lMs/bqdpTbGtf6ulkq5dTbONYLsOBTnloMJ4NSBOnAkCHSFqvfL2lpKskPSrpOkkvGpsSbbQG5YNdanbivREx9GTuJODEiJgCHI4DQNYnUsOJ6vn1I+IHABFxhaRJ9ZVlXTEgsxOpO/F5kuZKeh7wA0kfkrSZpIOB+8egPuvAoAwnUvPER5YN+21gC4rVf+ZQLDL4742uqy4HuvUaO7LJGlt1q15rRyZN2KnkMlYRcXZE7BgR65WrYv46Iv5PRDzW5JqVKTY3cO/4TkzTAJCXsbK+4WWsxrMVmdxKO+RlrMYzh+IdAMpdLmPaTtUeALrjVD/Ys3o5ADSeDcjDDg8NxjEPJyx/A9LEqRTb9yX9h6SJY1WQWbtSU2w7Am8A7pd0brmQyrPqL8u6QREd/+Qg1cR/jIg3A5sDPwTeDTwg6WxJe9ZdnHVoRRd+MpBq4gCIiMcj4usR8WrgBcB1wBGNLqouY/XnK6/rXrXWFt+JC38efiAiHomIL0fEbo0uqgaAJu7s7Q6sXqltcV8x/Jikc+orx7rKj51HTLEJ2NXLWGUik+FAp0azjNUsnGLLwqA87PAyVuOZV4p3is3yUHuKbdKCNUdTl3WB1ycegVNsmclkONApDw3Gs8Ho4fS3nc36XSrF9jxJX5X0P5ImSjpT0q2Svitp8zGq0UbJj50Lc4H5FI+f5wF3AK8CLgW+Wmtl1jlPsQEwKSK+BCDpfREx9JDjLEmH1FuadWxAZidSd+IVkmZK2h5YW9IsKJZ5BVZvdFE1xbb0pmu7WK7ZM6XuxIdR5IhXUITjP15uWj6Zcq21kUTEGcAZAP/ysRPz+DtpHMplTNup1BO7nwHPrxy6RtKPgNnl0zzrZ27ihmux7QKcL8kptn7nJga8GaNlwCm28czfsStSbBFxInAwcKSkL+JH1dno9cMOSZ+XdIekmyX9YOjLFOW5j0u6W9KdkvaqHN+7PHa3pIbf46yqPcX2zndc0s7bbVQ+PPLh3o+JLwM+HhFPSzoO+DhwuKStgf2BFwIbAT+VNLO85lRgD2AxMF/ShRFxe7Nf4hTbeNbjJo6In1T+OA94c/n69cB3IuLvwL2S7gZ2KM/dHRH3AEj6Tvnepk3sAJCNlXcAQ38tbwwsqpxbXB5rdLyp1BTbasBBwJsoVo1fDiwEvlx+yLN+1oU7cXUTodIZ5cOsofM/BTYY4dIjI+KC8j1HAk8D3+y4oBGkhhNnAfcBn6X4q+Bx4GrgKEkviohT6ijKuqQLswvVp68Nzr+y2fWSDgJeC+wesfK/qgcopm+HbFIeo8nxhlJNvF1EHFy+vkbSvIj4hKSrgBsBN3Ef6/VjZ0l7U0QXdo6IJyqnLgS+JekEig92WwHXUzyH2ErSDIrm3R84IPV7UmPipyRtURb0EuBJgHJA3vDfUDUAdO25i1M12Pj1RWAScJmkGyV9GSAibgPOpfjAdinwXxGxPCKeBg4BfgwsAM4t39tU6k78MeBySU9SpNbeCiDpOcCPGl1U/SvoxAV79nyeZ2D1fnZiyybnPgN8ZoTjFwMXt/N7UgGgn0vaDJg2tFG5pHMi4u0Uf01YPxuQLcBaDgBJGnq5m5exykTvH3aMCQeALHsOAI1n/o6dl7HKXiZN2KnaA0Bfmfuq0dRlbfjwcQ1O+IPdMzkAZP3IQ4PxbEC+BukmHs8GZEycWsZqsqRjy3T+UkmPSFpQHpsyRjXaaK2Izn8ykJpiOxdYBuwSEVMjYhqwa3ns3LqLsw4NyBRbqok3j4jjImLJ0IGIWBIRxwGb1VuaWWtSTXyfpMMkTR86IGm6pMNZNYG/imqKbdmNXsaqZ3wnBmA/YBpwpaRlkpYCVwBTgbc0uqi6GeO627ysa8VamwakiVNP7JYBh5c/SHo5xRf6bomIpfWXZx1ZMRhTbKnZiesrr98FnAxMBD7Z6poAZnVLzRNXtz56D7BnRDwk6f9SfAX72Noqs85lMhzoVKqJV5O0LsUdWxHxEEBE/EXS07VXZ51xEwPFOsS/psgRh6QNI+JBSRPLY9bPMnlY0anUB7vNG5xaAbyxlV/wl82Wt1mSWXtGlZ0ov359b5drsS4blHXQHQAazwZkODHqtdgkebnLfueHHSsXTBnxFLBN16sxG4XUcGI+cCUjz0RM6Xo11l0D8sQu1cQLgPdExF3DT0hqGgCiXElx6lvfxKSdXtpRkTZKmQwHOpUaE3+qyXve3+iiagDIDdw7sWJFxz85SM0Tn1f9s6SdKAJAt0bE+TXWZd3gO/EzAkDv5h+rHDoAZH2jnQDQHGAPB4AyMiDzxA4AjWd+Ygc4AJS18J24OwGgXbdPLvRt1hEHgMYzDycsdx5OWP4G5E6cmideR9JnJX1d0gHDzp1Wb2lmrUndic8G7gK+B7xD0puAA8otwPw8uc9dtuK7AzGDlMpObBERR0TE+eUmMzcAP5c0bQxqM2tJqoknlPs7Ayv3HjsTuIpiZaARVZexuvMHd3anUrMGUk38Q2C36oGImAscSrm76EiqKbbnv/H5HRdp1kzqYccqGy4OS7FtVWdhZq1yis2ylxpOjJRiOxrYE/j32qoya4NTbJY9p9gse7Wn2K57wLsi1G77XhfQW06xWfZGvQKQWb9wE1v2UvPEG0j6kqRTJU2T9ClJt0g6V9KGY1WkWTOpO/Fc4HaK7b4uB/4KvBq4GvhyrZWZtSjVxNMj4pSIOBaYUm7MuCgiTsGbMVqfSDVx9fw5rV67ymaMP/n1qIsza0WqiS8oH2wQEUcNHZS0JbCw0UWrbMa453bdqdSsgdTDjk9U/zwsxfbmOgsza5VTbJY9p9gse06xWfZqT7FtNnVZhyWaNVd7is2sbk6xWfbaDgBJWr+OQsxGK7WP3dThh4DrJW1L8UFvaW2VmbUoNZx4GLhv2LGNKVYCCuB5dRRl1o7UcOJjwJ3A7IiYEREzgMXlazew9YWmTRwRxwPvAj4h6QRJkyjuwE1VA0CLLry1S6WajSz5wS4iFkfEvsAVwGXA2i1cszIAtOnsf+m8SrMmWp5ii4gLJS0Ddpa0Z0T8pMa6zFrWbgDoZGB1HACyPtJuAGhPB4Cs3zgAZNnzMlaWvdoDQHf/stH/hXXNK3pdQG85AGTZ8wpAlj03sWUvNU+8d+X1ZElnSbpZ0rckTa+/PLO01J34mMrr44EHgdcB84HT6yrKrB3tfLCbFRHblK9PlHRgDfWYtS11J15f0kckHQqsI6k6N9zSMlaPXX9tVwo1ayTVxGdSLJYyEfgasB4US74CNza6qJpim7zDy7pUqtnIUg87jq7+WdJOkt5GsYzV22utzKxF7aTY3oWXsbI+1E6K7T14GSvrQ06xWfacYrPsKSL5vc9nXiStTbEVQjIEtGLJzPZ/gbVltQ0WDvQNxSk2y95olrGaVkchZqOVmmI7VtLQA45Zku4BrpN0n6Sdx6RCs4TUnfg1EfFw+frzwH4RsSWwB0UgyKznUk28hqShcfNaETEfICIWAhNqrcysRakmPg24WNJuwKWSTpK0s6SjaZKdqAaAzvj6Y10s1+yZklNsknYB3gvMpJjNWAScD5wdEU+lfoGn2OrnKbaEiLiCYh02JL2cYh+737XSwGZjod0A0MkUsUwHgKxvtBsA8jJW1nccALLsOQBk2at9Gav5f/fnv7rt2OsCeswBIMueVwCy7LmJLXupeeIbJB0laYuxKsisXak78brAFOBySddL+rCkjeovy6x1qSZeFhEfjYjnAocCWwE3SLpc0pz6yzNLa3lMHBFXR8T7KLbFPQ5ouLRPNcV2/rf+1IUyzRprmmKT9J2I2L+TX3DdfTOcYqvZjpvdO9APnlIPO1ZpYEk7UaTYbvVmjNYv2t2M0ctYWd9pdzNGL2NlfccpNsueU2yWvdpTbKf9Ybc2S7J27bhZryvoLafYLHsOAFn23MSWvdQ88awyJ/ENSZtKukzSY5LmS9p2rIo0a6aVFYA+B1wE/BI4PSImA0eU58x6LvmwIyIuiYhvAxER51G8+Bnw7NqrM2tBqon/JmlPSftSzBO/AaBc1nV5o4uqKbaFP7ije9WajSDVxO+lyBG/A9gL2FXSMoqhxAcbXVTdjHHmG1/QtWLNRpJ62HEjRfMCIOk84H7gloj4Rb2lmbWm3RSb12KzvtNuis1rsVnfcYrNsld7iu2ae5/XYYmWtEOvC+it2lNsZnVzis2y5wCQZS81xTZR0qcl3VYGfx6SNE/SQWNUn1lS6k78TeAeigceR1PME7+N4sndMTXXZtaSVBNvHhFzI2JxRJwAzI6Iu4CDgX3qL88sLdXEfykXTEHSbGApQESsoMkUWzUA9PhP53etWLORtBIAOqEM/RwGvB9A0nOAUxtdVA0ArfPK7btWrNlIUvPEN1GZSpe0k6TXUixjdXLdxZm1ot3NGL2MlfWddjdj9DJW1nccALLseRkry17tAaBNvvGsNkuytu3X6wJ6ywEgy54DQJY9N7FlLzVPPFnSsZLukLRU0iOSFpTHpoxRjWZNpe7E5wLLgF0iYmpETAN2LY+dW3dxZq1oJcV2XEQsGToQEUsi4jhgwJd2tn6RauL7JB0mafrQAUnTJR0OLGp0UTXF9uB987pVq9mIUk28HzANuFLSMklLgSuAqcBbGl1UTbFtuNlLu1as2UhSTTwTOCYiXkCxHe4Xgd+W5xouKGg2llJN/FXgL+XrL1Ak2I4FngDOrq8ss9YlA0ARMRT0mRURLylfXyPpxvrKMmtd6k58q6SDy9c3SZoFIGkm8FStlZm1KNXE7wJ2lvRbYGvgWkn3AGeW58x6LpVieww4SNI6wIzy/Ysj4g+t/oLfv/3vnVVoltBSii0iHgduqrkWs1FxAMiyN+omlnRJNwsxG62mwwlJL2l0Ctim69WYjUJqTDwfuJKRv083pevVmI1CqokXAO8p119bhaSmASCKPT54zpzZTPYqQFaj1Jj4U03e8/5GF1UDQG5gq1vqTrwIeBBA0lrAx4FtgdsBL+1qfaGVANAT5euTgHWA43AAyPqIA0CWPQeALHsOAFn2ag8APfm4l7GyejkAZNlzAMiy5ya27KWWsVpH0mclfV3SAcPOnVZvaWatSd2Jz6YI/3wP2F/S9yRNKM95QQnrC6km3iIijoiI8yNiNnAD8HNJ08agNrOWpJp4gqSV74mIz1DMEV9FsTLQiKrLWP35yuu6U6lZA6km/iGwW/VARMwFDgWebHRRNcU2cecdOy7SrJnUPPH3gDtgxBTbrHpLM2tNO8tYOcVmfckpNsueU2yWPafYLHuKiPSbOkixfXXhTulfYB15x8xrBnp3V6fYLHsOAFn2UgGgDSR9SdKpkqZJ+pSkWySdK2nDsSrSrJnUnXguxYONRcDlwF+BVwNXA1+utTKzFqWaeHpEnBIRxwJTyj3tFkXEKXgfO+sTqSaunj+nzWvNxkSqES+QNBEgIo4aOihpS2Bho4uqKbYr/3dJo7eZdUVqiu0iykYvA0BHAC+hGCe/s9FFEXEGcAZ4ntjq1+4yVpNxAMj6jANAlj0HgCx7DgBZ9mpfxuqbD+zQWYWW9I6Zva6gtxwAsuz5gYVlr+0mlrR+HYWYjVZqH7upww8B10valiJQv7S2ysxalBoTPwzcN+zYxhQrAQXwvDqKMmtHajjxMeBOYHZEzIiIGRSzEzMiwg1sfaFpE0fE8RTzwZ+QdIKkSRR34KaqAaAHfnRzl0o1G1nyg11ELI6IfYErgMuAtVu4ZuUyVhu/9sWdV2nWROrrSTuWDzoAfkqxkOCtko6TNLn26sxa0E6K7QvAmhRb5TrFZn3DKTbLnlNslj2n2Cx7tafY7r53g84qtLRde11AbznFZtlzis2y5ya27KUeduxdeT1Z0lmSbpb0LUnT6y/PLC11Jz6m8vp44EHgdcB84PS6ijJrR0sf7EqzImKb8vWJkg6soR6ztqXuxOtL+oikQ4F1JFVXJG94rTdjtLGUauIzgUnAROBrwHpQrFsM3NjoIm/GaGMpNZy4FLgjIh6TtDZwRPnVpNuB99denVkL2tmM8Qt4M0brQ06xWfacYrPsOcVm2as9xbbaE6t3VqFZglNslr3RLGM1rY5CzEYrFQA6VtLQA45Z5Xj4Okn3Sdp5TCo0S0jdiV8TEQ+Xrz8P7BcRWwJ7UASCzHou1cRrSBoaN68VEfMBImIhMKHWysxalGri04CLJe0GXCrpJEk7SzqaJtmJagDoT7+Y18VyzZ5JEc2XVpO0C/BeYCbFbMYi4Hzg7IhIPvCY8cXjvY9dze495FCl3zV+JZexAm6IiP2AfwN+AKwAtqCFNdnMxkK7y1hNAo7FASDrIw4AWfYcALLsOQBk2as9ALT+9QP9wdnGgANAlj2vAGTZcxNb9lIPO26QdJSkLcaqILN2pe7E6wJTgMslXS/pw5I2qr8ss9almnhZRHw0Ip4LHApsBdwg6XJJc+ovzywt1cQr58ci4uqIeB/FtrjHAS9reFElxfbHhdd2p1KzBlJNfOfwAxGxPCIujYiDR7qgfM/KZazWn9mw1826ItXEJw5txihpLUmflvRDb8Zo/aSdFNtJeBkr60NOsVn2nGKz7DnFZtmrPcX29Fsf6axCswSn2Cx7DgBZ9lIBoFnlI+ZvSNpU0mWSHpM0v9z2wKznWlk85XPARcAvgdMjYjJwRHnOrOdSTbxmRFwSEd8GIiLOo3jxM+DZtVdn1oJUE/9N0p6S9gVC0hsAyhUxl9ddnFkrUk38nxQRzHcAewG7SlpGMZT4YKOLqim2hy/5TdeKNRtJaort2cBbyn3s1gIeA34B3Abc2uiiiDgDOANgu0uO9FpsVqt29rE7CS9jZX3IASDLngNAlj0HgCx7tQeAnvjlep1VaGmv6nUBveUAkGXPASDLnpvYspdKsU0sv+F8W5lee0jSPEkHjVF9ZkmpO/E3gXsoHjkfDZwMvI3i8fMxNddm1pJUE28eEXMjYnFEnADMjoi7gIOBfeovzywt1cR/kbQTgKTZwFKAiFhBZYmr4aoBoEdv8DJWVq9WUmwnlMm1w4D3A0h6DnBqo4uqy1hNeYmXsbJ6peaJ1wL2KFNsawOHS3oJcDvgMbH1hXZSbF8AJuNlrKzPOMVm2XOKzbLnFJtlr/YU2+Sd/thZhWYJTrFZ9hwAsuy5iS17qRTbZEnHSrpD0lJJj0haUB6bMkY1mjWVuhOfCywDdomIqRExDdi1PHZu3cWZtaKVFNtxEbFk6EBELImI44DN6i3NrDWpJr5P0mGSpg8dkDRd0uHAokYXrbIZ48U3dqlUs5Glmng/YBpwpaRlkpYCVwBTgbc0umiVzRhfvU23ajUbUWqe+G3AFyPi8LEoxmw0Unfi/wauk3S1pPdK8iIS1ndSTXwPsAlFM88CFki6VNKBkibVXp1ZC1JNHBGxIiJ+EhHvBDaiWJt4b4oGN+s5RTRePljSbyJixA1mJK0dEU+MdK7qyt/N9PrENdt584UNv+84CFqZnRhRKw1sNhaaNnFELByrQsxGywEgy96om1jSJd0sxGy0mj7sKL+eP+IpYJuuV2M2CqkndvOBKxl5tZ8pXa/GbBRSTbwAeE+5/toqJDUNAAFzAA79zPq87oDJHRVp1kyqiT9F43Hz+xtdVN3HzvPEVrfUB7uNKFb7eYaIOL/r1ZiNQjsBoPeVCwma9ZV2AkDbAbc7AGT9xgEgy17qg90qU2sR8RRwIXBhudSrWc+lmrjjANDJv39lWwVZ+3bevNcV9JYDQJY9B4Ase25iy15qGat1JH1W0tclHTDs3Gn1lmbWmtSd+GyKGYrvAftL+p6kCeW5l9ZamVmLUk28RUQcERHnR8Rs4Abg55KmjUFtZi1JNfEESSvfExGfodjq4CqKlYFGVF3G6t4Lbu9OpWYNpJr4h8Bu1QMRMRc4FHiy0UXVZaxmvH7rjos0ayb1sGMxcOfwgxFxKbBVLRWZtckpNsueU2yWPafYLHtOsVn2ak+x3fvo1LYKMmuXU2yWPQeALHupANAGkr4k6VRJ0yR9StItks6VtOFYFWnWTOpOPBe4nWKnpMuBvwKvBq4GvlxrZWYtSjXx9Ig4JSKOBaaUe9otiohT8D521idSTVw9f06r11YDQA9fcsOoizNrRaqJL5A0ESAijho6KGlLoOHMRTUAtN6rGi2sadYdqSZ+GFh3+MGIuDsi3lxPSWbtcQDIsucAkGXPASDLngNAlr3aA0DPn/rHtgoya5cDQJY9B4Ase203saT16yjEbLRS+9gNT7QLuF7SthSbmy+trTKzFqU+2D0M3Dfs2MYUKwEF8Lw6ijJrR2o48TGKdSdmR8SMiJgBLC5fu4GtL6RmJ44H3gV8QtIJ5VO65L501RTb3ecv6FKpZiNLfrCLiMURsS9wBXAZkHzIUU2xbfmGf+68SrMmUl9P+oCkTQEi4kJgV8CbcFhfaSvFBvxTRNw6BnWZtazdFNsCp9is3zjFZtlzis2yV3uK7bp5L2irIBuFAd89xSk2y55TbJY9N7FlL/WwY+/K68mSzpJ0s6RvSZpef3lmaak78TGV18cDDwKvA+YDp9dVlFk7UrMTVbMiYpvy9YmSDqyhHrO2pe7E60v6iKRDgXUkVeeNW1qL7fFfXtuVQs0aSTXxmcAkYCLwNWA9KNYtBm5sdFE1xbbOv76sS6WajSw1nFgG/CAiFlUPRsQS4O21VWXWBq/FZtnzWmyWPafYLHu1p9j+aZHSbzLrQOpO3HGKzaxuTrFZ9kazjNW0OgoxG61UAOhYSUMPOGZJuodiyu0+STuPSYVmCak78Wsi4uHy9eeB/SJiS2APikCQWc+lmngNSUMzGGtFxHxYOVaeUGtlZi1KNfFpwMWSdgMulXSSpJ0lHU2T7EQ1ALT0ZgeArF6KaL60mqRdgf8EZlLMKy8CzgfOLueNm3rRoScm126zztxy/IcHejI+tT7xBygCQA3ni816rZ0A0HuHZirM+kk7AaBZeBkr60MOAFn2vIyVZa/2Zaxe9tYb26nHrG0OAFn2vAKQZc9NbNlLpdhukHSUpC3GqiCzdqXuxOsCU4DLJV0v6cOSNqq/LLPWpZp4WUR8NCKeCxwKbAXcIOlySXPqL88sLdXEK+eJI+LqiHgfxba4xwENl/apptgWfN8THFavVBPfOfxARCyPiEsj4uBGF1WXsfrnfWZ2XKRZM6km/uXQZoxm/crLWFn2vIyVZc8pNsueU2yWvdpTbFdesk079dhozOp1Ab3lFJtlzwEgy14qADSrfMT8DUmbSrpM0mOS5kvadqyKNGumlcVTPgdcBPwSOD0iJgNHlOfMei7VxGtGxCUR8W2K6bbzKF78DHh27dWZtSDVxH+TtKekfYGQ9AaAckXM5Y0uqgaAHv2Vl7GyeqWa+D8pIpjvAPYCdpX0KMVQ4gONLqoGgKbM8j52Vq/UPPHOwLsq+9h9sPwx6xsOAFn2HACy7DkAZNlzAMiyV3sAaI0XP9ZWQWbtcgDIsucAkGXPTWzZS6XYJkr6tKTbyvTaQ5LmSTpojOozS0rdib9JMZW2F3A0cDLwNorHz8fUXJtZS1JNvHlEzI2IxRFxAjA7Iu4CDgb2qb88s7RUE/9F0k4AkmYDSwEiYgXD5pCrqim2ZT/+ddeKNRtJKym2E8rk2mHA+wHKDMWpjS6qptjW3Wu7btVqNqLUw45dgDdVUmwARMRDFONjs55rdzNGp9is77S7GaNTbNZ3nGKz7DnFZtlTRDQ+Kc0cxBCQpDkRcUav67DWNG3iQSXpVxEx4Cuc5cMBIMuem9iy5yYemcfDGfGY2LLnO7Flz01cIWlvSXdKulvSEb2ux1rj4URJ0urAQmAPYDEwH3hrRNze08IsyXfif9gBuDsi7omIJ4HvAK/vcU3WAjfxP2wMVCOni8tj1ufcxJY9N/E/PABU97HepDxmfc5N/A/zga0kzZD0LGB/isSe9blUFHNgRMTTkg4BfgysDnw1Im7rcVnWAk+xWfY8nLDsuYkte25iy56b2LLnJrbsuYkte25iy56b2LL3/wDnQXwGeMBdyAAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "# Represents what is the value counts of different values in the target column in training dataset\n", - "import seaborn as sns\n", - "plt.figure(figsize=(2,20))\n", - "sns.heatmap(y_train,cmap='viridis')\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "XMXb9lTyzGHE" - }, - "source": [ - "## Model Definition\n", - "\n", - "Using TensorFlow, build a model with the following definition:\n", - "> Input of shape 5 \\\\\n", - "> Dense of shape 5 \\\\\n", - "> Dense of shape 5 \\\\\n", - "> Dense of shape 1 \\\\\n", - "\n", - "Use Mean Square Error Loss and Stochaistic Gradient Descent (SGD) Optimizer\n", - "\n", - "Use Gradient Decay with appropriate parameters" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "id": "r32N1xK2ziOs" - }, - "outputs": [], - "source": [ - "import tensorflow as tf\n", - "from tensorflow import keras\n", - "\n", - "\n", - "def build_model():\n", - " model=tf.keras.models.Sequential([\n", - " tf.keras.layers.InputLayer(input_shape=5) ,\n", - " tf.keras.layers.Dense(5,activation='relu'),\n", - " tf.keras.layers.Dense(5,activation='relu'),\n", - " tf.keras.layers.Dense(1)\n", - "\n", - " ])\n", - "\n", - " optimi=tf.keras.optimizers.SGD( learning_rate=0.01)\n", - "\n", - "\n", - " model.compile(loss='mean_squared_error',optimizer=optimi,metrics=['mse'])\n", - " return model\n", - "\n", - "model=build_model()\n", - "\n", - "\n", - "\n", - "# Your code here" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "yIQ0mPVfrUzy", - "outputId": "daba414e-804c-4d68-adf0-f360943225fa" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model: \"sequential\"\n", - "_________________________________________________________________\n", - " Layer (type) Output Shape Param # \n", - "=================================================================\n", - " dense (Dense) (None, 5) 30 \n", - " \n", - " dense_1 (Dense) (None, 5) 30 \n", - " \n", - " dense_2 (Dense) (None, 1) 6 \n", - " \n", - "=================================================================\n", - "Total params: 66\n", - "Trainable params: 66\n", - "Non-trainable params: 0\n", - "_________________________________________________________________\n" - ] - } - ], - "source": [ - "model.summary()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "0pL-Eg_8rzsm", - "outputId": "2e1dd950-09bc-4254-d3dd-7486d02010e4" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 1/100\n", - "2/2 [==============================] - 1s 306ms/step - loss: 12262.9619 - mse: 12262.9619 - val_loss: 11092.0488 - val_mse: 11092.0488\n", - "Epoch 2/100\n", - "2/2 [==============================] - 0s 45ms/step - loss: 14371.0664 - mse: 14371.0664 - val_loss: 7165.2935 - val_mse: 7165.2935\n", - "Epoch 3/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12583.0078 - mse: 12583.0078 - val_loss: 7146.7114 - val_mse: 7146.7114\n", - "Epoch 4/100\n", - "2/2 [==============================] - 0s 48ms/step - loss: 12578.8672 - mse: 12578.8672 - val_loss: 7129.0264 - val_mse: 7129.0264\n", - "Epoch 5/100\n", - "2/2 [==============================] - 0s 54ms/step - loss: 12573.8975 - mse: 12573.8975 - val_loss: 7111.7861 - val_mse: 7111.7861\n", - "Epoch 6/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12572.4795 - mse: 12572.4795 - val_loss: 7095.2236 - val_mse: 7095.2236\n", - "Epoch 7/100\n", - "2/2 [==============================] - 0s 47ms/step - loss: 12567.2871 - mse: 12567.2871 - val_loss: 7079.9390 - val_mse: 7079.9390\n", - "Epoch 8/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12563.1133 - mse: 12563.1133 - val_loss: 7065.2163 - val_mse: 7065.2163\n", - "Epoch 9/100\n", - "2/2 [==============================] - 0s 47ms/step - loss: 12560.5127 - mse: 12560.5127 - val_loss: 7051.2412 - val_mse: 7051.2412\n", - "Epoch 10/100\n", - "2/2 [==============================] - 0s 42ms/step - loss: 12570.8369 - mse: 12570.8369 - val_loss: 7037.2227 - val_mse: 7037.2227\n", - "Epoch 11/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12555.1982 - mse: 12555.1982 - val_loss: 7024.4541 - val_mse: 7024.4541\n", - "Epoch 12/100\n", - "2/2 [==============================] - 0s 42ms/step - loss: 12553.8750 - mse: 12553.8750 - val_loss: 7012.1353 - val_mse: 7012.1353\n", - "Epoch 13/100\n", - "2/2 [==============================] - 0s 39ms/step - loss: 12557.2422 - mse: 12557.2422 - val_loss: 7000.1250 - val_mse: 7000.1250\n", - "Epoch 14/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12549.5371 - mse: 12549.5371 - val_loss: 6989.2041 - val_mse: 6989.2041\n", - "Epoch 15/100\n", - "2/2 [==============================] - 0s 39ms/step - loss: 12549.4453 - mse: 12549.4453 - val_loss: 6978.8999 - val_mse: 6978.8999\n", - "Epoch 16/100\n", - "2/2 [==============================] - 0s 40ms/step - loss: 12547.2168 - mse: 12547.2168 - val_loss: 6968.6260 - val_mse: 6968.6260\n", - "Epoch 17/100\n", - "2/2 [==============================] - 0s 39ms/step - loss: 12549.8320 - mse: 12549.8320 - val_loss: 6958.6318 - val_mse: 6958.6318\n", - "Epoch 18/100\n", - "2/2 [==============================] - 0s 41ms/step - loss: 12542.8301 - mse: 12542.8301 - val_loss: 6949.4780 - val_mse: 6949.4780\n", - "Epoch 19/100\n", - "2/2 [==============================] - 0s 40ms/step - loss: 12542.5918 - mse: 12542.5918 - val_loss: 6940.5669 - val_mse: 6940.5669\n", - "Epoch 20/100\n", - "2/2 [==============================] - 0s 42ms/step - loss: 12540.4268 - mse: 12540.4268 - val_loss: 6932.1987 - val_mse: 6932.1987\n", - "Epoch 21/100\n", - "2/2 [==============================] - 0s 45ms/step - loss: 12549.0176 - mse: 12549.0176 - val_loss: 6923.7275 - val_mse: 6923.7275\n", - "Epoch 22/100\n", - "2/2 [==============================] - 0s 40ms/step - loss: 12551.0293 - mse: 12551.0293 - val_loss: 6915.5625 - val_mse: 6915.5625\n", - "Epoch 23/100\n", - "2/2 [==============================] - 0s 50ms/step - loss: 12538.0781 - mse: 12538.0781 - val_loss: 6908.1865 - val_mse: 6908.1865\n", - "Epoch 24/100\n", - "2/2 [==============================] - 0s 45ms/step - loss: 12543.6709 - mse: 12543.6709 - val_loss: 6900.8511 - val_mse: 6900.8511\n", - "Epoch 25/100\n", - "2/2 [==============================] - 0s 46ms/step - loss: 12539.5977 - mse: 12539.5977 - val_loss: 6894.5586 - val_mse: 6894.5586\n", - "Epoch 26/100\n", - "2/2 [==============================] - 0s 45ms/step - loss: 12539.6719 - mse: 12539.6719 - val_loss: 6887.9038 - val_mse: 6887.9038\n", - "Epoch 27/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12538.1367 - mse: 12538.1367 - val_loss: 6881.5728 - val_mse: 6881.5728\n", - "Epoch 28/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12542.5918 - mse: 12542.5918 - val_loss: 6875.3584 - val_mse: 6875.3584\n", - "Epoch 29/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12533.7070 - mse: 12533.7070 - val_loss: 6869.7583 - val_mse: 6869.7583\n", - "Epoch 30/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12548.0664 - mse: 12548.0664 - val_loss: 6863.9131 - val_mse: 6863.9131\n", - "Epoch 31/100\n", - "2/2 [==============================] - 0s 47ms/step - loss: 12532.1807 - mse: 12532.1807 - val_loss: 6858.8984 - val_mse: 6858.8984\n", - "Epoch 32/100\n", - "2/2 [==============================] - 0s 41ms/step - loss: 12531.9277 - mse: 12531.9277 - val_loss: 6854.0508 - val_mse: 6854.0508\n", - "Epoch 33/100\n", - "2/2 [==============================] - 0s 59ms/step - loss: 12537.1016 - mse: 12537.1016 - val_loss: 6849.8359 - val_mse: 6849.8359\n", - "Epoch 34/100\n", - "2/2 [==============================] - 0s 38ms/step - loss: 12532.6133 - mse: 12532.6133 - val_loss: 6845.2505 - val_mse: 6845.2505\n", - "Epoch 35/100\n", - "2/2 [==============================] - 0s 42ms/step - loss: 12538.8633 - mse: 12538.8633 - val_loss: 6840.6216 - val_mse: 6840.6216\n", - "Epoch 36/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12531.0820 - mse: 12531.0820 - val_loss: 6836.4883 - val_mse: 6836.4883\n", - "Epoch 37/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12533.3271 - mse: 12533.3271 - val_loss: 6832.3882 - val_mse: 6832.3882\n", - "Epoch 38/100\n", - "2/2 [==============================] - 0s 45ms/step - loss: 12530.0039 - mse: 12530.0039 - val_loss: 6828.8008 - val_mse: 6828.8008\n", - "Epoch 39/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12529.7305 - mse: 12529.7305 - val_loss: 6825.2300 - val_mse: 6825.2300\n", - "Epoch 40/100\n", - "2/2 [==============================] - 0s 42ms/step - loss: 12532.9531 - mse: 12532.9531 - val_loss: 6822.1538 - val_mse: 6822.1538\n", - "Epoch 41/100\n", - "2/2 [==============================] - 0s 42ms/step - loss: 12545.0898 - mse: 12545.0898 - val_loss: 6819.2314 - val_mse: 6819.2314\n", - "Epoch 42/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12530.6523 - mse: 12530.6523 - val_loss: 6815.5562 - val_mse: 6815.5562\n", - "Epoch 43/100\n", - "2/2 [==============================] - 0s 40ms/step - loss: 12526.3711 - mse: 12526.3711 - val_loss: 6809.5137 - val_mse: 6809.5137\n", - "Epoch 44/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12515.4746 - mse: 12515.4746 - val_loss: 6797.6768 - val_mse: 6797.6768\n", - "Epoch 45/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12492.8398 - mse: 12492.8398 - val_loss: 6772.5537 - val_mse: 6772.5537\n", - "Epoch 46/100\n", - "2/2 [==============================] - 0s 42ms/step - loss: 12305.8164 - mse: 12305.8164 - val_loss: 6718.9775 - val_mse: 6718.9775\n", - "Epoch 47/100\n", - "2/2 [==============================] - 0s 40ms/step - loss: 11177.3145 - mse: 11177.3145 - val_loss: 38427.1367 - val_mse: 38427.1367\n", - "Epoch 48/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 37039.4844 - mse: 37039.4844 - val_loss: 12114.6426 - val_mse: 12114.6426\n", - "Epoch 49/100\n", - "2/2 [==============================] - 0s 46ms/step - loss: 379740.7188 - mse: 379740.7188 - val_loss: 6984.1729 - val_mse: 6984.1729\n", - "Epoch 50/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12546.5430 - mse: 12546.5430 - val_loss: 6973.8364 - val_mse: 6973.8364\n", - "Epoch 51/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12557.4473 - mse: 12557.4473 - val_loss: 6963.4180 - val_mse: 6963.4180\n", - "Epoch 52/100\n", - "2/2 [==============================] - 0s 47ms/step - loss: 12543.7080 - mse: 12543.7080 - val_loss: 6954.1152 - val_mse: 6954.1152\n", - "Epoch 53/100\n", - "2/2 [==============================] - 0s 76ms/step - loss: 12544.0078 - mse: 12544.0078 - val_loss: 6945.3711 - val_mse: 6945.3711\n", - "Epoch 54/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12556.0166 - mse: 12556.0166 - val_loss: 6937.4219 - val_mse: 6937.4219\n", - "Epoch 55/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12555.8555 - mse: 12555.8555 - val_loss: 6929.8418 - val_mse: 6929.8418\n", - "Epoch 56/100\n", - "2/2 [==============================] - 0s 46ms/step - loss: 12539.0918 - mse: 12539.0918 - val_loss: 6921.9487 - val_mse: 6921.9487\n", - "Epoch 57/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12545.1680 - mse: 12545.1680 - val_loss: 6914.0068 - val_mse: 6914.0068\n", - "Epoch 58/100\n", - "2/2 [==============================] - 0s 48ms/step - loss: 12538.1182 - mse: 12538.1182 - val_loss: 6906.6826 - val_mse: 6906.6826\n", - "Epoch 59/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12536.4043 - mse: 12536.4043 - val_loss: 6899.8540 - val_mse: 6899.8540\n", - "Epoch 60/100\n", - "2/2 [==============================] - 0s 45ms/step - loss: 12545.4170 - mse: 12545.4170 - val_loss: 6893.7852 - val_mse: 6893.7852\n", - "Epoch 61/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12540.1338 - mse: 12540.1338 - val_loss: 6887.1465 - val_mse: 6887.1465\n", - "Epoch 62/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12535.9805 - mse: 12535.9805 - val_loss: 6881.3438 - val_mse: 6881.3438\n", - "Epoch 63/100\n", - "2/2 [==============================] - 0s 42ms/step - loss: 12533.7822 - mse: 12533.7822 - val_loss: 6875.5820 - val_mse: 6875.5820\n", - "Epoch 64/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12534.3340 - mse: 12534.3340 - val_loss: 6869.9229 - val_mse: 6869.9229\n", - "Epoch 65/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12544.7490 - mse: 12544.7490 - val_loss: 6864.1406 - val_mse: 6864.1406\n", - "Epoch 66/100\n", - "2/2 [==============================] - 0s 48ms/step - loss: 12532.7070 - mse: 12532.7070 - val_loss: 6859.2402 - val_mse: 6859.2402\n", - "Epoch 67/100\n", - "2/2 [==============================] - 0s 45ms/step - loss: 12540.0264 - mse: 12540.0264 - val_loss: 6854.8760 - val_mse: 6854.8760\n", - "Epoch 68/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12532.3975 - mse: 12532.3975 - val_loss: 6850.1201 - val_mse: 6850.1201\n", - "Epoch 69/100\n", - "2/2 [==============================] - 0s 41ms/step - loss: 12539.5771 - mse: 12539.5771 - val_loss: 6846.1504 - val_mse: 6846.1504\n", - "Epoch 70/100\n", - "2/2 [==============================] - 0s 48ms/step - loss: 12534.7676 - mse: 12534.7676 - val_loss: 6842.2109 - val_mse: 6842.2109\n", - "Epoch 71/100\n", - "2/2 [==============================] - 0s 47ms/step - loss: 12535.3730 - mse: 12535.3730 - val_loss: 6837.8101 - val_mse: 6837.8101\n", - "Epoch 72/100\n", - "2/2 [==============================] - 0s 40ms/step - loss: 12530.4844 - mse: 12530.4844 - val_loss: 6834.0049 - val_mse: 6834.0049\n", - "Epoch 73/100\n", - "2/2 [==============================] - 0s 41ms/step - loss: 12535.9141 - mse: 12535.9141 - val_loss: 6830.6431 - val_mse: 6830.6431\n", - "Epoch 74/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12529.7637 - mse: 12529.7637 - val_loss: 6827.0908 - val_mse: 6827.0908\n", - "Epoch 75/100\n", - "2/2 [==============================] - 0s 46ms/step - loss: 12537.2832 - mse: 12537.2832 - val_loss: 6824.0693 - val_mse: 6824.0693\n", - "Epoch 76/100\n", - "2/2 [==============================] - 0s 46ms/step - loss: 12560.0615 - mse: 12560.0615 - val_loss: 6821.5796 - val_mse: 6821.5796\n", - "Epoch 77/100\n", - "2/2 [==============================] - 0s 45ms/step - loss: 12534.9043 - mse: 12534.9043 - val_loss: 6818.0249 - val_mse: 6818.0249\n", - "Epoch 78/100\n", - "2/2 [==============================] - 0s 42ms/step - loss: 12530.1738 - mse: 12530.1738 - val_loss: 6814.8101 - val_mse: 6814.8101\n", - "Epoch 79/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12530.2627 - mse: 12530.2627 - val_loss: 6811.7124 - val_mse: 6811.7124\n", - "Epoch 80/100\n", - "2/2 [==============================] - 0s 44ms/step - loss: 12531.0273 - mse: 12531.0273 - val_loss: 6809.1479 - val_mse: 6809.1479\n", - "Epoch 81/100\n", - "2/2 [==============================] - 0s 54ms/step - loss: 12528.5293 - mse: 12528.5293 - val_loss: 6806.4868 - val_mse: 6806.4868\n", - "Epoch 82/100\n", - "2/2 [==============================] - 0s 48ms/step - loss: 12528.3770 - mse: 12528.3770 - val_loss: 6803.9165 - val_mse: 6803.9165\n", - "Epoch 83/100\n", - "2/2 [==============================] - 0s 41ms/step - loss: 12530.9883 - mse: 12530.9883 - val_loss: 6801.2090 - val_mse: 6801.2090\n", - "Epoch 84/100\n", - "2/2 [==============================] - 0s 42ms/step - loss: 12528.4297 - mse: 12528.4297 - val_loss: 6798.7744 - val_mse: 6798.7744\n", - "Epoch 85/100\n", - "2/2 [==============================] - 0s 45ms/step - loss: 12542.8262 - mse: 12542.8262 - val_loss: 6797.0767 - val_mse: 6797.0767\n", - "Epoch 86/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12527.9600 - mse: 12527.9600 - val_loss: 6794.8916 - val_mse: 6794.8916\n", - "Epoch 87/100\n", - "2/2 [==============================] - 0s 41ms/step - loss: 12527.9473 - mse: 12527.9473 - val_loss: 6792.7568 - val_mse: 6792.7568\n", - "Epoch 88/100\n", - "2/2 [==============================] - 0s 41ms/step - loss: 12532.5371 - mse: 12532.5371 - val_loss: 6790.4355 - val_mse: 6790.4355\n", - "Epoch 89/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12530.3691 - mse: 12530.3691 - val_loss: 6788.7583 - val_mse: 6788.7583\n", - "Epoch 90/100\n", - "2/2 [==============================] - 0s 42ms/step - loss: 12536.0205 - mse: 12536.0205 - val_loss: 6786.4990 - val_mse: 6786.4990\n", - "Epoch 91/100\n", - "2/2 [==============================] - 0s 41ms/step - loss: 12528.2305 - mse: 12528.2305 - val_loss: 6784.8643 - val_mse: 6784.8643\n", - "Epoch 92/100\n", - "2/2 [==============================] - 0s 45ms/step - loss: 12538.0020 - mse: 12538.0020 - val_loss: 6782.7163 - val_mse: 6782.7163\n", - "Epoch 93/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12529.5488 - mse: 12529.5488 - val_loss: 6780.9121 - val_mse: 6780.9121\n", - "Epoch 94/100\n", - "2/2 [==============================] - 0s 41ms/step - loss: 12530.9824 - mse: 12530.9824 - val_loss: 6779.1187 - val_mse: 6779.1187\n", - "Epoch 95/100\n", - "2/2 [==============================] - 0s 46ms/step - loss: 12529.6895 - mse: 12529.6895 - val_loss: 6777.8877 - val_mse: 6777.8877\n", - "Epoch 96/100\n", - "2/2 [==============================] - 0s 40ms/step - loss: 12530.5879 - mse: 12530.5879 - val_loss: 6776.2295 - val_mse: 6776.2295\n", - "Epoch 97/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12527.2910 - mse: 12527.2910 - val_loss: 6774.9199 - val_mse: 6774.9199\n", - "Epoch 98/100\n", - "2/2 [==============================] - 0s 43ms/step - loss: 12533.8867 - mse: 12533.8867 - val_loss: 6774.0078 - val_mse: 6774.0078\n", - "Epoch 99/100\n", - "2/2 [==============================] - 0s 41ms/step - loss: 12530.3994 - mse: 12530.3994 - val_loss: 6772.5107 - val_mse: 6772.5107\n", - "Epoch 100/100\n", - "2/2 [==============================] - 0s 50ms/step - loss: 12527.2217 - mse: 12527.2217 - val_loss: 6771.3604 - val_mse: 6771.3604\n" - ] - } - ], - "source": [ - "results=model.fit(x_train,y_train,epochs=100,validation_split=0.2)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "jmeP6vt3z0oA" - }, - "source": [ - "## Plot Loss\n", - "\n", - "Using matplotlib visualise how the loss (both validation and training) is changing, use this information to retrain the model with appropriate parameters.
We ideally want the loss to be constant over the last few iterations." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 206 - }, - "id": "RQTNqPHm0mOi", - "outputId": "a2aa2f5d-d682-4afa-b3e9-457edfd64ccd" - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
lossmseval_lossval_mseepoch
9512530.58789112530.5878916776.2294926776.22949295
9612527.29101612527.2910166774.9199226774.91992296
9712533.88671912533.8867196774.0078126774.00781297
9812530.39941412530.3994146772.5107426772.51074298
9912527.22168012527.2216806771.3603526771.36035299
\n", - "
" - ], - "text/plain": [ - " loss mse val_loss val_mse epoch\n", - "95 12530.587891 12530.587891 6776.229492 6776.229492 95\n", - "96 12527.291016 12527.291016 6774.919922 6774.919922 96\n", - "97 12533.886719 12533.886719 6774.007812 6774.007812 97\n", - "98 12530.399414 12530.399414 6772.510742 6772.510742 98\n", - "99 12527.221680 12527.221680 6771.360352 6771.360352 99" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import pandas as pd\n", - "res=pd.DataFrame(results.history)\n", - "res['epoch']=results.epoch\n", - "res.tail()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 282 - }, - "id": "ubeaG8e9t7im", - "outputId": "f763ebb3-d143-484d-b333-ccda2479bdb7" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(res['epoch'],res['loss'])\n", - "plt.plot(res['epoch'],res['val_loss'])\n", - "plt.legend([\"Loss\",\"Val_Loss\"])\n", - "# plt.xlim(0,80)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "IVrR_vXA7kOt" - }, - "source": [ - "## Evaluation Metrics\n", - "Use the R2 Score function implemented in the first assignment to evaluate the performance of the model." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "id": "-lOHpD8-7ggm" - }, - "outputs": [], - "source": [ - "# Insert the function for R2 Score\n", - "\n", - "def r2_score_predictor(y_true,y_pred):\n", - " from sklearn.metrics import r2_score\n", - " r=r2_score(y_true,y_pred)\n", - " return r\n", - "predictions=model.predict(x_test)\n", - "r=r2_score_predictor(y_test,predictions)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "SCApVNjtzbv8", - "outputId": "f108f6c9-9479-442a-f7f4-2c087c3986da" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The r2_score value is -0.0909121073526411\n" - ] - } - ], - "source": [ - "print(\"The r2_score value is \",r)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "CHqzF1OU0pBg" - }, - "source": [ - "## Your own custom model\n", - "Build a custom model of your own choice.
\n", - "Describe it in detail in Markdown/Latex in the cell below.
\n", - "Visualise the loss, as before." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "jF8oTUqq0y0g" - }, - "source": [ - "Your text here" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "from sklearn import datasets\n", - "from sklearn.model_selection import train_test_split\n", - "\n", - "# Generate the data\n", - "x_2, y_2 = datasets.make_regression(n_samples=1000, n_features=5, noise=5, random_state=4)\n", - "\n", - "\n", - "# Split the data\n", - "x_train_2, x_test_2, y_train_2, y_test_2 = train_test_split(x_2, y_2, test_size=0.2, random_state=1234)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Instead of using SGD optimizer we can use Adam optimizer to get better results." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "id": "1XOk5hJu0oSQ" - }, - "outputs": [], - "source": [ - "import tensorflow as tf\n", - "model_2=tf.keras.models.Sequential([\n", - " tf.keras.layers.InputLayer(input_shape=5) ,\n", - " tf.keras.layers.Dense(30,activation='relu'),\n", - " tf.keras.layers.Dense(30,activation='relu'),\n", - " tf.keras.layers.Dense(1)\n", - "\n", - " ])\n", - "\n", - "optimi=tf.keras.optimizers.Adam( learning_rate=0.01)\n", - "\n", - "\n", - "model_2.compile(loss='mean_squared_error',optimizer=optimi,metrics=tf.keras.metrics.Accuracy())\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model: \"sequential\"\n", - "_________________________________________________________________\n", - " Layer (type) Output Shape Param # \n", - "=================================================================\n", - " dense (Dense) (None, 30) 180 \n", - " \n", - " dense_1 (Dense) (None, 30) 930 \n", - " \n", - " dense_2 (Dense) (None, 1) 31 \n", - " \n", - "=================================================================\n", - "Total params: 1,141\n", - "Trainable params: 1,141\n", - "Non-trainable params: 0\n", - "_________________________________________________________________\n" - ] - } - ], - "source": [ - "model_2.summary()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "aS0ROZa402Lo", - "outputId": "c852055e-ec4f-4272-ad30-e068b76c623f" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 1/20\n", - "20/20 [==============================] - 1s 17ms/step - loss: 22293.0352 - accuracy: 0.0000e+00 - val_loss: 22968.2930 - val_accuracy: 0.0000e+00\n", - "Epoch 2/20\n", - "20/20 [==============================] - 0s 5ms/step - loss: 16845.7617 - accuracy: 0.0000e+00 - val_loss: 11418.9531 - val_accuracy: 0.0000e+00\n", - "Epoch 3/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 4155.4365 - accuracy: 0.0000e+00 - val_loss: 745.3987 - val_accuracy: 0.0000e+00\n", - "Epoch 4/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 621.0253 - accuracy: 0.0000e+00 - val_loss: 412.5599 - val_accuracy: 0.0000e+00\n", - "Epoch 5/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 308.1701 - accuracy: 0.0000e+00 - val_loss: 312.2416 - val_accuracy: 0.0000e+00\n", - "Epoch 6/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 240.7342 - accuracy: 0.0000e+00 - val_loss: 267.2795 - val_accuracy: 0.0000e+00\n", - "Epoch 7/20\n", - "20/20 [==============================] - 0s 5ms/step - loss: 207.0453 - accuracy: 0.0000e+00 - val_loss: 246.7999 - val_accuracy: 0.0000e+00\n", - "Epoch 8/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 185.6382 - accuracy: 0.0000e+00 - val_loss: 233.2929 - val_accuracy: 0.0000e+00\n", - "Epoch 9/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 172.4978 - accuracy: 0.0000e+00 - val_loss: 238.8235 - val_accuracy: 0.0000e+00\n", - "Epoch 10/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 154.8446 - accuracy: 0.0000e+00 - val_loss: 173.0536 - val_accuracy: 0.0000e+00\n", - "Epoch 11/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 129.1207 - accuracy: 0.0000e+00 - val_loss: 134.6592 - val_accuracy: 0.0000e+00\n", - "Epoch 12/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 121.6438 - accuracy: 0.0000e+00 - val_loss: 122.1448 - val_accuracy: 0.0000e+00\n", - "Epoch 13/20\n", - "20/20 [==============================] - 0s 5ms/step - loss: 100.9714 - accuracy: 0.0000e+00 - val_loss: 108.3006 - val_accuracy: 0.0000e+00\n", - "Epoch 14/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 88.0066 - accuracy: 0.0000e+00 - val_loss: 93.5628 - val_accuracy: 0.0000e+00\n", - "Epoch 15/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 74.2823 - accuracy: 0.0000e+00 - val_loss: 83.5923 - val_accuracy: 0.0000e+00\n", - "Epoch 16/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 67.1191 - accuracy: 0.0000e+00 - val_loss: 84.6325 - val_accuracy: 0.0000e+00\n", - "Epoch 17/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 59.6604 - accuracy: 0.0000e+00 - val_loss: 64.3586 - val_accuracy: 0.0000e+00\n", - "Epoch 18/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 50.1667 - accuracy: 0.0000e+00 - val_loss: 57.6406 - val_accuracy: 0.0000e+00\n", - "Epoch 19/20\n", - "20/20 [==============================] - 0s 8ms/step - loss: 45.9919 - accuracy: 0.0000e+00 - val_loss: 50.3901 - val_accuracy: 0.0000e+00\n", - "Epoch 20/20\n", - "20/20 [==============================] - 0s 4ms/step - loss: 43.3895 - accuracy: 0.0000e+00 - val_loss: 46.8216 - val_accuracy: 0.0000e+00\n" - ] - } - ], - "source": [ - "results_2=model_2.fit(x_train_2,y_train_2,epochs=20,validation_split=0.2)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 206 - }, - "id": "-v9c8bWtxbgP", - "outputId": "19e97d03-36e9-4893-ace2-3da787fe8f49" - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
lossaccuracyval_lossval_accuracyepoch
1567.1190570.084.6324620.015
1659.6604310.064.3586040.016
1750.1667180.057.6405750.017
1845.9919090.050.3900990.018
1943.3894840.046.8216480.019
\n", - "
" - ], - "text/plain": [ - " loss accuracy val_loss val_accuracy epoch\n", - "15 67.119057 0.0 84.632462 0.0 15\n", - "16 59.660431 0.0 64.358604 0.0 16\n", - "17 50.166718 0.0 57.640575 0.0 17\n", - "18 45.991909 0.0 50.390099 0.0 18\n", - "19 43.389484 0.0 46.821648 0.0 19" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import pandas as pd\n", - "res_2=pd.DataFrame(results_2.history)\n", - "res_2['epoch']=results_2.epoch\n", - "res_2.tail()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 282 - }, - "id": "6xWw8yxhxxmt", - "outputId": "4acfcf6e-3e59-48e7-fabe-3bac990417b3" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "plt.plot(res_2['epoch'],res_2['loss'])\n", - "plt.plot(res_2['epoch'],res_2['val_loss'])\n", - "plt.legend([\"Val_Loss\",\"Loss\"])\n", - "# plt.xlim(0,80)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "id": "FeWhnbAV0PUX" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2_score is 0.9978912555372441\n" - ] - } - ], - "source": [ - "# R2 score calculation\n", - "\n", - "from sklearn.metrics import r2_score\n", - "predic=model_2.predict(x_test_2)\n", - "r2_sco=r2_score(y_test_2,predic)\n", - "print(\"r2_score is \",r2_sco)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "r2_score coming close to 1 signify that our model is performing very well on the test data set ." - ] - } - ], - "metadata": { - "colab": { - "collapsed_sections": [], - "name": "Copy of CVusingTF_Assgn2.ipynb", - "provenance": [] - }, - "interpreter": { - "hash": "d32dd9972e4becc079854756227bbaf57600491c52d25499cfd0dde1c0f41dcc" - }, - "kernelspec": { - "display_name": "Python 3.9.6 64-bit", - "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.9.6" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} From ce4e6624feee155161178d68a80740f83e46f3da Mon Sep 17 00:00:00 2001 From: Abhay-sisodia <84870507+Abhay-sisodia@users.noreply.github.com> Date: Tue, 14 Jun 2022 15:59:08 +0530 Subject: [PATCH 6/8] Add files via upload --- Assignment 2/A2_200014.ipynb | 1090 ++++++++++++++++++++++++++++++++++ 1 file changed, 1090 insertions(+) create mode 100644 Assignment 2/A2_200014.ipynb diff --git a/Assignment 2/A2_200014.ipynb b/Assignment 2/A2_200014.ipynb new file mode 100644 index 0000000..973ca6c --- /dev/null +++ b/Assignment 2/A2_200014.ipynb @@ -0,0 +1,1090 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "UxcaEbrCy1g_" + }, + "source": [ + "# Assigment 2: Deep Learning" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "h2JON-_Oy79w" + }, + "source": [ + "## Generate Dataset\n", + "\n", + "This is the same code from Assignment 1" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "hgpG3WDuypfa" + }, + "outputs": [], + "source": [ + "from sklearn import datasets\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "# Generate the data\n", + "x, y = datasets.make_regression(n_samples=100, n_features=5, noise=5, random_state=4)\n", + "\n", + "\n", + "# Split the data\n", + "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=1234)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "H6yGzfrTyqcs", + "outputId": "60310a69-fdbc-4da7-8dcf-573e8a2ef598" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(80, 6)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "y_train=y_train.reshape(-1,1)\n", + "z_train=np.concatenate((x_train,y_train),axis=1)\n", + "z_train.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ZFK06IAqz7JU", + "outputId": "11d0d9a8-0102-4b5a-e00c-64f2958be46a" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "-261.6982943912921" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_train.min()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "r6it-Rm7zD1Y" + }, + "source": [ + "## Visualize Dataset\n", + "This is the same code from Assignment 1" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "UautPVj1yzaQ", + "outputId": "c1ceed4c-fa2f-4a3d-f9ba-547b66f1c1c8" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Visualizing the train dataset \n", + "import matplotlib.pyplot as plt\n", + "fig, axs = plt.subplots(5,figsize=(20,30))\n", + "\n", + "for i in range(5):\n", + " axs[i].scatter(x_train[:,i],y_train)\n", + "\n", + "\n", + "\n", + "\n", + "# Your code here" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "erZ1XReZ1QzO", + "outputId": "db319adf-ff5f-4dbe-af6f-ed1bf8c8239a" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Represents what is the value counts of different values in the target column in training dataset\n", + "import seaborn as sns\n", + "plt.figure(figsize=(2,20))\n", + "sns.heatmap(y_train,cmap='viridis')\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XMXb9lTyzGHE" + }, + "source": [ + "## Model Definition\n", + "\n", + "Using TensorFlow, build a model with the following definition:\n", + "> Input of shape 5 \\\\\n", + "> Dense of shape 5 \\\\\n", + "> Dense of shape 5 \\\\\n", + "> Dense of shape 1 \\\\\n", + "\n", + "Use Mean Square Error Loss and Stochaistic Gradient Descent (SGD) Optimizer\n", + "\n", + "Use Gradient Decay with appropriate parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "r32N1xK2ziOs" + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "\n", + "\n", + "def build_model():\n", + " model=tf.keras.models.Sequential([\n", + " tf.keras.layers.InputLayer(input_shape=5) ,\n", + " tf.keras.layers.Dense(5,activation='relu'),\n", + " tf.keras.layers.Dense(5,activation='relu'),\n", + " tf.keras.layers.Dense(1)\n", + "\n", + " ])\n", + "\n", + " optimi=tf.keras.optimizers.SGD( learning_rate=0.01)\n", + "\n", + "\n", + " model.compile(loss='mean_squared_error',optimizer=optimi,metrics=['mse'])\n", + " return model\n", + "\n", + "model=build_model()\n", + "\n", + "\n", + "\n", + "# Your code here" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "yIQ0mPVfrUzy", + "outputId": "daba414e-804c-4d68-adf0-f360943225fa" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " dense (Dense) (None, 5) 30 \n", + " \n", + " dense_1 (Dense) (None, 5) 30 \n", + " \n", + " dense_2 (Dense) (None, 1) 6 \n", + " \n", + "=================================================================\n", + "Total params: 66\n", + "Trainable params: 66\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0pL-Eg_8rzsm", + "outputId": "2e1dd950-09bc-4254-d3dd-7486d02010e4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/100\n", + "2/2 [==============================] - 1s 306ms/step - loss: 12262.9619 - mse: 12262.9619 - val_loss: 11092.0488 - val_mse: 11092.0488\n", + "Epoch 2/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 14371.0664 - mse: 14371.0664 - val_loss: 7165.2935 - val_mse: 7165.2935\n", + "Epoch 3/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12583.0078 - mse: 12583.0078 - val_loss: 7146.7114 - val_mse: 7146.7114\n", + "Epoch 4/100\n", + "2/2 [==============================] - 0s 48ms/step - loss: 12578.8672 - mse: 12578.8672 - val_loss: 7129.0264 - val_mse: 7129.0264\n", + "Epoch 5/100\n", + "2/2 [==============================] - 0s 54ms/step - loss: 12573.8975 - mse: 12573.8975 - val_loss: 7111.7861 - val_mse: 7111.7861\n", + "Epoch 6/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12572.4795 - mse: 12572.4795 - val_loss: 7095.2236 - val_mse: 7095.2236\n", + "Epoch 7/100\n", + "2/2 [==============================] - 0s 47ms/step - loss: 12567.2871 - mse: 12567.2871 - val_loss: 7079.9390 - val_mse: 7079.9390\n", + "Epoch 8/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12563.1133 - mse: 12563.1133 - val_loss: 7065.2163 - val_mse: 7065.2163\n", + "Epoch 9/100\n", + "2/2 [==============================] - 0s 47ms/step - loss: 12560.5127 - mse: 12560.5127 - val_loss: 7051.2412 - val_mse: 7051.2412\n", + "Epoch 10/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12570.8369 - mse: 12570.8369 - val_loss: 7037.2227 - val_mse: 7037.2227\n", + "Epoch 11/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12555.1982 - mse: 12555.1982 - val_loss: 7024.4541 - val_mse: 7024.4541\n", + "Epoch 12/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12553.8750 - mse: 12553.8750 - val_loss: 7012.1353 - val_mse: 7012.1353\n", + "Epoch 13/100\n", + "2/2 [==============================] - 0s 39ms/step - loss: 12557.2422 - mse: 12557.2422 - val_loss: 7000.1250 - val_mse: 7000.1250\n", + "Epoch 14/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12549.5371 - mse: 12549.5371 - val_loss: 6989.2041 - val_mse: 6989.2041\n", + "Epoch 15/100\n", + "2/2 [==============================] - 0s 39ms/step - loss: 12549.4453 - mse: 12549.4453 - val_loss: 6978.8999 - val_mse: 6978.8999\n", + "Epoch 16/100\n", + "2/2 [==============================] - 0s 40ms/step - loss: 12547.2168 - mse: 12547.2168 - val_loss: 6968.6260 - val_mse: 6968.6260\n", + "Epoch 17/100\n", + "2/2 [==============================] - 0s 39ms/step - loss: 12549.8320 - mse: 12549.8320 - val_loss: 6958.6318 - val_mse: 6958.6318\n", + "Epoch 18/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12542.8301 - mse: 12542.8301 - val_loss: 6949.4780 - val_mse: 6949.4780\n", + "Epoch 19/100\n", + "2/2 [==============================] - 0s 40ms/step - loss: 12542.5918 - mse: 12542.5918 - val_loss: 6940.5669 - val_mse: 6940.5669\n", + "Epoch 20/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12540.4268 - mse: 12540.4268 - val_loss: 6932.1987 - val_mse: 6932.1987\n", + "Epoch 21/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12549.0176 - mse: 12549.0176 - val_loss: 6923.7275 - val_mse: 6923.7275\n", + "Epoch 22/100\n", + "2/2 [==============================] - 0s 40ms/step - loss: 12551.0293 - mse: 12551.0293 - val_loss: 6915.5625 - val_mse: 6915.5625\n", + "Epoch 23/100\n", + "2/2 [==============================] - 0s 50ms/step - loss: 12538.0781 - mse: 12538.0781 - val_loss: 6908.1865 - val_mse: 6908.1865\n", + "Epoch 24/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12543.6709 - mse: 12543.6709 - val_loss: 6900.8511 - val_mse: 6900.8511\n", + "Epoch 25/100\n", + "2/2 [==============================] - 0s 46ms/step - loss: 12539.5977 - mse: 12539.5977 - val_loss: 6894.5586 - val_mse: 6894.5586\n", + "Epoch 26/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12539.6719 - mse: 12539.6719 - val_loss: 6887.9038 - val_mse: 6887.9038\n", + "Epoch 27/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12538.1367 - mse: 12538.1367 - val_loss: 6881.5728 - val_mse: 6881.5728\n", + "Epoch 28/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12542.5918 - mse: 12542.5918 - val_loss: 6875.3584 - val_mse: 6875.3584\n", + "Epoch 29/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12533.7070 - mse: 12533.7070 - val_loss: 6869.7583 - val_mse: 6869.7583\n", + "Epoch 30/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12548.0664 - mse: 12548.0664 - val_loss: 6863.9131 - val_mse: 6863.9131\n", + "Epoch 31/100\n", + "2/2 [==============================] - 0s 47ms/step - loss: 12532.1807 - mse: 12532.1807 - val_loss: 6858.8984 - val_mse: 6858.8984\n", + "Epoch 32/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12531.9277 - mse: 12531.9277 - val_loss: 6854.0508 - val_mse: 6854.0508\n", + "Epoch 33/100\n", + "2/2 [==============================] - 0s 59ms/step - loss: 12537.1016 - mse: 12537.1016 - val_loss: 6849.8359 - val_mse: 6849.8359\n", + "Epoch 34/100\n", + "2/2 [==============================] - 0s 38ms/step - loss: 12532.6133 - mse: 12532.6133 - val_loss: 6845.2505 - val_mse: 6845.2505\n", + "Epoch 35/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12538.8633 - mse: 12538.8633 - val_loss: 6840.6216 - val_mse: 6840.6216\n", + "Epoch 36/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12531.0820 - mse: 12531.0820 - val_loss: 6836.4883 - val_mse: 6836.4883\n", + "Epoch 37/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12533.3271 - mse: 12533.3271 - val_loss: 6832.3882 - val_mse: 6832.3882\n", + "Epoch 38/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12530.0039 - mse: 12530.0039 - val_loss: 6828.8008 - val_mse: 6828.8008\n", + "Epoch 39/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12529.7305 - mse: 12529.7305 - val_loss: 6825.2300 - val_mse: 6825.2300\n", + "Epoch 40/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12532.9531 - mse: 12532.9531 - val_loss: 6822.1538 - val_mse: 6822.1538\n", + "Epoch 41/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12545.0898 - mse: 12545.0898 - val_loss: 6819.2314 - val_mse: 6819.2314\n", + "Epoch 42/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12530.6523 - mse: 12530.6523 - val_loss: 6815.5562 - val_mse: 6815.5562\n", + "Epoch 43/100\n", + "2/2 [==============================] - 0s 40ms/step - loss: 12526.3711 - mse: 12526.3711 - val_loss: 6809.5137 - val_mse: 6809.5137\n", + "Epoch 44/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12515.4746 - mse: 12515.4746 - val_loss: 6797.6768 - val_mse: 6797.6768\n", + "Epoch 45/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12492.8398 - mse: 12492.8398 - val_loss: 6772.5537 - val_mse: 6772.5537\n", + "Epoch 46/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12305.8164 - mse: 12305.8164 - val_loss: 6718.9775 - val_mse: 6718.9775\n", + "Epoch 47/100\n", + "2/2 [==============================] - 0s 40ms/step - loss: 11177.3145 - mse: 11177.3145 - val_loss: 38427.1367 - val_mse: 38427.1367\n", + "Epoch 48/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 37039.4844 - mse: 37039.4844 - val_loss: 12114.6426 - val_mse: 12114.6426\n", + "Epoch 49/100\n", + "2/2 [==============================] - 0s 46ms/step - loss: 379740.7188 - mse: 379740.7188 - val_loss: 6984.1729 - val_mse: 6984.1729\n", + "Epoch 50/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12546.5430 - mse: 12546.5430 - val_loss: 6973.8364 - val_mse: 6973.8364\n", + "Epoch 51/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12557.4473 - mse: 12557.4473 - val_loss: 6963.4180 - val_mse: 6963.4180\n", + "Epoch 52/100\n", + "2/2 [==============================] - 0s 47ms/step - loss: 12543.7080 - mse: 12543.7080 - val_loss: 6954.1152 - val_mse: 6954.1152\n", + "Epoch 53/100\n", + "2/2 [==============================] - 0s 76ms/step - loss: 12544.0078 - mse: 12544.0078 - val_loss: 6945.3711 - val_mse: 6945.3711\n", + "Epoch 54/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12556.0166 - mse: 12556.0166 - val_loss: 6937.4219 - val_mse: 6937.4219\n", + "Epoch 55/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12555.8555 - mse: 12555.8555 - val_loss: 6929.8418 - val_mse: 6929.8418\n", + "Epoch 56/100\n", + "2/2 [==============================] - 0s 46ms/step - loss: 12539.0918 - mse: 12539.0918 - val_loss: 6921.9487 - val_mse: 6921.9487\n", + "Epoch 57/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12545.1680 - mse: 12545.1680 - val_loss: 6914.0068 - val_mse: 6914.0068\n", + "Epoch 58/100\n", + "2/2 [==============================] - 0s 48ms/step - loss: 12538.1182 - mse: 12538.1182 - val_loss: 6906.6826 - val_mse: 6906.6826\n", + "Epoch 59/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12536.4043 - mse: 12536.4043 - val_loss: 6899.8540 - val_mse: 6899.8540\n", + "Epoch 60/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12545.4170 - mse: 12545.4170 - val_loss: 6893.7852 - val_mse: 6893.7852\n", + "Epoch 61/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12540.1338 - mse: 12540.1338 - val_loss: 6887.1465 - val_mse: 6887.1465\n", + "Epoch 62/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12535.9805 - mse: 12535.9805 - val_loss: 6881.3438 - val_mse: 6881.3438\n", + "Epoch 63/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12533.7822 - mse: 12533.7822 - val_loss: 6875.5820 - val_mse: 6875.5820\n", + "Epoch 64/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12534.3340 - mse: 12534.3340 - val_loss: 6869.9229 - val_mse: 6869.9229\n", + "Epoch 65/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12544.7490 - mse: 12544.7490 - val_loss: 6864.1406 - val_mse: 6864.1406\n", + "Epoch 66/100\n", + "2/2 [==============================] - 0s 48ms/step - loss: 12532.7070 - mse: 12532.7070 - val_loss: 6859.2402 - val_mse: 6859.2402\n", + "Epoch 67/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12540.0264 - mse: 12540.0264 - val_loss: 6854.8760 - val_mse: 6854.8760\n", + "Epoch 68/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12532.3975 - mse: 12532.3975 - val_loss: 6850.1201 - val_mse: 6850.1201\n", + "Epoch 69/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12539.5771 - mse: 12539.5771 - val_loss: 6846.1504 - val_mse: 6846.1504\n", + "Epoch 70/100\n", + "2/2 [==============================] - 0s 48ms/step - loss: 12534.7676 - mse: 12534.7676 - val_loss: 6842.2109 - val_mse: 6842.2109\n", + "Epoch 71/100\n", + "2/2 [==============================] - 0s 47ms/step - loss: 12535.3730 - mse: 12535.3730 - val_loss: 6837.8101 - val_mse: 6837.8101\n", + "Epoch 72/100\n", + "2/2 [==============================] - 0s 40ms/step - loss: 12530.4844 - mse: 12530.4844 - val_loss: 6834.0049 - val_mse: 6834.0049\n", + "Epoch 73/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12535.9141 - mse: 12535.9141 - val_loss: 6830.6431 - val_mse: 6830.6431\n", + "Epoch 74/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12529.7637 - mse: 12529.7637 - val_loss: 6827.0908 - val_mse: 6827.0908\n", + "Epoch 75/100\n", + "2/2 [==============================] - 0s 46ms/step - loss: 12537.2832 - mse: 12537.2832 - val_loss: 6824.0693 - val_mse: 6824.0693\n", + "Epoch 76/100\n", + "2/2 [==============================] - 0s 46ms/step - loss: 12560.0615 - mse: 12560.0615 - val_loss: 6821.5796 - val_mse: 6821.5796\n", + "Epoch 77/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12534.9043 - mse: 12534.9043 - val_loss: 6818.0249 - val_mse: 6818.0249\n", + "Epoch 78/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12530.1738 - mse: 12530.1738 - val_loss: 6814.8101 - val_mse: 6814.8101\n", + "Epoch 79/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12530.2627 - mse: 12530.2627 - val_loss: 6811.7124 - val_mse: 6811.7124\n", + "Epoch 80/100\n", + "2/2 [==============================] - 0s 44ms/step - loss: 12531.0273 - mse: 12531.0273 - val_loss: 6809.1479 - val_mse: 6809.1479\n", + "Epoch 81/100\n", + "2/2 [==============================] - 0s 54ms/step - loss: 12528.5293 - mse: 12528.5293 - val_loss: 6806.4868 - val_mse: 6806.4868\n", + "Epoch 82/100\n", + "2/2 [==============================] - 0s 48ms/step - loss: 12528.3770 - mse: 12528.3770 - val_loss: 6803.9165 - val_mse: 6803.9165\n", + "Epoch 83/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12530.9883 - mse: 12530.9883 - val_loss: 6801.2090 - val_mse: 6801.2090\n", + "Epoch 84/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12528.4297 - mse: 12528.4297 - val_loss: 6798.7744 - val_mse: 6798.7744\n", + "Epoch 85/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12542.8262 - mse: 12542.8262 - val_loss: 6797.0767 - val_mse: 6797.0767\n", + "Epoch 86/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12527.9600 - mse: 12527.9600 - val_loss: 6794.8916 - val_mse: 6794.8916\n", + "Epoch 87/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12527.9473 - mse: 12527.9473 - val_loss: 6792.7568 - val_mse: 6792.7568\n", + "Epoch 88/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12532.5371 - mse: 12532.5371 - val_loss: 6790.4355 - val_mse: 6790.4355\n", + "Epoch 89/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12530.3691 - mse: 12530.3691 - val_loss: 6788.7583 - val_mse: 6788.7583\n", + "Epoch 90/100\n", + "2/2 [==============================] - 0s 42ms/step - loss: 12536.0205 - mse: 12536.0205 - val_loss: 6786.4990 - val_mse: 6786.4990\n", + "Epoch 91/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12528.2305 - mse: 12528.2305 - val_loss: 6784.8643 - val_mse: 6784.8643\n", + "Epoch 92/100\n", + "2/2 [==============================] - 0s 45ms/step - loss: 12538.0020 - mse: 12538.0020 - val_loss: 6782.7163 - val_mse: 6782.7163\n", + "Epoch 93/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12529.5488 - mse: 12529.5488 - val_loss: 6780.9121 - val_mse: 6780.9121\n", + "Epoch 94/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12530.9824 - mse: 12530.9824 - val_loss: 6779.1187 - val_mse: 6779.1187\n", + "Epoch 95/100\n", + "2/2 [==============================] - 0s 46ms/step - loss: 12529.6895 - mse: 12529.6895 - val_loss: 6777.8877 - val_mse: 6777.8877\n", + "Epoch 96/100\n", + "2/2 [==============================] - 0s 40ms/step - loss: 12530.5879 - mse: 12530.5879 - val_loss: 6776.2295 - val_mse: 6776.2295\n", + "Epoch 97/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12527.2910 - mse: 12527.2910 - val_loss: 6774.9199 - val_mse: 6774.9199\n", + "Epoch 98/100\n", + "2/2 [==============================] - 0s 43ms/step - loss: 12533.8867 - mse: 12533.8867 - val_loss: 6774.0078 - val_mse: 6774.0078\n", + "Epoch 99/100\n", + "2/2 [==============================] - 0s 41ms/step - loss: 12530.3994 - mse: 12530.3994 - val_loss: 6772.5107 - val_mse: 6772.5107\n", + "Epoch 100/100\n", + "2/2 [==============================] - 0s 50ms/step - loss: 12527.2217 - mse: 12527.2217 - val_loss: 6771.3604 - val_mse: 6771.3604\n" + ] + } + ], + "source": [ + "results=model.fit(x_train,y_train,epochs=100,validation_split=0.2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jmeP6vt3z0oA" + }, + "source": [ + "## Plot Loss\n", + "\n", + "Using matplotlib visualise how the loss (both validation and training) is changing, use this information to retrain the model with appropriate parameters.
We ideally want the loss to be constant over the last few iterations." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "id": "RQTNqPHm0mOi", + "outputId": "a2aa2f5d-d682-4afa-b3e9-457edfd64ccd" + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
lossmseval_lossval_mseepoch
9512530.58789112530.5878916776.2294926776.22949295
9612527.29101612527.2910166774.9199226774.91992296
9712533.88671912533.8867196774.0078126774.00781297
9812530.39941412530.3994146772.5107426772.51074298
9912527.22168012527.2216806771.3603526771.36035299
\n", + "
" + ], + "text/plain": [ + " loss mse val_loss val_mse epoch\n", + "95 12530.587891 12530.587891 6776.229492 6776.229492 95\n", + "96 12527.291016 12527.291016 6774.919922 6774.919922 96\n", + "97 12533.886719 12533.886719 6774.007812 6774.007812 97\n", + "98 12530.399414 12530.399414 6772.510742 6772.510742 98\n", + "99 12527.221680 12527.221680 6771.360352 6771.360352 99" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "res=pd.DataFrame(results.history)\n", + "res['epoch']=results.epoch\n", + "res.tail()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "ubeaG8e9t7im", + "outputId": "f763ebb3-d143-484d-b333-ccda2479bdb7" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(res['epoch'],res['loss'])\n", + "plt.plot(res['epoch'],res['val_loss'])\n", + "plt.legend([\"Loss\",\"Val_Loss\"])\n", + "# plt.xlim(0,80)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IVrR_vXA7kOt" + }, + "source": [ + "## Evaluation Metrics\n", + "Use the R2 Score function implemented in the first assignment to evaluate the performance of the model." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "id": "-lOHpD8-7ggm" + }, + "outputs": [], + "source": [ + "# Insert the function for R2 Score\n", + "\n", + "def r2_score_predictor(y_true,y_pred):\n", + " from sklearn.metrics import r2_score\n", + " r=r2_score(y_true,y_pred)\n", + " return r\n", + "predictions=model.predict(x_test)\n", + "r=r2_score_predictor(y_test,predictions)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "SCApVNjtzbv8", + "outputId": "f108f6c9-9479-442a-f7f4-2c087c3986da" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The r2_score value is -0.0909121073526411\n" + ] + } + ], + "source": [ + "print(\"The r2_score value is \",r)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CHqzF1OU0pBg" + }, + "source": [ + "## Your own custom model\n", + "Build a custom model of your own choice.
\n", + "Describe it in detail in Markdown/Latex in the cell below.
\n", + "Visualise the loss, as before." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jF8oTUqq0y0g" + }, + "source": [ + "Your text here" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn import datasets\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "# Generate the data\n", + "x_2, y_2 = datasets.make_regression(n_samples=1000, n_features=5, noise=5, random_state=4)\n", + "\n", + "\n", + "# Split the data\n", + "x_train_2, x_test_2, y_train_2, y_test_2 = train_test_split(x_2, y_2, test_size=0.2, random_state=1234)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Instead of using SGD optimizer we can use Adam optimizer to get better results." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "1XOk5hJu0oSQ" + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "model_2=tf.keras.models.Sequential([\n", + " tf.keras.layers.InputLayer(input_shape=5) ,\n", + " tf.keras.layers.Dense(30,activation='relu'),\n", + " tf.keras.layers.Dense(30,activation='relu'),\n", + " tf.keras.layers.Dense(1)\n", + "\n", + " ])\n", + "\n", + "optimi=tf.keras.optimizers.Adam( learning_rate=0.01)\n", + "\n", + "\n", + "model_2.compile(loss='mean_squared_error',optimizer=optimi,metrics=tf.keras.metrics.Accuracy())\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " dense (Dense) (None, 30) 180 \n", + " \n", + " dense_1 (Dense) (None, 30) 930 \n", + " \n", + " dense_2 (Dense) (None, 1) 31 \n", + " \n", + "=================================================================\n", + "Total params: 1,141\n", + "Trainable params: 1,141\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "model_2.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "aS0ROZa402Lo", + "outputId": "c852055e-ec4f-4272-ad30-e068b76c623f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/20\n", + "20/20 [==============================] - 1s 17ms/step - loss: 22293.0352 - accuracy: 0.0000e+00 - val_loss: 22968.2930 - val_accuracy: 0.0000e+00\n", + "Epoch 2/20\n", + "20/20 [==============================] - 0s 5ms/step - loss: 16845.7617 - accuracy: 0.0000e+00 - val_loss: 11418.9531 - val_accuracy: 0.0000e+00\n", + "Epoch 3/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 4155.4365 - accuracy: 0.0000e+00 - val_loss: 745.3987 - val_accuracy: 0.0000e+00\n", + "Epoch 4/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 621.0253 - accuracy: 0.0000e+00 - val_loss: 412.5599 - val_accuracy: 0.0000e+00\n", + "Epoch 5/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 308.1701 - accuracy: 0.0000e+00 - val_loss: 312.2416 - val_accuracy: 0.0000e+00\n", + "Epoch 6/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 240.7342 - accuracy: 0.0000e+00 - val_loss: 267.2795 - val_accuracy: 0.0000e+00\n", + "Epoch 7/20\n", + "20/20 [==============================] - 0s 5ms/step - loss: 207.0453 - accuracy: 0.0000e+00 - val_loss: 246.7999 - val_accuracy: 0.0000e+00\n", + "Epoch 8/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 185.6382 - accuracy: 0.0000e+00 - val_loss: 233.2929 - val_accuracy: 0.0000e+00\n", + "Epoch 9/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 172.4978 - accuracy: 0.0000e+00 - val_loss: 238.8235 - val_accuracy: 0.0000e+00\n", + "Epoch 10/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 154.8446 - accuracy: 0.0000e+00 - val_loss: 173.0536 - val_accuracy: 0.0000e+00\n", + "Epoch 11/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 129.1207 - accuracy: 0.0000e+00 - val_loss: 134.6592 - val_accuracy: 0.0000e+00\n", + "Epoch 12/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 121.6438 - accuracy: 0.0000e+00 - val_loss: 122.1448 - val_accuracy: 0.0000e+00\n", + "Epoch 13/20\n", + "20/20 [==============================] - 0s 5ms/step - loss: 100.9714 - accuracy: 0.0000e+00 - val_loss: 108.3006 - val_accuracy: 0.0000e+00\n", + "Epoch 14/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 88.0066 - accuracy: 0.0000e+00 - val_loss: 93.5628 - val_accuracy: 0.0000e+00\n", + "Epoch 15/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 74.2823 - accuracy: 0.0000e+00 - val_loss: 83.5923 - val_accuracy: 0.0000e+00\n", + "Epoch 16/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 67.1191 - accuracy: 0.0000e+00 - val_loss: 84.6325 - val_accuracy: 0.0000e+00\n", + "Epoch 17/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 59.6604 - accuracy: 0.0000e+00 - val_loss: 64.3586 - val_accuracy: 0.0000e+00\n", + "Epoch 18/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 50.1667 - accuracy: 0.0000e+00 - val_loss: 57.6406 - val_accuracy: 0.0000e+00\n", + "Epoch 19/20\n", + "20/20 [==============================] - 0s 8ms/step - loss: 45.9919 - accuracy: 0.0000e+00 - val_loss: 50.3901 - val_accuracy: 0.0000e+00\n", + "Epoch 20/20\n", + "20/20 [==============================] - 0s 4ms/step - loss: 43.3895 - accuracy: 0.0000e+00 - val_loss: 46.8216 - val_accuracy: 0.0000e+00\n" + ] + } + ], + "source": [ + "results_2=model_2.fit(x_train_2,y_train_2,epochs=20,validation_split=0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "id": "-v9c8bWtxbgP", + "outputId": "19e97d03-36e9-4893-ace2-3da787fe8f49" + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
lossaccuracyval_lossval_accuracyepoch
1567.1190570.084.6324620.015
1659.6604310.064.3586040.016
1750.1667180.057.6405750.017
1845.9919090.050.3900990.018
1943.3894840.046.8216480.019
\n", + "
" + ], + "text/plain": [ + " loss accuracy val_loss val_accuracy epoch\n", + "15 67.119057 0.0 84.632462 0.0 15\n", + "16 59.660431 0.0 64.358604 0.0 16\n", + "17 50.166718 0.0 57.640575 0.0 17\n", + "18 45.991909 0.0 50.390099 0.0 18\n", + "19 43.389484 0.0 46.821648 0.0 19" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "res_2=pd.DataFrame(results_2.history)\n", + "res_2['epoch']=results_2.epoch\n", + "res_2.tail()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "6xWw8yxhxxmt", + "outputId": "4acfcf6e-3e59-48e7-fabe-3bac990417b3" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(res_2['epoch'],res_2['loss'])\n", + "plt.plot(res_2['epoch'],res_2['val_loss'])\n", + "plt.legend([\"Val_Loss\",\"Loss\"])\n", + "# plt.xlim(0,80)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "id": "FeWhnbAV0PUX" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "r2_score is 0.9978912555372441\n" + ] + } + ], + "source": [ + "# R2 score calculation\n", + "\n", + "from sklearn.metrics import r2_score\n", + "predic=model_2.predict(x_test_2)\n", + "r2_sco=r2_score(y_test_2,predic)\n", + "print(\"r2_score is \",r2_sco)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "r2_score coming close to 1 signify that our model is performing very well on the test data set ." + ] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "Copy of CVusingTF_Assgn2.ipynb", + "provenance": [] + }, + "interpreter": { + "hash": "d32dd9972e4becc079854756227bbaf57600491c52d25499cfd0dde1c0f41dcc" + }, + "kernelspec": { + "display_name": "Python 3.9.6 64-bit", + "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.9.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From 7d2e204e9f9581de1d06bcde032412ad0243c26a Mon Sep 17 00:00:00 2001 From: Abhay-sisodia <84870507+Abhay-sisodia@users.noreply.github.com> Date: Thu, 23 Jun 2022 12:48:33 +0530 Subject: [PATCH 7/8] Add files via upload --- Assignment 3/A3_200014.ipynb | 502 +++++++++++++++++++++++++++++++++++ 1 file changed, 502 insertions(+) create mode 100644 Assignment 3/A3_200014.ipynb diff --git a/Assignment 3/A3_200014.ipynb b/Assignment 3/A3_200014.ipynb new file mode 100644 index 0000000..4b79740 --- /dev/null +++ b/Assignment 3/A3_200014.ipynb @@ -0,0 +1,502 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Copy of CV_with_TF-Assignment-3.ipynb", + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU", + "gpuClass": "standard" + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Assignment 3\n", + "\n", + " In this Assignment, we will use CNN to classify digits. \n", + "The `MNIST` database is a large database of handwritten digits that is commonly used for training various image processing systems.\n", + "\n" + ], + "metadata": { + "id": "VGHh_5UYzKpV" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Importing TensorFlow" + ], + "metadata": { + "id": "JnsMbCPNzPAr" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "HRLTw3cMwvi7" + }, + "outputs": [], + "source": [ + "import tensorflow as tf" + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Get the dataset" + ], + "metadata": { + "id": "6Ji7HGpgzSPi" + } + }, + { + "cell_type": "code", + "source": [ + "# Import the dataset\n", + "\n", + "(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()" + ], + "metadata": { + "id": "oEW3KDEvzIHL" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Split the dataset\n", + "\n", + "from sklearn.model_selection import train_test_split\n", + "X_train,X_test,Y_train,Y_test=train_test_split(x_test,y_test,test_size=0.2)" + ], + "metadata": { + "id": "F_sRU9dx_mYQ" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Visualize the dataset\n", + "Print some images with labels." + ], + "metadata": { + "id": "EVpQheoVqoEG" + } + }, + { + "cell_type": "code", + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "for i in range(5):\n", + " plt.subplot(2,5, i+1)\n", + " plt.imshow(x_train[i])\n", + " plt.axis('off')\n", + " plt.title(\"Value is {}\".format(y_train[i]))\n", + "\n", + "# Your code" + ], + "metadata": { + "id": "yF1Nj63Bz9m7", + "outputId": "8472897d-ca54-43af-eaf4-f7e558618dcb", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 105 + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Plot statistics of the training and testing dataset \n", + "(`x axis`: digits, `y axis`: number of samples corresponding to the digits)" + ], + "metadata": { + "id": "Rx8muKSIrKhe" + } + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import pandas as pd" + ], + "metadata": { + "id": "y2OEVvv8S5Na" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "\n", + "\n", + "df_y_train = pd.DataFrame({'Y_Train':y_train})\n", + "df_y_test = pd.DataFrame({'Y_Test':y_test})\n", + "\n", + "# Your code" + ], + "metadata": { + "id": "37kehTG_6Pi4" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Given below is the code that produces frequency of labels appearing in training dataset\n", + "df_y_train['Y_Train'].value_counts(ascending=True).plot( kind='bar', xlabel='Values', ylabel='Frequency')\n" + ], + "metadata": { + "id": "UkbVDV9JTJNP", + "outputId": "48d31ac7-cb24-4e9d-cfb3-7bf53e0386a2", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 295 + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 38 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "df_y_test['Y_Test'].value_counts(ascending=True).plot( kind='bar', xlabel='Values', ylabel='Frequency')" + ], + "metadata": { + "id": "wdLMufuQT_Nn", + "outputId": "ef0c6a1a-91db-4dfd-88af-0d34cc90b442", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 294 + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 39 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "So we can see that the frequency of labels in the test dataset are in same proportion as in the training dataset." + ], + "metadata": { + "id": "l9_l4idBUwbu" + } + }, + { + "cell_type": "code", + "source": [ + "# Pre Processing\n", + "\n", + "from tensorflow.keras.utils import to_categorical\n", + "from tensorflow.keras.layers import Flatten, Dense\n", + "from tensorflow.keras.losses import BinaryCrossentropy,sparse_categorical_crossentropy\n", + "\n", + "x_train = tf.keras.utils.normalize(x_train, axis=1)\n", + "x_test = tf.keras.utils.normalize(x_test, axis=1)" + ], + "metadata": { + "id": "LWtaJGgMVG_c" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Model" + ], + "metadata": { + "id": "kWlpCWdAr8d3" + } + }, + { + "cell_type": "code", + "source": [ + "# model building\n", + "model=tf.keras.Sequential([\n", + " Flatten(input_shape=(28,28)),\n", + " Dense(64,activation='relu'),\n", + " Dense(128,activation='relu'),\n", + " Dense(10,activation=tf.nn.softmax)\n", + "\n", + " ])\n", + "model.compile(optimizer='adam',\n", + " loss=sparse_categorical_crossentropy,\n", + " metrics=['accuracy'])\n", + "history = model.fit(x_train,y_train,epochs=10,validation_split=0.2)\n", + "\n", + "# You are supposed to look at some CNN architectures and add convolutional layers along with MaxPooling, specifying the kernel size, pooling size, activation \n" + ], + "metadata": { + "id": "1L07EyQ0Yion", + "outputId": "29b951f2-5843-44ca-8ffa-e5def844ecb4", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/10\n", + "1500/1500 [==============================] - 4s 3ms/step - loss: 0.3446 - accuracy: 0.8994 - val_loss: 0.1907 - val_accuracy: 0.9445\n", + "Epoch 2/10\n", + "1500/1500 [==============================] - 4s 3ms/step - loss: 0.1507 - accuracy: 0.9546 - val_loss: 0.1450 - val_accuracy: 0.9535\n", + "Epoch 3/10\n", + "1500/1500 [==============================] - 4s 2ms/step - loss: 0.1059 - accuracy: 0.9678 - val_loss: 0.1205 - val_accuracy: 0.9625\n", + "Epoch 4/10\n", + "1500/1500 [==============================] - 4s 3ms/step - loss: 0.0800 - accuracy: 0.9747 - val_loss: 0.1160 - val_accuracy: 0.9646\n", + "Epoch 5/10\n", + "1500/1500 [==============================] - 4s 3ms/step - loss: 0.0639 - accuracy: 0.9796 - val_loss: 0.1037 - val_accuracy: 0.9676\n", + "Epoch 6/10\n", + "1500/1500 [==============================] - 4s 3ms/step - loss: 0.0506 - accuracy: 0.9835 - val_loss: 0.1033 - val_accuracy: 0.9695\n", + "Epoch 7/10\n", + "1500/1500 [==============================] - 4s 3ms/step - loss: 0.0409 - accuracy: 0.9864 - val_loss: 0.1085 - val_accuracy: 0.9713\n", + "Epoch 8/10\n", + "1500/1500 [==============================] - 4s 2ms/step - loss: 0.0336 - accuracy: 0.9889 - val_loss: 0.1076 - val_accuracy: 0.9718\n", + "Epoch 9/10\n", + "1500/1500 [==============================] - 4s 2ms/step - loss: 0.0281 - accuracy: 0.9908 - val_loss: 0.1215 - val_accuracy: 0.9694\n", + "Epoch 10/10\n", + "1500/1500 [==============================] - 4s 3ms/step - loss: 0.0237 - accuracy: 0.9920 - val_loss: 0.1258 - val_accuracy: 0.9699\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "res_2=pd.DataFrame(history.history)\n", + "res_2['epoch']=history.epoch\n", + "plt.plot(res_2['epoch'],res_2['loss'])\n", + "plt.plot(res_2['epoch'],res_2['val_loss'])\n", + "plt.legend([\"Loss\"],[\"Val_loss\"])\n", + "\n" + ], + "metadata": { + "id": "nKEZ8cbO9JVV", + "outputId": "6dba2cd9-d2d3-4b05-fc4b-b8cb83f4be2e", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 374 + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:5: UserWarning: Legend does not support 'Loss' instances.\n", + "A proxy artist may be used instead.\n", + "See: http://matplotlib.org/users/legend_guide.html#creating-artists-specifically-for-adding-to-the-legend-aka-proxy-artists\n", + " \"\"\"\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 44 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Predict some images\n", + "Print the image along with its label (true value) and predicted value." + ], + "metadata": { + "id": "ml1Kna_DuJrL" + } + }, + { + "cell_type": "code", + "source": [ + "# Your code\n", + "y_predicted=[]\n", + "y_pred=model.predict(x_test)\n", + "for i in range(x_test.shape[0]):\n", + " y_predicted.append(np.argmax(y_pred[i]))\n" + ], + "metadata": { + "id": "qioZul7_uiYq" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "y_test[7]" + ], + "metadata": { + "id": "3rJt9b5-Y-9H", + "outputId": "91639e31-57f4-44a7-8045-4fa8e179b10b", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "9" + ] + }, + "metadata": {}, + "execution_count": 62 + } + ] + }, + { + "cell_type": "code", + "source": [ + "t=7\n", + "plt.imshow(x_test[t])\n", + "plt.title(\"Actual Label {} , Predicted label {} \".format(y_test[t],y_predicted[t]))" + ], + "metadata": { + "id": "hcaYkm8TXZ-h", + "outputId": "91c92df2-8314-40ea-f509-815a56ca0440", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 299 + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Actual Label 9 , Predicted label 9 ')" + ] + }, + "metadata": {}, + "execution_count": 68 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "" + ], + "metadata": { + "id": "ruZ4gQP7YSI5" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file From a5e03dcf157417a7f00c14d1bd86db33071879f2 Mon Sep 17 00:00:00 2001 From: Abhay-sisodia <84870507+Abhay-sisodia@users.noreply.github.com> Date: Sat, 16 Jul 2022 00:34:15 +0530 Subject: [PATCH 8/8] Add files via upload --- Final Task/A4_200014.ipynb | 1271 ++++++++++++++++++++++++++++++++++++ 1 file changed, 1271 insertions(+) create mode 100644 Final Task/A4_200014.ipynb diff --git a/Final Task/A4_200014.ipynb b/Final Task/A4_200014.ipynb new file mode 100644 index 0000000..2d1e698 --- /dev/null +++ b/Final Task/A4_200014.ipynb @@ -0,0 +1,1271 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "A4_200014.ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU", + "gpuClass": "standard" + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "## Final Task:\n", + "This is your final evaluation for the project. As decided, we will be predicting images of people into three classes: `without_mask`, `mask_weared_incorrect` and `with_mask`. " + ], + "metadata": { + "id": "rtI19Rt-H7Uc" + } + }, + { + "cell_type": "code", + "source": [ + "import tensorflow as tf" + ], + "metadata": { + "id": "c2CiXcHQTbX8" + }, + "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Loading the dataset\n", + "Make a copy of the dataset given to you in your Google Drive (keep it outside, don't put it in any folder to avoid inconvenience). Ensure it is named as `Mask_Dataset` or change the path (the variable `data_dir`) accordingly." + ], + "metadata": { + "id": "QKDPyiZTIm1c" + } + }, + { + "cell_type": "code", + "source": [ + "# Mount Google Drive\n", + "from google.colab import drive\n", + "drive.mount('/content/drive')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "hNEMe7XsIjrK", + "outputId": "25ea253f-323b-46e1-fba5-9c21d021bda5" + }, + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /content/drive\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import pathlib\n", + "\n", + "# path='/content/drive/MyDrive/Mask_Dataset/'\n", + "path='/content/drive/MyDrive/ABHAY SISODIA/Mask_Dataset/'\n", + "data_dir = pathlib.Path(path)" + ], + "metadata": { + "id": "8CXzo4MOJOl8" + }, + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "data_dir" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "YtR6XqWbDaFx", + "outputId": "b422c75e-cc0b-4955-a974-fc588e570be2" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "PosixPath('/content/drive/MyDrive/ABHAY SISODIA/Mask_Dataset')" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Know the Dataset\n", + "Most of the code is written for you as you aren't used to these libraries. You are to go through the documentation for your benefit." + ], + "metadata": { + "id": "YHPHkGyDKscK" + } + }, + { + "cell_type": "code", + "source": [ + "# Print image count\n", + "image_count = len(list(data_dir.glob('*/*.png')))\n", + "print(image_count)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "PzbSy-vXKjD-", + "outputId": "1cbf2350-a312-402e-b560-0f8167d01c59" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "8982\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import drive\n", + "drive.mount('/content/drive')" + ], + "metadata": { + "id": "tTfqUxhXa6zK", + "outputId": "1c66155b-21ef-4ccd-e07a-f220f0f7be0a", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Print Output Labels\n", + "import os\n", + "output_classes = os.listdir(data_dir)\n", + "print(output_classes)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "rFHWFYj5NCVm", + "outputId": "2274e718-ba0e-43ac-e2bb-93f83528d2ad" + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "['without_mask', 'mask_weared_incorrect', 'with_mask']\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Plot count of each ouput label\n", + "import matplotlib.pyplot as plt\n", + "\n", + "count=[]\n", + "for label in output_classes:\n", + " this_path=path+label\n", + " dir=pathlib.Path(this_path)\n", + " im_count=os.listdir(dir)\n", + " count.append(len(im_count))\n", + "\n", + "print(count)\n", + "\n", + "plt.bar(output_classes,count)\n", + "plt.title(\"Statistics\")\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 300 + }, + "id": "fESyMw90KaxN", + "outputId": "ee5e3669-33cd-404b-aba2-d626610b55c8" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[2994, 2994, 2994]\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "import cv2\n", + "path_new=path+output_classes[2]+'/15.png'\n", + "img = cv2.imread (path_new,1) \n" + ], + "metadata": { + "id": "3D9eZ3e_c9LI" + }, + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "path_new" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 36 + }, + "id": "Z1LxaTIVt_LW", + "outputId": "97e55285-3169-424e-c6b9-7477b68a3912" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'/content/drive/MyDrive/ABHAY SISODIA/Mask_Dataset/with_mask/15.png'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 10 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Check some sample images (Use of cv2)\n", + "import cv2\n", + "from google.colab.patches import cv2_imshow\n", + "cv2_imshow(img)\n", + "# Your code" + ], + "metadata": { + "id": "HDSJ2Zk5a14s", + "outputId": "e2384c31-c150-4bd3-d281-ae80d51575d9", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 145 + } + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "x=img.shape\n", + "x\n", + "# Check shape of the images in your dataset. This will be helpful while specifying input_shape in your Transfer Learning Model" + ], + "metadata": { + "id": "jWBEMC1FUfXS", + "outputId": "7be6f170-4ef7-4f32-a980-02dcf97775cf", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 12, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(128, 128, 3)" + ] + }, + "metadata": {}, + "execution_count": 12 + } + ] + }, + { + "cell_type": "code", + "source": [ + "import random\n", + "for label in output_classes:\n", + " print(label)\n", + " this_path=path+label\n", + " dir=pathlib.Path(this_path)\n", + " im_count=os.listdir(dir)\n", + " rand_no=random.randint(0,2994)\n", + " print(rand_no)\n", + " image = this_path+'/'+im_count[rand_no] #Checking the shape of 3 random images from the 3 different classes and we find all the images have the same shape (128,128,3)\n", + " testing=cv2.imread(image)\n", + " print(testing.shape)\n", + " \n", + " \n" + ], + "metadata": { + "id": "52BhBWRab5yc", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "0d50acdc-41d8-4d3b-f3ac-c67718b0736f" + }, + "execution_count": 13, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "without_mask\n", + "2616\n", + "(128, 128, 3)\n", + "mask_weared_incorrect\n", + "915\n", + "(128, 128, 3)\n", + "with_mask\n", + "919\n", + "(128, 128, 3)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "flag=False\n", + " # for comparison we contain a touple\n", + "\n", + "for label in output_classes:\n", + " this_path=path+label\n", + " dir=pathlib.Path(this_path)\n", + " im_count=os.listdir(dir)\n", + " for i in range(len(im_count)):\n", + " image = this_path+'/'+im_count[i] \n", + " testing=cv2.imread(image)\n", + " if testing.shape!=img.shape:\n", + " flag=True\n", + "\n", + "if(flag):\n", + " print(\"Different sized images are present\")" + ], + "metadata": { + "id": "G-Atau4Rfc-x" + }, + "execution_count": 14, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "\n", + "\n", + "# Anything else you want to plot/experiment" + ], + "metadata": { + "id": "F0XHxMo2RVQd" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Model Definition\n", + "Choose a model for Transfer Learning (You may also experment with multiple models and keep all of them in this notebook)" + ], + "metadata": { + "id": "zSoUXS1cRbnu" + } + }, + { + "cell_type": "code", + "source": [ + "from tensorflow.keras.layers import Input, Lambda, Dense, Flatten\n", + "from tensorflow.keras.models import Model\n", + "from tensorflow.keras.preprocessing import image\n", + "from tensorflow.keras.applications.vgg16 import VGG16\n", + "from tensorflow.keras.applications.vgg19 import VGG19\n", + "from tensorflow.keras.preprocessing.image import ImageDataGenerator,load_img\n", + "from tensorflow.keras.models import Sequential" + ], + "metadata": { + "id": "QKZmIgXMTHfy" + }, + "execution_count": 15, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Choose and define base model\n", + "IMAGE_SIZE = [128, 128]\n", + "vgg16 = VGG16(input_shape=IMAGE_SIZE + [3], weights='imagenet', include_top=False)" + ], + "metadata": { + "id": "9xWLUibHRNGj", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "d6af16df-df01-42fd-8946-607df8a80f69" + }, + "execution_count": 16, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/vgg16/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5\n", + "58892288/58889256 [==============================] - 0s 0us/step\n", + "58900480/58889256 [==============================] - 0s 0us/step\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "vgg16.summary()\n", + "# Print base model summary and have a look at the layers" + ], + "metadata": { + "id": "J3TwB_GLd7BU", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "b215deb4-f9ef-4d6b-f1f2-c795770238ee" + }, + "execution_count": 17, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Model: \"vgg16\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " input_1 (InputLayer) [(None, 128, 128, 3)] 0 \n", + " \n", + " block1_conv1 (Conv2D) (None, 128, 128, 64) 1792 \n", + " \n", + " block1_conv2 (Conv2D) (None, 128, 128, 64) 36928 \n", + " \n", + " block1_pool (MaxPooling2D) (None, 64, 64, 64) 0 \n", + " \n", + " block2_conv1 (Conv2D) (None, 64, 64, 128) 73856 \n", + " \n", + " block2_conv2 (Conv2D) (None, 64, 64, 128) 147584 \n", + " \n", + " block2_pool (MaxPooling2D) (None, 32, 32, 128) 0 \n", + " \n", + " block3_conv1 (Conv2D) (None, 32, 32, 256) 295168 \n", + " \n", + " block3_conv2 (Conv2D) (None, 32, 32, 256) 590080 \n", + " \n", + " block3_conv3 (Conv2D) (None, 32, 32, 256) 590080 \n", + " \n", + " block3_pool (MaxPooling2D) (None, 16, 16, 256) 0 \n", + " \n", + " block4_conv1 (Conv2D) (None, 16, 16, 512) 1180160 \n", + " \n", + " block4_conv2 (Conv2D) (None, 16, 16, 512) 2359808 \n", + " \n", + " block4_conv3 (Conv2D) (None, 16, 16, 512) 2359808 \n", + " \n", + " block4_pool (MaxPooling2D) (None, 8, 8, 512) 0 \n", + " \n", + " block5_conv1 (Conv2D) (None, 8, 8, 512) 2359808 \n", + " \n", + " block5_conv2 (Conv2D) (None, 8, 8, 512) 2359808 \n", + " \n", + " block5_conv3 (Conv2D) (None, 8, 8, 512) 2359808 \n", + " \n", + " block5_pool (MaxPooling2D) (None, 4, 4, 512) 0 \n", + " \n", + "=================================================================\n", + "Total params: 14,714,688\n", + "Trainable params: 14,714,688\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# As we're using Transfer Learning, you do not need to train all the layers. Freeze all of the layers or train some layers (experiment)\n", + "\n", + "for layer in vgg16.layers:\n", + " layer.trainable = False\n" + ], + "metadata": { + "id": "F_Heq3C1eKd-" + }, + "execution_count": 18, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "output_classes" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "piaL6BfmqGfX", + "outputId": "a014672f-32a6-457e-e8c4-4ff413b58490" + }, + "execution_count": 19, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['without_mask', 'mask_weared_incorrect', 'with_mask']" + ] + }, + "metadata": {}, + "execution_count": 19 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Append Fully connected/custom Conv2D/Dropout/MaxPooling layers to the base model\n", + "\n", + "\n", + "inputs = tf.keras.Input(shape=IMAGE_SIZE + [3])\n", + "x = inputs\n", + "x = vgg16(x)\n", + "x = tf.keras.layers.Flatten()(x)\n", + "x = tf.keras.layers.Dense(256)(x)\n", + "x = tf.keras.layers.Dense(256)(x)\n", + "outputs = tf.keras.layers.Dense(3, activation=\"softmax\")(x)\n", + "model = tf.keras.Model(inputs, outputs)\n" + ], + "metadata": { + "id": "MKx1EtUJea6D" + }, + "execution_count": 27, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Add the final output layer\n", + "prediction = Dense(len(output_classes), activation='softmax')(x)\n" + ], + "metadata": { + "id": "lo0mIe8HqUHk" + }, + "execution_count": 29, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Print your model's summary\n", + "model.summary()" + ], + "metadata": { + "id": "6aVQocJwgN5r", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "79d0e4f7-d8b8-416e-8a78-4a8903abacc4" + }, + "execution_count": 30, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Model: \"model\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " input_7 (InputLayer) [(None, 128, 128, 3)] 0 \n", + " \n", + " vgg16 (Functional) (None, 4, 4, 512) 14714688 \n", + " \n", + " flatten (Flatten) (None, 8192) 0 \n", + " \n", + " dense (Dense) (None, 256) 2097408 \n", + " \n", + " dense_1 (Dense) (None, 256) 65792 \n", + " \n", + " dense_2 (Dense) (None, 3) 771 \n", + " \n", + "=================================================================\n", + "Total params: 16,878,659\n", + "Trainable params: 2,163,971\n", + "Non-trainable params: 14,714,688\n", + "_________________________________________________________________\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Compile you model (set the parameters like loss/optimizers/metrics)\n", + "\n", + "model.compile(\n", + " loss='categorical_crossentropy',\n", + " optimizer='adam',\n", + " metrics=['accuracy']\n", + ")" + ], + "metadata": { + "id": "qdC71fUBgXAg" + }, + "execution_count": 31, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Data Augmentation and Pre-processing\n", + "Augment the data. You may also try dyanamic augmentation using [`tf.keras.preprocessing.image.ImageDataGenerator `](https://www.tensorflow.org/api_docs/python/tf/keras/preprocessing/image/ImageDataGenerator). \n", + "You may use [`tf.keras.applications.vgg16.preprocess_input`](https://www.tensorflow.org/api_docs/python/tf/keras/applications/vgg16/preprocess_input)(or some other base model's utility) for pre-processing (can also be passed as a parameter to `ImageDataGenerator`)" + ], + "metadata": { + "id": "RdUSMLggifex" + } + }, + { + "cell_type": "code", + "source": [ + "from keras_preprocessing.image import ImageDataGenerator\n", + "\n", + "label_datagen = ImageDataGenerator( rescale = 1./255, validation_split=0.2)\n", + "\n", + "# Your code " + ], + "metadata": { + "id": "DBscSsvkgn39" + }, + "execution_count": 32, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "from keras.backend import categorical_crossentropy\n", + "# Your code\n", + "train_label_generator = label_datagen.flow_from_directory(\n", + " directory=path,\n", + " target_size=(128,128),\n", + " subset=\"training\",\n", + " class_mode='categorical',\n", + " batch_size=32)\n", + "validation_label_generator = label_datagen.flow_from_directory(\n", + " directory=path,\n", + " target_size=(128,128),\n", + " subset=\"validation\",\n", + " class_mode='categorical',\n", + " batch_size=32)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "dR4JzFe-IKGp", + "outputId": "81a2ccdb-daf1-463c-8ad8-b878b06155e3" + }, + "execution_count": 33, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Found 7188 images belonging to 3 classes.\n", + "Found 1794 images belonging to 3 classes.\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Anything else you wish to try" + ], + "metadata": { + "id": "rhyHEFXDkZr4" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Training and Validation Dataset \n", + "Split the dataset into training and validation (We'll be looking for your validation accuracy, assume we are using complete dataset for now). \n", + "\n", + "Hint: `flow_from_directory` used with `ImageDataGenerator` will simplify things for you." + ], + "metadata": { + "id": "IcKPxCpOkcuG" + } + }, + { + "cell_type": "code", + "source": [ + "# Your code\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "sB7hb3ybkJRq" + }, + "execution_count": 34, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Training \n", + "Train your model for some epochs and plot the graph. Try and save your best model. Experiment with the parameters of `model.fit`" + ], + "metadata": { + "id": "ZZPsjpT1mp3z" + } + }, + { + "cell_type": "code", + "source": [ + "from keras.callbacks import ModelCheckpoint\n", + "\n", + "hist = model.fit(train_label_generator, validation_data=validation_label_generator, epochs=50, batch_size=50)\n", + "\n", + "# ModelCheckpoint is helpful to save the model giving best results (brownie points)" + ], + "metadata": { + "id": "Gs2X14MBmu7W", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "465c98da-17a6-4017-87d5-125d461a7992" + }, + "execution_count": 39, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/50\n", + "225/225 [==============================] - 24s 105ms/step - loss: 0.0168 - accuracy: 0.9951 - val_loss: 0.1409 - val_accuracy: 0.9693\n", + "Epoch 2/50\n", + "225/225 [==============================] - 23s 100ms/step - loss: 0.0030 - accuracy: 0.9989 - val_loss: 0.1305 - val_accuracy: 0.9727\n", + "Epoch 3/50\n", + "225/225 [==============================] - 23s 103ms/step - loss: 0.0019 - accuracy: 0.9993 - val_loss: 0.1150 - val_accuracy: 0.9822\n", + "Epoch 4/50\n", + "225/225 [==============================] - 23s 102ms/step - loss: 0.0015 - accuracy: 0.9996 - val_loss: 0.1538 - val_accuracy: 0.9788\n", + "Epoch 5/50\n", + "225/225 [==============================] - 25s 112ms/step - loss: 6.2750e-04 - accuracy: 0.9999 - val_loss: 0.1324 - val_accuracy: 0.9822\n", + "Epoch 6/50\n", + "225/225 [==============================] - 24s 106ms/step - loss: 5.7412e-04 - accuracy: 0.9999 - val_loss: 0.2892 - val_accuracy: 0.9638\n", + "Epoch 7/50\n", + "225/225 [==============================] - 23s 102ms/step - loss: 0.1654 - accuracy: 0.9734 - val_loss: 0.1862 - val_accuracy: 0.9783\n", + "Epoch 8/50\n", + "225/225 [==============================] - 23s 103ms/step - loss: 0.0120 - accuracy: 0.9964 - val_loss: 0.1658 - val_accuracy: 0.9777\n", + "Epoch 9/50\n", + "225/225 [==============================] - 24s 105ms/step - loss: 0.0023 - accuracy: 0.9994 - val_loss: 0.1932 - val_accuracy: 0.9755\n", + "Epoch 10/50\n", + "225/225 [==============================] - 23s 103ms/step - loss: 0.0013 - accuracy: 0.9997 - val_loss: 0.1685 - val_accuracy: 0.9799\n", + "Epoch 11/50\n", + "225/225 [==============================] - 23s 102ms/step - loss: 0.0021 - accuracy: 0.9992 - val_loss: 0.1510 - val_accuracy: 0.9816\n", + "Epoch 12/50\n", + "225/225 [==============================] - 23s 101ms/step - loss: 4.1410e-04 - accuracy: 1.0000 - val_loss: 0.1585 - val_accuracy: 0.9805\n", + "Epoch 13/50\n", + "225/225 [==============================] - 23s 102ms/step - loss: 7.7258e-04 - accuracy: 0.9999 - val_loss: 0.1744 - val_accuracy: 0.9788\n", + "Epoch 14/50\n", + "225/225 [==============================] - 24s 105ms/step - loss: 0.0061 - accuracy: 0.9985 - val_loss: 0.1402 - val_accuracy: 0.9810\n", + "Epoch 15/50\n", + "225/225 [==============================] - 23s 104ms/step - loss: 0.0118 - accuracy: 0.9968 - val_loss: 0.1318 - val_accuracy: 0.9805\n", + "Epoch 16/50\n", + "225/225 [==============================] - 23s 101ms/step - loss: 0.0794 - accuracy: 0.9834 - val_loss: 0.1231 - val_accuracy: 0.9760\n", + "Epoch 17/50\n", + "225/225 [==============================] - 23s 101ms/step - loss: 0.0245 - accuracy: 0.9944 - val_loss: 0.1348 - val_accuracy: 0.9766\n", + "Epoch 18/50\n", + "225/225 [==============================] - 23s 103ms/step - loss: 0.0045 - accuracy: 0.9985 - val_loss: 0.1885 - val_accuracy: 0.9744\n", + "Epoch 19/50\n", + "225/225 [==============================] - 23s 101ms/step - loss: 5.4151e-04 - accuracy: 1.0000 - val_loss: 0.1103 - val_accuracy: 0.9816\n", + "Epoch 20/50\n", + "225/225 [==============================] - 23s 101ms/step - loss: 2.7351e-04 - accuracy: 1.0000 - val_loss: 0.1178 - val_accuracy: 0.9816\n", + "Epoch 21/50\n", + "225/225 [==============================] - 23s 102ms/step - loss: 1.7116e-04 - accuracy: 1.0000 - val_loss: 0.1311 - val_accuracy: 0.9794\n", + "Epoch 22/50\n", + "225/225 [==============================] - 23s 100ms/step - loss: 8.4379e-04 - accuracy: 0.9997 - val_loss: 0.1103 - val_accuracy: 0.9838\n", + "Epoch 23/50\n", + "225/225 [==============================] - 24s 105ms/step - loss: 6.9733e-05 - accuracy: 1.0000 - val_loss: 0.1107 - val_accuracy: 0.9822\n", + "Epoch 24/50\n", + "225/225 [==============================] - 23s 102ms/step - loss: 4.9248e-05 - accuracy: 1.0000 - val_loss: 0.1210 - val_accuracy: 0.9816\n", + "Epoch 25/50\n", + "225/225 [==============================] - 23s 103ms/step - loss: 4.8405e-05 - accuracy: 1.0000 - val_loss: 0.1150 - val_accuracy: 0.9822\n", + "Epoch 26/50\n", + "225/225 [==============================] - 24s 107ms/step - loss: 4.9266e-05 - accuracy: 1.0000 - val_loss: 0.1254 - val_accuracy: 0.9816\n", + "Epoch 27/50\n", + "225/225 [==============================] - 24s 106ms/step - loss: 3.6202e-05 - accuracy: 1.0000 - val_loss: 0.1350 - val_accuracy: 0.9805\n", + "Epoch 28/50\n", + "225/225 [==============================] - 23s 103ms/step - loss: 3.3287e-05 - accuracy: 1.0000 - val_loss: 0.1198 - val_accuracy: 0.9822\n", + "Epoch 29/50\n", + "225/225 [==============================] - 23s 102ms/step - loss: 2.7000e-05 - accuracy: 1.0000 - val_loss: 0.1259 - val_accuracy: 0.9827\n", + "Epoch 30/50\n", + "225/225 [==============================] - 23s 102ms/step - loss: 2.9736e-05 - accuracy: 1.0000 - val_loss: 0.1317 - val_accuracy: 0.9822\n", + "Epoch 31/50\n", + "225/225 [==============================] - 23s 101ms/step - loss: 1.8315e-05 - accuracy: 1.0000 - val_loss: 0.1324 - val_accuracy: 0.9816\n", + "Epoch 32/50\n", + "225/225 [==============================] - 24s 106ms/step - loss: 2.5222e-05 - accuracy: 1.0000 - val_loss: 0.1487 - val_accuracy: 0.9794\n", + "Epoch 33/50\n", + "225/225 [==============================] - 23s 102ms/step - loss: 3.0340e-05 - accuracy: 1.0000 - val_loss: 0.1420 - val_accuracy: 0.9822\n", + "Epoch 34/50\n", + "225/225 [==============================] - 23s 103ms/step - loss: 1.0325e-05 - accuracy: 1.0000 - val_loss: 0.1453 - val_accuracy: 0.9810\n", + "Epoch 35/50\n", + "225/225 [==============================] - 24s 106ms/step - loss: 1.2105e-05 - accuracy: 1.0000 - val_loss: 0.1478 - val_accuracy: 0.9805\n", + "Epoch 36/50\n", + "225/225 [==============================] - 23s 103ms/step - loss: 0.3126 - accuracy: 0.9738 - val_loss: 0.2008 - val_accuracy: 0.9738\n", + "Epoch 37/50\n", + "225/225 [==============================] - 23s 102ms/step - loss: 0.0142 - accuracy: 0.9958 - val_loss: 0.1976 - val_accuracy: 0.9816\n", + "Epoch 38/50\n", + "225/225 [==============================] - 23s 102ms/step - loss: 0.0067 - accuracy: 0.9974 - val_loss: 0.1769 - val_accuracy: 0.9827\n", + "Epoch 39/50\n", + "225/225 [==============================] - 23s 102ms/step - loss: 9.2064e-04 - accuracy: 0.9997 - val_loss: 0.2281 - val_accuracy: 0.9771\n", + "Epoch 40/50\n", + "225/225 [==============================] - 23s 103ms/step - loss: 1.6477e-04 - accuracy: 1.0000 - val_loss: 0.1589 - val_accuracy: 0.9827\n", + "Epoch 41/50\n", + "225/225 [==============================] - 24s 105ms/step - loss: 4.5712e-05 - accuracy: 1.0000 - val_loss: 0.1556 - val_accuracy: 0.9849\n", + "Epoch 42/50\n", + "225/225 [==============================] - 23s 102ms/step - loss: 2.7562e-05 - accuracy: 1.0000 - val_loss: 0.1583 - val_accuracy: 0.9844\n", + "Epoch 43/50\n", + "225/225 [==============================] - 23s 102ms/step - loss: 2.7383e-05 - accuracy: 1.0000 - val_loss: 0.1588 - val_accuracy: 0.9838\n", + "Epoch 44/50\n", + "225/225 [==============================] - 22s 99ms/step - loss: 2.5726e-05 - accuracy: 1.0000 - val_loss: 0.1596 - val_accuracy: 0.9838\n", + "Epoch 45/50\n", + "225/225 [==============================] - 24s 105ms/step - loss: 2.1448e-05 - accuracy: 1.0000 - val_loss: 0.1614 - val_accuracy: 0.9838\n", + "Epoch 46/50\n", + "225/225 [==============================] - 23s 101ms/step - loss: 1.9031e-05 - accuracy: 1.0000 - val_loss: 0.1629 - val_accuracy: 0.9827\n", + "Epoch 47/50\n", + "225/225 [==============================] - 22s 100ms/step - loss: 1.8846e-05 - accuracy: 1.0000 - val_loss: 0.1600 - val_accuracy: 0.9849\n", + "Epoch 48/50\n", + "225/225 [==============================] - 22s 98ms/step - loss: 1.6371e-05 - accuracy: 1.0000 - val_loss: 0.1637 - val_accuracy: 0.9838\n", + "Epoch 49/50\n", + "225/225 [==============================] - 23s 104ms/step - loss: 1.6302e-05 - accuracy: 1.0000 - val_loss: 0.1608 - val_accuracy: 0.9844\n", + "Epoch 50/50\n", + "225/225 [==============================] - 23s 103ms/step - loss: 1.2676e-05 - accuracy: 1.0000 - val_loss: 0.1661 - val_accuracy: 0.9838\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Evaluate the performance" + ], + "metadata": { + "id": "FTvRa1FXri4R" + } + }, + { + "cell_type": "code", + "source": [ + "# Plot training & validation loss/accuracy values\n", + "\n", + "import pandas as pd\n", + "res_2=pd.DataFrame(hist.history)\n", + "res_2['epoch']=hist.epoch\n", + "res_2.head()" + ], + "metadata": { + "id": "cTH6flzcrck0", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "outputId": "2a8cda0d-f685-44ae-9e43-f5d4ec6a6b3e" + }, + "execution_count": 40, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " loss accuracy val_loss val_accuracy epoch\n", + "0 0.016776 0.995131 0.140860 0.969342 0\n", + "1 0.002999 0.998887 0.130457 0.972687 1\n", + "2 0.001879 0.999304 0.115042 0.982163 2\n", + "3 0.001461 0.999583 0.153825 0.978818 3\n", + "4 0.000627 0.999861 0.132381 0.982163 4" + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
lossaccuracyval_lossval_accuracyepoch
00.0167760.9951310.1408600.9693420
10.0029990.9988870.1304570.9726871
20.0018790.9993040.1150420.9821632
30.0014610.9995830.1538250.9788183
40.0006270.9998610.1323810.9821634
\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + " " + ] + }, + "metadata": {}, + "execution_count": 40 + } + ] + }, + { + "cell_type": "code", + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(res_2[\"epoch\"],res_2[\"loss\"],'red')\n", + "plt.plot(res_2[\"epoch\"],res_2[\"val_loss\"],'green')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 283 + }, + "id": "aFR6NKj679Sb", + "outputId": "adabcdb8-e6bd-4ad8-aad3-466e52bcac46" + }, + "execution_count": 41, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[]" + ] + }, + "metadata": {}, + "execution_count": 41 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "plt.plot(res_2[\"epoch\"],res_2[\"accuracy\"],'red')\n", + "plt.plot(res_2[\"epoch\"],res_2[\"val_accuracy\"],'green')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 283 + }, + "id": "0obCswfKOoES", + "outputId": "29af463d-ace9-45d2-ea80-8accfaa9ed7e" + }, + "execution_count": 43, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[]" + ] + }, + "metadata": {}, + "execution_count": 43 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "from sklearn.metrics import classification_report, confusion_matrix\n", + "import numpy as np\n", + "\n", + "validation_classes = []\n", + "validation_images = []\n", + "for i in range( -(-validation_label_generator.samples // validation_label_generator.batch_size)):\n", + " batch = validation_label_generator.next()\n", + " expected = np.argmax(batch[1], axis=1) \n", + " validation_classes.extend(expected)\n", + " validation_images.extend(batch[0])\n", + "validation_classes = np.array(validation_classes)\n", + "validation_images = np.array(validation_images)\n", + "Y_pred = model.predict(validation_images)\n", + "y_pred = np.argmax(Y_pred, axis=1)\n", + "\n", + "\n", + "print(classification_report(validation_classes, y_pred, \n", + "\t\ttarget_names = ['mask_weared_incorrect', 'with_mask', 'without_mask']))\n", + "# print classification report" + ], + "metadata": { + "id": "fJ-ZtU84r66Z", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "4802efa7-06b1-44e1-f54a-4fe6d2c64b75" + }, + "execution_count": 42, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " precision recall f1-score support\n", + "\n", + "mask_weared_incorrect 0.99 1.00 0.99 598\n", + " with_mask 0.98 0.97 0.98 598\n", + " without_mask 0.98 0.98 0.98 598\n", + "\n", + " accuracy 0.98 1794\n", + " macro avg 0.98 0.98 0.98 1794\n", + " weighted avg 0.98 0.98 0.98 1794\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Use the classification report to print precision, recall, f1-score for the three classes(optional, brownie points)" + ], + "metadata": { + "id": "VytDxkswrvXw" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file