{"metadata":{"kernelspec":{"name":"python3","display_name":"Python 3","language":"python"},"language_info":{"name":"python","version":"3.12.12","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceType":"datasetVersion","sourceId":14413364,"datasetId":9205632,"databundleVersionId":15229372}],"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Machine learning 2 : Regression (FR) v2.2 (version étudiant)","metadata":{}},{"cell_type":"markdown","source":"**Pascal Yim - Ecole Centrale de Lille - janvier 2026**\n\n```python\n# Imports: numpy pour le calcul numérique, matplotlib pour tracer, pandas pour les DataFrames, plotly pour les graphiques interactifs\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nimport pandas as pd\n\nimport plotly.express as px\n```\n","metadata":{}},{"cell_type":"code","source":"# Imports: numpy pour le calcul numérique, matplotlib pour tracer, pandas pour les DataFrames, plotly pour les graphiques interactifs\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nimport pandas as pd\n\nimport plotly.express as px","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T00:03:22.829759Z","iopub.execute_input":"2026-05-07T00:03:22.830043Z","iopub.status.idle":"2026-05-07T00:03:25.529969Z","shell.execute_reply.started":"2026-05-07T00:03:22.830010Z","shell.execute_reply":"2026-05-07T00:03:25.529048Z"}},"outputs":[],"execution_count":1},{"cell_type":"code","source":"df = pd.read_csv('/kaggle/input/datasets/pyim59/mini-datasets/co2_mini.csv')\ndf.head()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T00:04:38.759202Z","iopub.execute_input":"2026-05-07T00:04:38.760157Z","iopub.status.idle":"2026-05-07T00:04:38.793152Z","shell.execute_reply.started":"2026-05-07T00:04:38.760121Z","shell.execute_reply":"2026-05-07T00:04:38.792260Z"}},"outputs":[{"execution_count":3,"output_type":"execute_result","data":{"text/plain":" consumption co2\n0 8.5 196\n1 9.6 221\n2 5.9 136\n3 11.1 255\n4 10.6 244","text/html":"
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
consumptionco2
08.5196
19.6221
25.9136
311.1255
410.6244
\n
"},"metadata":{}}],"execution_count":3},{"cell_type":"code","source":"x = df['consumption']\ny = df['co2']","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T00:09:42.402533Z","iopub.execute_input":"2026-05-07T00:09:42.403032Z","iopub.status.idle":"2026-05-07T00:09:42.407999Z","shell.execute_reply.started":"2026-05-07T00:09:42.402968Z","shell.execute_reply":"2026-05-07T00:09:42.407058Z"}},"outputs":[],"execution_count":12},{"cell_type":"code","source":"x_bar = x.mean()\ny_bar = y.mean()\n\na = np.sum((x-x_bar)*(y-y_bar))/np.sum((x-x_bar)**2)\nb = y_bar - a*x_bar\n\ny_hat = a*x+b","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T00:14:27.779532Z","iopub.execute_input":"2026-05-07T00:14:27.780078Z","iopub.status.idle":"2026-05-07T00:14:27.790333Z","shell.execute_reply.started":"2026-05-07T00:14:27.780025Z","shell.execute_reply":"2026-05-07T00:14:27.789078Z"}},"outputs":[],"execution_count":19},{"cell_type":"code","source":"class RegressionLineaire:\n def __init__(self):\n self.a = 2\n self.b = 1\n\n def predict(self, x):\n return self.a*x + self.b\n\n def fit(self, x, y):\n x_bar = x.mean()\n y_bar = y.mean()\n self.a = np.sum((x-x_bar)*(y-y_bar))/np.sum((x-x_bar)**2)\n self.b = y_bar - self.a*x_bar","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T00:23:41.925243Z","iopub.execute_input":"2026-05-07T00:23:41.925681Z","iopub.status.idle":"2026-05-07T00:23:41.932935Z","shell.execute_reply.started":"2026-05-07T00:23:41.925642Z","shell.execute_reply":"2026-05-07T00:23:41.931916Z"}},"outputs":[],"execution_count":21},{"cell_type":"code","source":"model = RegressionLineaire()\nmodel.fit(x,y)\ny_hat = model.predict(x)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T00:23:44.273220Z","iopub.execute_input":"2026-05-07T00:23:44.273595Z","iopub.status.idle":"2026-05-07T00:23:44.282028Z","shell.execute_reply.started":"2026-05-07T00:23:44.273564Z","shell.execute_reply":"2026-05-07T00:23:44.280995Z"}},"outputs":[],"execution_count":22},{"cell_type":"code","source":"\n\nplt.scatter(x, y)\nplt.plot(x, y_hat, c='red')","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T00:23:46.663060Z","iopub.execute_input":"2026-05-07T00:23:46.663545Z","iopub.status.idle":"2026-05-07T00:23:46.872514Z","shell.execute_reply.started":"2026-05-07T00:23:46.663500Z","shell.execute_reply":"2026-05-07T00:23:46.871600Z"}},"outputs":[{"execution_count":23,"output_type":"execute_result","data":{"text/plain":"[]"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"
","image/png":"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\n"},"metadata":{}}],"execution_count":23},{"cell_type":"code","source":"plt.scatter","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T00:05:22.101014Z","iopub.execute_input":"2026-05-07T00:05:22.101408Z","iopub.status.idle":"2026-05-07T00:05:22.107880Z","shell.execute_reply.started":"2026-05-07T00:05:22.101373Z","shell.execute_reply":"2026-05-07T00:05:22.107030Z"}},"outputs":[{"execution_count":5,"output_type":"execute_result","data":{"text/plain":" 'PathCollection'>"},"metadata":{}}],"execution_count":5},{"cell_type":"markdown","source":"## Régression des moindres carrés","metadata":{}},{"cell_type":"markdown","source":"### Régression linéaire (moindres carrés) : trouver la meilleure droite\n\nOn cherche une droite :\n$$\n\\hat{y} = a x + b\n$$\nqui approxime au mieux les données $(x_i, y_i)$.\n\n#### Principe : minimiser l’erreur\nOn mesure l’erreur pour chaque point :\n$$\ne_i = y_i - (a x_i + b)\n$$\net on choisit $a$ et $b$ pour minimiser la somme des carrés :\n$$\n\\min_{a,b} \\sum_{i=1}^{n} e_i^2\n$$\nC’est la méthode des **moindres carrés**.\n\n#### Résultat \nEn notant $\\bar{x}$ et $\\bar{y}$ les moyennes :\n$$\na = \\frac{\\sum_i (x_i-\\bar{x})(y_i-\\bar{y})}{\\sum_i (x_i-\\bar{x})^2}\n\\qquad\nb = \\bar{y} - a\\bar{x}\n$$\n\nInterprétation :\n- le numérateur ressemble à une **covariance** (comment $x$ et $y$ varient ensemble)\n- le dénominateur est une **variance** de $x$\n\n#### Calcul des coefficients\n\nOn cherche à déterminer les coefficients $a$ et $b$ de la droite :\n\n$$\n\\hat{y}_i = a x_i + b\n$$\n\nqui approxime au mieux les données $(x_i, y_i)$.\n\n\n##### Fonction de coût à minimiser\n\nLa méthode des moindres carrés consiste à minimiser la somme des carrés des résidus :\n\n$$\nJ(a,b) = \\sum_{i=1}^{n} \\left(y_i - (a x_i + b)\\right)^2\n$$\n\nCette fonction mesure l’erreur globale entre les valeurs observées et les valeurs prédites par le modèle.\n\n\n##### Minimisation par dérivation\n\nLa fonction $J(a,b)$ est quadratique en $a$ et $b$.\nSon minimum est atteint lorsque les dérivées partielles s’annulent :\n\n$$\n\\frac{\\partial J}{\\partial a} = 0\n\\qquad\n\\frac{\\partial J}{\\partial b} = 0\n$$\n\nCes conditions conduisent aux **équations normales**.\n\n\n##### Dérivée par rapport à $b$\n\nOn dérive $J(a,b)$ par rapport à $b$ :\n\n$$\n\\frac{\\partial J}{\\partial b}\n= -2 \\sum_{i=1}^{n} \\left(y_i - (a x_i + b)\\right)\n$$\n\nEn posant cette dérivée égale à zéro :\n\n$$\n\\sum_{i=1}^{n} \\left(y_i - a x_i - b\\right) = 0\n$$\n\nce qui donne :\n\n$$\n\\sum y_i = a \\sum x_i + n b\n$$\n\nEn divisant par $n$ :\n\n$$\n\\bar{y} = a \\bar{x} + b\n$$\n\nd’où :\n\n$$\nb = \\bar{y} - a \\bar{x}\n$$\n\nLa droite de régression passe donc toujours par le point moyen $(\\bar{x}, \\bar{y})$.\n\n\n\n##### Dérivée par rapport à $a$\n\nOn dérive maintenant $J(a,b)$ par rapport à $a$ :\n\n$$\n\\frac{\\partial J}{\\partial a}\n= -2 \\sum_{i=1}^{n} x_i \\left(y_i - (a x_i + b)\\right)\n$$\n\nEn annulant cette dérivée :\n\n$$\n\\sum x_i y_i = a \\sum x_i^2 + b \\sum x_i\n$$\n\nEn remplaçant $b$ par $\\bar{y} - a \\bar{x}$ et en réorganisant les termes, on obtient :\n\n$$\na = \\frac{\\sum_{i=1}^{n} (x_i - \\bar{x})(y_i - \\bar{y})}\n{\\sum_{i=1}^{n} (x_i - \\bar{x})^2}\n$$\n\n\n\n##### Interprétation statistique\n\nLe coefficient $a$ peut s’écrire comme :\n\n$$\na = \\frac{\\mathrm{Cov}(x,y)}{\\mathrm{Var}(x)}\n$$\n\n* le numérateur mesure la manière dont $x$ et $y$ varient ensemble\n* le dénominateur mesure la dispersion de $x$\n\nLa pente est donc élevée lorsque $x$ explique bien les variations de $y$.\n\n\n\n##### Interprétation géométrique\n\nLa droite obtenue :\n\n* minimise la somme des distances verticales au carré\n* équilibre les résidus autour de zéro\n* constitue la meilleure approximation linéaire au sens des moindres carrés\n\n\n","metadata":{}},{"cell_type":"markdown","source":"### 💡 Syntaxe à reprendre\n\n_Repère syntaxique pour aborder l'exercice ci-dessous._\n\n```python\nclass MyLinearRegression:\n\n def __init__(self):\n self.a = None\n self.b = None\n\n def fit(self, x, y):\n x = np.array(x)\n y = np.array(y)\n x_mean = np.mean(x)\n y_mean = np.mean(y)\n numerator = np.sum((x - x_mean) * (y - y_mean))\n denominator = np.sum((x - x_mean) ** 2)\n self.a = numerator / denominator\n self.b = y_mean - self.a * x_mean\n\n def predict(self, x):\n x = np.array(x)\n return self.a * x + self.b\n```\n","metadata":{}},{"cell_type":"markdown","source":"> #### Exercice — Implémenter une régression linéaire simple\n>\n> L’objectif de cet exercice est d’implémenter **manuellement** une régression linéaire simple, sans utiliser de bibliothèque de type *scikit-learn*, afin de comprendre le calcul des coefficients.\n>\n> On considère un modèle de la forme :\n>\n> $$\n\\hat{y} = a x + b\n $$\n>\n> où :\n>\n> * $x$ est la variable explicative\n> * $y$ est la variable cible\n> * $a$ est la pente\n> * $b$ est l’ordonnée à l’origine\n>\n> **Travail demandé**\n>\n> Écrire une classe `MyLinearRegression` contenant :\n>\n> * un constructeur `__init__`\n> * une méthode `fit(x, y)` qui calcule les coefficients $a$ et $b$\n> * une méthode `predict(x)` qui renvoie les valeurs prédites $\\hat{y}$\n>\n>\n> **Contraintes**\n>\n> * ne pas utiliser `scikit-learn`\n> * utiliser uniquement Python et NumPy\n> * `x` et `y` peuvent être des listes, des `Series` Pandas ou des tableaux NumPy\n>\n>\n> **Indications**\n>\n> Les coefficients doivent être calculés à l’aide des formules :\n>\n> $$\n a = \\frac{\\sum_i (x_i - \\bar{x})(y_i - \\bar{y})}\n {\\sum_i (x_i - \\bar{x})^2}\n$$\n>\n> $$\n b = \\bar{y} - a \\bar{x}\n$$\n>\n>\n> **Interface attendue**\n>\n> ```python\n> model = MyLinearRegression()\n> model.fit(x, y)\n>\n> y_hat = model.predict(x)\n> ```\n","metadata":{}},{"cell_type":"markdown","source":"> **Tester sur le dataset co2_mini**","metadata":{}},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"### Figure et superposition de graphiques avec Plotly\n\nDans Plotly, un graphique est organisé autour de deux concepts fondamentaux :\n\n* la **figure**\n* les **traces**\n\nComprendre cette distinction permet de savoir comment superposer plusieurs courbes ou jeux de données sur un même graphique.\n\n\n#### 1. La figure\n\nUne **figure** est le conteneur principal du graphique.\n\nElle définit :\n\n* les axes\n* le titre\n* les labels\n* la zone d’affichage\n\nAvec Plotly Express, une figure est créée automatiquement lors de l’appel à une fonction comme :\n\n```python\nfig = px.scatter(x=x, y=y)\n```\n\nÀ ce stade :\n\n* la figure existe\n* elle contient **une seule trace** correspondant au nuage de points\n\n\n\n#### 2. Les traces\n\nUne **trace** correspond à un jeu de données affiché sur la figure.\n\nPar exemple :\n\n* un nuage de points\n* une courbe\n* un histogramme\n\nChaque appel à Plotly Express crée **une figure avec une ou plusieurs traces**, mais ces traces sont encapsulées dans une figure unique.\n\n\n\n#### 3. Ajouter une trace avec `add_scatter`\n\nPour superposer un second jeu de données sur la même figure, il ne faut pas créer une nouvelle figure, mais **ajouter une trace** à la figure existante.\n\n```python\nfig.add_scatter(\n x=x,\n y=y_hat,\n name=\"Valeurs prédites\"\n)\n```\n\nCette instruction :\n\n* ajoute une nouvelle trace à la figure existante\n* conserve les mêmes axes et la même échelle\n* permet la superposition visuelle des données\n\n```python\nfig = px.scatter(x=x, y=y)\nfig.add_scatter(\n x=x,\n y=y_hat,\n name=\"Valeurs prédites\"\n)\nfig.show()\n```\n","metadata":{}},{"cell_type":"code","source":"fig = px.scatter(x=x, y=y)\nfig.add_scatter(\n x=x,\n y=y_hat,\n name=\"Valeurs prédites\"\n)\nfig.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T00:25:02.241548Z","iopub.execute_input":"2026-05-07T00:25:02.242539Z","iopub.status.idle":"2026-05-07T00:25:02.294376Z","shell.execute_reply.started":"2026-05-07T00:25:02.242493Z","shell.execute_reply":"2026-05-07T00:25:02.293425Z"}},"outputs":[{"output_type":"display_data","data":{"text/html":"\n\n\n
\n
\n\n"},"metadata":{}}],"execution_count":26},{"cell_type":"markdown","source":"### Résidus de la régression linéaire\n\nAprès avoir ajusté un modèle de régression linéaire, il est important d’analyser les **résidus**.\nLes résidus permettent de mesurer **l’erreur de prédiction** du modèle pour chaque observation.\n\n#### Définition d’un résidu\n\nPour une observation ( i ), le résidu est défini comme :\n\n$$\nr_i = y_i - \\hat{y}_i\n$$\n\noù :\n\n* $y_i$ est la valeur réelle observée\n* $\\hat{y}_i$ est la valeur prédite par le modèle\n\nUn résidu positif signifie que le modèle **sous-estime** la valeur réelle.\nUn résidu négatif signifie que le modèle **surestime** la valeur réelle.\n\n\n\n#### Calcul des résidus en Python\n\n```python\nresidus = y - y_hat\n```\n\nChaque résidu correspond à une observation du dataset.\n\n\n#### Visualisation des résidus avec Plotly\n\nUn graphique des résidus permet de vérifier la qualité de l’ajustement du modèle.\n\n```python\nfig = px.scatter(\n x=x,\n y=residus,\n labels={\"x\": \"Consommation\", \"y\": \"Résidu\"},\n title=\"Résidus de la régression linéaire\"\n)\n\nfig.add_hline(y=0)\nfig.show()\n```\n\n\n\n#### Interprétation du graphique des résidus\n\nUn bon modèle linéaire présente généralement :\n\n* des résidus répartis de manière aléatoire autour de 0\n* aucune structure ou tendance visible\n* une dispersion relativement homogène\n\nDes motifs visibles peuvent indiquer :\n\n* une relation non linéaire\n* la présence d’outliers\n* une variance non constante\n\n```python\nresidus = y - y_hat\n\nfig = px.scatter(\n x=x,\n y=residus,\n labels={\"x\": \"Consommation\", \"y\": \"Résidu\"},\n title=\"Résidus de la régression linéaire\"\n)\n\nfig.add_hline(\n y=0,\n line_color=\"red\"\n)\n\nfig.show()\n```\n","metadata":{}},{"cell_type":"code","source":"residus = y - y_hat\n\nfig = px.scatter(\n x=x,\n y=residus,\n labels={\"x\": \"Consommation\", \"y\": \"Résidu\"},\n title=\"Résidus de la régression linéaire\"\n)\n\nfig.add_hline(\n y=0,\n line_color=\"red\"\n)\n\nfig.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T00:26:40.649436Z","iopub.execute_input":"2026-05-07T00:26:40.649885Z","iopub.status.idle":"2026-05-07T00:26:40.719585Z","shell.execute_reply.started":"2026-05-07T00:26:40.649843Z","shell.execute_reply":"2026-05-07T00:26:40.718333Z"}},"outputs":[{"output_type":"display_data","data":{"text/html":"\n\n\n
\n
\n\n"},"metadata":{}}],"execution_count":27},{"cell_type":"code","source":"def MAE(y, y_bar):\n # Mean absolute error\n return np.mean(abs(y-y_bar))\n\ndef MAPE(y, y_bar):\n # Mean absolute percentage error\n return np.mean(abs((y-y_bar)/y))\n\ndef MSE(y, y_bar):\n # Mean squared error\n return np.mean((y-y_bar)**2)\n\ndef RMSE(y, y_bar):\n # Root mean squared error\n return np.sqrt(MSE(y,y_bar))\n\ndef R2(y, y_hat):\n y = np.array(y)\n y_hat = np.array(y_hat)\n \n y_mean = np.mean(y)\n \n ss_res = np.sum((y - y_hat) ** 2)\n ss_tot = np.sum((y - y_mean) ** 2)\n \n return 1 - ss_res / ss_tot\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T00:43:20.440561Z","iopub.execute_input":"2026-05-07T00:43:20.441454Z","iopub.status.idle":"2026-05-07T00:43:20.449661Z","shell.execute_reply.started":"2026-05-07T00:43:20.441396Z","shell.execute_reply":"2026-05-07T00:43:20.448726Z"}},"outputs":[],"execution_count":38},{"cell_type":"code","source":"","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T00:32:24.469336Z","iopub.execute_input":"2026-05-07T00:32:24.470492Z","iopub.status.idle":"2026-05-07T00:32:24.476606Z","shell.execute_reply.started":"2026-05-07T00:32:24.470452Z","shell.execute_reply":"2026-05-07T00:32:24.475707Z"}},"outputs":[{"execution_count":32,"output_type":"execute_result","data":{"text/plain":"np.float64(266.0434103685197)"},"metadata":{}}],"execution_count":32},{"cell_type":"markdown","source":"## Métriques","metadata":{}},{"cell_type":"markdown","source":"### Métriques : mesurer la qualité d’une prédiction\n\nUne fois qu’on a des prédictions $\\hat{y}$, on veut quantifier “à quel point on se trompe”.\nUne **métrique** résume l’erreur en un nombre.\n\n#### MAE (Mean Absolute Error)\n$$\nMAE = \\frac{1}{n}\\sum_i |y_i-\\hat{y}_i|\n$$\n- unités identiques à $y$\n- robuste aux gros écarts (moins “explosif” que le carré)\n\n#### MSE (Mean Squared Error)\n$$\nMSE = \\frac{1}{n}\\sum_i (y_i-\\hat{y}_i)^2\n$$\n- pénalise fortement les grosses erreurs (carré)\n\n#### RMSE (Root Mean Squared Error)\n$$\nRMSE = \\sqrt{MSE}\n$$\n- revient aux unités de $y$\n- très sensible aux outliers\n\n#### Pourquoi MAE et RMSE peuvent raconter des histoires différentes ?\n- Si les erreurs sont bien “compactes”, MAE et RMSE seront proches.\n- Si quelques points ont de très grosses erreurs, **RMSE augmente beaucoup** (carré), alors que MAE augmente moins.\n\n#### Score R² (coefficient de détermination)\n\nLe coefficient de détermination $ R^2 $ mesure la **part de la variance de la variable cible expliquée par le modèle**.\n\nIl compare les erreurs du modèle à celles d’un modèle de référence très simple :\n**prédire toujours la moyenne** $ \\bar{y} $.\n\n\n##### Définition mathématique\n\nSoit :\n\n* $y_i$ : valeur réelle\n* $\\hat{y}_i$ : valeur prédite\n* $\\bar{y}$ : moyenne des valeurs réelles\n\nOn définit :\n\n* **Somme des carrés des résidus** :\n $$\n {SS_\\text{res}} = \\sum_{i=1}^{n} (y_i - \\hat{y}_i)^2\n $$\n\n* **Somme des carrés totale** :\n $$\n {SS_\\text{tot}} = \\sum_{i=1}^{n} (y_i - \\bar{y})^2\n $$\n\nLe coefficient de détermination est alors :\n\n$$\nR^2 = 1 - \\frac{SS_{\\text{res}}}{SS_{\\text{tot}}}\n$$\n\n\n\n##### Interprétation de ( R^2 )\n\n* $R^2 = 1$\n Le modèle explique parfaitement les données.\n\n* $ R^2 = 0 $\n Le modèle ne fait pas mieux que prédire la moyenne.\n\n* $ 0 < R^2 < 1 $\n Le modèle explique une partie de la variance.\n\n* $ R^2 < 0 $\n Le modèle est **pire que la prédiction par la moyenne**.\n\n\n\n##### Intuition\n\n* Si les prédictions sont proches des valeurs réelles, $ {\\text{res}} $ est petit et $ R^2 $ est proche de 1.\n* Si les prédictions sont mauvaises, $ {\\text{res}} $ est grand et $ R^2 $ diminue.\n\n$ R^2 $ mesure donc un **gain par rapport à un modèle naïf**.\n\n\n\n##### Lien avec les autres métriques\n\n* MAE et RMSE mesurent une **erreur absolue**\n* $ R^2 $ mesure une **qualité relative d’explication**\n* Un bon modèle doit être analysé avec **plusieurs métriques**\n\n\n\n##### Attention\n\nUn $ R^2 $ élevé :\n\n* ne garantit pas un bon modèle prédictif\n* ne détecte pas les problèmes de sur-apprentissage\n* doit être interprété avec les résidus et le contexte métier\n\n```python\n# Définition de métriques \"maison\"\n# y : valeurs réelles, y_hat : valeurs prédites\n\ndef MAE(y, y_hat):\n \"\"\"Mean Absolute Error\"\"\"\n y = np.asarray(y)\n y_hat = np.asarray(y_hat)\n return np.mean(np.abs(y_hat - y))\n\ndef MSE(y, y_hat):\n \"\"\"Mean Squared Error\"\"\"\n y = np.asarray(y)\n y_hat = np.asarray(y_hat)\n return np.mean((y_hat - y) ** 2)\n\ndef RMSE(y, y_hat):\n \"\"\"Root Mean Squared Error\"\"\"\n return np.sqrt(MSE(y, y_hat))\n\ndef MAPE(y, y_hat, eps=1e-12):\n \"\"\"Mean Absolute Percentage Error (en proportion)\"\"\"\n y = np.asarray(y)\n y_hat = np.asarray(y_hat)\n return np.mean(np.abs((y_hat - y) / (np.abs(y) + eps)))\n\ndef R2(y, y_hat):\n y = np.array(y)\n y_hat = np.array(y_hat)\n \n y_mean = np.mean(y)\n \n ss_res = np.sum((y - y_hat) ** 2)\n ss_tot = np.sum((y - y_mean) ** 2)\n \n return 1 - ss_res / ss_tot\n```\n\n```python\n# Exemple : calcul de métriques sur le dataset CO2\nx = df['consumption']\ny = df['co2']\n\nmodel = MyLinearRegression()\nmodel.fit(x, y)\ny_hat = model.predict(x)\n\nprint('RMSE :', RMSE(y, y_hat))\nprint('MAE :', MAE(y, y_hat))\nprint('MAPE :', MAPE(y, y_hat))\nprint('R2 :', R2(y, y_hat))\n\n# Visualisation : réel vs prédit\nfig = px.scatter(x=x, y=y)\nfig.add_scatter(\n x=x,\n y=y_hat,\n mode=\"lines\",\n name=\"Valeurs prédites\"\n)\nfig.show()\n\n# Résidus\nresidus = y - y_hat\n\nfig = px.scatter(\n x=x,\n y=residus,\n labels={\"x\": \"Consommation\", \"y\": \"Résidu\"},\n title=\"Résidus de la régression linéaire\"\n)\n\nfig.add_hline(\n y=0,\n line_color=\"red\"\n)\n\nfig.show()\n```\n","metadata":{}},{"cell_type":"code","source":"df = pd.read_csv('/kaggle/input/datasets/pyim59/mini-datasets/co2_mini.csv')\n\nx = df['consumption']\ny = df['co2']\n\nmodel = RegressionLineaire()\nmodel.fit(x, y)\ny_hat = model.predict(x)\n\nprint('RMSE :', RMSE(y, y_hat))\nprint('MAE :', MAE(y, y_hat))\nprint('MAPE :', MAPE(y, y_hat))\nprint('R2 :', R2(y, y_hat))\n\n# Visualisation : réel vs prédit\nfig = px.scatter(x=x, y=y)\nfig.add_scatter(\n x=x,\n y=y_hat,\n mode=\"lines\",\n name=\"Valeurs prédites\"\n)\nfig.show()\n\n# Résidus\nresidus = y - y_hat\n\nfig = px.scatter(\n x=x,\n y=residus,\n labels={\"x\": \"Consommation\", \"y\": \"Résidu\"},\n title=\"Résidus de la régression linéaire\"\n)\n\nfig.add_hline(\n y=0,\n line_color=\"red\"\n)\n\nfig.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T00:43:25.262022Z","iopub.execute_input":"2026-05-07T00:43:25.263176Z","iopub.status.idle":"2026-05-07T00:43:25.361213Z","shell.execute_reply.started":"2026-05-07T00:43:25.263130Z","shell.execute_reply":"2026-05-07T00:43:25.360409Z"}},"outputs":[{"name":"stdout","text":"RMSE : 2.922491799448456\nMAE : 2.2614749168864234\nMAPE : 0.008412017903738913\nR2 : 0.9973421048879121\n","output_type":"stream"},{"output_type":"display_data","data":{"text/html":"\n\n\n
\n
\n\n"},"metadata":{}},{"output_type":"display_data","data":{"text/html":"\n\n\n
\n
\n\n"},"metadata":{}}],"execution_count":39},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Régression linéaire multiple avec sklearn\n\n```python\n# Lecture du dataset abalone_mini\ndf = pd.read_csv('/kaggle/input/datasets/pyim59/mini-datasets/abalone_mini.csv')\ndf.head()\n```\n","metadata":{}},{"cell_type":"code","source":"df = pd.read_csv('/kaggle/input/datasets/pyim59/mini-datasets/abalone_mini.csv')\ndf.head()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T00:52:15.361659Z","iopub.execute_input":"2026-05-07T00:52:15.362115Z","iopub.status.idle":"2026-05-07T00:52:15.395770Z","shell.execute_reply.started":"2026-05-07T00:52:15.362079Z","shell.execute_reply":"2026-05-07T00:52:15.394768Z"}},"outputs":[{"execution_count":40,"output_type":"execute_result","data":{"text/plain":" Length Diameter Height Weight Rings\n0 0.455 0.365 0.095 0.5140 15\n1 0.350 0.265 0.090 0.2255 7\n2 0.530 0.420 0.135 0.6770 9\n3 0.440 0.365 0.125 0.5160 10\n4 0.330 0.255 0.080 0.2050 7","text/html":"
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
LengthDiameterHeightWeightRings
00.4550.3650.0950.514015
10.3500.2650.0900.22557
20.5300.4200.1350.67709
30.4400.3650.1250.516010
40.3300.2550.0800.20507
\n
"},"metadata":{}}],"execution_count":40},{"cell_type":"markdown","source":"### Le dataset `abalone_mini` : prédire l’âge d’un abalone\n\nUn **abalone** est un mollusque (un ormeau ou une nacre en français). Dans ce dataset (classique en ML), la variable **`Rings`** correspond au nombre d’anneaux comptés sur la coquille. C’est souvent utilisé comme une **estimation de l’âge** (âge ≈ Rings + constante, selon les conventions).\n\n![Abalone](https://upload.wikimedia.org/wikipedia/commons/2/27/Paua.jpg)\n\nIci, l’objectif est :\n- **cible** : `Rings` \n- **features** : `Length`, `Diameter`, `Height`, `Weight` (mesures physiques)\n","metadata":{}},{"cell_type":"markdown","source":"> ### Exercice\n> Prédire Rings à partir de Length","metadata":{}},{"cell_type":"code","source":"df = pd.read_csv('/kaggle/input/datasets/pyim59/mini-datasets/abalone_mini.csv')\n\nx = df['Length']\ny = df['Rings']\n\nmodel = RegressionLineaire()\nmodel.fit(x, y)\ny_hat = model.predict(x)\n\nprint('RMSE :', RMSE(y, y_hat))\nprint('MAE :', MAE(y, y_hat))\nprint('MAPE :', MAPE(y, y_hat))\nprint('R2 :', R2(y, y_hat))\n\n# Visualisation : réel vs prédit\nfig = px.scatter(x=x, y=y)\nfig.add_scatter(\n x=x,\n y=y_hat,\n mode=\"lines\",\n name=\"Valeurs prédites\"\n)\nfig.show()\n\n# Résidus\nresidus = y - y_hat\n\nfig = px.scatter(\n x=x,\n y=residus,\n labels={\"x\": \"Consommation\", \"y\": \"Résidu\"},\n title=\"Résidus de la régression linéaire\"\n)\n\nfig.add_hline(\n y=0,\n line_color=\"red\"\n)\n\nfig.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T00:56:09.180361Z","iopub.execute_input":"2026-05-07T00:56:09.180788Z","iopub.status.idle":"2026-05-07T00:56:09.282167Z","shell.execute_reply.started":"2026-05-07T00:56:09.180751Z","shell.execute_reply":"2026-05-07T00:56:09.281198Z"}},"outputs":[{"name":"stdout","text":"RMSE : 2.6779981890743265\nMAE : 1.9518934619912671\nMAPE : 0.1935476095807797\nR2 : 0.309936687336693\n","output_type":"stream"},{"output_type":"display_data","data":{"text/html":"\n\n\n
\n
\n\n"},"metadata":{}},{"output_type":"display_data","data":{"text/html":"\n\n\n
\n
\n\n"},"metadata":{}}],"execution_count":41},{"cell_type":"markdown","source":"### Nuage de points 3D avec Plotly\n\nCe nuage de points 3D permet de visualiser simultanément **trois variables numériques** et d’explorer leurs relations dans l’espace.\n\n```python\nfig = px.scatter_3d(\n x=df.Length, \n y=df.Weight, \n z=df.Rings,\n title=\"Abalone: réel (Rings) vs prédiction (plan)\",\n opacity=0.25\n)\n```\n\n\n#### Lecture du graphique\n\nDans ce graphique :\n\n* l’axe **X** correspond à la variable `Length`\n* l’axe **Y** correspond à la variable `Weight`\n* l’axe **Z** correspond à la variable `Rings`\n\nChaque point représente un individu du dataset Abalone, positionné selon ses caractéristiques physiques et son âge (approximé par le nombre d’anneaux).\n\n\n#### Rôle de l’opacité\n\n```python\nopacity=0.25\n```\n\n* Rend les points partiellement transparents\n* Améliore la lisibilité lorsque de nombreux points se superposent\n* Met en évidence les zones de forte densité de points\n\n\n\n## Interactivité\n\nCe graphique est interactif :\n\n* rotation pour changer le point de vue\n* zoom pour explorer des régions spécifiques\n* survol pour afficher les valeurs exactes\n\n```python\n# Nuage de points 3D\n\npx.scatter_3d(\n df, x='Length', y='Weight', z='Rings',\n title='Abalone 3D Scatter: Length, Weight vs Rings',\n opacity=0.2\n)\n```\n","metadata":{}},{"cell_type":"code","source":"px.scatter_3d(df, x='Length', y='Weight', z='Rings')","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T00:58:38.991111Z","iopub.execute_input":"2026-05-07T00:58:38.991543Z","iopub.status.idle":"2026-05-07T00:58:39.091535Z","shell.execute_reply.started":"2026-05-07T00:58:38.991508Z","shell.execute_reply":"2026-05-07T00:58:39.090655Z"}},"outputs":[{"output_type":"display_data","data":{"text/html":"\n\n\n
\n
\n\n"},"metadata":{}}],"execution_count":42},{"cell_type":"code","source":"from sklearn.linear_model import LinearRegression\nfrom sklearn.metrics import *\n\ndf = pd.read_csv('/kaggle/input/datasets/pyim59/mini-datasets/abalone_mini.csv')\n\nX = df[['Length','Weight']]\ny = df['Rings']\n\nmodel = LinearRegression()\nmodel.fit(X,y)\ny_hat = model.predict(X)\n\nprint(f\"MAE : {mean_absolute_error(y,y_hat):.2f}\")\nprint(f\"RMSE : {root_mean_squared_error(y,y_hat):.2f}\")\nprint(f\"MAPE : {mean_absolute_percentage_error(y,y_hat):.2f}\")\nprint(f\"R2 score : {r2_score(y,y_hat):.2f}\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T01:11:33.080768Z","iopub.execute_input":"2026-05-07T01:11:33.081172Z","iopub.status.idle":"2026-05-07T01:11:33.105152Z","shell.execute_reply.started":"2026-05-07T01:11:33.081139Z","shell.execute_reply":"2026-05-07T01:11:33.104386Z"}},"outputs":[{"name":"stdout","text":"MAE : 1.95\nRMSE : 2.67\nMAPE : 0.19\nR2 score : 0.31\n","output_type":"stream"}],"execution_count":50},{"cell_type":"markdown","source":"## Régression linéaire multiple (2 variables)\n\nQuand on utilise deux variables explicatives $x_1$ et $x_2$, le modèle linéaire devient :\n$$\n\\hat{y} = a_1 x_1 + a_2 x_2 + b\n$$\n\navec :\n- $x_1 =$ `Length`\n- $x_2 =$ `Weight`\n- $y =$ `Rings`\n\nEn 3D, $(x_1, x_2, \\hat{y})$ forme un **plan**. \nL’apprentissage consiste à choisir $a_1, a_2, b$ pour minimiser une erreur (souvent MSE).\n\nIntuition :\n- $a_1$ mesure l’effet de `Length` *à poids égal*.\n- $a_2$ mesure l’effet de `Weight` *à longueur égale*.\nC’est l’intérêt clé : on sépare les contributions de plusieurs facteurs.\n","metadata":{}},{"cell_type":"markdown","source":"### Régression linéaire multiple avec scikit-learn\n\nLa régression linéaire multiple généralise la régression linéaire simple à plusieurs variables explicatives.\nLe modèle cherche à approximer une variable cible $y$ à partir de plusieurs variables $x_1, x_2, \\dots, x_p$.\n\n\n\n#### Modèle mathématique\n\nLa régression linéaire multiple s’écrit :\n\n$$\n\\hat{y} = \\beta_0 + \\beta_1 x_1 + \\beta_2 x_2 + \\dots + \\beta_p x_p\n$$\n\noù :\n\n* $\\beta_0$ est l’ordonnée à l’origine (intercept)\n* $\\beta_j$ sont les coefficients associés aux variables explicatives\n* $x_j$ sont les caractéristiques (features)\n\n\n\n#### Import du modèle\n\n```python\nfrom sklearn.linear_model import LinearRegression\n```\n\n`LinearRegression` implémente la méthode des **moindres carrés ordinaires** (OLS).\n\n\n\n#### Préparation des données\n\n```python\nX = df[['Length', 'Weight']]\ny = df['Rings']\n```\n\n* `X` est une **matrice 2D** (DataFrame Pandas)\n\n * chaque ligne correspond à une observation\n * chaque colonne correspond à une variable explicative\n* `y` est un **vecteur 1D** (Series Pandas) représentant la variable cible\n\nCette distinction leading à la règle suivante :\n\n> `X` doit toujours être 2D, même avec une seule variable\n> `y` doit être 1D\n\n\n\n#### Création et entraînement du modèle\n\n```python\nmodel = LinearRegression()\nmodel.fit(X, y)\n```\n\n* `model` est un objet représentant le modèle de régression\n* `fit(X, y)` :\n\n * estime les coefficients $\\beta_j$\n * apprend le lien linéaire entre `X` et `y`\n * résout le problème des moindres carrés\n\nAprès l’entraînement :\n\n* `model.coef_` contient les coefficients $\\beta_1, \\beta_2, \\dots$\n* `model.intercept_` contient $\\beta_0$\n\n\n\n#### Prédiction\n\n```python\ny_hat = model.predict(X)\n```\n\n* `predict` applique le modèle appris\n* ici, la prédiction est faite sur les **mêmes données** que l’entraînement\n* cette étape est uniquement **illustrative**\n* pour une évaluation correcte, il faut utiliser un jeu de test séparé\n\n\n\n#### Évaluation des performances\n\n```python\nfrom sklearn.metrics import mean_absolute_error, mean_squared_error, mean_absolute_percentage_error, r2_score\n\n```\n\nLes métriques comparent les valeurs réelles $y$ et les prédictions $\\hat{y}$.\n\n```python\n# Modèle de régression linéaire standard de scikit-learn\nfrom sklearn.linear_model import LinearRegression\n```\n\n```python\n# Régression multiple avec scikit-learn\n# X doit être un tableau 2D (DataFrame avec 2 colonnes), y un vecteur 1D (Series)\n\nfrom sklearn.metrics import mean_absolute_error, mean_squared_error, mean_absolute_percentage_error, r2_score\n\ndf = pd.read_csv('/kaggle/input/datasets/pyim59/mini-datasets/abalone_mini.csv')\n\nX = df[['Length', 'Weight']]\ny = df['Rings']\n\nmodel = LinearRegression()\nmodel.fit(X, y)\n\n# Prediction sur les mêmes données (illustration)\ny_hat = model.predict(X)\n\nprint(\"MAE =\", mean_absolute_error(y, y_hat))\nprint(\"RMSE =\", np.sqrt(mean_squared_error(y, y_hat)))\nprint(\"MAPE =\", mean_absolute_percentage_error(y, y_hat))\nprint(\"R2 =\", r2_score(y, y_hat))\n```\n","metadata":{}},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"fig = px.scatter_3d(\n x=df.Length, \n y=df.Weight, \n z=df.Rings,\n title='Abalone: réel (Rings) vs prédiction (plan)',\n opacity=0.25\n)\n\nfig.add_scatter3d(\n x=df.Length,\n y=df.Weight,\n z=y_hat,\n name=\"Prédit (LinearRegression)\",\n mode=\"markers\",\n marker=dict(color=\"red\", size=2)\n)\n\nfig.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T01:13:26.048830Z","iopub.execute_input":"2026-05-07T01:13:26.049756Z","iopub.status.idle":"2026-05-07T01:13:26.116756Z","shell.execute_reply.started":"2026-05-07T01:13:26.049721Z","shell.execute_reply":"2026-05-07T01:13:26.116046Z"}},"outputs":[{"output_type":"display_data","data":{"text/html":"\n\n\n
\n
\n\n"},"metadata":{}}],"execution_count":51},{"cell_type":"markdown","source":"### Visualisation des résultats en 3D\n\nLa méthode `add_scatter3d` permet **d’ajouter une nouvelle couche de données** à une figure 3D existante.\nElle est utilisée pour superposer plusieurs jeux de données dans un **même espace 3D**.\n\n```python\nfig = px.scatter_3d(\n x=df.Length, \n y=df.Weight, \n z=df.Rings,\n title='Abalone: réel (Rings) vs prédiction (plan)',\n opacity=0.25\n)\n\nfig.add_scatter3d(\n x=df.Length,\n y=df.Weight,\n z=y_hat,\n name=\"Prédit (LinearRegression)\",\n mode=\"markers\",\n marker=dict(color=\"red\", size=2)\n)\n\nfig.show()\n```\n\n#### Rôle de `add_scatter3d`\n\n* Ajoute une **nouvelle trace** à la figure déjà créée\n* Utilise les **mêmes axes** que le nuage de points initial\n* Permet la comparaison visuelle entre plusieurs ensembles de points\n\nDans cet exemple, la trace ajoutée correspond aux **valeurs prédites** par le modèle.\n\n\n\n#### `mode=\"markers\"`\n\n* `markers` affiche les données sous forme de **points**\n* Chaque point représente une observation\n* En 3D, ce mode est adapté aux données non ordonnées\n\nLes prédictions sont ainsi visualisées **point par point**, sans imposer de structure artificielle.\n\n\n#### Personnalisation visuelle\n\n```python\nmarker=dict(color=\"red\", size=2)\n```\n\n* La couleur distingue clairement les prédictions\n* La taille limite la surcharge visuelle\n\n```python\n# 1) Nuage de points réel (Rings)\nfig = px.scatter_3d(\n x=df.Length, \n y=df.Weight, \n z=df.Rings,\n title='Abalone: réel (Rings) vs prédiction (plan)',\n opacity=0.25\n)\n\n# 2) Ajout des points prédits (y_hat) en rouge\nfig.add_scatter3d(\n x=df.Length,\n y=df.Weight,\n z=y_hat,\n name='Prédit (LinearRegression)',\n mode='markers',\n marker=dict(color='red', size=5)\n)\n\nfig.show()\n```\n","metadata":{}},{"cell_type":"code","source":"df.head()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T01:17:27.067425Z","iopub.execute_input":"2026-05-07T01:17:27.067834Z","iopub.status.idle":"2026-05-07T01:17:27.080460Z","shell.execute_reply.started":"2026-05-07T01:17:27.067801Z","shell.execute_reply":"2026-05-07T01:17:27.079593Z"}},"outputs":[{"execution_count":52,"output_type":"execute_result","data":{"text/plain":" Length Diameter Height Weight Rings\n0 0.455 0.365 0.095 0.5140 15\n1 0.350 0.265 0.090 0.2255 7\n2 0.530 0.420 0.135 0.6770 9\n3 0.440 0.365 0.125 0.5160 10\n4 0.330 0.255 0.080 0.2050 7","text/html":"
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
LengthDiameterHeightWeightRings
00.4550.3650.0950.514015
10.3500.2650.0900.22557
20.5300.4200.1350.67709
30.4400.3650.1250.516010
40.3300.2550.0800.20507
\n
"},"metadata":{}}],"execution_count":52},{"cell_type":"code","source":"X = df.drop(columns=['Rings'])","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T01:18:19.865507Z","iopub.execute_input":"2026-05-07T01:18:19.865861Z","iopub.status.idle":"2026-05-07T01:18:19.872122Z","shell.execute_reply.started":"2026-05-07T01:18:19.865831Z","shell.execute_reply":"2026-05-07T01:18:19.871074Z"}},"outputs":[],"execution_count":54},{"cell_type":"code","source":"df = pd.read_csv('/kaggle/input/datasets/pyim59/mini-datasets/abalone_mini.csv')\n\nX = df.drop(columns=['Rings'])\ny = df['Rings']\n\nmodel = LinearRegression()\nmodel.fit(X,y)\ny_hat = model.predict(X)\n\nprint(f\"MAE : {mean_absolute_error(y,y_hat):.2f}\")\nprint(f\"RMSE : {root_mean_squared_error(y,y_hat):.2f}\")\nprint(f\"MAPE : {mean_absolute_percentage_error(y,y_hat):.2f}\")\nprint(f\"R2 score : {r2_score(y,y_hat):.2f}\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T01:19:33.769827Z","iopub.execute_input":"2026-05-07T01:19:33.770919Z","iopub.status.idle":"2026-05-07T01:19:33.801089Z","shell.execute_reply.started":"2026-05-07T01:19:33.770874Z","shell.execute_reply":"2026-05-07T01:19:33.799998Z"}},"outputs":[{"name":"stdout","text":"MAE : 1.86\nRMSE : 2.59\nMAPE : 0.18\nR2 score : 0.36\n","output_type":"stream"}],"execution_count":55},{"cell_type":"markdown","source":"## Régression linéaire multiple (cas général à *n* variables)\n\nAvec $n$ features, le modèle s’écrit :\n$$\n\\hat{y} = b + \\sum_{j=1}^{n} a_j x_j\n$$\n\n### Écriture matricielle\nOn regroupe les données dans une matrice $X$ (taille $m \\times n$) et un vecteur $y$ (taille $m$) :\n$$\n\\hat{y} = X a + b\n$$\nSouvent on “absorbe” $b$ en ajoutant une colonne de 1 dans $X$.\n\n### Solution moindres carrés (équation normale)\nSi $X^TX$ est inversible :\n$$\na = (X^T X)^{-1} X^T y\n$$\nC’est la généralisation de la formule de la droite à 1 variable.\n\n### En pratique\n- Pour de petits problèmes, l’équation normale fonctionne très bien.\n- Pour de gros datasets ou quand $X^TX$ est mal conditionnée, on utilise des solveurs numériques (c’est ce que fait sklearn).\n\n","metadata":{}},{"cell_type":"markdown","source":"### 💡 Syntaxe à reprendre\n\n_Repère syntaxique pour aborder l'exercice ci-dessous._\n\n```python\nimport numpy as np\nfrom sklearn.metrics import mean_absolute_error, mean_squared_error, mean_absolute_percentage_error, r2_score\nmodel = LinearRegression()\nmodel.fit(X, y)\ny_hat = model.predict(X)\n```\n","metadata":{}},{"cell_type":"markdown","source":">#### Exercice \n>Prédire le nombre d'anneaux en fonction de toutes les autres caractéristiques\n>\n>**Indication** : utiliser `drop` pour éliminer la colonne `Rings` pour construire `X`\n>\n>Améliore-t-on la prédiction ?","metadata":{}},{"cell_type":"code","source":"from sklearn.model_selection import train_test_split\n\nX_train, X_test, y_train, y_test = train_test_split(X,y, test_size=0.2)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T01:27:59.702855Z","iopub.execute_input":"2026-05-07T01:27:59.703832Z","iopub.status.idle":"2026-05-07T01:27:59.711443Z","shell.execute_reply.started":"2026-05-07T01:27:59.703786Z","shell.execute_reply":"2026-05-07T01:27:59.710359Z"}},"outputs":[],"execution_count":61},{"cell_type":"code","source":"df = pd.read_csv('/kaggle/input/datasets/pyim59/mini-datasets/abalone_mini.csv')\n\nX = df.drop(columns=['Rings'])\ny = df['Rings']\n\nX_train, X_test, y_train, y_test = train_test_split(X,y, test_size=0.2, random_state=42)\n\nmodel = LinearRegression()\nmodel.fit(X_train,y_train)\ny_hat = model.predict(X_test)\n\nprint(f\"MAE : {mean_absolute_error(y_test,y_hat):.2f}\")\nprint(f\"RMSE : {root_mean_squared_error(y_test,y_hat):.2f}\")\nprint(f\"MAPE : {mean_absolute_percentage_error(y_test,y_hat):.2f}\")\nprint(f\"R2 score : {r2_score(y_test,y_hat):.2f}\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T01:52:37.662604Z","iopub.execute_input":"2026-05-07T01:52:37.663053Z","iopub.status.idle":"2026-05-07T01:52:37.693135Z","shell.execute_reply.started":"2026-05-07T01:52:37.663012Z","shell.execute_reply":"2026-05-07T01:52:37.692092Z"}},"outputs":[{"name":"stdout","text":"MAE : 1.87\nRMSE : 2.59\nMAPE : 0.18\nR2 score : 0.38\n","output_type":"stream"}],"execution_count":68},{"cell_type":"code","source":"X_train.shape","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T01:28:00.482922Z","iopub.execute_input":"2026-05-07T01:28:00.483966Z","iopub.status.idle":"2026-05-07T01:28:00.490141Z","shell.execute_reply.started":"2026-05-07T01:28:00.483919Z","shell.execute_reply":"2026-05-07T01:28:00.489111Z"}},"outputs":[{"execution_count":63,"output_type":"execute_result","data":{"text/plain":"(3341, 4)"},"metadata":{}}],"execution_count":63},{"cell_type":"code","source":"X_test.shape","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T01:28:02.290590Z","iopub.execute_input":"2026-05-07T01:28:02.291541Z","iopub.status.idle":"2026-05-07T01:28:02.297024Z","shell.execute_reply.started":"2026-05-07T01:28:02.291500Z","shell.execute_reply":"2026-05-07T01:28:02.296057Z"}},"outputs":[{"execution_count":64,"output_type":"execute_result","data":{"text/plain":"(836, 4)"},"metadata":{}}],"execution_count":64},{"cell_type":"markdown","source":"## Entraînement et test\n\n### Pourquoi séparer les données en ensembles d’entraînement et de test ?\n\nLors de l’apprentissage d’un modèle, il est fondamental de distinguer :\n\n* les données utilisées pour **ajuster le modèle**\n* les données utilisées pour **évaluer ses performances**\n\nÉvaluer un modèle sur les mêmes données que celles utilisées pour l’entraîner conduit presque toujours à une estimation **optimiste et trompeuse** de sa qualité.\n\n\n### Généralisation\n\nConsidérons un examen académique.\n\nSi les questions de l’examen sont **exactement identiques** à celles vues et répétées pendant le cours :\n\n* une bonne note ne garantit pas la compréhension réelle\n* elle mesure essentiellement la capacité de mémorisation\n\nDe la même manière, un modèle évalué sur ses données d’entraînement peut sembler très performant sans pour autant être capable de généraliser à de nouvelles données.\n\n\n\n### Rôle de l’ensemble de test\n\nL’ensemble de test permet de mesurer :\n\n* la capacité du modèle à **généraliser**\n* son comportement sur des données **non vues pendant l’apprentissage**\n* l’écart éventuel entre apprentissage et performance réelle\n\n### Création d'un jeu de test\n\n#### Principe de `train_test_split`\n\nLa fonction `train_test_split` :\n\n* mélange les données de manière aléatoire\n* sépare les observations en deux ensembles disjoints\n* garantit que les données de test ne sont jamais vues pendant l’apprentissage\n\n\n\n#### Utilisation de `train_test_split`\n\nOn considère :\n\n* une matrice de caractéristiques ( X \\in \\mathbb{R}^{n \\times p} )\n* un vecteur cible ( y \\in \\mathbb{R}^n )\n\n```python\nfrom sklearn.model_selection import train_test_split\n\nX_train, X_test, y_train, y_test = train_test_split(\n X,\n y,\n test_size=0.2,\n random_state=42\n)\n```\n\n\n#### Explication des paramètres\n\n* `X`, `y`\n données complètes (caractéristiques et variable cible)\n\n* `test_size=0.2`\n 20 % des données sont réservées à l’évaluation\n\n* `random_state=42`\n fixe la graine aléatoire afin de rendre la séparation reproductible\n\nLa fonction retourne quatre objets :\n\n* `X_train`, `y_train` : données utilisées pour entraîner le modèle\n* `X_test`, `y_test` : données utilisées uniquement pour l’évaluation\n\n\n\n#### Entraînement et prédiction\n\n```python\nmodel = LinearRegression()\nmodel.fit(X_train, y_train)\n\ny_hat = model.predict(X_test)\n```\n\n\n#### Évaluation des performances\n\nLes métriques doivent être calculées **sur l’ensemble de test**, car il simule des données jamais vues par le modèle.\n\nComparer les performances sur :\n\n* l’ensemble d’entraînement\n* l’ensemble de test\n\npermet de détecter un éventuel sur-apprentissage.\n","metadata":{}},{"cell_type":"markdown","source":"### 💡 Syntaxe à reprendre\n\n_Repère syntaxique pour aborder l'exercice ci-dessous._\n\n```python\nfrom sklearn.model_selection import train_test_split\nmodel = LinearRegression()\nmodel.fit(X_train, y_train)\ny_hat = model.predict(X_test)\n```\n","metadata":{}},{"cell_type":"markdown","source":">#### Exercice \n>Prédire le nombre d'anneaux en fonction de toutes les autres caractéristiques avec entraînement et test\n>\n>Tester sans le paramètre `random_state` dans `train_test_split` : que se passe-t-il ?","metadata":{}},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"### Validation croisée\n\nLorsqu’on utilise `train_test_split` **sans fixer `random_state`**, la séparation des données est **aléatoire**.\nÀ chaque exécution :\n\n* les observations du jeu d’entraînement changent\n* les observations du jeu de test changent\n* les performances mesurées varient\n\nIl est donc courant d’observer des métriques différentes (MAE, RMSE, $R^2$, etc.) d’une exécution à l’autre, **même avec le même modèle et les mêmes données**.\n\n\n\n#### Limite du train / test simple\n\nLa séparation train / test présente plusieurs limites :\n\n* l’évaluation dépend **fortement du tirage aléatoire**\n* une seule partition peut être :\n\n * trop favorable\n * trop défavorable\n* une partie des données n’est jamais utilisée pour l’entraînement\n* une autre partie n’est jamais utilisée pour l’évaluation\n\nAutrement dit, la performance mesurée peut être **instable** et **peu représentative**.\n\n\n\n#### Principe de la validation croisée (cross-validation)\n\nLa **validation croisée** vise à obtenir une estimation plus **robuste** et plus **stable** des performances d’un modèle.\n\nL’idée générale est de :\n\n* découper le dataset en plusieurs sous-ensembles\n* entraîner et évaluer le modèle **plusieurs fois**\n* agréger les résultats obtenus\n\n\n\n#### Validation croisée en $k$ plis (k-fold cross-validation)\n\nDans la validation croisée en $k$ plis :\n\n1. Le dataset est découpé en $k$ parties de taille comparable, appelées *plis*.\n2. Pour chaque itération :\n\n * un pli est utilisé comme jeu de test\n * les $k-1$ autres plis sont utilisés comme jeu d’entraînement\n3. Le processus est répété $k$ fois.\n4. On obtient $k$ scores de performance.\n\nLa performance finale est généralement :\n\n* la **moyenne** des scores\n* parfois accompagnée de leur **écart-type**\n\n\n\n##@### Illustration \n\nPour $k = 5$ :\n\n* chaque observation est utilisée :\n\n * 4 fois pour l’entraînement\n * 1 fois pour l’évaluation\n* toutes les données contribuent à l’évaluation du modèle\n\n\n\n#### Validation croisée avec scikit-learn\n\nScikit-learn fournit des outils dédiés à la validation croisée.\n\n#### Fonction `cross_val_score`\n\n```python\nfrom sklearn.model_selection import cross_val_score\n```\n\nCette fonction permet de :\n\n* entraîner un modèle plusieurs fois\n* évaluer ses performances sur différents plis\n* retourner un score par pli\n\n\n\n#### Exemple d’utilisation\n\n```python\nfrom sklearn.linear_model import LinearRegression\nfrom sklearn.model_selection import cross_val_score\n\nmodel = LinearRegression()\n\nscores = cross_val_score(\n model,\n X,\n y,\n cv=5,\n scoring=\"r2\"\n)\n\nscores\n```\n\n* `cv=5` : validation croisée en 5 plis\n* `scoring=\"r2\"` : métrique utilisée\n* `scores` contient 5 valeurs de $R^2$\n\n\n\n#### Interprétation des résultats\n\n```python\nscores.mean()\nscores.std()\n```\n\n* la **moyenne** donne une estimation globale de la performance\n* l’**écart-type** mesure la variabilité des résultats\n\nUn faible écart-type indique une performance **stable**.\n\n\n#### Choix de la métrique : le paramètre `scoring`\n\nLorsqu’on utilise la validation croisée avec `cross_val_score`, il est essentiel de préciser **quelle métrique de performance** on souhaite évaluer.\nC’est le rôle du paramètre `scoring`.\n\nLe paramètre `scoring` indique à scikit-learn **comment mesurer la qualité du modèle** à chaque pli de la validation croisée.\n\n\n#### Métriques couramment utilisées en régression\n\nQuelques valeurs courantes de `scoring` pour les problèmes de régression :\n\n* `\"r2\"`\n Coefficient de détermination\n Plus proche de 1 = meilleur modèle\n\n* `\"neg_mean_absolute_error\"`\n Erreur absolue moyenne (MAE)\n\n* `\"neg_mean_squared_error\"`\n Erreur quadratique moyenne (MSE)\n\n* `\"neg_root_mean_squared_error\"`\n Racine de l’erreur quadratique moyenne (RMSE)\n\n* `\"neg_mean_absolute_percentage_error\"`\n Erreur absolue moyenne en pourcentage (MAPE)\n\n\n#### Pourquoi les scores sont-ils négatifs ?\n\nPar convention, `cross_val_score` cherche **toujours à maximiser** un score.\n\nOr, les métriques d’erreur (MAE, MSE, RMSE, MAPE) doivent être **minimisées**.\nScikit-learn les renvoie donc sous forme **négative**.\n\nPar exemple :\n\n```python\nscores = cross_val_score(\n model,\n X,\n y,\n cv=5,\n scoring=\"neg_mean_absolute_error\"\n)\n```\n\nPour obtenir la valeur réelle de l’erreur :\n\n```python\nmae = -scores\nmae.mean()\n```\n\n","metadata":{}},{"cell_type":"markdown","source":"### 💡 Syntaxe à reprendre\n\n_Repère syntaxique pour aborder l'exercice ci-dessous._\n\n```python\nfrom sklearn.model_selection import cross_val_score\nmodel = LinearRegression()\nscores = cross_val_score(model, X, y, cv=5, scoring='neg_mean_absolute_percentage_error')\n```\n","metadata":{}},{"cell_type":"markdown","source":">#### Exercice \n>Evaluer la régression linéaire sur abalone avec une validation croisée sur la MAPE\n>","metadata":{}},{"cell_type":"code","source":"from sklearn.model_selection import cross_val_score\n\nmodel = LinearRegression()\n\nscores = cross_val_score(model, X, y, cv=100, scoring='neg_mean_absolute_error')\n\nprint(f'MAE = {-scores.mean():.2f}')","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T02:01:05.116296Z","iopub.execute_input":"2026-05-07T02:01:05.117072Z","iopub.status.idle":"2026-05-07T02:01:05.512832Z","shell.execute_reply.started":"2026-05-07T02:01:05.117028Z","shell.execute_reply":"2026-05-07T02:01:05.511961Z"}},"outputs":[{"name":"stdout","text":"MAE = 1.88\n","output_type":"stream"}],"execution_count":77},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Régression polynomiale","metadata":{}},{"cell_type":"markdown","source":"### 💡 Syntaxe à reprendre\n\n_Repère syntaxique pour aborder l'exercice ci-dessous._\n\n```python\nmodel = LinearRegression()\nmodel.fit(X, y)\ny_hat = model.predict(X)\nfig = px.scatter(x=X['Length'], y=y)\nfig.add_scatter(x=X['Length'], y=y_hat, mode='lines', name='Valeurs prédites')\nfig.show()\nresidus = y - y_hat\nfig = px.scatter(x=X['Length'], y=residus, labels={'x': 'Length', 'y': 'Weight'}, title='Résidus de la régression linéaire')\nfig.add_hline(y=0, line_color='red')\nfig.show()\n```\n","metadata":{}},{"cell_type":"markdown","source":"> #### Exercice — Régression linéaire simple (Abalone)\n>\n>\n> On souhaite maintenant prédire le **poids** (`Weight`) d’un abalone à partir de sa **longueur** (`Length`).\n>\n>\n> 1. Charger le dataset *Abalone*.\n> 2. Entraîner une régression linéaire pour prédire `Weight` à partir de `Length`.\n> 3. Calculer les valeurs prédites.\n> 4. Visualiser sur un même graphique :\n>\n> * les valeurs réelles\n> * les valeurs prédites par le modèle.\n> 5. Visualiser les résidus:\n>\n> \n> Qu'observe-t-on ?\n>","metadata":{}},{"cell_type":"code","source":"df['Length2'] = df['Length']**2","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T02:13:39.877453Z","iopub.execute_input":"2026-05-07T02:13:39.877810Z","iopub.status.idle":"2026-05-07T02:13:39.884229Z","shell.execute_reply.started":"2026-05-07T02:13:39.877781Z","shell.execute_reply":"2026-05-07T02:13:39.883222Z"}},"outputs":[],"execution_count":83},{"cell_type":"code","source":"df.head()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T02:13:46.205300Z","iopub.execute_input":"2026-05-07T02:13:46.205690Z","iopub.status.idle":"2026-05-07T02:13:46.218548Z","shell.execute_reply.started":"2026-05-07T02:13:46.205659Z","shell.execute_reply":"2026-05-07T02:13:46.217755Z"}},"outputs":[{"execution_count":84,"output_type":"execute_result","data":{"text/plain":" Length Diameter Height Weight Rings Length2\n0 0.455 0.365 0.095 0.5140 15 0.207025\n1 0.350 0.265 0.090 0.2255 7 0.122500\n2 0.530 0.420 0.135 0.6770 9 0.280900\n3 0.440 0.365 0.125 0.5160 10 0.193600\n4 0.330 0.255 0.080 0.2050 7 0.108900","text/html":"
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
LengthDiameterHeightWeightRingsLength2
00.4550.3650.0950.5140150.207025
10.3500.2650.0900.225570.122500
20.5300.4200.1350.677090.280900
30.4400.3650.1250.5160100.193600
40.3300.2550.0800.205070.108900
\n
"},"metadata":{}}],"execution_count":84},{"cell_type":"code","source":"df = pd.read_csv('/kaggle/input/datasets/pyim59/mini-datasets/abalone_mini.csv')\n\n\n\nX = df[['Length']]\ny = df['Weight']\n\nX_train, X_test, y_train, y_test = train_test_split(X,y, test_size=0.2, random_state=42)\n\nmodel = LinearRegression()\nmodel.fit(X_train,y_train)\ny_hat = model.predict(X_test)\n\nprint(f\"MAE : {mean_absolute_error(y_test,y_hat):.2f}\")\nprint(f\"RMSE : {root_mean_squared_error(y_test,y_hat):.2f}\")\nprint(f\"MAPE : {mean_absolute_percentage_error(y_test,y_hat):.2f}\")\nprint(f\"R2 score : {r2_score(y_test,y_hat):.2f}\")\n\nplt.scatter(X_test['Length'], y_test)\nplt.scatter(X_test['Length'], y_hat, c='red')\nplt.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-05-07T02:09:30.754595Z","iopub.execute_input":"2026-05-07T02:09:30.754962Z","iopub.status.idle":"2026-05-07T02:09:30.907001Z","shell.execute_reply.started":"2026-05-07T02:09:30.754923Z","shell.execute_reply":"2026-05-07T02:09:30.906167Z"}},"outputs":[{"name":"stdout","text":"MAE : 0.14\nRMSE : 0.19\nMAPE : 0.86\nR2 score : 0.85\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"
","image/png":"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\n"},"metadata":{}}],"execution_count":81},{"cell_type":"markdown","source":"## Introduction — Vers des modèles non linéaires\n\nLa régression linéaire simple suppose une relation de la forme :\n\n$$\n\\hat{y} = a x + b\n$$\n\nOr, certaines relations physiques ne sont pas strictement linéaires.\nUne manière simple d’introduire de la **non-linéarité** consiste à ajouter des **puissances de la variable explicative** comme nouvelles caractéristiques.\n\nPar exemple :\n\n$$\n\\hat{y} = \\beta_0 + \\beta_1 x + \\beta_2 x^2\n$$\n\nOn parle alors de **régression polynomiale**, même si le modèle reste **linéaire par rapport aux coefficients**.","metadata":{}},{"cell_type":"markdown","source":"### 💡 Syntaxe à reprendre\n\n_Repère syntaxique pour aborder l'exercice ci-dessous._\n\n```python\ndf['Length2'] = df['Length'] ** 2\nmodel = LinearRegression()\nmodel.fit(X, y)\ny_hat = model.predict(X)\nfig = px.scatter_3d(x=df.Length, y=df.Length2, z=df.Rings, title='Abalone: réel (Rings) vs prédiction (plan)', opacity=0.25)\nfig.add_scatter3d(x=df.Length, y=df.Length2, z=y_hat, name='Prédit (LinearRegression)', mode='markers', marker=dict(color='red', size=5))\nfig.show()\nfig = px.scatter(x=X['Length'], y=y, opacity=0.2)\nfig.add_scatter(x=X['Length'], y=y_hat, name='Valeurs prédites', mode='markers', marker=dict(color='red', size=10))\nfig.show()\n```\n","metadata":{}},{"cell_type":"markdown","source":"> #### Exercice — Régression polynomiale \n>\n>\n> On souhaite améliorer la prédiction du **poids** (`Weight`) d’un abalone à partir de sa **longueur** (`Length`) en introduisant des **variables polynomiales construites manuellement**.\n>\n>\n> **Travail demandé**\n>\n> 1. Charger le dataset *Abalone*.\n>\n> 2. Ajouter une nouvelle colonne `Length2` au DataFrame, correspondant au carré de la variable `Length`.\n>\n> 3. Construire la matrice de caractéristiques `X` à partir des colonnes :\n>\n> * `Length`\n> * `Length2`\n>\n> 4. Entraîner un modèle de régression linéaire (`LinearRegression`) pour prédire `Weight`.\n>\n> 5. Calculer les valeurs prédites.\n>\n> 6. Réaliser une visualisation 3D montrant :\n>\n> * `Length` en axe $x$\n> * `Length2` en axe $y$\n> * `Weight` (réel et prédit) en axe $z$\n>\n> 7. et une visualisation en 2D 'Length' vs 'Weight' réel et prédit\n","metadata":{}},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Plus proches voisins (k-Nearest Neighbors)\n\nLe **k-Nearest Neighbors Regressor (k-NN)** est une méthode de régression **non paramétrique** et **locale**.\nIl ne cherche pas à apprendre une formule globale reliant les variables explicatives à la variable cible.\nÀ la place, il prédit à partir des **observations les plus proches** dans l’espace des variables.\n\n### Idée générale\n\nPour prédire la valeur cible associée à une nouvelle observation $x$ :\n\n1. on calcule la **distance** entre $x$ et toutes les observations du jeu d’entraînement ;\n2. on identifie les $k$ observations les plus proches de $x$ : les **$k$ voisins** ;\n3. la prédiction est obtenue comme une **moyenne** des valeurs cibles de ces voisins.\n\nDans le cas le plus simple :\n\n$$\n\\hat{y}(x) = \\frac{1}{k} \\sum_{i \\in \\mathcal{N}_k(x)} y_i\n$$\n\noù $\\mathcal{N}_k(x)$ désigne l’ensemble des $k$ plus proches voisins de $x$.\n\n\n\n### Rôle de la distance\n\nLa notion de “voisin” repose entièrement sur une **distance entre observations**.\nCette distance mesure à quel point deux observations sont similaires dans l’espace des variables explicatives.\n\nDans scikit-learn, la distance utilisée par défaut est la **distance de Minkowski**.\n\n#### Distance de Minkowski\n\nPour deux observations\n$x = (x_1, \\dots, x_p)$\net\n$x' = (x'_1, \\dots, x'_p)$,\n\nla distance de Minkowski est définie par :\n\n$$\nd(x, x') = \\left( \\sum_{j=1}^{p} |x_j - x'_j|^p \\right)^{1/p}\n$$\n\nLe paramètre $p$ permet de retrouver des distances classiques :\n\n* **$p = 2$** : distance euclidienne\n\n$$\nd(x, x') = \\sqrt{\\sum_{j=1}^{p} (x_j - x'_j)^2}\n$$\n\n* **$p = 1$** : distance de Manhattan\n\n$$\nd(x, x') = \\sum_{j=1}^{p} |x_j - x'_j|\n$$\n\nCes distances définissent différentes manières de mesurer la proximité entre observations.\n\n\n\n#### Variante pondérée\n\nAu lieu d’une moyenne simple, on peut pondérer les voisins selon leur distance :\n\n$$\n\\hat{y}(x) =\n\\frac{\n\\sum_{i \\in \\mathcal{N}_k(x)} w_i \\, y_i\n}{\n\\sum_{i \\in \\mathcal{N}_k(x)} w_i\n}\n$$\n\navec par exemple\n\n$$\nw_i = \\frac{1}{d(x, x_i)}.\n$$\n\nLes voisins les plus proches ont alors plus d’influence sur la prédiction.\n\n\n\n### Intuition sur un exemple (Abalone)\n\nPour prédire `Rings` à partir de `Length` et `Weight` :\n\n* un nouvel abalone est comparé à ceux du jeu d’entraînement ;\n* on calcule les distances entre cet abalone et les autres ;\n* on sélectionne les abalones les plus proches selon cette distance ;\n* la prédiction est la moyenne (ou moyenne pondérée) de leurs valeurs `Rings`.\n\nLe modèle s’adapte ainsi **localement**, sans imposer de relation linéaire globale.\n\n\n\n### Implémentation avec scikit-learn\n\n```python\nfrom sklearn.neighbors import KNeighborsRegressor\n\nmodel = KNeighborsRegressor(n_neighbors=5)\nmodel.fit(X_train, y_train)\ny_hat = model.predict(X_test)\n```\n\nPar défaut :\n\n* la distance est de type Minkowski avec $p = 2$ (distance euclidienne) ;\n* tous les voisins ont le même poids.\n\n\n\n### Paramètres importants\n\n* **`n_neighbors`**\n Nombre de voisins $k$ :\n\n * petit $k$ : modèle très flexible, sensible au bruit ;\n * grand $k$ : modèle plus lisse, risque de sous-apprentissage.\n\n* **`metric`**\n Distance utilisée pour comparer les observations (par défaut Minkowski).\n\n* **`weights`**\n `\"uniform\"` ou `\"distance\"` pour une pondération par la proximité.\n","metadata":{}},{"cell_type":"markdown","source":"### 💡 Syntaxe à reprendre\n\n_Repère syntaxique pour aborder l'exercice ci-dessous._\n\n```python\nfrom sklearn.neighbors import KNeighborsRegressor\nmodel = KNeighborsRegressor(n_neighbors=5)\nmodel.fit(X, y)\ny_hat = model.predict(X)\ny_hat = model.predict(X)\nfig = px.scatter(x=X['Length'], y=y, opacity=0.2)\nfig.add_scatter(x=X['Length'], y=y_hat, name='Valeurs prédites', mode='markers', marker=dict(color='red', size=10))\nfig.show()\n```\n","metadata":{}},{"cell_type":"markdown","source":"> #### Exercice — SVR\n>\n>\n> Prédire le **poids** (`Weight`) d’un abalone à partir de sa **longueur** (`Length`) avec un **k-NN**`\n> Visualiser réel vs prédit\n>\n> Prédire `Rings` d’un abalone à partir des autres paramètres avec un **k-NN**`","metadata":{}},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Le dataset **House**\n\nLe dataset **`house_mini`** est une version simplifiée du jeu de données **KC House Data**, qui regroupe des informations sur des ventes de logements dans le **comté de King** (État de Washington, États-Unis).\n\n![Fremont Bridge (Seattle)](https://upload.wikimedia.org/wikipedia/commons/thumb/2/27/Fremont_Bridge_%28Seattle%29%2C_2022.jpg/640px-Fremont_Bridge_%28Seattle%29%2C_2022.jpg)\n\nChaque ligne correspond à un logement vendu, décrit par plusieurs caractéristiques, ainsi que son **prix de vente**.\n\n\n### Variable cible\n\n* **`price`**\n Prix de vente du logement\n → variable à prédire dans les exercices de régression\n\n\n### Variables explicatives\n\n* **`bedrooms`**\n Nombre de chambres\n\n* **`bathrooms`**\n Nombre de salles de bain\n\n* **`sqft_living`**\n Surface habitable du logement (en pieds carrés)\n\n* **`sqft_lot`**\n Surface totale du terrain (en pieds carrés)\n\n* **`floors`**\n Nombre d’étages du logement\n\n* **`zipcode`**\n Code postal du logement\n (variable catégorielle encodée sous forme numérique)\n\n","metadata":{}},{"cell_type":"markdown","source":"### 💡 Syntaxe à reprendre\n\n_Repère syntaxique pour aborder l'exercice ci-dessous._\n\n```python\ndf.head()\n```\n","metadata":{}},{"cell_type":"markdown","source":"> #### Exercice\n>\n> **Explorer le dataset house_mini (dimensions, statistiques, graphiques, ...)**","metadata":{}},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"> #### Exercice\n>\n> Prédire le prix avec une régression linéaire\n>\n> Séparation train/test, métriques, visualisation (par exemple surface vs prix réel/prédit), résidus, ...\n>\n> Remarques ?","metadata":{}},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"> #### Exercice\n>\n> Même exercice que le précédent avec un SVR\n>\n> Remarques ?","metadata":{}},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Sensibilité à la normalisation des données\n\nLe **k-Nearest Neighbors regressor** est **particulièrement sensible à la normalisation des données**, car l’ensemble de son fonctionnement repose sur le calcul de **distances entre observations**.\n\nDans le k-NN, deux observations sont considérées comme proches ou éloignées uniquement en fonction de la **distance** qui les sépare dans l’espace des variables explicatives.\n\nSi les variables n’ont pas la même échelle :\n\n* celles ayant les valeurs numériques les plus élevées dominent la distance ;\n* les autres variables deviennent quasi invisibles ;\n* la notion de “voisin le plus proche” perd son sens.\n\nAutrement dit, le k-NN compare alors des observations principalement selon **une seule variable**, indépendamment des autres.\n\n\n### Illustration\n\nSupposons deux variables :\n\n* `sqft_living` variant de 300 à 4 000\n* `bathrooms` variant de 1 à 5\n\nSans normalisation :\n\n* une différence de 500 en `sqft_living` écrase totalement\n* une différence de 1 en `bathrooms`\n\nLes voisins sont donc sélectionnés presque uniquement sur la surface, même si le nombre de salles de bain est informatif.\n\n\n\n### Conséquences sur le modèle\n\nSans normalisation, le k-NN peut :\n\n* sélectionner des voisins peu pertinents ;\n* produire des prédictions instables ;\n* afficher des performances très dégradées.\n","metadata":{}},{"cell_type":"markdown","source":"### Normalisation des données avec scikit-learn\n\nLa **normalisation** (ou mise à l’échelle) consiste à transformer les variables explicatives afin de les rendre **comparables en termes d’échelle**.\nElle est indispensable pour les méthodes basées sur des **distances** ou des **produits scalaires**, comme le SVR ou le k-NN.\n\n\n\n### Standardisation (StandardScaler)\n\nLa méthode de normalisation la plus couramment utilisée est la **standardisation**.\n\nChaque variable $x$ est transformée selon :\n\n$$\nx_{\\text{scaled}} = \\frac{x - \\mu}{\\sigma}\n$$\n\noù :\n\n* $\\mu$ est la moyenne de la variable\n* $\\sigma$ est son écart-type\n\nAprès standardisation :\n\n* la moyenne est nulle\n* la variance est égale à 1\n\n\n\n#### Implémentation avec scikit-learn\n\n```python\nfrom sklearn.preprocessing import StandardScaler\n```\n\nCréation du scaler :\n\n```python\nscaler = StandardScaler()\n```\n\n\n\n#### Ajustement et transformation\n\n```python\nX_train_scaled = scaler.fit_transform(X_train)\nX_test_scaled = scaler.transform(X_test)\n```\n\n* `fit_transform` :\n\n * calcule la moyenne et l’écart-type sur les données d’entraînement\n * applique la transformation\n* `transform` :\n\n * applique la même transformation aux données de test\n * évite toute fuite d’information\n\n\n\n### Transformation inverse\n\nAprès normalisation, les données sont exprimées dans un nouvel espace numérique.\nIl est souvent nécessaire de **revenir à l’échelle originale**, par exemple pour :\n\n* interpréter les résultats\n* afficher des prédictions\n* comparer aux valeurs réelles\n\n\n\n#### Principe\n\nLa transformation inverse correspond à :\n\n$$\nx = x_{\\text{scaled}} \\cdot \\sigma + \\mu\n$$\n\n\n\n#### Utilisation de `inverse_transform`\n\n```python\nX_train_original = scaler.inverse_transform(X_train_scaled)\nX_test_original = scaler.inverse_transform(X_test_scaled)\n```\n\nLes valeurs obtenues retrouvent :\n\n* leurs unités d’origine\n* leur ordre de grandeur initial\n\n\n\n\n### Autres méthodes de normalisation\n\nScikit-learn propose également :\n\n* `MinMaxScaler`\n Met les variables dans un intervalle donné (souvent [0, 1])\n\n* `RobustScaler`\n Utilise la médiane et l’intervalle interquartile\n Moins sensible aux valeurs aberrantes\n\n```python\nfrom sklearn.preprocessing import StandardScaler\n\nscaler = StandardScaler()\n\nX_train_scaled = scaler.fit_transform(X_train)\nX_test_scaled = scaler.transform(X_test)\n\npx.violin(X_train_scaled[:,3])\n```\n\n```python\nfrom sklearn.preprocessing import MinMaxScaler\n\nscaler = MinMaxScaler()\n\nX_train_scaled = scaler.fit_transform(X_train)\nX_test_scaled = scaler.transform(X_test)\n\npx.violin(X_train_scaled[:,3])\n```\n\n```python\nfrom sklearn.preprocessing import RobustScaler\n\nscaler = RobustScaler()\n\nX_train_scaled = scaler.fit_transform(X_train)\nX_test_scaled = scaler.transform(X_test)\n\npx.violin(X_train_scaled[:,3])\n```\n","metadata":{}},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"> #### Exercice\n>\n> Normaliser les données de l'exercice précédent\n>\n> Remarques ?","metadata":{}},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"### Utiliser un `Pipeline` dans scikit-learn\n\nUn **pipeline** (scikit-learn) permet d’enchaîner plusieurs étapes de traitement et de modélisation dans un **seul objet**, exécuté automatiquement dans le bon ordre.\nC’est particulièrement utile quand un modèle nécessite des transformations préalables (par exemple une normalisation), comme le **k-NN**.\n\n\n#### Éviter les erreurs méthodologiques (data leakage)\n\nLa normalisation doit être ajustée **uniquement sur le jeu d’entraînement**.\nSans pipeline, il est facile de se tromper (par exemple en normalisant avant le `train_test_split`).\n\nAvec un pipeline :\n\n* le scaler est ajusté sur `X_train` lors du `fit`\n* le même scaler est appliqué à `X_test` lors du `predict`\n\nCela garantit une évaluation correcte.\n\n\n\n#### Simplifier le code\n\nSans pipeline, il faut gérer séparément :\n\n* `fit_transform` sur train\n* `transform` sur test\n* puis entraîner le modèle\n\nAvec un pipeline, ces étapes sont automatisées.\n\n\n#### Validation croisée\n\nLes pipelines fonctionnent directement avec `cross_val_score`\n\nChaque pli de la validation croisée refait correctement :\n\n* la normalisation sur le train du pli\n* l’évaluation sur le test du pli\n\n\n\n### Exemple : pipeline pour k-NN (normalisation + modèle)\n\n```python\nfrom sklearn.pipeline import Pipeline\nfrom sklearn.preprocessing import StandardScaler\nfrom sklearn.neighbors import KNeighborsRegressor\n\npipe = Pipeline([\n (\"scaler\", StandardScaler()),\n (\"model\", KNeighborsRegressor(n_neighbors=5))\n])\n\npipe.fit(X_train, y_train)\ny_hat = pipe.predict(X_test)\n```\n\n\n* `(\"scaler\", StandardScaler())`\n étape de prétraitement : normalisation des variables\n\n* `(\"model\", KNeighborsRegressor(...))`\n étape de modélisation : apprentissage et prédiction\n\nLors de `pipe.fit(X_train, y_train)` :\n\n1. `StandardScaler` apprend la moyenne et l’écart-type sur `X_train` et transforme `X_train`\n2. le k-NN est entraîné sur les données transformées\n\nLors de `pipe.predict(X_test)` :\n\n1. `X_test` est transformé avec les paramètres appris sur `X_train`\n2. le k-NN produit les prédictions\n\n\n### Accéder aux étapes du pipeline\n\n```python\npipe.named_steps[\"scaler\"]\npipe.named_steps[\"model\"]\n```\n\nCela permet par exemple de récupérer le modèle entraîné ou d’inspecter le scaler.","metadata":{}},{"cell_type":"markdown","source":"### 💡 Syntaxe à reprendre\n\n_Repère syntaxique pour aborder l'exercice ci-dessous._\n\n```python\nfrom sklearn.pipeline import Pipeline\npipe = Pipeline([('scaler', StandardScaler()), ('model', KNeighborsRegressor(n_neighbors=5))])\npipe.fit(X_train, y_train)\ny_hat = pipe.predict(X_test)\nfig = px.scatter(x=X_test[:, 2], y=y_test, opacity=0.2)\nfig.add_scatter(x=X_test[:, 2], y=y_hat, mode='markers', name='Valeurs prédites')\nfig.show()\nresidus = y_test - y_hat\nfig = px.scatter(x=X_test[:, 2], y=residus, labels={'x': 'sqft_living', 'y': 'price'}, title='Résidus de la régression linéaire')\nfig.add_hline(y=0, line_color='red')\nfig.show()\n```\n","metadata":{}},{"cell_type":"markdown","source":"> #### Exercice\n>\n> Adapter l'exercice précédent avec un pipeline\n>","metadata":{}},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"> #### Exercice\n>\n> Comparer la performance de la régression linéaire et des k plus proches voisins avec une validation croisée\n>","metadata":{}},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null}]}