Recherche de l'émergence du choix (free will)

Recherche de l'émergence du choix (free will) - Ada - Programmation

Marsh Posté le 05-06-2011 à 01:45:51    

Bonjour, je suis à la recherche de l'émergence du choix, ou de la volonté propre si elle existe...
J'ai écrit un bout de code pour approcher mes idées des contraintes de la programmation sur laquelle je dois réfléchir.
Ce programme exploite un réseau de 5 neurones (2 d'entrées, 2 cachés, 1 de sortie) pour implémenter la fonction xnor.
Je donne ainsi une constante et une variable pouvant prendre les valeurs 0.0 ou 1.0 en entrée du réseau et j'obtiens alternativement comme résultat 0.0 et 1.0.
 
Voici le programme (dépend de la bibliothèque PragmARC.Rem_NN_Wrapper)
Main :

Code :
  1. -----------------------------------
  2. --                               --
  3. --             Sens              --
  4. --                               --
  5. -----------------------------------
  6. with Text_Io;                       use Text_Io;
  7. with Neurologic;                    use Neurologic;
  8. with PragmARC.REM_NN_Wrapper;       use PragmARC.REM_NN_Wrapper;
  9. procedure Sens is
  10.        
  11.   Intel : Binary_Net;            
  12.   Verax : Real := 0.0;
  13. begin
  14.  
  15.   loop      
  16.      Free(Verax, Intel);                
  17.      delay 1.0;
  18.   end loop;
  19. end Sens;


 
Neurologic spec :

Code :
  1. with Ada.Finalization;              use Ada.Finalization;
  2. with PragmARC.REM_NN_Wrapper;       use PragmARC.REM_NN_Wrapper;
  3.  
  4. package Neurologic is
  5.  
  6.   type Binary_Net is new Limited_Controlled with private;
  7.   procedure free(Value : in out Real; Net : in out Binary_Net);
  8.        
  9. private  
  10.   type Value_Type is
  11.      record
  12.      Value : Node_Set(1..1) := (1 => 0.0);    
  13.      end record;
  14.  
  15.   type Binary_Node;
  16.  
  17.   type Node_Access is access all Binary_Node;
  18.  
  19.   type Binary_Node is new Controlled with
  20.      record
  21.      Name  : Natural := 0;
  22.      node : Value_Type;    
  23.      Left  : Node_Access;
  24.      Right : Node_Access;
  25.      end record;
  26.   procedure Initialize(Node : in out Binary_Node);
  27.    
  28.   type Binary_Net is new Limited_Controlled with
  29.      record
  30.      Root  : Node_Access;
  31.      Count : Natural := 0;
  32.      end record;      
  33.   procedure Initialize(Net : in out Binary_Net);
  34. end Neurologic;


 
Neurologic body :

Code :
  1. with Text_Io;                      use Text_Io;
  2. with PragmARC.Math.Functions;
  3.  
  4. package body Neurologic is
  5.  
  6.  
  7.  
  8.   procedure Initialize(Node : in out Binary_Node) is
  9.   begin
  10.      Put_Line("initialize node" );
  11.      Put_line("initialize node done." );
  12.   end Initialize;
  13.  
  14.  
  15.   package Real_Math is new PragmARC.Math.Functions (Supplied_Real => Real);
  16.   package Real_Io is new Text_Io.Float_Io(Real);
  17.  
  18.  
  19.   procedure Initialize(Net : in out Binary_Net) is
  20.      
  21.      Init_Node : array (1..4) of Node_Set(1..2) :=
  22.     (1 => (1 => 0.0, 2 => 0.0),
  23.      2 => (1 => 0.0, 2 => 1.0),
  24.      3 => (1 => 1.0, 2 => 0.0),
  25.      4 => (1 => 1.0, 2 => 1.0));
  26.     
  27.      output : array (1..4) of Node_Set(1..1) :=
  28.     (1 => (1 => 1.0),
  29.      2 => (1 => 0.0),
  30.      3 => (1 => 0.0),
  31.      4 => (1 => 1.0));
  32.      
  33.      procedure Get_Input(Pattern : in Positive;
  34.               Input   : out Node_Set;
  35.               Desired : out Node_Set) is
  36.      begin
  37.      Input := Init_Node(Pattern);
  38.      Desired := Output(Pattern);
  39.      end Get_Input;
  40.      
  41.      package Binary_NN is new REM_NN(Num_Input_Nodes => 2,
  42.                       Num_Hidden_Nodes => 2,
  43.                       Num_Output_Nodes => 1,
  44.                       Num_Patterns => 4,
  45.                       New_Random_Weights => True,
  46.                       Input_To_Output_Connections => False,
  47.                       Weight_File_Name => "node 1.wgt",
  48.                       Get_Input => Get_Input);
  49.      
  50.      
  51.      Desired : Node_Set(1..1) := (1 => 0.0);
  52.      RMS_Error : Real := 1.0;
  53.      Error     : Real := 0.0;
  54.      Converged  : constant real := 0.3;
  55.      Current_Epoch : Long_integer := 0;
  56.      Response : Node_Set(1..1);
  57.      
  58.      
  59.   begin
  60.      Put_Line("initialize net" );
  61.      Net.Root := new Binary_Node;
  62.      Net.Count := 1;
  63.      loop
  64.      for Pattern in 1..4 Loop
  65.         Binary_NN.Train;
  66.         Binary_NN.Respond (Pattern, Response);
  67.         Desired := output(Pattern);                  
  68.         Error :=
  69.           Error + (Desired(1) - Response(1));        
  70.         RMS_Error := RMS_Error + (Error ** 2);
  71.         Error := 0.0;
  72.      end loop;
  73.      Binary_NN.Save_Weights;
  74.      RMS_Error :=
  75.        Real_Math.Sqrt(RMS_Error / Real (4)) ;
  76.      Current_Epoch := Current_Epoch + 1;
  77.     
  78.      if (Current_Epoch > 10 and RMS_Error <= Converged) then
  79.         exit;
  80.      else
  81.         Real_Io.Put(Rms_Error);
  82.         New_Line;
  83.      end if;
  84.      end loop;      
  85.         
  86.      Put_Line("initialize net done." );
  87.   end Initialize;            
  88.  
  89.   procedure Free(Value : in out Real; Net : in out Binary_Net) is
  90.      
  91.      
  92.      
  93.      
  94.      Next : Node_Access := Net.Root;
  95.      
  96.      
  97.      procedure Get_Input(Pattern : in Positive;
  98.               Input   : out Node_Set;
  99.               Desired : out Node_Set) is
  100.      begin
  101.      Input := (Next.Node.Value(1), Value);
  102.      Desired := (1 => 0.0);
  103.      end Get_Input;
  104.     
  105.      
  106.      package Binary_NN is new REM_NN(Num_Input_Nodes => 2,
  107.                       Num_Hidden_Nodes => 2,
  108.                       Num_Output_Nodes => 1,
  109.                       Num_Patterns => 1,
  110.                       New_Random_Weights => False,
  111.                       Input_To_Output_Connections => False,
  112.                       Weight_File_Name => "node 1.wgt",
  113.                       Get_Input => Get_Input);
  114.      Response : Node_Set(1..1);
  115.   begin
  116.      
  117.      Binary_NN.Respond(1, Response);
  118.      Value := Response(1);  
  119.      if Value > 0.5 then
  120.      Value := 1.0;
  121.      else
  122.      Value := 0.0;
  123.      end if;  
  124.      Put_Line(Real'Image(Value));
  125.   end Free;
  126. end Neurologic;


 
 
Mon approche pour la suite est la suivante :
la conscience est, simplement, un ensemble de relation de faits avec des fait-actions.
Pour entreprendre une action il faut avant un fait.
La première action sera une variation du fait initial.
 
fait 1     : 1 (un fait vrai)
action 1 : 0 (un fait faux) + 1 (une action vrai)   ou 1 (un fait vrai) + 0 (une action fausse, un echec).
Ainsi, la véracité du fait 1 est dépendante de la véracité du fait-action suivant.
 
Reste à établir la suite.
 

Reply

Marsh Posté le 05-06-2011 à 01:45:51   

Reply

Marsh Posté le 05-06-2011 à 11:35:57    

La suite,
J'ai enrichie mon programme de 2 procédures :

  • Add : qui permet d'ajouter une feuille dans un arbre binaire (un peu particulier puisque les valeurs sont soit 0.0 soit 1.0)
  • Unfree : une procédure récursive qui modifie l'arbre en fonction de la valeur ajouté.


J'ai modifier le procedure free ainsi :

Code :
  1. procedure Free(Value : in out Real; Net : in out Binary_Net) is
  2.      
  3.      Next : Node_Access := Net.Root;
  4.      
  5.      procedure Get_Input(Pattern : in Positive;
  6.               Input   : out Node_Set;
  7.               Desired : out Node_Set) is
  8.      begin
  9.      Input := (Next.Node.Value(1), Value);
  10.      Desired := (1 => 0.0);
  11.      end Get_Input;
  12.     
  13.      
  14.      package Binary_NN is new REM_NN(Num_Input_Nodes => 2,
  15.                       Num_Hidden_Nodes => 2,
  16.                       Num_Output_Nodes => 1,
  17.                       Num_Patterns => 1,
  18.                       New_Random_Weights => False,
  19.                       Input_To_Output_Connections => False,
  20.                       Weight_File_Name => "node 1.wgt",
  21.                       Get_Input => Get_Input);
  22.      Response : Node_Set(1..1);
  23.   begin
  24.      
  25.      Binary_NN.Respond(1, Response);
  26.      Value := Response(1);  
  27.      if Value > 0.5 then
  28.      Value := 1.0;
  29.      else
  30.      Value := 0.0;
  31.      end if;  
  32.      
  33.      Add(Next, Value, Net.Count);
  34.      Put("Adding " );
  35.      Real_Io.Put(Value, 1, 1);
  36.      Net.Count := Net.Count + 1;
  37.      New_Line;
  38.      Unfree(next, Value);
  39.   end Free;


La procédure Add  

Code :
  1. procedure Add(Root : in Node_Access;
  2.          Value : in out Real;
  3.          Count : in positive) is
  4.      
  5.      Next : Node_Access := Root;
  6.      
  7.      procedure Get_Input(Pattern : in Positive;
  8.               Input   : out Node_Set;
  9.               Desired : out Node_Set) is
  10.      begin
  11.      Input := (Next.Node.Value(1), Value);
  12.      Desired := (1 => 0.0);
  13.      end Get_Input;
  14.      
  15.      package Binary_NN is new REM_NN(Num_Input_Nodes => 2,
  16.                       Num_Hidden_Nodes => 2,
  17.                       Num_Output_Nodes => 1,
  18.                       Num_Patterns => 1,
  19.                       New_Random_Weights => False,
  20.                       Input_To_Output_Connections => False,
  21.                       Weight_File_Name => "node 1.wgt",
  22.                       Get_Input => Get_Input);
  23.      Response : Node_Set(1..1);                        
  24.      New_Node : Node_Access;
  25.   begin
  26.      New_Node:= new Binary_Node;
  27.      loop
  28.      Binary_NN.Respond(1, Response);                
  29.      Value := Response(1);                                   
  30.      if Value > 0.5 then
  31.         Value := 1.0;        
  32.      else        
  33.         Value := 0.0;                  
  34.      end if;                   
  35.     
  36.      if Next.Node.Value(1) = 1.0 then
  37.         if Next.Right /= null then
  38.            Next := Next.Right;
  39.         else
  40.            Next.Right := New_Node;
  41.            exit;
  42.         end if;
  43.      else
  44.         if Next.Left /= null then
  45.            Next := Next.Left;
  46.         else          
  47.            Next.Left := New_Node;          
  48.            exit;
  49.         end if;
  50.      end if;
  51.     
  52.     
  53.      end loop;
  54.      New_Node.Name := Count;
  55.      New_Node.Node := (Value => (others => Value));          
  56.      New_Line;      
  57.   end Add;


La procédure Unfree :

Code :
  1. procedure Unfree(Root : in Node_Access; Value : in out Real) is
  2.      Next : Node_Access := Root;
  3.   begin      
  4.      if Next.Left /= null then
  5.      Put("Left, " );
  6.      Unfree(Next.Left, Value);
  7.      end if;        
  8.      declare
  9.      procedure Get_Input(Pattern : in Positive;
  10.                  Input   : out Node_Set;
  11.                  Desired : out Node_Set) is
  12.      begin
  13.         Input := (Next.Node.Value(1), Value);
  14.         Desired := (1 => 0.0);
  15.      end Get_Input;
  16.     
  17.      package Binary_NN is new REM_NN(Num_Input_Nodes => 2,
  18.                      Num_Hidden_Nodes => 2,
  19.                      Num_Output_Nodes => 1,
  20.                      Num_Patterns => 1,
  21.                      New_Random_Weights => False,
  22.                      Input_To_Output_Connections => False,
  23.                      Weight_File_Name => "node 1.wgt",
  24.                      Get_Input => Get_Input);
  25.      Response : Node_Set(1..1);
  26.     
  27.      begin
  28.  
  29.      Binary_NN.Respond(1, Response);                
  30.      Value := Response(1);                                   
  31.      if Value > 0.5 then
  32.         Value := 1.0;
  33.      else
  34.         Value := 0.0;          
  35.      end if;
  36.      Next.Node.Value(1) := Value;
  37.      end;
  38.      if Next.Right /= null then
  39.      Put("Right, " );
  40.      Unfree(Next.Right, Value);        
  41.      end if;
  42.   end Unfree;


 
Résultat :  

Adding 0.0E+00
Left,
Adding 0.0E+00
Left, Right,
Adding 1.0E+00
Left, Left, Right,
Adding 1.0E+00
Left, Left, Right, Right,
Adding 1.0E+00
Left, Left, Right, Right, Right,
Adding 1.0E+00
Left, Left, Right, Right, Right, Right,
Adding 1.0E+00
Left, Left, Right, Right, Right, Right, Right,
Adding 1.0E+00
Left, Left, Right, Right, Right, Right, Right, Left,
Adding 1.0E+00
Left, Left, Right, Right, Right, Right, Right, Left, Right,
Adding 0.0E+00
Left, Left, Right, Right, Right, Right, Right, Right, Left, Right,
Adding 1.0E+00
Left, Left, Left, Right, Right, Right, Right, Right, Right, Left, Right,


Reply

Marsh Posté le 09-06-2011 à 22:01:10    

Bonjour, j'ai écrit un petit programme graphique pour mettre en valeur les propriétés de mon arbre logique, mais c'est pas sûr.
Tout d'abord, voici un screen shot avec un arbre ayant subit 32 itérations automatiques :
http://hfr-rehost.net/thumb/self/pic/9444ef1b8db56675b3c13b5f13d5b3ce3894780f.jpeg
Voici la sortie de la console :


Start loop
Iter : done.
10
Iter : done.
100
Iter : done.
0101
Iter : done.
10100
Iter : done.
101010
Iter : done.
1001110
Iter : done.
01010001
Iter : done.
010010000
Iter : done.
0001010011
Iter : done.
10010101111
Iter : done.
011100101111
Iter : done.
1011101010000
Iter : done.
10111001100111
Iter : done.
110111010011111
Iter : done.
1101110010000000
Iter : done.
10010001010111001
Iter : done.
100011000101111000
Iter : done.
1001001000111111001
Iter : done.
01110001101000000111
Iter : done.
011100111001001111111
Iter : done.
1000110111010111111111
Iter : done.
01101101110010111111111
Iter : done.
101101101110101000000000
Iter : done.
0100100100011001100011101
Iter : done.
00111000100001011000000011
Iter : done.
010001101001000100111000000
Iter : done.
1100100101110111001000111101
Iter : done.
11000111000001111000111111100
Iter : done.
001101000100011111001000000010
Iter : done.
1011001101000100000111000111110
Iter : done.
01001011010000101101110001000001
Iter : done.
110010100101110100010001111000011
Loop stopped.


 
Chaque ligne de 0 et 1 constitu l'ensemble des valeurs des divers noeuds durant les 32 itération consistant en un ajout de résultat de fonction xnor implémenté par réseau de neurones.
Le screen shot répresente la dernière ligne de la sortie console.
Sources : xsens_0.1.1.tar.gz pour Gnu/Linux
 
Ps : Ce programme est destiné à servir dans la chaîne de production de logiciel intelligent.
En effet, la valeur de la racine pourrait réprésenter un choix avant rétro-propagation de ce choix, entre autre (NR je pense à la suite).


Message édité par Profil supprimé le 09-06-2011 à 22:11:53
Reply

Marsh Posté le 09-06-2011 à 22:32:22    

Hey !
 
Juste pour noter que ça peut même débiter du texte....
 

jouissifs  pauvreté dévoilait   sages   séculairement  rattrapons  précédents  profilèrent  probloc englobe     épongeant inflationniste   sillage  raffermir essaiera cocker banquises anti-médicaments   ricanes   survivras   tapisseries grinçante   sensibleries fumigateur contacterez   régissent  pêcha   suintantes goinfré  orientèrent   sphinge    ébahies imputèrent    varier hébétait    vantards   texanes   taulardes grondaient coudriers  mimes décrites canule attardent   rizières   surélève   tapissées grinçât    vainquirent  reficelle  présenterons entassées clampin balayons ans     élasticité      inébranlable diluvienne  monstrueuse défilera carabosse attendues ameublement   reçoive    vétuste    écopait  remerciée fabriqué communiantes   réel  pétri envieraient   sapajous     instantané  participant   stabat mater giclaient convenue blottis apprivoisent aide-pharmacien           jouai  pause déviée   sagement  quipu escalators cléricalisme  matrimoniales  phobies embellissant  najas  placées     éventrerait  rentre-dedans fantasques    uniformisait hurlerez         resterez       ixe   skieur       jachère disciplinées bulbe   rugis flatulence condor  messagerie décommandait cancérologie atropine  liquéfiait  percevez  portage   sua glaçait convoqueraient   régurgitant  pûmes envisages clopinant banalisées anti-desperado affublés labbe distordant  morcelait déformes  muselle   souque  rallumèrent   superstitieux  raréfia ex-fils coincent barbarisme anti-temps agacements laborantins      intriguée diffamant bruissent artisanat  ligot dormirai cabinet   ruminent  péplums   suicidants  rapportée  précipitera   succombais   tangent    écarquillées inaltérée cyphoscoliose   répondez fortifiants     équations  renforcez  psychasthéniques entr'actes  noierai démêlant  méconnu  pitancier  pouacre  pressera enfourchant  neuronales   sous-préfet          égayait  rempaillaient factor communiquera bataillait antipersonnelles     électorale indiennes dallée    trublion  reculottée explicables  nursing   soutien  ramenait estomacs coffrée   récurage  pétillent enviable clodo  matraquaient décidèrent   réussisses fournaise  officière  plomb  pourras enfarine  nettoyants   sous-programme    ânonnement    écorcheront inclinomètre célébrât         jeunots disloquât


 
Alors, j'ai pas tout lu encore, c'est pas forcement idot, ça dépend [:dpenche]

Reply

Marsh Posté le 10-06-2011 à 02:25:25    

Plop !
Voici les sources pour Gnu/Linux, à moins d'installer Cygwin je crois, dépend de GtkAda est écrit avec Ada.
L'interface est simple...
pour compiler lancer la commande dans le Makefile, ou appeller "make" sans argument.
Cette version affiche la valeur des noeuds...
Source Xsens_0.1.2.tar.gz pour Gnul/Linux
Screen shot  
http://www.toofiles.com/fr/t/images/7278_xsens_012.jpg
 
La structure de l'arbre est modifier du coup de quelque corrections.


Message édité par Profil supprimé le 10-06-2011 à 04:39:21
Reply

Marsh Posté le 10-06-2011 à 02:45:16    

Arf, désolé, il manque encore la valeur de la racine, c'est important la racine.
Je corrige et j'éditerai.
 
Source pour la racine : Xsens_0.1.3.tar.gz


Message édité par Profil supprimé le 10-06-2011 à 03:28:27
Reply

Marsh Posté le 10-06-2011 à 04:57:02    

Zéroième.
 
Deux fois.  [:dawa]
 
Gourage de topic.


Message édité par Profil supprimé le 10-06-2011 à 05:00:53
Reply

Marsh Posté le 20-06-2011 à 13:34:25    

pas de reponse

Reply

Marsh Posté le 20-06-2011 à 13:34:47    

Reply

Marsh Posté le 22-06-2011 à 23:21:37    


 
J'ai jeté un oeil à au document que tu m'as envoyé, vite fait.
Il faudra que je prenne la patience de lire au moins le plus gros.
Je travaille actuellement sur un projet musical prévu pour le 1 juillet.
A l'issu du week end je serais dispo.
Mais on peut discuter, des tenant et des aboutissant peut-être entre temps.
?


Message édité par Profil supprimé le 22-06-2011 à 23:25:48
Reply

Marsh Posté le 22-06-2011 à 23:21:37   

Reply

Marsh Posté le 23-06-2011 à 15:54:38    

très bien, voilà qui me semble déjà une réponse sur le bon chemin.....qui sait??

Reply

Marsh Posté le 23-06-2011 à 15:58:30    

Ce projet qui a été réalisé est un puissant analyseur de syntaxe.Ainsi la structure du langage en lui même peut apporter des réponses structurées.

Reply

Marsh Posté le 23-06-2011 à 15:59:06    

mais il y a beaucoup mieux à faire!!

Reply

Marsh Posté le 23-06-2011 à 16:02:40    

pierrecadounou a écrit :

mais il y a beaucoup mieux à faire!!


 
Expose !

Reply

Marsh Posté le 05-07-2011 à 14:42:36    

il s'agit de programmer les mots en langage ....disons que je ne souhaite pas plus m'exprimer ici sur ce site .je ne sais pas du tout qui vous êtes.il s'agirait plutôt que de dévoiler mon concept et mes travaux  de se parler plus sérieusement.je pense que l'on peut programmer les mots afin que l'ordi puisse parfaitement comprendre ce que l'on écrit.j'ai les solutions!!

Reply

Marsh Posté le 06-07-2011 à 00:01:26    

La solution à quel problème alors ?

Reply

Marsh Posté le 06-07-2011 à 00:43:35    


 
La compréhension du langage naturel.
 

Reply

Marsh Posté le 06-07-2011 à 01:16:29    

pierrecadounou a écrit :

il s'agit de programmer les mots en langage


Dans le sens, j'avais penser à écrire une ou plusieurs fonction pour les verbes qui traiteraient des données/objets associés aux noms.

Reply

Marsh Posté le 06-07-2011 à 09:27:28    

oui, nous pouvons créer un petit programme mais très puissant qui comprend le sens des mots et va progressivement apprendre.on créer ensuite lorsque cela fonctionne pas trop mal ,un petit programme sur par exemple les i phone type tamagoshi évolutif pour dialoguer.on realiserait une nouvelle classe de jeux.

Reply

Marsh Posté le 06-07-2011 à 09:29:10    

il s'agit bien de compréhension du langage naturel

Reply

Marsh Posté le 06-07-2011 à 09:32:23    

je possède tous les outils linguistiques que j'ai mis au point pour réaliser ce programme mais je ne suis pas encore assez fort en programmation et je gagnerais du temps à partage mon savoir avec quelqu'un .on pourrait peut être utiliser une partie du programme de Cman

Reply

Marsh Posté le 07-07-2011 à 21:37:59    

Bonjour pierre.
Déjà, je pense que je n'aurais pas les compétence pour intégrer l'existant de Cman.
Enfin, j'ai pas envie.
Si j'écris quelque chose aujourd'hui ce sera principalement avec Ada, sur tout si c'est un projet sérieux.
Je pense pas que quoi que ce soi de nécessaire soit impossible à faire avec Ada.
Voilà.
Si t'es partant il faut m'explique le concept en mp et je te dis si j'ai les compétence pour le faire de toute pièce.
Si je comprend rien tu perd rien, si non on travaille ensemble.


Message édité par Profil supprimé le 07-07-2011 à 21:38:41
Reply

Marsh Posté le    

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed