Pedone 3.0

Qui si parla dei rilasci di nuovi motori italiani e dei loro aggiornamenti
User avatar
FabioGobbato
Posts: 16
Joined: Sun Dec 27, 2020 8:37 am
Contact:

Pedone 3.0

Post by FabioGobbato »

Ho rilasciato una versione nuova del mio engine. La modifica sostanziale è stata quella di implementare una rete neurale al posto della valutazione. Poi ho fatto anche lievi modifiche alla ricerca. La differenza elo rispetto alla versione 2.1 è di circa 150 punti.
In questa versione ho incorporato la rete neurale nell'eseguibile grazie all'header incbin di Dale Weiler.

Se volete provarlo il download lo trovate sul sito di Pedone: https://sites.google.com/site/pedonechess
stegemma
Site Admin
Posts: 28
Joined: Sat Dec 26, 2020 5:04 pm

Re: Pedone 3.0

Post by stegemma »

Grande notizia! L'ho scaricato e appena potrò lo proverò.

Hai notato un cambio di stile di gioco, rispetto alla versione non-neurale? Intendo proprio "stile", non forza.
User avatar
FabioGobbato
Posts: 16
Joined: Sun Dec 27, 2020 8:37 am
Contact:

Re: Pedone 3.0

Post by FabioGobbato »

Non ho visto moltissime partite, la rete che ho usato l'ho inserita all'ultimo ma mi pare che ripetto a prima per quanto riguarda la sicurezza del re l'engine cerchi maggiormente di portare i pezzi vicino al re avversario, mentre prima si limitava ad attaccare la zona del re avversario dalla distanza con torri, alfieri o regine. Penso che questa cosa dipenda da come è pensato l'input della rete che si basa sul posizionamento dei pezzi rispetto al re proprio e avversario.
Mi sembra anche che comprenda meglio le posizioni chiuse, nonostante in valutazione non abbia conoscenza a riguardo.
C'è qualche differenza ma non ci sono rivoluzioni nello stile. In realtà punto a migliorare la forza di gioco e dargli un gioco più equilibrato possibile.
La rete neurale può essere ancora migliorata anche perchè per risparmiare risorse l'ho addestrata con un numero di posizioni piuttosto basso.
stegemma
Site Admin
Posts: 28
Joined: Sat Dec 26, 2020 5:04 pm

Re: Pedone 3.0

Post by stegemma »

Non ho capito l'ultimo punto: per addestrare la rete puoi usare tutte le risorse che vuoi, perché non influiranno poi nel gioco reale.
User avatar
FabioGobbato
Posts: 16
Joined: Sun Dec 27, 2020 8:37 am
Contact:

Re: Pedone 3.0

Post by FabioGobbato »

Per addestrare la rete che ho usato in Pedone 3.0 ho preso 300M di posizioni e le ho fatte analizzare a Pedone 2.1 a depth 14. Per analizzare 300M di posizioni a depth 14 ci ho impiegato quasi 2 settimane con pc acceso giorno e notte. Ed ho utilizzato solo 300M di posizioni quando altri ne hanno usate più di 2 miliardi. Creare il set di posizioni per l'addestramento richiede molto molto tempo e io ho cercato un pò di risparmiare e questo ha effetti sulla qualità della rete. Un pò alla volta vedrò di migliorare anche questo aspetto.
stegemma
Site Admin
Posts: 28
Joined: Sat Dec 26, 2020 5:04 pm

Re: Pedone 3.0

Post by stegemma »

Se il software per addestrare la rete gira su Linux, posso installartelo su di un piccolo server che ho su Aruba e farlo girare anche per mesi (non è veloce ma lo uso solo come repository per GIT, per cui è libero).
User avatar
FabioGobbato
Posts: 16
Joined: Sun Dec 27, 2020 8:37 am
Contact:

Re: Pedone 3.0

Post by FabioGobbato »

Grazie, gentilissimo, ma per il momento penso di riuscire ad arrangiarmi con le risorse che ho a disposizione. Posso comunque calcolare le posizioni per l'addestramento un pò per volta lasciando il pc libero di tanto in tanto per altri test.
Comunque grazie mille.
Granata69
Posts: 5
Joined: Mon Feb 01, 2021 10:47 pm

Re: Pedone 3.0

Post by Granata69 »

Ciao. Complimenti per Pedone3.0!
Sto facendomi dei tornei con vari engine, ieri ho valutato la bonta' della tua opera informatica. Ho visto Pedone3 in difficolta' solo con Stockfish12 64bit, che credo usi lo stesso tipo di rete rete neurale implementata.
Sembra che l'approccio con le NN funzioni, non ho ancora capito bene perche' ma funziona. Credo sia un argomento dal potenziale ancora da scoprire...
sasachess
Posts: 2
Joined: Wed Mar 31, 2021 4:17 pm

Re: Pedone 3.0

Post by sasachess »

Ciao Fabio,
complimenti per il tuo gran lavoro!
Dopo un anno di fermo con la computer chess, ho scoperto da pochi giorni le reti NNUE.
Non ne capisco un bel niente, ma mi sono incuriosito e ho voluto provare a integrarle in gogobello.
Per il momento ho usato la libreria nnue-probe di Daniel Shawul, l'incbin di Dale Weiler e l'attuale net di default di Stockfish.
Il risultato ha dell'incredibile, rispetto la valutazione classica c'è un grande divario.
Vorrei cominciare a capirne di più di questo NNUE, tanto per cominciare non ho ancora capito come creare una nuova net con gli eseguibili di nodchip. Ci ho provato seguendo le istruzioni ma il file nn.bin che mi produce Stockfish non lo digerisce.

