aprendizaje_computacional.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Caso 2: Introducción conceptual al Aprendizaje Automático\n",
    "_Del curso \"Python y Machine Learning: de 0 a 100 con Reinforcement Learning\"_ <br/>\n",
    "_Impartido por MalagaAI, [Andrés Matesanz][mate] y [Joaquín Terrasa][quim]_ <br/>\n",
    "_27 de Marzo de 2020_ <br/>\n",
    "\n",
    "<small>Capítulo anterior (Introducción a Python): https://github.com/Matesanz/C0-intro-python</small>\n",
    "\n",
    "[quim]: https://twitter.com/josocjoq\n",
    "[mate]: https://twitter.com/AIMatesanz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "Vamos a ver brevemente los fundamentos del Aprendizaje Automático (AA) o *Machine Learning* (ML). Informalmente, entendemos como Inteligencia Artificial (IA) todo conjunto de técnicas que permiten a máquinas realizar tareas características del ser humano, como reconocimiento de imágenes o traducción entre lenguajes. Por ejemplo, los algoritmos definidos por reglas se consideran IA; aún así, éstos no aprenden por sí solos.\n",
    "\n",
    "El aprendizaje automático es una \"rama\" de la IA que agrupa **algoritmos que pueden aprender comportamientos sin ser explícitamente programados para ello**. Dentro del machine learning consideramos 3 categorías principales:\n",
    "\n",
    "<img src=\"https://i.imgur.com/RlvdIc1.jpg\" width=\"50%\"/>\n",
    "\n",
    "+ Aprendizaje **supervisado**: el algoritmo aprende **a partir de un conjunto de datos (*dataset*) etiquetados**. Por ejemplo, si la tarea es aprender a distinguir entre gatos y perros, el dataset son fotos de gatos etiquetadas con 'gato', y fotos de perros etiquetadas con 'perro'.\n",
    "+ Aprendizaje **no supervisado**: el algoritmo aprende **a partir de datos sin etiquetar**. Generalmente, se suelen usar para agrupar los datos en categorías. Un ejemplo es el algoritmo `k-medias` (imagen más abajo).\n",
    "+ Aprendizaje **por refuerzo**: el algoritmo aprende a partir de datos sin etiquetar, usando un **procedimiento de prueba y error**. Usando un mecanismo de aprendizaje disruptivo, permite aprender nuevos comportamientos, no solo limitados a los del ser humano, pues no aprende explícitamente de éstos. Por ello, tiene gran popularidad en algoritmos para superar a jugadores humanos.\n",
    "\n",
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/1/10/Iris_Flowers_Clustering_kMeans.svg/1920px-Iris_Flowers_Clustering_kMeans.svg.png\" width=\"30%\"/>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uno de los paquetes más útiles cuando comienzas a realizar *aprendizaje automático* en Python es [`scikit-learn`][web].\n",
    "\n",
    "<img src=\"https://miro.medium.com/max/1400/1*hjjC5Hi-PfEWLMEXHr6gdQ.png\" width=\"30%\"/>\n",
    "\n",
    "👉 [mas info][art] 👈\n",
    "\n",
    "[art]: https://code.tutsplus.com/es/tutorials/introduction-to-machine-learning-in-python--cms-30623\n",
    "[web]: https://scikit-learn.org/stable/index.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install sklearn\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import sklearn as sk\n",
    "import sklearn.datasets as _data\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\", category=DeprecationWarning)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sklearn.utils.Bunch"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "iris_raw = _data.load_iris()\n",
    "type(iris_raw)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'data': array([[5.1, 3.5, 1.4, 0.2],\n",
       "        [4.9, 3. , 1.4, 0.2],\n",
       "        [4.7, 3.2, 1.3, 0.2],\n",
       "        [4.6, 3.1, 1.5, 0.2],\n",
       "        [5. , 3.6, 1.4, 0.2],\n",
       "        [5.4, 3.9, 1.7, 0.4],\n",
       "        [4.6, 3.4, 1.4, 0.3],\n",
       "        [5. , 3.4, 1.5, 0.2],\n",
       "        [4.4, 2.9, 1.4, 0.2],\n",
       "        [4.9, 3.1, 1.5, 0.1],\n",
       "        [5.4, 3.7, 1.5, 0.2],\n",
       "        [4.8, 3.4, 1.6, 0.2],\n",
       "        [4.8, 3. , 1.4, 0.1],\n",
       "        [4.3, 3. , 1.1, 0.1],\n",
       "        [5.8, 4. , 1.2, 0.2],\n",
       "        [5.7, 4.4, 1.5, 0.4],\n",
       "        [5.4, 3.9, 1.3, 0.4],\n",
       "        [5.1, 3.5, 1.4, 0.3],\n",
       "        [5.7, 3.8, 1.7, 0.3],\n",
       "        [5.1, 3.8, 1.5, 0.3],\n",
       "        [5.4, 3.4, 1.7, 0.2],\n",
       "        [5.1, 3.7, 1.5, 0.4],\n",
       "        [4.6, 3.6, 1. , 0.2],\n",
       "        [5.1, 3.3, 1.7, 0.5],\n",
       "        [4.8, 3.4, 1.9, 0.2],\n",
       "        [5. , 3. , 1.6, 0.2],\n",
       "        [5. , 3.4, 1.6, 0.4],\n",
       "        [5.2, 3.5, 1.5, 0.2],\n",
       "        [5.2, 3.4, 1.4, 0.2],\n",
       "        [4.7, 3.2, 1.6, 0.2],\n",
       "        [4.8, 3.1, 1.6, 0.2],\n",
       "        [5.4, 3.4, 1.5, 0.4],\n",
       "        [5.2, 4.1, 1.5, 0.1],\n",
       "        [5.5, 4.2, 1.4, 0.2],\n",
       "        [4.9, 3.1, 1.5, 0.2],\n",
       "        [5. , 3.2, 1.2, 0.2],\n",
       "        [5.5, 3.5, 1.3, 0.2],\n",
       "        [4.9, 3.6, 1.4, 0.1],\n",
       "        [4.4, 3. , 1.3, 0.2],\n",
       "        [5.1, 3.4, 1.5, 0.2],\n",
       "        [5. , 3.5, 1.3, 0.3],\n",
       "        [4.5, 2.3, 1.3, 0.3],\n",
       "        [4.4, 3.2, 1.3, 0.2],\n",
       "        [5. , 3.5, 1.6, 0.6],\n",
       "        [5.1, 3.8, 1.9, 0.4],\n",
       "        [4.8, 3. , 1.4, 0.3],\n",
       "        [5.1, 3.8, 1.6, 0.2],\n",
       "        [4.6, 3.2, 1.4, 0.2],\n",
       "        [5.3, 3.7, 1.5, 0.2],\n",
       "        [5. , 3.3, 1.4, 0.2],\n",
       "        [7. , 3.2, 4.7, 1.4],\n",
       "        [6.4, 3.2, 4.5, 1.5],\n",
       "        [6.9, 3.1, 4.9, 1.5],\n",
       "        [5.5, 2.3, 4. , 1.3],\n",
       "        [6.5, 2.8, 4.6, 1.5],\n",
       "        [5.7, 2.8, 4.5, 1.3],\n",
       "        [6.3, 3.3, 4.7, 1.6],\n",
       "        [4.9, 2.4, 3.3, 1. ],\n",
       "        [6.6, 2.9, 4.6, 1.3],\n",
       "        [5.2, 2.7, 3.9, 1.4],\n",
       "        [5. , 2. , 3.5, 1. ],\n",
       "        [5.9, 3. , 4.2, 1.5],\n",
       "        [6. , 2.2, 4. , 1. ],\n",
       "        [6.1, 2.9, 4.7, 1.4],\n",
       "        [5.6, 2.9, 3.6, 1.3],\n",
       "        [6.7, 3.1, 4.4, 1.4],\n",
       "        [5.6, 3. , 4.5, 1.5],\n",
       "        [5.8, 2.7, 4.1, 1. ],\n",
       "        [6.2, 2.2, 4.5, 1.5],\n",
       "        [5.6, 2.5, 3.9, 1.1],\n",
       "        [5.9, 3.2, 4.8, 1.8],\n",
       "        [6.1, 2.8, 4. , 1.3],\n",
       "        [6.3, 2.5, 4.9, 1.5],\n",
       "        [6.1, 2.8, 4.7, 1.2],\n",
       "        [6.4, 2.9, 4.3, 1.3],\n",
       "        [6.6, 3. , 4.4, 1.4],\n",
       "        [6.8, 2.8, 4.8, 1.4],\n",
       "        [6.7, 3. , 5. , 1.7],\n",
       "        [6. , 2.9, 4.5, 1.5],\n",
       "        [5.7, 2.6, 3.5, 1. ],\n",
       "        [5.5, 2.4, 3.8, 1.1],\n",
       "        [5.5, 2.4, 3.7, 1. ],\n",
       "        [5.8, 2.7, 3.9, 1.2],\n",
       "        [6. , 2.7, 5.1, 1.6],\n",
       "        [5.4, 3. , 4.5, 1.5],\n",
       "        [6. , 3.4, 4.5, 1.6],\n",
       "        [6.7, 3.1, 4.7, 1.5],\n",
       "        [6.3, 2.3, 4.4, 1.3],\n",
       "        [5.6, 3. , 4.1, 1.3],\n",
       "        [5.5, 2.5, 4. , 1.3],\n",
       "        [5.5, 2.6, 4.4, 1.2],\n",
       "        [6.1, 3. , 4.6, 1.4],\n",
       "        [5.8, 2.6, 4. , 1.2],\n",
       "        [5. , 2.3, 3.3, 1. ],\n",
       "        [5.6, 2.7, 4.2, 1.3],\n",
       "        [5.7, 3. , 4.2, 1.2],\n",
       "        [5.7, 2.9, 4.2, 1.3],\n",
       "        [6.2, 2.9, 4.3, 1.3],\n",
       "        [5.1, 2.5, 3. , 1.1],\n",
       "        [5.7, 2.8, 4.1, 1.3],\n",
       "        [6.3, 3.3, 6. , 2.5],\n",
       "        [5.8, 2.7, 5.1, 1.9],\n",
       "        [7.1, 3. , 5.9, 2.1],\n",
       "        [6.3, 2.9, 5.6, 1.8],\n",
       "        [6.5, 3. , 5.8, 2.2],\n",
       "        [7.6, 3. , 6.6, 2.1],\n",
       "        [4.9, 2.5, 4.5, 1.7],\n",
       "        [7.3, 2.9, 6.3, 1.8],\n",
       "        [6.7, 2.5, 5.8, 1.8],\n",
       "        [7.2, 3.6, 6.1, 2.5],\n",
       "        [6.5, 3.2, 5.1, 2. ],\n",
       "        [6.4, 2.7, 5.3, 1.9],\n",
       "        [6.8, 3. , 5.5, 2.1],\n",
       "        [5.7, 2.5, 5. , 2. ],\n",
       "        [5.8, 2.8, 5.1, 2.4],\n",
       "        [6.4, 3.2, 5.3, 2.3],\n",
       "        [6.5, 3. , 5.5, 1.8],\n",
       "        [7.7, 3.8, 6.7, 2.2],\n",
       "        [7.7, 2.6, 6.9, 2.3],\n",
       "        [6. , 2.2, 5. , 1.5],\n",
       "        [6.9, 3.2, 5.7, 2.3],\n",
       "        [5.6, 2.8, 4.9, 2. ],\n",
       "        [7.7, 2.8, 6.7, 2. ],\n",
       "        [6.3, 2.7, 4.9, 1.8],\n",
       "        [6.7, 3.3, 5.7, 2.1],\n",
       "        [7.2, 3.2, 6. , 1.8],\n",
       "        [6.2, 2.8, 4.8, 1.8],\n",
       "        [6.1, 3. , 4.9, 1.8],\n",
       "        [6.4, 2.8, 5.6, 2.1],\n",
       "        [7.2, 3. , 5.8, 1.6],\n",
       "        [7.4, 2.8, 6.1, 1.9],\n",
       "        [7.9, 3.8, 6.4, 2. ],\n",
       "        [6.4, 2.8, 5.6, 2.2],\n",
       "        [6.3, 2.8, 5.1, 1.5],\n",
       "        [6.1, 2.6, 5.6, 1.4],\n",
       "        [7.7, 3. , 6.1, 2.3],\n",
       "        [6.3, 3.4, 5.6, 2.4],\n",
       "        [6.4, 3.1, 5.5, 1.8],\n",
       "        [6. , 3. , 4.8, 1.8],\n",
       "        [6.9, 3.1, 5.4, 2.1],\n",
       "        [6.7, 3.1, 5.6, 2.4],\n",
       "        [6.9, 3.1, 5.1, 2.3],\n",
       "        [5.8, 2.7, 5.1, 1.9],\n",
       "        [6.8, 3.2, 5.9, 2.3],\n",
       "        [6.7, 3.3, 5.7, 2.5],\n",
       "        [6.7, 3. , 5.2, 2.3],\n",
       "        [6.3, 2.5, 5. , 1.9],\n",
       "        [6.5, 3. , 5.2, 2. ],\n",
       "        [6.2, 3.4, 5.4, 2.3],\n",
       "        [5.9, 3. , 5.1, 1.8]]),\n",
       " 'target': array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "        0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n",
       "        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n",
       "        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]),\n",
       " 'target_names': array(['setosa', 'versicolor', 'virginica'], dtype='<U10'),\n",
       " 'DESCR': '.. _iris_dataset:\\n\\nIris plants dataset\\n--------------------\\n\\n**Data Set Characteristics:**\\n\\n    :Number of Instances: 150 (50 in each of three classes)\\n    :Number of Attributes: 4 numeric, predictive attributes and the class\\n    :Attribute Information:\\n        - sepal length in cm\\n        - sepal width in cm\\n        - petal length in cm\\n        - petal width in cm\\n        - class:\\n                - Iris-Setosa\\n                - Iris-Versicolour\\n                - Iris-Virginica\\n                \\n    :Summary Statistics:\\n\\n    ============== ==== ==== ======= ===== ====================\\n                    Min  Max   Mean    SD   Class Correlation\\n    ============== ==== ==== ======= ===== ====================\\n    sepal length:   4.3  7.9   5.84   0.83    0.7826\\n    sepal width:    2.0  4.4   3.05   0.43   -0.4194\\n    petal length:   1.0  6.9   3.76   1.76    0.9490  (high!)\\n    petal width:    0.1  2.5   1.20   0.76    0.9565  (high!)\\n    ============== ==== ==== ======= ===== ====================\\n\\n    :Missing Attribute Values: None\\n    :Class Distribution: 33.3% for each of 3 classes.\\n    :Creator: R.A. Fisher\\n    :Donor: Michael Marshall (MARSHALL%PLU@io.arc.nasa.gov)\\n    :Date: July, 1988\\n\\nThe famous Iris database, first used by Sir R.A. Fisher. The dataset is taken\\nfrom Fisher\\'s paper. Note that it\\'s the same as in R, but not as in the UCI\\nMachine Learning Repository, which has two wrong data points.\\n\\nThis is perhaps the best known database to be found in the\\npattern recognition literature.  Fisher\\'s paper is a classic in the field and\\nis referenced frequently to this day.  (See Duda & Hart, for example.)  The\\ndata set contains 3 classes of 50 instances each, where each class refers to a\\ntype of iris plant.  One class is linearly separable from the other 2; the\\nlatter are NOT linearly separable from each other.\\n\\n.. topic:: References\\n\\n   - Fisher, R.A. \"The use of multiple measurements in taxonomic problems\"\\n     Annual Eugenics, 7, Part II, 179-188 (1936); also in \"Contributions to\\n     Mathematical Statistics\" (John Wiley, NY, 1950).\\n   - Duda, R.O., & Hart, P.E. (1973) Pattern Classification and Scene Analysis.\\n     (Q327.D83) John Wiley & Sons.  ISBN 0-471-22361-1.  See page 218.\\n   - Dasarathy, B.V. (1980) \"Nosing Around the Neighborhood: A New System\\n     Structure and Classification Rule for Recognition in Partially Exposed\\n     Environments\".  IEEE Transactions on Pattern Analysis and Machine\\n     Intelligence, Vol. PAMI-2, No. 1, 67-71.\\n   - Gates, G.W. (1972) \"The Reduced Nearest Neighbor Rule\".  IEEE Transactions\\n     on Information Theory, May 1972, 431-433.\\n   - See also: 1988 MLC Proceedings, 54-64.  Cheeseman et al\"s AUTOCLASS II\\n     conceptual clustering system finds 3 classes in the data.\\n   - Many, many more ...',\n",
       " 'feature_names': ['sepal length (cm)',\n",
       "  'sepal width (cm)',\n",
       "  'petal length (cm)',\n",
       "  'petal width (cm)'],\n",
       " 'filename': 'c:\\\\users\\\\pachacho\\\\miniconda3\\\\envs\\\\pycourse\\\\lib\\\\site-packages\\\\sklearn\\\\datasets\\\\data\\\\iris.csv'}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "iris_raw"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([], <a list of 0 Text major ticklabel objects>)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "X = iris_raw.data[:, :2]  # we only take the first two features.\n",
    "y = iris_raw.target\n",
    "\n",
    "x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5\n",
    "y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5\n",
    "\n",
    "plt.figure(2, figsize=(8, 6))\n",
    "plt.clf()\n",
    "\n",
    "# Plot the training points\n",
    "plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Set1,\n",
    "            edgecolor='k')\n",
    "plt.xlabel('Sepal length')\n",
    "plt.ylabel('Sepal width')\n",
    "\n",
    "plt.xlim(x_min, x_max)\n",
    "plt.ylim(y_min, y_max)\n",
    "plt.xticks(())\n",
    "plt.yticks(())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal_length</th>\n",
       "      <th>sepal_width</th>\n",
       "      <th>petal_length</th>\n",
       "      <th>petal_width</th>\n",
       "      <th>species</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   sepal_length  sepal_width  petal_length  petal_width  species\n",
       "0           5.1          3.5           1.4          0.2        0\n",
       "1           4.9          3.0           1.4          0.2        0\n",
       "2           4.7          3.2           1.3          0.2        0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "iris = pd.DataFrame(iris_raw[\"data\"], columns=[\"sepal_length\", \"sepal_width\", \"petal_length\", \"petal_width\"])\n",
    "iris[\"species\"] = iris_raw[\"target\"]\n",
    "\n",
    "iris.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal_length</th>\n",
       "      <th>sepal_width</th>\n",
       "      <th>petal_length</th>\n",
       "      <th>petal_width</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>species</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.006</td>\n",
       "      <td>3.428</td>\n",
       "      <td>1.462</td>\n",
       "      <td>0.246</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5.936</td>\n",
       "      <td>2.770</td>\n",
       "      <td>4.260</td>\n",
       "      <td>1.326</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>6.588</td>\n",
       "      <td>2.974</td>\n",
       "      <td>5.552</td>\n",
       "      <td>2.026</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         sepal_length  sepal_width  petal_length  petal_width\n",
       "species                                                      \n",
       "0               5.006        3.428         1.462        0.246\n",
       "1               5.936        2.770         4.260        1.326\n",
       "2               6.588        2.974         5.552        2.026"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "iris.groupby(\"species\").mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal_length</th>\n",
       "      <th>sepal_width</th>\n",
       "      <th>petal_length</th>\n",
       "      <th>petal_width</th>\n",
       "      <th>species</th>\n",
       "      <th>species_name</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   sepal_length  sepal_width  petal_length  petal_width  species species_name\n",
       "0           5.1          3.5           1.4          0.2        0       setosa\n",
       "1           4.9          3.0           1.4          0.2        0       setosa\n",
       "2           4.7          3.2           1.3          0.2        0       setosa"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def map_category_to_name(species_class):\n",
    "    return {\n",
    "        0: \"setosa\",\n",
    "        1: \"versicolor\",\n",
    "        2: \"virginica\"\n",
    "    }.get(species_class)\n",
    "\n",
    "iris[\"species_name\"] = iris[\"species\"].apply(map_category_to_name)\n",
    "\n",
    "iris.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Familias de algoritmos\n",
    "\n",
    "+ *Support Vector Machines (SVM)*: [aplicados al dataset Iris](https://scikit-learn.org/stable/auto_examples/svm/plot_iris_svc.html).\n",
    "+ Regresión Logística: [aplicada a Iris](https://github.com/VictorMotogna/IrisLogisticRegression).\n",
    "+ *K-Nearest Neighbors*: [aplicado a Iris](). ¿Más info de cómo funciona? [aquí](https://www.cs.us.es/cursos/rac-2017/temas/tema-02.pdf).\n",
    "+ XGBoost: [aplicado a Iris](https://www.kdnuggets.com/2017/03/simple-xgboost-tutorial-iris-dataset.html).\n",
    "+ Red Neuronal Simple: [aplicada a Iris](https://www.bogotobogo.com/python/scikit-learn/Perceptron_Model_with_Iris_DataSet.php).\n",
    "+ *K-Means*: [aplicada a Iris](https://heartbeat.fritz.ai/k-means-clustering-using-sklearn-and-python-4a054d67b187).\n",
    "\n",
    "A continuación hay varios algoritmos escogidos del conjunto de ejemplos de `sklearn`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Agrupamiento jerárquico (*Hierarchical clustering*)\n",
    "\n",
    "*It is a general family of clustering algorithms that build nested clusters by merging or splitting them successively. This hierarchy of clusters is represented as a tree (or dendrogram)*:\n",
    "\n",
    "https://scikit-learn.org/stable/modules/clustering.html#hierarchical-clustering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "from scipy.cluster.hierarchy import dendrogram\n",
    "from sklearn.datasets import load_iris\n",
    "from sklearn.cluster import AgglomerativeClustering\n",
    "\n",
    "\n",
    "def plot_dendrogram(model, **kwargs):\n",
    "    # Create linkage matrix and then plot the dendrogram\n",
    "\n",
    "    # create the counts of samples under each node\n",
    "    counts = np.zeros(model.children_.shape[0])\n",
    "    n_samples = len(model.labels_)\n",
    "    for i, merge in enumerate(model.children_):\n",
    "        current_count = 0\n",
    "        for child_idx in merge:\n",
    "            if child_idx < n_samples:\n",
    "                current_count += 1  # leaf node\n",
    "            else:\n",
    "                current_count += counts[child_idx - n_samples]\n",
    "        counts[i] = current_count\n",
    "\n",
    "    linkage_matrix = np.column_stack([model.children_, model.distances_,\n",
    "                                      counts]).astype(float)\n",
    "\n",
    "    # Plot the corresponding dendrogram\n",
    "    dendrogram(linkage_matrix, **kwargs)\n",
    "\n",
    "\n",
    "iris = load_iris()\n",
    "X = iris.data\n",
    "\n",
    "# setting distance_threshold=0 ensures we compute the full tree.\n",
    "model = AgglomerativeClustering(distance_threshold=0, n_clusters=None)\n",
    "\n",
    "model = model.fit(X)\n",
    "plt.title('Hierarchical Clustering Dendrogram')\n",
    "# plot the top three levels of the dendrogram\n",
    "plot_dendrogram(model, truncate_mode='level', p=3)\n",
    "plt.xlabel(\"Number of points in node (or index of point if no parenthesis).\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Árboles de decisión\n",
    "\n",
    "*Decision Trees (DTs) are a non-parametric supervised learning method used for classification and regression. The goal is to create a model that predicts the value of a target variable by learning simple decision rules inferred from the data features:*\n",
    "\n",
    "https://scikit-learn.org/stable/modules/tree.html#tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.datasets import load_iris\n",
    "from sklearn.tree import DecisionTreeClassifier, plot_tree\n",
    "\n",
    "# Parameters\n",
    "n_classes = 3\n",
    "plot_colors = \"ryb\"\n",
    "plot_step = 0.02\n",
    "\n",
    "# Load data\n",
    "iris = load_iris()\n",
    "\n",
    "for pairidx, pair in enumerate([[0, 1], [0, 2], [0, 3],\n",
    "                                [1, 2], [1, 3], [2, 3]]):\n",
    "    # We only take the two corresponding features\n",
    "    X = iris.data[:, pair]\n",
    "    y = iris.target\n",
    "\n",
    "    # Train\n",
    "    clf = DecisionTreeClassifier().fit(X, y)\n",
    "\n",
    "    # Plot the decision boundary\n",
    "    plt.subplot(2, 3, pairidx + 1)\n",
    "\n",
    "    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1\n",
    "    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1\n",
    "    xx, yy = np.meshgrid(np.arange(x_min, x_max, plot_step),\n",
    "                         np.arange(y_min, y_max, plot_step))\n",
    "    plt.tight_layout(h_pad=0.5, w_pad=0.5, pad=2.5)\n",
    "\n",
    "    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])\n",
    "    Z = Z.reshape(xx.shape)\n",
    "    cs = plt.contourf(xx, yy, Z, cmap=plt.cm.RdYlBu)\n",
    "\n",
    "    plt.xlabel(iris.feature_names[pair[0]])\n",
    "    plt.ylabel(iris.feature_names[pair[1]])\n",
    "\n",
    "    # Plot the training points\n",
    "    for i, color in zip(range(n_classes), plot_colors):\n",
    "        idx = np.where(y == i)\n",
    "        plt.scatter(X[idx, 0], X[idx, 1], c=color, label=iris.target_names[i],\n",
    "                    cmap=plt.cm.RdYlBu, edgecolor='black', s=15)\n",
    "\n",
    "plt.suptitle(\"Decision surface of a decision tree using paired features\")\n",
    "plt.legend(loc='lower right', borderpad=0, handletextpad=0)\n",
    "plt.axis(\"tight\")\n",
    "\n",
    "plt.figure()\n",
    "clf = DecisionTreeClassifier().fit(iris.data, iris.target)\n",
    "plot_tree(clf, filled=True)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Support Vector Machines\n",
    "\n",
    "*Support vector machines (SVMs) are a set of supervised learning methods. They bring the following advantages to ML:*\n",
    "\n",
    "+ *Effective in high dimensional spaces.*\n",
    "+ *Still effective in cases where number of dimensions is greater than the number of samples.*\n",
    "+ *Uses a subset of training points in the decision function (called support vectors), so it is also memory efficient.*\n",
    "+ *Versatile: different Kernel functions can be specified for the decision function. Common kernels are provided, but it is also possible to specify custom kernels.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn import svm, datasets\n",
    "\n",
    "\n",
    "def make_meshgrid(x, y, h=.02):\n",
    "    \"\"\"Create a mesh of points to plot in\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    x: data to base x-axis meshgrid on\n",
    "    y: data to base y-axis meshgrid on\n",
    "    h: stepsize for meshgrid, optional\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    xx, yy : ndarray\n",
    "    \"\"\"\n",
    "    x_min, x_max = x.min() - 1, x.max() + 1\n",
    "    y_min, y_max = y.min() - 1, y.max() + 1\n",
    "    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),\n",
    "                         np.arange(y_min, y_max, h))\n",
    "    return xx, yy\n",
    "\n",
    "\n",
    "def plot_contours(ax, clf, xx, yy, **params):\n",
    "    \"\"\"Plot the decision boundaries for a classifier.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    ax: matplotlib axes object\n",
    "    clf: a classifier\n",
    "    xx: meshgrid ndarray\n",
    "    yy: meshgrid ndarray\n",
    "    params: dictionary of params to pass to contourf, optional\n",
    "    \"\"\"\n",
    "    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])\n",
    "    Z = Z.reshape(xx.shape)\n",
    "    out = ax.contourf(xx, yy, Z, **params)\n",
    "    return out\n",
    "\n",
    "\n",
    "# import some data to play with\n",
    "iris = datasets.load_iris()\n",
    "# Take the first two features. We could avoid this by using a two-dim dataset\n",
    "X = iris.data[:, :2]\n",
    "y = iris.target\n",
    "\n",
    "# we create an instance of SVM and fit out data. We do not scale our\n",
    "# data since we want to plot the support vectors\n",
    "C = 1.0  # SVM regularization parameter\n",
    "models = (svm.SVC(kernel='linear', C=C),\n",
    "          svm.LinearSVC(C=C, max_iter=10000),\n",
    "          svm.SVC(kernel='rbf', gamma=0.7, C=C),\n",
    "          svm.SVC(kernel='poly', degree=3, gamma='auto', C=C))\n",
    "models = (clf.fit(X, y) for clf in models)\n",
    "\n",
    "# title for the plots\n",
    "titles = ('SVC with linear kernel',\n",
    "          'LinearSVC (linear kernel)',\n",
    "          'SVC with RBF kernel',\n",
    "          'SVC with polynomial (degree 3) kernel')\n",
    "\n",
    "# Set-up 2x2 grid for plotting.\n",
    "fig, sub = plt.subplots(2, 2)\n",
    "plt.subplots_adjust(wspace=0.4, hspace=0.4)\n",
    "\n",
    "X0, X1 = X[:, 0], X[:, 1]\n",
    "xx, yy = make_meshgrid(X0, X1)\n",
    "\n",
    "for clf, title, ax in zip(models, titles, sub.flatten()):\n",
    "    plot_contours(ax, clf, xx, yy,\n",
    "                  cmap=plt.cm.coolwarm, alpha=0.8)\n",
    "    ax.scatter(X0, X1, c=y, cmap=plt.cm.coolwarm, s=20, edgecolors='k')\n",
    "    ax.set_xlim(xx.min(), xx.max())\n",
    "    ax.set_ylim(yy.min(), yy.max())\n",
    "    ax.set_xlabel('Sepal length')\n",
    "    ax.set_ylabel('Sepal width')\n",
    "    ax.set_xticks(())\n",
    "    ax.set_yticks(())\n",
    "    ax.set_title(title)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Perceptrón Simple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris = datasets.load_iris()\n",
    "\n",
    "X = iris.data[:, [2, 3]]\n",
    "y = iris.target"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "+ **Selección de los datos de entrenamiento** (70% aquí) **y datos de prueba** (30% aquí)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 105 samples in the training set and 45 samples in the test set\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)  # aqui se escogen\n",
    "\n",
    "print('There are {} samples in the training set and {} samples in the test set'.format(\n",
    "X_train.shape[0], X_test.shape[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "+ **Pre-procesamiento** de los datos (en este caso, **normalización con media 0 y varianza unitaria**. <br/> [saber más](https://scikit-learn.org/stable/modules/preprocessing.html) 🔥🔥"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "sc = StandardScaler()\n",
    "\n",
    "sc.fit(X_train)\n",
    "\n",
    "X_train_std = sc.transform(X_train)\n",
    "X_test_std = sc.transform(X_test)\n",
    "\n",
    "X_combined_std = np.vstack((X_train_std, X_test_std))\n",
    "y_combined = np.hstack((y_train, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "'c' argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with 'x' & 'y'.  Please use a 2-D array with a single row if you really want to specify the same RGB or RGBA value for all points.\n",
      "'c' argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with 'x' & 'y'.  Please use a 2-D array with a single row if you really want to specify the same RGB or RGBA value for all points.\n",
      "'c' argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with 'x' & 'y'.  Please use a 2-D array with a single row if you really want to specify the same RGB or RGBA value for all points.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.colors import ListedColormap\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "markers = ('s', 'x', 'o')\n",
    "colors = ('red', 'blue', 'lightgreen')\n",
    "cmap = ListedColormap(colors[:len(np.unique(y_test))])\n",
    "for idx, cl in enumerate(np.unique(y)):\n",
    "    plt.scatter(x=X[y == cl, 0], y=X[y == cl, 1],\n",
    "               c=cmap(idx), marker=markers[idx], label=cl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Perceptron in module sklearn.linear_model._perceptron:\n",
      "\n",
      "class Perceptron(sklearn.linear_model._stochastic_gradient.BaseSGDClassifier)\n",
      " |  Perceptron(penalty=None, alpha=0.0001, fit_intercept=True, max_iter=1000, tol=0.001, shuffle=True, verbose=0, eta0=1.0, n_jobs=None, random_state=0, early_stopping=False, validation_fraction=0.1, n_iter_no_change=5, class_weight=None, warm_start=False)\n",
      " |  \n",
      " |  Perceptron\n",
      " |  \n",
      " |  Read more in the :ref:`User Guide <perceptron>`.\n",
      " |  \n",
      " |  Parameters\n",
      " |  ----------\n",
      " |  \n",
      " |  penalty : {'l2','l1','elasticnet'}, default=None\n",
      " |      The penalty (aka regularization term) to be used.\n",
      " |  \n",
      " |  alpha : float, default=0.0001\n",
      " |      Constant that multiplies the regularization term if regularization is\n",
      " |      used.\n",
      " |  \n",
      " |  fit_intercept : bool, default=True\n",
      " |      Whether the intercept should be estimated or not. If False, the\n",
      " |      data is assumed to be already centered.\n",
      " |  \n",
      " |  max_iter : int, default=1000\n",
      " |      The maximum number of passes over the training data (aka epochs).\n",
      " |      It only impacts the behavior in the ``fit`` method, and not the\n",
      " |      :meth:`partial_fit` method.\n",
      " |  \n",
      " |      .. versionadded:: 0.19\n",
      " |  \n",
      " |  tol : float, default=1e-3\n",
      " |      The stopping criterion. If it is not None, the iterations will stop\n",
      " |      when (loss > previous_loss - tol).\n",
      " |  \n",
      " |      .. versionadded:: 0.19\n",
      " |  \n",
      " |  shuffle : bool, default=True\n",
      " |      Whether or not the training data should be shuffled after each epoch.\n",
      " |  \n",
      " |  verbose : int, default=0\n",
      " |      The verbosity level\n",
      " |  \n",
      " |  eta0 : double, default=1\n",
      " |      Constant by which the updates are multiplied.\n",
      " |  \n",
      " |  n_jobs : int, default=None\n",
      " |      The number of CPUs to use to do the OVA (One Versus All, for\n",
      " |      multi-class problems) computation.\n",
      " |      ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.\n",
      " |      ``-1`` means using all processors. See :term:`Glossary <n_jobs>`\n",
      " |      for more details.\n",
      " |  \n",
      " |  random_state : int, RandomState instance, default=None\n",
      " |      The seed of the pseudo random number generator to use when shuffling\n",
      " |      the data.  If int, random_state is the seed used by the random number\n",
      " |      generator; If RandomState instance, random_state is the random number\n",
      " |      generator; If None, the random number generator is the RandomState\n",
      " |      instance used by `np.random`.\n",
      " |  \n",
      " |  early_stopping : bool, default=False\n",
      " |      Whether to use early stopping to terminate training when validation.\n",
      " |      score is not improving. If set to True, it will automatically set aside\n",
      " |      a stratified fraction of training data as validation and terminate\n",
      " |      training when validation score is not improving by at least tol for\n",
      " |      n_iter_no_change consecutive epochs.\n",
      " |  \n",
      " |      .. versionadded:: 0.20\n",
      " |  \n",
      " |  validation_fraction : float, default=0.1\n",
      " |      The proportion of training data to set aside as validation set for\n",
      " |      early stopping. Must be between 0 and 1.\n",
      " |      Only used if early_stopping is True.\n",
      " |  \n",
      " |      .. versionadded:: 0.20\n",
      " |  \n",
      " |  n_iter_no_change : int, default=5\n",
      " |      Number of iterations with no improvement to wait before early stopping.\n",
      " |  \n",
      " |      .. versionadded:: 0.20\n",
      " |  \n",
      " |  class_weight : dict, {class_label: weight} or \"balanced\", default=None\n",
      " |      Preset for the class_weight fit parameter.\n",
      " |  \n",
      " |      Weights associated with classes. If not given, all classes\n",
      " |      are supposed to have weight one.\n",
      " |  \n",
      " |      The \"balanced\" mode uses the values of y to automatically adjust\n",
      " |      weights inversely proportional to class frequencies in the input data\n",
      " |      as ``n_samples / (n_classes * np.bincount(y))``\n",
      " |  \n",
      " |  warm_start : bool, default=False\n",
      " |      When set to True, reuse the solution of the previous call to fit as\n",
      " |      initialization, otherwise, just erase the previous solution. See\n",
      " |      :term:`the Glossary <warm_start>`.\n",
      " |  \n",
      " |  Attributes\n",
      " |  ----------\n",
      " |  coef_ : ndarray of shape = [1, n_features] if n_classes == 2 else         [n_classes, n_features]\n",
      " |      Weights assigned to the features.\n",
      " |  \n",
      " |  intercept_ : ndarray of shape = [1] if n_classes == 2 else [n_classes]\n",
      " |      Constants in decision function.\n",
      " |  \n",
      " |  n_iter_ : int\n",
      " |      The actual number of iterations to reach the stopping criterion.\n",
      " |      For multiclass fits, it is the maximum over every binary fit.\n",
      " |  \n",
      " |  classes_ : ndarray of shape (n_classes,)\n",
      " |      The unique classes labels.\n",
      " |  \n",
      " |  t_ : int\n",
      " |      Number of weight updates performed during training.\n",
      " |      Same as ``(n_iter_ * n_samples)``.\n",
      " |  \n",
      " |  Notes\n",
      " |  -----\n",
      " |  \n",
      " |  ``Perceptron`` is a classification algorithm which shares the same\n",
      " |  underlying implementation with ``SGDClassifier``. In fact,\n",
      " |  ``Perceptron()`` is equivalent to `SGDClassifier(loss=\"perceptron\",\n",
      " |  eta0=1, learning_rate=\"constant\", penalty=None)`.\n",
      " |  \n",
      " |  Examples\n",
      " |  --------\n",
      " |  >>> from sklearn.datasets import load_digits\n",
      " |  >>> from sklearn.linear_model import Perceptron\n",
      " |  >>> X, y = load_digits(return_X_y=True)\n",
      " |  >>> clf = Perceptron(tol=1e-3, random_state=0)\n",
      " |  >>> clf.fit(X, y)\n",
      " |  Perceptron()\n",
      " |  >>> clf.score(X, y)\n",
      " |  0.939...\n",
      " |  \n",
      " |  See also\n",
      " |  --------\n",
      " |  \n",
      " |  SGDClassifier\n",
      " |  \n",
      " |  References\n",
      " |  ----------\n",
      " |  \n",
      " |  https://en.wikipedia.org/wiki/Perceptron and references therein.\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      Perceptron\n",
      " |      sklearn.linear_model._stochastic_gradient.BaseSGDClassifier\n",
      " |      sklearn.linear_model._base.LinearClassifierMixin\n",
      " |      sklearn.base.ClassifierMixin\n",
      " |      sklearn.linear_model._stochastic_gradient.BaseSGD\n",
      " |      sklearn.linear_model._base.SparseCoefMixin\n",
      " |      sklearn.base.BaseEstimator\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, penalty=None, alpha=0.0001, fit_intercept=True, max_iter=1000, tol=0.001, shuffle=True, verbose=0, eta0=1.0, n_jobs=None, random_state=0, early_stopping=False, validation_fraction=0.1, n_iter_no_change=5, class_weight=None, warm_start=False)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __abstractmethods__ = frozenset()\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sklearn.linear_model._stochastic_gradient.BaseSGDClassifier:\n",
      " |  \n",
      " |  fit(self, X, y, coef_init=None, intercept_init=None, sample_weight=None)\n",
      " |      Fit linear model with Stochastic Gradient Descent.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      X : {array-like, sparse matrix}, shape (n_samples, n_features)\n",
      " |          Training data.\n",
      " |      \n",
      " |      y : ndarray of shape (n_samples,)\n",
      " |          Target values.\n",
      " |      \n",
      " |      coef_init : ndarray of shape (n_classes, n_features), default=None\n",
      " |          The initial coefficients to warm-start the optimization.\n",
      " |      \n",
      " |      intercept_init : ndarray of shape (n_classes,), default=None\n",
      " |          The initial intercept to warm-start the optimization.\n",
      " |      \n",
      " |      sample_weight : array-like, shape (n_samples,), default=None\n",
      " |          Weights applied to individual samples.\n",
      " |          If not provided, uniform weights are assumed. These weights will\n",
      " |          be multiplied with class_weight (passed through the\n",
      " |          constructor) if class_weight is specified.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      self :\n",
      " |          Returns an instance of self.\n",
      " |  \n",
      " |  partial_fit(self, X, y, classes=None, sample_weight=None)\n",
      " |      Perform one epoch of stochastic gradient descent on given samples.\n",
      " |      \n",
      " |      Internally, this method uses ``max_iter = 1``. Therefore, it is not\n",
      " |      guaranteed that a minimum of the cost function is reached after calling\n",
      " |      it once. Matters such as objective convergence and early stopping\n",
      " |      should be handled by the user.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      X : {array-like, sparse matrix}, shape (n_samples, n_features)\n",
      " |          Subset of the training data.\n",
      " |      \n",
      " |      y : ndarray of shape (n_samples,)\n",
      " |          Subset of the target values.\n",
      " |      \n",
      " |      classes : ndarray of shape (n_classes,), default=None\n",
      " |          Classes across all calls to partial_fit.\n",
      " |          Can be obtained by via `np.unique(y_all)`, where y_all is the\n",
      " |          target vector of the entire dataset.\n",
      " |          This argument is required for the first call to partial_fit\n",
      " |          and can be omitted in the subsequent calls.\n",
      " |          Note that y doesn't need to contain all labels in `classes`.\n",
      " |      \n",
      " |      sample_weight : array-like, shape (n_samples,), default=None\n",
      " |          Weights applied to individual samples.\n",
      " |          If not provided, uniform weights are assumed.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      self :\n",
      " |          Returns an instance of self.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sklearn.linear_model._stochastic_gradient.BaseSGDClassifier:\n",
      " |  \n",
      " |  loss_functions = {'epsilon_insensitive': (<class 'sklearn.linear_model...\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sklearn.linear_model._base.LinearClassifierMixin:\n",
      " |  \n",
      " |  decision_function(self, X)\n",
      " |      Predict confidence scores for samples.\n",
      " |      \n",
      " |      The confidence score for a sample is the signed distance of that\n",
      " |      sample to the hyperplane.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      X : array_like or sparse matrix, shape (n_samples, n_features)\n",
      " |          Samples.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      array, shape=(n_samples,) if n_classes == 2 else (n_samples, n_classes)\n",
      " |          Confidence scores per (sample, class) combination. In the binary\n",
      " |          case, confidence score for self.classes_[1] where >0 means this\n",
      " |          class would be predicted.\n",
      " |  \n",
      " |  predict(self, X)\n",
      " |      Predict class labels for samples in X.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      X : array_like or sparse matrix, shape (n_samples, n_features)\n",
      " |          Samples.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      C : array, shape [n_samples]\n",
      " |          Predicted class label per sample.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sklearn.base.ClassifierMixin:\n",
      " |  \n",
      " |  score(self, X, y, sample_weight=None)\n",
      " |      Return the mean accuracy on the given test data and labels.\n",
      " |      \n",
      " |      In multi-label classification, this is the subset accuracy\n",
      " |      which is a harsh metric since you require for each sample that\n",
      " |      each label set be correctly predicted.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      X : array-like of shape (n_samples, n_features)\n",
      " |          Test samples.\n",
      " |      \n",
      " |      y : array-like of shape (n_samples,) or (n_samples, n_outputs)\n",
      " |          True labels for X.\n",
      " |      \n",
      " |      sample_weight : array-like of shape (n_samples,), default=None\n",
      " |          Sample weights.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      score : float\n",
      " |          Mean accuracy of self.predict(X) wrt. y.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from sklearn.base.ClassifierMixin:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sklearn.linear_model._stochastic_gradient.BaseSGD:\n",
      " |  \n",
      " |  set_params(self, **kwargs)\n",
      " |      Set and validate the parameters of estimator.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      **kwargs : dict\n",
      " |          Estimator parameters.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      self : object\n",
      " |          Estimator instance.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sklearn.linear_model._base.SparseCoefMixin:\n",
      " |  \n",
      " |  densify(self)\n",
      " |      Convert coefficient matrix to dense array format.\n",
      " |      \n",
      " |      Converts the ``coef_`` member (back) to a numpy.ndarray. This is the\n",
      " |      default format of ``coef_`` and is required for fitting, so calling\n",
      " |      this method is only required on models that have previously been\n",
      " |      sparsified; otherwise, it is a no-op.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      self\n",
      " |          Fitted estimator.\n",
      " |  \n",
      " |  sparsify(self)\n",
      " |      Convert coefficient matrix to sparse format.\n",
      " |      \n",
      " |      Converts the ``coef_`` member to a scipy.sparse matrix, which for\n",
      " |      L1-regularized models can be much more memory- and storage-efficient\n",
      " |      than the usual numpy.ndarray representation.\n",
      " |      \n",
      " |      The ``intercept_`` member is not converted.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      self\n",
      " |          Fitted estimator.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      For non-sparse models, i.e. when there are not many zeros in ``coef_``,\n",
      " |      this may actually *increase* memory usage, so use this method with\n",
      " |      care. A rule of thumb is that the number of zero elements, which can\n",
      " |      be computed with ``(coef_ == 0).sum()``, must be more than 50% for this\n",
      " |      to provide significant benefits.\n",
      " |      \n",
      " |      After calling this method, further fitting with the partial_fit\n",
      " |      method (if any) will not work until you call densify.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sklearn.base.BaseEstimator:\n",
      " |  \n",
      " |  __getstate__(self)\n",
      " |  \n",
      " |  __repr__(self, N_CHAR_MAX=700)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __setstate__(self, state)\n",
      " |  \n",
      " |  get_params(self, deep=True)\n",
      " |      Get parameters for this estimator.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      deep : bool, default=True\n",
      " |          If True, will return the parameters for this estimator and\n",
      " |          contained subobjects that are estimators.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      params : mapping of string to any\n",
      " |          Parameter names mapped to their values.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(Perceptron)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Misclassfied samples: 5\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import Perceptron\n",
    "\n",
    "ppn = Perceptron(tol=1e-5, eta0=0.1, random_state=0)\n",
    "\n",
    "ppn.fit(X_train_std, y_train)\n",
    "\n",
    "y_pred = ppn.predict(X_test_std)\n",
    "\n",
    "print('Misclassfied samples: %d' % (y_test != y_pred).sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.89\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "print ('Accuracy: %.2f' % accuracy_score(y_test, y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_decision_regions(X, y, classifier, test_idx=None, resolution=0.02):\n",
    "\n",
    "    # setup marker generator and color map\n",
    "    markers = ('s', 'x', 'o', '^', 'v')\n",
    "    colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')\n",
    "    cmap = ListedColormap(colors[:len(np.unique(y))])\n",
    "\n",
    "    # plot the decision surface\n",
    "    x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1\n",
    "    x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1\n",
    "    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution),\n",
    "                           np.arange(x2_min, x2_max, resolution))\n",
    "    Z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)\n",
    "    Z = Z.reshape(xx1.shape)\n",
    "    plt.contourf(xx1, xx2, Z, alpha=0.4, cmap=cmap)\n",
    "    plt.xlim(xx1.min(), xx1.max())\n",
    "    plt.ylim(xx2.min(), xx2.max())\n",
    "\n",
    "    for idx, cl in enumerate(np.unique(y)):\n",
    "        plt.scatter(x=X[y == cl, 0], y=X[y == cl, 1],\n",
    "                    alpha=0.8, c=cmap(idx),\n",
    "                    marker=markers[idx], label=cl)\n",
    "    \n",
    "    # highlight test samples\n",
    "    if test_idx:\n",
    "        X_test, y_test = X[test_idx, :], y[test_idx]\n",
    "        plt.scatter(X_test[:, 0], X_test[:, 1], c='', \n",
    "                   alpha=1.0, linewidth=1, marker='o',\n",
    "                   s=55, label=\"test set\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "'c' argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with 'x' & 'y'.  Please use a 2-D array with a single row if you really want to specify the same RGB or RGBA value for all points.\n",
      "'c' argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with 'x' & 'y'.  Please use a 2-D array with a single row if you really want to specify the same RGB or RGBA value for all points.\n",
      "'c' argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with 'x' & 'y'.  Please use a 2-D array with a single row if you really want to specify the same RGB or RGBA value for all points.\n",
      "c:\\users\\pachacho\\miniconda3\\envs\\pycourse\\lib\\site-packages\\ipykernel_launcher.py:29: MatplotlibDeprecationWarning: Using a string of single character colors as a color sequence is deprecated. Use an explicit list instead.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_decision_regions(X=X_combined_std, y=y_combined, classifier=ppn, test_idx=range(105,150))\n",
    "plt.xlabel('petal length [standardized]')\n",
    "plt.ylabel('petal width [standardized]')\n",
    "plt.legend(loc='upper left')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Datos esparcidos o *Sparse Data*\n",
    "\n",
    "En ocasiones, trabajaremos con conjuntos de datos casi vacíos - ocurre por ejemplo, en algoritmos de recomendación y de procesamiento de lenguajes. Ésto supone un problema, pues podemos tener matrices enoooooormes (con lo que ocupan recursos del sistema) cuando en realidad los datos útiles son una décima parte. En Python lo solucionamos con `pandas`.\n",
    "\n",
    "<img src=\"https://miro.medium.com/max/1400/1*_k7neNsac5zH5cQn7hst6Q.png\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>user_id</th>\n",
       "      <th>item_id</th>\n",
       "      <th>rating</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>196</td>\n",
       "      <td>242</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>186</td>\n",
       "      <td>302</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>22</td>\n",
       "      <td>377</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>244</td>\n",
       "      <td>51</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>166</td>\n",
       "      <td>346</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   user_id  item_id  rating\n",
       "0      196      242       3\n",
       "1      186      302       3\n",
       "2       22      377       1\n",
       "3      244       51       2\n",
       "4      166      346       1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(100000, 3)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "\n",
    "    \n",
    "data = pd.read_csv(\"http://files.grouplens.org/datasets/movielens/ml-100k/u.data\", sep=\"\\t\", header=None, engine='python')\n",
    "data.columns = [\"user_id\", \"item_id\", \"rating\", \"timestamp\"]\n",
    "data.drop([\"timestamp\"], axis=1, inplace=True)\n",
    "display(data.head())\n",
    "display(data.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage is 2.4 MB\n"
     ]
    }
   ],
   "source": [
    "BYTES_TO_MB_DIV = 0.000001\n",
    "def print_memory_usage_of_data_frame(df):\n",
    "    mem = round(df.memory_usage().sum() * BYTES_TO_MB_DIV, 3) \n",
    "    print(\"Memory usage is \" + str(mem) + \" MB\")\n",
    "    \n",
    "print_memory_usage_of_data_frame(data)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>rating</th>\n",
       "      <th>user_id_1</th>\n",
       "      <th>user_id_2</th>\n",
       "      <th>user_id_3</th>\n",
       "      <th>user_id_4</th>\n",
       "      <th>user_id_5</th>\n",
       "      <th>user_id_6</th>\n",
       "      <th>user_id_7</th>\n",
       "      <th>user_id_8</th>\n",
       "      <th>user_id_9</th>\n",
       "      <th>...</th>\n",
       "      <th>item_id_1673</th>\n",
       "      <th>item_id_1674</th>\n",
       "      <th>item_id_1675</th>\n",
       "      <th>item_id_1676</th>\n",
       "      <th>item_id_1677</th>\n",
       "      <th>item_id_1678</th>\n",
       "      <th>item_id_1679</th>\n",
       "      <th>item_id_1680</th>\n",
       "      <th>item_id_1681</th>\n",
       "      <th>item_id_1682</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 2626 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   rating  user_id_1  user_id_2  user_id_3  user_id_4  user_id_5  user_id_6  \\\n",
       "0       3          0          0          0          0          0          0   \n",
       "1       3          0          0          0          0          0          0   \n",
       "2       1          0          0          0          0          0          0   \n",
       "3       2          0          0          0          0          0          0   \n",
       "4       1          0          0          0          0          0          0   \n",
       "\n",
       "   user_id_7  user_id_8  user_id_9  ...  item_id_1673  item_id_1674  \\\n",
       "0          0          0          0  ...             0             0   \n",
       "1          0          0          0  ...             0             0   \n",
       "2          0          0          0  ...             0             0   \n",
       "3          0          0          0  ...             0             0   \n",
       "4          0          0          0  ...             0             0   \n",
       "\n",
       "   item_id_1675  item_id_1676  item_id_1677  item_id_1678  item_id_1679  \\\n",
       "0             0             0             0             0             0   \n",
       "1             0             0             0             0             0   \n",
       "2             0             0             0             0             0   \n",
       "3             0             0             0             0             0   \n",
       "4             0             0             0             0             0   \n",
       "\n",
       "   item_id_1680  item_id_1681  item_id_1682  \n",
       "0             0             0             0  \n",
       "1             0             0             0  \n",
       "2             0             0             0  \n",
       "3             0             0             0  \n",
       "4             0             0             0  \n",
       "\n",
       "[5 rows x 2626 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(100000, 2626)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage is 263.3 MB\n"
     ]
    }
   ],
   "source": [
    "# One-hot encoding\n",
    "\n",
    "data_one_hot = pd.get_dummies(data, columns=['user_id', 'item_id'])  # Converts categorical variable into dummy/indicator variables.\n",
    "\n",
    "display(data_one_hot.head())\n",
    "display(data_one_hot.shape)\n",
    "\n",
    "print_memory_usage_of_data_frame(data_one_hot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_to_sparse_pandas(df, exclude_columns=[]):\n",
    "    \"\"\"\n",
    "    Converts columns of a data frame into SparseArrays and returns the data frame with transformed columns.\n",
    "    Use exclude_columns to specify columns to be excluded from transformation.\n",
    "    :param df: pandas data frame\n",
    "    :param exclude_columns: list\n",
    "        Columns not be converted to sparse\n",
    "    :return: pandas data frame\n",
    "    \"\"\"\n",
    "    df = df.copy()\n",
    "    exclude_columns = set(exclude_columns)\n",
    "\n",
    "    for (columnName, columnData) in df.iteritems():\n",
    "        if columnName in exclude_columns:\n",
    "            continue\n",
    "        df[columnName] = pd.arrays.SparseArray(columnData.values, dtype='uint8')\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\pachacho\\miniconda3\\envs\\pycourse\\lib\\site-packages\\ipykernel_launcher.py:16: FutureWarning: The pandas.SparseArray class is deprecated and will be removed from pandas in a future version. Use pandas.arrays.SparseArray instead.\n",
      "  app.launch_new_instance()\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "rating                     int64\n",
       "user_id_1       Sparse[uint8, 0]\n",
       "user_id_2       Sparse[uint8, 0]\n",
       "user_id_3       Sparse[uint8, 0]\n",
       "user_id_4       Sparse[uint8, 0]\n",
       "                      ...       \n",
       "item_id_1678    Sparse[uint8, 0]\n",
       "item_id_1679    Sparse[uint8, 0]\n",
       "item_id_1680    Sparse[uint8, 0]\n",
       "item_id_1681    Sparse[uint8, 0]\n",
       "item_id_1682    Sparse[uint8, 0]\n",
       "Length: 2626, dtype: object"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "ename": "NameError",
     "evalue": "name 'print_memory_usage_of_sparse_data_frame' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-31-8e7791fec3b4>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mdisplay\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata_one_hot_sparse\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdtypes\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mprint_memory_usage_of_sparse_data_frame\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata_one_hot_sparse\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'print_memory_usage_of_sparse_data_frame' is not defined"
     ]
    }
   ],
   "source": [
    "data_one_hot_sparse = convert_to_sparse_pandas(data_one_hot, exclude_columns=['rating'])\n",
    "\n",
    "display(data_one_hot_sparse.dtypes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage is 1.8 MB\n"
     ]
    }
   ],
   "source": [
    "print_memory_usage_of_data_frame(data_one_hot_sparse)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otra opción..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "rating                     int64\n",
       "user_id_1       Sparse[uint8, 0]\n",
       "user_id_2       Sparse[uint8, 0]\n",
       "user_id_3       Sparse[uint8, 0]\n",
       "user_id_4       Sparse[uint8, 0]\n",
       "                      ...       \n",
       "item_id_1678    Sparse[uint8, 0]\n",
       "item_id_1679    Sparse[uint8, 0]\n",
       "item_id_1680    Sparse[uint8, 0]\n",
       "item_id_1681    Sparse[uint8, 0]\n",
       "item_id_1682    Sparse[uint8, 0]\n",
       "Length: 2626, dtype: object"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage is 1.8 MB\n"
     ]
    }
   ],
   "source": [
    "data_one_hot_sparse = pd.get_dummies(data, columns=['user_id', 'item_id'], sparse=True)\n",
    "\n",
    "display(data_one_hot_sparse.dtypes)\n",
    "\n",
    "print_memory_usage_of_data_frame(data_one_hot_sparse)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "👉 [mas info](https://towardsdatascience.com/working-with-sparse-data-sets-in-pandas-and-sklearn-d26c1cfbe067). 👈"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inteligencia Artificial *Ética*\n",
    "\n",
    "Una tendencia que está tomando mucha relevancia actualmente es la de la ética aplicada a IA. Por poner un ejempo, imaginemos una IA que determina si una imagen es de una fiesta o no. Por ejemplo,\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <td><img src=\"https://i.imgur.com/lXF673S.png\" width=\"30%\"/></td>\n",
    "        <td><img src=\"https://i.imgur.com/LhoK3kf.jpg\" width=\"80%\"/></td>\n",
    "    </tr>\n",
    "</table>\n",
    "\n",
    "<br/>\n",
    "\n",
    "Ambas imágenes se consideran fiestas. ¿Qué pasaría si la IA solo entrenase con imágenes como la segunda? Y si sólo fuese entrenada con imágenes de gente de tez blanca, ¿reconocería la siguiente imagen como una fiesta o no?\n",
    "\n",
    "<img src=\"https://i.imgur.com/VHjmZc4.jpg\" width=\"20%\"/>\n",
    "\n",
    "Este tema es bastante amplio y para nada determinista, por lo que te recomiendo que busques los recursos por tu cuenta."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Extras\n",
    "\n",
    "+ [Crash Course de Google en ML](https://developers.google.com/machine-learning/crash-course?hl=es-419).\n",
    "+ [**Curso de la UC3M sobre Aprendizaje Automático**](http://ocw.uc3m.es/ingenieria-informatica/aprendizaje-automatico-para-el-analisis-de-datos/material-de-clase).\n",
    "+ [Algoritmos de ML comparados: Python vs R](https://www.analyticsvidhya.com/blog/2015/09/full-cheatsheet-machine-learning-algorithms/).\n",
    "+ [Aprendizaje Automático en paralelo](https://github.com/ogrisel/parallel_ml_tutorial).\n",
    "+ [Machine Learning by Chris Albon](https://chrisalbon.com/#machine_learning).\n",
    "\n",
    "<br/>\n",
    "<br/>\n",
    "<br/>\n",
    "\n",
    "[<img src=\"https://miro.medium.com/max/1400/1*05DngXXh_tH1RHF5UaXWjA.jpeg\" width=\"30%\"/>](https://miro.medium.com/max/1400/1*05DngXXh_tH1RHF5UaXWjA.jpeg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## ¿Más dudas?\n",
    "\n",
    "Puedes encontrarnos por\n",
    "\n",
    "+ Twitter: en @AIMalaga, @AIMatesanz (Andrés) y @josocjoq (Joaquín)\n",
    "+ Telegram: en nuestro grupo https://t.me/MalagaSchoolOfAI\n",
    "> Ojito! Este es el grupo de MálagaAI. Si perteneces a otra ciudad, quizás te interesa [encontrar tu comunidad local](https://www.spain-ai.com/). Si quieres crear una comunidad [contacta con SpainAI en Twitter](https://twitter.com/Spain_AI_).\n",
    "+ Linkedin: [Spain AI](https://www.linkedin.com/company/spainai/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "Licencia: Andrés Matesanz y Joaquín Terrasa, MalagaAI [CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/) 2020\n",
    "\n",
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/a/a3/Cc.logo.circle.svg/64px-Cc.logo.circle.svg.png\" width=\"1%\"/><img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/3/3c/Cc-by_new.svg/80px-Cc-by_new.svg.png\" width=\"1%\"/><img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/d/db/Cc-nc.svg/64px-Cc-nc.svg.png\" width=\"1%\"/>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}