Neural net,deep learning,bases en C, part 3
Pour continuer avec les posts précédents, et en gardant la configuration entrées/ expected formula ,
On peut tracer la sortie du reseau, et les états des variables back[ ] pour chaque entrées :
en abcisses, l’angle ‘ang’ , axe Y gauche pour ‘back A,B,C’ , axe Y droit pour ‘neuron’
Si, on modifie la valeur de inA (qui est le bias) de -1.0 , à -2.0 , sans modifier le reseau existant. il répond alors de la façon suivante :
On voit que la réponse a été translatée de +1.0 sur Y , ce qui est cohérent avec la valeur modifiée du bias , de -1.0 a -2.0 (elle est multipliée par approximative -1.0 (poids de l’entrée A )
Mais ce qui est remarquable, c’est la modifcation de la variable back pour A : elle est passée d’une valeur négative a une valeur positive différente.
On va faire effectuer de nouveau une suite de calculs avec le reseau, en gardant les poids calculés par l’apprentissage, et faire varier l’entrée A ( le bias) par des valeurs comprises en -4.0 et +4.0 ( tout en gardant en tete que la valeur originale du bias , pour ce reseau, est de -1.0 )
Ce qui donne :
On voit que back A , décroit jusqu’a un minima, puis croit de nouveau .
Pour être précis, on réduit la variation de l’entrée A entre -1.5 et -0.5 :
Le minima pour back A est situé entre deux passage par 0 de cette variable back[ ].
On change l’axe X pour qu’il représente la variable input A , au lieu des angles pour les cos/sin :
… clairement, BACK pour A passe par zéro en 2 points :
- pour une valeur inputA de -1.0
- pour une valeur inputA de 0.0
n->back[k]=n->neuron*n->part[k]*n->in[k];
…Si in[k] passe par zéro, back[k] est nul, quelle que soit la valeur du reste de sa formule.
Pour cette raison, on va modifier la fonction BACK() de façon à utiliser une partie seulement de la fonction existante :
n->part[k]=(fabs(n->w[k])/n->wtot); // proportion // assume w always positive n->ward[k]=n->error*n->w[k];// erreur * poids n->back[k]=n->error*n->in[k];// erreur * valeur d'entree
Pour ça, on modifie la structure du reseau, et on crée une nouvelle fonction backWARD :
// la structure typedef struct { uint32_t synapses; float* in; // forward compute inputs float* back; // backward computed inputs float* ward; float* w; // forward/backward weight for each inputs float* part; float neuron; // forward computed output, backward compute input float error; //float* delta; // //uint32_t genre; // float wtot; // total input weights // uint64_t epoch; uint64_t internal; } reso;
nouvelle fonction backward:
void RESO_backWARD(reso* n,float expected) { uint32_t k; n->error=n->neuron-expected; // actual_value - expected_value // for(k=0;k<n->synapses;k++) { n->part[k]=(fabs(n->w[k])/n->wtot); // proportion // assume w always positive n->ward[k]=n->error*n->w[k];// erreur * poids n->back[k]=n->error*n->in[k];// erreur * valeur d'entree } n->epoch++; }
Pour terminer, un autre graphe d’un réseau pour lequel la valeur de BIAS était fixée à -2.5.
- On la fait varier de -10.0 a 0.0, en fixant les 2 autres entrées à un état déterminé et connu
Sur le graphe, on peut voir back , ward et error (en abcisse, la valeur d’entrée du bias (nominal -2.5), les valeurs de ward sont sur l’axe Y de droite, celles de back et error sur l’axe Y de gauche
Dans le cas ou les valeurs des 2 autres entrées provoquent une sortie attendue à +1.0 :
Puis dans le cas ou les valeurs des 2 autres entrées provoquent une sortie attendue à -1.0 :