Réseau de neurones Python

[Loupsio]

Bonjour à tous

Je cherche a faire fonctionner un reseau de neurone assez simpliste (4 inputs, 1 output, 0 inner layer),
je tiens a préciser que c'est normal que je n'utilise aucun paquet tel que tensor flow ou scikit-learn, puisque le but ici était de comprendre, pas juste d'utiliser le pakage "parce que c'est plus simple avec les librairies", donc je ne cherche pas a faire "fonctionner" mon échantillon au moyen d'un package, je cherche a savoir qu'est ce qui ne va pas dans le code

j'ai repris le code que j'ai trouvé sur un tuto (https://www.youtube.com/watch?v=LSr96IZQknc)
dans l'exemple il y a 2 inputs et un output
l'exemple marche très bien, le cost diminue au fur et a mesure de l'entrainement et les prédictions sont plutot bonnes

j'ai juste rajouté 2 neurones d'entrée pour l'adapter à un nouveau jeu de donnée (j'ai donc rajouter les poids concernant ces deux nouveaux neurones, ainsi que les calculs de derivatives associées)

import numpy as np
from matplotlib import pyplot as plt

def sigmoid(x):
    return(1/(1+np.exp(-x)))
def sigmoid_p(x):# derivative sigmoide
    return(sigmoid(x)*(1-sigmoid(x)))
#sepal length, sepal width, petal length petal width, espece (versicolor =0 vs virginica=1)
data=[[64,28,56,22,1],
      [65,28,46,15,0],
      [67,31,56,24,1],
      [63,28,51,15,1],
      [69,31,51,23,1],
      [62,22,45,15,0],
      [59,32,48,18,0],
      [61,30,46,14,0],
      [60,27,51,16,0],
      [65,30,52,20,1],
      [56,25,39,11,0],
      [65,30,55,18,1],
      [58,27,51,19,1],
      [68,32,59,23,1],
      [57,28,45,13,0],
      [62,34,54,23,1],
      [63,33,47,16,0],
      [70,32,47,14,0],
      [64,32,45,15,0]
      ]
mysteryFlowerVi=[69,31,54,21]
mysteryFlowerVe=[61,29,47,14]


w1=np.random.randn()
w2=np.random.randn()
w3=np.random.randn()
w4=np.random.randn()
b=np.random.randn()


learning_rate=0.7
costs=[]
for i in range(1,50000):
    ri=np.random.randint(len(data))   #prendre une fleur au hasard
    point=data[ri]                    #prendre une fleur au hasard

    z=point[0]*w1+point[1]*w2+point[2]*w3+point[3]*w4+b  # evaluer 
    prediction=sigmoid(z)

    target=point[4]   # ce qu'on est censé trouver
    cost=np.square(prediction-target)  #cout, s'il est trop grand les poids seront modifiés

    costs.append(cost)

    dcost_pred= 2*(prediction-target)
    dpred_dz=sigmoid_p(z)
    dz_dw1=point[0]
    dz_dw2=point[1]
    dz_dw3=point[2]
    dz_dw4=point[3]
    dz_db=1

    dcost_dw1 = dcost_pred*dpred_dz*dz_dw1
    dcost_dw2 = dcost_pred*dpred_dz*dz_dw2
    dcost_dw3 = dcost_pred*dpred_dz*dz_dw3
    dcost_dw4 = dcost_pred*dpred_dz*dz_dw4
    dcost_db = dcost_pred*dpred_dz*dz_db
    
    w1=w1-learning_rate*dcost_dw1
    w2=w2-learning_rate*dcost_dw2
    w3=w3-learning_rate*dcost_dw3
    w4=w4-learning_rate*dcost_dw4
    b=b-learning_rate*dcost_db

plt.plot(costs)
plt.show()


zVE=mysteryFlowerVe[0]*w1+mysteryFlowerVe[1]*w2+mysteryFlowerVe[2]*w3+mysteryFlowerVe[3]*w4+b

zVi=mysteryFlowerVi[0]*w1+mysteryFlowerVi[1]*w2+mysteryFlowerVi[2]*w3+mysteryFlowerVi[3]*w4+b
predictionVE=sigmoid(zVE)#doit renvoyer 0
predictionVi=sigmoid(zVi)#doit renvoyer 1
print('\n\n',predictionVE)
print(predictionVi)

