In the following snippet the two versions (classic and analogic) are compared:

//  Classic version:
  void compute(){
    int black_neighbours = 0;
    for(int z=0; z < neighbours.length; z++)
      if(neighbours[z].rgb == black)
        black_neighbours ++;  

    switch(black_neighbours){
      case 0:
      case 1:
      case 4:
      case 5:
      case 6:
      case 7:
      case 8:
        to_color(white);
        break;
      case 2:
        to_color(rgb);
        break;
      case 3:
        to_color(black);
        break;
    }
  } 

// Analogic version
  void compute(){
    int[] medium_color = new int[] {0,0,0};
    for(int z=0; z < neighbours.length; z++)
      for(int c=0; c < 3; c++)
        medium_color[c] = medium_color[c] + neighbours[z].rgb[c];

    int medium_tone = 0;
    for(int c=0; c < 3; c++){
      medium_color[c] = medium_color[c] / neighbours.length;
      medium_tone = medium_tone + medium_color[c];
    }  

    medium_tone = medium_tone / 3;

    if (medium_tone > 191 || medium_tone < 128 ){
      to_color(white);
    }else if(medium_tone > 159 ){
      to_color(rgb);
    }else{
      to_color(black);
    }
  }

Next I went a step further using ‘medium color’ when the classic rules asked insted to keep the previous cell color. This lead to a general acceleration to white because the medium neighbours color is always more bright than pure black, to balance this behavior I expanded the range of medium_tones which results in black. Here’s the tuned code:

  void compute(){
    int[] medium_color = new int[] {0,0,0};
    for(int z=0; z < neighbours.length; z++)
      for(int c=0; c < 3; c++)
        medium_color[c] = medium_color[c] + neighbours[z].rgb[c];

    int medium_tone = 0;
    for(int c=0; c < 3; c++){
      medium_color[c] = medium_color[c] / neighbours.length;
      medium_tone = medium_tone + medium_color[c];
    }  

    medium_tone = medium_tone / 3;

    if (medium_tone > 191 || medium_tone < 80 ){
      to_color(white);
    }else if(medium_tone > 159 ){
      to_color(medium_color);
    }else{
      to_color(black);
    }
  }

Now a short video of this new behavior:

Here’s the rules:

• if the organism has more than 3 or fewer than 2 neighbours it dies;
• if the organism has 2 or 3 neighbours it survives;
• if a white cell in the matrix is sorrounded by exactly 3 neighbours it became a living organism.

I’ve implemented this Game Of Life using Processing language and trying to push all of the game logic within the organism class in order to really simulate a cellular behavior, here’s the class:

class Spot{
  int[]   rgb, rgb_next;
  int     x,y;
  Spot[]  neighbours;

  Spot(int gx, int gy, int[] c){
    rgb      = c;
    rgb_next = new int[3];
    x       = gx;
    y       = gy;
  }

  void set_neighbors(Spot[][] grid){
    int xp = (x+1 == grid.length ? 0 : x+1);
    int xm = (x-1 == -1 ? grid.length - 1 : x-1);
    int yp = (y+1 == grid[0].length ? 0 : y+1);
    int ym = (y-1 == -1 ? grid[0].length - 1 : y-1);

    neighbours = new Spot[] {  grid[xm][ym], grid[xm][y ], grid[xm][yp],
                               grid[x ][ym],               grid[x ][yp],
                               grid[xp][ym], grid[xp][y ], grid[xp][yp]
                            };
  }

  void compute(){
    int black_neighbours = 0;
    for(int z=0; z < neighbours.length; z++)
      if(neighbours[z].rgb == black)
        black_neighbours ++;  

    switch(black_neighbours){
      case 0:
      case 1:
      case 4:
      case 5:
      case 6:
      case 7:
      case 8:
        to_color(white);
        break;
      case 2:
        to_color(rgb);
        break;
      case 3:
        to_color(black);
        break;
    }
  } 

  void advance(){
    rgb = rgb_next;
    rgb_next = new int[3];
  }

  void draw(int bw,int bh){
     fill(rgb[0],rgb[1],rgb[2]);
     rect(x*bw,y*bh,bw,bh);
  }

  void to_color(int[] c){ rgb_next = c; }
}

There are three methods that worth a look:

• set_neighbors:
  which determinates the sourronding neighbors (as the method name states) by creating an array of pointer to the closest organisms using the matrix passed as parameter as a reference. The first four lines are needed in order to eliminate the boundaries by linking each edge of the matrix to the opposite one.
