Newsgroup: it.comp.ia
Titolo: Coach 0.2

Seconda versione di Coach che incorpora le seguenti modifiche:
- il metodo di apprendimento adesso funziona in modo simile a una
pallina lasciata cadere in un punto casuale di una superficie curva;
- il test sulla distribuzione binomiale e' stato corretto per
calcolare la sommatoria di tutte le probabilita' oltre una certa
soglia (anche "probabilita' della coda").
Credo che adesso quel poco che fa Coach lo faccia bene, sono sempre
felice di leggere commenti e/o suggerimenti.
Omega e' omega e basta.
SORGENTE
program Coach;
{$N+,E+}
{$M $4000,0,0}
uses Dos;
const
maxval=50;
ppstr='$coach$';
var
nvalori : integer;
valori : array[0..maxval,0..1] of integer;
nscontri : integer;
robtest : string[12];
robscrew : string[50];
pprow,ppcol,pplen : integer;
procedure Errore(nerr : integer);
begin
case nerr of
  1: writeln('File non trovato');
  2: writeln(ppstr,' non trovato');
  3: writeln('Errore di P-Robots');
  4: writeln('Nessun valore trovato');
end;
halt(1);
end;
function Pot(a : double; b : integer) : double;
var
i : integer;
aus : double;
begin
aus:=1.0;
for i:=1 to abs(b) do aus:=aus*a;
if b<0 then aus:=1.0/aus;
pot:=aus;
end;
function Fatt(n1,n2 : integer) : double;
var
i : integer;
aus : double;
begin
aus:=1.0;
for i:=n1 to n2 do aus:=aus*i;
fatt:=aus;
end;
procedure Leggi;
var
f : text;
i : integer;
begin
pprow:=-1;
if fsearch('coach.dat','.')='' then Errore(1);
assign(f,'coach.dat');
reset(f);
readln(f,nscontri);
readln(f,robtest);
readln(f,robscrew);
nvalori:=0;
for i:=0 to maxval do
  if not eoln(f) then
    begin
      read(f,valori[i,0]);
      nvalori:=i+1;
    end
  else break;
for i:=0 to nvalori-1 do valori[i,1]:=0;
close(f);
if nvalori=0 then Errore(4);
end;
procedure Preprocessore(numero : integer);
var
f1,f2 : text;
line : string[255];
subline : string[10];
i : integer;
begin
i:=1;
str(numero,subline);
if fsearch(robtest,'.')='' then Errore(1);
assign(f1,robtest);
assign(f2,'coach.tmp');
reset(f1);
rewrite(f2);
while not eof(f1) do
  begin
    readln(f1,line);
    if pprow=-1 then
      begin
        ppcol:=pos(ppstr,line);
        if ppcol>0 then pprow:=i;
        pplen:=length(ppstr);
      end;      
    if pprow=i then
line:=copy(line,1,ppcol-1)+subline+copy(line,ppcol+pplen,length(line)-(ppcol+pplen)+1);
    writeln(f2,line);
    inc(i);
  end;
close(f1);
erase(f1);
close(f2);
rename(f2,robtest);
pplen:=length(subline);
if pprow=-1 then Errore(2);
end;
function Vittoria : boolean;
var
f : text;
line : string[80];
begin
assign(f,'results.prb');
reset(f);
readln(f);
readln(f,line);
if pos('Number 1',line)>0 then vittoria:=true
else vittoria:=false;
close(f);
erase(f);
end;
procedure Spettro;
var
f : text;
seekval : integer;
i,magg : integer;
begin
for i:=0 to nscontri-1 do
  begin
    if i mod nvalori=0 then randomize;
    seekval:=random(nvalori);
    if (valori[pred(seekval),1]>valori[succ(seekval),1])
      and (pred(seekval)>=0) then
        while (valori[pred(seekval),1]>valori[seekval,1])
          and (pred(seekval)>=0) do dec(seekval)
    else if (valori[pred(seekval),1]<valori[succ(seekval),1])
      and (succ(seekval)<=nvalori-1) then
        while (valori[succ(seekval),1]>valori[seekval,1])
          and (succ(seekval)<=nvalori-1) do inc(seekval);
    Preprocessore(valori[seekval,0]);
    exec('.\p-robots.exe',robtest+' '+robscrew+' /m-1');
    if doserror>0 then Errore(3);
    if Vittoria then inc(valori[seekval,1],2)
    else if valori[seekval,1]>-10 then dec(valori[seekval,1]);
  end;
