EihiS

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 :