![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\"){kind=icon}
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "_-Lo440XIq3A"
+ },
+ "source": [
+ "# ML - Aprendizaje No Supervisado\n",
+ "## [M.Sc. Ruben Quispe](https://www.linkedin.com/in/ruben-quispe-l/)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "i9UMTmVDIq3A"
+ },
+ "source": [
+ "Si bien todos los ejemplos de *Machine Learning* que hemos visto hasta ahora en esta serie se han basado en aprendizaje supervisado (nuestros datos van acompañados de las etiquetas correspondientes, ejemplos de la tarea que queremos llevar a cabo) la mayoría de los datos no están etiquetados. Antes esta problemática tenemos dos alternativas: etiquetar datos manualmente (lo cual require de tiempo, esfuerzo y dinero en el caso de querer desarrollar sistemas reales) o bien usar técnicas de aprendizaje no supervisado, o *Unsupervised Learning* en inglés. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "oUt2I_XgIq3B"
+ },
+ "source": [
+ "## Clustering"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "nalt7jmuIq3B"
+ },
+ "source": [
+ "De entre las diferentes técnicas de aprendizaje no supervisado, el *Clustering* es una de las más usadas. Este técnica consiste en identificar aquellas muestras similares del conjunto de datos y asignarlas a un *cluster*, o grupo. Esto permite aplicaciones tales como: segmentación de clientes, análisis de datos, reducción de la dimensionalidad, detección de anomalías, aprendizaje semi-supervisado, motores de búsqueda e incluso la semgentación de imágenes. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "kbGRya9gIq3B"
+ },
+ "source": [
+ "### K-Means"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "uo82KxJpIq3C"
+ },
+ "source": [
+ "El algoritmo de *K-Means* es uno de los más usados a la hora de aplicar *Clustering*, ya que es un método rápido y eficiente. Vamos a generar un conjunto de datos sintético para aprender a usar esta técnica."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "Vuss31kPIq3C"
+ },
+ "outputs": [],
+ "source": [
+ "from sklearn.datasets import make_blobs\n",
+ "import numpy as np\n",
+ "\n",
+ "blob_centers = np.array(\n",
+ " [[ 0.2, 2.3],\n",
+ " [-1.5 , 2.3],\n",
+ " [-2.8, 1.8],\n",
+ " [-2.8, 2.8],\n",
+ " [-2.8, 1.3]])\n",
+ "blob_std = np.array([0.4, 0.3, 0.1, 0.1, 0.1])\n",
+ "\n",
+ "X, y = make_blobs(n_samples=2000, centers=blob_centers,\n",
+ " cluster_std=blob_std, random_state=7)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "MKJvusEXIq3D"
+ },
+ "outputs": [],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "def plot_clusters(X, y=None):\n",
+ " plt.scatter(X[:, 0], X[:, 1], c=y, s=1)\n",
+ " plt.xlabel(\"$x_1$\", fontsize=14)\n",
+ " plt.ylabel(\"$x_2$\", fontsize=14, rotation=0)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "QUb4dW7LIq3E",
+ "outputId": "01b339b7-cf40-40d4-9b05-586986112618"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "KMeans(algorithm='full', init='random', max_iter=3, n_clusters=5, n_init=1,\n", + " random_state=1)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
KMeans(algorithm='full', init='random', max_iter=3, n_clusters=5, n_init=1,\n", + " random_state=1)
KMeans(algorithm='full', init='random', n_clusters=5, random_state=11)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
KMeans(algorithm='full', init='random', n_clusters=5, random_state=11)
DBSCAN(eps=0.05)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
DBSCAN(eps=0.05)
KNeighborsClassifier(n_neighbors=50)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
KNeighborsClassifier(n_neighbors=50)
GaussianMixture(n_components=3, n_init=10, random_state=42)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
GaussianMixture(n_components=3, n_init=10, random_state=42)
BayesianGaussianMixture(n_components=10, n_init=10, random_state=42)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
BayesianGaussianMixture(n_components=10, n_init=10, random_state=42)
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "xP1rYduVOdXZ"
+ },
+ "source": [
+ "## ML - Proyecto de ML de Principio a Fin\n",
+ "## [M.Sc. Ruben Quispe](https://www.linkedin.com/in/ruben-quispe-l/)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "atMR5Z6mOdXZ"
+ },
+ "source": [
+ "Llegamos al final de nuestro viaje aprendiendo sobre algoritmos y técnicas de *Machine Learning*. Hemos visto modelos tales como la regresión lineal, *Support Vector Machine* y árboles de decisión; técnicas de ensamblado como *Random Forest* y *Gradient Boosting* y otras técnicas como de reducción de dimensionalidad y *Clustering* para aprendizaje no supervisado. En este último post de la serie vamos a poner en práctica estos conceptos, y aprender algunos trucos nuevos por el camino, con la ejecución de un proyecto de ML de principio a fin para que puedas usarlo como \"receta\" para tus proyectos."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "WcReftJJOdXa"
+ },
+ "source": [
+ "## El *checklist* del proyecto de *Machine Learning*"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ysMcPaWiOdXa"
+ },
+ "source": [
+ "A la hora de llevar a cabo un proyecto de ML, estos son los puntos más importantes que tienes que tener en cuenta:\n",
+ "\n",
+ "1. Entiende el problema desde una visión global (no sólo técnica, sino de negocio e impacto).\n",
+ "2. Obtén los datos.\n",
+ "3. Explora y visualiza los datos.\n",
+ "4. Prepara los datos para los algoritmos de ML.\n",
+ "5. Selecciona un modelo y entrénalo.\n",
+ "6. Ajusta tu modelo (optimización de hyperparámetros, ensamblado).\n",
+ "7. Presenta tu solución.\n",
+ "8. Despliega, monitoriza y mantén el sistema.\n",
+ "\n",
+ "Obviamente, siéntete libre de modificar esta lista para ajustarla a tus necesidades."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "WsXKLAP9OdXa"
+ },
+ "source": [
+ "## La visión global"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "V1bng3hWOdXa"
+ },
+ "source": [
+ "A la hora de entender un problema de ML en su conjunto, estas son algunas de las preguntas que debes hacerte:\n",
+ "\n",
+ "- ¿Cuáles son los objetivos de negocio?\n",
+ "- ¿Cómo será usada mi solución? (offline, API, aplicación, ...)\n",
+ "- ¿Existen soluciones similares o que se puedan usar para alcanzar los objetivos?\n",
+ "- ¿Cómo debería aproximar el problema? (aprendizaje supervisado/no supervisado, ...)\n",
+ "- ¿Cómo mediré la *performance*? (datos de test, métricas, ...)\n",
+ "- ¿Las métricas están alineadas con los objetivos de negocio?\n",
+ "- ¿Cuál es el valor mínimo de *performance* aceptable para alcanzar los objetivos de negocio?\n",
+ "- ¿Existe la experiencia para llevar a cabo el proyecto? (equipo interno, contratación externa, ...)\n",
+ "- ¿Cómo se podría resolver el problema de forma manual? (no automatizada, no ML)\n",
+ "- ¿Cuáles son las hipótesis hechas hasta ahora?\n",
+ "\n",
+ "Si eres capaz de responder a estas preguntas, serás capaz de enfocar el problema de manera mucho más eficiente y proveer mejores resultados.\n",
+ "\n",
+ "El ejemplo que vamos a desarrollar en este post consistirá en entrenar un modelo de ML para la predicción de precios de casas. Respondiendo a varias de las preguntas anteriores, el objetivo será el de desarrollar un sistema de ayuda a la decisión para inversión inmobiliaria. La solución será usada a través de API y aplicación web. Usaremos un dataset público con el que resolveremos una tarea de regresión de manera supervisada. La métrica usada será el error medico cuadrático evaluado en un conjunto de datos de test extraídos del dataset original. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "rxVxEHQaOdXb"
+ },
+ "source": [
+ "## Obtén los datos"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "XqUdu0cCOdXb"
+ },
+ "source": [
+ "Estos son los puntos esenciales a la hora de obtener los datos:\n",
+ "\n",
+ "- Lista los datos disponibles y estima cuántos serán necesarios.\n",
+ "- Documenta cómo y dónde encontrar los datos.\n",
+ "- Comprueba cuánto espacio ocuparán los datos.\n",
+ "- Comprueba si existen limitaciones en el uso de los datos, obteniendo autorización si es necesario.\n",
+ "- Crea tu espacio de trabajo con suficiente espacio para almacenar los datos (ya sea en local o en la nube).\n",
+ "- Obtén los datos.\n",
+ "- Convierte los datos a un formato en el que puedas manipularlos fácilmente (sin cambiar los datos en sí, obviamente).\n",
+ "- Asegúrate de que cualquier información sensible es eliminada o protegida.\n",
+ "- Comprueba el tipo de los datos (series temporales, datos geográficos, ...)\n",
+ "- Genera tus datos de test, guárdalos y NUNCA los uses ni los mires.\n",
+ "\n",
+ "Como nota, intenta automatizar el máximo número de puntos en el proceso para obtener nuevos datos de manera regular si es posible.\n",
+ "\n",
+ "En nuestro ejemplo, vamos a descargar los datos de un repositorio público. El dataset es abierto para uso libre, por lo que no tenemos que preocuparnos por mucho más."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "huDkp9bBOdXc"
+ },
+ "outputs": [],
+ "source": [
+ "import requests\n",
+ "import tarfile\n",
+ "\n",
+ "URL = \"https://mymldatasets.s3.eu-de.cloud-object-storage.appdomain.cloud/housing.tgz\"\n",
+ "PATH = \"housing.tgz\"\n",
+ "\n",
+ "def getData(url=URL, path=PATH):\n",
+ " r = requests.get(url)\n",
+ " with open(path, 'wb') as f:\n",
+ " f.write(r.content) \n",
+ " housing_tgz = tarfile.open(path)\n",
+ " housing_tgz.extractall()\n",
+ " housing_tgz.close()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "oYbsaid2OdXc"
+ },
+ "outputs": [],
+ "source": [
+ "getData()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "iQ7GwUjzOdXd"
+ },
+ "outputs": [],
+ "source": [
+ "import pandas as pd\n",
+ "\n",
+ "PATH = \"housing.csv\"\n",
+ "\n",
+ "def loadData(path=PATH):\n",
+ " return pd.read_csv(path)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "j-niS-IwOdXd",
+ "outputId": "a0018259-1b9f-43da-99ec-530d63ebb1f3"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "| \n", + " | longitude | \n", + "latitude | \n", + "housing_median_age | \n", + "total_rooms | \n", + "total_bedrooms | \n", + "population | \n", + "households | \n", + "median_income | \n", + "median_house_value | \n", + "ocean_proximity | \n", + "
|---|---|---|---|---|---|---|---|---|---|---|
| 8034 | \n", + "-118.13 | \n", + "33.84 | \n", + "48.0 | \n", + "1895.0 | \n", + "294.0 | \n", + "881.0 | \n", + "293.0 | \n", + "6.3364 | \n", + "307400.0 | \n", + "<1H OCEAN | \n", + "
| 16260 | \n", + "-121.25 | \n", + "37.97 | \n", + "41.0 | \n", + "855.0 | \n", + "189.0 | \n", + "716.0 | \n", + "206.0 | \n", + "2.0375 | \n", + "75000.0 | \n", + "INLAND | \n", + "
| 17188 | \n", + "-122.33 | \n", + "37.39 | \n", + "52.0 | \n", + "573.0 | \n", + "102.0 | \n", + "232.0 | \n", + "92.0 | \n", + "6.2263 | \n", + "500001.0 | \n", + "NEAR OCEAN | \n", + "
| 12864 | \n", + "-121.34 | \n", + "38.69 | \n", + "16.0 | \n", + "2686.0 | \n", + "516.0 | \n", + "1553.0 | \n", + "529.0 | \n", + "3.7857 | \n", + "112700.0 | \n", + "INLAND | \n", + "
| 468 | \n", + "-122.29 | \n", + "37.87 | \n", + "44.0 | \n", + "2539.0 | \n", + "755.0 | \n", + "1382.0 | \n", + "713.0 | \n", + "2.5370 | \n", + "175000.0 | \n", + "NEAR BAY | \n", + "
| 20199 | \n", + "-119.18 | \n", + "34.26 | \n", + "22.0 | \n", + "2334.0 | \n", + "359.0 | \n", + "1298.0 | \n", + "363.0 | \n", + "5.5275 | \n", + "228900.0 | \n", + "NEAR OCEAN | \n", + "
| 10422 | \n", + "-117.60 | \n", + "33.41 | \n", + "29.0 | \n", + "2193.0 | \n", + "389.0 | \n", + "922.0 | \n", + "387.0 | \n", + "4.5476 | \n", + "309200.0 | \n", + "NEAR OCEAN | \n", + "
| 7772 | \n", + "-118.10 | \n", + "33.91 | \n", + "35.0 | \n", + "1592.0 | \n", + "335.0 | \n", + "1238.0 | \n", + "320.0 | \n", + "4.9732 | \n", + "165000.0 | \n", + "<1H OCEAN | \n", + "
| 17689 | \n", + "-121.84 | \n", + "37.28 | \n", + "18.0 | \n", + "2749.0 | \n", + "633.0 | \n", + "1779.0 | \n", + "561.0 | \n", + "3.9250 | \n", + "166100.0 | \n", + "<1H OCEAN | \n", + "
| 15232 | \n", + "-117.21 | \n", + "33.02 | \n", + "26.0 | \n", + "3194.0 | \n", + "454.0 | \n", + "1032.0 | \n", + "406.0 | \n", + "10.1560 | \n", + "500001.0 | \n", + "NEAR OCEAN | \n", + "
| \n", + " | longitude | \n", + "latitude | \n", + "housing_median_age | \n", + "total_rooms | \n", + "total_bedrooms | \n", + "population | \n", + "households | \n", + "median_income | \n", + "median_house_value | \n", + "
|---|---|---|---|---|---|---|---|---|---|
| count | \n", + "20640.000000 | \n", + "20640.000000 | \n", + "20640.000000 | \n", + "20640.000000 | \n", + "20433.000000 | \n", + "20640.000000 | \n", + "20640.000000 | \n", + "20640.000000 | \n", + "20640.000000 | \n", + "
| mean | \n", + "-119.569704 | \n", + "35.631861 | \n", + "28.639486 | \n", + "2635.763081 | \n", + "537.870553 | \n", + "1425.476744 | \n", + "499.539680 | \n", + "3.870671 | \n", + "206855.816909 | \n", + "
| std | \n", + "2.003532 | \n", + "2.135952 | \n", + "12.585558 | \n", + "2181.615252 | \n", + "421.385070 | \n", + "1132.462122 | \n", + "382.329753 | \n", + "1.899822 | \n", + "115395.615874 | \n", + "
| min | \n", + "-124.350000 | \n", + "32.540000 | \n", + "1.000000 | \n", + "2.000000 | \n", + "1.000000 | \n", + "3.000000 | \n", + "1.000000 | \n", + "0.499900 | \n", + "14999.000000 | \n", + "
| 25% | \n", + "-121.800000 | \n", + "33.930000 | \n", + "18.000000 | \n", + "1447.750000 | \n", + "296.000000 | \n", + "787.000000 | \n", + "280.000000 | \n", + "2.563400 | \n", + "119600.000000 | \n", + "
| 50% | \n", + "-118.490000 | \n", + "34.260000 | \n", + "29.000000 | \n", + "2127.000000 | \n", + "435.000000 | \n", + "1166.000000 | \n", + "409.000000 | \n", + "3.534800 | \n", + "179700.000000 | \n", + "
| 75% | \n", + "-118.010000 | \n", + "37.710000 | \n", + "37.000000 | \n", + "3148.000000 | \n", + "647.000000 | \n", + "1725.000000 | \n", + "605.000000 | \n", + "4.743250 | \n", + "264725.000000 | \n", + "
| max | \n", + "-114.310000 | \n", + "41.950000 | \n", + "52.000000 | \n", + "39320.000000 | \n", + "6445.000000 | \n", + "35682.000000 | \n", + "6082.000000 | \n", + "15.000100 | \n", + "500001.000000 | \n", + "
| \n", + " | longitude | \n", + "latitude | \n", + "housing_median_age | \n", + "total_rooms | \n", + "total_bedrooms | \n", + "population | \n", + "households | \n", + "median_income | \n", + "ocean_proximity | \n", + "
|---|---|---|---|---|---|---|---|---|---|
| 0 | \n", + "-119.72 | \n", + "36.76 | \n", + "23.0 | \n", + "6403.0 | \n", + "NaN | \n", + "3573.0 | \n", + "1260.0 | \n", + "2.3006 | \n", + "INLAND | \n", + "
| 1 | \n", + "-120.79 | \n", + "38.70 | \n", + "13.0 | \n", + "5036.0 | \n", + "1034.0 | \n", + "2243.0 | \n", + "923.0 | \n", + "2.3319 | \n", + "INLAND | \n", + "
| 2 | \n", + "-118.20 | \n", + "34.04 | \n", + "18.0 | \n", + "796.0 | \n", + "227.0 | \n", + "547.0 | \n", + "218.0 | \n", + "1.0333 | \n", + "<1H OCEAN | \n", + "
| 3 | \n", + "-117.34 | \n", + "33.21 | \n", + "12.0 | \n", + "5963.0 | \n", + "1372.0 | \n", + "3015.0 | \n", + "1124.0 | \n", + "2.7386 | \n", + "NEAR OCEAN | \n", + "
| 4 | \n", + "-121.46 | \n", + "38.54 | \n", + "48.0 | \n", + "1001.0 | \n", + "205.0 | \n", + "605.0 | \n", + "175.0 | \n", + "1.8333 | \n", + "INLAND | \n", + "
| \n", + " | longitude | \n", + "latitude | \n", + "housing_median_age | \n", + "total_rooms | \n", + "total_bedrooms | \n", + "population | \n", + "households | \n", + "median_income | \n", + "
|---|---|---|---|---|---|---|---|---|
| 0 | \n", + "-119.72 | \n", + "36.76 | \n", + "23.0 | \n", + "6403.0 | \n", + "NaN | \n", + "3573.0 | \n", + "1260.0 | \n", + "2.3006 | \n", + "
| 1 | \n", + "-120.79 | \n", + "38.70 | \n", + "13.0 | \n", + "5036.0 | \n", + "1034.0 | \n", + "2243.0 | \n", + "923.0 | \n", + "2.3319 | \n", + "
| 2 | \n", + "-118.20 | \n", + "34.04 | \n", + "18.0 | \n", + "796.0 | \n", + "227.0 | \n", + "547.0 | \n", + "218.0 | \n", + "1.0333 | \n", + "
| 3 | \n", + "-117.34 | \n", + "33.21 | \n", + "12.0 | \n", + "5963.0 | \n", + "1372.0 | \n", + "3015.0 | \n", + "1124.0 | \n", + "2.7386 | \n", + "
| 4 | \n", + "-121.46 | \n", + "38.54 | \n", + "48.0 | \n", + "1001.0 | \n", + "205.0 | \n", + "605.0 | \n", + "175.0 | \n", + "1.8333 | \n", + "
| \n", + " | ocean_proximity | \n", + "
|---|---|
| 0 | \n", + "INLAND | \n", + "
| 1 | \n", + "INLAND | \n", + "
| 2 | \n", + "<1H OCEAN | \n", + "
| 3 | \n", + "NEAR OCEAN | \n", + "
| 4 | \n", + "INLAND | \n", + "
| \n", + " | longitude | \n", + "latitude | \n", + "housing_median_age | \n", + "total_rooms | \n", + "total_bedrooms | \n", + "population | \n", + "households | \n", + "median_income | \n", + "
|---|---|---|---|---|---|---|---|---|
| count | \n", + "1.651200e+04 | \n", + "1.651200e+04 | \n", + "1.651200e+04 | \n", + "1.651200e+04 | \n", + "1.634900e+04 | \n", + "1.651200e+04 | \n", + "1.651200e+04 | \n", + "1.651200e+04 | \n", + "
| mean | \n", + "7.623236e-16 | \n", + "6.937751e-16 | \n", + "6.444699e-17 | \n", + "3.953556e-18 | \n", + "-1.147640e-18 | \n", + "4.551632e-17 | \n", + "7.061938e-17 | \n", + "1.282216e-17 | \n", + "
| std | \n", + "1.000030e+00 | \n", + "1.000030e+00 | \n", + "1.000030e+00 | \n", + "1.000030e+00 | \n", + "1.000031e+00 | \n", + "1.000030e+00 | \n", + "1.000030e+00 | \n", + "1.000030e+00 | \n", + "
| min | \n", + "-2.381604e+00 | \n", + "-1.445235e+00 | \n", + "-2.201136e+00 | \n", + "-1.214416e+00 | \n", + "-1.278351e+00 | \n", + "-1.256377e+00 | \n", + "-1.310671e+00 | \n", + "-1.764526e+00 | \n", + "
| 25% | \n", + "-1.105456e+00 | \n", + "-7.998537e-01 | \n", + "-8.491991e-01 | \n", + "-5.457575e-01 | \n", + "-5.776820e-01 | \n", + "-5.636872e-01 | \n", + "-5.758077e-01 | \n", + "-6.848289e-01 | \n", + "
| 50% | \n", + "5.324548e-01 | \n", + "-6.455233e-01 | \n", + "2.558386e-02 | \n", + "-2.329159e-01 | \n", + "-2.440301e-01 | \n", + "-2.270859e-01 | \n", + "-2.333984e-01 | \n", + "-1.765975e-01 | \n", + "
| 75% | \n", + "7.819462e-01 | \n", + "9.679302e-01 | \n", + "6.617896e-01 | \n", + "2.338048e-01 | \n", + "2.564478e-01 | \n", + "2.609859e-01 | \n", + "2.723138e-01 | \n", + "4.571083e-01 | \n", + "
| max | \n", + "2.628182e+00 | \n", + "2.950841e+00 | \n", + "1.854675e+00 | \n", + "1.631534e+01 | \n", + "1.407917e+01 | \n", + "3.034782e+01 | \n", + "1.470618e+01 | \n", + "5.825810e+00 | \n", + "
LinearRegression()In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
LinearRegression()
DecisionTreeRegressor(random_state=42)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
DecisionTreeRegressor(random_state=42)
GridSearchCV(cv=5, estimator=RandomForestRegressor(random_state=42), n_jobs=-1,\n",
+ " param_grid=[{'max_features': [2, 4, 6, 8],\n",
+ " 'n_estimators': [3, 10, 30]},\n",
+ " {'bootstrap': [False], 'max_features': [2, 3, 4],\n",
+ " 'n_estimators': [3, 10]}],\n",
+ " return_train_score=True, scoring='neg_mean_squared_error')In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. GridSearchCV(cv=5, estimator=RandomForestRegressor(random_state=42), n_jobs=-1,\n",
+ " param_grid=[{'max_features': [2, 4, 6, 8],\n",
+ " 'n_estimators': [3, 10, 30]},\n",
+ " {'bootstrap': [False], 'max_features': [2, 3, 4],\n",
+ " 'n_estimators': [3, 10]}],\n",
+ " return_train_score=True, scoring='neg_mean_squared_error')RandomForestRegressor(random_state=42)
RandomForestRegressor(random_state=42)
RandomForestRegressor(max_features=8, n_estimators=30, random_state=42)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
RandomForestRegressor(max_features=8, n_estimators=30, random_state=42)
| \n", + " | longitude | \n", + "latitude | \n", + "housing_median_age | \n", + "total_rooms | \n", + "total_bedrooms | \n", + "population | \n", + "households | \n", + "median_income | \n", + "median_house_value | \n", + "ocean_proximity | \n", + "
|---|---|---|---|---|---|---|---|---|---|---|
| 2785 | \n", + "-121.73 | \n", + "36.93 | \n", + "29.0 | \n", + "2931.0 | \n", + "535.0 | \n", + "1954.0 | \n", + "506.0 | \n", + "3.2917 | \n", + "224700.0 | \n", + "<1H OCEAN | \n", + "
| 3619 | \n", + "-117.33 | \n", + "33.87 | \n", + "14.0 | \n", + "2300.0 | \n", + "335.0 | \n", + "1001.0 | \n", + "311.0 | \n", + "5.1045 | \n", + "161300.0 | \n", + "INLAND | \n", + "
| 1243 | \n", + "-122.31 | \n", + "38.01 | \n", + "18.0 | \n", + "4123.0 | \n", + "874.0 | \n", + "1895.0 | \n", + "772.0 | \n", + "3.2759 | \n", + "195000.0 | \n", + "NEAR BAY | \n", + "
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "7qclsB-sxngt"
+ },
+ "source": [
+ "# Introducción al *Machine Learning*\n",
+ "## [M.Sc. Ruben Quispe](https://www.linkedin.com/in/ruben-quispe-l/)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "HlajFHqIxngt"
+ },
+ "source": [
+ "En esta clase arrancamos una nueva serie en la que hablaremos sobre *Machine Learning* (ML). *Deep Learning* (DL) o aprendizaje profundo. Existen matices y diferencias entre ambos, de las cuales hablaremos en este CLASE. La principal: los algoritmos. Si bien el DL gira entorno al uso de redes neuronales (profundas), el ML engloba muchísimos más algoritmos utilizados durante décadas. Este serie va sobre esos algoritmos y todo lo que podemos hacer con ellos. ¡No toda la Inteligencia Artificial (IA) se basa en redes neuronales!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "colHVB01xngt"
+ },
+ "source": [
+ "## IA vs ML vs DL"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "iUz0vedvxngu"
+ },
+ "source": [
+ "Definir la IA no es tarea fácil. Aquí algunos ejemplos.\n",
+ "\n",
+ "> [La Inteligencia Artificial es el] ámbito de estudio que confiere a los ordenadores la capacidad de aprender sin ser programados explícitamente (Arthur Samuel, 1959).\n",
+ "\n",
+ "\n",
+ "> Un programa aprende de la experiencia E con respecto a la tarea T y medida de éxito P si su desempeño en T, medido por P, mejora con la experiencia E (Tom Michell, 1997).\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "VOioyQKqxngu"
+ },
+ "source": [
+ "La IA es un campo de la ciencia cuyo origen precedo incluso a la invención de los ordenadores. Desde entonces, multitud de técnicas y algoritmos han sido desarrollados, desde el Perceptrón hasta las redes neuronales de hoy en día. \n",
+ "\n",
+ "\n",
+ "\n",
+ "Dentro de la IA encontramos una familia de algoritmos conocida como *Machine Learning*. Estos algoritmos se caracterizan por ser capaces de aprender a llevar a cabo una tarea específica a partir de ejemplos. Dentro de este grupo encontramos una subcategoría de algoritmos conocida como *Deep Learning*, que no solo es capaz de aprender a partir de datos sino que además es capaz de hacerlo con mínima intervención humana (*feature engineering*).\n",
+ "\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "9vZeGlE0xngu"
+ },
+ "source": [
+ "## ¿Qué es el ML?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "cG4qbLTbxngu"
+ },
+ "source": [
+ "El uso del ML es de especial utilidad en aquellas tareas en las que la programación \"tradicional\" (o software 1.0) falla, principalmente debido a la imposibilidad de desarrollar una serie de instrucciones capaz de resolver el problema. También es recomendable su uso en entornos cambiantes o a la hora de extraer información de grandes cantidades de datos. \n",
+ "\n",
+ "\n",
+ "\n",
+ "Esto es debido a que, mientras que en el \"software 1.0\" el programador debe crear un programa (serie de instrucciones) para llevar a cabo una tarea, en el \"software 2.0\" (otro término atribuido al ML) será el mismo algoritmo el que aprenderá por sí mismo a resolver un problema a base de ejemplos. \n",
+ "\n",
+ "| | Programación tradicional | ML | \n",
+ "|---|---|---|\n",
+ "| Programa | Código escrito por el programador en un lenguaje | Los datos | \n",
+ "| Compilación | Traducción del programa a código máquina | El modelo (y receta de entrenamiento) | \n",
+ "| Binario | Ejecutable que el ordenador entiende | Modelo entrando | "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "yLnO4ecpxngv"
+ },
+ "source": [
+ "## Tipos de ML"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "dF5IIHQfxngv"
+ },
+ "source": [
+ "Podemos clasificar los diferentes algoritmos de ML en función de:\n",
+ "\n",
+ "1. El proceso de entrenamiento: supervisado, no supervisado (o semi-supervisado) y aprendizaje por refuerzo.\n",
+ "2. Su forma de aprender: en modo *batch* o *online*. \n",
+ "3. Su funcionamiento: basado en modelos o instancias."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "F2yav9Czxngv"
+ },
+ "source": [
+ "## Tareas de ML"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "7CuFnuCyxngv"
+ },
+ "source": [
+ "Las principales tareas que podemos llevar a cabo con ML son: clasificación, regresión y *clustering*. Para cada tarea, numerosos algoritmos (que iremos aprendiendo en esta serie) existen.\n",
+ "\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "3mVoZjNzxngw"
+ },
+ "source": [
+ "## Los datos"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "JOVE9b_ixngw"
+ },
+ "source": [
+ "El ML gira entorno a los datos. Como hemos visto anteriormente son la parte fundamental y dos conjuntos de datos distintos nos darán resultados muy diferentes aunque usemos el mismo modelo y receta de entrenamiento. Así pues, un buen entendimiento de los datos y cómo trabajar con ellos es crucial para tener éxito en aplicaciones de ML. De entre todas las cuestiones que hay que tener en cuenta, la separación de datos en conjuntos de entrenamiento, validación y test es quizás la más importante.\n",
+ "\n",
+ "\n",
+ "\n",
+ "Así pues usaremos el conjunto de entrenamiento para entrenar nuestros modelos, el de validación para optimizar los hiperparámetros y el de test para generar las métricas finales. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "8ZSvJ2dexngw"
+ },
+ "source": [
+ "## Principales problemas del ML"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Ev-zBBeixngw"
+ },
+ "source": [
+ "El desarrollo de aplicaciones de ML no es fácil, y es que existen multitud de problemas a los que nos podemos enfrentar. Algunos ejemplos son: \n",
+ "\n",
+ "- Cantidad insuficiente de datos\n",
+ "- Datos no representativos\n",
+ "- Datos de baja calidad\n",
+ "- Características en los datos irrelevantes\n",
+ "- *Overfitting* (SOBREAJUSTE el modelo es exato E=0) o *underfitting* (Desajuste,malo modelo E=1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "H-QavltQxngw"
+ },
+ "source": [
+ "## Ejemplo"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "tc0j99zexngw"
+ },
+ "source": [
+ "Vamos a cerrar esta breve introducción al ML con un sencillo ejemplo. Imaginemos que queremos descubrir si el dinero hace feliz a la gente. Para ello, nos descargamos un archivo con una lista de varios países, acompañada de sus PIB medio y un índice de satisfacción ciudadana."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2022-01-15T12:26:17.185924Z",
+ "start_time": "2022-01-15T12:26:16.081815Z"
+ },
+ "id": "tyk8uqGixngw",
+ "outputId": "9d0db8a6-1aaa-40fe-df91-d83e7c4a4fa6"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "zsh:1: command not found: wget\r\n"
+ ]
+ }
+ ],
+ "source": [
+ "# download data\n",
+ "\n",
+ "!wget https://mymldatasets.s3.eu-de.cloud-object-storage.appdomain.cloud/country_stats.csv"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "unVOw-_nmEzL",
+ "outputId": "4b47d981-e5b2-462d-9673-518c96832a71"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "zsh:1: command not found: brew\r\n"
+ ]
+ }
+ ],
+ "source": [
+ "!brew install wget"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2022-01-15T12:26:17.375054Z",
+ "start_time": "2022-01-15T12:26:17.189909Z"
+ },
+ "id": "Kjk4cnj-xngx",
+ "outputId": "28105b3b-4575-4dea-f4d4-9eea8c09e5d3"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "| \n", + " | GDP per capita | \n", + "Life satisfaction | \n", + "
|---|---|---|
| Country | \n", + "\n", + " | \n", + " |
| Russia | \n", + "9054.914 | \n", + "6.0 | \n", + "
| Turkey | \n", + "9437.372 | \n", + "5.6 | \n", + "
| Hungary | \n", + "12239.894 | \n", + "4.9 | \n", + "
| Poland | \n", + "12495.334 | \n", + "5.8 | \n", + "
| Slovak Republic | \n", + "15991.736 | \n", + "6.1 | \n", + "
| Estonia | \n", + "17288.083 | \n", + "5.6 | \n", + "
| Greece | \n", + "18064.288 | \n", + "4.8 | \n", + "
| Portugal | \n", + "19121.592 | \n", + "5.1 | \n", + "
| Slovenia | \n", + "20732.482 | \n", + "5.7 | \n", + "
| Spain | \n", + "25864.721 | \n", + "6.5 | \n", + "
| Korea | \n", + "27195.197 | \n", + "5.8 | \n", + "
| Italy | \n", + "29866.581 | \n", + "6.0 | \n", + "
| Japan | \n", + "32485.545 | \n", + "5.9 | \n", + "
| Israel | \n", + "35343.336 | \n", + "7.4 | \n", + "
| New Zealand | \n", + "37044.891 | \n", + "7.3 | \n", + "
| France | \n", + "37675.006 | \n", + "6.5 | \n", + "
| Belgium | \n", + "40106.632 | \n", + "6.9 | \n", + "
| Germany | \n", + "40996.511 | \n", + "7.0 | \n", + "
| Finland | \n", + "41973.988 | \n", + "7.4 | \n", + "
| Canada | \n", + "43331.961 | \n", + "7.3 | \n", + "
| Netherlands | \n", + "43603.115 | \n", + "7.3 | \n", + "
| Austria | \n", + "43724.031 | \n", + "6.9 | \n", + "
| United Kingdom | \n", + "43770.688 | \n", + "6.8 | \n", + "
| Sweden | \n", + "49866.266 | \n", + "7.2 | \n", + "
| Iceland | \n", + "50854.583 | \n", + "7.5 | \n", + "
| Australia | \n", + "50961.865 | \n", + "7.3 | \n", + "
| Ireland | \n", + "51350.744 | \n", + "7.0 | \n", + "
| Denmark | \n", + "52114.165 | \n", + "7.5 | \n", + "
| United States | \n", + "55805.204 | \n", + "7.2 | \n", + "
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "2NSBMT9OyYjg"
+ },
+ "source": [
+ "# Librerías de Python para ML\n",
+ "## [M.Sc. Ruben Quispe](https://www.linkedin.com/in/ruben-quispe-l/)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "9obUrehfyYjg"
+ },
+ "source": [
+ "En la clase anterior arrancamos con la serie sobre `Machine Learning`, en la que veremos múltiples algoritmos desarrollados durante las últimas décadas y que podemos usar como alternativa a las `redes neuronales` (*deep learning*), en algunos casos obteniendo mejores resultados (sobretodo en aquellos casos en los que no dispongamos de un dataset grande). Sin embargo, antes de entrar con los algoritmos y aplicaciones, vamos a hablar sobre el ecosistema de librerías existentes en `Python` para el `Machine Learning`, haciendo hincapié en aquellas más usadas por la comunidad y que también utilizaremos en esta serie.\n",
+ "\n",
+ "\n",
+ "\n",
+ "En la imagen anterior puedes ver un resumen de las herramientas más usadas a día de hoy para `Machine Learning` con `Python`. Las herramientas rodeadas por un círculo rojo son las que usaremos en esta serie, en verde son herramientas para `deep learning` que no usaremos (pero hemos usado en otros posts). Las herramientas sin círculo no las usaremos, pero vale la pena conocerlas ya que pueden serte útiles para algunas aplicaciones. \n",
+ "\n",
+ "En la base podemos encontrar `Python`, el lenguaje de programación base que todas las herramientas utilizan. Por encima encontramos herramientas como `Numpy`, para cálculo numérico, o `Jupyter`, para ejecutar nuestro código en `notebooks`. Por encima vemos herramientas basadas en `Numpy` como `Pandas`, para trabajar con datos tabulares, y `Matplotlib`, para generar gráficos en `Python`. Finalmente, en la última capa, encontramos `Scikit-Learn`, una de las librerías más utilizadas hoy en día para entrenar modelos de `Machine Learning`.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "y3qkNGJ3yYjg"
+ },
+ "source": [
+ "## Scikit-Learn"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "AY4Vv3qFyYjg"
+ },
+ "source": [
+ "El resto de este post lo vamos a dedicar a introducir los conceptos más importantes de [Scikit-Learn](https://scikit-learn.org/stable/), y que desarrollaremos durante la serie. Puedes empezar por instalar la librería\n",
+ "\n",
+ "```\n",
+ "pip install scikit-learn\n",
+ "```\n",
+ "\n",
+ "Y seguir echando un vistazo a la [documentación](https://scikit-learn.org/stable/getting_started.html) y [ejemplos](https://scikit-learn.org/stable/auto_examples/index.html). \n",
+ "\n",
+ "En cualquier proyecto de `Machine Learning` deberemos seguir una serie de pasos, los cuales describiremos al final de la serie. En lo referente al entrenamiento de modelos, normalmente encontramos tres pasos:\n",
+ "\n",
+ "1. Preparar los datos\n",
+ "2. Entrenar modelos\n",
+ "3. Optimizar hyperparámetros\n",
+ "\n",
+ "Existen otros pasos igual o más de importantes, pero (repito) los veremos más adelante ya que no involucran el uso de `Scikit-Learn`."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "oU_lF4flyYjh"
+ },
+ "source": [
+ "## Preparando los datos"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "_ilG9ZthyYjh"
+ },
+ "source": [
+ "Para este ejemplo vamos a utilizar un dataset para predicción de precios de casas. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2022-01-29T13:07:05.956876Z",
+ "start_time": "2022-01-29T13:07:05.907976Z"
+ },
+ "id": "QQn-4aToyYjh"
+ },
+ "outputs": [],
+ "source": [
+ "import requests\n",
+ "import tarfile\n",
+ "\n",
+ "URL = \"https://mymldatasets.s3.eu-de.cloud-object-storage.appdomain.cloud/housing.tgz\"\n",
+ "PATH = \"housing.tgz\"\n",
+ "\n",
+ "def getData(url=URL, path=PATH):\n",
+ " r = requests.get(url)\n",
+ " with open(path, 'wb') as f:\n",
+ " f.write(r.content) \n",
+ " housing_tgz = tarfile.open(path)\n",
+ " housing_tgz.extractall()\n",
+ " housing_tgz.close()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2022-01-29T13:07:07.939085Z",
+ "start_time": "2022-01-29T13:07:06.437292Z"
+ },
+ "id": "IO4JbS4dyYji"
+ },
+ "outputs": [],
+ "source": [
+ "getData()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2022-01-29T13:07:08.152252Z",
+ "start_time": "2022-01-29T13:07:07.941415Z"
+ },
+ "id": "Ed-bqV7ayYji",
+ "outputId": "8d020a30-017a-4387-8e74-b4cb6ec86cfa"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "| \n", + " | longitude | \n", + "latitude | \n", + "housing_median_age | \n", + "total_rooms | \n", + "total_bedrooms | \n", + "population | \n", + "households | \n", + "median_income | \n", + "median_house_value | \n", + "ocean_proximity | \n", + "
|---|---|---|---|---|---|---|---|---|---|---|
| 0 | \n", + "-122.23 | \n", + "37.88 | \n", + "41.0 | \n", + "880.0 | \n", + "129.0 | \n", + "322.0 | \n", + "126.0 | \n", + "8.3252 | \n", + "452600.0 | \n", + "NEAR BAY | \n", + "
| 1 | \n", + "-122.22 | \n", + "37.86 | \n", + "21.0 | \n", + "7099.0 | \n", + "1106.0 | \n", + "2401.0 | \n", + "1138.0 | \n", + "8.3014 | \n", + "358500.0 | \n", + "NEAR BAY | \n", + "
| 2 | \n", + "-122.24 | \n", + "37.85 | \n", + "52.0 | \n", + "1467.0 | \n", + "190.0 | \n", + "496.0 | \n", + "177.0 | \n", + "7.2574 | \n", + "352100.0 | \n", + "NEAR BAY | \n", + "
| 3 | \n", + "-122.25 | \n", + "37.85 | \n", + "52.0 | \n", + "1274.0 | \n", + "235.0 | \n", + "558.0 | \n", + "219.0 | \n", + "5.6431 | \n", + "341300.0 | \n", + "NEAR BAY | \n", + "
| 4 | \n", + "-122.25 | \n", + "37.85 | \n", + "52.0 | \n", + "1627.0 | \n", + "280.0 | \n", + "565.0 | \n", + "259.0 | \n", + "3.8462 | \n", + "342200.0 | \n", + "NEAR BAY | \n", + "
| \n", + " | longitude | \n", + "latitude | \n", + "housing_median_age | \n", + "total_rooms | \n", + "total_bedrooms | \n", + "population | \n", + "households | \n", + "median_income | \n", + "median_house_value | \n", + "
|---|---|---|---|---|---|---|---|---|---|
| count | \n", + "20640.000000 | \n", + "20640.000000 | \n", + "20640.000000 | \n", + "20640.000000 | \n", + "20433.000000 | \n", + "20640.000000 | \n", + "20640.000000 | \n", + "20640.000000 | \n", + "20640.000000 | \n", + "
| mean | \n", + "-119.569704 | \n", + "35.631861 | \n", + "28.639486 | \n", + "2635.763081 | \n", + "537.870553 | \n", + "1425.476744 | \n", + "499.539680 | \n", + "3.870671 | \n", + "206855.816909 | \n", + "
| std | \n", + "2.003532 | \n", + "2.135952 | \n", + "12.585558 | \n", + "2181.615252 | \n", + "421.385070 | \n", + "1132.462122 | \n", + "382.329753 | \n", + "1.899822 | \n", + "115395.615874 | \n", + "
| min | \n", + "-124.350000 | \n", + "32.540000 | \n", + "1.000000 | \n", + "2.000000 | \n", + "1.000000 | \n", + "3.000000 | \n", + "1.000000 | \n", + "0.499900 | \n", + "14999.000000 | \n", + "
| 25% | \n", + "-121.800000 | \n", + "33.930000 | \n", + "18.000000 | \n", + "1447.750000 | \n", + "296.000000 | \n", + "787.000000 | \n", + "280.000000 | \n", + "2.563400 | \n", + "119600.000000 | \n", + "
| 50% | \n", + "-118.490000 | \n", + "34.260000 | \n", + "29.000000 | \n", + "2127.000000 | \n", + "435.000000 | \n", + "1166.000000 | \n", + "409.000000 | \n", + "3.534800 | \n", + "179700.000000 | \n", + "
| 75% | \n", + "-118.010000 | \n", + "37.710000 | \n", + "37.000000 | \n", + "3148.000000 | \n", + "647.000000 | \n", + "1725.000000 | \n", + "605.000000 | \n", + "4.743250 | \n", + "264725.000000 | \n", + "
| max | \n", + "-114.310000 | \n", + "41.950000 | \n", + "52.000000 | \n", + "39320.000000 | \n", + "6445.000000 | \n", + "35682.000000 | \n", + "6082.000000 | \n", + "15.000100 | \n", + "500001.000000 | \n", + "
| \n", + " | longitude | \n", + "latitude | \n", + "housing_median_age | \n", + "total_rooms | \n", + "total_bedrooms | \n", + "population | \n", + "households | \n", + "median_income | \n", + "median_house_value | \n", + "ocean_proximity | \n", + "
|---|---|---|---|---|---|---|---|---|---|---|
| count | \n", + "20640.000000 | \n", + "20640.000000 | \n", + "20640.000000 | \n", + "20640.000000 | \n", + "20433.000000 | \n", + "20640.000000 | \n", + "20640.000000 | \n", + "20640.000000 | \n", + "20640.000000 | \n", + "20640 | \n", + "
| unique | \n", + "NaN | \n", + "NaN | \n", + "NaN | \n", + "NaN | \n", + "NaN | \n", + "NaN | \n", + "NaN | \n", + "NaN | \n", + "NaN | \n", + "5 | \n", + "
| top | \n", + "NaN | \n", + "NaN | \n", + "NaN | \n", + "NaN | \n", + "NaN | \n", + "NaN | \n", + "NaN | \n", + "NaN | \n", + "NaN | \n", + "<1H OCEAN | \n", + "
| freq | \n", + "NaN | \n", + "NaN | \n", + "NaN | \n", + "NaN | \n", + "NaN | \n", + "NaN | \n", + "NaN | \n", + "NaN | \n", + "NaN | \n", + "9136 | \n", + "
| mean | \n", + "-119.569704 | \n", + "35.631861 | \n", + "28.639486 | \n", + "2635.763081 | \n", + "537.870553 | \n", + "1425.476744 | \n", + "499.539680 | \n", + "3.870671 | \n", + "206855.816909 | \n", + "NaN | \n", + "
| std | \n", + "2.003532 | \n", + "2.135952 | \n", + "12.585558 | \n", + "2181.615252 | \n", + "421.385070 | \n", + "1132.462122 | \n", + "382.329753 | \n", + "1.899822 | \n", + "115395.615874 | \n", + "NaN | \n", + "
| min | \n", + "-124.350000 | \n", + "32.540000 | \n", + "1.000000 | \n", + "2.000000 | \n", + "1.000000 | \n", + "3.000000 | \n", + "1.000000 | \n", + "0.499900 | \n", + "14999.000000 | \n", + "NaN | \n", + "
| 25% | \n", + "-121.800000 | \n", + "33.930000 | \n", + "18.000000 | \n", + "1447.750000 | \n", + "296.000000 | \n", + "787.000000 | \n", + "280.000000 | \n", + "2.563400 | \n", + "119600.000000 | \n", + "NaN | \n", + "
| 50% | \n", + "-118.490000 | \n", + "34.260000 | \n", + "29.000000 | \n", + "2127.000000 | \n", + "435.000000 | \n", + "1166.000000 | \n", + "409.000000 | \n", + "3.534800 | \n", + "179700.000000 | \n", + "NaN | \n", + "
| 75% | \n", + "-118.010000 | \n", + "37.710000 | \n", + "37.000000 | \n", + "3148.000000 | \n", + "647.000000 | \n", + "1725.000000 | \n", + "605.000000 | \n", + "4.743250 | \n", + "264725.000000 | \n", + "NaN | \n", + "
| max | \n", + "-114.310000 | \n", + "41.950000 | \n", + "52.000000 | \n", + "39320.000000 | \n", + "6445.000000 | \n", + "35682.000000 | \n", + "6082.000000 | \n", + "15.000100 | \n", + "500001.000000 | \n", + "NaN | \n", + "
LinearRegression()In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
LinearRegression()
DecisionTreeRegressor()In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
DecisionTreeRegressor()
GridSearchCV(cv=5, estimator=RandomForestRegressor(random_state=42),\n",
+ " param_grid=[{'max_features': [2, 4, 6, 8],\n",
+ " 'n_estimators': [3, 10, 30]},\n",
+ " {'bootstrap': [False], 'max_features': [2, 3, 4],\n",
+ " 'n_estimators': [3, 10]}],\n",
+ " return_train_score=True, scoring='neg_mean_squared_error')In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. GridSearchCV(cv=5, estimator=RandomForestRegressor(random_state=42),\n",
+ " param_grid=[{'max_features': [2, 4, 6, 8],\n",
+ " 'n_estimators': [3, 10, 30]},\n",
+ " {'bootstrap': [False], 'max_features': [2, 3, 4],\n",
+ " 'n_estimators': [3, 10]}],\n",
+ " return_train_score=True, scoring='neg_mean_squared_error')RandomForestRegressor(random_state=42)
RandomForestRegressor(random_state=42)
RandomForestRegressor(max_features=6, n_estimators=30, random_state=42)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
RandomForestRegressor(max_features=6, n_estimators=30, random_state=42)
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "pUHInVwN8gr0"
+ },
+ "source": [
+ "# | \n", + " | MODELYEAR | \n", + "MAKE | \n", + "MODEL | \n", + "VEHICLECLASS | \n", + "ENGINESIZE | \n", + "CYLINDERS | \n", + "TRANSMISSION | \n", + "FUELTYPE | \n", + "FUELCONSUMPTION_CITY | \n", + "FUELCONSUMPTION_HWY | \n", + "FUELCONSUMPTION_COMB | \n", + "FUELCONSUMPTION_COMB_MPG | \n", + "CO2EMISSIONS | \n", + "
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | \n", + "2014 | \n", + "ACURA | \n", + "ILX | \n", + "COMPACT | \n", + "2.0 | \n", + "4 | \n", + "AS5 | \n", + "Z | \n", + "9.9 | \n", + "6.7 | \n", + "8.5 | \n", + "33 | \n", + "196 | \n", + "
| 1 | \n", + "2014 | \n", + "ACURA | \n", + "ILX | \n", + "COMPACT | \n", + "2.4 | \n", + "4 | \n", + "M6 | \n", + "Z | \n", + "11.2 | \n", + "7.7 | \n", + "9.6 | \n", + "29 | \n", + "221 | \n", + "
| 2 | \n", + "2014 | \n", + "ACURA | \n", + "ILX HYBRID | \n", + "COMPACT | \n", + "1.5 | \n", + "4 | \n", + "AV7 | \n", + "Z | \n", + "6.0 | \n", + "5.8 | \n", + "5.9 | \n", + "48 | \n", + "136 | \n", + "
| 3 | \n", + "2014 | \n", + "ACURA | \n", + "MDX 4WD | \n", + "SUV - SMALL | \n", + "3.5 | \n", + "6 | \n", + "AS6 | \n", + "Z | \n", + "12.7 | \n", + "9.1 | \n", + "11.1 | \n", + "25 | \n", + "255 | \n", + "
| 4 | \n", + "2014 | \n", + "ACURA | \n", + "RDX AWD | \n", + "SUV - SMALL | \n", + "3.5 | \n", + "6 | \n", + "AS6 | \n", + "Z | \n", + "12.1 | \n", + "8.7 | \n", + "10.6 | \n", + "27 | \n", + "244 | \n", + "
| \n", + " | ENGINESIZE | \n", + "CYLINDERS | \n", + "FUELCONSUMPTION_COMB | \n", + "CO2EMISSIONS | \n", + "
|---|---|---|---|---|
| 0 | \n", + "2.0 | \n", + "4 | \n", + "8.5 | \n", + "196 | \n", + "
| 1 | \n", + "2.4 | \n", + "4 | \n", + "9.6 | \n", + "221 | \n", + "
| 2 | \n", + "1.5 | \n", + "4 | \n", + "5.9 | \n", + "136 | \n", + "
| 3 | \n", + "3.5 | \n", + "6 | \n", + "11.1 | \n", + "255 | \n", + "
| 4 | \n", + "3.5 | \n", + "6 | \n", + "10.6 | \n", + "244 | \n", + "
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "hAvyBAjaR6ur"
+ },
+ "source": [
+ "# | \n", + " | Year | \n", + "Value | \n", + "
|---|---|---|
| 0 | \n", + "1960 | \n", + "5.918412e+10 | \n", + "
| 1 | \n", + "1961 | \n", + "4.955705e+10 | \n", + "
| 2 | \n", + "1962 | \n", + "4.668518e+10 | \n", + "
| 3 | \n", + "1963 | \n", + "5.009730e+10 | \n", + "
| 4 | \n", + "1964 | \n", + "5.906225e+10 | \n", + "
| 5 | \n", + "1965 | \n", + "6.970915e+10 | \n", + "
| 6 | \n", + "1966 | \n", + "7.587943e+10 | \n", + "
| 7 | \n", + "1967 | \n", + "7.205703e+10 | \n", + "
| 8 | \n", + "1968 | \n", + "6.999350e+10 | \n", + "
| 9 | \n", + "1969 | \n", + "7.871882e+10 | \n", + "
| 10 | \n", + "1970 | \n", + "9.150621e+10 | \n", + "
| 11 | \n", + "1971 | \n", + "9.856202e+10 | \n", + "
| 12 | \n", + "1972 | \n", + "1.121598e+11 | \n", + "
| 13 | \n", + "1973 | \n", + "1.367699e+11 | \n", + "
| 14 | \n", + "1974 | \n", + "1.422547e+11 | \n", + "
| 15 | \n", + "1975 | \n", + "1.611625e+11 | \n", + "
| 16 | \n", + "1976 | \n", + "1.516277e+11 | \n", + "
| 17 | \n", + "1977 | \n", + "1.723490e+11 | \n", + "
| 18 | \n", + "1978 | \n", + "1.483821e+11 | \n", + "
| 19 | \n", + "1979 | \n", + "1.768565e+11 | \n", + "
| \n", + " | Year | \n", + "Value | \n", + "
|---|---|---|
| 45 | \n", + "2005 | \n", + "2.268599e+12 | \n", + "
| 46 | \n", + "2006 | \n", + "2.729784e+12 | \n", + "
| 47 | \n", + "2007 | \n", + "3.523094e+12 | \n", + "
| 48 | \n", + "2008 | \n", + "4.558431e+12 | \n", + "
| 49 | \n", + "2009 | \n", + "5.059420e+12 | \n", + "
| 50 | \n", + "2010 | \n", + "6.039659e+12 | \n", + "
| 51 | \n", + "2011 | \n", + "7.492432e+12 | \n", + "
| 52 | \n", + "2012 | \n", + "8.461623e+12 | \n", + "
| 53 | \n", + "2013 | \n", + "9.490603e+12 | \n", + "
| 54 | \n", + "2014 | \n", + "1.035483e+13 | \n", + "
| \n", + " | Year | \n", + "Value | \n", + "
|---|---|---|
| count | \n", + "55.00000 | \n", + "5.500000e+01 | \n", + "
| mean | \n", + "1987.00000 | \n", + "1.437042e+12 | \n", + "
| std | \n", + "16.02082 | \n", + "2.500085e+12 | \n", + "
| min | \n", + "1960.00000 | \n", + "4.668518e+10 | \n", + "
| 25% | \n", + "1973.50000 | \n", + "1.395123e+11 | \n", + "
| 50% | \n", + "1987.00000 | \n", + "3.074796e+11 | \n", + "
| 75% | \n", + "2000.50000 | \n", + "1.268748e+12 | \n", + "
| max | \n", + "2014.00000 | \n", + "1.035483e+13 | \n", + "
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "_VUO0ZOXy8EG"
+ },
+ "source": [
+ "# ML - Regresión\n",
+ "## [M.Sc. Ruben Quispe](https://www.linkedin.com/in/ruben-quispe-l/)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "xt0dJ6uTy8EH"
+ },
+ "source": [
+ "Seguimos con nuestra serie en la que estamos aprendiendo sobre *Machine Learning*. Si lo recuerdas, en nuestra introducción al ML, vimos las diferentes tareas que podemos resolver con esta tecnología. Estas son, principalmente: regresión, clasificación y *clustering*. En este post aprenderemos sobre la primera de ellas, la regresión."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "piNNVm4Sy8EH"
+ },
+ "source": [
+ "## Regresión Lineal"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "EWbMXxjgy8EH"
+ },
+ "source": [
+ "La tarea de regresión consiste en encontrar una función que nos permita predecir el valor de una o más variables a partir de una o más características (o *features*). Un ejemplo sería el de predecir el precio de una casa a partir de su número de habitaciones, metros cuadrados, etc. El modelos de ML más sencillo para este tipo de tarea es el modelo de **regresión lineal**.\n",
+ "\n",
+ "$$\n",
+ " \\hat{y} = w_0 + w_1 x_1 + w_2 x_2 + ... + w_n x_n\n",
+ "$$\n",
+ "\n",
+ "donde $\\hat{y}$ es el valor predicho, $w_i$ es el parámetro $i$ (incluyendo el *bias* $w_0$), $n$ es el número de características (*features*) y $x_i$ es la característica $i$. \n",
+ "\n",
+ "Entrenear un modelo de regresión lineal consiste en encontrar el conjunto de pesos, $w_i$, que minimizen una función de coste determinada. En el caso de la regresión, el error medio cuadrático suele utilizarse comunmente como medida del error:\n",
+ "\n",
+ "$$\n",
+ " MSE(\\hat{y},y) = \\frac{1}{N} \\sum^{N}_{j=1} (\\hat{y}^{(j)} - y^{(j)})^2\n",
+ "$$\n",
+ "\n",
+ "donde $N$ es el número de muestras en nuestro conjunto de datos, $y^{(i)}$ es el valor real, la etiqueta (o *ground truth*) de la muestra $j$.\n",
+ "\n",
+ "Vamos a ver un ejemplo de como resolver este problema con el siguiente conjunto de datos simple."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "K3wbkFpby8EI",
+ "outputId": "3d2b3c6f-b206-4f23-fbc9-34ec912d2f27"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ygxPJER8zUyp"
+ },
+ "source": [
+ "# Métricas para Clasificación Binaria\n",
+ "## [M.Sc. Ruben Quispe](https://www.linkedin.com/in/ruben-quispe-l/)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "j6XG5KnAzUyp"
+ },
+ "source": [
+ "En clases anteriores hemos visto como podemos implementar modelos lineales para clasficación binaria, ejemplos de los modelos más simples en el `Machine Learning` pero no por ello menos usados (pese a las limitaciones que ya hemos comentado, estos modelos son eficientes y explicables, lo cual es preferido en multitud de aplicaciones). En este clase vamos a ver algunas de las métricas más utilizadas en clasificación binaria (aunque pueden extenderse también a clasificación en varias clases). Estas métricas nos van a ser muy útiles para caracterizar el desempeño de nuestros modelos y comparar diferentes modelos entre sí para, por ejemplos, utilizar el mejor. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "oZlQTzaazUyq"
+ },
+ "source": [
+ "## El dataset MNIST"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "DUDl4oK8zUyq"
+ },
+ "source": [
+ "En las clases anteriores sobre clasificación binaria hemos trabajado con el dataset Iris para clasificación de flores a partir de características como el ancho o la longitud de sus pétalos. En este post vamos a utilizar un nuevo dataset, probablemente el más utilizado mientras aprendemos sobre `Deep Learning` y considerado el *hello world* del `Machine Learning`: el dataset [MNIST](http://yann.lecun.com/exdb/mnist/). Este dataset fue elaborado con el objetivo de entrenar modelos automáticos de OCR (*Optical Character Recognition*) para poder acelerar el trabajo de clasificación de correo a partir del código postal escrito. Está formado por 70,0000 imágenes de dígitos manuscritos, entre $0$ y $9$, y el objetivo es el de ser capaces de diseñar un algoritmo capaz de clasificar una imágen (decir que número es) directamente a partir de sus pixeles. De entre las diferentes fuentes que podemos utilizar para descargar estos datos, vamos a utilizar [Scikit-Learn](https://scikit-learn.org/stable/)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-07-14T11:34:30.332724Z",
+ "start_time": "2020-07-14T11:34:11.690776Z"
+ },
+ "id": "Cbv_Gf5TzUyr",
+ "outputId": "daa92e1a-6d94-4f83-ed3c-c90091d162b4"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "dict_keys(['data', 'target', 'frame', 'categories', 'feature_names', 'target_names', 'DESCR', 'details', 'url'])"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.datasets import fetch_openml\n",
+ "\n",
+ "mnist = fetch_openml('mnist_784', version=1)\n",
+ "mnist.keys()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-07-14T11:34:30.348758Z",
+ "start_time": "2020-07-14T11:34:30.333725Z"
+ },
+ "id": "KWX7asI_zUys",
+ "outputId": "eabb6788-ffbb-419c-df18-e15a78a347e8"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((70000, 784), (70000,))"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "X, y = mnist[\"data\"], mnist[\"target\"]\n",
+ "\n",
+ "X.shape, y.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "aHwY8YEyzUys"
+ },
+ "source": [
+ "Como puedes ver, cada imágen está formada por $784$ características (los pixeles). Podemos visualizar unas cuantas imágenes junto a sus etiquetas de la siguiente manera para hacernos una idea del tipo de datos al que nos enfrentamos."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-07-14T11:34:30.906759Z",
+ "start_time": "2020-07-14T11:34:30.349757Z"
+ },
+ "id": "B-ze4oZEzUyt",
+ "outputId": "1367901b-f2bf-4097-fbc6-0e1838d6a63f"
+ },
+ "outputs": [
+ {
+ "ename": "KeyError",
+ "evalue": "63745",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m 2894\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2895\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasted_key\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2896\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32mpandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n",
+ "\u001b[0;32mpandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n",
+ "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n",
+ "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n",
+ "\u001b[0;31mKeyError\u001b[0m: 63745",
+ "\nThe above exception was the direct cause of the following exception:\n",
+ "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "EaOXRtEKFOs9"
+ },
+ "source": [
+ "# ML - Clasificación\n",
+ "## [M.Sc. Ruben Quispe](https://www.linkedin.com/in/ruben-quispe-l/)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Zp93xH0HFOs9"
+ },
+ "source": [
+ "En esta clase aprenderemos sobre la segunda tarea que podemos resolver con modelos de ML, después de la [regresión, y esta es la de **clasificación**. A diferencia de la regresión, en el que el objetivo era predecir el valor de una variable con respecto a diferentes caracterísitcas, en la clasificación el objetivo es el de asignar una clase, o etiqueta, a partir de las diferentes características. Como ejemplo, la clasificación de imágenes, se trata de asignar una etiqueta en función del valor de los pixeles. Vamos a ver diferentes modelos de ML que tenemos a nuestra disposición para esta tarea."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "azhtS4VlFOs-"
+ },
+ "source": [
+ "## Regresión Logística"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "S0xJPB8iFOs-"
+ },
+ "source": [
+ "Si bien este modelo lleva en el nombre **regresión**, realmente es un modelo de **clasificación**. Se llama así porque el modelo usado es el mismo que vimos en el post anterior para regresión lineal, aplicando una función **sigmoid** a la salida del modelo. Esta función convertirá el valor de la salida en un valor entre 0 y 1 que puede ser interpretado como una probabilidad. Aplicando un umbral a la salida podremos decidir si la muestra en cuestión pertenece a una clase o no (por ejemplo, si la probabilidad es mayor del 50%). Así pues, este modelo no servirá para la tarea de **clasificación binaria**.\n",
+ "\n",
+ "$$\n",
+ " \\hat{y} = \\sigma(w_0 + w_1 x_1 + w_2 x_2 + ... + w_n x_n)\n",
+ "$$\n",
+ "\n",
+ "donde $\\sigma(t) = \\frac{1}{1 + e^{-t}}$ es la funcion sigmoidal."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "u7al6_Y_FOs-",
+ "outputId": "20669043-d3f9-4b0d-fd68-05eb6ab71822"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "LogisticRegression(random_state=42)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
LogisticRegression(random_state=42)
LogisticRegression(C=10000000000, random_state=42)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
LogisticRegression(C=10000000000, random_state=42)
LogisticRegression(C=10, multi_class='multinomial', random_state=42)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
LogisticRegression(C=10, multi_class='multinomial', random_state=42)
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "4DBBY9XEzy9u"
+ },
+ "source": [
+ "# ML - Support Vector Machine\n",
+ "## [M.Sc. Ruben Quispe](https://www.linkedin.com/in/ruben-quispe-l/)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [],
+ "metadata": {
+ "id": "5t4u8ZH8mbgh"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "heDgPd8yzy9u"
+ },
+ "source": [
+ "En clases anteriores hemos aprendido sobre las dos tareas más típicas en el mundo del *Machine Learning*: la regresión y la classificación, y un primer modelo sencillo para atacar estos problemas: la regresión lineal (o regresión logísitica en el caso de la clasificación). Si bien este modelo es muy sencillo, eficiente y explicable (cada variable tiene un peso asignado, por lo que podemos saber cuánto contribuye a la decisión final) su principal limitación se encuentra, como ya vimos, en que no es capaz de aprender datasets que no sigan tendencias lineales. Esto motivó el desarrollo de nuevos modelos de ML capaces de sobreponerse a estas limitaciones. Entre ellos, uno de los más usados por sus buenas prestaciones cuando no disponemos de muchos datos son las máquinas de soporte vectorial, o *Support Vector Machines* (SVM) en inglés."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "cyZylkgJzy9u"
+ },
+ "source": [
+ "## Clasificación lineal con SVMs"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "xnmGJTJbzy9u"
+ },
+ "source": [
+ "Mientras que los modelos de regresión lineal se basan en la idea de minimizar el número de errores, las SVMs intentan maximizar la distancia entre las fronteras de decisión y los datos de entrenamiento: el margen.\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "Añadir más datos fuera del margen no afecta al modelo ya que está totalmente determinado por las instancias localizadas en los límites de la frontera: los vectores soporte. Esto solo funciona si los datos son linealmente separables, en caso contrario deberemos aceptar un cierto número de errores (aunque en la sección siguiente veremos como hacerlo con un modelo no lineal).\n",
+ "\n",
+ "En *Scikit-Learn* puedes usar el modelo [LinearSVC](https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html) para entrenar un clasificador lineal con SVMs. En el siguiente ejemplo veremos como podemos ajustar el número de errores aceptables en la clasificación (instancias dentro del margen) con el dataset Iris, que ya hemos usado en varios de los posts anteriores."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "3z8oG2X0zy9v",
+ "outputId": "90d732ce-37c8-4080-b766-2ef56e7a36a8"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Users/rubencarthy/opt/anaconda3/lib/python3.8/site-packages/sklearn/svm/_base.py:1225: ConvergenceWarning: Liblinear failed to converge, increase the number of iterations.\n",
+ " warnings.warn(\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "Pipeline(steps=[('scaler', StandardScaler()),\n",
+ " ('linear_svc',\n",
+ " LinearSVC(C=100, loss='hinge', random_state=42))])In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. Pipeline(steps=[('scaler', StandardScaler()),\n",
+ " ('linear_svc',\n",
+ " LinearSVC(C=100, loss='hinge', random_state=42))])StandardScaler()
LinearSVC(C=100, loss='hinge', random_state=42)
Pipeline(steps=[('poly_features', PolynomialFeatures(degree=3)),\n",
+ " ('scaler', StandardScaler()),\n",
+ " ('svm_clf', LinearSVC(C=10, loss='hinge', random_state=42))])In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. Pipeline(steps=[('poly_features', PolynomialFeatures(degree=3)),\n",
+ " ('scaler', StandardScaler()),\n",
+ " ('svm_clf', LinearSVC(C=10, loss='hinge', random_state=42))])PolynomialFeatures(degree=3)
StandardScaler()
LinearSVC(C=10, loss='hinge', random_state=42)
Pipeline(steps=[('scaler', StandardScaler()),\n",
+ " ('svm_clf', SVC(C=5, coef0=1, kernel='poly'))])In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. Pipeline(steps=[('scaler', StandardScaler()),\n",
+ " ('svm_clf', SVC(C=5, coef0=1, kernel='poly'))])StandardScaler()
SVC(C=5, coef0=1, kernel='poly')
Pipeline(steps=[('scaler', StandardScaler()),\n",
+ " ('svm_clf', SVC(C=5, coef0=100, degree=10, kernel='poly'))])In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. Pipeline(steps=[('scaler', StandardScaler()),\n",
+ " ('svm_clf', SVC(C=5, coef0=100, degree=10, kernel='poly'))])StandardScaler()
SVC(C=5, coef0=100, degree=10, kernel='poly')
LinearSVR(epsilon=1.5, random_state=42)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
LinearSVR(epsilon=1.5, random_state=42)
SVR(C=100, degree=2, kernel='poly')In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
SVR(C=100, degree=2, kernel='poly')
SVR(C=0.01, degree=2, kernel='poly')In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
SVR(C=0.01, degree=2, kernel='poly')
SVC(C=100, kernel='linear')In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
SVC(C=100, kernel='linear')
SGDClassifier(alpha=0.017)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
SGDClassifier(alpha=0.017)
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "AHM_fjnV8Ivs"
+ },
+ "source": [
+ "# Decision Trees para Predecir la Medicina Correcta\n",
+ "## [MSc: Ruben Quispe](https://www.linkedin.com/in/ruben-quispe-l/)\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "7xLcoCIT8Umf"
+ },
+ "source": [
+ "En este laboratorio, aprenderá un popular algoritmo de aprendizaje automático, el árbol de decisiones. Utilizará este algoritmo de clasificación para construir un modelo a partir de datos históricos de pacientes y su respuesta a diferentes medicamentos. Luego, utiliza el árbol de decisiones capacitado para predecir la clase de un paciente desconocido o para encontrar un medicamento adecuado para un nuevo paciente.\n",
+ "# Tabla de contenidos\n",
+ "1. Sobre el dataset\n",
+ "2. descargar la data\n",
+ "3. Pre-procesamiento\n",
+ "4. Modelado\n",
+ "5. Predicción\n",
+ "6. Evaluación\n",
+ "7. Visualización"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "0guMSka78Uky"
+ },
+ "source": [
+ "# 1. importar las librerías Necesarias"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "KJBTl5aP8Oe3"
+ },
+ "source": [
+ "import numpy as np \n",
+ "import pandas as pd\n",
+ "from sklearn.tree import DecisionTreeClassifier"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "1CxTBDD49F_g"
+ },
+ "source": [
+ "# Sobre el Dataset\n",
+ "Imagine que es un investigador médico que recopila datos para un estudio. Ha recopilado datos sobre un conjunto de pacientes, todos los cuales padecían la misma enfermedad. Durante el curso de su tratamiento, cada paciente respondió a uno de los 5 medicamentos, medicamento A, medicamento B, medicamento c, medicamento x e y.\n",
+ "\n",
+ "Parte de su trabajo consiste en crear un modelo para averiguar qué fármaco podría ser apropiado para un futuro paciente con la misma enfermedad. Los conjuntos de características de este conjunto de datos son la edad, el sexo, la presión arterial y el colesterol de los pacientes, y el objetivo es el fármaco al que respondió cada paciente.\n",
+ "\n",
+ "Es una muestra de clasificador binario, y puede usar la parte de entrenamiento del conjunto de datos para construir un árbol de decisiones y luego usarlo para predecir la clase de un paciente desconocido o prescribirlo a un nuevo paciente.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "CYKhTowS9puh"
+ },
+ "source": [
+ "# 2. Cargando o descargando la data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "oG0ILrCM9DBc"
+ },
+ "source": [
+ "df = pd.read_csv(\"drug200.csv\")"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "kQhlJfM2-Dnu",
+ "outputId": "dbd27def-4f1a-453b-ca14-eb3b3598be0f",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 206
+ }
+ },
+ "source": [
+ "df[0:5]"
+ ],
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ " Age Sex BP Cholesterol Na_to_K Drug\n",
+ "0 23 F HIGH HIGH 25.355 drugY\n",
+ "1 47 M LOW HIGH 13.093 drugC\n",
+ "2 47 M LOW HIGH 10.114 drugC\n",
+ "3 28 F NORMAL HIGH 7.798 drugX\n",
+ "4 61 F LOW HIGH 18.043 drugY"
+ ],
+ "text/html": [
+ "\n",
+ " | \n", + " | Age | \n", + "Sex | \n", + "BP | \n", + "Cholesterol | \n", + "Na_to_K | \n", + "Drug | \n", + "
|---|---|---|---|---|---|---|
| 0 | \n", + "23 | \n", + "F | \n", + "HIGH | \n", + "HIGH | \n", + "25.355 | \n", + "drugY | \n", + "
| 1 | \n", + "47 | \n", + "M | \n", + "LOW | \n", + "HIGH | \n", + "13.093 | \n", + "drugC | \n", + "
| 2 | \n", + "47 | \n", + "M | \n", + "LOW | \n", + "HIGH | \n", + "10.114 | \n", + "drugC | \n", + "
| 3 | \n", + "28 | \n", + "F | \n", + "NORMAL | \n", + "HIGH | \n", + "7.798 | \n", + "drugX | \n", + "
| 4 | \n", + "61 | \n", + "F | \n", + "LOW | \n", + "HIGH | \n", + "18.043 | \n", + "drugY | \n", + "
| \n", + " | Age | \n", + "Sex | \n", + "BP | \n", + "Cholesterol | \n", + "Na_to_K | \n", + "Drug | \n", + "
|---|---|---|---|---|---|---|
| 0 | \n", + "23 | \n", + "F | \n", + "HIGH | \n", + "HIGH | \n", + "25.355 | \n", + "drugY | \n", + "
| 1 | \n", + "47 | \n", + "M | \n", + "LOW | \n", + "HIGH | \n", + "13.093 | \n", + "drugC | \n", + "
| 2 | \n", + "47 | \n", + "M | \n", + "LOW | \n", + "HIGH | \n", + "10.114 | \n", + "drugC | \n", + "
| 3 | \n", + "28 | \n", + "F | \n", + "NORMAL | \n", + "HIGH | \n", + "7.798 | \n", + "drugX | \n", + "
| 4 | \n", + "61 | \n", + "F | \n", + "LOW | \n", + "HIGH | \n", + "18.043 | \n", + "drugY | \n", + "
| ... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "
| 195 | \n", + "56 | \n", + "F | \n", + "LOW | \n", + "HIGH | \n", + "11.567 | \n", + "drugC | \n", + "
| 196 | \n", + "16 | \n", + "M | \n", + "LOW | \n", + "HIGH | \n", + "12.006 | \n", + "drugC | \n", + "
| 197 | \n", + "52 | \n", + "M | \n", + "NORMAL | \n", + "HIGH | \n", + "9.894 | \n", + "drugX | \n", + "
| 198 | \n", + "23 | \n", + "M | \n", + "NORMAL | \n", + "NORMAL | \n", + "14.020 | \n", + "drugX | \n", + "
| 199 | \n", + "40 | \n", + "F | \n", + "LOW | \n", + "NORMAL | \n", + "11.349 | \n", + "drugX | \n", + "
200 rows × 6 columns
\n", + "| \n", + " | Age | \n", + "Sex | \n", + "BP | \n", + "Cholesterol | \n", + "Na_to_K | \n", + "Drug | \n", + "
|---|---|---|---|---|---|---|
| 0 | \n", + "23 | \n", + "F | \n", + "HIGH | \n", + "HIGH | \n", + "25.355 | \n", + "drugY | \n", + "
| 1 | \n", + "47 | \n", + "M | \n", + "LOW | \n", + "HIGH | \n", + "13.093 | \n", + "drugC | \n", + "
| 2 | \n", + "47 | \n", + "M | \n", + "LOW | \n", + "HIGH | \n", + "10.114 | \n", + "drugC | \n", + "
| 3 | \n", + "28 | \n", + "F | \n", + "NORMAL | \n", + "HIGH | \n", + "7.798 | \n", + "drugX | \n", + "
| 4 | \n", + "61 | \n", + "F | \n", + "LOW | \n", + "HIGH | \n", + "18.043 | \n", + "drugY | \n", + "
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "5UluWz2hmTu4"
+ },
+ "source": [
+ "# K- Nearest Neighbors\n",
+ "## [MSc: Ruben Quispe](https://www.linkedin.com/in/ruben-quispe-l/)\n",
+ "En este laboratorio, cargará un conjunto de datos de un cliente, ajustará los datos y usará K-Vecinos más cercanos para predecir un punto de datos. Pero, ¿qué son los K-vecinos más cercanos?\n",
+ "\n",
+ "K-Neighbors Neighbors es un algoritmo de aprendizaje supervisado. Donde los datos están 'entrenados' con puntos de datos correspondientes a su clasificación. Una vez que se va a predecir un punto, tiene en cuenta los puntos 'K' más cercanos a él para determinar su clasificación.\n",
+ "\n",
+ "## Aquí hay una visualización del algoritmo K-Neighbors Neighbors.\n",
+ "\n",
+ "![](\"https://ibm.box.com/shared/static/mgkn92xck0z05v7yjq8pqziukxvc2461.png\")
\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "cJTaoeK4mTu7"
+ },
+ "source": [
+ "En este caso, tenemos puntos de datos de Clase A y B. Queremos predecir cuál es la estrella (punto de datos de prueba). Si consideramos un valor k de 3 (3 puntos de datos más cercanos) obtendremos una predicción de Clase B. Sin embargo, si consideramos un valor k de 6, obtendremos una predicción de Clase A.\n",
+ "\n",
+ "En este sentido, es importante considerar el valor de k. Pero, con suerte, a partir de este diagrama, debería tener una idea de lo que es el algoritmo K-Neighbours. Considera los'K'vecinos más cercanos (puntos) cuando predice la clasificación del punto de prueba.\n",
+ "\n",
+ "# Tabla de contenido\n",
+ "1. Sobre el dataset\n",
+ "2. Análisis y Visualización de Datos\n",
+ "3. Clasificación"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "A3GJl8jSmTu8"
+ },
+ "source": [
+ "# 1. Importando las librerías necesarias"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "eyttO6VqmTu-"
+ },
+ "source": [
+ "import itertools\n",
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "from matplotlib.ticker import NullFormatter\n",
+ "import pandas as pd\n",
+ "import numpy as np\n",
+ "import matplotlib.ticker as ticker\n",
+ "from sklearn import preprocessing\n",
+ "%matplotlib inline"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "OEPqvpblmTvE"
+ },
+ "source": [
+ "# 2. Sobre el conjunto de datos\n",
+ "Imagine que un proveedor de telecomunicaciones ha segmentado su base de clientes por patrones de uso del servicio, categorizando a los clientes en cuatro grupos. Si los datos demográficos se pueden utilizar para predecir la pertenencia a un grupo, la empresa puede personalizar ofertas para posibles clientes individuales. Es un problema de clasificación. Es decir, dado el conjunto de datos, con etiquetas predefinidas, necesitamos construir un modelo que se utilizará para predecir la clase de un caso nuevo o desconocido.\n",
+ "\n",
+ "El ejemplo se centra en el uso de datos demográficos, como región, edad y matrimonio, para predecir patrones de uso.\n",
+ "\n",
+ "El campo de destino, denominado custcat, tiene cuatro valores posibles que corresponden a los cuatro grupos de clientes, de la siguiente manera: 1- Servicio básico 2- Servicio electrónico 3- Servicio Plus 4- Servicio total\n",
+ "\n",
+ "Nuestro objetivo es construir un clasificador, para predecir la clase de casos desconocidos. Usaremos un tipo específico de clasificación llamado K vecino más cercano.\n",
+ "\n",
+ "# 3. Carga los datos desde un archivo csv"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "RzrWu6mZmTvF",
+ "outputId": "a790a4f8-34cf-45ca-bd1c-84d45e218fb4"
+ },
+ "source": [
+ "df = pd.read_csv(\"D:/TECHNOLOGY 2020/EIE/ML con Python/Data/teleCust1000t.csv\")\n",
+ "df.head()"
+ ],
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/html": [
+ "| \n", + " | region | \n", + "tenure | \n", + "age | \n", + "marital | \n", + "address | \n", + "income | \n", + "ed | \n", + "employ | \n", + "retire | \n", + "gender | \n", + "reside | \n", + "custcat | \n", + "
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | \n", + "2 | \n", + "13 | \n", + "44 | \n", + "1 | \n", + "9 | \n", + "64.0 | \n", + "4 | \n", + "5 | \n", + "0.0 | \n", + "0 | \n", + "2 | \n", + "1 | \n", + "
| 1 | \n", + "3 | \n", + "11 | \n", + "33 | \n", + "1 | \n", + "7 | \n", + "136.0 | \n", + "5 | \n", + "5 | \n", + "0.0 | \n", + "0 | \n", + "6 | \n", + "4 | \n", + "
| 2 | \n", + "3 | \n", + "68 | \n", + "52 | \n", + "1 | \n", + "24 | \n", + "116.0 | \n", + "1 | \n", + "29 | \n", + "0.0 | \n", + "1 | \n", + "2 | \n", + "3 | \n", + "
| 3 | \n", + "2 | \n", + "33 | \n", + "33 | \n", + "0 | \n", + "12 | \n", + "33.0 | \n", + "2 | \n", + "0 | \n", + "0.0 | \n", + "1 | \n", + "1 | \n", + "1 | \n", + "
| 4 | \n", + "2 | \n", + "23 | \n", + "30 | \n", + "1 | \n", + "9 | \n", + "30.0 | \n", + "1 | \n", + "2 | \n", + "0.0 | \n", + "0 | \n", + "4 | \n", + "3 | \n", + "
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "io_JXxeZ0CkJ"
+ },
+ "source": [
+ "# ML - Decision Trees\n",
+ "## [M.Sc. Ruben Quispe](https://www.linkedin.com/in/ruben-quispe-l/)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Aawv_afq0CkK"
+ },
+ "source": [
+ "Seguimos en nuestra aventura aprendiendo nuevos algoritmos de *Machine Learning*. En clases anteriores hemos hablado ya de algoritmos como la regresión lineal y *Suport Vector Machines*, y ahora es el turno de conocer los árboles de decisión, o *Decision Trees* en inglés. Este tipo de algoritmo, que es la base de uno de los modelos más usados en ML, los *Random Forest* (que veremos en detalle en el siguiente post), es capaz de llevar a cabo tareas de clasificación, regresión e incluso tareas con múltiples outputs. Además, es un modelo muy sencillo y explicable lo que lo hace ideal para aquellas tareas en las que la explicabilidad sea esencial (como aplicaciones médicas, entre otras)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "GatdveVe0CkL"
+ },
+ "source": [
+ "## Entrenando y visualizando árboles de decisión"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ODxteqey0CkL"
+ },
+ "source": [
+ "Vamos a ver un primer ejemplo de entrenamiento de un árbol de decisión en nuestro querido dataset Iris, que ya deberías conocer de los posts anteriores. En *Scikit-Learn*, puedes usar el modelo [DecisionTreeClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html?highlight=decisiontreeclassifier#sklearn.tree.DecisionTreeClassifier)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "Lcg0YAHQ0CkL",
+ "outputId": "775b5d41-1cd0-4fb5-96f8-b64a0a2be8cf"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "DecisionTreeClassifier(max_depth=2, random_state=42)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
DecisionTreeClassifier(max_depth=2, random_state=42)
GridSearchCV(cv=10, estimator=DecisionTreeClassifier(), n_jobs=-1,\n",
+ " param_grid={'max_leaf_nodes': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,\n",
+ " 13, 14, 15, 16, 17, 18, 19, 20, 21,\n",
+ " 22, 23, 24, 25, 26, 27, 28, 29, 30,\n",
+ " 31, ...],\n",
+ " 'min_samples_split': [2, 3, 4]},\n",
+ " verbose=1)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. GridSearchCV(cv=10, estimator=DecisionTreeClassifier(), n_jobs=-1,\n",
+ " param_grid={'max_leaf_nodes': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,\n",
+ " 13, 14, 15, 16, 17, 18, 19, 20, 21,\n",
+ " 22, 23, 24, 25, 26, 27, 28, 29, 30,\n",
+ " 31, ...],\n",
+ " 'min_samples_split': [2, 3, 4]},\n",
+ " verbose=1)DecisionTreeClassifier()
DecisionTreeClassifier()
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "BvPakoZp0sF7"
+ },
+ "source": [
+ "# ML - Ensemble Learning\n",
+ "## [M.Sc. Ruben Quispe](https://www.linkedin.com/in/ruben-quispe-l/)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "njlMmL-90sF7"
+ },
+ "source": [
+ "La técnica de aprendizaje ensamblado, o *Ensemble Learning* en inglés, consiste en combinar diferentes modelos de ML para obtener mejores predicciones que las que nos proporcionarían los diferentes modelos por separado. Existen multitud de técnicas de ensamblado, y en este post veremos las siguientes:\n",
+ "\n",
+ "- Clasificadores por votación\n",
+ "- *Bagging* y *Pasting*\n",
+ "- *Random Forest*\n",
+ "- *Boosting*\n",
+ "- *Stacking*"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "kvAouxJA0sF8"
+ },
+ "source": [
+ "## Clasificadores por votación"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "yjBP7bGK0sF8"
+ },
+ "source": [
+ "Esta es una de las técnicas de ensamblado más sencillas, y como su propio nombre indica simplemente agregaremos las predicciones de diferentes clasificadores quedándonos con la clase más votada.\n",
+ "\n",
+ "\n",
+ "\n",
+ "En *Scikit-Learn* puedes usar el objeto [VotingClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.VotingClassifier.html), que usamos en el siguiente ejemplo en el que ensamblamos un modelos de regresión logística, un SVM y un árbol de decisión (todos explicados en clases anteriores)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "-Mzv2Aq50sF8"
+ },
+ "outputs": [],
+ "source": [
+ "from sklearn.model_selection import train_test_split\n",
+ "from sklearn.datasets import make_moons\n",
+ "\n",
+ "X, y = make_moons(n_samples=500, noise=0.30, random_state=42)\n",
+ "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "dwQ2nK040sF9"
+ },
+ "outputs": [],
+ "source": [
+ "from sklearn.ensemble import VotingClassifier\n",
+ "from sklearn.linear_model import LogisticRegression\n",
+ "from sklearn.svm import SVC\n",
+ "from sklearn.tree import DecisionTreeClassifier\n",
+ "\n",
+ "log_clf = LogisticRegression(solver=\"lbfgs\", random_state=42)\n",
+ "svm_clf = SVC(gamma=\"scale\", random_state=42)\n",
+ "tree_cf = DecisionTreeClassifier(max_depth=2, random_state=42)\n",
+ "\n",
+ "voting_clf = VotingClassifier(\n",
+ " estimators=[('lr', log_clf), ('svc', svm_clf), ('rf', tree_cf)],\n",
+ " voting='hard')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "Pwl9EvDj0sF9",
+ "outputId": "726626c0-51f8-4043-c845-f4956c4e4718"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "VotingClassifier(estimators=[('lr', LogisticRegression(random_state=42)),\n",
+ " ('svc', SVC(random_state=42)),\n",
+ " ('rf',\n",
+ " DecisionTreeClassifier(max_depth=2,\n",
+ " random_state=42))])In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. VotingClassifier(estimators=[('lr', LogisticRegression(random_state=42)),\n",
+ " ('svc', SVC(random_state=42)),\n",
+ " ('rf',\n",
+ " DecisionTreeClassifier(max_depth=2,\n",
+ " random_state=42))])LogisticRegression(random_state=42)
SVC(random_state=42)
DecisionTreeClassifier(max_depth=2, random_state=42)
RandomForestClassifier(random_state=42)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
RandomForestClassifier(random_state=42)
DecisionTreeRegressor(max_depth=2, random_state=42)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
DecisionTreeRegressor(max_depth=2, random_state=42)
DecisionTreeRegressor(max_depth=2, random_state=42)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
DecisionTreeRegressor(max_depth=2, random_state=42)
DecisionTreeRegressor(max_depth=2, random_state=42)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
DecisionTreeRegressor(max_depth=2, random_state=42)
GradientBoostingRegressor(learning_rate=1.0, max_depth=2, n_estimators=3,\n", + " random_state=42)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
GradientBoostingRegressor(learning_rate=1.0, max_depth=2, n_estimators=3,\n", + " random_state=42)
GradientBoostingRegressor(max_depth=2, n_estimators=200, random_state=42)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
GradientBoostingRegressor(max_depth=2, n_estimators=200, random_state=42)
GradientBoostingRegressor(max_depth=2, n_estimators=45, random_state=42)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
GradientBoostingRegressor(max_depth=2, n_estimators=45, random_state=42)
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "PP6Xb4RWFU2g"
+ },
+ "source": [
+ "# ML - Reducción de la Dimensionalidad\n",
+ "## [M.Sc. Ruben Quispe](https://www.linkedin.com/in/ruben-quispe-l/)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "m0FMN832FU2g"
+ },
+ "source": [
+ "En los clases anteriores de la serie de *Machine Learning* hemos visto multitud de algoritmos: modelos de regresión lineal, *Support Vector Machines*, árboles de decisión y modelos ensamblados, como los *Random Forest*. Todos los ejemplos que hemos visto hasta ahora consistían de *datasets* con pocas características, o *features* (ya que así podemos probar de manera rápida muchos modelos y compararlos). En muchos problemas reales, sin embargo, solemos tener muchas características (es común tener cientos o incluso miles o millones). Esto resulta en entrenamientos muy lentos (si es que son posibles) para encontrar una buena solución. Para aliviar este problema existen varias técnicas de *Reducción de la Dimensionalidad*, que como su propio nombre indica son algoritmos para reducir el número de características de nuestros datos a una cantidad manejable por los modelos de ML sin perder por el camino mucha información con el objetivo de obtener resultados similares a los que obtendríamos usando todas las *features*. Estas técnicas también son muy utilizadas para generar visualizaciones de los datos, útiles para descubrir patrones sencillos y comunicar conclusiones. En este post veremos algunas de estas técnicas y aplicaciones a ejemplos sencillos. ¡Vamos a ello!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "N-ptV5yKFU2g"
+ },
+ "source": [
+ "## Tipos de Técnicas de Reducción de la Dimensionalidad"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "JxrEcfTBFU2g"
+ },
+ "source": [
+ "Básicamente, existen dos técnicas para reducir la dimensionalidad de un dataset: la *Proyección* y el *Manifold Learning*. En muchos problemas reales las muestras de entrenamiento no se encuentran esparcidas de manera uniforme en todas sus dimensiones. Muchas de las características son constantes mientras que otras están altamente correlacionadas. Esto implica que las muestras de entrenamiento de un dataset suelen encontrarse en subespacios de baja dimensionalidad dentro del espacio de alta dimensionalidad original. La siguiente imagen ilustra este caso en un dataset tridimensional que, al ser proyectado en un subespacio bidimensional, sigue manteniendo la mayoría de la información.\n",
+ "\n",
+ " \n",
+ "\n",
+ "Sin embargo, hay ocasiones en las que la proyección no es la mejor alternativa ya que los datos pueden estar pleagdos en el espacio de alta dimensionalidad. En estos casos, técnicas de *manifold learning* permiten \"desdoblar\" estos datos para representarlos con menor dimension manteniendo la máxima información posible (como puedes ver en la siguiente figura).\n",
+ "\n",
+ " \n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "E_Rg9dg-FU2h"
+ },
+ "source": [
+ "## PCA"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "7eVM-5kZFU2h"
+ },
+ "source": [
+ "De entre las diferentes técnicas de reducción de la dimensionalidad, el PCA (*Principal Component Analysis* en inglés) es probablemente la más común. Es una técnica de proyección que consiste en encontrar el hyperplano de dimensión dada más cercano a los datos. Para ello, el algoritmo se basa en identificar el eje con mayor variancia en los datos de entrenamiento (llamado componente principal, o *princial component* en inglés). \n",
+ "\n",
+ "\n",
+ "\n",
+ "Para encontrar este componente principal se utiliza la técnica de factorización de matrices conocida como SVD (*Singular Value Decomposition*) que descompone la matriz de entrenamiento $\\bf{X}$ en la multiplicación de tres matrices $\\bf{U}$ $\\bf{\\Sigma}$ $\\bf{V}^T$, donde $\\bf{V}$ contiene los vectores unitarios que definen los componentes principales.\n",
+ "\n",
+ "$$\n",
+ " \\mathbf{V} = \\left( \n",
+ " \\begin{array}{cccc}\n",
+ " | & | & & | \\\\\n",
+ " c_1 & c_2 & ... & c_n \\\\\n",
+ " | & | & & | \n",
+ " \\end{array} \\right)\n",
+ "$$\n",
+ "\n",
+ "Una vez encontrados los componentes principales se puede reducir la dimensionalidad del dataset a un número de dimensiones $d$ mediante la proyección del mismo en el hyperplano definido por los primeros $d$ componentes principales.\n",
+ "\n",
+ "$$\n",
+ " \\mathbf{X}_d = \\mathbf{X} \\mathbf{W}_d\n",
+ "$$\n",
+ "\n",
+ "donde $\\mathbf{W}_d$ contiene las primeras $d$ columnas de $\\bf{V}$. Podemos recuperar el dataset original con la siguiente operación\n",
+ "\n",
+ "$$\n",
+ " \\mathbf{X} = \\mathbf{X}_d \\mathbf{W}_d^T\n",
+ "$$\n",
+ "\n",
+ "Aunque alguna información es perdida en el proceso."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "w9E28UYHFU2i"
+ },
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "\n",
+ "np.random.seed(4)\n",
+ "m = 60\n",
+ "w1, w2 = 0.1, 0.3\n",
+ "noise = 0.1\n",
+ "\n",
+ "angles = np.random.rand(m) * 3 * np.pi / 2 - 0.5\n",
+ "X = np.empty((m, 3))\n",
+ "X[:, 0] = np.cos(angles) + np.sin(angles)/2 + noise * np.random.randn(m) / 2\n",
+ "X[:, 1] = np.sin(angles) * 0.7 + noise * np.random.randn(m) / 2\n",
+ "X[:, 2] = X[:, 0] * w1 + X[:, 1] * w2 + noise * np.random.randn(m)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "VfQ8wpVnFU2j",
+ "outputId": "c8f542fc-3b0d-48d3-8614-09ebfbf13aef"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "28a331b4",
+ "metadata": {
+ "id": "28a331b4"
+ },
+ "source": [
+ "# Breve introducción a Python y Jupyter Notebooks\n",
+ "## [M.Sc. Ruben Quispe](https://www.linkedin.com/in/ruben-quispe-l/)\n",
+ "¡Bienvenido al primer laboratorio\n",
+ "Los laboratorios están disponibles para:\n",
+ "- proporcionar información\n",
+ "- reforzar el material de lectura con ejemplos prácticos\n",
+ "- proporcionar ejemplos prácticos de rutinas utilizadas en los laboratorios calificados"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "44e9d643",
+ "metadata": {
+ "id": "44e9d643"
+ },
+ "source": [
+ "## Objetivos\n",
+ "En este laboratorio, usted:\n",
+ "- Obtenga una breve introducción a los cuadernos Jupyter\n",
+ "- Haga un recorrido por los cuadernos de Jupyter\n",
+ "- Aprenda la diferencia entre celdas de descuento y celdas de código\n",
+ "- Practica algo básico de python\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "30941bf0",
+ "metadata": {
+ "id": "30941bf0"
+ },
+ "source": [
+ "La forma más fácil de familiarizarse con los notebooks de Jupyter es realizar el recorrido disponible arriba en el menú Ayuda:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bb6e5f41",
+ "metadata": {
+ "id": "bb6e5f41"
+ },
+ "source": [
+ "![missing](\"./images/C1W1L1_Tour.PNG\")
![missing](\"./images/C1W1L1_Markdown.PNG\")
\n",
+ "![](\"./images/C1W1L1_Run.PNG\")
\n",
+ "