diff --git a/doc/pub/week45/ipynb/DataFiles/cancer.dot b/doc/pub/week45/ipynb/DataFiles/cancer.dot index 0c1e8242f..be1a64a18 100644 --- a/doc/pub/week45/ipynb/DataFiles/cancer.dot +++ b/doc/pub/week45/ipynb/DataFiles/cancer.dot @@ -6,15 +6,15 @@ edge [fontname=helvetica] ; 0 -> 1 [labeldistance=2.5, labelangle=45, headlabel="True"] ; 2 [label="worst concave points <= 0.135\ngini = 0.031\nsamples = 253\nvalue = [[249, 4]\n[4, 249]]", fillcolor="#e78946"] ; 1 -> 2 ; -3 [label="radius error <= 0.643\ngini = 0.008\nsamples = 242\nvalue = [[241, 1]\n[1, 241]]", fillcolor="#e5833c"] ; +3 [label="area error <= 48.975\ngini = 0.008\nsamples = 242\nvalue = [[241, 1]\n[1, 241]]", fillcolor="#e5833c"] ; 2 -> 3 ; 4 [label="gini = 0.0\nsamples = 239\nvalue = [[239, 0]\n[0, 239]]", fillcolor="#e58139"] ; 3 -> 4 ; -5 [label="texture error <= 1.938\ngini = 0.444\nsamples = 3\nvalue = [[2, 1]\n[1, 2]]", fillcolor="#fdf6f0"] ; +5 [label="mean symmetry <= 0.166\ngini = 0.444\nsamples = 3\nvalue = [[2, 1]\n[1, 2]]", fillcolor="#fdf6f0"] ; 3 -> 5 ; -6 [label="gini = 0.0\nsamples = 2\nvalue = [[2, 0]\n[0, 2]]", fillcolor="#e58139"] ; +6 [label="gini = 0.0\nsamples = 1\nvalue = [[0, 1]\n[1, 0]]", fillcolor="#e58139"] ; 5 -> 6 ; -7 [label="gini = 0.0\nsamples = 1\nvalue = [[0, 1]\n[1, 0]]", fillcolor="#e58139"] ; +7 [label="gini = 0.0\nsamples = 2\nvalue = [[2, 0]\n[0, 2]]", fillcolor="#e58139"] ; 5 -> 7 ; 8 [label="mean texture <= 20.84\ngini = 0.397\nsamples = 11\nvalue = [[8, 3]\n[3, 8]]", fillcolor="#fae9dd"] ; 2 -> 8 ; @@ -30,11 +30,11 @@ edge [fontname=helvetica] ; 11 -> 13 ; 14 [label="worst texture <= 20.645\ngini = 0.202\nsamples = 167\nvalue = [[19, 148]\n[148, 19]]", fillcolor="#f0b68c"] ; 0 -> 14 [labeldistance=2.5, labelangle=-45, headlabel="False"] ; -15 [label="worst concavity <= 0.318\ngini = 0.375\nsamples = 16\nvalue = [[12, 4]\n[4, 12]]", fillcolor="#f9e3d4"] ; +15 [label="worst radius <= 17.74\ngini = 0.375\nsamples = 16\nvalue = [[12, 4]\n[4, 12]]", fillcolor="#f9e3d4"] ; 14 -> 15 ; 16 [label="gini = 0.0\nsamples = 11\nvalue = [[11, 0]\n[0, 11]]", fillcolor="#e58139"] ; 15 -> 16 ; -17 [label="area error <= 23.16\ngini = 0.32\nsamples = 5\nvalue = [[1, 4]\n[4, 1]]", fillcolor="#f6d5bd"] ; +17 [label="concave points error <= 0.008\ngini = 0.32\nsamples = 5\nvalue = [[1, 4]\n[4, 1]]", fillcolor="#f6d5bd"] ; 15 -> 17 ; 18 [label="gini = 0.0\nsamples = 1\nvalue = [[1, 0]\n[0, 1]]", fillcolor="#e58139"] ; 17 -> 18 ; @@ -42,13 +42,13 @@ edge [fontname=helvetica] ; 17 -> 19 ; 20 [label="mean concave points <= 0.049\ngini = 0.088\nsamples = 151\nvalue = [[7, 144]\n[144, 7]]", fillcolor="#ea985d"] ; 14 -> 20 ; -21 [label="compactness error <= 0.016\ngini = 0.48\nsamples = 15\nvalue = [[6, 9]\n[9, 6]]", fillcolor="#ffffff"] ; +21 [label="concave points error <= 0.01\ngini = 0.48\nsamples = 15\nvalue = [[6, 9]\n[9, 6]]", fillcolor="#ffffff"] ; 20 -> 21 ; 22 [label="gini = 0.0\nsamples = 9\nvalue = [[0, 9]\n[9, 0]]", fillcolor="#e58139"] ; 21 -> 22 ; 23 [label="gini = 0.0\nsamples = 6\nvalue = [[6, 0]\n[0, 6]]", fillcolor="#e58139"] ; 21 -> 23 ; -24 [label="mean smoothness <= 0.079\ngini = 0.015\nsamples = 136\nvalue = [[1, 135]\n[135, 1]]", fillcolor="#e6853f"] ; +24 [label="worst smoothness <= 0.096\ngini = 0.015\nsamples = 136\nvalue = [[1, 135]\n[135, 1]]", fillcolor="#e6853f"] ; 20 -> 24 ; 25 [label="gini = 0.0\nsamples = 1\nvalue = [[1, 0]\n[0, 1]]", fillcolor="#e58139"] ; 24 -> 25 ; diff --git a/doc/pub/week45/ipynb/DataFiles/cancer.png b/doc/pub/week45/ipynb/DataFiles/cancer.png index 4d0fc1208..f74fc3c50 100644 Binary files a/doc/pub/week45/ipynb/DataFiles/cancer.png and b/doc/pub/week45/ipynb/DataFiles/cancer.png differ diff --git a/doc/pub/week45/ipynb/Results/FigureFiles/gdclassiffiercgain.png b/doc/pub/week45/ipynb/Results/FigureFiles/gdclassiffiercgain.png index 097599daa..455369c77 100644 Binary files a/doc/pub/week45/ipynb/Results/FigureFiles/gdclassiffiercgain.png and b/doc/pub/week45/ipynb/Results/FigureFiles/gdclassiffiercgain.png differ diff --git a/doc/pub/week45/ipynb/Results/FigureFiles/gdclassiffierconfusion.png b/doc/pub/week45/ipynb/Results/FigureFiles/gdclassiffierconfusion.png index 731ee99b4..bd2dd5adf 100644 Binary files a/doc/pub/week45/ipynb/Results/FigureFiles/gdclassiffierconfusion.png and b/doc/pub/week45/ipynb/Results/FigureFiles/gdclassiffierconfusion.png differ diff --git a/doc/pub/week45/ipynb/Results/FigureFiles/gdclassiffierroc.png b/doc/pub/week45/ipynb/Results/FigureFiles/gdclassiffierroc.png index 8fbf286fe..458ffab47 100644 Binary files a/doc/pub/week45/ipynb/Results/FigureFiles/gdclassiffierroc.png and b/doc/pub/week45/ipynb/Results/FigureFiles/gdclassiffierroc.png differ diff --git a/doc/pub/week45/ipynb/Results/FigureFiles/gdregression.png b/doc/pub/week45/ipynb/Results/FigureFiles/gdregression.png index 5592de634..170f02202 100644 Binary files a/doc/pub/week45/ipynb/Results/FigureFiles/gdregression.png and b/doc/pub/week45/ipynb/Results/FigureFiles/gdregression.png differ diff --git a/doc/pub/week45/ipynb/Results/FigureFiles/xdclassiffierconfusion.png b/doc/pub/week45/ipynb/Results/FigureFiles/xdclassiffierconfusion.png index 6c0f198b3..3ab2f6024 100644 Binary files a/doc/pub/week45/ipynb/Results/FigureFiles/xdclassiffierconfusion.png and b/doc/pub/week45/ipynb/Results/FigureFiles/xdclassiffierconfusion.png differ diff --git a/doc/pub/week45/ipynb/Results/FigureFiles/xdclassiffierroc.png b/doc/pub/week45/ipynb/Results/FigureFiles/xdclassiffierroc.png index f8ef6a3f0..a9d37df15 100644 Binary files a/doc/pub/week45/ipynb/Results/FigureFiles/xdclassiffierroc.png and b/doc/pub/week45/ipynb/Results/FigureFiles/xdclassiffierroc.png differ diff --git a/doc/pub/week45/ipynb/week45.ipynb b/doc/pub/week45/ipynb/week45.ipynb index 45668051b..d1ee6c975 100644 --- a/doc/pub/week45/ipynb/week45.ipynb +++ b/doc/pub/week45/ipynb/week45.ipynb @@ -146,9 +146,7 @@ { "cell_type": "code", "execution_count": 1, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "%matplotlib inline\n", @@ -658,11 +656,60 @@ }, { "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " (0, 2)\t1.0\n", + " (0, 5)\t1.0\n", + " (0, 8)\t1.0\n", + " (1, 1)\t1.0\n", + " (1, 3)\t1.0\n", + " (1, 6)\t1.0\n", + " (2, 0)\t1.0\n", + " (2, 4)\t1.0\n", + " (2, 6)\t1.0\n", + " (3, 1)\t1.0\n", + " (3, 3)\t1.0\n", + " (3, 7)\t1.0\n", + " (4, 1)\t1.0\n", + " (4, 4)\t1.0\n", + " (4, 7)\t1.0\n", + " (5, 0)\t1.0\n", + " (5, 3)\t1.0\n", + " (5, 7)\t1.0\n", + " (6, 1)\t1.0\n", + " (6, 3)\t1.0\n", + " (6, 6)\t1.0\n", + " (7, 0)\t1.0\n", + " (7, 4)\t1.0\n", + " (7, 7)\t1.0\n", + " (8, 0)\t1.0\n", + " (8, 3)\t1.0\n", + " (8, 7)\t1.0\n", + " (9, 1)\t1.0\n", + " (9, 3)\t1.0\n", + " (9, 6)\t1.0\n", + " (10, 1)\t1.0\n", + " (10, 4)\t1.0\n", + " (10, 7)\t1.0\n", + "Train set accuracy with Decision Tree: 0.82\n" + ] + }, + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Common imports\n", "import numpy as np\n", @@ -742,11 +789,119 @@ }, { "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " mean radius mean texture mean perimeter mean area mean smoothness \\\n", + "0 17.99 10.38 122.80 1001.0 0.11840 \n", + "1 20.57 17.77 132.90 1326.0 0.08474 \n", + "2 19.69 21.25 130.00 1203.0 0.10960 \n", + "3 11.42 20.38 77.58 386.1 0.14250 \n", + "4 20.29 14.34 135.10 1297.0 0.10030 \n", + ".. ... ... ... ... ... \n", + "564 21.56 22.39 142.00 1479.0 0.11100 \n", + "565 20.13 28.25 131.20 1261.0 0.09780 \n", + "566 16.60 28.08 108.30 858.1 0.08455 \n", + "567 20.60 29.33 140.10 1265.0 0.11780 \n", + "568 7.76 24.54 47.92 181.0 0.05263 \n", + "\n", + " mean compactness mean concavity mean concave points mean symmetry \\\n", + "0 0.27760 0.30010 0.14710 0.2419 \n", + "1 0.07864 0.08690 0.07017 0.1812 \n", + "2 0.15990 0.19740 0.12790 0.2069 \n", + "3 0.28390 0.24140 0.10520 0.2597 \n", + "4 0.13280 0.19800 0.10430 0.1809 \n", + ".. ... ... ... ... \n", + "564 0.11590 0.24390 0.13890 0.1726 \n", + "565 0.10340 0.14400 0.09791 0.1752 \n", + "566 0.10230 0.09251 0.05302 0.1590 \n", + "567 0.27700 0.35140 0.15200 0.2397 \n", + "568 0.04362 0.00000 0.00000 0.1587 \n", + "\n", + " mean fractal dimension ... worst radius worst texture \\\n", + "0 0.07871 ... 25.380 17.33 \n", + "1 0.05667 ... 24.990 23.41 \n", + "2 0.05999 ... 23.570 25.53 \n", + "3 0.09744 ... 14.910 26.50 \n", + "4 0.05883 ... 22.540 16.67 \n", + ".. ... ... ... ... \n", + "564 0.05623 ... 25.450 26.40 \n", + "565 0.05533 ... 23.690 38.25 \n", + "566 0.05648 ... 18.980 34.12 \n", + "567 0.07016 ... 25.740 39.42 \n", + "568 0.05884 ... 9.456 30.37 \n", + "\n", + " worst perimeter worst area worst smoothness worst compactness \\\n", + "0 184.60 2019.0 0.16220 0.66560 \n", + "1 158.80 1956.0 0.12380 0.18660 \n", + "2 152.50 1709.0 0.14440 0.42450 \n", + "3 98.87 567.7 0.20980 0.86630 \n", + "4 152.20 1575.0 0.13740 0.20500 \n", + ".. ... ... ... ... \n", + "564 166.10 2027.0 0.14100 0.21130 \n", + "565 155.00 1731.0 0.11660 0.19220 \n", + "566 126.70 1124.0 0.11390 0.30940 \n", + "567 184.60 1821.0 0.16500 0.86810 \n", + "568 59.16 268.6 0.08996 0.06444 \n", + "\n", + " worst concavity worst concave points worst symmetry \\\n", + "0 0.7119 0.2654 0.4601 \n", + "1 0.2416 0.1860 0.2750 \n", + "2 0.4504 0.2430 0.3613 \n", + "3 0.6869 0.2575 0.6638 \n", + "4 0.4000 0.1625 0.2364 \n", + ".. ... ... ... \n", + "564 0.4107 0.2216 0.2060 \n", + "565 0.3215 0.1628 0.2572 \n", + "566 0.3403 0.1418 0.2218 \n", + "567 0.9387 0.2650 0.4087 \n", + "568 0.0000 0.0000 0.2871 \n", + "\n", + " worst fractal dimension \n", + "0 0.11890 \n", + "1 0.08902 \n", + "2 0.08758 \n", + "3 0.17300 \n", + "4 0.07678 \n", + ".. ... \n", + "564 0.07115 \n", + "565 0.06637 \n", + "566 0.07820 \n", + "567 0.12400 \n", + "568 0.07039 \n", + "\n", + "[569 rows x 30 columns]\n", + " malignant benign\n", + "0 1 0\n", + "1 1 0\n", + "2 1 0\n", + "3 1 0\n", + "4 1 0\n", + ".. ... ...\n", + "564 1 0\n", + "565 1 0\n", + "566 1 0\n", + "567 1 0\n", + "568 0 1\n", + "\n", + "[569 rows x 2 columns]\n" + ] + }, + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "import os\n", "from sklearn.datasets import load_breast_cancer\n", @@ -792,11 +947,20 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Common imports\n", "import numpy as np\n", @@ -835,11 +999,48 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[Text(167.4, 199.32, 'X[2] <= 2.45\\ngini = 0.667\\nsamples = 150\\nvalue = [50, 50, 50]'),\n", + " Text(141.64615384615385, 163.07999999999998, 'gini = 0.0\\nsamples = 50\\nvalue = [50, 0, 0]'),\n", + " Text(193.15384615384616, 163.07999999999998, 'X[3] <= 1.75\\ngini = 0.5\\nsamples = 100\\nvalue = [0, 50, 50]'),\n", + " Text(103.01538461538462, 126.83999999999999, 'X[2] <= 4.95\\ngini = 0.168\\nsamples = 54\\nvalue = [0, 49, 5]'),\n", + " Text(51.50769230769231, 90.6, 'X[3] <= 1.65\\ngini = 0.041\\nsamples = 48\\nvalue = [0, 47, 1]'),\n", + " Text(25.753846153846155, 54.359999999999985, 'gini = 0.0\\nsamples = 47\\nvalue = [0, 47, 0]'),\n", + " Text(77.26153846153846, 54.359999999999985, 'gini = 0.0\\nsamples = 1\\nvalue = [0, 0, 1]'),\n", + " Text(154.52307692307693, 90.6, 'X[3] <= 1.55\\ngini = 0.444\\nsamples = 6\\nvalue = [0, 2, 4]'),\n", + " Text(128.76923076923077, 54.359999999999985, 'gini = 0.0\\nsamples = 3\\nvalue = [0, 0, 3]'),\n", + " Text(180.27692307692308, 54.359999999999985, 'X[2] <= 5.45\\ngini = 0.444\\nsamples = 3\\nvalue = [0, 2, 1]'),\n", + " Text(154.52307692307693, 18.119999999999976, 'gini = 0.0\\nsamples = 2\\nvalue = [0, 2, 0]'),\n", + " Text(206.03076923076924, 18.119999999999976, 'gini = 0.0\\nsamples = 1\\nvalue = [0, 0, 1]'),\n", + " Text(283.2923076923077, 126.83999999999999, 'X[2] <= 4.85\\ngini = 0.043\\nsamples = 46\\nvalue = [0, 1, 45]'),\n", + " Text(257.53846153846155, 90.6, 'X[1] <= 3.1\\ngini = 0.444\\nsamples = 3\\nvalue = [0, 1, 2]'),\n", + " Text(231.7846153846154, 54.359999999999985, 'gini = 0.0\\nsamples = 2\\nvalue = [0, 0, 2]'),\n", + " Text(283.2923076923077, 54.359999999999985, 'gini = 0.0\\nsamples = 1\\nvalue = [0, 1, 0]'),\n", + " Text(309.04615384615386, 90.6, 'gini = 0.0\\nsamples = 43\\nvalue = [0, 0, 43]')]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "from sklearn.datasets import load_iris\n", "from sklearn import tree\n", @@ -862,11 +1063,24 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "|--- petal width (cm) <= 0.80\n", + "| |--- class: 0\n", + "|--- petal width (cm) > 0.80\n", + "| |--- petal width (cm) <= 1.75\n", + "| | |--- class: 1\n", + "| |--- petal width (cm) > 1.75\n", + "| | |--- class: 2\n", + "\n" + ] + } + ], "source": [ "from sklearn.datasets import load_iris\n", "from sklearn.tree import DecisionTreeClassifier\n", @@ -1024,11 +1238,78 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " (0, 0)\t1.0\n", + " (0, 7)\t1.0\n", + " (0, 9)\t1.0\n", + " (0, 13)\t1.0\n", + " (1, 3)\t1.0\n", + " (1, 5)\t1.0\n", + " (1, 8)\t1.0\n", + " (1, 12)\t1.0\n", + " (2, 3)\t1.0\n", + " (2, 5)\t1.0\n", + " (2, 8)\t1.0\n", + " (2, 11)\t1.0\n", + " (3, 1)\t1.0\n", + " (3, 5)\t1.0\n", + " (3, 8)\t1.0\n", + " (3, 12)\t1.0\n", + " (4, 2)\t1.0\n", + " (4, 6)\t1.0\n", + " (4, 8)\t1.0\n", + " (4, 12)\t1.0\n", + " (5, 2)\t1.0\n", + " (5, 4)\t1.0\n", + " (5, 10)\t1.0\n", + " (5, 12)\t1.0\n", + " (6, 2)\t1.0\n", + " :\t:\n", + " (8, 12)\t1.0\n", + " (9, 3)\t1.0\n", + " (9, 4)\t1.0\n", + " (9, 10)\t1.0\n", + " (9, 12)\t1.0\n", + " (10, 2)\t1.0\n", + " (10, 6)\t1.0\n", + " (10, 10)\t1.0\n", + " (10, 12)\t1.0\n", + " (11, 3)\t1.0\n", + " (11, 6)\t1.0\n", + " (11, 10)\t1.0\n", + " (11, 11)\t1.0\n", + " (12, 1)\t1.0\n", + " (12, 6)\t1.0\n", + " (12, 8)\t1.0\n", + " (12, 11)\t1.0\n", + " (13, 1)\t1.0\n", + " (13, 5)\t1.0\n", + " (13, 10)\t1.0\n", + " (13, 12)\t1.0\n", + " (14, 2)\t1.0\n", + " (14, 6)\t1.0\n", + " (14, 8)\t1.0\n", + " (14, 11)\t1.0\n", + "Train set accuracy with Decision Tree: 0.73\n" + ] + }, + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Common imports\n", "import numpy as np\n", @@ -1115,11 +1396,73 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1 < 0.000 Gini=0.408\n", + "X1 < 0.000 Gini=0.408\n", + "X1 < 1.000 Gini=0.394\n", + "X1 < 2.000 Gini=0.394\n", + "X1 < 2.000 Gini=0.394\n", + "X1 < 2.000 Gini=0.394\n", + "X1 < 1.000 Gini=0.394\n", + "X1 < 0.000 Gini=0.408\n", + "X1 < 0.000 Gini=0.408\n", + "X1 < 2.000 Gini=0.394\n", + "X1 < 0.000 Gini=0.408\n", + "X1 < 1.000 Gini=0.394\n", + "X1 < 1.000 Gini=0.394\n", + "X1 < 2.000 Gini=0.394\n", + "X2 < 0.000 Gini=0.408\n", + "X2 < 0.000 Gini=0.408\n", + "X2 < 0.000 Gini=0.408\n", + "X2 < 1.000 Gini=0.407\n", + "X2 < 2.000 Gini=0.407\n", + "X2 < 2.000 Gini=0.407\n", + "X2 < 2.000 Gini=0.407\n", + "X2 < 1.000 Gini=0.407\n", + "X2 < 2.000 Gini=0.407\n", + "X2 < 1.000 Gini=0.407\n", + "X2 < 1.000 Gini=0.407\n", + "X2 < 1.000 Gini=0.407\n", + "X2 < 0.000 Gini=0.408\n", + "X2 < 1.000 Gini=0.407\n", + "X3 < 0.000 Gini=0.408\n", + "X3 < 0.000 Gini=0.408\n", + "X3 < 0.000 Gini=0.408\n", + "X3 < 0.000 Gini=0.408\n", + "X3 < 1.000 Gini=0.367\n", + "X3 < 1.000 Gini=0.367\n", + "X3 < 1.000 Gini=0.367\n", + "X3 < 0.000 Gini=0.408\n", + "X3 < 1.000 Gini=0.367\n", + "X3 < 1.000 Gini=0.367\n", + "X3 < 1.000 Gini=0.367\n", + "X3 < 0.000 Gini=0.408\n", + "X3 < 1.000 Gini=0.367\n", + "X3 < 0.000 Gini=0.408\n", + "X4 < 0.000 Gini=0.408\n", + "X4 < 1.000 Gini=0.405\n", + "X4 < 0.000 Gini=0.408\n", + "X4 < 0.000 Gini=0.408\n", + "X4 < 0.000 Gini=0.408\n", + "X4 < 1.000 Gini=0.405\n", + "X4 < 1.000 Gini=0.405\n", + "X4 < 0.000 Gini=0.408\n", + "X4 < 0.000 Gini=0.408\n", + "X4 < 0.000 Gini=0.408\n", + "X4 < 1.000 Gini=0.405\n", + "X4 < 1.000 Gini=0.405\n", + "X4 < 0.000 Gini=0.408\n", + "X4 < 1.000 Gini=0.405\n", + "Split: [X3 < 1.000]\n" + ] + } + ], "source": [ "# Split a dataset based on an attribute and an attribute value\n", "def test_split(index, value, dataset):\n", @@ -1224,11 +1567,38 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(426, 30)\n", + "(143, 30)\n", + "Test set accuracy with Logistic Regression: 0.95\n", + "Test set accuracy with SVM: 0.63\n", + "Test set accuracy with Decision Trees: 0.90\n", + "Test set accuracy Logistic Regression with scaled data: 0.96\n", + "Test set accuracy SVM with scaled data: 0.96\n", + "Test set accuracy with Decision Trees and scaled data: 0.89\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/hjensen/opt/anaconda3/lib/python3.8/site-packages/sklearn/linear_model/_logistic.py:762: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + "Please also refer to the documentation for alternative solver options:\n", + " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", + " n_iter_i = _check_optimize_result(\n" + ] + } + ], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", @@ -1282,11 +1652,22 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "from __future__ import division, print_function, unicode_literals\n", "\n", @@ -1363,11 +1744,22 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "np.random.seed(6)\n", "Xs = np.random.rand(100, 2) - 0.5\n", @@ -1400,10 +1792,8 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": { - "collapsed": false - }, + "execution_count": 11, + "metadata": {}, "outputs": [], "source": [ "# Quadratic training set + noise\n", @@ -1416,11 +1806,20 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DecisionTreeRegressor(max_depth=2, random_state=42)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "from sklearn.tree import DecisionTreeRegressor\n", "\n", @@ -1437,11 +1836,22 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "from sklearn.tree import DecisionTreeRegressor\n", "\n", @@ -1485,11 +1895,22 @@ }, { "cell_type": "code", - "execution_count": 15, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "tree_reg1 = DecisionTreeRegressor(random_state=42)\n", "tree_reg2 = DecisionTreeRegressor(random_state=42, min_samples_leaf=10)\n", @@ -1648,11 +2069,74 @@ }, { "cell_type": "code", - "execution_count": 16, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Polynomial degree: 1\n", + "Error: 0.061448998019132145\n", + "Bias^2: 0.06105618955900724\n", + "Var: 0.00039280846012491264\n", + "0.061448998019132145 >= 0.06105618955900724 + 0.00039280846012491264 = 0.06144899801913215\n", + "Polynomial degree: 2\n", + "Error: 0.03875741192664723\n", + "Bias^2: 0.034968923076368015\n", + "Var: 0.0037884888502792186\n", + "0.03875741192664723 >= 0.034968923076368015 + 0.0037884888502792186 = 0.03875741192664724\n", + "Polynomial degree: 3\n", + "Error: 0.02041636912454364\n", + "Bias^2: 0.01715994964969937\n", + "Var: 0.003256419474844272\n", + "0.02041636912454364 >= 0.01715994964969937 + 0.003256419474844272 = 0.020416369124543643\n", + "Polynomial degree: 4\n", + "Error: 0.015965748446438426\n", + "Bias^2: 0.013554291046963396\n", + "Var: 0.0024114573994750295\n", + "0.015965748446438426 >= 0.013554291046963396 + 0.0024114573994750295 = 0.015965748446438426\n", + "Polynomial degree: 5\n", + "Error: 0.013812239104124671\n", + "Bias^2: 0.011703251217852149\n", + "Var: 0.002108987886272521\n", + "0.013812239104124671 >= 0.011703251217852149 + 0.002108987886272521 = 0.013812239104124671\n", + "Polynomial degree: 6\n", + "Error: 0.014027604155185338\n", + "Bias^2: 0.011913977762964968\n", + "Var: 0.0021136263922203642\n", + "0.014027604155185338 >= 0.011913977762964968 + 0.0021136263922203642 = 0.014027604155185332\n", + "Polynomial degree: 7\n", + "Error: 0.015038650222479456\n", + "Bias^2: 0.012358926638419723\n", + "Var: 0.0026797235840597265\n", + "0.015038650222479456 >= 0.012358926638419723 + 0.0026797235840597265 = 0.015038650222479449\n", + "Polynomial degree: 8\n", + "Error: 0.01573056551137539\n", + "Bias^2: 0.012523761778720667\n", + "Var: 0.003206803732654721\n", + "0.01573056551137539 >= 0.012523761778720667 + 0.003206803732654721 = 0.01573056551137539\n", + "Polynomial degree: 9\n", + "Error: 0.016856035170026745\n", + "Bias^2: 0.013111698385627429\n", + "Var: 0.003744336784399317\n", + "0.016856035170026745 >= 0.013111698385627429 + 0.003744336784399317 = 0.016856035170026745\n", + "0.5424065596633239\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAD7CAYAAABuSzNOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXxU1f34/9c7mcmeAIGwBgw7BgggcUEUqIq44PJRW/dqqbUFta3WVq11AfVj67c/tXWptdWqtWq1xaWi+BFBAUUxUAHDJsgW1pBANrJMJu/fH3cmzISETCDhZnk/H495zJ1zztx5T5bzvueeu4iqYowxxgRFuR2AMcaY1sUSgzHGmDCWGIwxxoSxxGCMMSaMJQZjjDFhPG4HEIlu3bppRkaG22EYY0ybsmzZsr2qmtbU97WJxJCRkUFOTo7bYRhjTJsiIluO5H22K8kYY0wYSwzGGGPCWGIwxhgTpk3MMRhj2j+fz0deXh4VFRVuh9LmxMXFkZ6ejtfrbZb1WWIwxrQKeXl5JCcnk5GRgYi4HU6boaoUFBSQl5dH//79m2WdtivJGNMqVFRU0LVrV0sKTSQidO3atVlHWpYYjDGthiWFI9PcP7c2kRgqq2vcDsEYYzqMNpEY8grLsPtGGGNamohw7bXX1r6urq4mLS2NqVOnArB7926mTp3KqFGjyMzM5LzzzgNg8+bNxMfHM3r06NrHSy+95Mp3aA5tYvI5tXo389bsYXJmD7dDMca0Y4mJiXz99deUl5cTHx/Phx9+SJ8+fWrr7733XiZPnszPfvYzAFauXFlbN3DgQL766qtjHnNLiGjEICKpIvKmiJSJyBYRueowbW8VkV0iUiQiz4tIbJ36K0RkTWBdG0Xk9MY+vzOlvPjBZ9TU2KjBGNOyzj33XObMmQPAq6++ypVXXllbt3PnTtLT02tfZ2VlHfP4joVIRwxPAVVAD2A0MEdEVqhqbmgjEZkC3AmcAewA3gRmBsoQkcnA74DLgaVAr0g+XFBOLZjNB7mncO7IiN5ijGnDZv4nl9U7ipt1nZm9U7jvguGNtrviiiuYNWsWU6dOZeXKlUybNo1FixYBcNNNN3H55Zfz5JNPctZZZ/GDH/yA3r17A7Bx40ZGjx5du54nnniC009vdLu3VWo0MYhIInApMEJVS4HFIvIOcC2BDj/EdcBzwYQhIg8A/whpNxOYpaqfB15vjyjKuE5c45nPNR+u5OzhPYmOsiMXjDEtIysri82bN/Pqq6/WziEETZkyhW+//Za5c+fy/vvvM2bMGL7++mugfe1KimTEMATwq+r6kLIVwMR62g4H3q7TroeIdAX2A9nAOyKyAYgD3gJ+qarldVckIjcCNwIM7NuTFErJKnifOatGcuGo3hGEbYxpqyLZsm9JF154Ibfffjsff/wxBQUFYXWpqalcddVVXHXVVUydOpWFCxcyduxYlyJtGZHMMSQBRXXKioDkCNoGl5NxdkN5gcuA03F2SY0BflPfh6rqs6qararZnbv3QXuP5SexH/CHD9fit7kGY0wLmjZtGvfeey8jR44MK58/fz4HDhwAoKSkhI0bN9KvXz83QmxRkSSGUiClTlkKUBJB2+ByCRAcFTyhqjtVdS/wKBA+VmuAjJtBes0OMgoX8/ZXke2BMsaYI5Genl575FGoZcuWkZ2dTVZWFuPGjeOGG27gxBNPBA7OMQQff/zjH4912M0mkl1J6wGPiAxW1W8CZaOA3Hra5gbqXg9pt1tVCwBEJA84ss39zIvQD+/jpwf+j59+dDoXjuqNJ7pNnIZhjGkjSktLDymbNGkSkyZNAuCXv/wlv/zlLw9pk5GRQXn5IXvE26xGe1ZVLQNmA7NEJFFExgMXAX+vp/lLwA9FJFNEuuDsJnohpP5vwC0i0j1Q/3Pg3YgijfYiJ9/IqOpVJBWuZvZyGzUYY0xLiHSTewYQD+wBXgWmq2quiPQTkVIR6QegqnOBR4AFwJbA476Q9TwAfIkzClkD/Bd4KOJoT7gO9SZye8o8/jj/G6rsUhnGGNPsIkoMqlqoqheraqKq9lPVVwLlW1U1SVW3hrR9VFV7qGqKqv5AVStD6nyqOkNVO6tqT1X9qapGfknA+M7ImGuY6FtE1b4dvLFsWxO+qjHGmEi0vZ30p/wEqanmV6kLeXL+Biqr/W5HZIwx7UrbSwypA5Bh53NR9QfsKyritaU2ajDGmObU9hIDwLib8Fbt5xfdl/PUgg1U+GzUYIwxzaVtJoZ+46DXaK5hDvkl5bz8+Ra3IzLGtAObN29mxIgRh5TfcMMNrF692oWI3NE2E4MIjLuJ+OJvmdHnW575ZCMHqqrdjsoY00799a9/JTMz0+0wjpm2mRgAMi+G5N78OOYD9pZW8dISGzUYY45edXU11113HVlZWVx22WUcOHCASZMmkZOTA8D06dPJzs5m+PDh3HffwaPx77zzTjIzM8nKyuL22293K/xm0SZu1FMvTwyc9CNSPprJNRnX8udPNnLNKceRFNt2v5IxJuD9O2HXquZdZ8+RcO5vG222bt06nnvuOcaPH8+0adN4+umnw+ofeughUlNT8fv9nHnmmaxcuZL09HTefPNN1q5di4iwf//+5o39GGu7IwaAsdeDN4Fbkz9i3wEfL3622e2IjDFtXN++fRk/fjwA11xzDYsXLw6rf/311znhhBMYM2YMubm5rF69mpSUFOLi4rjhhhuYPXs2CQkJboTebNr25nVCKoy+iq7LX+KSwd/l2YXfcu2440iJ87odmTHmaESwZd9SRKTB15s2beL3v/89X375JV26dOH666+noqICj8fD0qVL+eijj3jttdd48sknmT9//rEOvdm07REDwMnTwe/jzm6fUlTu4/nFm9yOyBjThm3dupUlS5YAzq09TzvttNq64uJiEhMT6dSpE7t37+b9998HnIvvFRUVcd555/H444+3+Rv2tP3E0G0QDDmH7ute5oLju/Dcok3sP1DldlTGmDbq+OOP58UXXyQrK4vCwkKmT59eWzdq1CjGjBnD8OHDmTZtWu0up5KSEqZOnUpWVhYTJ07ksccecyv8ZtG2dyUFjbsJXnyfX/ddybtr+/LXRZu4fcpQt6MyxrQxGRkZ9Z6v8PHHH9cuv/DCC/W+d+nSpS0U1bHX9kcMABmnQc+R9Fr9POeP6MnfPt1EYZmNGowx5ki0j8QgAuNuhr3r+PXQ7ZT7/Px54Ua3ozLGmDapfSQGgOGXQFJPeq9+notG9+Glz7aQX1LZ+PuMMcaEaT+JIXDCG98u4Bej/VT5a3jmExs1GGNMU7WfxACQPQ088aSv/RuXjOnDy59vYXdx5PcBMsYY094SQ0IqjL4SVr7Oz07pgr9GeXrBBrejMsaYNqV9JQaAU2aAv5L0ja/w3ex0Xl26je37y92OyhjTyk2aNIkPPvggrOzxxx9nxowZEb3/3nvvZd68eS0R2jHX/hJDt8EweAos/Qs3T+iLojxlowZjTCOuvPJKXnvttbCy1157jSuvvLLR9/r9fmbNmsVZZ53VUuEdU+0vMQCMmwEH9tJn67tccWI/Xv9yG9sKD7gdlTGmFbvssst49913qax0jmbcvHkzO3bs4JVXXqn3MtsZGRnMmjWL0047jTfeeIPrr7+ef/3rXwDMmjWLE088kREjRnDjjTeiqoAzKrnjjjs46aSTGDJkCIsWLQKcxHL77bczcuRIsrKyeOKJJwBYtmwZEydOZOzYsUyZMoWdO3cek59F+zjzua7+E6HHCFjyFDddvYB/5mzjifnf8Mhlo9yOzBgTgd8t/R1rC9c26zqHpQ7jjpPuaLC+a9eunHTSScydO5eLLrqI1157jcsvv5y77rrrkMtsZ2VlARAXF1d79dW5c+fWruvmm2/m3nvvBeDaa6/l3Xff5YILLgCc+z0sXbqU9957j5kzZzJv3jyeffZZNm3axH//+188Hg+FhYX4fD5uueUW3n77bdLS0vjnP//J3XffzfPPP9+sP5f6RDRiEJFUEXlTRMpEZIuIXHWYtreKyC4RKRKR50UkNqTuYxGpEJHSwGNdc3yJeoJw5hry19CzYAlXn9yPfy/fzua9ZS3yccaY9iF0d1JwN1J9l9kOuvzyy+tdz4IFCzj55JMZOXIk8+fPJzc3t7bukksuAWDs2LFs3rwZgHnz5vGTn/wEj8fZVk9NTWXdunV8/fXXTJ48mdGjR/Pggw+Sl5fXEl/7EJGOGJ4CqoAewGhgjoisUNXc0EYiMgW4EzgD2AG8CcwMlAXdrKp/PdrAGzXyMph3Pyx5iukX/YNXl27ljx99w6OXj27xjzbGHJ3Dbdm3pIsvvpjbbruN5cuXU15eTpcuXeq9zHZQYmLiIeuoqKhgxowZ5OTk0LdvX+6///6w98TGOtvK0dHRVFc7tyRW1UMu962qDB8+vPZKr8dSoyMGEUkELgXuUdVSVV0MvANcW0/z64DnVDVXVfcBDwDXN2O8kfPEOie8bZhH9/LNfH9cBm99tZ0Ne0pdCccY0/olJSUxadIkpk2bxpVXXtngZbYPJ5gEunXrRmlpae28w+GcffbZPPPMM7WJorCwkKFDh5Kfn1+bGHw+X9jIoyVFsitpCOBX1fUhZSuA4fW0HR6oC23XQ0S6hpQ9LCJ7ReRTEZnU0IeKyI0ikiMiOfn5+RGEWY/saeCJg8+f5scTBhDnjeYPH31zZOsyxnQIV155JStWrOCKK65o8DLbh9O5c2d+9KMfMXLkSC6++GJOPPHERt9zww030K9fP7Kyshg1ahSvvPIKMTEx/Otf/+KOO+5g1KhRjB49ms8++6w5vmKjJDhb3mADkdOBN1S1Z0jZj4CrVXVSnbYbgZtUdW7gtRdnF1R/Vd0sIicDqwNlVwBPAqNV9bDXrsjOztbgjbib7J2fwsp/wq25PLJoL3/6ZCNzfzaBoT2Tj2x9xpgWsWbNGo4//ni3w2iz6vv5icgyVc1u6roiGTGUAil1ylKAkgjaBpdLAFT1C1UtUdVKVX0R+BQ4r2khN9EpM6C6AnKe58YJA0iM8fD4vPWNv88YYzqoSBLDesAjIoNDykYB9e3syg3UhbbbraoFDaxbAWmgrnl0HwaDzoKlf6FzjDLttP68//UucncUtejHGmNMW9VoYlDVMmA2MEtEEkVkPHAR8Pd6mr8E/FBEMkWkC/Ab4AUAEeksIlNEJE5EPCJyNTAB+KCe9TSvcTdB2R5Y9S9+eFp/UuI8PPahzTUY09o0tmvb1K+5f26Rnvk8A4gH9gCvAtNVNVdE+gXOR+gXCG4u8AiwANgSeARPFfQCDwL5wF7gFuBiVW2ZcxlCDfgOdM+Ez5+mU5yHH50+gHlrdrMyb3+Lf7QxJjJxcXEUFBRYcmgiVaWgoIC4uLhmW2ejk8+twVFNPgct/zu8czN8/21Keo/n9EcWMKZvZ/72g5OaJ0hjzFHx+Xzk5eWFHfNvIhMXF0d6ejperzes/Egnn9vnJTHqM/K78NFMWPI0yVdP4scTBvK7uWtZtmUfY4/r4nZ0xnR4Xq+X/v37ux2Gob1eRK8+3jg48Qb45gPIX8/3xx1H18QYO0LJGGPq6DiJASD7hxAdC1/8icRYD9MnDWTRN3tZuqnQ7ciMMabV6FiJISkNsr4HX70KBwq5+uTjSEuO5dEPW37+2xhj2oqOlRggcMJbOeQ8T3xMNDdNGsjn3xby2Ya9bkdmjDGtQsdLDD0yYeAZsPQvUF3FFSf1o1enOB79cL0dJmeMMXTExABwyk1QugtyZxPnjeam7wwiZ8s+Fn5jowZjjOmYiWHQmZA2DJY8Cap8L7svfTrH26jBGGPoqIlBBE6ZDrtWwebFxHiiuOWMQazYtp/5a/e4HZ0xxriqYyYGgKzLIaErLHkKgEvHptMvNcFGDcaYDq/jJgZvvHNew/q5ULARb3QUPz1zMLk7ivkgd7fb0RljjGs6bmIA50zoaC98/icALh7dmwHdEnl83npqamzUYIzpmDp2Ykju4VxD6at/wIFCPNFR/OyswazdVcL7X+9yOzpjjHFFx04M4ExC+w7A8hcBmJrVm8Hdk3hs3nr8NmowxnRAlhh6joT+E+GLZ8HvIzpK+PlZQ9iwp5R3V+5wOzpjjDnmLDGAc4e3kh2Q+xYA547oybCeyTw+7xuq/TUuB2eMMceWJQaAQZOh6+DaE96iooRbJw9h094y3vrKRg3GmI7FEgNAVJQz17DzK9i6BICzM3swok8Kf/zoG3w2ajDGdCCWGIJGXQnxXWpPeBMRbps8hK2FB/j3sjyXgzPGmGPHEkNQTAJkT4O1c6DwWwC+M7Q7o/t25on5G6is9rscoDHGHBuWGEKd+COI8sDnzwAHRw3b95fzeo6NGowxHYMlhlApvWDEpfDfl6F8PwCnD+5G9nFdeGr+Bip8NmowxrR/ESUGEUkVkTdFpExEtojIVYdpe6uI7BKRIhF5XkRi62kzWEQqROTlowm+RYybAb6y2hPeRITbzh7CruIKXl261eXgjDGm5UU6YngKqAJ6AFcDfxKR4XUbicgU4E7gTCADGADMbGB9Xx5BvC2v1yjIOL32hDeAUwd245QBqTy1YCPlVTZqMMa0b40mBhFJBC4F7lHVUlVdDLwDXFtP8+uA51Q1V1X3AQ8A19dZ3xXAfuCjo4y95Yy7CYrzYPXbtUW3TR7K3tJKXv58i4uBGWNMy4tkxDAE8Kvq+pCyFcAhI4ZA2Yo67XqISFcAEUkBZgG/aOxDReRGEckRkZz8/PwIwmxGg6dA6kDn0NXAvRlO6p/K6YO78cwnGymrrD628RhjzDEUSWJIAorqlBUByRG0DS4H2z6AM6LY1tiHquqzqpqtqtlpaWkRhNmMgie87VgO276oLb518hAKyqp4ccnmYxuPMcYcQ5EkhlIgpU5ZClASQdvgcomIjAbOAh5rapCuGH0VxHWuPeEN4IR+XfjO0DSeXfgtJRU+F4MzxpiWE0liWA94RGRwSNkoILeetrmButB2u1W1AJiEMyG9VUR2AbcDl4rI8iOIu+XFJEL2D2Dtu7Bvc23xbZOHsv+Aj799urnBtxpjTFvWaGJQ1TJgNjBLRBJFZDxwEfD3epq/BPxQRDJFpAvwG+CFQN2zwEBgdODxDDAHmHK0X6LFnHQjSBR88efaopHpnZgyvAd/+ngjefsOuBicMca0jEgPV50BxAN7gFeB6aqaKyL9RKRURPoBqOpc4BFgAbAl8LgvUHdAVXcFHzi7nSpU9RjPLDdBSm8YfgksfwkqDk6d3HvBcETg3rdzUbWb+Rhj2peIEoOqFqrqxaqaqKr9VPWVQPlWVU1S1a0hbR9V1R6qmqKqP1DVygbWeb+qXtM8X6MFjZsBVaWw/OAAqU/neG6bPIT5a/cwZ9VOF4MzxpjmZ5fEaEzvMXDcePjiGfAfPEz1+lMzGNmnE/e/s5qiAzYRbYxpPywxROKUGVC0Ddb+p7bIEx3Fw5eMpLCskt/OXeticMYY07wsMURi6LnQpX/YoasAI/p04oen9efVpVv5cnOhS8EZY0zzssQQiaho54S3vC9h29KwqlsnD6FP53jumr3K7tlgjGkXLDFEavTVENvpkFFDQoyHBy8ewYY9pfz5k29dCs4YY5qPJYZIxSbB2OtgzTuwL/xCet8Z1p2pWb14cv4GNuaXuhSgMcY0D0sMTXHyjwGBpc8eUnXvBZnEeaO4+81Vdm6DMaZNs8TQFJ3SYfjFzglvleGXiuqeHMdd5x3P598W8sYyuw2oMabtssTQVKfcBJXFzu0/67g8uy8nZnThf99bw97Ses/rM8aYVs8SQ1Olj4V+42DRo1C+L6wqKkp4+JKRlFVW8+C7q10K0Bhjjo4lhiNxzm/hQAF88JtDqgZ1T2b6pEG89dUOFq5vvZeBMsaYhlhiOBK9R8P4n8JXL8PG+YdUz5g0kAHdErn7rVV2j2hjTJtjieFITbwDug6C//wMKsMPUY3zRvO/l4xkW2E5f/joG5cCNMaYI2OJ4Uh54+HCJ2H/Vpj/wCHVpwzoyvey0/nLom9ZvaPYhQCNMebIWGI4GseNgxN/5NzIZ+sXh1T/+rzj6Rzv5a43V+GvsXMbjDFtgyWGo3XWfZDSB965GXwVYVWdE2K494JMVmzbz8ufb2lgBcYY07pYYjhasclwweOwdz0s+v0h1ReO6s3pg7vxyNy17CwqdyFAY4xpGksMzWHwZMi6AhY/BrtWhVWJCA9dPBK/Kve9netSgMYYEzlLDM3lnIchvgu8fVPYnd4A+nVN4OdnDeH/Vu9m7te7XArQGGMiY4mhuSSkwnn/D3augCVPHlL9w9P6M6xnMve/k0tJhd0K1BjTelliaE6ZF8OwqfDxw7B3Q1iVNzqK316axe6SCn7/wTqXAjTGmMZZYmhOInDe7yE6Fv7zU6ipCase3bcz143L4KXPt7B8674GVmKMMe6KKDGISKqIvCkiZSKyRUSuOkzbW0Vkl4gUicjzIhIbUveyiOwUkWIRWS8iNzTHl2hVUnrBlIdgy6ew7PlDqm+fMpSeKXH8evYqfP6aelZgjDHuinTE8BRQBfQArgb+JCLD6zYSkSnAncCZQAYwAJgZ0uRhIENVU4ALgQdFZOwRR99ajbkG+k+ED++D/dvCqpJiPcy8cDhrd5Xwl0V2K1BjTOvTaGIQkUTgUuAeVS1V1cXAO8C19TS/DnhOVXNVdR/wAHB9sDJQHrxRgQYeA4/uK7RCInDBH0Br4N1boc4d3c4e3pMpw3vwh3nfsKWgzKUgjTGmfpGMGIYAflVdH1K2AjhkxBAoW1GnXQ8R6RosEJGnReQAsBbYCbxX34eKyI0ikiMiOfn5bfDy1an94Yx7YMOHsOqNQ6pnXjgCb3QUd7/5td0K1BjTqkSSGJKAojplRUByBG2Dy7VtVXVG4PXpwGyg3ludqeqzqpqtqtlpaWkRhNkKnfxjSD8R3r8DSsOTW89OcfzqnKEs3rCXt77a7lKAxhhzqEgSQymQUqcsBSiJoG1wOaytqvoDu6TSgemRhdoGRUU7V2CtKoX3f3VI9dUnH8eYfp154N017CurciFAY4w5VCSJYT3gEZHBIWWjgPqu75AbqAttt1tVCxpYt4f2OMcQqvswmPBLyJ0Na+eEVUUHbgVaXO7joffWuBSgMcaEazQxqGoZzi6fWSKSKCLjgYuAv9fT/CXghyKSKSJdgN8ALwCISHcRuUJEkkQkOnAE05XAobdAa2/G/xy6D4c5v4Dy/WFVw3qmcOOEAfxrWR6fbdjrUoDGGHNQpIerzgDigT3Aq8B0Vc0VkX4iUioi/QBUdS7wCLAA2BJ43BdYh+LsNsoD9gG/B36uqm8315dptTwxcNGTULobPrz3kOqfnjmY47omcPdbX1Phs1uBGmPcJW3hiJjs7GzNyclxO4yj93/3wGd/hO+/AwMmhlUt/mYv1zz3BbecMYhfnD3UpQCNMe2JiCxT1eymvs8uiXEsTboLUgc4l8uoCj9/4bTB3bhkTB+e+WQj63fXN69vjDHHhiWGYykmAS58AvZthgX/e0j13ecfT1Ksh7tmr6LGbgVqjHGJJYZjLeM0yJ4Gnz8NeeG7x7omxXL3+Zks27KPV7/c6lKAxpiOzhKDG86aCcm94O2boTr8/L5LT+jDqQO78tv317KnuKKBFRhjTMuxxOCGuBSY+hjkr4FFj4ZViQgP/c9IKqtrmPmf1S4FaIzpyCwxuGXIFBj5XVj0/8Hu8HMF+3dL5KdnDGLOqp18tGa3SwEaYzoqSwxuOud3zujh7ZuhJvz8hRsnDGRIjyTufTuXssrqBlZgjDHNzxKDmxK7wrmPwI7lzmR0iBhPFA9fMpLt+8t59MP1DazAGGOanyUGt424FIacC/MfgoKNYVVjj0vl6pP78bdPN7Eqr+4Fbo0xpmVYYnCbCEx9FKK98J+fHXJTn1+dM4yuSbHcOXsl1XYrUGPMMWCJoTVI6Q1nPwCbF8HyF8OqOsV7mXnhcHJ3FPO3Tze7E58xpkOxxNBanHAdZJzuXE+peEdY1bkjenLmsO48+uF6thUecClAY0xHYYmhtQjeJ9rvg3dvC9ulJCLMungEInDP23YrUGNMy7LE0Jp0HQhn3A3r34ev/x1W1adzPL84eygfr8vn3ZU7XQrQGNMRWGJobU6ZAX3GOrcCLQu/8d31p2Ywsk8nZv5nNUUHfC4FaIxp7ywxtDbB+0RXFMPcO8OqgrcC3Xegit/OtVuBGmNahiWG1qhHJpz+C1j1Oqz/IKxqRJ9OTBufwatLt7F0U6FLARpj2jNLDK3V6b+AtOPhPz93Rg8hbp08hD6d4/n1m6uorLZbgRpjmpclhtbKEwMXPQWlu2DefWFVCTEeHvyfEWzYU8ozH3/rUoDGmPbKEkNrlj7WmYzOeR42Lw6r+s7Q7kzN6sVTCzawMb/UpQCNMe2RJYbW7ju/hi4Z8M4tUBV+ctu9F2QS543i17NX2bkNxphmY4mhtYtJhAv+CIXfwscPh1V1T47jrvOO54tNhbyRk+dSgMaY9iaixCAiqSLypoiUicgWEbnqMG1vFZFdIlIkIs+LSGygPFZEngu8v0RE/isi5zbXF2nXBkx0Lpmx5EnYvjys6vLsvpyUkcpD761hb2llAyswxpjIRTpieAqoAnoAVwN/EpHhdRuJyBTgTuBMIAMYAMwMVHuAbcBEoBNwD/C6iGQccfQdyeRZkNQjcJ/oqtriqCjhfy8ZwYGqau789yr2lNh9oo0xR6fRxCAiicClwD2qWqqqi4F3gGvraX4d8Jyq5qrqPuAB4HoAVS1T1ftVdbOq1qjqu8AmYGwzfZf2Lb4znP8o7MmFT/8QVjWoezK3TR7KvDW7GffwfG54MYcPV+/GZ5fpNsYcAU8EbYYAflUNvY3YCpwt/7qGA2/XaddDRLqqatj1HUSkR2Dd4Tc8Ng0bdh4MvwQWPgLHXwDdh9VWTZ80kMmZPXhj2Tb+vWw789bsJi05lktO6MN3x/ZlUPckFwM3xrQlkexKSgLq3j6sCEiOoG1wOaytiHiBfwAvqura+j5URG4UkRwRycnPz48gzA7i3EcgJgneOfQ+0YO6J3HXucez5K4z+Mv3sxndtzN/XeZdxCkAABhMSURBVLSJsx79hMv+9Bmvf7nN7h9tjGlUJImhFEipU5YClETQNrhc21ZEooC/48xZ3NzQh6rqs6qararZaWlpEYTZQSSlwbm/g7wvYemz9TbxRkcxObMHf/l+NkvuOoM7zx1G4YEqfvXvlZz40Dx+9a8VLNtSaIe4GmPqFcmupPWAR0QGq+o3gbJR1L8LKDdQ93pIu93B3UgiIsBzOJPY56mqXSL0SIz8Lqx6Az6aBUPPdc5zaED35Dh+MnEgP54wgGVb9vF6zjbeXbmT13PyGJiWyPey+3LJCemkJcceu/iNMa2aRLLVKCKvAQrcAIwG3gNOVdXcOu3OAV4AzgB2Av8GlqrqnYH6ZwLvP0tVIz5dNzs7W3NyciJt3jEU5cFTJ0N6Nlz7lnOjnwiVVlbz3sqd/DNnG8u27CM6SjhjWHcuz+7LpKFpeKLt9BZj2gMRWaaq2U1+X4SJIRV4HpgMFAB3quorItIPWA1kqurWQNvbgDuAeJzE8BNVrRSR44DNQCUQuqP7x6r6j8N9viWGBnz5V5jzC+cy3SfUd5BY4zbsKeWNnG38e/l29pZWkpYcy6UnpPPd7HQGptmEtTFtWYsmBrdZYmhATQ28OBV2fQ03fQEpvY54VT5/DQvW7uH1nDwWrNuDv0Y5MaML383uy/kje5EYG8leR2NMa2KJoaPauwGeGQ+DzoLLX27SLqWG7CmuYPZ/t/P6l9v4dm8ZiTHRTM3qzfdO7MsJ/TojzfAZxpiWZ4mhI1v8uHNp7u++AMP/p9lWq6os27KPf365jTmrdnKgys+g7kl8Lzud/xljE9bGtHaWGDoyfzX89UzIXwuDJ8OwqTD4bEhIbbaPKK2sZs7KHfzzy20s37ofT2DC+ns2YW06OFWlqNxHUqyn1f0fWGLo6PZvg8WPwbr3oGQnSDQcd6qTJIadB537NdtHbdhTwus5ecxensfe0qraCevvZaczwCasTTvhr1EKSivZU1LJnpIK9hQfXM4vCSwXV5JfWklVdQ3zbpvY6q4wYInBOGpqYOd/Ye0c55EfOLG8Z1YgSZwPPYY3y1yEz1/D/LV7eCNnGwvW5eOvUU7KSOW72emcn9WLhBibsDatT4XPX9ux55dUBJ4rAx1/RaDzr6SgtJKaerrHzgleuifH0j05ju7JsaSlOMsXje5Nt6TWtXvVEoOp394NsG4OrH0Ptn0BqDN6CCaJvqdA9NF34HuKK/j38u28kXNwwvqCUb25dGw6WemdiPVEH/13MaYBqkppZXXtVnxwq752yz5ki7+o/NDzaqMEuiXF0j0lpMNPjg08xwXKnbK29LdsicE0rnQPrHvfGUl8+zH4KyE+1Tl7etj5MOA7EJNwVB+hquQEJ6xX7qTc58cTJQzqnsTxvVLI7JVCZu8Uju+VQmpiTPN8L9OuqCoVvhpKKnwUV1RTXOGjpKLaeV1ezf7yKmcXTknIFn5xJeU+/yHrivFEhXXywU4/mADSAstdE2OJjmp/R9tZYjBNU1kCGz5yksQ3H0BFEXjiYeAZTpIYcg4kdj2qjyitrGbh+nxW7yhm9c5iVu8oZlfxwftF9EyJCySJZDJ7dSKzdwrHpSYQ1Q7/QTuSqmqnU3c680CHHujkSyqqKS73hZUH24UmAJ//8P1SUqznYIefEujsk8O3+Lsnx5ES7+nQh1dbYjBHzu+DLZ8enJco3g4SBf1OdSauh51/2OsxNUVhWRVrAkli9c5i1uws5ps9pfgDO3MTYqIZ1jO5dlSR2SuFYT1TiI9pO8P3tq6mRtl3oIqCsir2lVUd0mkXhzyHd/LOc4Wv8fuAJMV6SI5zHilx3sCyl5R45zm0vPY53nnuFO+1+asIWWIwzUMVdn4VSBLvOTcGAugxwkkQw853JrKbcSuswudnw57S2lFFMGGUVDhXTokS6N8t0UkUvQO7o3qlkJYc26G3Bpuiwudnb2klBaVVB5/LKtlbUkVB2cHyvaVVFJbVP+kaFOuJqu2kk+O8pIR17nU7+vDylDgvSXGedrnbpjWyxGBaRuG3ToJYOwe2fQ5aA536wtDASOK4UyHa2+wfq6rk7SuvTRLBhJG3r7y2TbekmLB5i8xeKfTvltjqjiVvCcFj54Od+cEOv5L80ioKSispKDuYBEobuA9HYkw0XZNi6ZYUU/vcLSmWronO6y4JMbVb8SmBzj7G0/5/vu2FJQbT8sr2wvq5TpLYOB+qKyCuszMfMex8GHQmxCS2aAhF5T7W7jw4Z7FmVzHrd5VSFbiNaawniqE9k8nslVI7whjWM5nkuOZPXs2tstpPYVkVe0ucrfnQzr6gtIr8kC3+wrIqquvZrI8SSE2MoWtiLN2Sneeugc6+ttMPdPzdkmJtF107Z4nBHFtVZU5yWDvHOdKpYj944mDApMDk9bnOTYWOAZ+/ho35pWEji9U7itl34OBhif1SE2pHFkN7JhPjiaLar/hravD5lerAs79GqfYfLKuuUar9gbJAXW1ZyHt8/prasmC9r7ZtSFlNTeBzD9YH31vfUTUAcd6o2g49LenQTj8t2NknxdAlIcZ205halhiMe/zVsHXJwcnroq2AQL9TYMgU6DkSug2FTunNOjdxOKrK7uJKVu8sckYWO0tYvbOYzQVlHOmfvDda8ERF4YkWvNFReKLEeUQHyqKiiI4Sp12g3hsdUhZ4b/A9dcs6xXsPbs0nx9It0PHblW3NkbLEYFoHVdi16mCS2L3qYJ03EboNhrSh0G1I4HkopPZvkXmK+pRVVrNhTyl+Vby1nbwQHXWwIw/tvEM7d2MaVF0FUR6Ial3zL5YYTOtUtte5LEf+Oti7/uBz8faDbaI8kDoQ0oY4iSKYOLoNbvE5C9NB1dRAVanzqCyFqpLAc53XlSWNt6kqBX8VzPgCug9z+5uFOdLEYGNU07ISu0HiaZBxWnh5ZUkgUayHveuc5z1rnCOgNGRfe6d+9Y8yjvLkO9NKqUKN3/kbqKl2loPPwbLqypDOuW7nXd/rejp1X1mEAQnEJkNMEsQmHXxO6Bb+OiYZ4ru06I/mWLLEYNwRmwx9xjqPUNVVULgxMLL4JpA01sGWz6D64KGqJHQNjC6GhD8fw3mMNkHVOXrMVw6+A+CrCDyXhz+HtQl59leFdNDBTrraOWw5uFxf511T7WyV17b3R7YerX8Cvkk88Yd22kk9nFFp8HVsUkiHX7fjD3ntTeiQf0+WGEzr4omB7sc7j1A1NVC0LWR3VGCUsfptKN93sF0rmMeoV43fOcO8phpqfM6Efe2yz6lvqHOubqAz9zXQ3lfuJNFg2ZGIjgVvPETHOD83iYao6MB+9JBnCS4Hy2Oc5dryqIP1Evr+kPdJVJ11NLTu4Gtv/Z14TODRDBeF7OjsJ2jahqgo6HKc8xg8+WC5qjOPERxZBBPH5sWw8p8h7w+Zx+g62OnsaqpDOuvgsi+kE6+7XB3o0OtbrrueOss001xesMP2JtR5joP4znXK4p2t53rbhz7q1HninE7YdFiWGEzbJuKcL5GU1vR5DIl2EkRwq7R22etsdda77HVGNcHlqOiQ5brrOdw662njiQvpoOOswzauscRg2q+G5jFqAhd5a2WHFhrTWlhiMB2PJQRjDiui/xARSRWRN0WkTES2iMhVh2l7q4jsEpEiEXleRGJD6m4WkRwRqRSRF5ohfmOMMc0s0k2np4AqoAdwNfAnERlet5GITAHuBM4EMoABwMyQJjuAB4HnjzxkY4wxLanRxCAiicClwD2qWqqqi4F3gGvraX4d8Jyq5qrqPuAB4PpgparOVtW3gILmCN4YY0zzi2TEMATwq+r6kLIVwCEjhkDZijrteohIk09TFZEbA7udcvLz85v6dmOMMUcoksSQBBTVKSsCkiNoG1yur+1hqeqzqpqtqtlpacfm8s3GGGMiSwylQEqdshSgJIK2weX62hpjjGmFIkkM6wGPiAwOKRsF5NbTNjdQF9put6ranIIxxrQRjSYGVS0DZgOzRCRRRMYDFwF/r6f5S8APRSRTRLoAvwFeCFaKiEdE4oBoIFpE4kTEzqUwxphWJNLDVWcA8cAe4FVguqrmikg/ESkVkX4AqjoXeARYAGwJPO4LWc9vgHKcQ1qvCSz/pjm+iDHGmOZhN+oxxph26khv1GPXBjDGGBPGEoMxxpgwlhiMMcaEscRgjDEmjCUGY4wxYSwxGGOMCWOJwRhjTBhLDMYYY8JYYjDGGBPGEoMxxpgwlhiMMcaEscRwBFSVGq1xOwxjjGkRdsnrCJX5yvh8x+cs3L6QRXmLyC/PJ94TT7wnngRPAgnehLDl+spq2zdQn+BJIDY6FhFx++sa0+7VaA3l1eWUV5dzwHeAA9UHDvt8SNs69X89+69kdMpw+2s1C0sMh7G1eCuf5H3CwryF5OzOobqmmiRvEqf2PpUBnQdQ7iuv/QMJLpdVl5Ffnh/2R1Thr4j4M6Mk6pBkEe+JJ94bKAu8Dk0uwbKkmCRSYlLoHNuZzrGdSY5JJjoqugV/Qsa0PFXFV+Or7YTr7chDloP/i4fr8IP/n5GKkqiD/3+B/8V4Tzxd4rrQx9OHBK+zUddeWGII4fP7WLZnGQvznFHB5uLNAPTv1J+rh13NhPQJjOkxBm+Ut0nr9df4DyaKerZCGtsyKa8up6iiiJ3VO8Pa+Gp8h/1cQUiOSa5NFCmxKfUud4rtRKfYTrWvEzwJNmoxTRbswOv+7R7JcvD/ItjJ+9UfcRyx0bGHbEDFe51OvHaDqoGRfe0GWJ0Nr442ku/wiWFv+V4W5S1i0fZFfLbjM8p8ZXijvJzU8ySuGHYFE9In0De571F9RnRUNEkxSSTFJDVT1A6f3xf2z1TqK2V/5X6KKosoqiw6ZLmgvIBNRZvYX7mfMl9Zg+v1RHnoFNOp3qRxuIQSEx3TrN/PtBxVpcJfQZmvjHJfOWXVZZT5yjjgc0a95b5y53UTOvRyXznVWh1xDB7xHOyUQ0a+aQlpYR17fbtjE72J4SPnkHpPVIfv1o5ah/sJ1mgNqwtWszBvIQvzFpJb4Ny6unt8d87JOIcJ6RM4pdcpJHgTXI60cd5oL52inc65qXx+H0VV9SeQuq/zSvPI3ZvL/sr9VNVUNbjOeE98baLoFOPElRKbQmx0LDFRMXijvXijvMRExzivA8u15VExTl20U+eN9oa1qy0PvO5IHUB1TfXBkWWgMw7tyIPlweVgp163beiul0gPoPCIh3hv/CG7OLvGdaVvct9Dt84bWQ6uxxvdtJG3OXY6xH9WaVUpS3Yuqd1FVFBRgCBkpWVxy5hbmJA+gaFdhnaooaI32ku3+G50i+8W8XtUlfLqcoqriutNIHWfd+/bTXFVMT6/j6qaKqr8VSjNd8fAKImqTSiHJJ3ohsu9UV6Ew/+umzPOSO6SqCiV/sqwTr3MV0Z5tbPlXumvjPjzgh1vojextlNOjUulb3Jfpyykcw+2SfQkEu+Nr60PbeeN8nao/w3TjhPD5qLNtaOCZXuWUV1TTXJMMuN7j2dC+gTG9xlPalyq22G2KSLidCjeBHom9mzy+1UVv/qp8lfhq/Hhq/FR5a+qfV1VU+UkkeBrf5VTVuMLL685+J5g0glNPqHlVf4qZ46msijsMyP6vo0kj9CfS3OIjY6t7ai7xHUJ66TjvfEkegKdeGjnHujUg+XxnniixI5CN0en3SQGn99Hzu6c2mSwtWQrAIM6D+LazGuZ0GcCo7uP7lC7H1obEcEjHvsdGNPKten/0PwD+SzavoiFeQtZsmMJB6oPEBMVw0m9TuKazGuYkD6BPkl93A7TGGPalDaVGGq0hty9ubXnFqwpXANAj4QeTB0wlQnpEzip10nEe+JdjtQYY9quiBKDiKQCzwFnA3uBu1T1lQba3grcAcQD/wamq2plU9cTqriqmLsX383i7YsprCgkSqIYlTaKn53wM07vczpDugyxyTFjjGkmkY4YngKqgB7AaGCOiKxQ1dzQRiIyBbgTOAPYAbwJzAyURbyeuraVbOPjbR8zvs94JqZPZHzv8XSO6xxh6MYYY5pCGjuUTkQSgX3ACFVdHyj7O7BdVe+s0/YVYLOq/jrw+kzgH6rasynrqStzVKau/O9Km7Q0xpgmEJFlqprd1PdFclzbEMAf7MwDVgDD62k7PFAX2q6HiHRt4noQkRtFJEdEcsr2l1lSMMaYYySSxJAEFNUpKwKSI2gbXE5u4npQ1WdVNVtVs9PS0iII0xhjTHOIJDGUAil1ylKAkgjaBpdLmrgeY4wxLokkMawHPCIyOKRsFFDfhHFuoC603W5VLWjieowxxrik0cSgqmXAbGCWiCSKyHjgIuDv9TR/CfihiGSKSBfgN8ALR7AeY4wxLon0oiozcM5L2AO8inNuQq6I9BORUhHpB6Cqc4FHgAXAlsDjvsbW0yzfxBhjTLNo9HDV1iA7O1tzcnLcDsMYY9qUljxc1RhjTAdiicEYY0wYSwzGGGPCtIk5BhEpAda5HUcd3XAuBNiaWEyRa41xWUyRsZgiN1RV6z2J+HDaynUm1h3JBEpLEpEci6lxrTEmaJ1xWUyRsZgiJyJHdNSO7UoyxhgTxhKDMcaYMG0lMTzrdgD1sJgi0xpjgtYZl8UUGYspckcUV5uYfDbGGHPstJURgzHGmGPEEoMxxpgwlhiMMcaEabWJQURuDtzas1JEXnA7HgARiRWR50Rki4iUiMh/ReTcVhDXyyKyU0SKRWS9iNzgdkxBIjJYRCpE5GW3YwEQkY8D8ZQGHq3ixEkRuUJE1ohImYhsFJHTXYyltM7DLyJPuBVPSFwZIvKeiOwTkV0i8qSIuHoulogcLyLzRaRIRDaIyP+4EEODfaWInCkia0XkgIgsEJHjIllnq00MwA7gQeB5twMJ4QG2AROBTsA9wOsikuFiTAAPAxmqmgJcCDwoImNdjinoKeBLt4Oo42ZVTQo8hrodjIhMBn4H/ADnVrcTgG/diifkZ5ME9ADKgTfciifE0ziX7O8FjMb5P5zhVjCBpPQ28C6QCtwIvCwiQ45xKPX2lSLSDeceOPcE4ssB/hnJClttYlDV2ar6FlDgdixBqlqmqver6mZVrVHVd4FNgKudsKrmqmpl8GXgMdDFkABnKxjYD3zkdiyt3Exglqp+Hvi72q6q290OKuAynM54kduBAP2B11W1QlV3AXOB4S7GMwzoDTymqn5VnQ98Clx7LIM4TF95CZCrqm+oagVwPzBKRIY1ts5WmxjaAhHpAQyhFdyeVESeFpEDwFpgJ/Cey/GkALOAX7gZRwMeFpG9IvKpiExyMxARiQaygbTAroi8wC6SeDfjCnEd8JK2juPa/wBcISIJItIHOBcnObhFGigbcawDacBwYEXwReAumhuJIJlaYjhCIuIF/gG8qKpr3Y5HVWfg7IY4HWf4WHn4d7S4B4DnVHWby3HUdQcwAOiDc/LPf0TEzdFVD8CLs2V+Os4ukjE4t8V1VeDOjBOBF92OJeATnE6tGMjD2TXylovxrMUZTf1SRLwicjbOzyvBxZhCJQFFdcqKcPqJw7LEcAREJArnXtVVwM0uh1MrMJxdDKQD092KQ0RGA2cBj7kVQ0NU9QtVLVHVSlV9EWfof56LIZUHnp9Q1Z2quhd41OWYgr4PLFbVTW4HEvif+wBnoycR52qmXXDmZlyhqj7gYuB8YBfO6Ph1nKTVGpQCKXXKUoCSxt5oiaGJRESA53C29C4N/HG0Nh7cnWOYBGQAW0VkF3A7cKmILHcxpoYo9e8SODYfrroPpyNpDbtq6vo+rWe0kAr0BZ4MJPUC4G+4nEBVdaWqTlTVrqo6BWc0utTNmELkAqOCL0QkEadfaHTXd6tNDCLiEZE4IBqIFpE4tw9NC/gTcDxwgaqWN9a4pYlI98ChjkkiEi0iU4ArgfkuhvUszh/g6MDjGWAOMMXFmBCRziIyJfi3JCJX4xwB9IGbceF0cLcEfpddgJ/jHOniGhE5FWd3W2s4GonASGoTMD3wu+uMM/+x4vDvbFkikhX4e0oQkdtxjph64RjH0FBf+SYwQkQuDdTfC6yMaNe3qrbKB84MutZ53O9yTMcF4qjAGaYFH1e7GFMazr7X/Tj7XlcBP3L791fP7/LlVhBHGs6hsyWBn9fnwORWEJcX51DM/Ti7JP4IxLkc05+Bv7v9s6kT02jgY2Afzk1x3gC6uxzT/wvEUwq8DwxyIYYG+0qcXbprcXZZfoxzWHuj67SL6BljjAnTanclGWOMcYclBmOMMWEsMRhjjAljicEYY0wYSwzGGGPCWGIwxhgTxhKDMcaYMJYYjDHGhPn/ASRfQYUwyrdsAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "\n", "import matplotlib.pyplot as plt\n", @@ -1756,10 +2240,8 @@ }, { "cell_type": "code", - "execution_count": 17, - "metadata": { - "collapsed": false - }, + "execution_count": 16, + "metadata": {}, "outputs": [], "source": [ "# Common imports\n", @@ -1810,11 +2292,22 @@ }, { "cell_type": "code", - "execution_count": 18, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "\n", "# Common imports\n", @@ -1852,11 +2345,24 @@ }, { "cell_type": "code", - "execution_count": 19, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LogisticRegression 0.864\n", + "RandomForestClassifier 0.872\n", + "SVC 0.888\n", + "VotingClassifier 0.896\n", + "LogisticRegression 0.864\n", + "RandomForestClassifier 0.872\n", + "SVC 0.888\n", + "VotingClassifier 0.912\n" + ] + } + ], "source": [ "from sklearn.model_selection import train_test_split\n", "from sklearn.datasets import make_moons\n", @@ -1911,11 +2417,22 @@ }, { "cell_type": "code", - "execution_count": 20, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "VotingClassifier(estimators=[('lr', LogisticRegression(random_state=42)),\n", + " ('rf', RandomForestClassifier(random_state=42)),\n", + " ('svc', SVC(random_state=42))])" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "from sklearn.model_selection import train_test_split\n", "from sklearn.datasets import make_moons\n", @@ -1939,11 +2456,20 @@ }, { "cell_type": "code", - "execution_count": 21, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LogisticRegression 0.864\n", + "RandomForestClassifier 0.896\n", + "SVC 0.896\n", + "VotingClassifier 0.912\n" + ] + } + ], "source": [ "from sklearn.metrics import accuracy_score\n", "\n", @@ -1955,11 +2481,23 @@ }, { "cell_type": "code", - "execution_count": 22, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "VotingClassifier(estimators=[('lr', LogisticRegression(random_state=42)),\n", + " ('rf', RandomForestClassifier(random_state=42)),\n", + " ('svc', SVC(probability=True, random_state=42))],\n", + " voting='soft')" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "log_clf = LogisticRegression(random_state=42)\n", "rnd_clf = RandomForestClassifier(random_state=42)\n", @@ -1973,11 +2511,20 @@ }, { "cell_type": "code", - "execution_count": 23, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LogisticRegression 0.864\n", + "RandomForestClassifier 0.896\n", + "SVC 0.896\n", + "VotingClassifier 0.92\n" + ] + } + ], "source": [ "from sklearn.metrics import accuracy_score\n", "\n", @@ -2063,11 +2610,83 @@ }, { "cell_type": "code", - "execution_count": 24, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(426, 30)\n", + "(143, 30)\n", + "Test set accuracy with Logistic Regression: 0.95\n", + "Test set accuracy with SVM: 0.63\n", + "Test set accuracy with Decision Trees: 0.88\n", + "Test set accuracy Logistic Regression with scaled data: 0.96\n", + "Test set accuracy SVM with scaled data: 0.96\n", + "Test set accuracy with Decision Trees and scaled data: 0.90\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/hjensen/opt/anaconda3/lib/python3.8/site-packages/sklearn/linear_model/_logistic.py:762: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + "Please also refer to the documentation for alternative solver options:\n", + " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", + " n_iter_i = _check_optimize_result(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.93333333 0.8 0.93333333 1. 1. 0.92857143\n", + " 1. 0.92857143 0.92857143 1. ]\n", + "Test set accuracy with Random Forests and scaled data: 0.97\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAATgAAAEWCAYAAADy2YssAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deZxU1Z3+8c/T3aLsiAqyiIobm3FDcPm5JSaiEjWjuBs1GveoMSZxZpIY0WQSozNm4h7jmGhco0aNCmZMSIIjAURRcUFUEBpkU1AIBmi+vz/u7bZoeqmSrq6u28/bV72se+6pc8+tqv5yzj33nFJEYGaWRRWlroCZWbE4wJlZZjnAmVlmOcCZWWY5wJlZZjnAmVlmOcC1AZImSDo7fX6KpGdauPztJIWkqpYsN89jd5T0hKTlkh7aiHJa/H0pBUlPSzq91PVoL9pFgJM0W9JCSZ1z0s6WNKGE1WpQRPw2Ir7U2seVdLKkqZJWSFqQ/iH+vxYo+jigN7BFRIz5rIUU632RdHAa/B+pl75bmj4hz3J+KOme5vJFxOER8evPWF0rULsIcKkq4JKNLUSJTL1vki4DbgB+TBKMBgA3A0e3QPHbAjMjYm0LlFUsi4H9JG2Rk3Y6MLOlDpDF701ZiIjMP4DZwBXAB0CPNO1sYEJOnv2AKcDy9P/75eybAPwIeA5YBewIBHAB8BbwMXA1sAPwPPAR8CDQIX395sAfSP6QPkyf969X/tnp8zOAienz7wArch5rgLvSfd2BXwELgGrgGqAy3VcJXAcsAd4BLkzrW9XAe9M9LXtME+/fpiQBcH76uAHYNN13MDAP+BawKK3Pmem+q4DVab1XAGcBPwTuySl7u9y6pef/TvqevgucUv99yfPzujr9vD4GngG2bOTcaut/K3Bhzvs3D/gB639Hfg7MTT/fF4AD0vRR9c5zehPfm9zP+hbgdznl/xR4FlCp/2ay8ih5BVrlJJMAdyjwCHBNmlYX4ICeJIHnNJKW3knp9hbp/gnAe8DQdP8m6R/l40C3NP2f6ZdzYBo0XgNOT1+/BXAs0AnoCjwE/D6nfrlf+vX+kHPybEMSXI5It38P3AZ0BnoBk4Fz033nAW+kr+kJ/JnGA9woYG1D+3LyjAUmpcfZCvg/4Op038Hp68em78sRwD+AzdP9P2T9gFZ/e7vauqXn8hGwS7qvDzC0/vuS5+f1NrAz0DHd/kkj53YwSTDbD/h7mnYEMJ4N/xE8Nf0sq0gC+vvAZg2dVxPfm9zPuhNJK/EM4ACSf5D6N/Y5+FH4o701mX8AfEPSVvXSjwTeioi7I2JtRNxHEiC+nJPnroiYke5fk6b9NCI+iogZwKvAMxHxTkQsB54G9gCIiKUR8XBE/CMiPib5V/2gfCstqSNJQPt5RDwlqTdwOHBpRKyMiEXAfwEnpi85HrghIuZGxAfAfzRR/BbAkmi6C3kKMDYiFkXEYpKW2Wk5+9ek+9dExFMkrZhd8j2/etYBwyR1jIgF6XtbXz6f1/9ExMyIWEXSmt69qYNGxP8BPSXtAnwV+E0Dee5JP8u1EXE9Scu2ufNs6HtTW94/SILmfwL3AN+IiHnNlGcFaFcBLiJeJekeXlFvV19gTr20OUC/nO25DRS5MOf5qga2uwBI6iTpNklzJH0E/BXoIakyz6r/CngzIn6abm9L0hpYIGmZpGUkrbleOeeTW9/655ZrKbBlMyOs9d+fOWlaXRn1AuQ/SM+9EBGxEjiBpAW6QNKTkgblUZ/aOuV+Xu9/hvrcDVwEHAI8Wn+npG9Jej0dEV5G0lLfspkyG/re1ImIySRdcpEEYmtB7SrApa4Evs76fwzzSYJGrgEk17ZqbcyyK98i+Zd+ZER0Aw5M09XcCyVdkb72rJzkuSRd4i0jokf66BYRQ9P9C0i6p7UGNHGI54FPgGOayFP//RmQpn0WK0m6ZrW2zt0ZEeMj4osk3dM3gF/mUZ/aOlU3kLcQd5NcV30qbV3VkXQA8F2S1vHmEdGD5Ppf7WfY2Pejye+NpAtJWoLzSa65WgtqdwEuImYBDwAX5yQ/Beyc3ipRJekEYAhJa68ldCVp0S2T1JMkyDZL0uFpPY9Ju1q157CA5ML59ZK6SaqQtIOk2m7vg8DFkvpL2pwNW6zklLWcpOt+k6Rj0tbmJpIOl3Rtmu0+4HuStpK0ZZq/2VsiGvEScKCkAZK6A/+ac769JR2V3s7zT5Kubk0DZRTl84qId0kuHfx7A7u7klxrXAxUSfoByfXXWguB7QoZKZW0M8ng0KkkXf7vSGqyK22FaXcBLjWW5II2kFwjA0aTtLSWkvxLOjoilrTQ8W4gudi9hORi/bg8X3cCyUX919P701ZIujXd91WgA8lgxofA70haPZC0esYD04FpJIMrjYqI/wQuA75H8gc8l6Sr9vs0yzXAVOBl4JW0zGvyPIf6x/ojyT8wL5OMROYGpQqSz2A+yYj3QSQtqvplFO3zioiJEdFQ63Q8yXXVmSTd4U9Yv/tZexPzUknTmjtOekngHpLruNMj4i3g34C7JW26Medgn1KEF7w0s2xqry04M2sHHODMLLMc4MwssxzgzCyzWn35nKaoqmOoQ9dSV8MKsMfgpm6xs7ZmzpzZLFmypNn7L5tS2W3biLWrms8IxKrF4yNi1MYcb2O0rQDXoSub7nJ8qathBXju7zeWugpWgP1HDt/oMmLtqrz/Tj956abmZnoUVZsKcGZWDgRlsvKTA5yZFUZARb7TqEvLAc7MCqeNuozXahzgzKxA7qKaWZa5BWdmmSTcgjOzrJJbcGaWYR5FNbNs8iCDmWWVcBfVzDLMLTgzyyZ3Uc0sqwRUepDBzLLK1+DMLJvcRTWzLHMLzswyyy04M8skeaqWmWWZp2qZWTZ5kMHMssxdVDPLJK8HZ2bZ5S6qmWWZBxnMLLN8Dc7MMknuoppZlrkFZ2ZZJQc4M8uiZMVyBzgzyyIJVTjAmVlGuQVnZpnlAGdmmeUAZ2bZpPRRBhzgzKwgQm7BmVl2VVSUx0yG8qilmbUpkvJ65FFOT0mPSlopaY6kkxvJJ0nXSKqWtFzSBElDmyvfAc7MCqMCHs27CVgN9AZOAW5pJHCNAb4GHAD0BJ4H7m6ucAc4MytYS7TgJHUGjgW+HxErImIi8DhwWgPZtwcmRsQ7EVED3AMMaa6eDnBmVpDaQYY8A9yWkqbmPM7JKWpnoCYiZuakTQcaasHdD+woaWdJmwCnA+Oaq6sHGcysYAVM1VoSEcMb2dcFWF4vbTnQtYG8C4C/AW8CNcBc4PPNHdwtODMrjFpskGEF0K1eWjfg4wbyXgnsDWwDbAZcBfxJUqemDuAAZ2YFa6EANxOokrRTTtpuwIwG8u4GPBAR8yJibUTcBWxOM9fhHODMrGAtEeAiYiXwCDBWUmdJ+wNH0/Do6BRgjKTekioknQZsAsxq6hi+BmdmBWnhmQwXAHcCi4ClwPkRMUPSAOA1YEhEvAf8FOgFvAR0Jglsx0bEsqYKd4Azs8K1UHyLiA+AYxpIf49kEKJ2+xPgwvSRNwc4MyuMymeqlgOcmRXMk+3NLLvKI755FHVjfHG/wUx/9Pu8+tiVXH7mFzfY36NrRx64/utMfuBf+dvdlzNkhz51+75xyiG88Lt/Z+pD/8av/+MMNu3gf2tawzPjx/G5obswdNCO/Ozan2ywPyK47NKLGTpoR/be43O8OG0aAHPnzuWwQw9h910Hs+duQ7nxv3/e2lVvU1pqsn2xFTXASRol6U1JsyRdUcxjtbaKCnHDFcdz9EU3s8ex1zBm1F4MGrj1enm+c9ZhTH9zHiNO+A/O+v7dXPft4wDou1V3LjjpIPY/5VqGj/kxlRUVjDlsr1KcRrtSU1PDpRdfyGNPPM2LL7/GQ/ffx+uvvbZenvHjnubtWW/x6utvceMtt3PxRecDUFVVxU+uvZ6XXnmdv0ycxG233rTBa9uLfINbpgOcpEqSlQIOJ7kZ7yRJzU6OLRd7D9uOt+cuYXb1UtasreGh8dMYffDn1sszaODWTJj8JgAzZy9k27496dUzmYVSVVlJx003obKygo6bdWDB4vozVqylTZk8mR122JHtBw6kQ4cOjDnhRP7wxGPr5fnD449x8qlfRRIj99mH5cuXsWDBAvr06cMee+4JQNeuXRk0aDDz51eX4jTahHYf4IARwKx09v9qksmyRxfxeK2qb6/uzFv4Yd129cIP6bdV9/XyvDKzmqO/sDsAw4duy4A+PenXuwfzFy/nht88y8ynr+bdP/6Ij1as4tlJb7Rq/duj+fOr6d9/m7rtfv36U11d3Wye+fXyzJk9m5deepG9R4wsboXbMFUor0epFTPA9SOZEFtrXpq2Hknn1K40EGtXFbE6LUsNXGWNetvX/c8f6dG1E5Puv4LzTzyI6W/OY23NOnp07cjog3dl8OgrGfilf6dzxw6ceMTerVPxdiyi/ie04Whgc3lWrFjBSccfy8+uv4Fu3epPo2w/yqUFV8wr2w2d3Qbfnoi4HbgdoKJTrw2/XW1U9aJl9O+9ed12v96bM79eN/PjlZ9w7g/vqdt+48mrmF29lC/uO5jZ85ey5MMVAPz+T9PZZ7ftuf+pKa1T+XaqX7/+zJv36b+51dXz6Nu3b7N5+qR51qxZw0nHH8sJJ53CMV/5l9apdFuk8rlNpJgtuHkkM/9r9QfmF/F4rWrqjDnsOGArtu27BZtUVTLmsD15csLL6+Xp3qUjm1RVAnDmV/Zj4rRZfLzyE+a+/wEjdt2ejpttAsAhI3bhzXcXtvo5tDfD996bWbPeYva777J69WoeeuB+jhx91Hp5jvzyUdx7z2+ICP4+aRLdunWnT58+RATnff0sdhk0mEu+eVmJzqBtECDl9yi1YrbgpgA7SdoeqAZOBBpcb70c1dSs45s/fZAnbr6Qygrx68cm8fo773P2cf8PgDt+N5FBA7fmjqtPo6ZmHW+88z7nXfVbAKa8OodH//dFnr/3u6ytWcf0N+bxq4efK+XptAtVVVX8189v5MtHHkZNTQ2nn/E1hgwdyi9vuxWAr597HqMOP4LxTz/F0EE70qljJ267438A+L/nnuPe397NsGG7MnKv5LrqVdf8mFGHH1Gy8ymdttH9zIcauubQYoVLRwA3AJXAnRHxo6byV3TqFZvucnzR6mMt78MpN5a6ClaA/UcO54UXpm5UdNps651j29N/kVfemdeOeqGJBS+Lrqh3l0bEU8BTxTyGmbWyNtL9zIdvnzezgojkRvdy4ABnZgVzC87MMqtcBhkc4MysML4GZ2ZZJeQFL80su9yCM7PM8jU4M8smX4Mzs6xK5qKWR4RzgDOzgpVJfHOAM7PCeSaDmWVTGa0H5wBnZgWpXQ+uHDjAmVmBymc9OAc4MytYmcQ3BzgzK5A8yGBmGeX74Mws0xzgzCyzyiS+OcCZWeHcgjOzbPJkezPLqmTBy/KIcOWxLKeZtSkVUl6P5kjqKelRSSslzZHU6I/DSxoo6Q+SPpa0RNK1zZXvFpyZFawFu6g3AauB3sDuwJOSpkfEjPWPpw7AH9P8JwA1wM7NFe4AZ2YFUQtNtpfUGTgWGBYRK4CJkh4HTgOuqJf9DGB+RPxnTtrLzR3DXVQzK1iF8nsAW0qamvM4J6eYnYGaiJiZkzYdGNrAIfcBZkt6Ou2eTpC0a3P1bLQFJ+kXQDS2PyIubq5wM8umAgYZlkTE8Eb2dQGW10tbDnRtIG9/4BDgKOBZ4BLgMUmDImJ1Ywdvqos6tYl9ZtZOiWQktQWsALrVS+sGfNxA3lXAxIh4GkDSdcD3gMEkrb4GNRrgIuLXuduSOkfEyvzqbWZZ1kJ3icwEqiTtFBFvpWm7ATMayPsysH+hB2j2GpykfSW9Bryebu8m6eZCD2RmGaFkPbh8Hk1JG0yPAGMldZa0P3A0cHcD2e8B9pF0qKRK4FJgCWlcakw+gww3AIcBS9NKTQcOzON1ZpZRUn6PPFwAdAQWAfcB50fEDEkDJK2QNAAgIt4ETgVuBT4kCYRHNXX9DfK8TSQi5taLxjV5Vd3MMkeQ1028+YiID4BjGkh/j2QQIjftEZIWX97yCXBzJe0HRHqz3cU00yw0s2zL0lSt84ALgX5ANcndxhcWs1Jm1nbl2z1tCxPym23BRcQS4JRWqIuZlYmW6qIWWz6jqAMlPSFpsaRFkh6TNLA1KmdmbZPyfJRaPl3Ue4EHgT5AX+AhktEOM2unWuI2kdaQT4BTRNwdEWvTxz00MYXLzLItGUXNey5qSTU1F7Vn+vTPkq4A7icJbCcAT7ZC3cysLVL5LHjZ1CDDCyQBrfZMzs3ZF8DVxaqUmbVtbaH7mY+m5qJu35oVMbPyUNtFLQd5zWSQNAwYAmxWmxYRvylWpcysbSv7FlwtSVcCB5MEuKeAw4GJgAOcWTtVHuEtv1HU44AvAO9HxJkky5lsWtRamVmbJUFlhfJ6lFo+XdRVEbFO0lpJ3Uhm/ftGX7N2LDNdVGCqpB7AL0lGVlcAk4taKzNr08okvuU1F/WC9OmtksYB3SKi2V+zMbNsEvn95mlb0NSNvns2tS8iphWnSmbWprWRlULy0VQL7vom9gXw+RauC7sPHsDE53/R0sVaEW0+8pJSV8EK8M835rZIOWV/DS4iDmnNiphZeRBQWe4BzsysMW3gDpC8OMCZWcEc4Mwsk5LlyMsjwuWzoq8knSrpB+n2AEkjil81M2urymU9uHymat0M7AuclG5/DNxUtBqZWZuXmR+dAUZGxJ6SXgSIiA/Tnw80s3ZIQFVbiF55yCfArZFUSbpMuaStgHVFrZWZtWllEt/yCnD/DTwK9JL0I5LVRb5X1FqZWZslZWCqVq2I+K2kF0iWTBJwTET4l+3N2rEyiW95LXg5APgH8ERuWkS8V8yKmVnb1RZGSPORTxf1ST798ZnNgO2BN4GhRayXmbVRgjaxmGU+8umi7pq7na4ycm4j2c0s69rIPW75KHgmQ0RMk7R3MSpjZuVBZfKrDPlcg7ssZ7MC2BNYXLQamVmblrWfDeya83wtyTW5h4tTHTMrB5kIcOkNvl0i4tutVB8zKwPlMtm+qSXLqyJibVNLl5tZ+5P8bGCpa5Gfplpwk0mut70k6XHgIWBl7c6IeKTIdTOzNqpcZjLkE4d7AktJfoNhNPDl9P9m1g7VDjK0xHJJknpKelTSSklzJJ2cx2v+JCkkNTuG0FSGXukI6qt8eqNvrWi25maWWS3YgLsJWA30BnYHnpQ0PSJmNHxcnUIBt7c1lbES6AIN3vDiAGfWbomKFrgPTlJn4FhgWESsACaml8NOA65oIH934Ergq8Dz+RyjqQC3ICLGFlxrM8s0UVALbktJU3O2b4+I29PnOwM1ETEzZ/904KBGyvoxcAvwfr4HbyrAlcdVRDNrXYKq/G+EWxIRwxvZ1wVYXi9tOevfe5scUhoO7A9cAvTP9+BNBbgv5FuImbUfBbbgmrIC6FYvrRvJzyJ8ejypguSnEy5Jb13L+wCNjqJGxAf519PM2pOKdNHL5h7NmAlUSdopJ203oP4AQzdgOPCApPeBKWn6PEkHNHUA/2ygmRWsJVpwEbFS0iPAWElnk4yiHg3sVy/rcqBvzvY2JPfp7kUz8+Id4MysICK/G2jzdAFwJ7CI5H7b8yNiRrrQ7mvAkHRx3bqBBUmbpU8XRsTapgp3gDOzwqjlZjKkl8KOaSD9PZJBiIZeM5s8B0Ed4MysIMlMhvK4ycIBzswKVh7hzQHOzD6DMmnAOcCZWaFU/uvBmZk1pIVHUYvKAc7MCuZBBjPLJmVgyXIzs4a4i2pmmeYWnJllVnmENwc4MyuQgEq34Mwsq8okvjnAmVmhhMqkk+oAZ2YFcwvOzDIpuU2kPCKcA5yZFUZuwZlZhnmqlpllUrLgZalrkR8HODMrmEdRzSyzyqSHWjZzZtukZ8aPY/dhg9h18E5c97OfbLA/Irj8mxez6+CdGLHXbrz44jQAPvnkEw7cfyQjh+/O8N2Hcc3YK1u76u3WF/cdxPSH/41Xf/89Lj/j0A329+jakQeuO4vJ93+Xv/36Mobs0AeAnbbtxaR7v133WPiXn3LRSQe1dvXbDOX5X6kVrQUn6U5gNLAoIoYV6zilUlNTw2WXXMQTTz1Dv/79OWC/ERw5+igGDx5Sl2f8uKeZNWsWL782kymT/86l37iAv0ycxKabbspT45+lS5curFmzhkMPOYAvHXY4I0buU8Izyr6KCnHDFWM48oKbqV64jIl3f4s//OUV3nh3YV2e73zti0x/s5oTLv8VO2/Xixu+O4Yjzr+Jt+YsYp+Tf1ZXzttPj+XxP79cqlMpqXK6BlfMFtxdwKgill9SU6dMZuAOO7L9wIF06NCB444/gT888dh6eZ584jFOPvU0JDFi5D4sX7aMBQsWIIkuXZJfRFuzZg1r1qwpm9UZytneQ7fl7bmLmV29lDVra3jomWmMPnjX9fIMGrg1E6bMBGDm7EVs27cnvXp2XS/PISN25t15S3jv/Q9bre5tSp6/at8WRlqLFuAi4q/AB8Uqv9Tmz6+m/zb967b79evPgurqennm07//NnXbffv1Z8H8JE9NTQ377L0H2/Xvzee/cCh7jxjZOhVvx/r26s68hcvqtqsXLqPfVt3Xy/PKzPkcfcjnABg+dAADtt6cfr3WzzPmS3vy4Phpxa9wG6Y8H6VW8mtwks6RNFXS1CVLFpe6OnmLiA3S6rfCmspTWVnJpCkvMvOdubwwdQozZrxanIpanYZayfU/ouvu+iM9unVi0r3f5vwTDmT6m9WsrVlXt3+TqkqOPGgYj/zvS8WubptV+7uo5dCCK/koakTcDtwOsOdewzeMCG1Uv379mTd3Xt12dfU8tu7bt16efsybN7due371PLbus36eHj16cMCBB/HH8eMYOjRzlyrblOqFy+jfu0fddr/ePZi/ZPl6eT5e+U/Overeuu03nvgBs+cvrds+bP/BvPTGPBZ98HHxK9yGlT505afkLbhytdfwvXl71lvMfvddVq9eze8efIAjRx+1Xp4jRx/FvffcTUQw+e+T6Na9O3369GHx4sUsW5Z0lVatWsWf//Qsu+wyqBSn0a5Mfe09dtxmK7bt25NNqioZ86U9efIv67ecu3fpyCZVlQCc+ZV9mTjtbT5e+c+6/ccfthcPjmvf3VOgbPqoJW/Blauqqiquv+EXHD16FDU1NXz1jDMZMmQod9x+KwBnn3Mehx1+BOPHPcWug3eiY6dO3PbLOwF4//0FnHPWGdTU1LBu3TqOPW4Mhx85uoRn0z7U1Kzjm9c+zBM3nk9lZQW/fmwSr7/zPmcfuz8Adzz8HIO2780dY0+lZt063njnfc4be1/d6ztutgmfH7kLF/34gVKdQpvRFrqf+VBD14lapGDpPuBgYEtgIXBlRPyqqdfsudfwmPj8lKLUx4pji30vLXUVrAD/fON+1q1cuFHRafCue8RvHpuQV94RO/R4ISKGb8zxNkbRWnARcVKxyjazEiuPBpy7qGZWmOTyWnlEOAc4MyuM14Mzsywrk/jmAGdmhVLZTC10gDOzgpVJfPONvmZWmHzv8c0nBkrqKelRSSslzZF0ciP5Tpf0gqSPJM2TdK2kZhtoDnBmVriWm8lwE7Aa6A2cAtwiaWgD+ToBl5LcVzsS+AJweXOFu4tqZgVridtEJHUGjgWGRcQKYKKkx4HTgCty80bELTmb1ZJ+CxzS3DEc4MysYAVcg9tS0tSc7dvTBTYAdgZqImJmzv7pQD5LJR8IzGgukwOcmRWmsPvgljQxVasLsLxe2nKgawN5Pz28dCYwHDi7uYM7wJlZwVpoJsMKoFu9tG5Ao2tRSToG+AlwaEQsae4AHmQws4KIpAWXz6MZM4EqSTvlpO1GI11PSaOAXwJfjohX8qmrA5yZFawlBlEjYiXwCDBWUmdJ+wNHA3dvcDzp88BvgWMjYnK+9XSAM7PCtdxtIhcAHYFFwH3A+RExQ9IASSskDUjzfR/oDjyVpq+Q9HRzhfsanJkVrKUWvIyID4BjGkh/j2QQona72VtCGuIAZ2YFK5OZWg5wZvYZlEmEc4Azs4J4wUszyy4veGlmWVYm8c0BzswK5QUvzSzDyiS+OcCZWWHayI/W58UBzswKVyYRzgHOzArm20TMLLN8Dc7MsklQ4QBnZtlVHhHOAc7MClK74GU5cIAzs4KVSXxzgDOzwrkFZ2aZ5alaZpZZ5RHeHODMrEB5/mJWm+AAZ2YF80wGM8uu8ohvDnBmVrgyiW8OcGZWKLXYzwYWmwOcmRWknGYy+JftzSyz3IIzs4KVSwvOAc7MCubbRMwsm3yjr5llVTkNMjjAmVnB3EU1s8xyC87MMqtM4psDnJl9BmUS4RzgzKwggrKZqqWIKHUd6khaDMwpdT2KYEtgSakrYQXJ6me2bURstTEFSBpH8v7kY0lEjNqY422MNhXgskrS1IgYXup6WP78mWWD56KaWWY5wJlZZjnAtY7bS10BK5g/swzwNTgzyyy34MwssxzgzCyzHOCKSNIoSW9KmiXpilLXx5on6U5JiyS9Wuq62MZzgCsSSZXATcDhwBDgJElDSlsry8NdQMluTLWW5QBXPCOAWRHxTkSsBu4Hji5xnawZEfFX4INS18NahgNc8fQD5uZsz0vTzKyVOMAVT0OzkX1PjlkrcoArnnnANjnb/YH5JaqLWbvkAFc8U4CdJG0vqQNwIvB4ietk1q44wBVJRKwFLgLGA68DD0bEjNLWypoj6T7geWAXSfMknVXqOtln56laZpZZbsGZWWY5wJlZZjnAmVlmOcCZWWY5wJlZZjnAlRFJNZJekvSqpIckddqIsu6SdFz6/I6mFgKQdLCk/T7DMWZL2uDXlxpLr5dnRYHH+qGkywuto2WbA1x5WRURu0fEMGA1cF7uznQFk4JFxNkR8VoTWQ4GCg5wZqXmAFe+/gbsmLau/izpXuAVSZWSfiZpiqSXJZ0LoMSNkl6T9CTQq7YgSRMkDU+fj5I0TdJ0Sc9K2o4kkH4zbT0eIGkrSQ+nx5giaf/0tVtIekbSi5JuI4/fP5f0e0kvSJoh6Zx6+65P6/KspK3StB0kjZ/kyPAAAAJASURBVEtf8zdJg1rizbRs8i/blyFJVSTrzI1Lk0YAwyLi3TRILI+IvSVtCjwn6RlgD2AXYFegN/AacGe9crcCfgkcmJbVMyI+kHQrsCIirkvz3Qv8V0RMlDSAZLbGYOBKYGJEjJV0JLBewGrE19JjdASmSHo4IpYCnYFpEfEtST9Iy76I5MdgzouItySNBG4GPv8Z3kZrBxzgyktHSS+lz/8G/Iqk6zg5It5N078EfK72+hrQHdgJOBC4LyJqgPmS/tRA+fsAf60tKyIaWxftUGCIVNdA6yapa3qMf0lf+6SkD/M4p4slfSV9vk1a16XAOuCBNP0e4BFJXdLzfSjn2JvmcQxrpxzgysuqiNg9NyH9Q1+ZmwR8IyLG18t3BM0v16Q88kByaWPfiFjVQF3ynvsn6WCSYLlvRPxD0gRgs0ayR3rcZfXfA7PG+Bpc9owHzpe0CYCknSV1Bv4KnJheo+sDHNLAa58HDpK0ffranmn6x0DXnHzPkHQXSfPVBpy/AqekaYcDmzdT1+7Ah2lwG0TSgqxVAdS2Qk8m6fp+BLwraUx6DEnarZljWDvmAJc9d5BcX5uW/nDKbSQt9UeBt4BXgFuAv9R/YUQsJrlu9oik6XzaRXwC+ErtIANwMTA8HcR4jU9Hc68CDpQ0jaSr/F4zdR0HVEl6GbgamJSzbyUwVNILJNfYxqbppwBnpfWbgZeBtyZ4NREzyyy34MwssxzgzCyzHODMLLMc4MwssxzgzCyzHODMLLMc4Mwss/4/JLeMOr3VrhEAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", @@ -2155,10 +2774,8 @@ }, { "cell_type": "code", - "execution_count": 25, - "metadata": { - "collapsed": false - }, + "execution_count": 24, + "metadata": {}, "outputs": [], "source": [ "bag_clf = BaggingClassifier(\n", @@ -2168,11 +2785,20 @@ }, { "cell_type": "code", - "execution_count": 26, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9790209790209791" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "bag_clf.fit(X_train, y_train)\n", "y_pred = bag_clf.predict(X_test)\n", @@ -2712,11 +3338,46 @@ }, { "cell_type": "code", - "execution_count": 27, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "from sklearn.ensemble import AdaBoostClassifier\n", "\n", @@ -2902,11 +3563,69 @@ }, { "cell_type": "code", - "execution_count": 28, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/hjensen/opt/anaconda3/lib/python3.8/site-packages/sklearn/utils/validation.py:73: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", + " return f(**kwargs)\n", + "/Users/hjensen/opt/anaconda3/lib/python3.8/site-packages/sklearn/utils/validation.py:73: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", + " return f(**kwargs)\n", + "/Users/hjensen/opt/anaconda3/lib/python3.8/site-packages/sklearn/utils/validation.py:73: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", + " return f(**kwargs)\n", + "/Users/hjensen/opt/anaconda3/lib/python3.8/site-packages/sklearn/utils/validation.py:73: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", + " return f(**kwargs)\n", + "/Users/hjensen/opt/anaconda3/lib/python3.8/site-packages/sklearn/utils/validation.py:73: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", + " return f(**kwargs)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Max depth: 1\n", + "Error: 0.47355721367673903\n", + "Bias^2: 0.22077011251783993\n", + "Var: 0.25278710115889913\n", + "0.47355721367673903 >= 0.22077011251783993 + 0.25278710115889913 = 0.4735572136767391\n", + "Max depth: 2\n", + "Error: 0.48142907887100067\n", + "Bias^2: 0.22274557848791893\n", + "Var: 0.25868350038308174\n", + "0.48142907887100067 >= 0.22274557848791893 + 0.25868350038308174 = 0.48142907887100067\n", + "Max depth: 3\n", + "Error: 0.48142972227533726\n", + "Bias^2: 0.2227455925200145\n", + "Var: 0.2586841297553228\n", + "0.48142972227533726 >= 0.2227455925200145 + 0.2586841297553228 = 0.4814297222753373\n", + "Max depth: 4\n", + "Error: 0.48142972227533726\n", + "Bias^2: 0.2227455925200145\n", + "Var: 0.2586841297553228\n", + "0.48142972227533726 >= 0.2227455925200145 + 0.2586841297553228 = 0.4814297222753373\n", + "Max depth: 5\n", + "Error: 0.48142972227533726\n", + "Bias^2: 0.2227455925200145\n", + "Var: 0.2586841297553228\n", + "0.48142972227533726 >= 0.2227455925200145 + 0.2586841297553228 = 0.4814297222753373\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAD+CAYAAAAzmNK6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAZ4ElEQVR4nO3de3Bc5Znn8e+jlmQZ2QJfFIesUQQzNhdfCQKnxs7iDAm3WsramCpjOxQOY5zYRWpnst61KZabcoGZoSpUJVzKE7KwSbAJrAmXgLNlCCEOmTEyiUNEsKsmGMbDTbYHYRnLklvP/tEt0W53q4+kI5027+9T1UWf0+85/eh18/7OrU+buyMiIuGpSLoAERFJhgJARCRQCgARkUApAEREAqUAEBEJlAJARCRQCgARkUBFCgAzm2hmj5nZITN7w8yWFWm3wszSZtaZ81gYa8UiIhKLyojt7ga6gSnAXODnZrbT3dsKtP2tuy8YTBGTJ0/2xsbGwSwiIhK8HTt27HP3+qEuXzIAzKwWWAzMdPdOYJuZPQFcDawf6hvnamxspLW1NY5ViYgEw8zeGM7yUQ4BTQfS7r47Z95OYEaR9uea2T4z221mN5lZ1L0MEREZRVEG53FAR968DmB8gbYvADOBN8gExMPAUeD2/IZmtgpYBdDQ0BC9YhERiUWUPYBOoC5vXh1wML+hu//Z3V939153fwVoAa4stFJ33+DuTe7eVF8/5ENYIiIyRFECYDdQaWbTcubNAQqdAM7ngA2lMBERGVklA8DdDwGbgRYzqzWz+cAi4Ef5bc3sMjObkn1+FnAT8Hi8JYuISByifhFsDTAWeA/YCKx29zYza8he6993EP8i4A9mdgh4mkxwfCfuokVEZPgiXaHj7geA5gLz3yRzkrhvei2wNrbqRERkxOgSzTLm7hw52ktXT5rDPWkOd2f+29WTnZedzsz7aLq3V7/yJiKlKQCGwN3pTvfS1d177ADck6YrZ1A+3J3OGbx76TqaP+/YZTOv5Qz4PWmG8oudptPuIhLBxyoA3J2etPcPqgUH2txBO3cwztuKPtzT2z+YdxV4fSgb2dWpCmqqKhhbnWJsVYqaqhRjq1PUVKb4xPiqnHkVjK3Ktsltm7NM3+tjqyuOea2mKkWqQgkgEgK7Y3jLl0UAHOw6ytOvvJ3ZAj5uK7n3uMH3mMG9b+s6+zw9hJG5KmX9g2jf4DqmKsXYqgomj6vODNJVuYPuR4Pt2JwBO38dNccM8hVUpnTzVREpH2URAHv2H2LNT14+bn6qwjgpuxVcU5WzVVyVYkJtNZ86biu5ouBWck113uBdmaImZ9Cu0sAsIgEqiwA45aQqtvzt544bsDUwi4iMnLIIgE+Mr+GsT+bfbUJEREZSWWxij6ksizJERIKikVdEJFAKABGRQCkAREQCpQAQEQmUAkBEJFAKABGRQCkAREQCpQAQEQmUAkBEJFAKABGRQCkAREQCpQAQEQmUAkBEJFAKABGRQCkAREQCpQAQEQmUAkBEJFAKABGRQCkAREQCpQAQEQmUAkBEJFAKABGRQCkAREQCFSkAzGyimT1mZofM7A0zWxZhmefMzM2scvhliohI3KIOzncD3cAUYC7wczPb6e5thRqb2fJBrFtERBJQcg/AzGqBxcBN7t7p7tuAJ4Cri7Q/GbgF+J9xFioiIvGKcghoOpB2990583YCM4q0/w5wL/DOMGsTEZERFCUAxgEdefM6gPH5Dc2sCZgPfK/USs1slZm1mllre3t7lFpFRCRGUQKgE6jLm1cHHMydYWYVwD3Af3P3o6VW6u4b3L3J3Zvq6+uj1isiIjGJEgC7gUozm5Yzbw6QfwK4DmgCHjazd4CXsvP3mtnnhl2piIjEquSVOu5+yMw2Ay1mtpLMVUCLgL/Ka9oBfCpn+jRgO3AeoGM8IiJlJuoXwdYAY4H3gI3AandvM7MGM+s0swbPeKfvwUeD/rvu3j0CtYuIyDBEulbf3Q8AzQXmv0nmJHGhZfYANpziRERk5OhWECIigVIAiIgESgEgIhIoBYCISKAUACIigVIAiIgESgEgIhIoBYCISKAUACIigVIAiIgESgEgIhIoBYCISKAUACIigVIAiIgESgEgIhIoBYCISKAUACIigVIAiIgESgEgIhIoBYCISKAUACIigVIAiIgESgEgIhIoBYCISKAUACIigVIAiIgESgEgIhIoBYCISKAUACIigVIAiIgESgEgIhKoSAFgZhPN7DEzO2Rmb5jZsiLtrjKzXWbWYWbvmdmDZlYXb8kiIhKHqHsAdwPdwBRgOXCvmc0o0O43wHx3Pxk4A6gEvhVHoSIiEq+SAWBmtcBi4CZ373T3bcATwNX5bd3939x9X86sNPCXcRUrIiLxqYzQZjqQdvfdOfN2AhcWamxmC4CfA3XAh8B/HW6RIiISvyiHgMYBHXnzOoDxhRq7+7bsIaCpwD8Cewq1M7NVZtZqZq3t7e3RKxYRkVhECYBOMlvzueqAgwMt5O7/DmwBNhV5fYO7N7l7U319fZRaRUQkRlECYDdQaWbTcubNAdoiLFsJ/MVQChMRkZFVMgDc/RCwGWgxs1ozmw8sAn6U39bMlptZg2V8Gvg28GzcRYuIyPBFvQx0DTAWeA/YCKx297bsYN9pZg3ZducAL5I5bPQbYBdwXcw1i4hIDKJcBYS7HwCaC8x/k8xJ4r7pG4EbY6tORERGjG4FISISKAWAiEigFAAiIoFSAIiIBEoBICISKAWAiEigFAAiIoFSAIiIBEoBICISqEjfBJYTQ7o3TXdvN+6edCkicgJQAAyTu9PT20N3upsj6SPHPO/u7aY7nffozb6W7qant6f/ee7rfc/71tGT7im5vp50D0f9aNLdISInkBM2AI72Hj1+EM0bPAsOnL2FB89C68id7hvc+wfvnHXHIWUpqlPVmUdF9THPx6TGUJWqYlzVOKrHVFOVqmJMaszxbbPTKUvFUpOIlLev8JVhLW/lcLjg1LNO9aX3LaUn3XP8oFxk8E57Opb3zh1gq1PZ5xUDD7D97foG4orjX88fvPvXl7+Oisz7VlacsFksIgkxsx3u3jTU5cti1DnYfZB/ff9fPxqIK6oZXz2eiamJAw+wJQbs3PUVGoCrKqows6T/fBGRRJRFAJxxyhk83vx40mWIiASlLC4Dra6oTroEEZHglEUAiIjI6FMAiIgESgEgIhIoBYCISKAUACIigVIAiIgESgEgIhIoBYCISKDK4pvAH0vu4L2ZR286+zydM+150zmvuxdZpjfaOkVEIiiPAOh8B56/o8jA1ltkIEwPcaAssb64aiD5m+yJiAykPALgg7fh+dszzy0FVgEV2f/2T1dkpyvy2liEZfJer0iBVRVoX2x9fW2syDI5tUWtIer6Br3OCtD97UTCcNuQbwQKlEsAfOJsuOWVzIAoIiKjojxOAlfWaPAXERll5REAIiIy6hQAIiKBihQAZjbRzB4zs0Nm9oaZLSvS7hoz22FmH5jZXjP7BzMrj/MMIiJyjKh7AHcD3cAUYDlwr5nNKNDuJOBvgcnAPOAiYG0MdYqISMxKbp2bWS2wGJjp7p3ANjN7ArgaWJ/b1t3vzZn8dzP7CfD5GOsVEZGYRNkDmA6k3X13zrydQKE9gHz/GWgbSmEiIjKyogTAOKAjb14HMH6ghczsK0ATcGeR11eZWauZtba3t0epVUREYhQlADqBurx5dcDBYguYWTNwB3CZu+8r1MbdN7h7k7s31dfXR61XRERiEiUAdgOVZjYtZ94cihzaMbNLgX8CrnD3V4ZfooiIjISSAeDuh4DNQIuZ1ZrZfGAR8KP8tmb218BPgMXuvj3uYkVEJD5RLwNdA4wF3gM2Aqvdvc3MGsys08wasu1uAk4Gns7O7zSzZ+IvW0REhivSl7Tc/QDQXGD+m2ROEvdN65JPEZEThG4FISISKAWAiEigFAAiIoFSAIiIBEoBICISKAWAiEigFAAiIoFSAIiIBEoBICISKAWAiEigFAAiIoFSAIiIBEoBICISKAWAiEigFAAiIoFSAIiIBEoBICISKAWAiEigFAAiIoFSAIiIBEoBICISKAWAiEigFAAiIoFSAIiIBEoBICISKAWAiEigFAAiIoFSAIiIBEoBICISKAWAiEigFAAiIoGKFABmNtHMHjOzQ2b2hpktK9Juppn9wsz2mZnHW6qIiMQp6h7A3UA3MAVYDtxrZjMKtOsBfgr8TTzliYjISKks1cDMaoHFwEx37wS2mdkTwNXA+ty27r4L2GVmfzncwnp6eti7dy9dXV3DXVVwampqmDp1KlVVVUmXIiJlrGQAANOBtLvvzpm3E7hwZErK2Lt3L+PHj6exsREzG8m3+lhxd/bv38/evXs5/fTTky5HRMpYlENA44COvHkdwPjhvLGZrTKzVjNrbW9vP+71rq4uJk2apMF/kMyMSZMmac9JREqKEgCdQF3evDrg4HDe2N03uHuTuzfV19cXbKPBf2jUbyISRZQA2A1Umtm0nHlzgLaRKal8pFIp5s6d2/+44447ki5JRCQ2Jc8BuPshM9sMtJjZSmAusAj4q/y2ltn0HANUZ6drMqvwI7FWPUrGjh3L73//+wHbpNNpUqlU0emoy4mIjLaol4GuAcYC7wEbgdXu3mZmDWbWaWYN2XafBg7z0d7BYWBXnAWXg8bGRlpaWliwYAGPPPLIcdMbN25k1qxZzJw5k3Xr1vUvN27cOG6++WbmzZvHb3/72wT/AhGRaFcB4e4HgOYC898kc5K4b3oPEPsB6NuebOPVtz6IdZ3nfKqOW64o9FWGjxw+fJi5c+f2T99www0sWbIEyFxquW3bNgDWr1/fP/3WW2/x2c9+lh07djBhwgQuvvhifvazn9Hc3MyhQ4eYOXMmLS0tsf4tIiJDESkAQjXQIaC+IMiffumll1i4cCF9J7aXL1/OCy+8QHNzM6lUisWLF49s0SIiEZ0QAVBqSz0JtbW1Bafdi98Bo6amRsf9RaRs6GZwMZs3bx6/+tWv2LdvH+l0mo0bN3LhhSP6nTkRkSE5IfYAkpJ/DuDSSy8teSnoqaeeyu23387nP/953J3LL7+cRYsWjXSpIiKDpgAYQDqdLjh/z549A04vW7aMZcuOv2FqZ2dnXKWJiAybDgGJiARKASAiEigFgIhIoBQAIiKBUgCIiARKASAiEigFwAD27NnDzJkzj5u/cuVKXn311QQqEhGJj74HMAQ/+MEPki5BRGTYtAdQwtGjR7nmmmuYPXs2V155JR9++CELFy6ktbUVgNWrV9PU1MSMGTO45ZZb+pdbv34955xzDrNnz2bt2rVJlS8iUtSJsQfwzHp455V41/nJWXBZ6V/42rVrF/fffz/z58/n2muv5Z577jnm9W9/+9tMnDiRdDrNRRddxB/+8AemTp3KY489xmuvvYaZ8f7778dbu4hIDLQHUMJpp53G/PnzAfjyl7/c/xsAfX7605/ymc98hnPPPZe2tjZeffVV6urqqKmpYeXKlWzevJmTTjopidJFRAZ0YuwBRNhSHyn5P7CeO/36669z55138tJLLzFhwgRWrFhBV1cXlZWVbN++nWeffZZNmzbx/e9/n+eee260SxcRGZD2AEp48803+3++cePGjSxYsKD/tQ8++IDa2lpOPvlk3n33XZ555hkgc9O3jo4OLr/8cu66666SvyssIpKEE2MPIEFnn302Dz74IF/96leZNm0aq1ev5sknnwRgzpw5nHvuucyYMYMzzjij/1DRwYMHWbRoEV1dXbg73/3ud5P8E0REClIADKCxsbHg9f7PP/98//MHHnig4LLbt28foapEROKhQ0AiIoFSAIiIBEoBICISKAWAiEigFAAiIoFSAIiIBEoBUMTChQv5xS9+ccy8u+66izVr1kRa/uabb2br1q0jUZqISCwUAEUsXbqUTZs2HTNv06ZNLF26tOSy6XSalpYWvvCFL4xUeSIiw6YAKOLKK6/kqaee4siRI0Dmx2HeeustHnrooYK3f25sbKSlpYUFCxbwyCOPsGLFCh599FEAWlpaOP/885k5cyarVq3C3YHMXsa6deu44IILmD59Or/+9a+BTICsXbuWWbNmMXv2bL73ve8BsGPHDi688ELOO+88LrnkEt5+++3R7BIR+Zg5Ib4J/Pfb/57XDrwW6zrPmngW6y5YV/T1SZMmccEFF7BlyxYWLVrEpk2bWLJkCTfccMNxt3+ePXs2ADU1Nf13C92yZUv/uq6//npuvvlmAK6++mqeeuoprrjiCiDzewPbt2/n6aef5rbbbmPr1q1s2LCB119/nd/97ndUVlZy4MABenp6+PrXv87jjz9OfX09Dz/8MDfeeCM//OEPY+0XEQmH9gAGkHsYqO/wT6HbP/dZsmRJwfX88pe/ZN68ecyaNYvnnnuOtra2/te+9KUvAXDeeeexZ88eALZu3crXvvY1Kisz+Txx4kR27drFH//4R774xS8yd+5cvvWtb7F3796R+LNFJBCR9gDMbCJwP3AxsA+4wd0fKtL274B1wFjg/wKr3f3IcIocaEt9JDU3N/ONb3yDl19+mcOHDzNhwoSCt3/uU1tbe9w6urq6WLNmDa2trZx22mnceuutxywzZswYAFKpFEePHgXA3Y+7DbW7M2PGjP47k4qIDFfUPYC7gW5gCrAcuNfMZuQ3MrNLgPXARUAjcAZwWyyVJmDcuHEsXLiQa6+9lqVLlxa9/fNA+gb7yZMn09nZ2X9eYCAXX3wx9913X38gHDhwgDPPPJP29vb+AOjp6TlmT0JEZLBKBoCZ1QKLgZvcvdPdtwFPAFcXaH4NcL+7t7n7fwDfBFbEWO+oW7p0KTt37uSqq6465vbP1157bf/tnwdyyimncN111zFr1iyam5s5//zzSy6zcuVKGhoamD17NnPmzOGhhx6iurqaRx99lHXr1jFnzhzmzp3Liy++GMefKCKBsr4rUoo2MDsXeNHdx+bMWwtc6O5X5LXdCXzH3R/OTk8G2oHJ7r6/2Hs0NTV534+s9/nTn/7E2WefPcg/R/qo/0Q+/sxsh7s3DXX5KIeAxgEdefM6gPER2vY9P66tma0ys1Yza21vb49Sq4iIxChKAHQCdXnz6oCDEdr2PT+urbtvcPcmd2+qr6+PUquIiMQoSgDsBirNbFrOvDlAoTOQbdnXctu9O9DhHxERSUbJAHD3Q8BmoMXMas1sPrAI+FGB5v8H+BszO8fMJgD/C3hgqMWVOj8hhanfRCSKqJeBriFzXf97wEYy1/a3mVmDmXWaWQOAu28B/gH4JfBG9nFLkXUOqKamhv3792swGyR3Z//+/dTU1CRdioiUuZJXAY2GQlcB9fT0sHfv3mO+NCXR1NTUMHXqVKqqqpIuRURG0HCvAirbewFVVVVx+umnJ12GiMjHlu4FJCISKAWAiEigFAAiIoEqi5PAZnYQ2JV0HRFMJnM31HKnOuN1ItR5ItQIqjNuZ7p7obsyRFIuJ4F3DedM9mgxs1bVGR/VGZ8ToUZQnXEzs9bSrYrTISARkUApAEREAlUuAbAh6QIiUp3xUp3xORFqBNUZt2HVWRYngUVEZPSVyx6AiIiMMgWAiEigRiUAzOz67K9/HTGzB0q0/Tsze8fMOszsh2Y2ZjRqzL53pDrNbIWZpbN3Qu17LBylGseY2f1m9oaZHTSz35nZZQO0T6Q/B1Nnkv2Zff8fm9nbZvaBme02s5UDtE3y8xmpzqT7M1vDNDPrMrMfD9Amsb7MqWHAOpPuSzN7Pltf33sX/b7UkPrT3Uf8AXwJaAbuBR4YoN0lwLvADGAC8Dxwx2jUOMg6VwDbRquuvPeuBW4FGskE+H8h84trjeXUn4OsM7H+zL7/DGBM9vlZwDvAeeXUn4OsM9H+zNbw/4BfAz8u8nqifTmIOpP+bD4PrIzQbkj9OSp7AO6+2d1/BpT6ZbBrgPvdvc3d/wP4Jpl/gFExiDoT4+6H3P1Wd9/j7r3u/hTwOnBegeaJ9ecg60xUtn+O9E1mH39RoGnSn8+odSbKzK4C3geeHaBZon0Jkes8UQypP8vtHMAMYGfO9E5giplNSqiegZxrZvuyu+I3mVki36o2synAdAr/RGfZ9GeJOiHh/jSze8zsQ+A14G3g6QLNEu/PiHVCQv1pZnVAC/DfSzRNtC8HUSck///67dn3/80Ah5+G1J/lFgDjgI6c6b7nQ77XxQh5AZgJfAJYDCwF/sdoF2FmVcBPgAfd/bUCTcqiPyPUmXh/uvsaMv3yOTI/gXqkQLPE+zNinUn25zfJbIn+W4l2Sfdl1DqT/myuA84A/hOZa/6fNLNCe31D6s9yC4BOoC5nuu/5wQRqKcrd/+zur2cPbbxCZkviytGswcwqyPwuczdwfZFmifdnlDrLoT+zdaTdfRswFVhdoEni/Qml60yqP81sLvAF4LsRmifWl4OpM+nPprv/i7sfdPcj7v4g8Bvg8gJNh9Sf5RYAbcCcnOk5wLvuXrbH5LMcsNF6MzMz4H5gCrDY3XuKNE20PwdRZ75R7c8CKil8bL3cPp/F6sw3Wv25kMxJ/zfN7B1gLbDYzF4u0DbJvlxI9DrzJf3ZLPb+Q+vPUTqTXQnUALeT2RqsASoLtLuUzJUN55A5k/0co3uVRdQ6LwOmZJ+fBfwRuGUU67wP+GdgXIl2Sfdn1DoT608yu/ZXkdmFTpG5muIQsKic+nOQdSbSn8BJwCdzHncCjwL1ZdaXg6kzyc/mKdl/55rs2LQ8+29+Zlz9OeJ/RLa4W/noqoW+x61AA5ldl4actt8gcznTB8D/JnvZWznVmf3AvJv9x/gzmd3CqlGq8dPZurqyNfU9lpdTfw6mzoT7sx74FZmrQT4AXgGuy75WTv0Zuc4k+zOv5lvJXl5ZTn05mDrL4LP5EpnDOO+T2Zj6Ypz9qXsBiYgEqtzOAYiIyChRAIiIBEoBICISKAWAiEigFAAiIoFSAIiIBEoBICISKAWAiEigFAAiIoH6/xt6NPz81RIZAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", @@ -2965,11 +3684,57 @@ }, { "cell_type": "code", - "execution_count": 29, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(426, 30)\n", + "(143, 30)\n", + "[1. 0.86666667 0.93333333 1. 1. 0.92857143\n", + " 1. 0.92857143 0.92857143 0.92857143]\n", + "Test set accuracy with Random Forests and scaled data: 0.97\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", @@ -3038,11 +3803,106 @@ }, { "cell_type": "code", - "execution_count": 30, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[17:15:53] WARNING: /Users/travis/build/dmlc/xgboost/src/learner.cc:516: \n", + "Parameters: { colsaobjective } might not be used.\n", + "\n", + " This may not be accurate due to some parameters are only used in language bindings but\n", + " passed down to XGBoost core. Or some parameters are not used but slip through this\n", + " verification. Please open an issue if you find above cases.\n", + "\n", + "\n", + "Max depth: 0\n", + "Error: 0.27265898772673286\n", + "Bias^2: 0.27265898120693166\n", + "Var: 3.552713678800501e-15\n", + "0.27265898772673286 >= 0.27265898120693166 + 3.552713678800501e-15 = 0.2726589812069352\n", + "[17:15:53] WARNING: /Users/travis/build/dmlc/xgboost/src/learner.cc:516: \n", + "Parameters: { colsaobjective } might not be used.\n", + "\n", + " This may not be accurate due to some parameters are only used in language bindings but\n", + " passed down to XGBoost core. Or some parameters are not used but slip through this\n", + " verification. Please open an issue if you find above cases.\n", + "\n", + "\n", + "Max depth: 1\n", + "Error: 0.30539667982909335\n", + "Bias^2: 0.2707146103037183\n", + "Var: 0.03468207269906998\n", + "0.30539667982909335 >= 0.2707146103037183 + 0.03468207269906998 = 0.30539668300278827\n", + "[17:15:53] WARNING: /Users/travis/build/dmlc/xgboost/src/learner.cc:516: \n", + "Parameters: { colsaobjective } might not be used.\n", + "\n", + " This may not be accurate due to some parameters are only used in language bindings but\n", + " passed down to XGBoost core. Or some parameters are not used but slip through this\n", + " verification. Please open an issue if you find above cases.\n", + "\n", + "\n", + "Max depth: 2\n", + "Error: 0.3086154634354187\n", + "Bias^2: 0.27120662006386265\n", + "Var: 0.037408843636512756\n", + "0.3086154634354187 >= 0.27120662006386265 + 0.037408843636512756 = 0.3086154637003754\n", + "[17:15:53] WARNING: /Users/travis/build/dmlc/xgboost/src/learner.cc:516: \n", + "Parameters: { colsaobjective } might not be used.\n", + "\n", + " This may not be accurate due to some parameters are only used in language bindings but\n", + " passed down to XGBoost core. Or some parameters are not used but slip through this\n", + " verification. Please open an issue if you find above cases.\n", + "\n", + "\n", + "Max depth: 3\n", + "Error: 0.3086162750614561\n", + "Bias^2: 0.27120680244783013\n", + "Var: 0.037409473210573196\n", + "0.3086162750614561 >= 0.27120680244783013 + 0.037409473210573196 = 0.3086162756584033\n", + "[17:15:53] WARNING: /Users/travis/build/dmlc/xgboost/src/learner.cc:516: \n", + "Parameters: { colsaobjective } might not be used.\n", + "\n", + " This may not be accurate due to some parameters are only used in language bindings but\n", + " passed down to XGBoost core. Or some parameters are not used but slip through this\n", + " verification. Please open an issue if you find above cases.\n", + "\n", + "\n", + "Max depth: 4\n", + "Error: 0.3086162750614561\n", + "Bias^2: 0.27120680244783013\n", + "Var: 0.037409473210573196\n", + "0.3086162750614561 >= 0.27120680244783013 + 0.037409473210573196 = 0.3086162756584033\n", + "[17:15:53] WARNING: /Users/travis/build/dmlc/xgboost/src/learner.cc:516: \n", + "Parameters: { colsaobjective } might not be used.\n", + "\n", + " This may not be accurate due to some parameters are only used in language bindings but\n", + " passed down to XGBoost core. Or some parameters are not used but slip through this\n", + " verification. Please open an issue if you find above cases.\n", + "\n", + "\n", + "Max depth: 5\n", + "Error: 0.3086162750614561\n", + "Bias^2: 0.27120680244783013\n", + "Var: 0.037409473210573196\n", + "0.3086162750614561 >= 0.27120680244783013 + 0.037409473210573196 = 0.3086162756584033\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", @@ -3103,11 +3963,79 @@ }, { "cell_type": "code", - "execution_count": 31, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(426, 30)\n", + "(143, 30)\n", + "Test set accuracy with Random Forests and scaled data: 1.00\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "\n", "import matplotlib.pyplot as plt\n", @@ -3162,9 +4090,34 @@ "save_fig(\"xgparams\")\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], - "metadata": {}, + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, "nbformat": 4, "nbformat_minor": 4 }