Intelligenza artificiale: m-table

Dopo aver realizzato un ambiente virtuale per l’addestramento di una rete neurale QUI e un programma che sfruttando questo ambiente virtuale implementa le q-table QUI, ho pensato che c’era un modo molto più efficiente di fare apprendere la rete neurale, non so se già è stato fatto ma non sapendo come definire questo nuovo tipo di rete l’ho chiamata m-table.

Il meccanismo è molto simile alla q-table, solo che i punteggi ricevuti come ritorno dall’ambiente in seguito ad una azione ne modificano immediatamente il valore, quindi non è previsto (in questa versione) una propagazione dell’apprendimento.

Nonostante questo la m-table é risultata più efficiente della q-table, almeno in questo contesto.

Nel futuro implementerò il sistema di propagazione dell’apprendimento che la renderà ancora più efficiente, sarà oggetto di altro articolo.

Il programma che, sempre appoggiandosi allo stesso ambiente virtuale, implementa le m-table è il seguente:

from env_tallo import *
import keyboard
import time

mtable_pilota = []
mtable_memoria = []

casuali = scelte = vuote = 0
crea_mondo(100,50,30)
disegna_mondo()
tallo = [random.randrange(1, at_mondo_colonne-1), random.randrange(1, at_mondo_righe-1)]
griglia = '0'*(at_vista+at_vista+1)**2
for x in range(0,500000):
    pygame.draw.rect(at_sfondo, at_col_visitato, (1, 505, 1500 ,700))
    if  mtable_pilota.count(griglia) == 0:
        mtable_pilota.append(griglia)
        mtable_memoria.append([0,0,0,0,0,0,0,0,0])
    puntatore = mtable_pilota.index(griglia)
    azione = mtable_memoria[puntatore].index(max(mtable_memoria[puntatore]))
    memoria = mtable_memoria[puntatore]
    if mtable_memoria[puntatore][azione] == 0:
        azione = random.randint(0, 8)
        casuali += 1
    else:
        scelte += 1
    at_sfondo.blit(at_font.render('q:esci m:manuale a:automatico  -  azione 1:su 2:destra 3:giu 4:sinistra 5:su destra 6:giu destra 7:giu sinistra 8:su sinistra 9:fermo  ', True, at_col_ostacolo), (10, 510))
    at_sfondo.blit(at_font.render('Casuali   '+format(casuali, ',d'), True, at_col_ostacolo), (10, 530))
    at_sfondo.blit(at_font.render('Scelte   '+format(scelte, ',d'), True, at_col_ostacolo), (10, 550))
    at_sfondo.blit(at_font.render('M-table  '+format(len(mtable_pilota), ',d'), True, at_col_ostacolo), (10, 570))
    at_sfondo.blit(at_font.render('prima di eseguire azione: azione e puntatore e griglia  '+format(azione, ',d')+' '+format(puntatore, ',d')+' '+griglia, True, at_col_ostacolo), (10, 600))
    at_sfondo.blit(at_font.render('Memoria   ' + ' '.join(str(e) for e in memoria), True, at_col_ostacolo), (10, 620))
    pygame.display.flip()
    punteggio, griglia = azione_tallo(tallo, azione)
    mtable_memoria[puntatore][azione] += punteggio
    at_sfondo.blit(at_font.render('dopo esecuzione: azione e puntatore e griglia  '+format(azione, ',d')+' '+format(puntatore, ',d')+' '+griglia, True, at_col_ostacolo), (10, 650))
    at_sfondo.blit(at_font.render('Memoria   ' + ' '.join(str(e) for e in memoria), True, at_col_ostacolo), (10, 670))
    at_sfondo.blit(at_font.render('Punteggio   ' + format(punteggio, ',d'), True, at_col_ostacolo), (10, 690))
    pygame.display.flip()
    if keyboard.is_pressed("q"):
        break
input('premi invio')

Molto semplice è snello, sono più le istruzioni per visualizzare i dati di quelle necessarie alla gestione della rete neurale. I risultati sono stati molto interessanti, il tempo di esecuzione è un centesimo rispetto alle q-table e il rapporto fra cibo e urti è migliore e mostra un andamento costante di apprendimento a differenza delle q-table che tende a diminuire con il tempo.

random
tempocicliurticiborapporto urti/cibo
211.000.00020.3331.6998,36
482.000.00060.0765.2538,74
683.000.000120.18110.6828,89
914.000.000198.08017.6828,93
1275.000.000296.69126.5478,95
1516.000.000418.69936.8048,79
1757.000.000560.26948.8718,72
2038.000.000718.26862.9748,77
2139.000.000901.83078.6758,72
qtable
601.000.0001.5701.05867,39
1912.000.0002.0662.139103,53
3693.000.0002.5433.386133,15
5244.000.0003.3994.067119,65
7585.000.0004.0155.646140,62
9026.000.0004.5586.934152,13
11237.000.0005.1818.036155,11
13508.000.0005.7498.787152,84
15739.000.0006.41710.025156,23
mtable
201.000.0005941.074180,81
322.000.0008692.147247,07
393.000.0001.0803.154292,04
464.000.0001.3634.329317,61
525.000.0001.5735.284335,92
556.000.0001.7446.210356,08
587.000.0001.9267.237375,75
628.000.0002.1208.280390,57
659.000.0002.2779.421413,75

Come potete vedere le q-table hanno sono un po’ più efficienti nel raggiungimento del cibo ma per il resto sono peggiori. Penso che ora che implemento la propagazione dell’apprendimento, anche in questo le m-table, pur nella loro semplicità, saranno più efficienti.

Alla prossima.

Maurizio

Lascia un commento