assign(f,'coach.dat');
append(f);
writeln(f);
writeln(f,'Punti vittoria');
for i:=0 to nvalori-1 do
  write(f,valori[i,1],' ');
close(f);
magg:=0;
for i:=1 to nvalori-1 do
  if valori[i,1]>valori[magg,1] then magg:=i;
Preprocessore(valori[magg,0]);
end;
procedure Test;
var
f : text;
i,j : integer;
p : double;
begin
for i:=0 to 1 do
  begin
    Preprocessore(valori[i,0]);
    for j:=1 to nscontri div 2 do
    begin
      exec('.\p-robots.exe',robtest+' '+robscrew+' /m-1');
      if doserror>0 then Errore(3);
      if Vittoria then inc(valori[i,1]);    
    end;
  end;
assign(f,'coach.dat');
append(f);
writeln(f);
writeln(f,'Vittorie');
writeln(f,valori[0,1],' ',valori[1,1]);
if valori[1,1]>valori[0,1] then
  begin
    valori[2,0]:=valori[0,0];
    valori[2,1]:=valori[0,1];
    valori[0,0]:=valori[1,0];
    valori[0,1]:=valori[1,1];
    valori[1,0]:=valori[2,0];
    valori[1,1]:=valori[2,1];
  end;
p:=0.0;
j:=valori[0,1]+valori[1,1];
for i:=valori[0,1] to j do
  p:=p+Fatt(i+1,j)/Fatt(1,j-i)*Pot(0.5,j);
writeln(f,'Probabilita'' (ipotesi nulla)=',round(p*100.0),'%');
if p<0.05 then writeln(f,'Il valore ',valori[0,0],' e''
significativamente migliore di ',valori[1,0])
else writeln(f,'I due valori si equivalgono');
close(f);
Preprocessore(valori[0,0]);
end;
begin
Leggi;
if nvalori=2 then Test
else Spettro;
end.

 pallina lasciata cadere in un punto casuale di una superficie curva;
Perdona la mia ignoranza, ad occhio e croce intendi dire che applica la 
regola del delta (quella che aggiorna i pesi utilizzando l'opposto della 
derivata etc etc...)? Faccio questa domanda solo per capire quanto ho 
compreso in queste 2 settimane che studio reti neurali :)
Giulio
----
prinar...@ieee.org

 derivata etc etc...)
solo ora mi accorgo che hai detto "superficie" e non "curva", si tratta 
di un metodo del delta applicato tridimensionalmente?
Giulio
----
prinar...@ieee.org



In effetti io non so nulla di reti neurali e metodo del delta, quello
che ho fatto e' stato di implementare un modello fisico in cui si ha
una superficie di energia potenziale legata tramite il gradiente alle
forze che agiscono su un corpo in essa, con la differenza che in
questo programma le "forze" che tendono a "spostare" sono dirette
dalle buche ai picchi in quanto si vogliono premiare i comportamenti
vincenti.
Saluti.

 una superficie di energia potenziale legata tramite il gradiente
Il metodo dei potenziali, ben noto nello studio degli agenti autonomi e dei
robot.
Stefano

Stefano
Grazie per la precisazione, non dubito di aver semplicemente
reinventato l'acqua calda, in materia di IA sono assolutamente un
principiante e il mio interesse starebbe nel convertire in codice le
migliori idee di questo campo di studi, per questo nel post "Aiuto:
metodi di apprendimento" chiedevo lumi in questo senso.
PS: ho corretto la linea nella procedura Spettro
  if Vittoria then inc(valori[seekval,1],2)
    else if valori[seekval,1]>-10 then dec(valori[seekval,1]);
che dava un cut-off verso il basso eccessivo e che appiattiva il
potenziale in
if Vittoria then inc(valori[seekval,1],2)
    else if valori[seekval,1]>-nscontri div 5 then
dec(valori[seekval,1]);
