From 2ca34b39d013de6ea0f26c9af4b2dc97103a0959 Mon Sep 17 00:00:00 2001 From: Morten Hjorth-Jensen Date: Thu, 20 Oct 2022 14:46:29 +0200 Subject: [PATCH] update --- doc/pub/week41/ipynb/week41.ipynb | 695 +++++++++++++++++++++++++++++- doc/pub/week42/ipynb/week42.ipynb | 2 +- 2 files changed, 680 insertions(+), 17 deletions(-) diff --git a/doc/pub/week41/ipynb/week41.ipynb b/doc/pub/week41/ipynb/week41.ipynb index c276098a3..e2255d1f9 100644 --- a/doc/pub/week41/ipynb/week41.ipynb +++ b/doc/pub/week41/ipynb/week41.ipynb @@ -597,10 +597,30 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 7, "id": "9b1e2335", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "inputs = (n_inputs, pixel_width, pixel_height) = (1797, 8, 8)\n", + "labels = (n_inputs) = (1797,)\n", + "X = (n_inputs, n_features) = (1797, 64)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "%matplotlib inline\n", "\n", @@ -668,10 +688,19 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 8, "id": "63b5f925", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of training images: 1437\n", + "Number of test images: 360\n" + ] + } + ], "source": [ "from sklearn.model_selection import train_test_split\n", "\n", @@ -802,7 +831,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 9, "id": "21742490", "metadata": {}, "outputs": [], @@ -886,10 +915,27 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 10, "id": "655edfa8", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "probabilities = (n_inputs, n_categories) = (1437, 10)\n", + "probability that image 0 is in category 0,1,2,...,9 = \n", + "[5.41511965e-04 2.17174962e-03 8.84355903e-03 1.44970586e-03\n", + " 1.10378326e-04 5.08318298e-09 2.03256632e-04 1.92507116e-03\n", + " 9.84443254e-01 3.11507992e-04]\n", + "probabilities sum up to: 1.0\n", + "\n", + "predictions = (n_inputs) = (1437,)\n", + "prediction for image 0: 8\n", + "correct label for image 0: 6\n" + ] + } + ], "source": [ "# setup the feed-forward pass, subscript h = hidden layer\n", "\n", @@ -1065,10 +1111,33 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 11, "id": "70a11914", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Old accuracy on training data: 0.1440501043841336\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "New accuracy on training data: 0.09951287404314545\n" + ] + } + ], "source": [ "# to categorical turns our integer vector into a onehot representation\n", "from sklearn.metrics import accuracy_score\n", @@ -1172,7 +1241,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 13, "id": "9f565f04", "metadata": {}, "outputs": [], @@ -1296,10 +1365,18 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 14, "id": "e864f3aa", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy score on test set: 0.9444444444444444\n" + ] + } + ], "source": [ "epochs = 100\n", "batch_size = 100\n", @@ -1332,10 +1409,559 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 15, "id": "a7eeea76", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate = 1e-05\n", + "Lambda = 1e-05\n", + "Accuracy score on test set: 0.11666666666666667\n", + "\n", + "Learning rate = 1e-05\n", + "Lambda = 0.0001\n", + "Accuracy score on test set: 0.20833333333333334\n", + "\n", + "Learning rate = 1e-05\n", + "Lambda = 0.001\n", + "Accuracy score on test set: 0.12222222222222222\n", + "\n", + "Learning rate = 1e-05\n", + "Lambda = 0.01\n", + "Accuracy score on test set: 0.14722222222222223\n", + "\n", + "Learning rate = 1e-05\n", + "Lambda = 0.1\n", + "Accuracy score on test set: 0.17777777777777778\n", + "\n", + "Learning rate = 1e-05\n", + "Lambda = 1.0\n", + "Accuracy score on test set: 0.16111111111111112\n", + "\n", + "Learning rate = 1e-05\n", + "Lambda = 10.0\n", + "Accuracy score on test set: 0.20277777777777778\n", + "\n", + "Learning rate = 0.0001\n", + "Lambda = 1e-05\n", + "Accuracy score on test set: 0.5305555555555556\n", + "\n", + "Learning rate = 0.0001\n", + "Lambda = 0.0001\n", + "Accuracy score on test set: 0.5944444444444444\n", + "\n", + "Learning rate = 0.0001\n", + "Lambda = 0.001\n", + "Accuracy score on test set: 0.5888888888888889\n", + "\n", + "Learning rate = 0.0001\n", + "Lambda = 0.01\n", + "Accuracy score on test set: 0.6111111111111112\n", + "\n", + "Learning rate = 0.0001\n", + "Lambda = 0.1\n", + "Accuracy score on test set: 0.5222222222222223\n", + "\n", + "Learning rate = 0.0001\n", + "Lambda = 1.0\n", + "Accuracy score on test set: 0.5555555555555556\n", + "\n", + "Learning rate = 0.0001\n", + "Lambda = 10.0\n", + "Accuracy score on test set: 0.8055555555555556\n", + "\n", + "Learning rate = 0.001\n", + "Lambda = 1e-05\n", + "Accuracy score on test set: 0.85\n", + "\n", + "Learning rate = 0.001\n", + "Lambda = 0.0001\n", + "Accuracy score on test set: 0.85\n", + "\n", + "Learning rate = 0.001\n", + "Lambda = 0.001\n", + "Accuracy score on test set: 0.875\n", + "\n", + "Learning rate = 0.001\n", + "Lambda = 0.01\n", + "Accuracy score on test set: 0.8666666666666667\n", + "\n", + "Learning rate = 0.001\n", + "Lambda = 0.1\n", + "Accuracy score on test set: 0.8638888888888889\n", + "\n", + "Learning rate = 0.001\n", + "Lambda = 1.0\n", + "Accuracy score on test set: 0.9555555555555556\n", + "\n", + "Learning rate = 0.001\n", + "Lambda = 10.0\n", + "Accuracy score on test set: 0.925\n", + "\n", + "Learning rate = 0.01\n", + "Lambda = 1e-05\n", + "Accuracy score on test set: 0.9472222222222222\n", + "\n", + "Learning rate = 0.01\n", + "Lambda = 0.0001\n", + "Accuracy score on test set: 0.9277777777777778\n", + "\n", + "Learning rate = 0.01\n", + "Lambda = 0.001\n", + "Accuracy score on test set: 0.9472222222222222\n", + "\n", + "Learning rate = 0.01\n", + "Lambda = 0.01\n", + "Accuracy score on test set: 0.9305555555555556\n", + "\n", + "Learning rate = 0.01\n", + "Lambda = 0.1\n", + "Accuracy score on test set: 0.9555555555555556\n", + "\n", + "Learning rate = 0.01\n", + "Lambda = 1.0\n", + "Accuracy score on test set: 0.7694444444444445\n", + "\n", + "Learning rate = 0.01\n", + "Lambda = 10.0\n", + "Accuracy score on test set: 0.19166666666666668\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate = 0.1\n", + "Lambda = 1e-05\n", + "Accuracy score on test set: 0.10555555555555556\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate = 0.1\n", + "Lambda = 0.0001\n", + "Accuracy score on test set: 0.08611111111111111\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate = 0.1\n", + "Lambda = 0.001\n", + "Accuracy score on test set: 0.10555555555555556\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate = 0.1\n", + "Lambda = 0.01\n", + "Accuracy score on test set: 0.08888888888888889\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate = 0.1\n", + "Lambda = 0.1\n", + "Accuracy score on test set: 0.08611111111111111\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate = 0.1\n", + "Lambda = 1.0\n", + "Accuracy score on test set: 0.08888888888888889\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate = 0.1\n", + "Lambda = 10.0\n", + "Accuracy score on test set: 0.09166666666666666\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n", + " exp_term = np.exp(self.z_o)\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n", + " self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate = 1.0\n", + "Lambda = 1e-05\n", + "Accuracy score on test set: 0.07777777777777778\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n", + " exp_term = np.exp(self.z_o)\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n", + " self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate = 1.0\n", + "Lambda = 0.0001\n", + "Accuracy score on test set: 0.07777777777777778\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n", + " exp_term = np.exp(self.z_o)\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n", + " self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate = 1.0\n", + "Lambda = 0.001\n", + "Accuracy score on test set: 0.07777777777777778\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n", + " exp_term = np.exp(self.z_o)\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n", + " self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate = 1.0\n", + "Lambda = 0.01\n", + "Accuracy score on test set: 0.07777777777777778\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n", + " exp_term = np.exp(self.z_o)\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n", + " self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate = 1.0\n", + "Lambda = 0.1\n", + "Accuracy score on test set: 0.07777777777777778\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate = 1.0\n", + "Lambda = 1.0\n", + "Accuracy score on test set: 0.10555555555555556\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n", + " exp_term = np.exp(self.z_o)\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n", + " self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate = 1.0\n", + "Lambda = 10.0\n", + "Accuracy score on test set: 0.07777777777777778\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n", + " exp_term = np.exp(self.z_o)\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n", + " self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate = 10.0\n", + "Lambda = 1e-05\n", + "Accuracy score on test set: 0.07777777777777778\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n", + " exp_term = np.exp(self.z_o)\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n", + " self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate = 10.0\n", + "Lambda = 0.0001\n", + "Accuracy score on test set: 0.07777777777777778\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n", + " exp_term = np.exp(self.z_o)\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n", + " self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate = 10.0\n", + "Lambda = 0.001\n", + "Accuracy score on test set: 0.07777777777777778\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n", + " exp_term = np.exp(self.z_o)\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n", + " self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate = 10.0\n", + "Lambda = 0.01\n", + "Accuracy score on test set: 0.07777777777777778\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n", + " exp_term = np.exp(self.z_o)\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n", + " self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate = 10.0\n", + "Lambda = 0.1\n", + "Accuracy score on test set: 0.07777777777777778\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n", + " exp_term = np.exp(self.z_o)\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n", + " self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate = 10.0\n", + "Lambda = 1.0\n", + "Accuracy score on test set: 0.07777777777777778\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n", + " exp_term = np.exp(self.z_o)\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n", + " self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate = 10.0\n", + "Lambda = 10.0\n", + "Accuracy score on test set: 0.07777777777777778\n", + "\n" + ] + } + ], "source": [ "eta_vals = np.logspace(-5, 1, 7)\n", "lmbd_vals = np.logspace(-5, 1, 7)\n", @@ -1369,10 +1995,47 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 17, "id": "b53e874c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n", + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_73993/953065564.py:4: RuntimeWarning: overflow encountered in exp\n", + " return 1/(1 + np.exp(-x))\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# visual representation of grid search\n", "# uses seaborn heatmap, you can also do this with matplotlib imshow\n", diff --git a/doc/pub/week42/ipynb/week42.ipynb b/doc/pub/week42/ipynb/week42.ipynb index d0a476381..e8305c46a 100644 --- a/doc/pub/week42/ipynb/week42.ipynb +++ b/doc/pub/week42/ipynb/week42.ipynb @@ -870,7 +870,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 8, "id": "a65da691", "metadata": {}, "outputs": [