notebooks/linear_models_sol_01.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# \ud83d\udcc3 Solution for Exercise M4.01\n",
    "\n",
    "The aim of this exercise is two-fold:\n",
    "\n",
    "* understand the parametrization of a linear model;\n",
    "* quantify the fitting accuracy of a set of such models.\n",
    "\n",
    "We will reuse part of the code of the course to:\n",
    "\n",
    "* load data;\n",
    "* create the function representing a linear model.\n",
    "\n",
    "## Prerequisites\n",
    "\n",
    "### Data loading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"admonition note alert alert-info\">\n",
    "<p class=\"first admonition-title\" style=\"font-weight: bold;\">Note</p>\n",
    "<p class=\"last\">If you want a deeper overview regarding this dataset, you can refer to the\n",
    "Appendix - Datasets description section at the end of this MOOC.</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "penguins = pd.read_csv(\"../datasets/penguins_regression.csv\")\n",
    "feature_name = \"Flipper Length (mm)\"\n",
    "target_name = \"Body Mass (g)\"\n",
    "data, target = penguins[[feature_name]], penguins[target_name]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "source": [
    "### Model definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def linear_model_flipper_mass(\n",
    "    flipper_length, weight_flipper_length, intercept_body_mass\n",
    "):\n",
    "    \"\"\"Linear model of the form y = a * x + b\"\"\"\n",
    "    body_mass = weight_flipper_length * flipper_length + intercept_body_mass\n",
    "    return body_mass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Main exercise\n",
    "\n",
    "Given a vector of the flipper length, several weights and intercepts to\n",
    "plot several linear model that could fit our data. Use the above\n",
    "visualization helper function to visualize both the model and data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "flipper_length_range = np.linspace(data.min(), data.max(), num=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "weights = [-40, 45, 90]\n",
    "intercepts = [15000, -5000, -14000]\n",
    "\n",
    "ax = sns.scatterplot(data=penguins, x=feature_name, y=target_name,\n",
    "                     color=\"black\", alpha=0.5)\n",
    "\n",
    "label = \"{0:.2f} (g / mm) * flipper length + {1:.2f} (g)\"\n",
    "for weight, intercept in zip(weights, intercepts):\n",
    "    predicted_body_mass = linear_model_flipper_mass(\n",
    "        flipper_length_range, weight, intercept)\n",
    "\n",
    "    ax.plot(flipper_length_range, predicted_body_mass,\n",
    "            label=label.format(weight, intercept))\n",
    "_ = ax.legend(loc='center left', bbox_to_anchor=(-0.25, 1.25), ncol=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "source": [
    "In the previous question, you were asked to create several linear models.\n",
    "The visualization allowed you to qualitatively assess if a model was better\n",
    "than another.\n",
    "\n",
    "Now, you should come up with a quantitative measure which will indicate the\n",
    "goodness of fit of each linear model. This quantitative metric should result\n",
    "in a single scalar and allow you to pick up the best model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def goodness_fit_measure(true_values, predictions):\n",
    "    # we compute the error between the true values and the predictions of our\n",
    "    # model\n",
    "    errors = np.ravel(true_values) - np.ravel(predictions)\n",
    "    # We have several possible strategy to reduce all errors to a single value.\n",
    "    # Computing the mean error (sum divided by the number of element) looks\n",
    "    # like a good solution. However, we have negative error and therefore, we\n",
    "    # need to sum only positive numbers. Therefore, we can either square each\n",
    "    # error or take the absolute value: these metrics are known as mean\n",
    "    # squared error (MSE) and mean absolute error (MAE). Let's use the MAE here\n",
    "    # as an example.\n",
    "    return np.mean(np.abs(errors))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for model_idx, (weight, intercept) in enumerate(zip(weights, intercepts)):\n",
    "    target_predicted = linear_model_flipper_mass(data, weight, intercept)\n",
    "    print(f\"Model #{model_idx}:\")\n",
    "    print(f\"{weight:.2f} (g / mm) * flipper length + {intercept:.2f} (g)\")\n",
    "    print(f\"Error: {goodness_fit_measure(target, target_predicted):.3f}\\n\")"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "cell_metadata_filter": "-all",
   "main_language": "python",
   "notebook_metadata_filter": "-all"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}