• compute:
  which implements the real logic of the Game, it is divided into two steps, the first part calculates the number of alive neighbors sorrounding the organism and the second one applies the rules stated above.
• advance:
  due the fact that all of the organisms need to be processed before each of them can switch to the new state, the Spot class record the result of the ‘compute’ method inside a different variable and then, when advance is invoked, it moves this result to the ‘live’ variable.

Here’s a short video of my script in action, the source code is, as usually, available on my github account:

Il principio base che sottende tutti gli algoritmi di reinforcement learning è lo stesso: ad ogni interazione con l’ambiente circostante l’agente viene premiato o punito a seconda dell’azione intrapresa in quel particolare stato. A fronte di questi premi/punizioni l’agente impara col tempo a collezionare il maggior numero di premi possibili evitando le punizioni.

Possiamo formalizzare quanto appena enunciato come segue: dato un’insieme di stati  S={s0,s1…,sn}, un’insieme di azioni A={a1,a2…,am} dobbiamo trovare una corrispondenza stato-azione (detta policy p[s,a] ) in modo da massimizzare il reward R={r1,r2…,rl} che l’ambiente ci fornisce ogniqualvolta in un determinato stato eseguiamo una determinata azione.

Chiaramente a questo enunciato devono seguire alcune considerazioni (che ci porteranno poi alla stesura dell’algoritmo Q-learning), ad esempio risulta ovvio pensare che se dall’azione che eseguo all’istante t ottengo una punizione questa non sarà (probabilmente) legata solo a quello che ho scelto di fare in quell’istante ma anche da tutte le scelte che ho fatto prima.

Ecco dunque che nasce la necessità di aggiungere una nuova definizone a quanto già espresso precedentemente, definiamo q[s,a] come la misura del premio/punizione che mi dovrebbe attendere a lungo termine se intraprendo quella azione in quello stato. Quindi una q[s,a] abbastanza alta dovrebbe rassicurare il mio agente e fargli intraprendere quell’azione in quanto, se prendiamo come esempio gli scacchi, poche mosse dopo quella che stò per fare potrei vincere.

Ottenere un buon indicatore di questa q non è esattamente facile. Per farlo deve necessariamente esplorare l’ambiente in modo da collezionare un po di ‘esperienza’ sul campo, esperienza che poi potrò utilizzare proprio per stillare la policy (perchè unendo i concetti fin qui esposti risulta ben chiaro che se dovessi mai avere la q ‘perfetta’ per ogni copia di stato/azione la mia policy si risolverebbe nell’eseguire di volta in volta l’azione con la q più alta per quello stato).

L’algoritmo Q-learning che stò per enunciare unisce il concetto di ‘calcolo della q’ al concetto di ‘elaborazione della policy’ semplicemente accontentandosi di volta in volta di scelgiere l’azione con la q più alta tra quelle disponibili in quello stato e successivamente di retro-modificare la q scelta incrementandola se l’azione (e quelle successive) hanno portato ad un premio e decrementandola viceversa.

In questo modo dopo un certo numero di ‘episodi’ la q che l’agente si è calcolato dovrebbe essere almeno vicina a quella reale.

Scrivo ora l’algoritmo del Q-learning cosi come descritto nei paragrafi precedenti:

Variabili iniziali:
S = {s1,s2,...sn}   # Stati  (ad esempio in un labirinto ogni casella)
A ={a1,a2,...an}    # Azioni (potrebbero non esserci tutte per ogni stato, in un labirinto
                    # potrebbero essere su, giu, sx, dx)

Setup iniziale:
q = 0               # Per ogni coppia di stato/azione
r =  0              # Per ogni coppia di stato/azione imposto il reward a zero
imposta_reward()    # Per ogni coppia di stato azione significativa ( ad esempio in un
                    # labirinto l'uscita) imposto un
                    # reward diverso dallo zero ( ad esempio uscita: +10, rovi: -5 )
stati_terminali = s1,s2  # Vanno identificati gli stati terminali (quelli in cui,
                         # cioè l'episodio finisce - ad esempio l'uscaita dal labirinto)
stato_corrente = stato_inizale      # Va impostato uno stato iniziale
azione_corrente = azione_iniziale   # Va impostata la prima azione
alpha = xx          # costante, indica quanto la variazione dei q futuri incida sul q
                    # corrente
gamma = xx          # costante, indica quanto 'ridimensionare' la variazione dei q futuri 

