linear-zoo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8c098a5b",
   "metadata": {},
   "source": [
    "# Linear Zoo\n",
    "\n",
    "This notebook shows some of the very strange ways that \"lines of best fit\" apply to a simple toy data set.\n",
    "\n",
    "Here's the dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4adea7d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = [\n",
    "    (1,3),\n",
    "    (2,6),\n",
    "    (3,4),\n",
    "    (4,12),\n",
    "    (5,5),\n",
    "    (6,13)\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6732bca4",
   "metadata": {},
   "source": [
    "The idea is pretty simple: you take some data, and you use some algorithm to find a gradient and\n",
    "coefficient that best fits that data.\n",
    "\n",
    "But what do you mean by best? And what algorithm do you want to choose?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fe13f996",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "import fractions\n",
    "\n",
    "class Unimplemented(Exception):\n",
    "    pass\n",
    "\n",
    "class LinearModel:\n",
    "    def __init__(self):\n",
    "        self._gradient = None\n",
    "        self._y_intercept = None\n",
    "        self._predictions = []\n",
    "        self._residuals = []\n",
    "        self._residual_impact = []\n",
    "        self._overall_metric = None\n",
    "        \n",
    "        self._y_values = self.reshape_y([t[1] for t in dataset])\n",
    "        self._raw_x_values = [t[0] for t in dataset]\n",
    "        self._x_values = self.reshape_x(self._raw_x_values)\n",
    "        \n",
    "        self.fit()\n",
    "        \n",
    "        for (x,y) in dataset:\n",
    "            this_prediction = self.predict(x)\n",
    "            self._predictions.append(this_prediction)\n",
    "            self._residuals.append(y - this_prediction)\n",
    "            self._residual_impact.append(self.measure(y - this_prediction))\n",
    "            \n",
    "        self._overall_metric = self.aggregate_metrics(self._residual_impact)\n",
    "        \n",
    "    def reshape_y(self, values):\n",
    "        return values[:]\n",
    "    \n",
    "    def reshape_x(self, values):\n",
    "        return values[:]\n",
    "            \n",
    "    def predict(self, x):\n",
    "        y = self._gradient * x + self._y_intercept\n",
    "        return y\n",
    "        \n",
    "    def formula(self):\n",
    "        floating_point_coefficients = False\n",
    "        fractional_coefficients = False\n",
    "        gradient_term = \"\"\n",
    "        if self._gradient == 0.0:\n",
    "            pass\n",
    "        elif type(self._gradient) in [type(0.0), numpy.float64]:\n",
    "            gradient_term = f\"{self._gradient:.3f} x\"\n",
    "        elif type(self._gradient) == fractions.Fraction and self._gradient.denominator != 1:\n",
    "            if self._gradient.numerator == 1:\n",
    "                gradient_term = f\"x / {self._gradient.denominator}\"\n",
    "            else:\n",
    "                gradient_term = f\"{self._gradient.numerator} x / {self._gradient.denominator}\"\n",
    "        else:\n",
    "            gradient_term = f\"{self._gradient} x\"\n",
    "            \n",
    "        intercept_term = \"\"\n",
    "        if self._y_intercept == 0.0:\n",
    "            if gradient_term == \"\":\n",
    "                return \"y = 0\"\n",
    "            return f\"y = {gradient_term}\"\n",
    "        if type(self._y_intercept) in [type(0.0), numpy.float64]:\n",
    "            intercept_term = f\"{self._y_intercept:.3f}\"\n",
    "        else:\n",
    "            intercept_term = f\"{self._y_intercept}\"\n",
    "            \n",
    "        if gradient_term == \"\":\n",
    "            return f\"y = {intercept_term}\"\n",
    "        return f\"y = {gradient_term} + {intercept_term}\"\n",
    "        \n",
    "    def plot(self, ax, **kwargs):\n",
    "        t = self.title()\n",
    "        s = self.formula()\n",
    "        ax.axline((0, float(self._y_intercept)), slope=float(self._gradient), \n",
    "                  label=f\"{t}: {s}\",**kwargs)\n",
    "        \n",
    "    def fit(self):\n",
    "        \"\"\"This is where you implement the line-of-best fit algorithm. It \n",
    "        needs to set self._gradient and self._y_intercept\"\"\"\n",
    "        raise Unimplemented\n",
    "\n",
    "    def measure(self, residual):\n",
    "        \"\"\"How bad is this residual?\"\"\"\n",
    "        raise Unimplemented\n",
    "        \n",
    "    def aggregate_metrics(self, residual_measures):\n",
    "        \"\"\"How bad is this collection of residuals?\"\"\"\n",
    "        raise Unimplemented\n",
    "        \n",
    "    def title(self):\n",
    "        \"\"\"What's the name of this algorithm for finding a best line?\"\"\"\n",
    "        raise Unimplemented      \n",
    "        \n",
    "    def measure_latex_prefix(self):\n",
    "        \"\"\"When we make a table out of this model, what do we put before the y - \\hat{y}?\"\"\"\n",
    "        return Unimplemented\n",
    "    def measure_latex_postfix(self):\n",
    "        \"\"\"What do we put after the y - \\hat{y}?\"\"\"\n",
    "        return Unimplemented"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26e5dc5f",
   "metadata": {},
   "source": [
    "scikit learn has a large number of useful linear regression functions. They all need the x values to be a numpy\n",
    "array (or pandas DataFrame). They don't need the y values to be a numpy array, but it's conventional.\n",
    "\n",
    "I've said that they all use $r^2$ as a measure, which isn't completely true. But subclasses can override this.\n",
    "\n",
    "Among the many things I haven't put in here that are interesting are:\n",
    " \n",
    "- Huber is very robust to outliers (more so even than RANSAC). I could do this, but it would just be another line\n",
    "somewhere between the ordinary least squares line and the Siegel one.\n",
    "\n",
    "- GLMs (generalised linear models) using link functions. This would make sense if the noise in the dataset followed\n",
    "some special distribution, or if the relationship wasn't quite linear."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e19af77",
   "metadata": {},
   "outputs": [],
   "source": [
    "import sklearn.linear_model\n",
    "import pandas\n",
    "\n",
    "class SklearnModel(LinearModel):\n",
    "    def __init__(self):\n",
    "        LinearModel.__init__(self)\n",
    "    def reshape_y(self, values):\n",
    "        return pandas.Series(values)\n",
    "    def reshape_x(self, values):\n",
    "        return pandas.DataFrame({'x': pandas.Series(values)})\n",
    "    def measure(self, residual):\n",
    "        return residual ** 2\n",
    "    def aggregate_metrics(self, residual_measures):\n",
    "        return sum(residual_measures)\n",
    "    def measure_latex_prefix(self):\n",
    "        return r'\\left('\n",
    "    def measure_latex_postfix(self):\n",
    "        return r'\\right)^2'\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c29f95d2",
   "metadata": {},
   "source": [
    "## Ordinary Least Squares\n",
    "\n",
    "This is the one you learned about at school and in statistics class. Plain and simple: minimise the sum\n",
    "of squared residuals. It works because you can calculate the residuals as a function of (gradient and intercept).\n",
    "This function turns out to be convex, so a little bit of calculus and you can find the minimum. Every data point\n",
    "affects the outcome, so every outlier nudges the line a little. You will almost always end up with real-valued\n",
    "gradient and intercept."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "328eb634",
   "metadata": {},
   "outputs": [],
   "source": [
    "class OLS(SklearnModel):\n",
    "    def __init__(self):\n",
    "        SklearnModel.__init__(self)\n",
    "    def title(self): return \"Ordinary least squares regression (minimise the sum of r^2)\"\n",
    "    def fit(self):\n",
    "        ols = sklearn.linear_model.LinearRegression()\n",
    "        ols.fit(self._x_values, self._y_values)\n",
    "        self._gradient = ols.coef_[0]\n",
    "        self._y_intercept = ols.intercept_\n",
    "       "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "919e1c9e",
   "metadata": {},
   "source": [
    "## Theil-Sen\n",
    "\n",
    "My absolute favourite linear model. Take a pair of points at random, draw a line through them. Then take another\n",
    "pair of points at random and draw a line through them. Repeat this process as many times as you want, depending\n",
    "on the accuracy you want. Take the line with the median gradient.\n",
    "\n",
    "Beautifully robust to outliers. Scales to very large datasets. Can be done by hand or in your head. Falls apart a bit when you have a lot of dimensions though."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11aab932",
   "metadata": {},
   "outputs": [],
   "source": [
    " class TheilSen(SklearnModel):\n",
    "    def __init__(self):\n",
    "        SklearnModel.__init__(self)\n",
    "    def title(self): return \"Theil-Sen (median gradient of point pairs)\"\n",
    "    def fit(self):\n",
    "        ts = sklearn.linear_model.TheilSenRegressor()\n",
    "        ts.fit(self._x_values, self._y_values)\n",
    "        self._gradient = ts.coef_[0]\n",
    "        self._y_intercept = ts.intercept_\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30d55317",
   "metadata": {},
   "source": [
    "## RANSAC\n",
    "\n",
    "Take subsets of points and draw a line through them. Count the number of other points that you are close to. Take another subset of points and draw a line through them and count the number of other points. Keep track of the\n",
    "maximum so far, and how often you are beating the maximum as you iterate. Stop when you don't think you are going\n",
    "to get any better.\n",
    "\n",
    "Even more robust to outliers than Theil-Sen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "70624f5f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class RANSAC(SklearnModel):\n",
    "    def __init__(self):\n",
    "        SklearnModel.__init__(self)\n",
    "    def title(self): return \"RANSAC\"\n",
    "    def fit(self):\n",
    "        rs = sklearn.linear_model.RANSACRegressor()\n",
    "        rs.fit(self._x_values, self._y_values)\n",
    "        self._gradient = rs.estimator_.coef_[0]\n",
    "        self._y_intercept = rs.estimator_.intercept_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9c37021",
   "metadata": {},
   "source": [
    "## Siegel\n",
    "\n",
    "For each point, draw a line to every other point, and take the median gradient. Now you have a \"best\" line through\n",
    "each point. They have gradients, so take the line with the median gradient.\n",
    "\n",
    "The most robust-to-outliers method of all linear models. Unfortunately, it only works with one-dimensional $x$ variables, so it isn't part of scikit-learn.\n",
    "\n",
    "I've kept the $r^2$ residual calculation even though it doesn't make sense here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "d7713b2e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'y = 2.000 x + 1.000'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Siegel(LinearModel):\n",
    "    def __init__(self):\n",
    "        LinearModel.__init__(self)\n",
    "    def measure(self, residual):\n",
    "        return residual ** 2\n",
    "    def aggregate_metrics(self, residual_measures):\n",
    "        return sum(residual_measures)\n",
    "    def title(self):\n",
    "        return 'Siegel (median of median gradients)'\n",
    "    def fit(self):\n",
    "        all_median_gradients = []\n",
    "        all_median_intercepts = {}\n",
    "        for i in range(len(self._x_values)):\n",
    "            x1 = self._x_values[i]\n",
    "            y1 = self._y_values[i]\n",
    "            my_gradients = []\n",
    "            my_intercepts = {}\n",
    "            for j in range(len(self._x_values)):\n",
    "                x2 = self._x_values[j]\n",
    "                y2 = self._y_values[j]\n",
    "                if x1 == x2:\n",
    "                    continue\n",
    "                gradient = (y2-y1) / (x2-x1)\n",
    "                my_gradients.append(gradient)\n",
    "                y_intercept = (y2 - x2 * gradient)\n",
    "                my_intercepts[gradient] = y_intercept\n",
    "            my_gradients.sort()\n",
    "            n_lines = len(my_gradients)\n",
    "            #if n_lines % 2 == 0:\n",
    "            if False:\n",
    "                n1 = n_lines // 2 - 1\n",
    "                n2 = n1 + 1\n",
    "                grad1 = my_gradients[n1]\n",
    "                grad2 = my_gradients[n2]\n",
    "                intercept1 = my_intercepts[grad1]\n",
    "                intercept2 = my_intercepts[grad2]\n",
    "                my_median_gradient = (grad1 + grad2) / 2\n",
    "                my_median_intercept= (intercept1 + intercept2) / 2\n",
    "            else:\n",
    "                n1 = n_lines // 2\n",
    "                my_median_gradient = my_gradients[n1]\n",
    "                my_median_intercept = my_intercepts[my_median_gradient]\n",
    "            all_median_gradients.append(my_median_gradient)\n",
    "            if my_median_gradient in all_median_intercepts:\n",
    "                all_median_intercepts[my_median_gradient].append(my_median_intercept)\n",
    "            else:\n",
    "                all_median_intercepts[my_median_gradient] = [my_median_intercept]\n",
    "        all_median_gradients.sort()\n",
    "        n_lines = len(all_median_gradients)\n",
    "        #if n_lines % 2 == 0:\n",
    "        if False:\n",
    "            n1 = n_lines // 2 - 1\n",
    "            n2 = n1 + 1\n",
    "            grad1 = all_median_gradients[n1]\n",
    "            grad2 = all_median_gradients[n2]\n",
    "            intercept1 = sum(all_median_intercepts[grad1]) / len(all_median_intercepts[grad1])\n",
    "            intercept2 = sum(all_median_intercepts[grad2]) / len(all_median_intercepts[grad2])\n",
    "            self._gradient = (grad1 + grad2) / 2\n",
    "            self._y_intercept = (intercept1 + intercept2) / 2\n",
    "        else:\n",
    "            n1 = (n_lines) // 2\n",
    "            self._gradient = all_median_gradients[n1]\n",
    "            self._y_intercept = sum(all_median_intercepts[self._gradient]) / len(all_median_intercepts[self._gradient])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e045f212",
   "metadata": {},
   "source": [
    "# P-adic regression\n",
    "\n",
    "Now we get really exotic. What if you don't try to minimise $r^2$, but instead you want to look at whether the\n",
    "points in the data set have residuals that are highly divisible by a prime? For example, you have bit sequences,\n",
    "and you want to make sure that the tail of the bit sequences are as long as possible. (e.g. see my paper at AACL-IJCNLP \"Number Theory Meets Linguistics: Modelling Noun Pluralisation Across 1497 Languages Using 2-adic Metrics\")\n",
    "\n",
    "I can prove that if you are minimising the sum of p-adic residuals, that the line of best fit must pass through\n",
    "two of the points in the dataset.\n",
    "\n",
    "I can't quite prove (but I think it's true) that this is also true if you are trying to minimise the largest\n",
    "residual. (Because the p-adic metric is an ultrametric, max() is more common than sum().) What I also can't prove\n",
    "(but think is true) is that one of the max-minimisers will always also minimise the sum.\n",
    "\n",
    "Anyway, we can brute force our way through finding these lines of best fit. It's only $O(n^3)$ and our dataset is small."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e359f8f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PadicModel(LinearModel):\n",
    "    def __init__(self, prime):\n",
    "        self._prime = prime\n",
    "        LinearModel.__init__(self)\n",
    "    def measure(self, residual):\n",
    "        (n,d) = residual.as_integer_ratio()\n",
    "        if n == 0:\n",
    "            return 0\n",
    "        if d == 0:\n",
    "            raise ValueError\n",
    "        valuation = 0\n",
    "        while n % self._prime == 0:\n",
    "            valuation += 1\n",
    "            n = n // self._prime\n",
    "        while d % self._prime == 0:\n",
    "            valuation -= 1\n",
    "            d = d // self._prime\n",
    "        return fractions.Fraction(1, self._prime) ** valuation\n",
    "    def measure_latex_prefix(self):\n",
    "        return r'\\left|'\n",
    "    def measure_latex_postfix(self):\n",
    "        return r'\\right|_' + str(self._prime)\n",
    "    \n",
    "    def fit(self):\n",
    "        best_gradient = None\n",
    "        best_intercept = None\n",
    "        best_score = None\n",
    "        for i in range(len(self._x_values)):\n",
    "            x1 = self._x_values[i]\n",
    "            y1 = self._y_values[i]\n",
    "            for j in range(i+1, len(self._x_values)):\n",
    "                x2 = self._x_values[j]\n",
    "                y2 = self._y_values[j]\n",
    "                if x1 == x2:\n",
    "                    continue\n",
    "                gradient = fractions.Fraction(y2-y1, x2-x1)\n",
    "                y_intercept = fractions.Fraction(y2 - x2 * gradient)\n",
    "                residuals = []\n",
    "                residual_sizes = []\n",
    "                for k in range(len(self._x_values)):\n",
    "                    x3 = self._x_values[k]\n",
    "                    y3 = self._y_values[k]\n",
    "                    prediction = gradient * x3 + y_intercept\n",
    "                    residuals.append(prediction - y3)\n",
    "                    residual_sizes.append(self.measure(prediction - y3))\n",
    "                overall = self.aggregate_metrics(residual_sizes)\n",
    "                if best_score is None or overall < best_score:\n",
    "                    best_gradient = gradient\n",
    "                    best_intercept = y_intercept\n",
    "                    best_score = overall\n",
    "        self._gradient = best_gradient\n",
    "        self._y_intercept = best_intercept\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aec900a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PadicLinearSumMinimizer(PadicModel):\n",
    "    def __init__(self, prime):\n",
    "        PadicModel.__init__(self, prime)\n",
    "    def aggregate_metrics(self, residual_measures):\n",
    "        return sum(residual_measures)\n",
    "    def title(self):\n",
    "        return f'Minimise sum of {self._prime}-adic residuals'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d305e63",
   "metadata": {},
   "source": [
    "Note what I said above, I'm not sure if this is guaranteed to get the right answer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "3efaa7ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PadicLinearMaxMinimizer(PadicModel):\n",
    "    def __init__(self, prime):\n",
    "        PadicModel.__init__(self, prime)\n",
    "    def aggregate_metrics(self, residual_measures):\n",
    "        return max(residual_measures)\n",
    "    def title(self):\n",
    "        return f'Minimise max of {self._prime}-adic residuals'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "ad4fd3c2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot\n",
    "fig, ax = matplotlib.pyplot.subplots(figsize=(10,6))\n",
    "ax.set_ylim((0,20))\n",
    "ax.scatter(x=[t[0] for t in dataset], y=[t[1] for t in dataset], c=\"red\")\n",
    "ols = OLS()\n",
    "ols.plot(ax=ax, c=\"green\")\n",
    "p3 = PadicLinearSumMinimizer(3)\n",
    "p3.plot(ax=ax, c=\"blue\", linestyle=\"-.\")\n",
    "p5 = PadicLinearSumMinimizer(5)\n",
    "p5.plot(ax=ax, c=\"cyan\", linestyle=\"--\")\n",
    "siegel = Siegel()\n",
    "siegel.plot(ax=ax, c=\"olive\", linestyle=(0,(1,10)))\n",
    "\n",
    "# Feel free to uncomment these... they are nice, but they just add noise to the diagram that starts\n",
    "# to get overwhelming.\n",
    "\n",
    "#ts = TheilSen()\n",
    "#ts.plot(ax=ax, c=\"purple\",linestyle=\":\")\n",
    "#rs = RANSAC()\n",
    "#rs.plot(ax=ax, c=\"orange\",linestyle=\"-.\")\n",
    "\n",
    "ax.legend()\n",
    "ax.set_title(\"Optimal lines through a toy dataset\")\n",
    "fig.savefig(\"toydata-regression.png\")\n",
    "None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "285674e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def nice_format(v):\n",
    "    if type(v) == fractions.Fraction:\n",
    "        if v.denominator == 1:\n",
    "            return str(v)\n",
    "        return r'\\frac{' + f\"{v.numerator}\" + '}{' + f'{v.denominator}' + '}'\n",
    "    if type(v) in [type(0.0), numpy.float64]:\n",
    "        return f\"{v:.3f}\"\n",
    "    return str(v)\n",
    "\n",
    "def latex_table(*models):\n",
    "    output = r'\\renewcommand{\\arraystretch}{1.5}' + '\\n'\n",
    "    output += r'\\begin{tabular}{|rr|'\n",
    "    output += '|'.join(['rrr' for m in models])\n",
    "    output += '|}\\n'\n",
    "    output += r'\\hline' + '\\n'\n",
    "    output += ' & & '\n",
    "    model_titles = ['\\\\multicolumn{3}{p{4cm}|}{' + m.title().replace('r^2', '$r^2$') + '}' for m in models]\n",
    "    output += ' & '.join(model_titles)\n",
    "    output += r'\\\\' + '\\n ' + r'\\multicolumn{2}{|l|}{\\bf Line} & '\n",
    "    model_formulas = ['\\\\multicolumn{3}{l|}{$' + m.formula().replace('y', r'\\hat{y}') + '$}' for m in models]\n",
    "    output += \" & \".join(model_formulas)\n",
    "    output += r'\\\\' + '\\n'\n",
    "    output += r'\\hline' + '\\n'\n",
    "    output += '$x$ & $y$ &'\n",
    "    middle_terms = [r'$\\hat{y}$ & $\\hat{y}-y$ & $' + m.measure_latex_prefix() + '\\hat{y}-y' + m.measure_latex_postfix() + '$' for m in models]\n",
    "    output += ' & '.join(middle_terms)\n",
    "    output += r'\\\\' + '\\n'\n",
    "    for i in range(len(dataset)):\n",
    "        (x,y) = dataset[i]\n",
    "        output += f'{x} & {y} & '\n",
    "        values = []\n",
    "        for m in models:\n",
    "            values.append(nice_format(m._predictions[i]))\n",
    "            values.append(nice_format(m._residuals[i]))\n",
    "            values.append(nice_format(m._residual_impact[i]))\n",
    "        output += '$'\n",
    "        output += '$ & $'.join(values)\n",
    "        output += r'$\\\\' + '\\n'\n",
    "    output += r'\\hline' + '\\n'\n",
    "    output += r'\\multicolumn{2}{|l|}{\\bf Aggregate} & '\n",
    "    values = []\n",
    "    for m in models:\n",
    "        values.append('')\n",
    "        values.append('')\n",
    "        total = nice_format(m._overall_metric)\n",
    "        values.append('$' + total + '$')\n",
    "    output += ' & '.join(values)\n",
    "    output += r'\\\\' + '\\n' + r'\\hline'\n",
    "    output += r'\\end{tabular}' + '\\n'\n",
    "    output += r'\\renewcommand{\\arraystretch}{1}' + '\\n'\n",
    "    return output"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44aad153",
   "metadata": {},
   "source": [
    "Showing the reg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "178fa594",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\renewcommand{\\arraystretch}{1.5}\n",
      "\\begin{tabular}{|rr|rrr|rrr|rrr|}\n",
      "\\hline\n",
      " & & \\multicolumn{3}{p{4cm}|}{Ordinary least squares regression (minimise the sum of $r^2$)} & \\multicolumn{3}{p{4cm}|}{Minimise sum of 3-adic residuals} & \\multicolumn{3}{p{4cm}|}{Minimise sum of 5-adic residuals}\\\\\n",
      " \\multicolumn{2}{|l|}{\\bf Line} & \\multicolumn{3}{l|}{$\\hat{y} = 1.571 x + 1.667$} & \\multicolumn{3}{l|}{$\\hat{y} = x / 2 + 5/2$} & \\multicolumn{3}{l|}{$\\hat{y} = 3 x$}\\\\\n",
      "\\hline\n",
      "$x$ & $y$ &$\\hat{y}$ & $\\hat{y}-y$ & $\\left(\\hat{y}-y\\right)^2$ & $\\hat{y}$ & $\\hat{y}-y$ & $\\left|\\hat{y}-y\\right|_3$ & $\\hat{y}$ & $\\hat{y}-y$ & $\\left|\\hat{y}-y\\right|_5$\\\\\n",
      "1 & 3 & $3.238$ & $-0.238$ & $0.057$ & $3$ & $0$ & $0$ & $3$ & $0$ & $0$\\\\\n",
      "2 & 6 & $4.810$ & $1.190$ & $1.417$ & $\\frac{7}{2}$ & $\\frac{5}{2}$ & $1$ & $6$ & $0$ & $0$\\\\\n",
      "3 & 4 & $6.381$ & $-2.381$ & $5.669$ & $4$ & $0$ & $0$ & $9$ & $-5$ & $\\frac{1}{5}$\\\\\n",
      "4 & 12 & $7.952$ & $4.048$ & $16.383$ & $\\frac{9}{2}$ & $\\frac{15}{2}$ & $\\frac{1}{3}$ & $12$ & $0$ & $0$\\\\\n",
      "5 & 5 & $9.524$ & $-4.524$ & $20.465$ & $5$ & $0$ & $0$ & $15$ & $-10$ & $\\frac{1}{5}$\\\\\n",
      "6 & 13 & $11.095$ & $1.905$ & $3.628$ & $\\frac{11}{2}$ & $\\frac{15}{2}$ & $\\frac{1}{3}$ & $18$ & $-5$ & $\\frac{1}{5}$\\\\\n",
      "\\hline\n",
      "\\multicolumn{2}{|l|}{\\bf Aggregate} &  &  & $47.619$ &  &  & $\\frac{5}{3}$ &  &  & $\\frac{3}{5}$\\\\\n",
      "\\hline\\end{tabular}\n",
      "\\renewcommand{\\arraystretch}{1}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(latex_table(ols, p3, p5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "da3b8331",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('toydata-data.tex', 'w') as f:\n",
    "    f.write(latex_table(ols,p3,p5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60a9ece9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c4bdf531",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}