diff --git a/anno3/apprendimento_automatico/esercizi/marco/.ipynb_checkpoints/classification_iris_knn_aa_19_20-checkpoint-checkpoint.ipynb b/anno3/apprendimento_automatico/esercizi/marco/.ipynb_checkpoints/classification_iris_knn_aa_19_20-checkpoint-checkpoint.ipynb new file mode 100644 index 0000000..8ec9ae8 --- /dev/null +++ b/anno3/apprendimento_automatico/esercizi/marco/.ipynb_checkpoints/classification_iris_knn_aa_19_20-checkpoint-checkpoint.ipynb @@ -0,0 +1,1810 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# # Classifiers comparison: decision trees and k-nearest neighbors on the dataset Iris\n", + "\n", + "\n", + "In the following program we compare the prediction results obtained by decision trees and k-nearest neighbors on the dataset Iris" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "The following cell shows the program training a decision tree and its results in preciction " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.96666667 1. 0.86666667 0.86666667 1. ]\n" + ] + } + ], + "source": [ + "from sklearn import tree \n", + "from sklearn.datasets import load_iris\n", + "from sklearn.model_selection import cross_val_score # will be used to separate training and test\n", + "iris = load_iris()\n", + "clf = tree.DecisionTreeClassifier(criterion=\"entropy\",random_state=300,min_samples_leaf=5,class_weight={0:1,1:1,2:1})\n", + "clf = clf.fit(iris.data, iris.target)\n", + "scores = cross_val_score(clf, iris.data, iris.target, cv=5) # score will be the accuracy\n", + "print(scores)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following cell shows the training of k-nearest neighbors and its prediction results.\n", + "Here we use a uniform weighting setting (weights='uniform'): any neighbors weights the same in the majority voting aggregation." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.93333333 1. 1. 0.96666667 1. ]\n", + "0 ok setosa\n", + "1 ok setosa\n", + "2 ok setosa\n", + "3 ok setosa\n", + "4 ok setosa\n", + "5 ok setosa\n", + "6 ok setosa\n", + "7 ok setosa\n", + "8 ok setosa\n", + "9 ok setosa\n", + "10 ok setosa\n", + "11 ok setosa\n", + "12 ok setosa\n", + "13 ok setosa\n", + "14 ok setosa\n", + "15 ok setosa\n", + "16 ok setosa\n", + "17 ok setosa\n", + "18 ok setosa\n", + "19 ok setosa\n", + "20 ok setosa\n", + "21 ok setosa\n", + "22 ok setosa\n", + "23 ok setosa\n", + "24 ok setosa\n", + "25 ok setosa\n", + "26 ok setosa\n", + "27 ok setosa\n", + "28 ok setosa\n", + "29 ok setosa\n", + "30 ok setosa\n", + "31 ok setosa\n", + "32 ok setosa\n", + "33 ok setosa\n", + "34 ok setosa\n", + "35 ok setosa\n", + "36 ok setosa\n", + "37 ok setosa\n", + "38 ok setosa\n", + "39 ok setosa\n", + "40 ok setosa\n", + "41 ok setosa\n", + "42 ok setosa\n", + "43 ok setosa\n", + "44 ok setosa\n", + "45 ok setosa\n", + "46 ok setosa\n", + "47 ok setosa\n", + "48 ok setosa\n", + "49 ok setosa\n", + "50 ok versicolor\n", + "51 ok versicolor\n", + "52 ok versicolor\n", + "53 ok versicolor\n", + "54 ok versicolor\n", + "55 ok versicolor\n", + "56 ok versicolor\n", + "57 ok versicolor\n", + "58 ok versicolor\n", + "59 ok versicolor\n", + "60 ok versicolor\n", + "61 ok versicolor\n", + "62 ok versicolor\n", + "63 ok versicolor\n", + "64 ok versicolor\n", + "65 ok versicolor\n", + "66 ok versicolor\n", + "67 ok versicolor\n", + "68 ok versicolor\n", + "69 ok versicolor\n", + "70 ok versicolor\n", + "71 ok versicolor\n", + "72 ok versicolor\n", + "73 ok versicolor\n", + "74 ok versicolor\n", + "75 ok versicolor\n", + "76 ok versicolor\n", + "77 nok true class: versicolor; predicted: virginica\n", + "78 ok versicolor\n", + "79 ok versicolor\n", + "80 ok versicolor\n", + "81 ok versicolor\n", + "82 ok versicolor\n", + "83 nok true class: versicolor; predicted: virginica\n", + "84 ok versicolor\n", + "85 ok versicolor\n", + "86 ok versicolor\n", + "87 ok versicolor\n", + "88 ok versicolor\n", + "89 ok versicolor\n", + "90 ok versicolor\n", + "91 ok versicolor\n", + "92 ok versicolor\n", + "93 ok versicolor\n", + "94 ok versicolor\n", + "95 ok versicolor\n", + "96 ok versicolor\n", + "97 ok versicolor\n", + "98 ok versicolor\n", + "99 ok versicolor\n", + "100 ok virginica\n", + "101 ok virginica\n", + "102 ok virginica\n", + "103 ok virginica\n", + "104 ok virginica\n", + "105 ok virginica\n", + "106 nok true class: virginica; predicted: versicolor\n", + "107 ok virginica\n", + "108 ok virginica\n", + "109 ok virginica\n", + "110 ok virginica\n", + "111 ok virginica\n", + "112 ok virginica\n", + "113 ok virginica\n", + "114 ok virginica\n", + "115 ok virginica\n", + "116 ok virginica\n", + "117 ok virginica\n", + "118 ok virginica\n", + "119 ok virginica\n", + "120 ok virginica\n", + "121 ok virginica\n", + "122 ok virginica\n", + "123 ok virginica\n", + "124 ok virginica\n", + "125 ok virginica\n", + "126 ok virginica\n", + "127 ok virginica\n", + "128 ok virginica\n", + "129 ok virginica\n", + "130 ok virginica\n", + "131 ok virginica\n", + "132 ok virginica\n", + "133 ok virginica\n", + "134 ok virginica\n", + "135 ok virginica\n", + "136 ok virginica\n", + "137 ok virginica\n", + "138 nok true class: virginica; predicted: versicolor\n", + "139 ok virginica\n", + "140 ok virginica\n", + "141 ok virginica\n", + "142 ok virginica\n", + "143 ok virginica\n", + "144 ok virginica\n", + "145 ok virginica\n", + "146 ok virginica\n", + "147 ok virginica\n", + "148 ok virginica\n", + "149 ok virginica\n" + ] + } + ], + "source": [ + "from sklearn import neighbors\n", + "n_neighbors = 11\n", + "clf_knn = neighbors.KNeighborsClassifier(n_neighbors, weights='uniform')\n", + "clf_knn = clf_knn.fit(iris.data, iris.target)\n", + "scores = cross_val_score(clf_knn, iris.data, iris.target, cv=5) # score will be the accuracy\n", + "print(scores)\n", + "# shows the model predictions \n", + "for i in range(len(iris.target)):\n", + " instance=(iris.data[i,:]).reshape(1, -1)\n", + " predicted=clf_knn.predict(instance)[0]\n", + " if iris.target[i]==predicted:\n", + " print(str(i)+\" ok \"+str(iris.target_names[iris.target[i]]))\n", + " else:\n", + " print(str(i)+\" nok \"+\"true class: \"+str(iris.target_names[iris.target[i]])+\"; predicted: \"+str(iris.target_names[predicted]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the following cell we use a varying weighting setting (weights='distance'): any neighbors weights inversely with its distance to the test instance in the majority voting aggregation." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 ok setosa\n", + "1 ok setosa\n", + "2 ok setosa\n", + "3 ok setosa\n", + "4 ok setosa\n", + "5 ok setosa\n", + "6 ok setosa\n", + "7 ok setosa\n", + "8 ok setosa\n", + "9 ok setosa\n", + "10 ok setosa\n", + "11 ok setosa\n", + "12 ok setosa\n", + "13 ok setosa\n", + "14 ok setosa\n", + "15 ok setosa\n", + "16 ok setosa\n", + "17 ok setosa\n", + "18 ok setosa\n", + "19 ok setosa\n", + "20 ok setosa\n", + "21 ok setosa\n", + "22 ok setosa\n", + "23 ok setosa\n", + "24 ok setosa\n", + "25 ok setosa\n", + "26 ok setosa\n", + "27 ok setosa\n", + "28 ok setosa\n", + "29 ok setosa\n", + "30 ok setosa\n", + "31 ok setosa\n", + "32 ok setosa\n", + "33 ok setosa\n", + "34 ok setosa\n", + "35 ok setosa\n", + "36 ok setosa\n", + "37 ok setosa\n", + "38 ok setosa\n", + "39 ok setosa\n", + "40 ok setosa\n", + "41 ok setosa\n", + "42 ok setosa\n", + "43 ok setosa\n", + "44 ok setosa\n", + "45 ok setosa\n", + "46 ok setosa\n", + "47 ok setosa\n", + "48 ok setosa\n", + "49 ok setosa\n", + "50 ok versicolor\n", + "51 ok versicolor\n", + "52 ok versicolor\n", + "53 ok versicolor\n", + "54 ok versicolor\n", + "55 ok versicolor\n", + "56 ok versicolor\n", + "57 ok versicolor\n", + "58 ok versicolor\n", + "59 ok versicolor\n", + "60 ok versicolor\n", + "61 ok versicolor\n", + "62 ok versicolor\n", + "63 ok versicolor\n", + "64 ok versicolor\n", + "65 ok versicolor\n", + "66 ok versicolor\n", + "67 ok versicolor\n", + "68 ok versicolor\n", + "69 ok versicolor\n", + "70 ok versicolor\n", + "71 ok versicolor\n", + "72 ok versicolor\n", + "73 ok versicolor\n", + "74 ok versicolor\n", + "75 ok versicolor\n", + "76 ok versicolor\n", + "77 ok versicolor\n", + "78 ok versicolor\n", + "79 ok versicolor\n", + "80 ok versicolor\n", + "81 ok versicolor\n", + "82 ok versicolor\n", + "83 ok versicolor\n", + "84 ok versicolor\n", + "85 ok versicolor\n", + "86 ok versicolor\n", + "87 ok versicolor\n", + "88 ok versicolor\n", + "89 ok versicolor\n", + "90 ok versicolor\n", + "91 ok versicolor\n", + "92 ok versicolor\n", + "93 ok versicolor\n", + "94 ok versicolor\n", + "95 ok versicolor\n", + "96 ok versicolor\n", + "97 ok versicolor\n", + "98 ok versicolor\n", + "99 ok versicolor\n", + "100 ok virginica\n", + "101 ok virginica\n", + "102 ok virginica\n", + "103 ok virginica\n", + "104 ok virginica\n", + "105 ok virginica\n", + "106 ok virginica\n", + "107 ok virginica\n", + "108 ok virginica\n", + "109 ok virginica\n", + "110 ok virginica\n", + "111 ok virginica\n", + "112 ok virginica\n", + "113 ok virginica\n", + "114 ok virginica\n", + "115 ok virginica\n", + "116 ok virginica\n", + "117 ok virginica\n", + "118 ok virginica\n", + "119 ok virginica\n", + "120 ok virginica\n", + "121 ok virginica\n", + "122 ok virginica\n", + "123 ok virginica\n", + "124 ok virginica\n", + "125 ok virginica\n", + "126 ok virginica\n", + "127 ok virginica\n", + "128 ok virginica\n", + "129 ok virginica\n", + "130 ok virginica\n", + "131 ok virginica\n", + "132 ok virginica\n", + "133 ok virginica\n", + "134 ok virginica\n", + "135 ok virginica\n", + "136 ok virginica\n", + "137 ok virginica\n", + "138 ok virginica\n", + "139 ok virginica\n", + "140 ok virginica\n", + "141 ok virginica\n", + "142 ok virginica\n", + "143 ok virginica\n", + "144 ok virginica\n", + "145 ok virginica\n", + "146 ok virginica\n", + "147 ok virginica\n", + "148 ok virginica\n", + "149 ok virginica\n", + "Classification score of k-nn with distance weighting\n", + "[0.96666667 1. 1. 0.96666667 1. ]\n" + ] + } + ], + "source": [ + "n_neighbors = 11\n", + "clf_knn2 = neighbors.KNeighborsClassifier(n_neighbors, weights='distance')\n", + "clf_knn2.fit(iris.data, iris.target)\n", + "\n", + "for i in range(len(iris.target)):\n", + " instance=(iris.data[i,:]).reshape(1, -1)\n", + " predicted2=clf_knn2.predict(instance)[0]\n", + " if iris.target[i]==predicted2:\n", + " print(str(i)+\" ok \"+str(iris.target_names[iris.target[i]]))\n", + " else:\n", + " print(str(i)+\" nok \"+\"true class: \"+str(iris.target_names[iris.target[i]])+\"; predicted: \"+str(iris.target_names[predicted]))\n", + "print(\"Classification score of k-nn with distance weighting\")\n", + "scores2 = cross_val_score(clf_knn2, iris.data, iris.target, cv=5,scoring='accuracy') # score will be the accuracy\n", + "print(scores2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following cell shows the tuning of the k-nn models with a varying value of k (number of nearest neighbors) and finds the best value of k (giving the maximum accuracy)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "k neighbors=1\n", + "accuracy=0.9166666666666666\n", + "k neighbors=2\n", + "accuracy=0.9166666666666666\n", + "k neighbors=3\n", + "accuracy=0.9333333333333333\n", + "k neighbors=4\n", + "accuracy=0.9166666666666666\n", + "k neighbors=5\n", + "accuracy=0.95\n", + "k neighbors=6\n", + "accuracy=0.9333333333333333\n", + "k neighbors=7\n", + "accuracy=0.9666666666666667\n", + "k neighbors=8\n", + "accuracy=0.9333333333333333\n", + "k neighbors=9\n", + "accuracy=0.9666666666666667\n", + "k neighbors=10\n", + "accuracy=0.9666666666666667\n", + "k neighbors=11\n", + "accuracy=0.9666666666666667\n", + "k neighbors=12\n", + "accuracy=0.9666666666666667\n", + "k neighbors=13\n", + "accuracy=0.9666666666666667\n", + "k neighbors=14\n", + "accuracy=0.95\n", + "k neighbors=15\n", + "accuracy=0.95\n", + "k neighbors=16\n", + "accuracy=0.9166666666666666\n", + "k neighbors=17\n", + "accuracy=0.9333333333333333\n", + "k neighbors=18\n", + "accuracy=0.9166666666666666\n", + "k neighbors=19\n", + "accuracy=0.9166666666666666\n", + "k neighbors=20\n", + "accuracy=0.9166666666666666\n", + "k neighbors=21\n", + "accuracy=0.9166666666666666\n", + "k neighbors=22\n", + "accuracy=0.9166666666666666\n", + "k neighbors=23\n", + "accuracy=0.9166666666666666\n", + "k neighbors=24\n", + "accuracy=0.9\n", + "k neighbors=25\n", + "accuracy=0.9166666666666666\n", + "k neighbors=26\n", + "accuracy=0.9166666666666666\n", + "k neighbors=27\n", + "accuracy=0.9333333333333333\n", + "k neighbors=28\n", + "accuracy=0.9333333333333333\n", + "k neighbors=29\n", + "accuracy=0.9333333333333333\n", + "k neighbors=30\n", + "accuracy=0.9166666666666666\n", + "k neighbors=31\n", + "accuracy=0.9333333333333333\n", + "k neighbors=32\n", + "accuracy=0.9166666666666666\n", + "k neighbors=33\n", + "accuracy=0.9333333333333333\n", + "k neighbors=34\n", + "accuracy=0.9166666666666666\n", + "k neighbors=35\n", + "accuracy=0.9333333333333333\n", + "k neighbors=36\n", + "accuracy=0.9166666666666666\n", + "k neighbors=37\n", + "accuracy=0.9333333333333333\n", + "k neighbors=38\n", + "accuracy=0.9\n", + "k neighbors=39\n", + "accuracy=0.9166666666666666\n", + "k neighbors=40\n", + "accuracy=0.9166666666666666\n", + "k neighbors=41\n", + "accuracy=0.9333333333333333\n", + "k neighbors=42\n", + "accuracy=0.9333333333333333\n", + "k neighbors=43\n", + "accuracy=0.9333333333333333\n", + "k neighbors=44\n", + "accuracy=0.9166666666666666\n", + "k neighbors=45\n", + "accuracy=0.9333333333333333\n", + "k neighbors=46\n", + "accuracy=0.9166666666666666\n", + "k neighbors=47\n", + "accuracy=0.9166666666666666\n", + "k neighbors=48\n", + "accuracy=0.9166666666666666\n", + "k neighbors=49\n", + "accuracy=0.9166666666666666\n", + "k neighbors=50\n", + "accuracy=0.9166666666666666\n", + "k neighbors=51\n", + "accuracy=0.9333333333333333\n", + "k neighbors=52\n", + "accuracy=0.9333333333333333\n", + "k neighbors=53\n", + "accuracy=0.9333333333333333\n", + "k neighbors=54\n", + "accuracy=0.9333333333333333\n", + "k neighbors=55\n", + "accuracy=0.9333333333333333\n", + "k neighbors=56\n", + "accuracy=0.95\n", + "k neighbors=57\n", + "accuracy=0.95\n", + "k neighbors=58\n", + "accuracy=0.95\n", + "k neighbors=59\n", + "accuracy=0.95\n", + "k neighbors=60\n", + "accuracy=0.95\n", + "k neighbors=61\n", + "accuracy=0.95\n", + "k neighbors=62\n", + "accuracy=0.95\n", + "k neighbors=63\n", + "accuracy=0.95\n", + "k neighbors=64\n", + "accuracy=0.95\n", + "k neighbors=65\n", + "accuracy=0.95\n", + "k neighbors=66\n", + "accuracy=0.95\n", + "k neighbors=67\n", + "accuracy=0.95\n", + "k neighbors=68\n", + "accuracy=0.95\n", + "k neighbors=69\n", + "accuracy=0.95\n", + "k neighbors=70\n", + "accuracy=0.95\n", + "k neighbors=71\n", + "accuracy=0.95\n", + "k neighbors=72\n", + "accuracy=0.95\n", + "k neighbors=73\n", + "accuracy=0.95\n", + "k neighbors=74\n", + "accuracy=0.95\n", + "k neighbors=75\n", + "accuracy=0.95\n", + "k neighbors=76\n", + "accuracy=0.95\n", + "k neighbors=77\n", + "accuracy=0.95\n", + "k neighbors=78\n", + "accuracy=0.95\n", + "k neighbors=79\n", + "accuracy=0.95\n", + "k neighbors=80\n", + "accuracy=0.95\n", + "k neighbors=81\n", + "accuracy=0.95\n", + "k neighbors=82\n", + "accuracy=0.95\n", + "k neighbors=83\n", + "accuracy=0.95\n", + "k neighbors=84\n", + "accuracy=0.95\n", + "k neighbors=85\n", + "accuracy=0.95\n", + "k neighbors=86\n", + "accuracy=0.95\n", + "k neighbors=87\n", + "accuracy=0.95\n", + "k neighbors=88\n", + "accuracy=0.95\n", + "k neighbors=89\n", + "accuracy=0.95\n", + "k neighbors=90\n", + "accuracy=0.95\n", + "\n", + "\n", + "best k=7\n", + "best accuracy=0.9666666666666667\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "from numpy import zeros\n", + "from sklearn import neighbors\n", + "from sklearn.datasets import load_iris\n", + "iris = load_iris()\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.4, random_state=0)\n", + "\n", + "best_accuracy=0\n", + "best_k=1\n", + "A=np.zeros(len(y_train), dtype=np.float) # for storing accuracies\n", + "for n_neighbors in np.arange(1,len(y_train)+1):\n", + " clf_knn3 = neighbors.KNeighborsClassifier(n_neighbors, weights='distance')\n", + " # (n_neighbors=5, weights='uniform', algorithm='auto', leaf_size=30, p=2, metric='minkowski', metric_params=None, n_jobs=1, **kwargs)\n", + " clf_knn3.fit(X_train, y_train)\n", + " index=n_neighbors-1\n", + " A[index]=clf_knn3.score(X_test, y_test)\n", + " if best_accuracy" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "from numpy import zeros\n", + "from sklearn import neighbors\n", + "from sklearn.datasets import load_iris\n", + "iris = load_iris()\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.4, random_state=0)\n", + "\n", + "i=0 #parameter in the control of the subplot to draw on'\n", + "f,(ax1, ax2) = plt.subplots(1, 2, sharey=True)\n", + "for weight_type in ['uniform','distance']:\n", + " print(\"weighting:\"+str(weight_type))\n", + " A=np.zeros(len(y_train), dtype=np.float) # for storing accuracies\n", + " best_accuracy=0\n", + " best_k=1\n", + " for n_neighbors in np.arange(1,len(y_train)+1):\n", + " clf_knn2 = neighbors.KNeighborsClassifier(n_neighbors, weights=weight_type)\n", + " # (n_neighbors=5, weights='uniform', algorithm='auto', leaf_size=30, p=2, metric='minkowski', metric_params=None, n_jobs=1, **kwargs)\n", + " clf_knn2.fit(X_train, y_train)\n", + " index=n_neighbors-1\n", + " A[index]=clf_knn2.score(X_test, y_test)\n", + " if best_accuracy" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "from numpy import zeros\n", + "from sklearn import neighbors\n", + "from sklearn.datasets import load_iris\n", + "iris = load_iris()\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.4, random_state=0)\n", + "\n", + "fig = plt.figure()\n", + "fig.suptitle('Accuracy in k-nn with number of neighbors and types of weighting', fontsize=14, fontweight='bold')\n", + "ax = fig.add_subplot(111)\n", + "ax.set_xlabel('n. neighbors')\n", + "ax.set_ylabel('accuracy')\n", + "\n", + "A=np.zeros((len(y_train),2), dtype=np.float) # 2 arrays for storing accuracies for each type of weigthing\n", + "i=0 #parameter in the control of the different diagram (=matrix A column index)\n", + "best_accuracy=0\n", + "for weight_type in ['uniform','distance']:\n", + " print(\"\\n weighting:\"+str(weight_type))\n", + " best_accuracy=0\n", + " best_k=1\n", + " for n_neighbors in np.arange(1,len(y_train)+1):\n", + " clf_knn2 = neighbors.KNeighborsClassifier(n_neighbors, weights=weight_type)\n", + " # (n_neighbors=5, weights='uniform', algorithm='auto', leaf_size=30, p=2, metric='minkowski', metric_params=None, n_jobs=1, **kwargs)\n", + " clf_knn2.fit(X_train, y_train)\n", + " index=n_neighbors-1 # computes the matrix row index\n", + " A[index,i]=clf_knn2.score(X_test, y_test)\n", + " if best_accuracy" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "colors = ['r' if iris.target[i] == 0 else 'b' if iris.target[i] == 1 else 'g' for i in range(len(iris.target))]\n", + "plt.scatter(iris.data[:,0], iris.data[:,1], c = colors)\n", + "plt.xlabel('sepal length')\n", + "plt.ylabel('sepal width')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot the Iris dataset, in 2-D, with the color as above determined by the k-nn estimation\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'sepal width')" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Knn con k = 7 e weights = distance\n", + "clf = neighbors.KNeighborsClassifier(7, weights='distance')\n", + "clf.fit(X_train, y_train)\n", + "\n", + "#Predict sul dataset\n", + "y_predicted = clf.predict(iris.data)\n", + "colors = ['r' if y_predicted[i] == 0 else 'b' if y_predicted[i] == 1 else 'g' for i in range(len(y_predicted))]\n", + "\n", + "plt.scatter(iris.data[:,0], iris.data[:,1], c = colors)\n", + "plt.xlabel('sepal length')\n", + "plt.ylabel('sepal width')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the following, extend the above exercize on k-nn using a kernel function for the distances computation. Use a Gaussian kernel, centered around the data point, with a standard deviation sigma that must be tuned to the best value." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "import math" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def gaussian_kernel(X, Y, sigma):\n", + " return np.exp(-np.linalg.norm(X - Y)**2 / (2 * sigma**2))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def gaussian_distance(X, Y, sigma):\n", + " return math.sqrt(gaussian_kernel(X, X, sigma) - 2 * gaussian_kernel(X, Y, sigma) + gaussian_kernel(Y, Y, sigma))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "best sigma: 0.09999999999999999 with accuracy: 0.9666666666666667\n" + ] + } + ], + "source": [ + "best_sigma = 0\n", + "best_score = 0\n", + "for sigma in np.arange(0.01, 0.5, 0.01):\n", + " clf_gaus = neighbors.KNeighborsClassifier(7, weights='distance', metric = gaussian_distance, metric_params = {'sigma' : sigma})\n", + " clf_gaus.fit(X_train, y_train)\n", + " score = clf_gaus.score(X_test, y_test)\n", + " if(score > best_score):\n", + " best_score = score\n", + " best_sigma = sigma\n", + "print(\"best sigma: \", best_sigma, \" with accuracy: \", best_score)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'sepal width')" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "clf_gaus = neighbors.KNeighborsClassifier(7, weights='distance', metric = gaussian_distance, metric_params = {'sigma' : best_sigma})\n", + "clf_gaus.fit(X_train, y_train)\n", + "\n", + "#Predict sul dataset\n", + "y_predicted = clf_gaus.predict(iris.data)\n", + "colors = ['r' if y_predicted[i] == 0 else 'b' if y_predicted[i] == 1 else 'g' for i in range(len(y_predicted))]\n", + "\n", + "plt.scatter(iris.data[:,0], iris.data[:,1], c = colors)\n", + "plt.xlabel('sepal length')\n", + "plt.ylabel('sepal width')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "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.7.7" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/anno3/apprendimento_automatico/esercizi/marco/.ipynb_checkpoints/coverage_plots-checkpoint.ipynb b/anno3/apprendimento_automatico/esercizi/marco/.ipynb_checkpoints/coverage_plots-checkpoint.ipynb new file mode 100644 index 0000000..4071407 --- /dev/null +++ b/anno3/apprendimento_automatico/esercizi/marco/.ipynb_checkpoints/coverage_plots-checkpoint.ipynb @@ -0,0 +1,491 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Coverage plots" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us consider the following function which applies a linear model to the given data. \n", + "Specifically, given a \"model\" vector containing the model coefficients $(a,b)$ and a $n \\times 2$ \"data\" matrix containing the data points to be classified, the function outputs a vector $\\mathbf{z}$, $|\\mathbf{z}| = n$ of booleans where $z_i$ is `True` if $a \\cdot x_{i,1} + b \\cdot x_{i,2} \\geq 0$, it is `False` otherwise." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def apply_linear_model(model, data):\n", + " return np.dot(data, np.transpose(model)) > 0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us define `data` by generating $1000$ points drawn uniformly from $\\mathcal{X} = [-100,100]^2$." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\galat\\.conda\\envs\\aaut\\lib\\site-packages\\ipykernel_launcher.py:1: DeprecationWarning: This function is deprecated. Please call randint(-100, 100 + 1) instead\n", + " \"\"\"Entry point for launching an IPython kernel.\n" + ] + }, + { + "data": { + "text/plain": [ + "array([[ -8, -49],\n", + " [-39, 7],\n", + " [ 48, 95],\n", + " ...,\n", + " [ -2, 7],\n", + " [ 35, 72],\n", + " [ 28, -5]])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data = np.random.random_integers(-100,100,[1000,2])\n", + "data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "and let target_labels be the labeling output by applying `apply_linear_model` with our target model: $4x -y > 0$" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "target_model = [4.,-1.]\n", + "target_labels = apply_linear_model(target_model, data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By using matplotlib.pyplot module it is easy to plot the generated points onto a 2D plot:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "colors = ['r' if l else 'b' for l in target_labels]\n", + "plt.scatter(data[:,0], data[:,1], color=colors)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally let us now generate at random 100 linear models with coefficients in $[-5,5]$:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-2.47471947, -3.5581708 ],\n", + " [ 1.59686449, 1.71893864],\n", + " [ 3.03294605, 4.57263288],\n", + " [ 4.3603124 , -1.19540694],\n", + " [ 1.21976183, 4.09720458],\n", + " [ 0.42857121, 3.20268614],\n", + " [-2.15226242, 2.96225011],\n", + " [ 0.65773544, -2.54676899],\n", + " [-2.79365386, -0.78924628],\n", + " [ 2.90156232, -3.31703275],\n", + " [-0.9849533 , 0.62170036],\n", + " [-4.0396815 , 4.36277095],\n", + " [ 1.34248188, 1.77758129],\n", + " [ 0.38419206, 0.17314725],\n", + " [-2.04665134, 2.10337995],\n", + " [-2.50975771, 3.65315789],\n", + " [ 2.004511 , 2.73918509],\n", + " [ 4.15805913, -4.96182686],\n", + " [ 4.51026319, -1.78429829],\n", + " [-3.31973604, 3.43442154],\n", + " [ 3.52497128, 0.85718807],\n", + " [-3.06163513, -0.86712587],\n", + " [-4.18156322, -2.21571818],\n", + " [-4.59703113, 4.4801163 ],\n", + " [-2.65368229, 4.37023623],\n", + " [ 3.90990454, -2.1420455 ],\n", + " [-3.24752094, -0.40639067],\n", + " [ 0.10755654, 0.48649316],\n", + " [ 2.26731088, 4.73364989],\n", + " [-4.22292673, -0.21284274],\n", + " [-4.66592874, -2.79620572],\n", + " [ 4.63716865, 0.87182744],\n", + " [-4.32406367, 1.10060443],\n", + " [-0.45847 , 0.70180339],\n", + " [ 3.22176576, -2.5364163 ],\n", + " [ 3.80797501, 2.35293627],\n", + " [ 3.36332162, -3.79299501],\n", + " [ 3.99625756, 2.36135165],\n", + " [ 1.20216525, -1.23827528],\n", + " [-3.09694201, 3.9600678 ],\n", + " [-0.64611333, 2.09501923],\n", + " [ 0.99744202, 1.49993523],\n", + " [-3.36391051, -3.90944487],\n", + " [-3.58672509, -4.1088498 ],\n", + " [ 3.46090243, 0.02661214],\n", + " [-1.49631605, -2.28424324],\n", + " [ 1.1089388 , -1.73806817],\n", + " [ 3.30150146, -3.13759682],\n", + " [-4.51293209, 4.08479726],\n", + " [-4.09529163, 4.28334043],\n", + " [-0.7227784 , 0.85683098],\n", + " [-3.54236195, -4.37842609],\n", + " [-1.67857772, 1.18420411],\n", + " [-2.06131565, -3.81118901],\n", + " [-0.94505145, -0.79410051],\n", + " [-1.58100698, -4.40226088],\n", + " [ 3.49623546, 0.98568917],\n", + " [-4.7875311 , 2.46132599],\n", + " [-0.90714606, -4.03370503],\n", + " [-4.04974727, 1.89697029],\n", + " [ 2.3912763 , 4.43535836],\n", + " [ 1.91805621, 3.10706978],\n", + " [ 2.7870542 , -4.76785357],\n", + " [-4.83230806, 0.68706866],\n", + " [ 4.21091682, 2.69235722],\n", + " [ 4.92125435, 1.67552945],\n", + " [-4.17809823, -3.0655279 ],\n", + " [ 1.34522792, -2.11218453],\n", + " [-2.82712946, -3.84431909],\n", + " [ 4.32983019, -0.67660343],\n", + " [ 3.69650316, -2.09533608],\n", + " [-2.46459767, -2.78730998],\n", + " [-0.12911643, 3.03464722],\n", + " [-0.54414414, -4.24446833],\n", + " [ 0.70841166, 0.82220448],\n", + " [-1.21624127, 2.67030582],\n", + " [-4.4511487 , -0.18157221],\n", + " [ 0.54850624, 3.80806515],\n", + " [ 0.41580003, 2.39770318],\n", + " [ 0.78040198, -2.27920522],\n", + " [-0.98993749, -4.66406869],\n", + " [ 2.67850165, 1.2013196 ],\n", + " [-0.85139301, -3.08916589],\n", + " [ 2.00142468, -3.62142984],\n", + " [-0.08136816, 1.76822154],\n", + " [-4.92951601, 0.11860089],\n", + " [-2.36011692, 2.25618495],\n", + " [ 1.60982063, -0.44192244],\n", + " [-2.54853258, -2.17737341],\n", + " [-1.31205757, 2.17528846],\n", + " [ 4.9863995 , -3.99442219],\n", + " [-1.87206871, -2.53218008],\n", + " [ 2.35107436, -4.08841325],\n", + " [ 3.5602568 , -2.39084033],\n", + " [-1.67264783, -2.78819786],\n", + " [ 2.14307079, -1.80908234],\n", + " [-2.47515458, 2.07939336],\n", + " [ 0.34640981, 0.10794752],\n", + " [ 1.0289358 , -1.10048266],\n", + " [-4.92276006, 0.74592667]])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "models = (np.random.rand(100,2) - 0.5) * 10\n", + "models" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Write a function that, taken two list of labellings build the corresponding confusion matrix [[1](#hint1)];\n", + "1. For each model in `models` plot the [FP,TP] pairs on a scatter plot;\n", + "1. Just looking at the plot: which is the best model in the pool?\n", + "1. Find the model with the best accuracy [[2](#hint2)] and compare it with the target model, is it close? Is it the model you would have picked up visually from the scatter plot?\n", + "1. If everything is ok, you should have found a pretty good model for our data. It fits the data quite well and it is quite close to the target model. Did you expect this? If so, why? If not so, why not?\n", + "\n", + "Hint 1: it may be helpful to have a way to map TRUE to 0, FALSE to 1 and to use these values as indices in the confusion matrix. \n", + "\n", + "Hint 2: one way to proceed is to build a function `accuracy`, use the `map` function to calculate the accuracies of all the models, and then apply the `numpy.argmax` to retrieve the index of the best model." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Es. 1" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "def build_confusion_matrix(labels1, labels2):\n", + " confusion_matrix = np.zeros((2,2))\n", + " for i in range(len(labels1)):\n", + " confusion_matrix[1 - labels1[i], 1 - labels2[i]] += 1\n", + " return confusion_matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[202. 281.]\n", + " [310. 207.]]\n" + ] + } + ], + "source": [ + "print(build_confusion_matrix(apply_linear_model(target_model, data), apply_linear_model(models[0], data)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Es. 2\n" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fp = []\n", + "tp = []\n", + "\n", + "for model in models:\n", + " confusion = build_confusion_matrix(target_labels, apply_linear_model(model, data))\n", + " fp.append(confusion[1,0])\n", + " tp.append(confusion[0,0])\n", + "plt.scatter(fp, tp)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Es. 3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Il modello migliore è quello in alto a sinistra (max TP/FP)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 4.3603124 , -1.19540694])" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "models[np.argmax([t / f for t, f in zip(tp, fp)])]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Es. 4\n" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "def accuracy(tp, tn, total):\n", + " return (tp + tn) / total" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model: [ 4.3603124 -1.19540694] accuracy: 0.995\n" + ] + } + ], + "source": [ + "accuracies = []\n", + "\n", + "for model in models:\n", + " confusion = build_confusion_matrix(target_labels, apply_linear_model(model, data))\n", + " accuracies.append(accuracy(confusion[0,0], confusion[1,1], 1000))\n", + "\n", + "print(\"model: \", models[np.argmax(accuracies)], \" accuracy: \", accuracies[np.argmax(accuracies)])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Il modello è lo stesso predetto dalla plot" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Es. 5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Mi aspettavo di trovare un modello con un'accuracy alta ma non come quella trovata (0.995), perchè su 100 modelli, con due variabili comprese tra 5 e -5, generati con una funzione random uniforme mi aspetto dei valori vicini a quelli target." + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "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.7.7" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/anno3/apprendimento_automatico/esercizi/marco/my_iris_predictions.pdf b/anno3/apprendimento_automatico/esercizi/marco/my_iris_predictions.pdf index 233ff05..66ba98e 100644 Binary files a/anno3/apprendimento_automatico/esercizi/marco/my_iris_predictions.pdf and b/anno3/apprendimento_automatico/esercizi/marco/my_iris_predictions.pdf differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_009d5b9a38354e47bc531517fd08c916f839dbcf.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_009d5b9a38354e47bc531517fd08c916f839dbcf.png new file mode 100644 index 0000000..b306308 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_009d5b9a38354e47bc531517fd08c916f839dbcf.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_00a4f41cea1936ef9d6881f6237c9ba92ab21059.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_00a4f41cea1936ef9d6881f6237c9ba92ab21059.png new file mode 100644 index 0000000..4b7dfe7 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_00a4f41cea1936ef9d6881f6237c9ba92ab21059.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_0c8cca787b25836299452be6103195086681f2f5.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_0c8cca787b25836299452be6103195086681f2f5.png new file mode 100644 index 0000000..6cb5907 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_0c8cca787b25836299452be6103195086681f2f5.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_1de56530261142450e287b9928175213bbea6e28.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_1de56530261142450e287b9928175213bbea6e28.png new file mode 100644 index 0000000..1655e5c Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_1de56530261142450e287b9928175213bbea6e28.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_1ec901a6e24ab393a52f6208bff7a91a91946505.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_1ec901a6e24ab393a52f6208bff7a91a91946505.png new file mode 100644 index 0000000..64e785e Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_1ec901a6e24ab393a52f6208bff7a91a91946505.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_1f3ab76e15118e7ccd68550c1539964c8eba1e54.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_1f3ab76e15118e7ccd68550c1539964c8eba1e54.png new file mode 100644 index 0000000..745b2c7 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_1f3ab76e15118e7ccd68550c1539964c8eba1e54.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_21ee0ba462390d4aae091efafded31095f545d9d.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_21ee0ba462390d4aae091efafded31095f545d9d.png new file mode 100644 index 0000000..90c499c Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_21ee0ba462390d4aae091efafded31095f545d9d.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_24c79671536067ab714500ac10875dffcb3bb725.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_24c79671536067ab714500ac10875dffcb3bb725.png new file mode 100644 index 0000000..e8abeed Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_24c79671536067ab714500ac10875dffcb3bb725.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_2eaa86cae1fbdc530298157cf488971a535319e6.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_2eaa86cae1fbdc530298157cf488971a535319e6.png new file mode 100644 index 0000000..12b84a4 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_2eaa86cae1fbdc530298157cf488971a535319e6.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_343b198e9e11357d7385707205e8cb7e2677c09e.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_343b198e9e11357d7385707205e8cb7e2677c09e.png new file mode 100644 index 0000000..5aaca54 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_343b198e9e11357d7385707205e8cb7e2677c09e.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_34a7da99a6319d7371d9b56218e0b3fbbc3ff309.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_34a7da99a6319d7371d9b56218e0b3fbbc3ff309.png new file mode 100644 index 0000000..07b94d3 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_34a7da99a6319d7371d9b56218e0b3fbbc3ff309.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_351ae0300b8ead5e5329ffcaf9d317f1db02bf24.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_351ae0300b8ead5e5329ffcaf9d317f1db02bf24.png new file mode 100644 index 0000000..f5cb34f Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_351ae0300b8ead5e5329ffcaf9d317f1db02bf24.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_35968ea8a72637e2180f132128c5070b45a4d60b.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_35968ea8a72637e2180f132128c5070b45a4d60b.png new file mode 100644 index 0000000..5304b81 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_35968ea8a72637e2180f132128c5070b45a4d60b.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_359b5e417687668c8a82f0423c510574139aa7be.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_359b5e417687668c8a82f0423c510574139aa7be.png new file mode 100644 index 0000000..0218585 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_359b5e417687668c8a82f0423c510574139aa7be.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_3d2d02f27f3f92afe6c5a0984a07b0ba0efcb1da.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_3d2d02f27f3f92afe6c5a0984a07b0ba0efcb1da.png new file mode 100644 index 0000000..6603df3 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_3d2d02f27f3f92afe6c5a0984a07b0ba0efcb1da.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_3fe65cdddc27fa5d46457129d3a9f5da8ce9b11b.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_3fe65cdddc27fa5d46457129d3a9f5da8ce9b11b.png new file mode 100644 index 0000000..e18bd23 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_3fe65cdddc27fa5d46457129d3a9f5da8ce9b11b.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_3ff92d346640c09cc510c41daa6f7976cfdba167.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_3ff92d346640c09cc510c41daa6f7976cfdba167.png new file mode 100644 index 0000000..d1ab6be Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_3ff92d346640c09cc510c41daa6f7976cfdba167.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_408cce809a33a5781e67e2c9b87ca740fe1c3a67.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_408cce809a33a5781e67e2c9b87ca740fe1c3a67.png new file mode 100644 index 0000000..68631bd Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_408cce809a33a5781e67e2c9b87ca740fe1c3a67.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_418ab4c9fff36ce69acef4ecf592a17d0d59908b.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_418ab4c9fff36ce69acef4ecf592a17d0d59908b.png new file mode 100644 index 0000000..cb494c5 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_418ab4c9fff36ce69acef4ecf592a17d0d59908b.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_49be64268fd426e35f9881846d00dcb888bf64ea.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_49be64268fd426e35f9881846d00dcb888bf64ea.png new file mode 100644 index 0000000..4dec2f6 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_49be64268fd426e35f9881846d00dcb888bf64ea.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_5760bde3a0bd0a854cdcf398632218aced169991.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_5760bde3a0bd0a854cdcf398632218aced169991.png new file mode 100644 index 0000000..aef660f Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_5760bde3a0bd0a854cdcf398632218aced169991.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_57697e580097bf2e847137bf9e0e4f18082ad873.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_57697e580097bf2e847137bf9e0e4f18082ad873.png new file mode 100644 index 0000000..a57e427 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_57697e580097bf2e847137bf9e0e4f18082ad873.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_59acfef2961bd547ab6a90f8acfbfa3d5ebba57c.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_59acfef2961bd547ab6a90f8acfbfa3d5ebba57c.png new file mode 100644 index 0000000..815e470 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_59acfef2961bd547ab6a90f8acfbfa3d5ebba57c.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_5e49e5a231af71bb449576b66cb221471004565d.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_5e49e5a231af71bb449576b66cb221471004565d.png new file mode 100644 index 0000000..d1ab6be Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_5e49e5a231af71bb449576b66cb221471004565d.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_5f11436b1a47849340bdb1cf7bcabd72fe3f6c86.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_5f11436b1a47849340bdb1cf7bcabd72fe3f6c86.png new file mode 100644 index 0000000..683a08f Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_5f11436b1a47849340bdb1cf7bcabd72fe3f6c86.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_638c63f719adc6a4cf4e2253b1bac9081833caa3.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_638c63f719adc6a4cf4e2253b1bac9081833caa3.png new file mode 100644 index 0000000..a72f9e1 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_638c63f719adc6a4cf4e2253b1bac9081833caa3.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_69ebb5bf6aa72e433fffe18ea5067d7bad4fc659.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_69ebb5bf6aa72e433fffe18ea5067d7bad4fc659.png new file mode 100644 index 0000000..21331e6 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_69ebb5bf6aa72e433fffe18ea5067d7bad4fc659.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_6f8436f74f46d2c53c56fe18b969a6ee22206b8c.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_6f8436f74f46d2c53c56fe18b969a6ee22206b8c.png new file mode 100644 index 0000000..510cba6 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_6f8436f74f46d2c53c56fe18b969a6ee22206b8c.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_6fb261465c838ecbbb15b370845c375adebd7282.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_6fb261465c838ecbbb15b370845c375adebd7282.png new file mode 100644 index 0000000..c86c4da Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_6fb261465c838ecbbb15b370845c375adebd7282.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_798a6ebd2cf5cdc51b80ecda2d14a15d82ec53d9.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_798a6ebd2cf5cdc51b80ecda2d14a15d82ec53d9.png new file mode 100644 index 0000000..0218585 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_798a6ebd2cf5cdc51b80ecda2d14a15d82ec53d9.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_7a8c72698b6e68ccc5163056488061de84e4a515.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_7a8c72698b6e68ccc5163056488061de84e4a515.png new file mode 100644 index 0000000..010da3d Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_7a8c72698b6e68ccc5163056488061de84e4a515.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_8278b4a9704279a1b69491dbbc5ae3ac80b853f4.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_8278b4a9704279a1b69491dbbc5ae3ac80b853f4.png new file mode 100644 index 0000000..03bfbda Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_8278b4a9704279a1b69491dbbc5ae3ac80b853f4.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_84d210584a6f0d659c91f19d10db9bed120d3071.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_84d210584a6f0d659c91f19d10db9bed120d3071.png new file mode 100644 index 0000000..c0298b9 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_84d210584a6f0d659c91f19d10db9bed120d3071.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_86251eda3e3b937cc3ee753e80c76bddc29c9b8d.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_86251eda3e3b937cc3ee753e80c76bddc29c9b8d.png new file mode 100644 index 0000000..90c499c Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_86251eda3e3b937cc3ee753e80c76bddc29c9b8d.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_98f9c8a8d8af2fdb66070e12ce265d8e72d28c89.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_98f9c8a8d8af2fdb66070e12ce265d8e72d28c89.png new file mode 100644 index 0000000..281274e Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_98f9c8a8d8af2fdb66070e12ce265d8e72d28c89.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_9ca523d8741c8155303b16535fba8d1356f1072b.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_9ca523d8741c8155303b16535fba8d1356f1072b.png new file mode 100644 index 0000000..0822ce4 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_9ca523d8741c8155303b16535fba8d1356f1072b.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_a69a83d0699c4d404ec73d1108f421f0655843bc.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_a69a83d0699c4d404ec73d1108f421f0655843bc.png new file mode 100644 index 0000000..2cd6494 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_a69a83d0699c4d404ec73d1108f421f0655843bc.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_a6ec56199a3fecd2cc5f7bcbd3c80a3cd606922a.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_a6ec56199a3fecd2cc5f7bcbd3c80a3cd606922a.png new file mode 100644 index 0000000..a0b9727 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_a6ec56199a3fecd2cc5f7bcbd3c80a3cd606922a.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_a73ae23a701ca7a6d78c0d703298e88764502924.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_a73ae23a701ca7a6d78c0d703298e88764502924.png new file mode 100644 index 0000000..f81e41b Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_a73ae23a701ca7a6d78c0d703298e88764502924.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_af0b218808645b593d70fb11abb7bbe5a5b9c9ef.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_af0b218808645b593d70fb11abb7bbe5a5b9c9ef.png new file mode 100644 index 0000000..029d979 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_af0b218808645b593d70fb11abb7bbe5a5b9c9ef.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_b2629e636b3e136b547f2678f5bebc1990807b69.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_b2629e636b3e136b547f2678f5bebc1990807b69.png new file mode 100644 index 0000000..9aab4c1 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_b2629e636b3e136b547f2678f5bebc1990807b69.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_b5b1cb07c63f3b103a6a0fc2da42be4fccd618ff.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_b5b1cb07c63f3b103a6a0fc2da42be4fccd618ff.png new file mode 100644 index 0000000..48a9e71 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_b5b1cb07c63f3b103a6a0fc2da42be4fccd618ff.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_b7cc23709d0a522e2aca0705efad9e05856071bc.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_b7cc23709d0a522e2aca0705efad9e05856071bc.png new file mode 100644 index 0000000..5ff9ca9 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_b7cc23709d0a522e2aca0705efad9e05856071bc.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_bb182d316566a7fbf4d597faa904f45b26ce2664.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_bb182d316566a7fbf4d597faa904f45b26ce2664.png new file mode 100644 index 0000000..24113e2 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_bb182d316566a7fbf4d597faa904f45b26ce2664.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_bc02ad4f947a80325ec0f3ca8674b1aa77c58cd9.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_bc02ad4f947a80325ec0f3ca8674b1aa77c58cd9.png new file mode 100644 index 0000000..2bf4267 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_bc02ad4f947a80325ec0f3ca8674b1aa77c58cd9.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_bc80a944060980d3b09b5e08170675585219f16b.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_bc80a944060980d3b09b5e08170675585219f16b.png new file mode 100644 index 0000000..1cab6fc Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_bc80a944060980d3b09b5e08170675585219f16b.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_c1ac0bc69508906b4c6b0c9600dd9fdeae2b7efa.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_c1ac0bc69508906b4c6b0c9600dd9fdeae2b7efa.png new file mode 100644 index 0000000..b503706 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_c1ac0bc69508906b4c6b0c9600dd9fdeae2b7efa.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_d4374805c6f2a6c7b0dbe5bdb17212f14c8ddf96.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_d4374805c6f2a6c7b0dbe5bdb17212f14c8ddf96.png new file mode 100644 index 0000000..770d47c Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_d4374805c6f2a6c7b0dbe5bdb17212f14c8ddf96.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_d576af9d3848800e51e11196767875145c28ce27.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_d576af9d3848800e51e11196767875145c28ce27.png new file mode 100644 index 0000000..d1ab6be Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_d576af9d3848800e51e11196767875145c28ce27.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_d642a051e39cb11809687f0e525f34f0ee6cad45.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_d642a051e39cb11809687f0e525f34f0ee6cad45.png new file mode 100644 index 0000000..4178ae4 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_d642a051e39cb11809687f0e525f34f0ee6cad45.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_d6dcf60c7536af1edf93d58815a8adce48357516.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_d6dcf60c7536af1edf93d58815a8adce48357516.png new file mode 100644 index 0000000..b306308 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_d6dcf60c7536af1edf93d58815a8adce48357516.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_e3833db98f32ceaef9e2340c61e8b313e0e9f23e.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_e3833db98f32ceaef9e2340c61e8b313e0e9f23e.png new file mode 100644 index 0000000..48a9e71 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_e3833db98f32ceaef9e2340c61e8b313e0e9f23e.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_e3d5a5cb92f8abc71fd64f3b8d98c3be5efd3709.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_e3d5a5cb92f8abc71fd64f3b8d98c3be5efd3709.png new file mode 100644 index 0000000..5aaca54 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_e3d5a5cb92f8abc71fd64f3b8d98c3be5efd3709.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_eaf4677a5942866b2d95fb477b01c7aefd036084.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_eaf4677a5942866b2d95fb477b01c7aefd036084.png new file mode 100644 index 0000000..6c3a849 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_eaf4677a5942866b2d95fb477b01c7aefd036084.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_f6f0be2a3d19586f9905eeb617ce5e941b7e360c.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_f6f0be2a3d19586f9905eeb617ce5e941b7e360c.png new file mode 100644 index 0000000..1088a7c Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_f6f0be2a3d19586f9905eeb617ce5e941b7e360c.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_f8e6f41ff89f93c9680d46abad2fc42233b86369.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_f8e6f41ff89f93c9680d46abad2fc42233b86369.png new file mode 100644 index 0000000..b36e6ab Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_f8e6f41ff89f93c9680d46abad2fc42233b86369.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_fadfd453b7a79a82a6f7ebb9883331c14623be8a.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_fadfd453b7a79a82a6f7ebb9883331c14623be8a.png new file mode 100644 index 0000000..3e0b125 Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_fadfd453b7a79a82a6f7ebb9883331c14623be8a.png differ diff --git a/anno3/apprendimento_automatico/ltximg/org-ltximg_fb834d47d5fb28a49ebdc568787ec2b76a62df26.png b/anno3/apprendimento_automatico/ltximg/org-ltximg_fb834d47d5fb28a49ebdc568787ec2b76a62df26.png new file mode 100644 index 0000000..ff63c8a Binary files /dev/null and b/anno3/apprendimento_automatico/ltximg/org-ltximg_fb834d47d5fb28a49ebdc568787ec2b76a62df26.png differ diff --git a/anno3/apprendimento_automatico/preparazione.org b/anno3/apprendimento_automatico/preparazione.org new file mode 100644 index 0000000..9173c2e --- /dev/null +++ b/anno3/apprendimento_automatico/preparazione.org @@ -0,0 +1,116 @@ +* Esposito +** Tasks: Binary Classification +I modelli predittivi si occupano di inferire delle informazioni sui +nuove istanze di problemi in base ai dati gia` consumati +*** TODO Geometric classification +*** Probabilistic classifier +Stima probabilita` dai dati e fornisce predizioni usando la seguente +regola: +- Yₘₐₚ = $arg max_{Y}P(Y|X)$ = $argmax_Y\frac{(P(X|Y)(PY)}{P(X))}$ = + $argmax_Y\frac{(P(X|Y)(PY)}{P(Y))}$ +- Yₘₗ = $argmax_YP(X|Y)$ (se priori non importanti) +*** Features +Se vogliamo approssimare la funzione coseno e` inutile considerare +un'approssimazione lineare (y=0). +Pero` possiamo usare x come sia come splitting feature (due +approssimazioni diverse se x<0 o x≥0) e come variabile di regression +(l'approssimazione contiene x) +Delle volte si puo` mappare il feature space su nuovi spazi (e.g.: +scatter plot: renderlo al quadrato) +** Classification +$\hat{c}$: X → C +C = {C₁, C₂, ..., Cₖ} +example: +Learning is constructing $\hat{c}$ +*** TODO Decision Tree +Vedi decision tree, feature tree, contingency table +*** Misure +- Accuracy: $acc = \frac{1}{|T_e|}\sum I[\hat{c}(x)=c(x)] = P(\hat{c}(x) = c(x))$ +- Error rate: $1-acc = P(\hat{c}(x) \ne c(x))$ +- class ratio, clr: $\frac{Pos}{Neg} = \frac{\sum_{x\in{T_e}} + I[c(x)=1]}{\sum_{x\in{T_e}} I[c(x)=0]}$ +- recall, true positive rate: $\frac{TP}{Pos} = P(\hat{c}(x)|c(x))$ +- specificity, true negative rate = $\frac{TP}{Pos} = + P(\hat{c}(x)|c(x))$ +- false positive, false negative = 1-tnr, 1-tpr +- Precision, confidence = $\frac{TP}{TP+FP} = P(c(x)|\hat{c}(x))$ +*** TODO Coverage plot e roc plot +*** Scoring Classifier +mapping $\hat{s}: X \to R^k$ dove s e` un vettore s(x) = (s₁(x), +s₂(x), ..., sₖ(x)). i-th componente = score della classe Cᵢ +Nello scoring tree, in caso di classificazione binaria, si possono +usare nelle foglie il logaritmo del ratio fra lo score delle classi. +**** Margine e Loss f +Prendiamo la classe true come +1: +- z(x) = c(x)$\hat{s}(x)$ +Il margine e` il valore assoluto della predizione, positivo se giusta, +negativo se errata. +La Loss function L(z(x)): R → [0, ∞); L(0) = 1 e L(z<0)≥1 e +L(z>0)∈[0,1) +La loss function e` importante nella fase di learning per cercare la +soluzione ottimale +- 0-1 Loss +- Hinge Loss +- Logistic Loss +- Exp Loss +- Squared Loss +**** Ranking +Una funzione di scoring puo` essere trasformata in una di ranking +ordinando le istanze in base allo score ottenuto. +Ranking-Error quando $\hat{s}(x)<\hat{s}(x') \wedge s(x') < s(x)$ +- $\frac{\sum_{x\in{T^+_e},x'\in{T^-_e}}{I[\hat{s}(x) < \hat(s)(x')] + + I[\hat{s}(x) = \hat(s)(x')]}}{Pos\cdot Neg}$ +- Ranking accuracy: 1 - Rank-Err +*** Probability Estimator +Scoring classifier che per ogni classe restituisce la probabilita` che +l'istanza appartenga a quella classe +- $\hat{p}: X \to [0,1]^k$ +- $\sum_{i=1}^{k}{\hat{p_i}(x)} = 1$ +- Squared Error: $SE(x) = \frac{1}{2} \Vert \hat{p}(x) - I_{c(x)} \Vert + ^2_2 = \frac{1}{2}\sum_{i=1}^{k}(\hat{p}(x) - I[c(x) = C_i])^2$ +- Mean Squared Error: $MSE(T_e) = + \frac{1}{|T_e|}\sum_{x\in{T_e}}SE(x)$ +- Empirical Probability: Vettore dato dal numero di istanze sul totale + per ogni classe (frequenza) +Solitamente si applica un coefficente di smoothing per queste +frequenze +- Laplace correction: $\dot{p_i}(S) = \frac{n_i+1}{|S|+k}$ +- m-estimate: non uniform smoothing dato da pseudo-counts m e prior + probs πᵢ $\dot{p_i}(S) = \frac{n_i+m\cdot\pi_i}{|S|+m}$ +*** TODO Beyond Binary Classification +Vedi 1-vs-rest, 1-vs-1 e cosi` via +*** Overfitting, bias-variance +L'overfitting si evita avendo un numero di parametri ben piu` basso +dei data points. +Con un numero basso di parametri si introduce un bias che spesso anche +con un training elevato non si riesce a risolvere. +Invece con pochi parametri si introduce una forte dipendenza dal test +set e quindi molta varianza. +- $E[(f(x)-\hat{f}(x))^2] = Bias^2(\hat{f}(x)) + Var(\hat{f}(x))$ + (vedi dimostrazione slides) +** Descriptive Learning +Tasks and learning problem coincide. No separate training set, produce +a descriptive model of the data at hand. Learn a model describing the +data. +*** Clustering +Obbiettivo: trovare gruppi omegenei, trovare una labelling function da +dati senza label. +- $\hat{q}: X \to C$ (predictive) +- $\hat{q}: X \to L$ (descriptive) +*** Supervised subgroup discovery +Preso un dataset labelled (xᵢ, l(xᵢ))ⁱ trova: +- $\hat{g}: D \to {true, false}$ +- G = {x∈D | $\hat{g}$(x) = true}, la cui class distribution e` + diversa marcatamente dalla popolazione originale +*** Association Rules +Dato un dataset unlabelled D trova: +- un set di regole {b→h} tale che: + + h solitamente e` soddisfatta quando b lo e` + + b∪h e` frequente (high support: %n di elementi soddisfano la + regola) +- Il powerset di un insieme di regole frequenti e` frequente a sua + volta. +- Confidenza: support(a∪b)/suport(a) +** Models +*** Linear Models +* Meo diff --git a/tesi/files/translation.png b/tesi/files/translation.png new file mode 100644 index 0000000..132af41 Binary files /dev/null and b/tesi/files/translation.png differ diff --git a/tesi/files/translation.xml b/tesi/files/translation.xml new file mode 100644 index 0000000..6e0248b --- /dev/null +++ b/tesi/files/translation.xml @@ -0,0 +1,2 @@ + +7VpLc5swEP41PrbD23Bs7TQ5pJnMuE2TU0cB2agViAg5tvvrK4p4yo6JYx5OfWHY1fvbT6vVwkifBOtLCiL/K/EgHmmKtx7p05Gm2ZbFn4likyoMx0kVC4q8VKUWihn6A4VSEdol8mBcqcgIwQxFVaVLwhC6rKIDlJJVtdqc4OqoEVhASTFzAZa1P5DHfLEsUyn0VxAt/GxkVRElAcgqC0XsA4+sSir9YqRPKCEsfQvWE4gT7DJc0nZfdpTmE6MwZE0aaN8NeLmyQXz9E8yuVjcYPDkfRC/PAC/Fgr8BuoCM6ybclGLmbJPBwbvkyHPh88pHDM4i4CYlK257rvNZgLmk8lfRL6QMrndOWM1h4PSBJICMbngV0cASwAnmZJCvCjOoGbZ+yQS20AFh+UXecQEOfxH4vAYrSwJLxsfj7BEiocwnCxICfFFoP1OyDD2YjKNwqahzTUgksPsFGduIrQCWjGxDNhnoZVz5vMiSuvCFFYn5s9Tku+vp2+1EIQYMPVfncXzYx/8r7GafsGsS6rN0XYmvHZZn0I3eXYP53jiqN+ToDkN1w1F9N0c5NJqSn2UuCSKEIZWMUoW8c+ZqSkPmWm0xV5cjgBNnrnEK3tWQUM+5+gwoAo+YB72aglHMevW0BxO2NVeryZu+D8Jy/OjmXrT/JzwkwkczE6frcuF0I6QjEt1sSHT7jUQXTW8JClnBDKN+CNctns5LtKoZPZ/G4TyQT9zc9wfiEsooCGO+SNK/35dClqa3mdYcfzbYeR9ZDffRuJ19ZFaZoerd7iPt3QUATe1p9BkAyLmEPAA4Afdl9e295JxAHb4egyZjPLDMlb33rBwQWv3f5rV3d5t3GrpEVdluqm58oiPBfle6CwUgilC4GBRXVad3rsp7+8S5mn352U/WXnNPqhw/30GK5sjlg5NwlHxACT0k3i9hCOkgjnJrfOCNvrWzXJUj0Cl0UZwid0uJC70llTPOXSNnDw85TULu4mmJuAhDOW/0KrzmCOMJwZywSVvdA9Ceu1wfM0p+w1KJ5drwcX4chMdOLRTYEjk5WwAetwawnGy6IUmQedIwO/bQYJbTofIhFnqfku/5XHIxiGPk1hIJa8TuS++lNAKXiixCImRJhAEkH7J/GvYddtZ2i5YsZm6xWKZ7Y45Cr3s+p8aEdJlSjkJOdmi1joxaR20nO9oi2gE0U7sjWdNMsXMm2TFI1uQ/kc68WYc0sxvSbNctsxuemc6ReGYZPfOsyY8x3Z2a3fFsfOZZpzyT8zIH86zg1kOpZB/PioCsY6apTcOz9CbWF9Vs9UhUs+uf+zumWvbt60y1fXfSM9V2Uo2LxV/VafXi13T94i8= \ No newline at end of file diff --git a/tesi/ltximg/org-ltximg_281d75b9c7257f8ca0009fb57df82c88bf8d6238.png b/tesi/ltximg/org-ltximg_281d75b9c7257f8ca0009fb57df82c88bf8d6238.png new file mode 100644 index 0000000..8097f8d Binary files /dev/null and b/tesi/ltximg/org-ltximg_281d75b9c7257f8ca0009fb57df82c88bf8d6238.png differ diff --git a/tesi/ltximg/org-ltximg_53c50223013bcadba7aaf69653d434e229d31555.png b/tesi/ltximg/org-ltximg_53c50223013bcadba7aaf69653d434e229d31555.png new file mode 100644 index 0000000..5eb483d Binary files /dev/null and b/tesi/ltximg/org-ltximg_53c50223013bcadba7aaf69653d434e229d31555.png differ diff --git a/tesi/ltximg/org-ltximg_5dbff3d74212c1e74b41bf94fdf29fb07ade3aaa.png b/tesi/ltximg/org-ltximg_5dbff3d74212c1e74b41bf94fdf29fb07ade3aaa.png new file mode 100644 index 0000000..ce8fd5a Binary files /dev/null and b/tesi/ltximg/org-ltximg_5dbff3d74212c1e74b41bf94fdf29fb07ade3aaa.png differ diff --git a/tesi/ltximg/org-ltximg_6c6174872f14d48141ae8b2ccd27ea18d48790f8.png b/tesi/ltximg/org-ltximg_6c6174872f14d48141ae8b2ccd27ea18d48790f8.png new file mode 100644 index 0000000..7b01c77 Binary files /dev/null and b/tesi/ltximg/org-ltximg_6c6174872f14d48141ae8b2ccd27ea18d48790f8.png differ diff --git a/tesi/ltximg/org-ltximg_775db85e9cf9bc2228b3916136bdd06d46a3bf01.png b/tesi/ltximg/org-ltximg_775db85e9cf9bc2228b3916136bdd06d46a3bf01.png new file mode 100644 index 0000000..058138b Binary files /dev/null and b/tesi/ltximg/org-ltximg_775db85e9cf9bc2228b3916136bdd06d46a3bf01.png differ diff --git a/tesi/ltximg/org-ltximg_82e3df8253d0f8b87fa87d8969d1b5bbd5d47ea6.png b/tesi/ltximg/org-ltximg_82e3df8253d0f8b87fa87d8969d1b5bbd5d47ea6.png new file mode 100644 index 0000000..74e98de Binary files /dev/null and b/tesi/ltximg/org-ltximg_82e3df8253d0f8b87fa87d8969d1b5bbd5d47ea6.png differ diff --git a/tesi/ltximg/org-ltximg_95341eada942a193a82e9059076737864cc22cfc.png b/tesi/ltximg/org-ltximg_95341eada942a193a82e9059076737864cc22cfc.png new file mode 100644 index 0000000..1edeeff Binary files /dev/null and b/tesi/ltximg/org-ltximg_95341eada942a193a82e9059076737864cc22cfc.png differ diff --git a/tesi/ltximg/org-ltximg_bdf6bd03ada02c6af4899c26e77896cc6aa59837.png b/tesi/ltximg/org-ltximg_bdf6bd03ada02c6af4899c26e77896cc6aa59837.png new file mode 100644 index 0000000..80047bd Binary files /dev/null and b/tesi/ltximg/org-ltximg_bdf6bd03ada02c6af4899c26e77896cc6aa59837.png differ diff --git a/tesi/referenze/10.1.1.172.9992.pdf b/tesi/referenze/10.1.1.172.9992.pdf new file mode 100644 index 0000000..927d344 Binary files /dev/null and b/tesi/referenze/10.1.1.172.9992.pdf differ diff --git a/tesi/referenze/10.1.1.43.1286.pdf b/tesi/referenze/10.1.1.43.1286.pdf new file mode 100644 index 0000000..cbecb85 Binary files /dev/null and b/tesi/referenze/10.1.1.43.1286.pdf differ diff --git a/tesi/referenze/tv_pldi00.pdf b/tesi/referenze/tv_pldi00.pdf new file mode 100644 index 0000000..0b457c2 Binary files /dev/null and b/tesi/referenze/tv_pldi00.pdf differ diff --git a/todo.org b/todo.org index c8a6777..c6a6ba1 100644 --- a/todo.org +++ b/todo.org @@ -1,7 +1,7 @@ -* Apprendimento Automatico [2/3] +* Apprendimento Automatico [2/4] - [X] Scrivile per date di esame - [X] Richiedi date esame -- [ ] Slides [0/2] +- [ ] Slides [0/5] - [ ] 002: + [ ] Laplace adjustment + [ ] Output code decoding @@ -22,13 +22,13 @@ + [ ] Sum of squared error + [ ] Silhouttes + [ ] Rivedi kernelization -- [ ] Esercizi: - - [ ] es1: perche` min_impurity decrease +- [-] Esercizi [1/3] + - [X] es1: perche` min_impurity decrease - [ ] chiedi a Galla`, Marco e Naz quali sono tutti gli es - [ ] linear models.zip? -* Tesi [8/33] -- [ ] Rivedere inference rules di Gabriel e aggiustarle con le mie +* Tesi [9/33] +- [X] Rivedere inference rules di Gabriel e aggiustarle con le mie - [ ] Definisci domain sempre allo stesso modo, con bigcup o | - [ ] Scegli se usare [[t_s]\] o D(ts) - [X] Definizione di First(x_i): serve?