Algoritmo:
Finche la policy non converge:
   prossimo_stato   =  recupera_prossimo_stato(stato_corrente,azione_corrente)
   reward = recupera_reward(stato_corrente,azione_corrente)
   prossima_azione =  recupera_l_azione_col_q_maggiore(prossimo_stato)
   q[stato_corrente,azione_corrente] =  q[stato_corrente,azione_corrente] + alpha * ( reward +
                                        gamma * q[prossimo_stato,prossima_azione] -
                                        q[stato_corrente,azione_corrente])

   # se prossimo_stato è una stato terminale stato_corrente deve tornare ad
   # essere stato_iniziale a meno che la policy non si sia stabilizzata.
   stato_corrente = prossimo_stato
   azione_corrente = prossima_azione
end

Ho implementato questo algoritmo in Processing.org ma a differenza del post precedente non posso visualizzarlo nel browser in quanto computazionalmente è troppo impegnativo; potere comunque scaricarlo dal mio accounti di GitHub.

Q-learning in processing.org

Ecco la spiegazione del programma: il quadrato arancio è lo stato terminale, e frutta al nostro agente +1 di ricompensa, i bordi invece quando colpiti fruttano -1 (quindi l’agente tenderà ad evitarli). Dopo qualche minuto dovreste cominciare a notare dei cambiamenti di colore sulla griglia, le celle con q negativo tendono a colorarsi di blu mentre quelle con q positivo tendono ad un viola molto acceso.

L’agente è rappresentato da un quadrato verde e viene disegnato con un scia al seguito; tale scia rappresenta (e lo vedremo meglio la prossima volta) il modo in cui la variazione di q si distribuisce sulle scelte precedenti.

Se avete la pazienza di attendere 5-6 minuti dovreste scorgere con chiarezza una specie di ‘percorso più chiaro’, rappresentato da tutte quelle celle che hanno un q positivo, che parte dallo stato iniziale e guida l’agente verso quello terminale.

Scarica Q-learning con Processing.org dal mio account di GitHub

• muoversi verso il centro del gruppo;
• mantenere una distanza minima dagli altri;
• muoversi con una velocità simile alla velocità del gruppo;

Sulla base di queste tre regole ho sviluppato un piccolo programma in Processing.org che simula il modello comportamentale di un gruppo (mantenendo le tre leggi sopra descritte) in questi passi:

• per ogni elemento dello stormo viene generata una posizione iniziale random all’interno del canvas;
• per ogni ciclo di ridisegno, per ogni elemento dello stormo:
  • recupero la velocità dell’elemento più vicino e la assegno (leggermente variata) all’elemento corrente;
  • trovo il centro dello stormo (e lo modifico con un pò di noise);
  • avvicino l’elemento corrente verso il centro dello stormo alla velocità precedentemente impostata – eseguo quest’ultima operazione solo se l’elemento nella nuova posizione non è troppo vicino a qualche altro elemento dello stormo;

A questo ho aggiunto la possibilità, usando i tasti W,S,A,D di spostare il centro dello stormo calcolato automaticamente e, in questo modo, pilotare l’intero stormo.

Come al solito il codice nella sua interezza è presente sul mio account di GitHub, posso però in questa sede mostrarvi una demo di quanto creato grazie alla potentissima libreria Processing.js regalataci da Jhon Resing che consente di eseguire script scritti per Processing.org all’interno di un elemento ‘CANVAS’ del browser.

Questa libreria non è però al momento 100% cross-browser: io ho personalmente testato il tutto con la versione più aggiornata di Firefox (3.0.5) senza riscontrare nessuna perdità di funzionalità (funzionano anche i comandi da tastiera!); lo stesso però non posso garantire per altri browser.

Per provare il programma non vi resta che cliccare sul link sottostante; ricordate che potete direzionare lo stormo usando la vostra tastiera (tasti: WSAD).

Lancia la simulazione di stormo in Processing

class Creature {
 int sng_x;
 int sng_y;
 float sng_x_speed;
 float sng_y_speed;

 Creature(){
   sng_x = 0;
   sng_y = 0;
   sng_x_speed = 0;
   sng_y_speed = 0;
 }

 float calc_dist(Creature k){
   return sqrt(pow(this.sng_x - k.sng_x,2) + pow(this.sng_y - k.sng_y,2));
 }
 void to_text(){
   println("X: " + sng_x + " Y: " + sng_y);
 }
}

