![](\"images/classification-algorithm-in-machine-learning.png\")
\n",
"\n",
"Existen dos tipos de clasificadores según el número de clases:\n",
"- Binarios. Predicen un resultado binario. Hay dos tipos de clases, por ejemplo: *yes/no, pass/fail, spam/not spam, etc.*\n",
"- Multiclase. Como se indica existen más de dos clases, por ejemplo: *generos narrativos, etiquetas medioambientales, etc.*\n",
"\n",
"En la clasificación hay dos grupos de algoritmos:\n",
"- Modelos lineales:\n",
" - Logistic Regression / Regresión logística. \n",
" - Support Vector Machines / Máquinas de vectores de soporte (SVM)\n",
" - Naïve Bayes. Calculan la posibilidad de pertenecer a una categoría.\n",
"- Modelos no lineales:\n",
" - K-Nearest Neighbors K-NN / K-cercanos vecinos\n",
" - Decision Tree / Árboles de decisión\n",
" - Random Forest Classification\n",
" - Multi-layer percentron (MLP)\n",
" - Boosting\n",
"\n",
"Métricas de evaluación:\n",
" - Matriz de confusión: *True positive TP*, FP, FN, TN, ...\n",
" - E indicadores medios como: **F1-score**, **precisión** y **recall**\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Algoritmo lineal: Logistic Regression\n",
"\n",
"https://en.wikipedia.org/wiki/Logistic_regression"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [],
"source": [
"# Cargamos librerías\n",
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"\n",
"from sklearn.datasets import make_blobs\n",
"from sklearn.model_selection import train_test_split\n",
"from sklearn.metrics import confusion_matrix\n",
"from sklearn.model_selection import train_test_split\n",
"from sklearn.metrics import classification_report\n",
"\n",
"from sklearn.linear_model import LogisticRegression"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[ 6.14584755 -10.21373524]\n",
" [ 7.90822545 -3.28426248]\n",
" [ 5.52020454 -9.4260145 ]\n",
" [ 5.32686636 -7.74093543]\n",
" [ 7.66189206 -3.20638495]]\n",
"[1 0 1 1 0]\n"
]
},
{
"data": {
"text/plain": [
"LogisticRegression()In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
LogisticRegression()
Dada la siguiente muestras de datos reales, ¿dónde clasificarías cada una de ellas? ¿Qué accuracy se ha obtenido?\n", "- Nota: en la documentación hay dos funciones: *predict* y *predic_proba*. ¿Qué diferencias hay aplicando cada una de ellas?" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "
Calcula la matriz de confusión aplicando el método correspondiente: sklearn.metrics.confusion_matrix\n" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [], "source": [ "#TODO" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Algoritmo lineal: Support Vector Machine\n", "\n", "https://en.wikipedia.org/wiki/Support_vector_machine\n" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from sklearn.datasets import make_classification\n", "from sklearn.metrics import confusion_matrix\n", "from sklearn.metrics import precision_score\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.svm import LinearSVC\n" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[ 0.10049183 0.48800911]\n", " [-1.13103537 1.09946452]\n", " [-1.41857135 -0.86904789]\n", " [-0.57911797 -1.2615109 ]\n", " [-0.10760837 -2.13413139]]\n", "[0 0 1 1 1]\n" ] }, { "data": { "text/plain": [ "
\n", "Analiza como se comporta el algoritmo variando el parámetro de regulación (C). Retoca el siguiente código para poder representar los segmentos de separación de clases entre cada valor." ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "ename": "NameError", "evalue": "name 'X_train' is not defined", "output_type": "error", "traceback": [ "\u001b[31m---------------------------------------------------------------------------\u001b[39m", "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[45]\u001b[39m\u001b[32m, line 11\u001b[39m\n\u001b[32m 8\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m idx, C \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(Cs):\n\u001b[32m 10\u001b[39m model = LinearSVC(C=C, random_state=\u001b[32m0\u001b[39m)\n\u001b[32m---> \u001b[39m\u001b[32m11\u001b[39m model.fit(\u001b[43mX_train\u001b[49m, y_train)\n\u001b[32m 12\u001b[39m y_predict = model.predict(X_test)\n\u001b[32m 14\u001b[39m m = -model.coef_[\u001b[32m0\u001b[39m][\u001b[32m0\u001b[39m] / model.coef_[\u001b[32m0\u001b[39m][\u001b[32m1\u001b[39m]\n", "\u001b[31mNameError\u001b[39m: name 'X_train' is not defined" ] }, { "data": { "text/plain": [ "
\n", "- Prepara los datos y divide el conjunto de datos en un 70%\n", "- Entrena el regresor logístico\n", "- Muestra la matriz de confusión: ¿qué clases se confunden más?\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0 1 2 ... 8 9 8]\n", "(1797,)\n" ] } ], "source": [ "print(digits[\"target\"])\n", "print(digits[\"target\"].shape)\n", "digits[\"data\"][0]\n", "X = digits[\"data\"]\n", "Y = digits[\"target\"]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Modelo y entreno" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Matriz de confusión " ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Clasificación no lineal\n", "\n", "Básicamente, son instancias que no son separables linealmente.\n", "\n", "- Modelos no lineales:\n", " - K-Nearest Neighbors K-NN / K-cercanos vecinos\n", " - Decision Tree / Árboles de decisión\n", " - Random Forest Classification\n", " - Multi-layer percentron (MLP)\n", "\n", "Ejemplo de un K-NN:
\n", "
![](\"images/KNN-figure.png\")
\n",
"\n",
"Ejemplo de un Random Forest Classifier:\n", "
![](\"images/Random_forest_diagram_complete.png\")
\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### SVM para problemas no lineales\n",
"\n",
"Sobre SVM se pueden aplicar diferentes kernels, los más usados son aquellos polinómicos y el conocido como RBF ( Radial Basis Function).\n",
"\n",
"**RBF**\n", "Para usarlo necesitamos ajustar dos hiperparámetros: el ya conocido parámetro de regularización C y un segundo parámetro gamma, a mayor valor de este parámetro conduce a un límite de decisión más suave.\n", "\n", "Para usar SVM no lineales en scikit con kernel RBF, lo haremos de la siguiente manera:\n", "\n", "```python\n", "from sklearn.svm import SVC\n", "svm = SVC(kernel='rbf', random_state=0, gamma=0.10, C=1.0)\n", "```\n", "\n", "**Polinómico**
\n", "A efectos prácticos no es muy recomendable usar polinomios con grado mayor a 3, ya que corremos el riesgo de sobreajustar el clasificador a los datos y además el tiempo de entrenamiento crece.\n", "\n", "```python\n", "from sklearn.svm import SVC\n", "svm = SVC(kernel='poly', random_state=0, gamma=0.10, C=1.0)\n", "```\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "!uv add mlxtend\n", "# https://rasbt.github.io/mlxtend/" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [], "source": [ "from matplotlib.colors import ListedColormap\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "\n", "from mlxtend.plotting import plot_decision_regions" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
\n", "El objetivo de este ejercicio es valorar las características de unos modelos de vehículos para conocer su calidad: *unaccuracy, accuracy, good, y very good*. Variable *class*.\n", "- Carga y explora los datos del archivo: *data/car_evaluation.csv*.\n", "- Prepara los datos (X,y) y separa para el entrenamiento\n", "- Aplica RandomForest algorithm\n", " ```python\n", " from sklearn.ensemble import RandomForestClassifier\n", " rfc = RandomForestClassifier(random_state=0)\n", " ```\n", "- Entrena \n", "- Comprueba su accuracy:\n", " ```python\n", " from sklearn.metrics import accuracy_score\n", " print(\"Model accuracy score : %0.4f\" %accuracy_score(y_test, y_pred))\n", " ```\n", "- ¿Cómo se comportan los resultados variando el número de árboles?\n", " En https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html\n", " ```\n", " n_estimators : int, default=100\n", " The number of trees in the forest.\n", " ```" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(1727, 7)\n", " vhigh vhigh.1 2 2.1 small low unacc\n", "count 1727 1727 1727 1727 1727 1727 1727\n", "unique 4 4 4 3 3 3 4\n", "top high high 3 4 med med unacc\n", "freq 432 432 432 576 576 576 1209\n", " vhigh vhigh.1 2 2.1 small low unacc\n", "0 vhigh vhigh 2 2 small med unacc\n", "1 vhigh vhigh 2 2 small high unacc\n", "2 vhigh vhigh 2 2 med low unacc\n", "3 vhigh vhigh 2 2 med med unacc\n", "4 vhigh vhigh 2 2 med high unacc\n" ] }, { "data": { "text/html": [ "
LabelEncoder()In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
LabelEncoder()