diff --git a/notebooks/machine-learning/21.a-linear-model-by-hand.ipynb b/notebooks/machine-learning/21.a-linear-model-by-hand.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..9a7946d20329f3df125f2ddcc64b6121309eeddf
--- /dev/null
+++ b/notebooks/machine-learning/21.a-linear-model-by-hand.ipynb
@@ -0,0 +1,771 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "c7ae78da-efe7-41ab-a8a0-3573921477d8",
+ "metadata": {},
+ "source": [
+ "# Un modèle de régression linéaire à la main"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ec36c5e2-e33a-4dc4-97bc-b892795b6d8c",
+ "metadata": {},
+ "source": [
+ "Dans le but double de démystifier les algorithmes mis en œuvre dans le *machine learning* et de se réapproprier ses concepts, nous allons résoudre un modèle de régression linéaire à la main. Après un court rappel sur l’équation réduite d’une droite, nous établirons une droite de régression à partir de la méthode des moindres carrés.\n",
+ "\n",
+ "Chargeons toutes les librairies dont nous aurons besoin pour ce calepin :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d0926f26-5128-413c-80c0-0bb2b23279fe",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "import pandas as pd\n",
+ "import seaborn as sns\n",
+ "from sklearn.metrics import r2_score"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd13e526-eaf9-4b82-8289-33b9f0dc48e0",
+ "metadata": {},
+ "source": [
+ "Et quelques jeux de données qui se prêteront à nos envies :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "86bf18aa-4f66-4d97-ae84-d9778c7b959d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "davis = pd.read_csv(\"./files/davis.csv\", delimiter=\"\\t\", index_col=[0])\n",
+ "penguins = pd.read_csv(\"./files/penguin-census.csv\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f4439ae1-8f76-43f4-959b-8897abc07018",
+ "metadata": {},
+ "source": [
+ "## Une régression linéaire ?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6f6966df-0f7d-4e7a-9ec4-d0f58ee49ad1",
+ "metadata": {},
+ "source": [
+ "Pour la petite histoire, c’est en 1886 que le terme de régression apparaît pour la première fois, dans un article de Sir Francis Galton qu’il publie sous le titre de *Regression Towards Mediocrity in Hereditary Stature*. Dans cet article, il mettait en évidence que les enfants de personnes de grandes tailles avaient tendance à être plus petits qu’elles, et inversement, d’où l’idée d’une régression vers la médiocrité pour décrire en fait un phénomène d’attraction de la moyenne.\n",
+ "\n",
+ "Prenons l’enquête [*Self-Reports of Height and Weight*](./0.about-datasets.ipynb#Self-Reports-of-Height-and-Weight) (Davis, 1990) et affichons un nuage de points à partir des variables *repwt* en abscisses et *repht* en ordonnées afin d’observer qu’elles ont l’air corrélées (à chaque fois que $x$ augmente, $y$ augmente en conséquence) :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "dae64660-3ffd-403c-ae4f-bf65774cdfb4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "_ = sns.scatterplot(data=davis, x=\"repwt\", y=\"repht\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c9c70b0f-7045-4013-a169-4a11af578da6",
+ "metadata": {},
+ "source": [
+ "Si nous affichons maintenant une droite qui passe au milieu de ces points de telle manière qu’elle réduit au mieux la distance avec eux tous, nous obtenons une régression linéaire :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9482302e-74c3-4d3b-9f41-d829c6088139",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "_ = sns.regplot(data=davis, x=\"repwt\", y=\"repht\", ci=None)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2e8b9d97-8aaf-400c-8a9e-a75f1c0f4063",
+ "metadata": {},
+ "source": [
+ "Un tel modèle de régression linéaire permet d’estimer l’une de ces variables si l’autre est manquante (p. ex. : on pourrait estimer qu’une personne déclarant peser 60 kgs penserait mesurer 1,65 m)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "84035a84-2b14-490d-acc5-d978390c5b3e",
+ "metadata": {},
+ "source": [
+ "## Rappels sur l’équation réduite d’une droite"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7f140f77-fdaa-433f-9635-27216dde7a9c",
+ "metadata": {},
+ "source": [
+ "Dans un plan orthonormé, une droite passe au minimum par deux points de coordonnées $(x1;y1)$ et $(x2;y2)$. Elle est caractérisée par une pente, son coefficient directeur, et par son ordonnée à l’origine, c’est-à -dire l’ordonnée de son point d’intersection avec l’axe des ordonnées. Dans la formule $y = b + mx$, le terme $m$ est le coefficient directeur et $b$ l’ordonnée à l’origine.\n",
+ "\n",
+ "Commençons par matérialiser une droite quelconque dans un plan en considérant les points de coordonnées $(2;3)$ et $(4;9)$ afin de se rendre compte que lorsque $x$ augmente de deux unités, $y$ augmente de six unités. :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "894adc97-bf7e-43f2-bd40-48aab75a96a7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x = [2, 4]\n",
+ "y = [3, 9]\n",
+ "\n",
+ "plt.xlim([0, 10])\n",
+ "plt.ylim([0, 10])\n",
+ "sns.regplot(x=x, y=y, ci=None)\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b28bc627-4792-4512-a3b4-197bca052961",
+ "metadata": {},
+ "source": [
+ "### Le coefficient directeur"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e93b63c3-dc69-4465-8c10-2d9989394979",
+ "metadata": {},
+ "source": [
+ "Le coefficient directeur détermine la pente de la droite : s’il est positif, la droite monte ; s’il est négatif, la droite descend. Pour le calculer, la formule est :\n",
+ "\n",
+ "$$m = \\frac{\\Delta y}{\\Delta x}$$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3e96c096-3361-432f-8461-e2956ac0dbb9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "m = (y[0] - y[1]) / (x[0] - x[1])\n",
+ "print(f\"Le coefficient directeur de la droite est : {m}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "de1efd80-7cc1-4160-a8b6-5ad9d205322a",
+ "metadata": {},
+ "source": [
+ "### L’ordonnée à l’origine"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b98deca2-e422-4b97-81c7-6e6ca5ebde8a",
+ "metadata": {},
+ "source": [
+ "Maintenant que vous connaissez $m$, il reste à calculer $b$, qui est l’ordonnée à l’origine. Or, vous savez que l’un des points de cette droite a pour coordonnées $(2;3)$, qui en est une solution. C’est-à -dire que lorsque $x$ vaut 2, alors $y$ vaut 3. Le droite qui vous occupe a donc pour équation :\n",
+ "\n",
+ "$$y = 3x + b$$\n",
+ "\n",
+ "D’où :\n",
+ "\n",
+ "$$\\begin{eqnarray} \n",
+ "3 &=& 3 \\times 2 + b \\\\\n",
+ "- b &=& 3 \\times 2 - 3 \\\\\n",
+ "b &=& - 3 \\times 2 + 3 \\\\\n",
+ "&=& - 6 + 3 \\\\\n",
+ "&=& - 3\n",
+ "\\end{eqnarray}$$\n",
+ "\n",
+ "La forme canonique se déduit simplement :\n",
+ "\n",
+ "$$b = y - mx$$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b93e90ce-ecd4-4c45-ae91-a0acf37f31e9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "b = y[0] - m * x[0]\n",
+ "print(f\"L’ordonnée à l’origine est : {b}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cb89a53-8fe1-48f2-9168-6987f28d794d",
+ "metadata": {},
+ "source": [
+ "Il est maintennat possible d’afficher cet autre point de coordonnées $(0;-3)$ sur la droite afin de vérifier graphiquement si la solution est correcte :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6109e7e4-8bef-431c-b8a7-6978ffb6d4a5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x = [2, 4, 0]\n",
+ "y = [3, 9, -3]\n",
+ "\n",
+ "plt.xlim([-1, 10])\n",
+ "plt.ylim([-4, 10])\n",
+ "sns.regplot(x=x, y=y, ci=None)\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "90008fb4-5e5f-408f-be59-9ce538b281c9",
+ "metadata": {},
+ "source": [
+ "Aucun doute, l’équation réduite de la droite est : $y = 3x - 3$. Une conclusion qui nous amène à effectuer des prédictions efficaces :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6b24dc05-37b6-4494-8135-afe1e8c1aead",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for value in [8, 12, 189]:\n",
+ " print(f\"Si x vaut {value}, alors y vaudra {3 * value - 3}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e9d6233c-6132-4dc4-b550-cf8a095dc76d",
+ "metadata": {},
+ "source": [
+ "## Calculer une droite de régression"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d1ca313a-bcb8-469a-9051-1f68d435b9ba",
+ "metadata": {},
+ "source": [
+ "L’exemple introductif montrait comment calculer l’équation réduite d’une droite dont on connaît deux points. Le problème dans le cas de la régression, c’est qu’on ne les connaît pas, les points.\n",
+ "\n",
+ "Matérialisons concrètement la question avec le jeu de données sur [les manchots en Antarctique](./0.about-datasets.ipynb#Size-measurements-for-adult-foraging-penguins-near-Palmer-Station,-Antarctica) (Gorman, 2014) :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4acbd633-57c9-42bf-89a9-fd8bad11eb0c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(12,5))\n",
+ "sns.scatterplot(data=penguins, x=\"body_mass_g\", y=\"flipper_length_mm\", ax=ax1)\n",
+ "sns.regplot(data=penguins, x=\"body_mass_g\", y=\"flipper_length_mm\", ci=None, ax=ax2)\n",
+ "sns.despine()\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c8bb6cbc-857c-48ba-9fa0-ea843375c9c1",
+ "metadata": {},
+ "source": [
+ "Nous venons d’afficher deux nuages de points qui représentent deux caractéristiques des manchots : la masse en grammes sur l’axe des abscisses et la longueur des nageoires en millimètres sur l’axe des ordonnées. Nous notons clairement une tendance : lorsque la masse d’un manchot augmente, la longueur de ses nageoires aussi. Ceci dit, la relation entre les deux caractéristiques n’est pas réellement linéaire : aucun individu n’est identique et nous ne pouvons être sûr·es que, si un manchot pèse 500 g de plus qu’un autre, ses nageoires mesureront 10 mm de plus.\n",
+ "\n",
+ "Sur le graphique de droite, nous avons en plus affiché la droite de régression. Cette droite vous montre la tendance centrale qui minimise la somme des erreurs pour toutes les observations et qui nous permettrait en plus de prédire pour une certaine masse la longueur des nageoires d’un manchot."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "80daa84f-0307-41e6-af09-39546979cdd6",
+ "metadata": {
+ "tags": []
+ },
+ "source": [
+ "## La droite de régression des moindres carrés"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1d8e6848-37c5-4ef5-a9e2-35cc3117cded",
+ "metadata": {},
+ "source": [
+ "Lorsque nous prenons les coordonnées d’une observation, nous remarquons qu’elles sont éloignées de la droite. Il existe un décalage – que l’on appelle communément une erreur – et la droite de régression des moindres carrés est celle qui minimise la somme des carrés de toutes les erreurs. Le rapport s’établit au carré afin d’éviter les valeurs négatives."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "86724e91-c9f3-4a38-9873-81df4ff99c17",
+ "metadata": {},
+ "source": [
+ "### La formule"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3c7d8e74-99d8-4d7d-9c03-0d2e03636713",
+ "metadata": {},
+ "source": [
+ "L’équation réduite qui permet d’obtenir les coordonnées de tous les points de la droite et, partant, d’obtenir une prédiction de $\\hat{y}$ en fonction de $x$ respecte la forme $\\hat{y} = mx + b$. Deux étapes majeures pour la trouver, calculer d’abord le coefficient directeur $m$ puis l’ordonnée à l’origine $b$."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e067a08e-1d6b-48e4-ae9d-babf78d73f18",
+ "metadata": {},
+ "source": [
+ "### Calculer le coefficient directeur"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "084ee5b7-fb3d-4367-bf49-afcd58420f61",
+ "metadata": {},
+ "source": [
+ "La résolution du coefficient directeur d’une droite des moindres carré est régi par la formule ci-dessous :\n",
+ "\n",
+ "$$m = \\frac{n\\sum xy - \\sum x \\sum y}{n \\sum x^2 - \\left(\\sum x\\right)^2}$$\n",
+ "\n",
+ "De cette formule, nous concluons avoir besoin de connaître :\n",
+ "- le nombre $n$ des observations ;\n",
+ "- la somme du produit de $x$ et de $y$Â ;\n",
+ "- la somme de $x$ et son carré ;\n",
+ "- la somme de $y$Â ;\n",
+ "- la somme des carrés de $x$.\n",
+ "\n",
+ "Commençons par définir un nouveau *data frame* avec l’ensemble des valeurs pour les caractéristiques *body_mass_g* et *flipper_length_mm*. Parmi toutes les manières de procéder, l’une d’elles mobilise la propriété `.loc[]` d’un *data frame* avec la liste des colonnes à conserver :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "912d47a6-d3b7-4f19-9ae1-bbad5de4790f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "coords = penguins.loc[:, [\"body_mass_g\",\"flipper_length_mm\"]]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9e18cd1b-7f98-4a55-a5c4-bc37c0bcb02d",
+ "metadata": {},
+ "source": [
+ "Dans un deuxième temps, nous supprimons par commodité les observations qui contiennent des valeurs nulles :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d5739b0b-df78-4ccf-93f5-8fae9a22b450",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# only 2 na, drop them\n",
+ "coords = coords.dropna()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "85f0e56b-b1d0-4148-bf8c-5b6f06101b81",
+ "metadata": {},
+ "source": [
+ "Transformons maintenant le *data frame* en matrice *Numpy* grâce à la méthode `.to_numpy()` :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e03c1e82-acbd-4d6e-a084-68c1e897f661",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "coords = coords.to_numpy()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e7dd2bc2-a577-4c7d-86a1-7336509bf5b6",
+ "metadata": {},
+ "source": [
+ "Chaque ligne du tableau est désormais un couple de coordonnées $x$ et $y$ :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "553befd1-266c-43da-83d8-f3c7b5d70363",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# first 5 points\n",
+ "coords[:5]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cb7b8754-d0da-4e81-bfdd-ae81fabff4f1",
+ "metadata": {},
+ "source": [
+ "Pour accéder, depuis une matrice $a$, aux valeurs d’une dimension $d$, on utilse la syntaxe `a[:, d]`. Ici, les $x$ étant affectés à la dimension 0 :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2af85c01-ab72-4159-9602-61f27c1b4894",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "coords[:5, 0]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7b779e22-a1f6-453b-8d68-feaa35190b67",
+ "metadata": {},
+ "source": [
+ "Il nous reste à rajouter deux dimensions à la matrice pour :\n",
+ "- le produit de $x$ et $y$Â ;\n",
+ "- le carré de $x$.\n",
+ "\n",
+ "Utilisons la méthode `.column_stack()` de *Numpy* :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "687f35fd-6f5d-4a41-bcad-d9eaffc9b56b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data = np.column_stack((\n",
+ " # dim 0 : x\n",
+ " # dim 1 : y\n",
+ " coords,\n",
+ " # dim 2 : x times y\n",
+ " coords[:, 0] * coords[:, 1],\n",
+ " # dim 3 : x square\n",
+ " coords[:, 0] ** 2\n",
+ "))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "49c75935-8b1f-4fb4-bf49-b948a92ffc5b",
+ "metadata": {},
+ "source": [
+ "Ou l’écriture raccourcie `c_` :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "75432cce-70a8-4e90-8c1d-75c8c87a127b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data = np.c_[\n",
+ " coords,\n",
+ " coords[:, 0] * coords[:, 1],\n",
+ " coords[:, 0] ** 2\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "41c0b6b8-a5f5-47ee-97ef-a9b0a82355a1",
+ "metadata": {},
+ "source": [
+ "Il ne nous reste plus qu’à remplacer les inconnues de la formule par la somme des différents éléments de la matrice pour calculer le coefficient directeur :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a9db52b4-98f7-4bfb-b5ed-2bd687231cd8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def slope(nd):\n",
+ " \"\"\"Return the slope of a straight line.\n",
+ "\n",
+ " Argument:\n",
+ " nd -- a numpy array with the following dimensions:\n",
+ " 0: x\n",
+ " 1: y\n",
+ " 2: x times y\n",
+ " 3: x square\n",
+ " \"\"\"\n",
+ "\n",
+ " n = len(nd)\n",
+ " sum_x = sum(nd[:, 0])\n",
+ " sum_y = sum(nd[:, 1])\n",
+ " sum_xy = sum(nd[:, 2])\n",
+ " sum_x2 = sum(nd[:, 3])\n",
+ "\n",
+ " return (n * sum_xy - sum_x * sum_y) / (n * sum_x2 - sum_x ** 2)\n",
+ "\n",
+ "m = slope(data)\n",
+ "\n",
+ "print(f\"Le coefficient directeur vaut : {m}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b3e41057-2f19-4b51-bfae-c7c9249fc9f7",
+ "metadata": {},
+ "source": [
+ "### Calculer l’ordonnée à l’origine"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1fc012b2-842c-4277-8445-240b385d7e03",
+ "metadata": {},
+ "source": [
+ "La formule de résolution de l’ordonnée à l’origine fait appel au coefficient directeur et aux moyennes des valeurs de $x$ et de $y$ :\n",
+ "\n",
+ "$$b = \\bar{y} - m\\bar{x}$$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5b57f415-c877-4706-8a70-5bb4628ec5c4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def intercept(m, d):\n",
+ " \"\"\"Intercept of a straight line.\n",
+ " \n",
+ " Arguments:\n",
+ " m -- slope\n",
+ " d -- a numpy array\n",
+ " \"\"\"\n",
+ "\n",
+ " avg_y = np.average(d[:, 1])\n",
+ " avg_x = np.average(d[:, 0])\n",
+ " \n",
+ " return avg_y - (m * avg_x)\n",
+ "\n",
+ "b = intercept(m, data)\n",
+ "\n",
+ "print(f\"L’ordonnée à l’origine vaut : {m}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9281171e-fb3c-498d-aa84-997268094bea",
+ "metadata": {},
+ "source": [
+ "### Afficher le graphique"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7cb8b33f-0ecd-4fd9-a9af-41d5dbc85030",
+ "metadata": {},
+ "source": [
+ "Nous disposons maintenant de tous les éléments pour mettre en place le graphique.\n",
+ "\n",
+ "Définissons tout d’abord une fonction de signature `F(*, x, m, b) -> float` qui renvoie l’équation réduite d’une droite. Elle nous servira à effectuer des prédictions à partir du coefficient directeur $m$, de l’ordonnée à l’origine $b$ et d’une valeur de $x$ :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8d7643ad-dfe9-48cc-8b42-0ee19df24b79",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def F(*, x, m, b) -> float:\n",
+ " \"\"\"Solution to the standard form equation\n",
+ " of a straight line.\n",
+ " \n",
+ " Keyword-only arguments:\n",
+ " x -- value of x\n",
+ " m -- slope\n",
+ " b -- intercept\n",
+ " \"\"\"\n",
+ " return m * x + b"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dfe1bab9-e161-43a3-be81-8968e3484575",
+ "metadata": {},
+ "source": [
+ "Instancions deux variables nommées `X` et `Y` pour recevoir respectivement tous les $x$ et tous les $y$ de la matrice *Numpy* :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "80af0aea-562d-4c1f-8785-c9b04a1cd1d4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "X = data[:, 0]\n",
+ "Y = data[:, 1]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "54e98919-9d0d-464b-9d57-849fc52630e9",
+ "metadata": {},
+ "source": [
+ "Et constituons une matrice `Y_pred` pour les prédictions à partir des valeurs contenues dans `X` :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "82eca1e9-ab03-4a04-945c-ed1029bedd6b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "Y_pred = [ F(x=x, m=m, b=b) for x in X ]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c5c48ef3-323e-4a9c-9bf4-8a4f49199f1d",
+ "metadata": {},
+ "source": [
+ "Le graphique :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "489671d0-e90f-4265-9507-9fbd6478c2c3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ax = plt.subplots()\n",
+ "\n",
+ "ax = sns.lineplot(x=X, y=Y_pred, color=\"fuchsia\")\n",
+ "ax = sns.scatterplot(x=X, y=Y, color=\"seagreen\")\n",
+ "\n",
+ "ax.set(xlabel=\"Body mass (g)\", ylabel=\"Flipper length (mm)\")\n",
+ "\n",
+ "sns.despine()\n",
+ "\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7f5a797b-4125-4406-86ba-be8fef4544a5",
+ "metadata": {},
+ "source": [
+ "La droite est strictement identique à celle obtenue par *Seaborn*, mais nous l’avons calculée à la main, en nous reposant sur des principes mathématiques simples. De là , on peut estimer la taille des nageoires d’un manchot en fonction de son poids :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ae0d5576-4ad4-404a-893d-f26e2bdb7c99",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x = 7890\n",
+ "r = F(x=x, m=m, b=b)\n",
+ "\n",
+ "print(f\"Un manchot de 7,89 kgs aurait des nageoires de {r:.2f} mm\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6acf30c7-2329-4c95-9fe5-0649d803dcdc",
+ "metadata": {},
+ "source": [
+ "## Établir une mesure de la performance du modèle"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "94e9966f-dd0a-4b4e-aa89-98c8a1811d04",
+ "metadata": {},
+ "source": [
+ "Si la droite obtenue par un calcul manuel correspond plus ou moins à la géométrie des données, il reste à évaluer la performance du modèle. Dire qu’un manchot de 7,89 kgs aurait des nageoires de 257,26 mm ne nous dit rien sur la qualité de la prédiction."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "629d4859-0618-4d97-bd68-d3d123a020d1",
+ "metadata": {},
+ "source": [
+ "### Le coefficient de détermination linéaire de Pearson ($R^2$)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b6b5d5b1-a027-43b1-b820-96492403dabe",
+ "metadata": {},
+ "source": [
+ "Si la géométrie des données est linéaire et qu’une seule variable explicative est concernée par le modèle, le *$R^2$ score* peut se révéler un indicateur fiable de la qualité d’une prédiction. Comme il est situé dans un intervalle $[0;1]$, on peut facilement en calculer un pourcentage :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "329b5bfc-6a0a-4301-b9ef-896985668851",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "r = F(x=3120, m=m, b=b)\n",
+ "r2 = r2_score(Y, F(x=X, m=m, b=b))\n",
+ "\n",
+ "print(\n",
+ " f\"Un manchot pesant 3,12 kgs aurait des nageoires de {r:.2f} mm\",\n",
+ " f\"La qualité de la prédiction est estimée à {r2:.2%} selon la méthode du coefficient de détermination linéaire de Pearson.\",\n",
+ " sep=\"\\n\"\n",
+ ")"
+ ]
+ }
+ ],
+ "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.6"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}