Un caro saluto a tutti,
Salvatore
User avatar
FabioGobbato
Posts: 16
Joined: Sun Dec 27, 2020 8:37 am
Contact:

Re: Pedone 3.0

Post by FabioGobbato »

Non ho usato il trainer di stockfish che non conosco bene, ma ho implementato un mio trainer, uso un semplicissimo stochastic gradient descent, trovi moltissime implementazioni in rete. Poi ho creato un set di 300M posizioni analizzate a depth 14 da pedone tradizionale ed ho addestrato la rete con i risultati della ricerca a quella profondità. Non è sempre semplice trovare delle reti buone, alle volte devi interrompere l'addestramento dopo poche epoche ed altre volte invece devi proseguire. Ci vuole anche un pò di fortuna.

Se può esserti di aiuto ti riporto un esemio semplice di rete neurale che ho usato all'inizio per capire come funzionano, richiede un pò di tempo ma non è complicato adeguarlo alla rete nnue per poi addestrarla.

L'esempio è una piccola rete che viene addestrata per una operazione di xor tra gli input scritto in C

Code: Select all

#include <stdio.h>
#include <stdlib.h>

typedef double NNType;
// numer of inputs
#define IN 2
// number neurons layer hidden
#define HID 8
// numer of outputs
#define OUT 1
// learning constant
#define EPS 0.1

NNType input[IN]; // input
NNType hidden[HID]; // layer hidden
NNType output[OUT]; // output
NNType weightH[HID][IN]; // weights layer hidden
NNType biasesH[HID]; // biases layer hidden
NNType weightO[OUT][HID]; // weights output
NNType biasesO[OUT]; // biases output

NNType Loss(NNType x)
{
   return 0.5*x*x;
}

NNType DerivativeLoss(NNType x)
{
   return x;
}

NNType Activation(NNType x)
{
   return x>0?x:0;
}

NNType DerivativeActivation(NNType x)
{
   return x>0?1:0;
}

NNType NetworkResult(NNType inp1,NNType inp2)
{
   // load the inputs
   input[0]=inp1;
   input[1]=inp2;
   // compute hidden layer
   for (int i=0;i<HID;i++)
   {
      hidden[i]=biasesH[i];
      for (int j=0;j<IN;j++)
         hidden[i] += input[j]*weightH[i][j];
      hidden[i]=Activation(hidden[i]);
   }
   // compute output
   for (int i=0;i<OUT;i++)
   {
      output[i]=biasesO[i];
      for (int j=0;j<HID;j++)
         output[i] += hidden[j]*weightO[i][j];
      output[i]=Activation(output[i]);
   }
   return output[0];
}

void TrainNet(NNType inp1,NNType inp2,NNType result,NNType *error)
{
   NetworkResult(inp1,inp2);
   NNType DeltaO[OUT];
   NNType DeltaH[HID];
   // layer output
   NNType err= result-output[0];
   *error+=Loss(err);
   DeltaO[0]=DerivativeLoss(err)*DerivativeActivation(output[0]);
   // layer hidden
   for (int i=0;i<HID;i++)
   {
      NNType err=0;
      for (int j=0;j<OUT;j++)
         err+= DeltaO[j]*weightO[j][i];
      DeltaH[i]=err*DerivativeActivation(hidden[i]);
   }
   // change weights
   // layer output
   for (int i=0;i<OUT;i++)
   {
      for (int j=0;j<HID;j++)
         weightO[i][j]+=EPS*DeltaO[i]*hidden[j];
      biasesO[i]+=EPS*DeltaO[i];
   }
   // layer hidden
   for (int i=0;i<HID;i++)
   {
      for (int j=0;j<IN;j++)
         weightH[i][j]+=EPS*DeltaH[i]*input[j];
      biasesH[i]+=EPS*DeltaH[i];
   }
}

// constant for weights initializations
#define CONSTINIT 0.1

int main(int argc, char *argv[])
{
   srand(1);
   // initalize weights and biases
   for (int i=0;i<HID;i++)
   {
      for (int j=0;j<IN;j++)
         weightH[i][j]= 2.0 * ( (rand()/((NNType)RAND_MAX)) - 0.5 ) * CONSTINIT;
      biasesH[i]=0.1;
   }
   for (int i=0;i<OUT;i++)
   {
      for (int j=0;j<HID;j++)
         weightO[i][j]= 2.0 * ( (rand()/((NNType)RAND_MAX)) - 0.5 ) * CONSTINIT;
      biasesO[i]=0.1;
   }
   // calculate the results with the random weights
   printf("0 0 = %f\n",NetworkResult(0,0));
   printf("0 1 = %f\n",NetworkResult(0,1));
   printf("1 0 = %f\n",NetworkResult(1,0));
   printf("1 1 = %f\n",NetworkResult(1,1));
   printf("\n");
   // Train the net to recognize an xor operation
   int i;
   for (i=0;i<10000;i++)
   {
      NNType error=0;
      TrainNet(0,0,0,&error); // input 0 0 result 0
      TrainNet(0,1,1,&error); // input 0 1 result 1
      TrainNet(1,0,1,&error); // input 1 0 result 1
      TrainNet(1,1,0,&error); // input 1 1 result 0
      if (error<0.0001) break; // exit the training with a low error
   }
   // calculate the results after the train
   printf("After %d iterations\n",i);
   printf("0 0 = %f\n",NetworkResult(0,0));
   printf("0 1 = %f\n",NetworkResult(0,1));
   printf("1 0 = %f\n",NetworkResult(1,0));
   printf("1 1 = %f\n",NetworkResult(1,1));
   printf("\n");
   return 0;
}
Post Reply