Archives Mensuelles: novembre 2011

J’ai continue a reflechir au processus de remise en cause des valeurs dans un cognit.

Tout d’abord, j’ai change les criteres de reproduction. Maintenant un mebius mort engendre un nouveau mebius a son image (avec des alterations aleatoires) s’il a reussi a vivre presque (actuellement 80%) aussi longtemps que le champion courant, sinon c’est le champion qui se reproduit. Ca ameliore un peu l’evolution de la population.

Mais il y avait toujours cette periode de regression apres l’apparition d’un champion. Apres reflexion j’ai compris que ca venait de la facon dont je fais bouger la cible. A chaque fois qu’un champion apparait, elle se deplace plus rapidement. La contrainte sur les Mebius est donc plus grande, une erreur de trajectoire les entrainant en moyenne plus loin de la cible. Il faut alors attendre qu’ils evoluent pour etre plus performants et caapble de suivre la cible a sa nouvelle vitesse de deplacement. Au passage c’est deja en soit une facon de constater qu’il y a une certaine remise en cause remise en cause des valeurs dans les cognits, puisque de nouveaux champions continuent effectivement a apparaitre.

Cependant, en regardant les videos des cognits je me suis rendu compte que des valeurs ‘correctes’ ont tendance a se perdre. En soit c’est normal, le mebius en lui meme ne sait pas qu’elle est correcte et la remet en cause comme les autres. Mais etant correcte elle devrait reapparaitre tres rapidement et etre remise en cause beaucoup moins souvent d’apres mon modele. La, j’ai trouve que le probleme venait de l’implementation des cognits interfaces. Ils ne disposaient en effet que d’un senseur global de rapprochement a la cible pour alimenter les cognits d’apprentissage. Ainsi, si le mebius s’eloigne globalement de la cible, il va avoir tendance a penser que ses valeurs ne sont pas bonnes et chercher de nouvelles. Mais s’il s’est eloigne car les cognits gerant le deplacement haut/bas ont fait n’importe quoi, pendant que les cognits droite/gauche ont vu juste, ces derniers seront penalises a tort. J’ai donc divise le senseur de rapprochement pour chaque axe dans le mebius interface et reconfigurer les cognits de son mebius. On obtient tout de suite de bien meilleurs resultats :


Distance moyenne a la cible
en bleu mebius interface a senseurs separes,
en rouge mebius interface a senseurs confondus

Plus les mebius ont d’information sur leur environnement et plus elles sont pertinentes, plus ils obtiennent de bons resultats. C’est coherent avec le modele, donc c’est satisfaisant.

Ensuite je me suis penche sur le probleme inverse, les valeurs incorrectes qui ne sont pas remises en cause. La aussi j’ai commence par suspecter un probleme de configuration, au niveau des cognits d’enseignement. J’ai reflechi aux parametres que j’utilisais, et je me suis dit qu’ils engendraient des mebius un peu trop sur d’eux, prompt a decider et rechignant a changer d’idee. J’ai donc changer les parametres pour des mebius un peu plus prudent et ouvert d’esprit, et j’ai refait tourner un petit run.

Distance moyenne a la cible
en bleu parametres « prudent et ouvert »
en rouge parametres « fonceur et tetu »

Le mebius prudent et ouvert stagne au debut, il prend le temps de s’assurer de ses choix diront nous, alors que le mebius fonceur arrive tres rapidement a sur une solution. Mais au bout de 30.000 iterations, ils arrivent tout les deux a des performances similaires. Cependant le mebius ouvert a des valeurs maximales de distance a la cible plus grandes que le mebius fonceur. C’est parce qu’il continue a explorer des possibilites, donc commet des erreurs qui le penalise, alors que le mebius fonceur s’en tient a sa solution optimale. Il va donc etre interressant de comparer les deux sur du long terme. A priori le tetu ne progressera plus, alors que le prudent va finir par trouver une meilleure solution. Je vais arreter la pour aujourd’hui et laisser tourner a nouveau un run d’un million d’iteration pendant que je vais me changer les idees devant un petit cafe ! Si ca a fini de tourner ce soir je referai un autre long run avec le mebius fonceur, et demain soir je devrai pouvoir comparer les resultats.

Publicités

Pendant que j’etais au boulot j’ai laisse tourner des run pour voir l’influence d’un parametre influent sur la confiance.
image
S’il ne semble pas avoir d’influence sur les performances d’apprentissage, il joue par contre beaucoup sur la vitesse de l’algo.
Ayant gagne en temps d’execution j’ai refait un run d’un million d’iterations pour m’inspirer.
image
J’ai remarque que la population de Mebius ne semblait pas beneficier autant que prevu de l’apparition de champions. Je me suis donc interroge sur les criteres de selection que j’utilisais pour la reproduction, et il est vrai que ce n’etait pas forcement tip top. J’ai programme de nouveaux criteres, et je laisse tourner cette nuit pour voir…

Ca y est j’ai debusque l’anerie aussi monumentale que stupide…

Euh je sais meme plus ou j’en etais du coup ! Vite, vite, demain soir et apres demain soir je suis encore occupe a faire la fete. Ca n’avance pas en ce moment ! Pour ce qu’il reste de ce soir, c’est donc 100% Mebius project !

 

 

Arf… C’est moi que je vais jeter par la fenetre ! Le bug est toujours la…

Bon on va faire une grosse pause et s’aerer le cerveau.

 

J’ai envie de jeter ma becane par la fenetre !! J’ai perdu une journee a m’arracher les cheveux sur le bug d’hier. Totalement inexplicable, sur une portion de code qui n’a pas bouge. Et finalement je viens de trouver. Quand je compile avec l’option -O0 ca se met a faire n’importe quoi. J’utilisais cette option d’optimisation suite a l’utilisation de Valgrind. Il y a en effet des problemes de decalage de numero de ligne pendant le debuggage en fonction du niveau d’optimisation. Ca m’a bien permis de nettoyer le code, mais une fois que j’ai arrete d’utiliser Valgrind j’ai laisse l’option dans mon Makefile, d’autant plus que -O0 est le niveau d’optimisation par defaut. Et Boum ! … Bon j’ai pas le temps de chercher si c’est un bug documente du compilateur gcc, mais en tout cas dorenavant je marcherai sur des oeufs quand je tripoterai les options de compilation.

(Edit : erreur de ma part, le bug ne venait pas de l’option de compilation)

Ce soir j’ai avance le nettoyage du code en me concentrant sur l’initialisation des variables. Valgrind me pointait en effet plein de zones memoire non initialisees. Ce soir ca semble resolu. Demain je me pencherai sur un bug dans les cognits d’apprentissage qui ait apparu mysterieusement (ca sent la faute d’etourderie a plein nez).

 

Gueuleton hier et obligation d’avancer sur d’autres travaux ce soir, pas tres productif donc ! Demain et apres demain je devrai avoir un peu plus de temps…

 

Ce soir j’ai continue un petit peu a nettoyer le code.