Discussion :

[Bilala92]

Bonsoir,
Voilà maintenant plusieurs heures que je bloque sur un problème de classification en python utilisant les réseaux de neurones (forward propagation et backward propagation).
En effet, je ne comprend pas pourquoi mon erreur ne converge pas et quand elle converge, c'est vers tout sauf 0 (24 par exemple).
Pour ce qui est du problème, j'ai un data set de 3 colonnes, X1, X2 et Y. X1 est l'abscisse du point, X2 l'ordonnée et Y la "couleur" représentée par 0,1 ou 2.
Le but est donc d'obtenir une matrice Y_chapeau la plus proche de Y.

Je met le dataset en pièce jointe au cas oùdata_ffnn_3classes.txt

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
 
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import random
import math
from scipy.linalg import expm, sinm, cosm
 
name_file = './data_ffnn_3classes.txt'
 
columns = ['x1', 'x2', 'y']
 
data_in = pd.read_csv(name_file,
                      names=columns,
                      sep='\t',
                      skiprows=1)
 
 
x1 = np.asarray(data_in['x1'])
x2 = np.asarray(data_in['x2'])
y = np.asarray(data_in['y'])
 
plt.figure(1)
colors = ['red','green','blue']
plt.scatter(x1, x2, c=y, cmap=matplotlib.colors.ListedColormap(colors))
 
 
 
def sigmoid(matrice):
    result = (1 + np.exp(np.negative(matrice)))
    return result
 
 
def SSE(gg, yy):
    erreur = 0
    erreur = (1/2) * sum([((gg[i][j]-yy[i])**2) for i in range(gg.shape[0]) for j in range(gg.shape[1])])
    return erreur
 
 
K = 2
 
 
v = np.random.uniform(low=0, high=1, size=(3,K))
w = np.random.uniform(low=0, high=1, size=((K+1),1))
 
x = np.c_[x1,x2]
x_barre = np.c_[np.ones(x.shape[0]), x]
x_barre_barre = np.dot(x_barre,v)
 
f = np.reciprocal(sigmoid(x_barre_barre))
f_barre = np.c_[np.ones(f.shape[0]), f]
f_barre_barre =  np.dot(f_barre,w)
 
 
g = np.reciprocal(sigmoid(f_barre_barre))
erreur_SSE = SSE(g,y)
 
print("SSE error : " + str(erreur_SSE))
 
 
 
def BGD(X, gg, yy, fbarre, v, w, f, Xbarre):
    #On initilise theta
 
    iterations = 6500
    optiv = v
    optiw = w
    ve = v
    we = w
    ve2 = v
    we2 = w
    erreurs = list()
    learning_ratev = 0.00742
    learning_ratew = 0.00742
    g = yy
    f_barre = fbarre
    ff = f
    x_barre = Xbarre
    abscisses = [i for i in range (iterations)]
 
 
 
    for i in range(0, iterations):
        #print(gg.shape)
 
        x_barre_barre = np.dot(x_barre,ve)
        ff = np.reciprocal(sigmoid(x_barre_barre))
        f_barre = np.c_[np.ones(ff.shape[0]), ff]
        f_barre_barre =  np.dot(f_barre,we)
 
        g = np.reciprocal(sigmoid(f_barre_barre))
 
        d_Ew = sum([((g[l]-yy[l])* g[l]*(1-gg[l])* f_barre[l]) for l in range(0,g.shape[0]) ])  
 
        d_Ev = sum([(((g[l]-yy[l])*g[l]*(1-gg[l])*we[k]*ff[l]*(1-ff[l])*x_barre[l][k])) for l in range(0,g.shape[0]) for k in range (0,2)])
 
 
 
        for o in range (1,we.shape[1]):
            we = we2- (learning_rate * d_Ew)
 
        ve =   ve2- (learning_ratew)* d_Ev
 
 
 
        ve2=ve
        we2=we
 
        erreur = SSE( g,yy)
        erreurs.append(erreur)
 
        toutG = g
        optiv = ve
        optiw = we
        if i%500==0:
            print("Itération [" + str(i)+ "] : Erreur = " + str(erreur))
 
    plt.figure(20)
    plt.plot(abscisses, erreurs, label = "Evolution de l'erreur")
    plt.xlabel('Iteration')
    plt.ylabel('Error')
    plt.legend()
    return toutG, optiv, optiw
 
 
 
 
gai, optiv, optiw = BGD(x, g, y, f_barre,v, w, f, x_barre)
colors = ['red','green','blue']
plt.figure(2)
plt.scatter(x1, x2, c=gai, cmap=matplotlib.colors.ListedColormap(colors))

Merci d'avance pour vos pistes

[robinechuca]

Bonsoir,

Je ne peux que vous encourager et vous feliciter d'avoir cherche et fait un effort avant de poser votre question mais je dois avouer que j'ai du mal a comprendre certains points de votre code. Je pense ne pas etre le seul au vu du nombre de reponses par rapport au nombre de vues.

Il y a plusieurs choses que je ne comprends pas bien et que vous pourriez eclaircir:

• Vous parlez de reseau de neurones, mais c'est qui les parametres entrainables ? v et w ?
• Je ne comprends pas ou se trouve le model? Il devrai y avoir une fonction qui prend en entree les parametres entrainables, la liste des coordonnees de chaque points et qui devrai retourner la classe (la couleur) associee a chaque point.
• Deja avec ca bien pose on y verrai tous plus clair!

Pour la suite on pourra vous aider mais la c'est un peu confus!