je sais qu'une 15aine d'echantillon c'est pas énormes mais c'est juste pour l'exemple, le problème ne vient pas de la
Le probleme c'est que ici j'obtiens un "z" assez grand (par exemple 55) lorsque je somme chaque entrée par le poids de son neurone et que j'ajoute le biais, du coup lorsqu'on utilise la derivative sigmoid, celle ci est égale à 0 , puique celle ci est egale a zéro, "dpred_dz" est égal a 0 et donc toutes les variables "dcost" (dcost_dw1, dcost_dw2...) sont aussi égales a 0 puisque dedans se trouve dpred_dz multiplié (et multiplier par 0 donne forcément 0)
Or la moification du poids associé a chaque neurone correspond à

w1=w1-learning_rate*dcost_dw1

c qui revient a "poids-(x*0), donc e poids auquel on soustrait rien du tout

pourtant cela fonctionnait très bien avec l'exemple initial de la vidéo, et je n'ai pas modifié les calculs ( a part ajouté les neurones 3 et 4) et il s'agit du meme genre de données (mesures de fleurs), meme type de resultat attendu (2 especes possibles)

Merci à ceux qui pourront m'aider à comprendre
-----

[herrmattoon]

Hello,

Je te propose de jeter un œil ici :
https://www.internalpointers.com/pos...tic-regression

La fonction coût que tu utilises a bien des chances de ne pas être convexe et donc de te faire tomber sur un minimum local mais pas global...

Je n'ai pas analysé tout ton code mais je pense que c'est une piste sérieuse à envisager.

[pm42]

Merci à ceux qui pourront m'aider à comprendre

J'ai lu vite mais je me demande si tu n'es pas tombé sur un cas classique de disparition du gradient, la sigmoid y étant de plus assez sensible.
Il serait intéressant d'essayer avec du Relu pour voir.

https://towardsdatascience.com/the-v...m-69bf08b15484
https://en.wikipedia.org/wiki/Vanish...adient_problem

[Loupsio]

Oula, ya du déterrement d'anciens posts ^^, il date d'avant https://forums.futura-sciences.com/p...-neurones.html ou tu m'avais apporté ton aide à l'époque,

Effectivement avec le recul je pense qu'il s'agissait d'une disparition de gradient, j'ai d'ailleurs arrêté d'utiliser sigmoide, même si je ne doute pas qu'elle ait un interet dans certains cas, ReLu est effectivement plus polyvalent, (d'ailleurs maintenant que j'ai pu me faire la min sur de versions "manuelles" pour comprendre le fond, j'utilise maintenant les package, car les versions manuelles, quand ca marche, c'est génial, mais quand cela ne marche pas, je n'ai pas les connaissances en math nécessaire pour tout passer au peigne fin ^^ ca reste tout de meme interessant à utiliser pour comprendre le fond)

En tout cas merci quand meme à vous deux

[A voir en vidéo sur Futura]

[pm42]

Oula, ya du déterrement d'anciens posts ^^

Ah oui, je n'avais pas vu la date de ton post, il est redevenu visible suite à la réponse d'herrmattoon.

j'utilise maintenant les package, car les versions manuelles, quand ca marche, c'est génial, mais quand cela ne marche pas, je n'ai pas les connaissances en math nécessaire pour tout passer au peigne fin

Même en ayant les connaissances, on gagne un temps fou. Des chercheurs en IA m'ont dit que ce qui leur prenait 6 mois avant Tensorflow, Pytorch & co leur prend moins de 15 jours maintenant.

[Loupsio]

Même en ayant les connaissances, on gagne un temps fou. Des chercheurs en IA m'ont dit que ce qui leur prenait 6 mois avant Tensorflow, Pytorch & co leur prend moins de 15 jours maintenant.

Bien évidemment, c'est d'ailleurs pour ca qu'ils sont développé en premier lieu je pense, mais ce que je veux dire c'est que malgré que les maths poussées par la suite puissent être limitantes, c'est tout de même intéressant de commencer par la version manuelle et de se frotter a des problèmes dont on peut essayer de suivre le raisonnement, avant de passer aux packages (comme le fait que mon learning rate ne changeait pas lorsque mon "z" était trop grand, ce que je n'aurais pas pu comprendre si j'avais utilisé une fonction issue d'un package qui aurait fait tout ca a ma place), même si mathématiquement après je n'étais pas en mesure de corriger ou d'adapter le code pour le faire fonctionner de façon manuelle en sachant ca in fine on est obligé de passer aux librairies pour des questions de temps et de complexité, mais je conseillerai vivement à tout ceux qui débutent de commencer par des programmes qui n'utilisent pas tensorflow, je me suis arraché les cheveux en tant que neophyte qui apprend sans prof, mais très c'est très instructif, et c'est pas des choses qu'on apprend dans les livres (là j'utilise le livre "Deep Learning avec Keras et TensorFlow" et a aucun moment le lecteur ne passe par une création manuelle, ce qui selon moi, manque cruellement au début du livre lorsque l'on veut comprendre réellement)