int canvas_width  = 400;
int canvas_height = 400;
int min_separation = 15;
int circle_size = 5;
int num_sheep = 20;
int max_noise = 250;
int mint_follow_x = 0;
int mint_follow_y = 0;
int follow_amount = 100;
float max_speed_variance = 0.001;
float min_speed = 0.005;
float max_speed = 0.01;

Creature[] flock = new Creature[num_sheep]; 

void setup(){
  int i;
  int j;
  boolean bln_separation;
  size(canvas_width,canvas_height);

  for(int x=0; x < flock.length; x++){
    bln_separation = false;
    flock[x] = new Creature();
    while(!bln_separation){
      flock[x].sng_x = int(random(1,canvas_width));
      flock[x].sng_y = int(random(1,canvas_height));
      bln_separation = true;
      for(int y=0; y < x; y++){
        if(flock[x].calc_dist(flock[y]) <= min_separation){
          bln_separation = false;
          break;
        }
      }
    }
  }
}

void draw(){
  background(100);
  float sng_dist;
  float sng_x_speed = 0.0;
  float sng_y_speed = 0.0;
  int sng_x_sum;
  int sng_y_sum;
  float sng_x_avg;
  float sng_y_avg;
  float sng_x_dist;
  float sng_y_dist;
  int sng_tmp_x;
  int sng_tmp_y;

  for(int x=0; x < flock.length; x++){
    sng_dist = 0;
    for(int y=0; y < flock.length; y++){
      if(x!=y){
        if(sng_dist == 0.0 || flock[x].calc_dist(flock[y]) < sng_dist){
          sng_dist = flock[x].calc_dist(flock[y]);
          sng_x_speed = flock[y].sng_x_speed;
          sng_y_speed = flock[y].sng_y_speed;
        }
      }
    }

    flock[x].sng_x_speed = sng_x_speed + max_speed_variance;
    flock[x].sng_y_speed = sng_y_speed + max_speed_variance;
    if(flock[x].sng_x_speed < min_speed) flock[x].sng_x_speed = min_speed;
    if(flock[x].sng_y_speed < min_speed) flock[x].sng_y_speed = min_speed;
    if(flock[x].sng_x_speed > max_speed) flock[x].sng_x_speed = max_speed;
    if(flock[x].sng_y_speed > max_speed) flock[x].sng_y_speed = max_speed;

    sng_x_sum = 0;
    sng_y_sum = 0;
    for(int y=0; y < flock.length; y++){
      sng_x_sum = sng_x_sum + flock[y].sng_x;
      sng_y_sum = sng_y_sum + flock[y].sng_y;
    }

    sng_x_avg = float(sng_x_sum / num_sheep) + (random(1) * max_noise) - (max_noise / 2.0) + mint_follow_x;
    sng_y_avg = float(sng_y_sum / num_sheep) + (random(1) * max_noise) - (max_noise / 2.0) + mint_follow_y;  

    sng_tmp_x = flock[x].sng_x;
    sng_tmp_y = flock[x].sng_y;
    sng_x_dist = sng_x_avg - flock[x].sng_x;
    sng_y_dist = sng_y_avg - flock[x].sng_y;
    flock[x].sng_x = int(flock[x].sng_x + sng_x_dist * flock[x].sng_x_speed);
    flock[x].sng_y = int(flock[x].sng_y + sng_y_dist * flock[x].sng_y_speed);

    for(int y=0; y < flock.length; y++){
      if( x!=y && flock[x].calc_dist(flock[y]) <= min_separation ){
        flock[x].sng_x = sng_tmp_x;
        flock[x].sng_y = sng_tmp_y;
        break;
      }
    }

    if(flock[x].sng_x > canvas_width) flock[x].sng_x = flock[x].sng_x - canvas_width;
    if(flock[x].sng_x < 0) flock[x].sng_x = flock[x].sng_x + canvas_width;
    if(flock[x].sng_y > canvas_height) flock[x].sng_y = flock[x].sng_y - canvas_height;
    if(flock[x].sng_y < 0) flock[x].sng_y = flock[x].sng_y + canvas_height;

     ellipse(flock[x].sng_x,flock[x].sng_y,circle_size,circle_size);
  }
}

void keyPressed() {
  if (key == 'w') mint_follow_y = mint_follow_y - follow_amount;
  if (key == 's') mint_follow_y = mint_follow_y + follow_amount;
  if (key == 'a') mint_follow_x = mint_follow_x - follow_amount;
  if (key == 'd') mint_follow_x = mint_follow_x + follow_amount;
}