"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"Text(0, 0.5, 'Poids')"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"plt.close()\n",
"\n",
"# data\n",
"x = np.array([[1.47,1.50,1.53,1.55,1.58,1.60,1.63,1.65,1.68,1.70,1.73,1.75,1.78,1.80,1.83]]).T\n",
"y = np.array([[49,50,51,52,54,56,58,59,60,62,63,64,66,67,68]]).T\n",
"print(x.shape)\n",
"print(y.shape)\n",
"\n",
"\n",
"# plot the data\n",
"plt.scatter(x,y, color='red')\n",
"plt.title('Poids en fonction de taille')\n",
"plt.xlabel('Taille')\n",
"plt.ylabel('Poids')\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On voudrait approcher les données au mieux à l'aide d'une droite $y = a . x + b$.\n",
"\n",
"\n",
"Ici la fonction à minimiser est la fonction $E(a,b) = \\sum_i(y_ i - (aX_i + b))^2$.\n",
"\n",
"\n",
"La fonction `plotDroite` affiche en rouge les données de coordonnées $(dataX[i], dataY[i])$ et, en bleu, la droite $y = ax+b$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def plotDroite(dataX,dataY,a,b):\n",
" \n",
" # Representation des donnees x en fct de y\n",
" plt.scatter(dataX,dataY, color='red')\n",
" plt.title('Poids en fonction de taille')\n",
" plt.xlabel('Taille (en m)')\n",
" plt.ylabel('Poids')\n",
" \n",
" #Representation de la droite y=ax+b\n",
" xinf=np.linspace(min(dataX)-10,max(dataX)+10,500)\n",
" yinf=[a*i+b for i in xinf]\n",
" \n",
" plt.plot(xinf,yinf, color='blue')\n",
" plt.ylim(min(dataY)-5,max(dataY)+5)\n",
" plt.xlim(min(dataX)-0.1,max(dataX)+0.1)\n",
" \n",
" plt.tight_layout()\n",
"\n",
" plt.show()\n",
"\n",
"plotDroite(x,y,0,60)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Question 1** \n",
"\n",
"A l'aide des widgets, visualiser l'effet d'un changement de a et b. Arrivez-vous à trouver des valeurs de a et b qui permettent d'approcher les données ?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Question 2** \n",
"\n",
"Nous avons vu en cours la formule pour calculer théoriquement les paramètres $a^*$ et $b^*$ optimaux pour la regression linéaire à partir du gradient de $E$.\n",
"\n",
"1. Rappelez la formule de $a^*$ et $b^*$ trouvées en cours et utiliser Python pour calculer ces paramètres optimaux.\n",
"\n",
"2. En déduire le poids théorique d'une personne de $1.77$m\n",
"\n",
"3. Quelle est la valeur de l'erreur minimale $E(a^*,b^*)$ ?\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Question 3**\n",
"\n",
"1. Calculer théoriquement le gradient de la fonction de coût $E(a,b)$ (on pourra se reporter au cours)\n",
"\n",
"2. Ecrire la fonction `gradReg(a,b,x,y)` qui retourne le gradient associé à la fonction de coût pour la regression linéaire.\n",
"\n",
"3. Ecrire la fonction `graddes(dataX,dataY,a0,b0,k,d)` qui fait la descente de gradient et renvoie les valeurs de a et b après k pas."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": []
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"grad = [[-0.00020373 -0.00020491]\n",
" [ 0.00033763 0.00033959]]\n",
"err = 7.450068810470074\n"
]
},
{
"data": {
"text/plain": [
"(array([56.37941812, 56.37940578]), array([-34.53878748, -34.53876703]))"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Question 4** \n",
"\n",
"Ecrire une fonction `plotErrEtDroite(dataX,dataY,a0,b0,k,d)` qui trace la valeur de l'erreur $E(a,b)$ en fonction du temps (nombre de pas) et qui trace les données et la droite de régression obtenue après la descente de gradient sur le même graphe (utiliser plotDroite)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Un peu de machine learning avec neurones : régression linéaire toujours\n",
"\n",
"créer un neurone permettant de retrouver la régression linéaire et entrainez le.\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"Model: \"sequential_1\"\n",
"\n"
],
"text/plain": [
"\u001b[1mModel: \"sequential_1\"\u001b[0m\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
"┃ Layer (type) ┃ Output Shape ┃ Param # ┃\n",
"┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
"│ dense_1 (Dense) │ (None, 1) │ 2 │\n",
"└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
"\n"
],
"text/plain": [
"┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
"┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n",
"┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
"│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m2\u001b[0m │\n",
"└─────────────────────────────────┴────────────────────────┴───────────────┘\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
" Total params: 2 (8.00 B)\n",
"\n"
],
"text/plain": [
"\u001b[1m Total params: \u001b[0m\u001b[38;5;34m2\u001b[0m (8.00 B)\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
" Trainable params: 2 (8.00 B)\n",
"\n"
],
"text/plain": [
"\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m2\u001b[0m (8.00 B)\n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
" Non-trainable params: 0 (0.00 B)\n",
"\n"
],
"text/plain": [
"\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Architecture du réseau\n",
"modelreg = Sequential()\n",
"\n",
"# Couches de neurones\n",
"modelreg.add(Dense(1, input_dim=1, activation='linear'))\n",
"\n",
"# Couche 0 - Définir à la main les poids\n",
"coeff = np.array([[0]])\n",
"biais = np.array([1])\n",
"poids = [coeff,biais]\n",
"\n",
"modelreg.layers[0].set_weights(poids)\n",
"modelreg.summary()"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [],
"source": [
"#inspiré de https://colab.research.google.com/github/toelt-llc/ADL-Book-2nd-Ed/blob/master/docs/single_neuron/Linear_regression_with_one_neuron.ipynb#scrollTo=iEYRvFMXx7i4\n",
"\n",
"keras.optimizers.SGD(\n",
" learning_rate=0.01,\n",
" momentum=0.0,\n",
")\n",
"\n",
"\n",
"modelreg.compile(optimizer = optimizer, loss = 'mean_squared_error', metrics = ['mse'])\n",
"\n",
"history = modelreg.fit(x, y, validation_split=0.2, epochs=100,verbose =0)"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" | \n",
" loss | \n",
" mse | \n",
" val_loss | \n",
" val_mse | \n",
" epoch | \n",
"
\n",
" \n",
" \n",
" \n",
" | 95 | \n",
" 48.415562 | \n",
" 48.415562 | \n",
" 168.278687 | \n",
" 168.278687 | \n",
" 95 | \n",
"
\n",
" \n",
" | 96 | \n",
" 48.104721 | \n",
" 48.104721 | \n",
" 167.578659 | \n",
" 167.578659 | \n",
" 96 | \n",
"
\n",
" \n",
" | 97 | \n",
" 47.795135 | \n",
" 47.795135 | \n",
" 166.880173 | \n",
" 166.880173 | \n",
" 97 | \n",
"
\n",
" \n",
" | 98 | \n",
" 47.486866 | \n",
" 47.486866 | \n",
" 166.183258 | \n",
" 166.183258 | \n",
" 98 | \n",
"
\n",
" \n",
" | 99 | \n",
" 47.179974 | \n",
" 47.179974 | \n",
" 165.488068 | \n",
" 165.488068 | \n",
" 99 | \n",
"
\n",
" \n",
"
\n",
"