Tipe!

(*Reseaux de neurones tricouches*)

include "P:\Tipe\fonctions usuelles";;

type neurone ={mutable poids : float; mutable tab_entres : int list; mutable seuil : float};;
type couche={mutable tab_neurones : neurone list ; mutable tab_results : float list};;
type cerveau={mutable tab_couches : couche vect;mutable tab_coeffs : float vect};;
type robotgroup={mutable tab_cerveau : cerveau vect};;
random__init ( int_of_float (1000.*.sys__time()) );;
(*random__init 10;;*)

let compteur = ref 0;;
let nbre_parametres = ref 3;;
let nbre_sorties= ref 2;;
let nbr_robots= 10;;
let tab_robot={tab_cerveau = [| |] };;
let tab_succes= make_vect nbr_robots 0;;

include "P:\Tipe\Annexe";;
for i=0 to (nbr_robots -1) do
tab_robot.tab_cerveau<- concat tab_robot.tab_cerveau [|{tab_couches=[| {tab_neurones=[] ; tab_results=[]} ;{tab_neurones=[] ; tab_results=[]} ;{tab_neurones=[] ; tab_results=[]} |] ; tab_coeffs = [||] }|]
done;;

(*affiche un cerveau -1=pas de neurone*)

let affiche_cerveau brain =
let t=make_matrix (vect_length brain.tab_couches) (list_length brain.tab_couches.(0).tab_neurones) (-1.) in
for i=0 to ((vect_length brain.tab_couches)-1) do
for j=0 to (list_length brain.tab_couches.(i).tab_neurones - 1) do
t.(i).(j)<-(get (brain.tab_couches.(i).tab_neurones) j).poids
done;
done;
t;;



(*remplit et relie les couches aleatoirement*)

let init_couches couch numero =
let taille= ref 0 and nbre_entres=ref 0 in
(if (numero =0||numero=1)
then taille := ! nbre_parametres -1
else taille := ! nbre_sorties - 1;
for i=0 to !taille do
couch.tab_neurones<-({poids=(random__float 10. ) -. 5. ;tab_entres=[];seuil=(random__float 10. -. 5. )}::(couch.tab_neurones));
nbre_entres:= random__int 2 + 1;
for j=0 to ( ! nbre_entres-1) do
if (numero=0||numero=1) then
(get couch.tab_neurones 0).tab_entres<-(random__int ( !nbre_parametres ) )::(get couch.tab_neurones 0).tab_entres
else
(get couch.tab_neurones 0).tab_entres<- (random__int ( !nbre_sorties))::(get couch.tab_neurones 0).tab_entres
done;
done);;


(*creer des cerveaus aleatoires*)
let init_cerveau brain =
for i=0 to 2 do
brain.tab_coeffs <- make_vect ( !nbre_sorties) 0.;
for j=0 to ( !nbre_sorties - 1) do
brain.tab_coeffs.(j)<-(random__float 1000.)
done;
init_couches brain.tab_couches.(i) i
done;;



