01_regresion_lineal.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Regresión Lineal\n",
    "\n",
    "Un modelo sencillo como el de regresión lineal nos va a servir de base y para empezar a ver como implementar un modelo matemático en código.\n",
    "\n",
    "El problema puede ser descripto por un conjunto de datos $\\{x_{i1},x_{i2},...,x_{iN},z_i\\}_{i=1}^P$, en donde cada $z_i$ de los $P$ conocidos son el resultado de una combinación lineal de $N$ variables $x$ con $N+1$ valores $a$ que no conocemos.\n",
    "\n",
    "$$z_i = a_1 x_{i1} + a_2 x_{i2} + ... + a_N x_{iN} + a_{N+1}$$\n",
    "\n",
    "El objetivo va a ser utilizar los $x$ y $z$ que conocemos para encontrar una aproximación $w$ a los valores $a$ desconocidos. Y para hacer el problema un poco más interesante vamos a asumir que tenemos $M$ valores de $z$ por instancia resultantes de distintos $a$, es decir nuestro conjunto de datos será $\\{x_{i1},...,x_{iN},z_{1i},...,z_{Mi}\\}_{i=1}^P$.\n",
    "\n",
    "Y bajo estas condiciones podemos pensar en $a$ como una matriz de $N+1$ por $M$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Empecemos por importar la librería numpy que nos va a ayudar con las operaciones algebráicas.\n",
    "\n",
    "import numpy as num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Y establezcamos las dimensiones de los datos que vamos a utilizar.\n",
    "\n",
    "N = 4\n",
    "M = 2\n",
    "P = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.54362889  2.74552522  6.53552448  1.12986878  1.        ]\n",
      " [ 6.67959745 -6.049644   -8.14060442 -3.68157569  1.        ]\n",
      " [-6.8111973  -2.47899491  4.33572297 -3.7493281   1.        ]\n",
      " [-4.5964805  -8.64516663  5.70941129 -4.23871697  1.        ]\n",
      " [ 3.39267301 -0.37644501  0.1350543  -7.22650565  1.        ]]\n"
     ]
    }
   ],
   "source": [
    "# Vamos a tener que generar nuestros propios datos al azar para el problema.\n",
    "\n",
    "# Primero vamos a necesitar una matriz de mezcla para la combinación lineal.\n",
    "a = num.random.uniform( -1, 1, (N+1,M))\n",
    "\n",
    "# Y los valores x de entrada con una columna extra que podremos en 1.\n",
    "x = num.random.uniform( -9, 9, (P,N+1))\n",
    "x[:,-1] = 1    # Esto indica que a todas las filas ':', en la última columna '-1', le asigne el valor '1'.\n",
    "\n",
    "print( x[:5])  # Veamos las primeras 5 filas de x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Con esto podemos generar Z facilmente como en producto entre X y A.\n",
    "\n",
    "z = num.dot( x, a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Nuestro modelo va a consistir en la matriz W inicializada también al azar con valores pequeños.\n",
    "\n",
    "w = num.random.normal( 0, 0.1, (N+1,M))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El proceso de aprendizaje, es decir, encontrar un $w$ que *explique* suficientemente bien los $z$ dados los $x$, lo vamos a realizar iterativamente de la siguiente manera.\n",
    "\n",
    "1. Generar una respuesta $y$ del modelo: $$y = x\\bullet w$$\n",
    "2. Calcular la diferencia entre la respuesta deseada y la obtenida: $$ d = z-y $$\n",
    "3. Usar esta diferencia para calcular las correcciones a $w$: $$ \\triangle w = x^T \\bullet d $$\n",
    "4. Aplicar estas correcciones en intervalos pequeños: $$ w = w + \\eta \\triangle w $$\n",
    "5. Si el error es muy alto volver al paso 1: $$ (\\sum d^2) > \\epsilon $$\n",
    "\n",
    "Las correcciones $\\triangle w$ consisten en una matriz de las mismas dimensiones que $w$ en donde cada valor será proporcional al valor de entrada $x$ y el error $z-y$ cometido en la salida.\n",
    "\n",
    "$$ \\triangle w_{ij} = x_i \\dot (z_j - y_j) $$\n",
    "\n",
    "El valor $\\eta$ es el llamado *coeficiente de aprendizaje* o *learning rate*, generalmente elegido como un valor pequeño, para que las correcciones se apliquen gradualmente.\n",
    "\n",
    "Como no siempre vamos a estar seguros de poder encontrar una buena solución, vamos a incluir un término extra a la condición de finalización del algoritmo. Este será de un valor *t* que permitirá detener el proceso después de una cierta candidad de pasos.\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 0.23853621543726952\n",
      "200 0.01878685322634201\n",
      "300 0.01325882122251105\n",
      "400 0.01086028420217652\n"
     ]
    }
   ],
   "source": [
    "lr = 1e-5\n",
    "E = []\n",
    "e = 1\n",
    "t = 0\n",
    "while (e>0.01) and (t<999):\n",
    "    y = num.dot( x, w)\n",
    "    d = z-y\n",
    "    dw = lr*num.dot( x.T, d)\n",
    "    w += dw\n",
    "    e = num.mean( num.square( d))\n",
    "    E.append( e)\n",
    "    t += 1\n",
    "    if t%100==0:\n",
    "        print( t, e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "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": [
    "# Finalmente podemos graficar la evolución del error durante el entrenamiento.\n",
    "\n",
    "from matplotlib import pyplot as mpl\n",
    "\n",
    "mpl.plot(E,'r')\n",
    "mpl.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Este sencillo ejemplo es una simplificación de la técnica de regresión lineal y tiene como objetivo ilustrar el uso de las herramientas de programación que vamos a utilizar más adelante.\n",
    "\n",
    "[Para profundizar más sobre el tema.](https://es.wikipedia.org/wiki/Regresi%C3%B3n_lineal)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}