{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from numpy import dot\n",
    "from pandas import DataFrame, Series\n",
    "from numpy.linalg import inv, solve\n",
    "import matplotlib\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "matplotlib.rcParams[\"font.size\"] = 16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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>c</th>\n",
       "      <th>b</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   c  b\n",
       "0  2  5\n",
       "1  4  6"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = DataFrame({\"c\": [2, 4], \"b\": [5, 6]})\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matrix dot Vector\n",
    "\n",
    "The dot product of A with x is dot(A, x).\n",
    "\n",
    "Not the same as A * x.\n",
    "\n",
    "The vector (when after the matrix) takes a combination of the columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 4])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(df, [1, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(df, [0, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-3, -2])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(df, [1, -1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matrix dot Matrix\n",
    "\n",
    "A matrix times a vector is a combination of the matrix's columns.\n",
    "\n",
    "When we do A dot B, each column is taken as a vector, used to make a combination of A's columns, to create a column of output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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>c</th>\n",
       "      <th>b</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   c  b\n",
       "0  2  5\n",
       "1  4  6"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = DataFrame({\"c\": [2, 4], \"b\": [5, 6]})\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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>0</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    0   1\n",
       "0  10   2\n",
       "1   1  10"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2 = DataFrame([[10, 2],\n",
    "                 [1, 10]])\n",
    "df2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[25, 54],\n",
       "       [46, 68]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(df, df2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([25, 46])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# column 1\n",
    "dot(df, df2[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([54, 68])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# column 2\n",
    "dot(df, df2[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Identity and Inverse\n",
    "\n",
    "An identity matrix is has 1's on the diagonal and 0's everywhere else.  Multiply another matrix with it and get the same matrix back."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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>c</th>\n",
       "      <th>b</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   c  b\n",
       "0  2  5\n",
       "1  4  6"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = DataFrame({\"c\": [2, 4], \"b\": [5, 6]})\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "I = [[1, 0],\n",
    "     [0, 1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 5],\n",
       "       [4, 6]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(df, I)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes we want to find an inverse matrix $A^{-1}$ such that $AA^{-1} = I$.  Numpy's `inv` can help."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.75 ,  0.625],\n",
       "       [ 0.5  , -0.25 ]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_inv = inv(df)\n",
    "df_inv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0.],\n",
       "       [0., 1.]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# does it work?\n",
    "dot(df, df_inv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solve for Slope+Intercept"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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>c</th>\n",
       "      <th>b</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   c  b\n",
       "0  2  5\n",
       "1  4  6"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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": [
    "def plot_cb(c, b, color=\"black\"):\n",
    "    plt.scatter(x=c, y=b, c=color)\n",
    "    plt.xlim(0, 10)\n",
    "    plt.ylim(0, 10)\n",
    "    plt.xlabel(\"c\")\n",
    "    plt.ylabel(\"b\")\n",
    "    \n",
    "plot_cb(df.c, df.b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Say we want to find $x$ such that $b = cx_1 + 1x_2$\n",
    "\n",
    "We have two equations and two unknows:\n",
    "* $2x_1 + 1x_2 = 5$\n",
    "* $4x_1 + 1x_2 = 6$\n",
    "\n",
    "This becomes a standard $Ax = b$ problem (data determines A and b, and we want to solve for x, which captures the slope and intercept)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2., 1.],\n",
       "       [4., 1.]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([df.c, np.ones(len(df))]).T\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = df.b.values\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.5, 4. ])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = solve(A, b)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11d2ddcf8>]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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_cb(df.c, df.b)\n",
    "c = np.arange(10)\n",
    "plt.plot(c, c*x[0] + x[1], c=\"red\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# More Points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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>c</th>\n",
       "      <th>b</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   c  b\n",
       "0  2  5\n",
       "1  4  6\n",
       "2  6  7"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = DataFrame({\"c\": [2, 4, 6], \"b\": [5, 6, 7]})\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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": [
    "plot_cb(df.c, df.b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2., 1.],\n",
       "       [4., 1.],\n",
       "       [6., 1.]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([df.c, np.ones(len(df))]).T\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6, 7])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = df.b.values\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# problem 1: numpy wants it square\n",
    "# x = solve(A, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "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>c</th>\n",
       "      <th>b</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>8</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   c  b\n",
       "0  2  5\n",
       "1  4  6\n",
       "2  8  7"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# problem 2: there might not even be a solution!\n",
    "df = DataFrame({\"c\": [2, 4, 8], \"b\": [5, 6, 7]})\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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": [
    "plot_cb(df.c, df.b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2., 1.],\n",
       "       [4., 1.],\n",
       "       [8., 1.]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([df.c, np.ones(len(df))]).T\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6, 7])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = df.b.values\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# when can we solve Ax = b?\n",
    "# answer: when b is a combination of A's columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Projection Matrix\n",
    "\n",
    "Define P as:\n",
    "\n",
    "$P = A(A^TA)^{-1}A^T$\n",
    "\n",
    "In a good linear algebra course, you would derive the above formula.  For now, it's probably worth memorizing.\n",
    "\n",
    "P is a projection matrix.  Even if we there's not an answer for what x is in $Ax = b$, there will be an answer to $Ax = p$, where $p = Pb$.\n",
    "\n",
    "Better still, p will be the closest possible to b (\"closest\" brings in least squares)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "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>c</th>\n",
       "      <th>b</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>8</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   c  b\n",
       "0  2  5\n",
       "1  4  6\n",
       "2  8  7"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = DataFrame({\"c\": [2, 4, 8], \"b\": [5, 6, 7]})\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.71428571,  0.42857143, -0.14285714],\n",
       "       [ 0.42857143,  0.35714286,  0.21428571],\n",
       "       [-0.14285714,  0.21428571,  0.92857143]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P = dot(dot(A, inv(dot(A.T, A))), A.T)\n",
    "P"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "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": [
    "plot_cb(df.c, df.b)\n",
    "plot_cb(df.c, dot(P, df.b), \"red\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Finding \"best\" x\n",
    "\n",
    "1. $Ax = Pb$\n",
    "2. $Ax = A(A^TA)^{-1}A^Tb$\n",
    "3. $x = (A^TA)^{-1}A^Tb$\n",
    "4. $(A^TA)x = A^Tb$\n",
    "\n",
    "numpy can help now!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.32142857, 4.5       ])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = solve(dot(A.T, A), dot(A.T, b))\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11d5c34a8>]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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_cb(df.c, df.b)\n",
    "cvals = np.arange(10)\n",
    "plt.plot(cvals, cvals * x[0] + x[1], color=\"red\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}