diff --git a/M1/Stats learning/TP0_Intro_Jupyter_Python.ipynb b/M1/Stats learning/TP0_Intro_Jupyter_Python.ipynb
new file mode 100644
index 0000000..377d158
--- /dev/null
+++ b/M1/Stats learning/TP0_Intro_Jupyter_Python.ipynb
@@ -0,0 +1,1356 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# TP0 Introduction\n",
+ "\n",
+ "### Table of Contents\n",
+ "\n",
+ "* [1. Introduction to Jupyter notebooks](#chapter1)\n",
+ " * [1.1 Markdown cell](#section_1_1)\n",
+ " * [1.2 Python cell](sSection_1_2)\n",
+ " \n",
+ "* [2. Introduction to Python](#chapter2)\n",
+ " * [2.1 Variables and types, list and np.array](#section_2_1)\n",
+ " * [2.1.1. Variable](#section_2_1_1)\n",
+ " * [2.1.2. List](#section_2_1_2)\n",
+ " * [2.1.3. Type `array`](#section_2_1_3)\n",
+ " * [2.2 basic operations](#section_2_2)\n",
+ " * [2.2.1 Operations on figures](#section_2_2_1)\n",
+ " * [2.2.2 Operations on a matrix](#section_2_2_2)\n",
+ " * [2.3 `for`-loop and `if...else`](#section_2_3)\n",
+ " * [2.4 Define your function](#section_2_4)\n",
+ " * [2.5 Graphs](#section_2_5)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# 1. Introduction to Jupyter notebook"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "To launch Jupyter, you need to run the command in a terminal:\n",
+ "\n",
+ "`jupyter notebook`\n",
+ "\n",
+ "This will automatically open a web browser where you can work. The main tab represents the file tree starting from the directory where the command was executed.\n",
+ "\n",
+ "Notebooks are composed of cells containing code (in Python) or text (plain or formatted with Markdown markup). These notebooks allow for interactive calculations in Python and are an excellent tool for teaching.\n",
+ "\n",
+ "You can edit a cell by double-clicking on it, and evaluate it by pressing **Ctrl+Enter** (you will also often use **Shift+Enter** to evaluate and move to the next cell). The buttons in the toolbar will be very useful; hover over them to display a tooltip if their icon is not clear enough.\n",
+ "\n",
+ "Don't forget to save your work from time to time, even though Jupyter performs regular automatic saves."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "You can click on *Help -> User Interface Tour* or *Help -> Keyboard Shortcuts* to get explanations[5]."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Question 1** : Delete the following cell:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Question 2** : Add a Python cell below"
+ ]
+ },
+ {
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:11:15.477711Z",
+ "start_time": "2025-01-22T09:11:15.474249Z"
+ }
+ },
+ "cell_type": "code",
+ "source": "print(\"Hello World\")",
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Hello World\n"
+ ]
+ }
+ ],
+ "execution_count": 1
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 1.1 Markdown cell \n",
+ "*Markdown* is a text format that allows minimal formatting. It enables you to quickly:\n",
+ "- create lists.\n",
+ "- make *italics*, **bold**, ~~strikethrough~~, etc.\n",
+ "- create [links](https://fr.wikipedia.org/wiki/Markdown)\n",
+ "- write mathematical formulas using $$\\LaTeX$$ (see [here](http://www.tuteurs.ens.fr/logiciels/latex/maths.html#s2) for a quick introduction to $$\\LaTeX$$).\n",
+ "\n",
+ "Citations:\n",
+ "[1] https://fr.wikipedia.org/wiki/Markdown"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Question 3** : change the first word to *italics* and the second word to **bold** "
+ ]
+ },
+ {
+ "metadata": {},
+ "cell_type": "markdown",
+ "source": [
+ "*first word*\n",
+ "\n",
+ "**second word**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Question 4** : Type a simple formula in $$\\LaTeX$$ (for example : integration, expectation of a random variable)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": "$\\mathbb{E}[X]=\\frac{1}{\\lambda}$\n"
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 1.2 Python cell\n",
+ "The following cell is a python cell. You can run it with maj+ Enter (or the triangular icon : \"run the selected cell and advance\" or go to the run tab)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Question 5** : Run the next cell. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:13:39.085033Z",
+ "start_time": "2025-01-22T09:13:39.081416Z"
+ }
+ },
+ "source": [
+ "# This is a Python comment. \n",
+ "# Comment your code :\n",
+ "# Code should be readable and understandable by other users\n",
+ "#\n",
+ "\n",
+ "print(\"hello world !\")"
+ ],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "hello world !\n"
+ ]
+ }
+ ],
+ "execution_count": 2
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Question 6** : Next cell is formatted in markdown. Switch to a Python cell. "
+ ]
+ },
+ {
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:14:10.188568Z",
+ "start_time": "2025-01-22T09:14:10.185558Z"
+ }
+ },
+ "cell_type": "code",
+ "source": "print(\"hello world !\")",
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "hello world !\n"
+ ]
+ }
+ ],
+ "execution_count": 3
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Question 7** : Turn the next cell into a markdown cell. "
+ ]
+ },
+ {
+ "metadata": {},
+ "cell_type": "markdown",
+ "source": "Oops! This is a Markdown cell"
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# 2. Introduction to Python"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Possible resources (mostly for numpy and matplotlib) : \n",
+ "- https://numpy.org/doc/2.2/user/absolute_beginners.html\n",
+ "- https://file.cz123.top/5textbook/CODING/Numerical_Python.pdf\n",
+ "- https://cs231n.github.io/python-numpy-tutorial/\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Import a library. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:14:38.458151Z",
+ "start_time": "2025-01-22T09:14:37.524456Z"
+ }
+ },
+ "source": [
+ "# Import the library numpy\n",
+ "import numpy\n",
+ "\n",
+ "# Import the library numpy and give it a diminutive \n",
+ "import numpy as np\n",
+ "\n",
+ "# Import part of a library\n",
+ "from scipy.stats import norm, multivariate_normal"
+ ],
+ "outputs": [],
+ "execution_count": 5
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 2.1 Variables and types, list and np.array"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 2.1.1. Variable "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:14:40.801476Z",
+ "start_time": "2025-01-22T09:14:40.798177Z"
+ }
+ },
+ "source": [
+ "#Integer\n",
+ "a = 4\n",
+ "print(\"a = \", a, \"\\t\\t\\t\\t its type is\", type(a))\n",
+ "\n",
+ "# Float\n",
+ "a = 3.5\n",
+ "print(\"a = \", a, \"\\t\\t\\t its type is\", type(a))\n",
+ "a = 1e7 # = 10^7, --> float\n",
+ "print(\"a = \", a, \"\\t\\t its type is\", type(a))\n",
+ "a = np.pi\n",
+ "print(\"a = \", a, \"\\t\\t its type is\", type(a))\n",
+ "\n",
+ "# Boolean\n",
+ "a = True\n",
+ "print(\"a = \", a, \"\\t\\t\\t its type is\", type(a))\n",
+ "\n",
+ "# String\n",
+ "a = \"Hello World!\"\n",
+ "print(\"a = \", a, \"\\t\\t its type is\", type(a))\n",
+ "\n",
+ "# Lists (mutable)\n",
+ "a = [1, 2, 3]\n",
+ "print(\"a = \", a, \"\\t\\t\\t its type is\", type(a))\n",
+ "\n",
+ "# Tuples (immutable)\n",
+ "a = (1.5, [1, 2], \"coucou\")\n",
+ "print(\"a = \", a, \"\\t its type is\", type(a))"
+ ],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "a = 4 \t\t\t\t its type is \n",
+ "a = 3.5 \t\t\t its type is \n",
+ "a = 10000000.0 \t\t its type is \n",
+ "a = 3.141592653589793 \t\t its type is \n",
+ "a = True \t\t\t its type is \n",
+ "a = Hello World! \t\t its type is \n",
+ "a = [1, 2, 3] \t\t\t its type is \n",
+ "a = (1.5, [1, 2], 'coucou') \t its type is \n"
+ ]
+ }
+ ],
+ "execution_count": 6
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 2.1.2. List \n",
+ "Run the following cells : "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:15:47.717601Z",
+ "start_time": "2025-01-22T09:15:47.714511Z"
+ }
+ },
+ "source": [
+ "#Empty list\n",
+ "L = []\n",
+ "print(\"The empty list : L =\", L, \"\\n\")"
+ ],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "The empty list : L = [] \n",
+ "\n"
+ ]
+ }
+ ],
+ "execution_count": 7
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:15:49.504901Z",
+ "start_time": "2025-01-22T09:15:49.502Z"
+ }
+ },
+ "source": [
+ "L = [1, 2, 3, 4, 5]\n",
+ "print(\"L =\", L)\n",
+ "\n",
+ "#Indices in Python start at zero !\n",
+ "print(\"the first element is\", L[0])\n",
+ "\n",
+ "#Another way to to access the last element of a list :\n",
+ "print(\"The last element is \", L[-1])\n",
+ "\n",
+ "# Access to a sublist \n",
+ "print(\"L contains the sublist\", L[1:4])"
+ ],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "L = [1, 2, 3, 4, 5]\n",
+ "the first element is 1\n",
+ "The last element is 5\n",
+ "L contains the sublist [2, 3, 4]\n"
+ ]
+ }
+ ],
+ "execution_count": 8
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:15:51.173918Z",
+ "start_time": "2025-01-22T09:15:51.170290Z"
+ }
+ },
+ "source": [
+ "L = [1, 2, 3, 4, 5]\n",
+ "print(\"L =\", L)\n",
+ "\n",
+ "# my_liste.append()\n",
+ "L.append(100)\n",
+ "print(\"L =\", L)\n"
+ ],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "L = [1, 2, 3, 4, 5]\n",
+ "L = [1, 2, 3, 4, 5, 100]\n"
+ ]
+ }
+ ],
+ "execution_count": 9
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 2.1.3. Type `array` : \n",
+ "In addition to these basic types, we work with the numpy library, which introduces the array type. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Question 8** : import numpy and use `np.array` to define a matrix $a$\n",
+ "\n",
+ "$a=\\begin{pmatrix}\n",
+ "1 & 2 \\\\\n",
+ "3 & 4 \\\\\n",
+ "\\end{pmatrix}$\n",
+ "\n",
+ "Display the matrix and its type."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:16:18.283762Z",
+ "start_time": "2025-01-22T09:16:18.280869Z"
+ }
+ },
+ "source": [
+ "# Your answer for Q8:\n",
+ "a = np.array([[1, 2], [3, 4]])\n",
+ "print(a)"
+ ],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[[1 2]\n",
+ " [3 4]]\n"
+ ]
+ }
+ ],
+ "execution_count": 11
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 2.2 Basic operations \n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 2.2.1 Operations on numbers\n",
+ "\n",
+ "Operators : `+,-,/,*`, and many other ones using the packages `math` and `numpy`.\n",
+ "\n",
+ "Package `math`: https://docs.python.org/3/library/math.html"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Question 9** : display $e$ and $log(e)$. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:17:01.140658Z",
+ "start_time": "2025-01-22T09:17:01.138212Z"
+ }
+ },
+ "source": [
+ "import math\n",
+ "\n",
+ "print(\"e = \", math.exp(1))\n",
+ "print(\"log(e) = \", math.log(math.exp(1)))\n",
+ "\n",
+ "print(\"e = \", np.exp(1))\n",
+ "print(\"log(e) = \", np.log(np.exp(1)))"
+ ],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "e = 2.718281828459045\n",
+ "log(e) = 1.0\n",
+ "e = 2.718281828459045\n",
+ "log(e) = 1.0\n"
+ ]
+ }
+ ],
+ "execution_count": 14
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 2.2.2 Operations on an array"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:17:03.680124Z",
+ "start_time": "2025-01-22T09:17:03.675137Z"
+ }
+ },
+ "source": [
+ "# Creation of a 2 x 3 array filled with zeroes:\n",
+ "A = np.zeros([2, 3])\n",
+ "print(\"A = \\n\", A)\n",
+ "\n",
+ "# Creation of a 2 x 3 array filled with ones\n",
+ "B = np.ones([2, 3])\n",
+ "print(\"\\nB = \\n\", B)\n",
+ "\n",
+ "# Identity matrix\n",
+ "C = np.eye(3) # alternative : np.identity(3)\n",
+ "print(\"\\n C = \\n\", A)\n",
+ "\n",
+ "# arange \n",
+ "print('np.arange(3) =', np.arange(3))\n",
+ "print('np.arange(2,5)=', np.arange(2, 5))\n"
+ ],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "A = \n",
+ " [[0. 0. 0.]\n",
+ " [0. 0. 0.]]\n",
+ "\n",
+ "B = \n",
+ " [[1. 1. 1.]\n",
+ " [1. 1. 1.]]\n",
+ "\n",
+ " C = \n",
+ " [[0. 0. 0.]\n",
+ " [0. 0. 0.]]\n",
+ "np.arange(3) = [0 1 2]\n",
+ "np.arange(2,5)= [2 3 4]\n"
+ ]
+ }
+ ],
+ "execution_count": 15
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Question 10**\n",
+ "Create an array that contains 10 evenly spaced numbers over [3,9].\n",
+ "\n",
+ "Click here for a hint\n",
+ "Use linspace https://numpy.org/doc/2.1/reference/generated/numpy.linspace.html\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:17:27.970224Z",
+ "start_time": "2025-01-22T09:17:27.966232Z"
+ }
+ },
+ "source": [
+ "space = np.linspace(3, 9, 10)\n",
+ "print(space)"
+ ],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[3. 3.66666667 4.33333333 5. 5.66666667 6.33333333\n",
+ " 7. 7.66666667 8.33333333 9. ]\n"
+ ]
+ }
+ ],
+ "execution_count": 17
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Matrix multiplication \n",
+ "**Beware**, `a*b` , where `a` and `b` are 2-dimensional arrays, corresponds to elementwise multiplication whereas matrix multiplication can be performed with `np.dot` or `@`.\n",
+ "The official documentation says `@`is to be preferred. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:17:44.926867Z",
+ "start_time": "2025-01-22T09:17:44.922056Z"
+ }
+ },
+ "source": [
+ "a = np.array([[1, 2], [3, 4]])\n",
+ "b = np.eye(2)\n",
+ "\n",
+ "print(\"a=\\n\", a)\n",
+ "print(\"b=\\n\", b)\n",
+ "\n",
+ "print(\" a*b = \\n \", a * b)\n",
+ "print(\" np.dot(a,b) = \\n\", np.dot(a, b))\n",
+ "print(\" a@b = \\n\", a @ b) # equivalent to np.matmul(a,b)"
+ ],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "a=\n",
+ " [[1 2]\n",
+ " [3 4]]\n",
+ "b=\n",
+ " [[1. 0.]\n",
+ " [0. 1.]]\n",
+ " a*b = \n",
+ " [[1. 0.]\n",
+ " [0. 4.]]\n",
+ " np.dot(a,b) = \n",
+ " [[1. 2.]\n",
+ " [3. 4.]]\n",
+ " a@b = \n",
+ " [[1. 2.]\n",
+ " [3. 4.]]\n"
+ ]
+ }
+ ],
+ "execution_count": 18
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Inner product for one dimensional arrays**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:17:48.202259Z",
+ "start_time": "2025-01-22T09:17:48.198663Z"
+ }
+ },
+ "source": [
+ "a = np.arange(3)\n",
+ "b = np.arange(4, 7)\n",
+ "c = np.dot(a, b)\n",
+ "d = np.inner(a, b)\n",
+ "print('a = ', a)\n",
+ "print('b = ', b)\n",
+ "print('np.dot(a,b)=', c)\n",
+ "print('np.inner(a,b)=', d) # alternative to np.dot for the inner product\n",
+ "# of one-dimensional arrays"
+ ],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "a = [0 1 2]\n",
+ "b = [4 5 6]\n",
+ "np.dot(a,b)= 17\n",
+ "np.inner(a,b)= 17\n"
+ ]
+ }
+ ],
+ "execution_count": 19
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Reshaping**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:17:50.913721Z",
+ "start_time": "2025-01-22T09:17:50.910196Z"
+ }
+ },
+ "source": [
+ "#Turning a one-dimensional array with 6 elements into a \n",
+ "#2x3 dimensional array \n",
+ "a = np.arange(6)\n",
+ "b = a.reshape(2, 3)\n",
+ "print('a = ', a)\n",
+ "print('b =\\n', b)"
+ ],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "a = [0 1 2 3 4 5]\n",
+ "b =\n",
+ " [[0 1 2]\n",
+ " [3 4 5]]\n"
+ ]
+ }
+ ],
+ "execution_count": 20
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Question 11**\n",
+ "Turn the previous 2X3 dimensional array `b` into a 3x2 dimensional array using `reshape`:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:18:51.612181Z",
+ "start_time": "2025-01-22T09:18:51.609302Z"
+ }
+ },
+ "source": [
+ "b2 = b.copy().reshape(3, 2)\n",
+ "print(b2)\n",
+ "print(b2.shape)"
+ ],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[[0 1]\n",
+ " [2 3]\n",
+ " [4 5]]\n",
+ "(3, 2)\n"
+ ]
+ }
+ ],
+ "execution_count": 27
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Question 12** Does the new array corresponds to the transpose of `b`? In case it does not, display the transpose of `b`. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:19:31.699357Z",
+ "start_time": "2025-01-22T09:19:31.697031Z"
+ }
+ },
+ "source": [
+ "print(b.transpose())\n",
+ "print(b.transpose() == b2)"
+ ],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[[0 3]\n",
+ " [1 4]\n",
+ " [2 5]]\n",
+ "[[ True False]\n",
+ " [False False]\n",
+ " [False True]]\n"
+ ]
+ }
+ ],
+ "execution_count": 30
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 2.3 `for`-loop and `if...else`\n",
+ "\n",
+ "Python code is structured by *indentation*.\n",
+ "\n",
+ "**Beware** : Python indices start at **ZERO** !"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Question 13** : Write a `for` loop that displays every integer `i` from 2 to 12. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:19:43.363208Z",
+ "start_time": "2025-01-22T09:19:43.359985Z"
+ }
+ },
+ "source": [
+ "for i in range(2, 13):\n",
+ " print(i)"
+ ],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2\n",
+ "3\n",
+ "4\n",
+ "5\n",
+ "6\n",
+ "7\n",
+ "8\n",
+ "9\n",
+ "10\n",
+ "11\n",
+ "12\n"
+ ]
+ }
+ ],
+ "execution_count": 31
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Question 14** : Write a program to check if a number is divisible by both 3 and 13 or not, using if-else. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:20:24.414268Z",
+ "start_time": "2025-01-22T09:20:24.410942Z"
+ }
+ },
+ "source": [
+ "def divisible_by_3_and13(n):\n",
+ " if n % 3 == 0 and n % 13 == 0:\n",
+ " print(n, \"is divisible by 3 and 13\")\n",
+ " else:\n",
+ " print(n, \"is not divisible by 3 and 13\")\n",
+ "\n",
+ "\n",
+ "print(divisible_by_3_and13(39))\n",
+ "print(divisible_by_3_and13(26))"
+ ],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "39 is divisible by 3 and 13\n",
+ "None\n",
+ "26 is not divisible by 3 and 13\n",
+ "None\n"
+ ]
+ }
+ ],
+ "execution_count": 33
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 2.4 Functions "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "To define a function, use the keyword `def`. To let a function return a value, use the return statement. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:20:41.546944Z",
+ "start_time": "2025-01-22T09:20:41.542979Z"
+ }
+ },
+ "source": [
+ "# Example\n",
+ "def my_function(x):\n",
+ " return x + 3\n",
+ "\n",
+ "\n",
+ "print(my_function(2))"
+ ],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "5\n"
+ ]
+ }
+ ],
+ "execution_count": 34
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Question 15** : Define a function named *square_cube*. The input is a integer, the output is its square and its cube. Diplay the result of carre_cube(2)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:20:59.887492Z",
+ "start_time": "2025-01-22T09:20:59.884773Z"
+ }
+ },
+ "source": [
+ "def square_cube(x):\n",
+ " return x ** 2, x ** 3\n",
+ "\n",
+ "\n",
+ "print(square_cube(2))"
+ ],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(4, 8)\n"
+ ]
+ }
+ ],
+ "execution_count": 35
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 2.5 Graphs "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Matplotlib tutorial :\n",
+ "https://matplotlib.org/stable/tutorials/introductory/pyplot.html"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:21:02.381191Z",
+ "start_time": "2025-01-22T09:21:02.126204Z"
+ }
+ },
+ "source": [
+ "import matplotlib.pyplot as plt"
+ ],
+ "outputs": [],
+ "execution_count": 36
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The basic command is `plt.plot(x,y)` where $x$ and $y$ are lists/arrays of the same size. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Question 16** : Plot the graph of the standard normal distribution density on [-5,5]. You can use `scipy.stats.norm`. \n",
+ "https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.norm.html"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:22:37.451301Z",
+ "start_time": "2025-01-22T09:22:37.386127Z"
+ }
+ },
+ "source": [
+ "xx = np.linspace(-5, 5, 100)\n",
+ "yy = norm.pdf(xx)\n",
+ "plt.plot(xx, yy)\n",
+ "plt.ylabel('Density')\n",
+ "plt.xlabel('x')\n",
+ "plt.title('Standard normal distribution')\n",
+ "plt.show()"
+ ],
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ],
+ "image/png": "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"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "execution_count": 39
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Question 17** : Plot the graph of the density of the two-dimensional standard normal distribution $\\mathcal{N}(0, I_2)$ on [-3,3]$\\times$[-3,3].\n",
+ "\n",
+ "We will use `plot_surface`. You can find an example here https://matplotlib.org/stable/gallery/mplot3d/surface3d.html\n",
+ "\n",
+ "For the PDF (probability density function), you can use `scipy.stats.multivariate_normal`. \n",
+ "https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.multivariate_normal.html"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "Click here for a hint\n",
+ "Use `meshgrid`. See below for more info about `meshgrid`. \n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:31:03.547534Z",
+ "start_time": "2025-01-22T09:31:03.467548Z"
+ }
+ },
+ "source": [
+ "from scipy.stats import multivariate_normal\n",
+ "\n",
+ "fig, ax = plt.subplots(subplot_kw={\"projection\": \"3d\"})\n",
+ "\n",
+ "X = np.arange(-3, 3, 0.25)\n",
+ "Y = np.arange(-3, 3, 0.25)\n",
+ "X, Y = np.meshgrid(X, Y)\n",
+ "R = multivariate_normal([0, 0], np.eye(2))\n",
+ "\n",
+ "surf = ax.plot_surface(X, Y, R.pdf(np.dstack((X, Y))), cmap='coolwarm', linewidth=0, antialiased=False)\n",
+ "\n",
+ "fig.colorbar(surf, shrink=0.5, aspect=5)\n",
+ "plt.show()"
+ ],
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ],
+ "image/png": "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"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "execution_count": 56
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "If you feel you need to practice more, there are lots of resources online, for instance : https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises.ipynb (exercises with solutions !)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Details about `meshgrid`: "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:31:27.147136Z",
+ "start_time": "2025-01-22T09:31:27.142313Z"
+ }
+ },
+ "source": [
+ "x = np.arange(3)\n",
+ "y = np.arange(3)\n",
+ "\n",
+ "\n",
+ "def f(x, y):\n",
+ " return x ** 2 + y ** 2\n",
+ "\n",
+ "\n",
+ "f(x, y)\n"
+ ],
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([0, 2, 8])"
+ ]
+ },
+ "execution_count": 57,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "execution_count": 57
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The output is [f(0,0),f(1,1),f(2,2)]\n",
+ "Now if the desired output is [f(0,0),f(0,1),f(0,2),f(1,0),f(1,1), etc. jusqu'Ã f(2,2)], \n",
+ "i.e. the f(i,j)'s for every (i,j) where i=0,1,2 and j=0,1,2, then you should use \n",
+ " `meshgrid`(or `mgrid`) instead. The output is two arrays :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:31:53.126413Z",
+ "start_time": "2025-01-22T09:31:53.120541Z"
+ }
+ },
+ "source": [
+ "X, Y = np.meshgrid(x, y)\n",
+ "X, Y"
+ ],
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(array([[0, 1, 2],\n",
+ " [0, 1, 2],\n",
+ " [0, 1, 2]]),\n",
+ " array([[0, 0, 0],\n",
+ " [1, 1, 1],\n",
+ " [2, 2, 2]]))"
+ ]
+ },
+ "execution_count": 58,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "execution_count": 58
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:32:24.722840Z",
+ "start_time": "2025-01-22T09:32:24.717892Z"
+ }
+ },
+ "source": "X ** 2 + Y ** 2 # gives the desired output",
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[0, 1, 4],\n",
+ " [1, 2, 5],\n",
+ " [4, 5, 8]])"
+ ]
+ },
+ "execution_count": 59,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "execution_count": 59
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:32:27.491058Z",
+ "start_time": "2025-01-22T09:32:27.486755Z"
+ }
+ },
+ "source": [
+ "#same calculation, except here Z is a list of lists \n",
+ "Z = [[x ** 2 + y ** 2 for x in range(3)] for y in range(3)]\n",
+ "Z"
+ ],
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[[0, 1, 4], [1, 2, 5], [4, 5, 8]]"
+ ]
+ },
+ "execution_count": 60,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "execution_count": 60
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:32:34.752570Z",
+ "start_time": "2025-01-22T09:32:34.747781Z"
+ }
+ },
+ "source": [
+ "#Alternative : using mgrid (vu qu'on utilise une grille uniforme)\n",
+ "X, Y = np.mgrid[0:3, 0:3] # equivalent to np.meshgrid(np.arange(3),np.arange(3))\n",
+ "X, Y"
+ ],
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(array([[0, 0, 0],\n",
+ " [1, 1, 1],\n",
+ " [2, 2, 2]]),\n",
+ " array([[0, 1, 2],\n",
+ " [0, 1, 2],\n",
+ " [0, 1, 2]]))"
+ ]
+ },
+ "execution_count": 61,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "execution_count": 61
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:32:36.382070Z",
+ "start_time": "2025-01-22T09:32:36.377342Z"
+ }
+ },
+ "source": [
+ "# from -1 to 1, in steps of 0.5\n",
+ "X, Y = np.mgrid[-1:1:.5, -1:1:.5]\n",
+ "X, Y"
+ ],
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(array([[-1. , -1. , -1. , -1. ],\n",
+ " [-0.5, -0.5, -0.5, -0.5],\n",
+ " [ 0. , 0. , 0. , 0. ],\n",
+ " [ 0.5, 0.5, 0.5, 0.5]]),\n",
+ " array([[-1. , -0.5, 0. , 0.5],\n",
+ " [-1. , -0.5, 0. , 0.5],\n",
+ " [-1. , -0.5, 0. , 0.5],\n",
+ " [-1. , -0.5, 0. , 0.5]]))"
+ ]
+ },
+ "execution_count": 62,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "execution_count": 62
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.9.7"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/M1/Stats learning/TP1 A first example.ipynb b/M1/Stats learning/TP1 A first example.ipynb
new file mode 100644
index 0000000..714b670
--- /dev/null
+++ b/M1/Stats learning/TP1 A first example.ipynb
@@ -0,0 +1,1700 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# TP1 A first example of statistical learning\n",
+ "\n",
+ "\n",
+ "### Table of Contents\n",
+ "\n",
+ "* [1. Linear regression](#chapter1)\n",
+ "* [2. Polynomial regression](#chapter2)\n",
+ " * [2.1 `PolynomialFeatures` 2-dimensional features](#section2_1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We will use the following simulated data. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:32:45.876883Z",
+ "start_time": "2025-01-22T09:32:45.601010Z"
+ }
+ },
+ "source": [
+ "from cProfile import label\n",
+ "\n",
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "rng = np.random.default_rng(seed=42)\n",
+ "size = 100\n",
+ "x = np.sort(rng.uniform(-5, 5, size))\n",
+ "X = x.reshape(size, 1) # See later (Question 8) for the reason why we reshape\n",
+ "# X into a 2-dimensional array with the same size (i.e \n",
+ "# same number of elements)\n",
+ "y = 0.5 + x ** 2 + x + 2 * rng.standard_normal(size)"
+ ],
+ "outputs": [],
+ "execution_count": 1
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now let us display the data : "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:34:02.429428Z",
+ "start_time": "2025-01-22T09:34:02.363995Z"
+ }
+ },
+ "source": [
+ "plt.scatter(x, y)\n",
+ "plt.show()"
+ ],
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ],
+ "image/png": "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"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "execution_count": 7
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Exercise 1** : \n",
+ "1. Which variable is the *feature/input/covariable*? \n",
+ "2. Which variable is the *label/outcome/target*? \n",
+ "3. What is the dimension $X$? What is the sample size? \n"
+ ]
+ },
+ {
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:34:58.459483Z",
+ "start_time": "2025-01-22T09:34:58.457153Z"
+ }
+ },
+ "cell_type": "code",
+ "source": "print(X.shape, x.shape)",
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(100, 1) (100,)\n"
+ ]
+ }
+ ],
+ "execution_count": 8
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Answer for Exercise 1 :\n",
+ "\n",
+ "1. Feature : x\n",
+ "\n",
+ "2. Target : y\n",
+ "\n",
+ "3. The dimension of X is (100, 1) and the sample size is 100.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 1. Linear regression \n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We will first use linear regression to model the relationship between $x$ and $y$. That is, we are looking for $\\hat{a}$ and $\\hat{b}$ such that $\\hat{f}(x)=\\hat{a}\\cdot x+\\hat{b}$ is close to $y$ in the sense of quadratic loss.\n",
+ "\n",
+ "We will use the sklearn package : `sklearn.linear_model.LinearRegression`. \n",
+ "\n",
+ "(Ref: https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html) <-- See the example on this page. The goal is to get used to sklearn syntax as we will use this package for all sessions (except for the neural networks). "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Exercise 2** : Define a linear regression model, named `lin_reg`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:38:51.198238Z",
+ "start_time": "2025-01-22T09:38:51.195801Z"
+ }
+ },
+ "source": [
+ "from sklearn.linear_model import LinearRegression\n",
+ "\n",
+ "lin_reg = LinearRegression()"
+ ],
+ "outputs": [],
+ "execution_count": 14
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Exercise 3** : Train the linear regression model `lin_reg` on $X$, y. If the training is successful, `lin_reg` will store the model and you will be able to access the different results using its attributes. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:38:55.111182Z",
+ "start_time": "2025-01-22T09:38:55.104393Z"
+ }
+ },
+ "source": "lin_reg.fit(X, y)",
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "LinearRegression()"
+ ],
+ "text/html": [
+ "
LinearRegression()
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
LinearRegression()
"
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "execution_count": 16
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Exercise 4**: Try the following code and explain the problem. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:38:57.098642Z",
+ "start_time": "2025-01-22T09:38:56.937883Z"
+ }
+ },
+ "source": "lin_reg.fit(x, y) # we used x instead of X",
+ "outputs": [
+ {
+ "ename": "ValueError",
+ "evalue": "Expected 2D array, got 1D array instead:\narray=[-4.9263773 -4.77287927 -4.69182165 -4.56196234 -4.41697258 -4.36182744\n -4.12350081 -4.09952139 -4.05822652 -3.85469926 -3.81994098 -3.71886367\n -3.70078495 -3.60247516 -3.60203002 -3.47687897 -3.45710508 -3.38728221\n -3.3302708 -3.10528641 -3.05361292 -3.00091798 -2.85415327 -2.73090651\n -2.72761278 -2.66060514 -2.18616108 -2.11671896 -2.06406242 -1.98487911\n -1.96049902 -1.87633359 -1.74174642 -1.45474032 -1.38187389 -1.29540294\n -1.29201976 -1.18978774 -1.12521621 -0.93613139 -0.91471356 -0.63282611\n -0.62848081 -0.6112156 -0.56585801 -0.53843724 -0.49614062 -0.41084224\n -0.3812277 -0.33278996 -0.30444189 -0.28903794 -0.24295074 0.01044775\n 0.53579401 0.54584787 0.57032152 0.59207161 0.65236106 0.68741196\n 1.30282593 1.31664399 1.3471832 1.4386512 1.61916515 1.6431354\n 1.64850857 1.68402962 1.69813995 1.82495504 1.83048953 1.96320375\n 1.97368029 2.00265102 2.05165379 2.22359351 2.44762156 2.5808774\n 2.61139702 2.64998857 2.73956049 2.78383497 2.80729031 2.83898209\n 2.86064305 2.86924378 3.04764357 3.14020385 3.22761613 3.27631172\n 3.32259801 3.32678196 3.53403073 3.5859792 3.93121121 4.26764989\n 4.61897665 4.67509732 4.70698024 4.75622352].\nReshape your data either using array.reshape(-1, 1) if your data has a single feature or array.reshape(1, -1) if it contains a single sample.",
+ "output_type": "error",
+ "traceback": [
+ "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
+ "\u001B[0;31mValueError\u001B[0m Traceback (most recent call last)",
+ "Cell \u001B[0;32mIn[17], line 1\u001B[0m\n\u001B[0;32m----> 1\u001B[0m \u001B[43mlin_reg\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mfit\u001B[49m\u001B[43m(\u001B[49m\u001B[43mx\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43my\u001B[49m\u001B[43m)\u001B[49m \u001B[38;5;66;03m# we used x instead of X\u001B[39;00m\n",
+ "File \u001B[0;32m/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/sklearn/base.py:1389\u001B[0m, in \u001B[0;36m_fit_context..decorator..wrapper\u001B[0;34m(estimator, *args, **kwargs)\u001B[0m\n\u001B[1;32m 1382\u001B[0m estimator\u001B[38;5;241m.\u001B[39m_validate_params()\n\u001B[1;32m 1384\u001B[0m \u001B[38;5;28;01mwith\u001B[39;00m config_context(\n\u001B[1;32m 1385\u001B[0m skip_parameter_validation\u001B[38;5;241m=\u001B[39m(\n\u001B[1;32m 1386\u001B[0m prefer_skip_nested_validation \u001B[38;5;129;01mor\u001B[39;00m global_skip_validation\n\u001B[1;32m 1387\u001B[0m )\n\u001B[1;32m 1388\u001B[0m ):\n\u001B[0;32m-> 1389\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mfit_method\u001B[49m\u001B[43m(\u001B[49m\u001B[43mestimator\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43margs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n",
+ "File \u001B[0;32m/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/sklearn/linear_model/_base.py:601\u001B[0m, in \u001B[0;36mLinearRegression.fit\u001B[0;34m(self, X, y, sample_weight)\u001B[0m\n\u001B[1;32m 597\u001B[0m n_jobs_ \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mn_jobs\n\u001B[1;32m 599\u001B[0m accept_sparse \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mFalse\u001B[39;00m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mpositive \u001B[38;5;28;01melse\u001B[39;00m [\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mcsr\u001B[39m\u001B[38;5;124m\"\u001B[39m, \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mcsc\u001B[39m\u001B[38;5;124m\"\u001B[39m, \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mcoo\u001B[39m\u001B[38;5;124m\"\u001B[39m]\n\u001B[0;32m--> 601\u001B[0m X, y \u001B[38;5;241m=\u001B[39m \u001B[43mvalidate_data\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 602\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[43m,\u001B[49m\n\u001B[1;32m 603\u001B[0m \u001B[43m \u001B[49m\u001B[43mX\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 604\u001B[0m \u001B[43m \u001B[49m\u001B[43my\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 605\u001B[0m \u001B[43m \u001B[49m\u001B[43maccept_sparse\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43maccept_sparse\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 606\u001B[0m \u001B[43m \u001B[49m\u001B[43my_numeric\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mTrue\u001B[39;49;00m\u001B[43m,\u001B[49m\n\u001B[1;32m 607\u001B[0m \u001B[43m \u001B[49m\u001B[43mmulti_output\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mTrue\u001B[39;49;00m\u001B[43m,\u001B[49m\n\u001B[1;32m 608\u001B[0m \u001B[43m \u001B[49m\u001B[43mforce_writeable\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mTrue\u001B[39;49;00m\u001B[43m,\u001B[49m\n\u001B[1;32m 609\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 611\u001B[0m has_sw \u001B[38;5;241m=\u001B[39m sample_weight \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m\n\u001B[1;32m 612\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m has_sw:\n",
+ "File \u001B[0;32m/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/sklearn/utils/validation.py:2961\u001B[0m, in \u001B[0;36mvalidate_data\u001B[0;34m(_estimator, X, y, reset, validate_separately, skip_check_array, **check_params)\u001B[0m\n\u001B[1;32m 2959\u001B[0m y \u001B[38;5;241m=\u001B[39m check_array(y, input_name\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124my\u001B[39m\u001B[38;5;124m\"\u001B[39m, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mcheck_y_params)\n\u001B[1;32m 2960\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[0;32m-> 2961\u001B[0m X, y \u001B[38;5;241m=\u001B[39m \u001B[43mcheck_X_y\u001B[49m\u001B[43m(\u001B[49m\u001B[43mX\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43my\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mcheck_params\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 2962\u001B[0m out \u001B[38;5;241m=\u001B[39m X, y\n\u001B[1;32m 2964\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m no_val_X \u001B[38;5;129;01mand\u001B[39;00m check_params\u001B[38;5;241m.\u001B[39mget(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mensure_2d\u001B[39m\u001B[38;5;124m\"\u001B[39m, \u001B[38;5;28;01mTrue\u001B[39;00m):\n",
+ "File \u001B[0;32m/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/sklearn/utils/validation.py:1370\u001B[0m, in \u001B[0;36mcheck_X_y\u001B[0;34m(X, y, accept_sparse, accept_large_sparse, dtype, order, copy, force_writeable, force_all_finite, ensure_all_finite, ensure_2d, allow_nd, multi_output, ensure_min_samples, ensure_min_features, y_numeric, estimator)\u001B[0m\n\u001B[1;32m 1364\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mValueError\u001B[39;00m(\n\u001B[1;32m 1365\u001B[0m \u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;132;01m{\u001B[39;00mestimator_name\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m requires y to be passed, but the target y is None\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m 1366\u001B[0m )\n\u001B[1;32m 1368\u001B[0m ensure_all_finite \u001B[38;5;241m=\u001B[39m _deprecate_force_all_finite(force_all_finite, ensure_all_finite)\n\u001B[0;32m-> 1370\u001B[0m X \u001B[38;5;241m=\u001B[39m \u001B[43mcheck_array\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 1371\u001B[0m \u001B[43m \u001B[49m\u001B[43mX\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1372\u001B[0m \u001B[43m \u001B[49m\u001B[43maccept_sparse\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43maccept_sparse\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1373\u001B[0m \u001B[43m \u001B[49m\u001B[43maccept_large_sparse\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43maccept_large_sparse\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1374\u001B[0m \u001B[43m \u001B[49m\u001B[43mdtype\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mdtype\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1375\u001B[0m \u001B[43m \u001B[49m\u001B[43morder\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43morder\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1376\u001B[0m \u001B[43m \u001B[49m\u001B[43mcopy\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcopy\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1377\u001B[0m \u001B[43m \u001B[49m\u001B[43mforce_writeable\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mforce_writeable\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1378\u001B[0m \u001B[43m \u001B[49m\u001B[43mensure_all_finite\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mensure_all_finite\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1379\u001B[0m \u001B[43m \u001B[49m\u001B[43mensure_2d\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mensure_2d\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1380\u001B[0m \u001B[43m \u001B[49m\u001B[43mallow_nd\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mallow_nd\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1381\u001B[0m \u001B[43m \u001B[49m\u001B[43mensure_min_samples\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mensure_min_samples\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1382\u001B[0m \u001B[43m \u001B[49m\u001B[43mensure_min_features\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mensure_min_features\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1383\u001B[0m \u001B[43m \u001B[49m\u001B[43mestimator\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mestimator\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1384\u001B[0m \u001B[43m \u001B[49m\u001B[43minput_name\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[38;5;124;43mX\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1385\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1387\u001B[0m y \u001B[38;5;241m=\u001B[39m _check_y(y, multi_output\u001B[38;5;241m=\u001B[39mmulti_output, y_numeric\u001B[38;5;241m=\u001B[39my_numeric, estimator\u001B[38;5;241m=\u001B[39mestimator)\n\u001B[1;32m 1389\u001B[0m check_consistent_length(X, y)\n",
+ "File \u001B[0;32m/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/sklearn/utils/validation.py:1093\u001B[0m, in \u001B[0;36mcheck_array\u001B[0;34m(array, accept_sparse, accept_large_sparse, dtype, order, copy, force_writeable, force_all_finite, ensure_all_finite, ensure_non_negative, ensure_2d, allow_nd, ensure_min_samples, ensure_min_features, estimator, input_name)\u001B[0m\n\u001B[1;32m 1086\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m 1087\u001B[0m msg \u001B[38;5;241m=\u001B[39m (\n\u001B[1;32m 1088\u001B[0m \u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mExpected 2D array, got 1D array instead:\u001B[39m\u001B[38;5;130;01m\\n\u001B[39;00m\u001B[38;5;124marray=\u001B[39m\u001B[38;5;132;01m{\u001B[39;00marray\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m.\u001B[39m\u001B[38;5;130;01m\\n\u001B[39;00m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m 1089\u001B[0m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mReshape your data either using array.reshape(-1, 1) if \u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m 1090\u001B[0m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124myour data has a single feature or array.reshape(1, -1) \u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m 1091\u001B[0m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mif it contains a single sample.\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m 1092\u001B[0m )\n\u001B[0;32m-> 1093\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mValueError\u001B[39;00m(msg)\n\u001B[1;32m 1095\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m dtype_numeric \u001B[38;5;129;01mand\u001B[39;00m \u001B[38;5;28mhasattr\u001B[39m(array\u001B[38;5;241m.\u001B[39mdtype, \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mkind\u001B[39m\u001B[38;5;124m\"\u001B[39m) \u001B[38;5;129;01mand\u001B[39;00m array\u001B[38;5;241m.\u001B[39mdtype\u001B[38;5;241m.\u001B[39mkind \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mUSV\u001B[39m\u001B[38;5;124m\"\u001B[39m:\n\u001B[1;32m 1096\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mValueError\u001B[39;00m(\n\u001B[1;32m 1097\u001B[0m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mdtype=\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mnumeric\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124m is not compatible with arrays of bytes/strings.\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m 1098\u001B[0m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mConvert your data to numeric values explicitly instead.\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m 1099\u001B[0m )\n",
+ "\u001B[0;31mValueError\u001B[0m: Expected 2D array, got 1D array instead:\narray=[-4.9263773 -4.77287927 -4.69182165 -4.56196234 -4.41697258 -4.36182744\n -4.12350081 -4.09952139 -4.05822652 -3.85469926 -3.81994098 -3.71886367\n -3.70078495 -3.60247516 -3.60203002 -3.47687897 -3.45710508 -3.38728221\n -3.3302708 -3.10528641 -3.05361292 -3.00091798 -2.85415327 -2.73090651\n -2.72761278 -2.66060514 -2.18616108 -2.11671896 -2.06406242 -1.98487911\n -1.96049902 -1.87633359 -1.74174642 -1.45474032 -1.38187389 -1.29540294\n -1.29201976 -1.18978774 -1.12521621 -0.93613139 -0.91471356 -0.63282611\n -0.62848081 -0.6112156 -0.56585801 -0.53843724 -0.49614062 -0.41084224\n -0.3812277 -0.33278996 -0.30444189 -0.28903794 -0.24295074 0.01044775\n 0.53579401 0.54584787 0.57032152 0.59207161 0.65236106 0.68741196\n 1.30282593 1.31664399 1.3471832 1.4386512 1.61916515 1.6431354\n 1.64850857 1.68402962 1.69813995 1.82495504 1.83048953 1.96320375\n 1.97368029 2.00265102 2.05165379 2.22359351 2.44762156 2.5808774\n 2.61139702 2.64998857 2.73956049 2.78383497 2.80729031 2.83898209\n 2.86064305 2.86924378 3.04764357 3.14020385 3.22761613 3.27631172\n 3.32259801 3.32678196 3.53403073 3.5859792 3.93121121 4.26764989\n 4.61897665 4.67509732 4.70698024 4.75622352].\nReshape your data either using array.reshape(-1, 1) if your data has a single feature or array.reshape(1, -1) if it contains a single sample."
+ ]
+ }
+ ],
+ "execution_count": 17
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The same *problem* arises very often with sklearn : we will have to use `reshape` for one-dimensional features. Some extra info about `reshape`:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:39:52.478784Z",
+ "start_time": "2025-01-22T09:39:52.472388Z"
+ }
+ },
+ "source": [
+ "a = np.arange(6).reshape(2, 3)\n",
+ "# 3 ways to reshape the array a into a 3 x 2 array \n",
+ "b = a.reshape(3, 2)\n",
+ "b2 = a.reshape(3, -1) # -1 means \"guess\" the number\n",
+ "b3 = a.reshape(-1, 2) # same\n",
+ "# obviously reshape(4,-1) would not work here as 2 X 3=6 is not\n",
+ "# divisible by 4...\n",
+ "print(a)\n",
+ "print(b)\n",
+ "print(b2)\n",
+ "print(b3)"
+ ],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[[0 1 2]\n",
+ " [3 4 5]]\n",
+ "[[0 1]\n",
+ " [2 3]\n",
+ " [4 5]]\n",
+ "[[0 1]\n",
+ " [2 3]\n",
+ " [4 5]]\n",
+ "[[0 1]\n",
+ " [2 3]\n",
+ " [4 5]]\n"
+ ]
+ }
+ ],
+ "execution_count": 20
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Exercise 5** : \n",
+ "\n",
+ "(1) Compute $\\hat{y}$ and the plot the line estimated by the model. \n",
+ " \n",
+ "Click here for a hint\n",
+ "You can use `lin_reg.predict`. \n",
+ "\n",
+ "\n",
+ "(2) Predict the value of $y$ for x=1. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:50:01.091807Z",
+ "start_time": "2025-01-22T09:50:00.964206Z"
+ }
+ },
+ "source": [
+ "y_predict = lin_reg.predict(X)\n",
+ "plt.plot(X, y_predict, color='r', label='Regression')\n",
+ "plt.scatter(X, y, label='Sample')\n",
+ "plt.legend()\n",
+ "plt.show()\n",
+ "\n",
+ "y_1 = lin_reg.predict([[1]])\n",
+ "print(\"The estimated value for x=1 is\", y_1)"
+ ],
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ],
+ "image/png": "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"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "The estimated value for x=1 is [8.54372371]\n"
+ ]
+ }
+ ],
+ "execution_count": 52
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Exercise 6** : Display the coefficients $\\hat{a}$ and $\\hat{b}$ computed by `lin_reg`. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:42:26.316701Z",
+ "start_time": "2025-01-22T09:42:26.312959Z"
+ }
+ },
+ "source": "print(\"The estimated coefficients are a=\", lin_reg.coef_, \", b=\", lin_reg.intercept_)",
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "The estimated coefficients are a= [0.6841386] , b= 7.8595851113619375\n"
+ ]
+ }
+ ],
+ "execution_count": 30
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Exercise 7** : Calculate the quadratic error $\\sum_{i=1}^{100}(y_i-\\hat{y}_i)^2$."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:42:50.448815Z",
+ "start_time": "2025-01-22T09:42:50.445550Z"
+ }
+ },
+ "source": "print(np.sum((y - y_predict) ** 2))",
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "4906.471161398307\n"
+ ]
+ }
+ ],
+ "execution_count": 31
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Exercise 8** : What does the next line of code compute ? (see the doc : https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html.)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:42:57.691432Z",
+ "start_time": "2025-01-22T09:42:57.686810Z"
+ }
+ },
+ "source": [
+ "lin_reg.score(X, y)"
+ ],
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0.06603572054935491"
+ ]
+ },
+ "execution_count": 32,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "execution_count": 32
+ },
+ {
+ "metadata": {},
+ "cell_type": "markdown",
+ "source": "The output is the $R^2$ coefficient. It is far from 1, which means that the model is not perfect."
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 2.Polynomial regression \n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We seek 3 coefficients $\\hat{a}$, $\\hat{b}$ and $\\hat{c}$ such that $\\hat{f}(x)=\\hat{a}\\cdot x^{2}+\\hat{b}\\cdot x +\\hat{c}$ is close to $y$ with respect to the quadratic loss. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Exercise 9** : Create a new 2-dimensional array named `X2`, of dimension $100\\times$2, the first column of which is $x^2$, and the second column is $x$."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:44:45.265060Z",
+ "start_time": "2025-01-22T09:44:45.261420Z"
+ }
+ },
+ "source": [
+ "X2 = np.array([x ** 2, x]).T\n",
+ "print(X2.shape)"
+ ],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(100, 2)\n"
+ ]
+ }
+ ],
+ "execution_count": 36
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Exercise 10** : Fit a new model, named `poly2_reg`, which will be the linear regression of `y` on `X2` (which will correspond to 2nd degree polynomial regression of `y` on `X`)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2025-01-22T09:45:05.543859Z",
+ "start_time": "2025-01-22T09:45:05.532828Z"
+ }
+ },
+ "source": [
+ "poly2_reg = LinearRegression()\n",
+ "poly2_reg.fit(X2, y)"
+ ],
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "LinearRegression()"
+ ],
+ "text/html": [
+ "
LinearRegression()
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.