(*initialisation des robots en fonction de l'environnement*)
let initialisation nbr_parametres nbr_sorties temps_reflexion =
nbre_parametres :=nbr_parametres;
nbre_sorties := nbr_sorties;
for i=0 to (nbr_robots-1) do
init_cerveau tab_robot.tab_cerveau.(i)
done;;



(*fonction de seuillage d'un neurone*)
let seuillage xr seuil =
(1./. (1. +. exp ( -. ( xr +. seuil)))) -. (1./. (1. +. exp ( xr +. seuil))) ;;



(*renvoie la liste des sorties a partir des paramètres d'entré*)
let action2 brain paramt =
let taille= ref 0 in
let result=ref 0. in
for i=0 to 2 do
taille := list_length (brain.tab_couches.(i).tab_neurones);
for j=0 to (!taille -1) do
for k=0 to list_length (get brain.tab_couches.(i).tab_neurones j).tab_entres -1 do
if i=0 then
result := !result +. (get (brain.tab_couches.(i)).tab_neurones j).poids*. (float_of_int paramt.(get (get brain.tab_couches.(i).tab_neurones j ).tab_entres k))
else(result:= !result +. (get (brain.tab_couches.(i)).tab_neurones j).poids*. (get (brain.tab_couches.(i-1)).tab_results (get (get brain.tab_couches.(i).tab_neurones j ).tab_entres k)));
done;
brain.tab_couches.(i).tab_results<-(brain.tab_couches.(i).tab_results)@[( seuillage ( !result) (get (brain.tab_couches.(i)).tab_neurones j).seuil )];
result:= 0.
done;
done;
vect_of_list brain.tab_couches.(2).tab_results;;




(*renvoie la liste des sorties de tout les robots à partir des paramètres d'entré*)
let action tabparam =
let sortie =make_matrix nbr_robots (! nbre_sorties) 0 in
for i=0 to (nbr_robots -1) do
for j=0 to ( ! nbre_sorties -1) do
sortie.(i).(j)<- int_of_float ((tab_robot.tab_cerveau.(i).tab_coeffs.(j))*. (action2 tab_robot.tab_cerveau.(i) tabparam.(i)).(j));
done;
done;
for i=0 to (nbr_robots -1) do
for j=0 to 2do
tab_robot.tab_cerveau.(i).tab_couches.(j).tab_results<-[]
done;
done;
sortie;;




let mutation brain =
let n=random__int 3 and c=random__int 2 in
let s=random__int (list_length brain.tab_couches.(c).tab_neurones) in
let tailletabcoeffs= random__int (vect_length brain.tab_coeffs) in
match n with
|1->(get brain.tab_couches.(c).tab_neurones s).poids<-(get brain.tab_couches.(c).tab_neurones s).poids +. (random__float 2. -. 1.)
|2->(get brain.tab_couches.(c).tab_neurones s).seuil<- (get brain.tab_couches.(c).tab_neurones s).seuil +.(random__float 2. -. 1.)
|_->brain.tab_coeffs.(tailletabcoeffs)<-brain.tab_coeffs.(tailletabcoeffs) +. random__float 100. -.50. ;;




let addition nbr=
let a=ref 0 and b= ref 0 and points =make_vect nbr_robots 0 in
(for i=3 to (nbr-1) do
a:=random__int 50;
b:=random__int 50;
for j=0 to (nbr_robots-1) do
let t =make_vect nbr_robots [|!a ;!b|] in
(
if (action (t)).(j) = [|( !a + !b)|] then points.(j)<-(points.(j)+1))
done;
done;
points);;








let nouveau_tour tabsucc =
compteur:= !compteur +1;
for i=0 to (nbr_robots-1) do
tab_succes.(i)<-(tab_succes.(i)+tabsucc.(i))
done;
if !compteur = 2 then
(let t = low_abs (tab_succes) nbr_robots in
for i=2 to (nbr_robots-1) do
let a= copy_cerveau (tab_robot.tab_cerveau).(t.((i) mod 2)) in
tab_robot.tab_cerveau.(t.(i))<- a;
mutation tab_robot.tab_cerveau.(t.(i))
done;
compteur:=0;
for i=0 to (nbr_robots-1) do
tab_succes.(i)<-0
done);
(make_vect nbr_robots true);;




(*
initialisation 2 1 20;;
affiche_cerveau tab_robot.tab_cerveau.(1);;
affiche_cerveau tab_robot.tab_cerveau.(2);;
affiche_cerveau tab_robot.tab_cerveau.(3);;
affiche_cerveau tab_robot.tab_cerveau.(4);;
affiche_cerveau tab_robot.tab_cerveau.(5);;
affiche_cerveau tab_robot.tab_cerveau.(6);;


let test nbre=
for k=0 to (nbre-1) do
let t = low_abs (addition 1000) nbr_robots in
(for i=2 to (nbr_robots-1) do
let a= copy_cerveau (tab_robot.tab_cerveau).(t.((i) mod 2)) in
tab_robot.tab_cerveau.(t.(i))<- a;
mutation tab_robot.tab_cerveau.(t.(i))
done);
done;
addition 1000;;

test 2;;
test 2;;
test 2;;
test 2;;
test 2;;
test 2;;
test 2;;
test 2;;
test 2;;
test 2;;
test 2;;
test 2;;


affiche_cerveau tab_robot.tab_cerveau.(1);;
affiche_cerveau tab_robot.tab_cerveau.(2);;
affiche_cerveau tab_robot.tab_cerveau.(3);;
affiche_cerveau tab_robot.tab_cerveau.(4);;

tab_robot.tab_cerveau.(1).tab_coeffs;;
tab_robot.tab_cerveau.(2).tab_coeffs;;
tab_robot.tab_cerveau.(3).tab_coeffs;;
tab_robot.tab_cerveau.(4).tab_coeffs;;
tab_robot.tab_cerveau.(5).tab_coeffs;;
tab_robot.tab_cerveau.(6).tab_coeffs;;*)

(*Annexe*)


let concat t1 t2 =
let n1 =vect_length t1 and n2=vect_length t2 in
let res=make_vect (n1+n2) t2.(0) in
for i=0 to (n1-1) do
res.(i)<-t1.(i)
done;
for j= n1 to (n1+n2-1) do
res.(j)<-t2.(j-n1)
done;
res;;


let pluspetite_abs t=
let min=ref 0 in
for i=1 to (vect_length t)-1 do
if t.(i)<t.( !min) then min:= i
done;
! min;;

let max t=
let max=ref t.(0) in
for i=1 to (vect_length t)-1 do
if t.(i)>(! max) then max:=t.(i)
done;
! max;;


let low_abs tab n=
let t=copy_vect tab in
let l=ref [] in
let maxi=(max t)+1 in
for i=1 to n do
l:=(pluspetite_abs t): !l);
t.(hd( !l))<-maxi;
done;
let longliste=(list_length (! l))in
let rep=make_vect longliste 0 in
for i=0 to longliste -1 do
rep.(i)<-hd( !l);
l:=tl (!l);
done;
rep;;



let copy_tab tab =
let n= vect_length tab in
let tab2 =ref [||] in
for i=0 to (n-1) do
tab2:= concat (!tab2) [| (tab.(i))|]
done;
!tab2;;



let copy_neurone neur=
{poids=neur.poids;tab_entres=list_of_vect (copy_tab (vect_of_list neur.tab_entres));seuil= neur.seuil};;

let copy_tabneurone tab =
let n= vect_length tab in
let tab2 =ref [||] in
for i=0 to (n-1) do
tab2:= concat (!tab2) [|copy_neurone (tab.(i))|]
done;
!tab2;;


let copy_couche couch=
{tab_neurones= list_of_vect (copy_tabneurone (vect_of_list couch.tab_neurones)) ; tab_results=[]};;

let copy_tabcouch tab =
let n= vect_length tab in
let tab2 =ref [||] in
for i=0 to (n-1) do
tab2:= concat (!tab2) [|copy_couche (tab.(i))|]
done;
!tab2;;

let copy_cerveau brain=
{tab_couches=copy_tabcouch brain.tab_couches;tab_coeffs= copy_tab brain.tab_coeffs};;