Lezione 6: Esempio pratico: far giocare l'AI al posto tuo

Obiettivi della lezione

Questa lezione è una parentesi, e conviene saperlo prima di cominciare: il tuo processo resta dov'è, lo riprendiamo nella Lezione 7. Qui il metodo delle cinque lezioni di prima lo guardiamo girare per intero su una cosa piccola, perché un metodo si capisce quando lo vedi in moto. Questa lezione è quella cosa piccola: facciamo giocare l'AI a un videogioco al posto nostro. È un gioco, e insegna il giro del lavoro meglio di qualunque schema, perché a ogni turno vedi subito se la decisione era buona.

Alla fine di questa lezione sai:

• Fotografare uno stato e passarlo a un modello che decide;
• Scrivere le tre forme di domanda di un classificatore con i loro criteri;
• Costruire il giro: leggi lo stato, chiedi, esegui, ricomincia (il gioco te lo do scritto);
• Tenere i conti dentro al gioco e lasciare al modello la sola scelta;
• Mettere il cancello sulla confidenza, e portare tutto questo sul tuo lavoro.

Perché si comincia da un gioco

Un gioco a turni ha le tre cose che un processo di lavoro fatica a darti tutte insieme. Le regole sono scritte, quindi sai sempre quali mosse esistono. Lo stato sta in una riga, perché la partita è fatta di pochi numeri. E soprattutto una mossa sbagliata non fa danni: il caso peggiore è che perdi la partita e ne cominci un'altra.

Al lavoro nessuna delle tre è vera all'inizio: le regole stanno nella testa delle persone (Lezione 2), lo stato è sparso fra una casella di posta e tre fogli, e una mossa sbagliata arriva a un cliente. Per questo si impara qui e si porta lì.

C'è anche una ragione tecnica. Una partita a turni fa una domanda al modello ogni turno, e una partita ne dura trenta. Con un modello che scrive staresti a guardare una rotellina e pagheresti trenta risposte lunghe per ottenere trenta parole. Con un classificatore la domanda è una sola chiamata che torna un'etichetta, ed è il motivo per cui questo laboratorio si può fare stasera.

Il gioco: la grotta

Serve un gioco abbastanza semplice da tenerlo in una schermata e abbastanza cattivo da rendere la scelta interessante. Questo basta e avanza.

• Hai 100 di vita, due pozioni da 30 e un colpo forte che dopo l'uso si ricarica in due turni.
• Il mostro ha 120 di vita e a ogni turno ti toglie da 8 a 20, tirato a caso.
• Ogni turno scegli una fra quattro mosse: attacca, colpo forte, pozione, fuggi.
• Scappando tieni le monete raccolte. Morendo le perdi tutte.

La scelta è interessante perché nessuna mossa è sempre giusta. Il colpo forte rende molto e ti lascia scoperto due turni. La pozione ti salva e regala un turno al mostro. Fuggire è la mossa che nessuno ricorda di avere, e spesso è quella che porta a casa la serata.

Il gioco te lo do già scritto, perché il laboratorio di oggi è la parte che decide e non la grotta. Sono cinquanta righe di Python senza niente da installare: le copi in un file e girano.

import random

MOSSE = ["attacca", "colpo_forte", "pozione", "fuggi"]

class Eroe:
    def __init__(self):
        self.vita, self.pozioni, self.ricarica = 100, 2, 0
        self.monete, self.turno, self.fuggito = 0, 1, False

class Mostro:
    def __init__(self):
        self.nome, self.vita = "Ombra della grotta", 120
    def colpisci(self, eroe):
        eroe.vita -= random.randint(8, 20)

def fotografia(eroe, mostro):
    forte = "pronto" if eroe.ricarica == 0 else "fra %d turni" % eroe.ricarica
    return ("Turno %d. "
            "Eroe: vita %d su 100, pozioni %d (curano 30). "
            "Colpo forte: %s. "
            "Mostro: %s, vita %d su 120, toglie da 8 a 20 a turno. "
            "Monete raccolte: %d, si perdono morendo."
            % (eroe.turno, eroe.vita, eroe.pozioni, forte,
               mostro.nome, mostro.vita, eroe.monete))

def esegui(mossa, eroe, mostro):
    # ⚠️ Una mossa impossibile (colpo forte in ricarica, pozione finita)
    #    brucia il turno. È una conseguenza vera: chi decide deve leggere lo stato.
    if mossa == "attacca":
        mostro.vita -= random.randint(6, 10); eroe.monete += 5
    elif mossa == "colpo_forte" and eroe.ricarica == 0:
        mostro.vita -= random.randint(18, 24); eroe.ricarica = 3; eroe.monete += 5
    elif mossa == "pozione" and eroe.pozioni > 0:
        eroe.pozioni -= 1; eroe.vita = min(100, eroe.vita + 30)
    elif mossa == "fuggi":
        eroe.fuggito = True

def esito(eroe, mostro):
    if eroe.vita <= 0:  return ("morto", 0)
    if eroe.fuggito:    return ("fuggito", eroe.monete)
    return ("vinto", eroe.monete + 50)

def gioca(scegli):
    """`scegli(stato, eroe, mostro)` restituisce una delle MOSSE."""
    eroe, mostro = Eroe(), Mostro()
    while eroe.vita > 0 and mostro.vita > 0 and not eroe.fuggito:
        esegui(scegli(fotografia(eroe, mostro), eroe, mostro), eroe, mostro)
        if mostro.vita > 0 and not eroe.fuggito:
            mostro.colpisci(eroe)
        if eroe.ricarica: eroe.ricarica -= 1
        eroe.turno += 1
        if eroe.turno > 60: break          # salvagente contro le partite infinite
    return esito(eroe, mostro)

Tutto quello che cambia da un giocatore all'altro sta in una funzione sola, scegli, che riceve la fotografia e restituisce una parola. I due metri di paragone sono tre righe:

a_caso = lambda stato, eroe, mostro: random.choice(MOSSE)

def tre_if(stato, eroe, mostro):
    # la strategia che scriveresti tu in due minuti
    if eroe.vita <= 30 and eroe.pozioni: return "pozione"
    if eroe.vita <= 15:                  return "fuggi"
    if eroe.ricarica == 0:               return "colpo_forte"
    return "attacca"

Questi due leggono i numeri dagli oggetti e la fotografia la ignorano: il testo serve a chi decide leggendo. Scrivi tre_if come ti pare, l'importante è che sia la tua strategia. È il giocatore da battere, e non è un fantoccio: con queste quattro righe la grotta si vince spesso.

Fotografare lo stato

Un classificatore guarda uno stato e risponde a delle domande su quello stato. Il primo pezzo da scrivere è quindi la funzione che fotografa la partita e la mette in una riga leggibile.

def fotografia(eroe, mostro):
    forte = "pronto" if eroe.ricarica == 0 else "fra %d turni" % eroe.ricarica
    return (
        "Turno %d. "
        "Eroe: vita %d su 100, pozioni %d (curano 30). "
        "Colpo forte: %s. "
        "Mostro: %s, vita %d su 120, toglie da 8 a 20 a turno. "
        "Monete raccolte: %d, si perdono morendo."
        % (eroe.turno, eroe.vita, eroe.pozioni, forte,
           mostro.nome, mostro.vita, eroe.monete)
    )

Due scelte dentro a queste poche righe, e sono le stesse che farai sul lavoro.

Si manda lo stato di adesso, non la storia della partita. La tentazione è allegare tutti i turni precedenti. In un gioco a turni il presente contiene già tutto quello che conta, e la cronologia allunga la richiesta senza aggiungere niente. È la stessa ragione per cui nella Lezione 4 si apre una conversazione nuova a ogni pratica.

Nello stato ci vanno anche le regole che servono a scegliere: che le pozioni curano 30, che il mostro toglie da 8 a 20, che le monete si perdono morendo. Senza questi numeri la domanda «conviene bere?» non ha una risposta, e il modello indovina.

Le tre domande, in una chiamata sola

Adesso la parte che decide. Sullo stesso stato faccio tre domande di tipo diverso: quale mossa (scelta), quanto sono in pericolo (si_no), quanto è dura questa partita (voto). Lo stato viene letto una volta sola e le tre domande si appoggiano a quella lettura, quindi aspettare le tre insieme è quasi come aspettarne una.

Il classificatore è Bivio, quello della Lezione 3: gira sul tuo computer, non chiede nessuna chiave e non manda niente in rete. Se non l'hai ancora installato sono due comandi.

pip install git+https://github.com/TheRealF/bivio
bivio scarica     # il modello, 2,5 GB

from bivio import Bivio

cervello = Bivio()          # il modello si carica una volta, poi resta in memoria

DOMANDE = {
    "mossa": {
        "tipo": "scelta",
        "istruzioni": "Quale mossa conviene giocare in questo turno",
        "opzioni": {
            "attacca": "Colpo normale, toglie da 6 a 10, sempre disponibile",
            "colpo_forte": "Toglie da 18 a 24, poi tre turni di ricarica",
            "pozione": "Recupera 30 di vita e regala un turno al mostro",
            "fuggi": "Esci vivo dalla grotta e tieni le monete gia' raccolte",
        },
    },
    "pericolo": {
        "tipo": "si_no",
        "istruzioni": "Il mostro puo' uccidermi entro i prossimi due turni",
    },
    "durezza": {
        "tipo": "voto",
        "istruzioni": "Quanto e' messa male questa partita",
        "livelli": ["Sotto controllo", "In bilico", "Persa"],
    },
}

def decidi(stato):
    return cervello.decidi(stato, DOMANDE)

Il campo che fa il lavoro vero è opzioni (in Jev si chiama criteria, ed è la stessa cosa). Quelle descrizioni sono il regolamento che il modello legge: se scrivi «pozione: cura» e basta, la berrà anche a vita piena. Per il voto è l'elenco ordinato dei livelli, dal più basso al più alto. Le opzioni arrivano a 26, che per un gioco a turni sono molte più del necessario.

r = decidi(stato)

r["mossa"].valore           # 'pozione'
r["mossa"].probabilita      # 0.86
r["mossa"].distribuzione    # {'attacca': 0.07, 'colpo_forte': 0.02,
                            #  'pozione': 0.86, 'fuggi': 0.05}
r["mossa"].confidenza       # 0.79

r["pericolo"].valore        # True
r["pericolo"].probabilita   # 0.91

r["durezza"].valore         # 1.4   il voto come media pesata sui tre livelli
r["durezza"].dispersione    # 0.57  quanto il modello era combattuto

Guarda che cosa ti torna oltre alla mossa. La distribuzione dice quanto la scelta era combattuta: 0,86 contro 0,07 è una decisione netta, 0,44 contro 0,41 è una moneta lanciata. La confidenza è il numero su cui monteremo il cancello. E durezza a 1,4 su una scala di tre livelli è l'informazione che in una chat avresti dovuto leggere in un paragrafo.

Il giro

Il giro ce l'hai già: è la funzione gioca del gioco. Quello che manca è il terzo giocatore, e sono otto righe.

def con_bivio(stato, eroe, mostro):
    r = decidi(stato)
    mossa = r["mossa"].valore

    # il cancello: se la scelta e' combattuta si gioca quella che non fa danni
    if r["mossa"].confidenza < 0.6:
        mossa = "attacca"

    return mossa

print(gioca(a_caso), gioca(tre_if), gioca(con_bivio))

È il giro degli agenti della Lezione 5, scritto per esteso: leggi lo stato, chiedi una decisione, esegui, ricomincia finché il compito non è finito. Cambia che qui lo vedi tutto in una schermata, e che i tre giocatori si scambiano cambiando una parola.

Se non vuoi installare niente

Bivio si scarica 2,5 GB di modello, e su una connessione lenta o su un computer prestato non è sempre la strada. In quel caso il laboratorio si fa lo stesso con l'assistente che usi tutti i giorni. La funzione da scrivere è la stessa, con dentro un'altra cosa:

import json

def con_assistente(stato, eroe, mostro):
    risposta = chiedi_al_modello(               # la tua chiamata, quella che hai gia'
        "Scegli una mossa fra: attacca, colpo_forte, pozione, fuggi.\n"
        "Rispondi solo con {\"mossa\": \"...\"}, senza testo attorno.\n\n" + stato)
    try:
        return json.loads(risposta)["mossa"]
    except (ValueError, KeyError):
        return "attacca"        # la lettura e' fallita: mossa che non fa danni

Cambiano tre cose, e sono le tre della Lezione 5. Va più piano, perché una risposta scritta si aspetta. Costa di più, perché paghi dei token per ottenere una parola. E soprattutto non hai la confidenza, quindi il cancello non lo puoi mettere sulla certezza della scelta: ti resta il try, che è un cancello sulla forma della risposta invece che sul merito. Quella differenza, provata di persona su qualche partita, vale più di qualunque tabella comparativa.

Quello che il modello non tocca

La riga con il commento è la più importante del file. esegui() fa i conti: sottrae la vita, tira i danni, scala le pozioni, gestisce la ricarica. Al modello resta la sola scelta fra quattro parole.

È la regola della Lezione 1 vista in azione, e in un gioco si tocca con mano. Se lasciassi calcolare i danni al modello, ogni tanto il mostro perderebbe 14 di vita invece di 9 e nessuno se ne accorgerebbe, perché 14 è un numero plausibile.

Lo stesso vale per le regole già scritte. «Se la vita è sotto 15 e ho una pozione, bevo» è una regola: si scrive con un if, costa zero e non sbaglia mai. Il modello si guadagna il posto dove la scelta dipende da cinque cose insieme, che è il caso di tutti gli altri turni.

Le mosse impossibili non gliele offriamo

Questa è la cosa che ho imparato facendo girare il laboratorio, e da sola vale la lezione.

La prima versione offriva al modello tutte e quattro le mosse a ogni turno. Sceglieva il colpo forte anche mentre era in ricarica, cioè bruciava il turno senza fare danni, e moriva in tutte le partite. Leggeva nello stato che il colpo forte era «fra 2 turni» e lo sceglieva lo stesso, perché nella descrizione c'era scritto che toglie da 18 a 24 ed è il numero più grande della lista.

La correzione è una funzione di sei righe che costruisce l'elenco delle opzioni guardando lo stato:

def legali(eroe):
    mosse = ["attacca"]
    if eroe.ricarica == 0:  mosse.append("colpo_forte")
    if eroe.pozioni > 0:    mosse.append("pozione")
    mosse.append("fuggi")
    return {m: DESCRIZIONI[m] for m in mosse}

# e nella domanda, al posto dell'elenco fisso:
"opzioni": legali(eroe)

Con questa riga sola il giocatore passa da morire in ogni partita a vincerne tre su quattro. Quale mossa sia possibile è un passo meccanico: la regola è scritta e vale sempre, quindi lo fa il codice. Quale mossa sia conveniente è un passo di giudizio, e resta al modello. È la tabella della Lezione 3 applicata a una riga di codice.

Il cancello, anche in un gioco

La riga confidence < 0.6 è il cancello della Lezione 5, in miniatura. Quando la scelta è combattuta, il programma gioca la mossa che non può far male invece di fidarsi.

Nel gioco puoi spingerla oltre, e ti consiglio di provarci: la mossa che spende una risorsa che non torna (l'ultima pozione, il colpo forte) la fai passare solo sopra una confidenza alta. Vedrai le partite cambiare forma. La soglia è il tuo unico bottone: alzandola il programma gioca prudente e vince meno, abbassandola diventa spavaldo e muore.

Quel bottone al lavoro si chiama in un altro modo, e lo vediamo nella Lezione 7: sotto soglia la pratica si ferma e chiama una persona.

Misurare, che qui è gratis

Il bello di un gioco è che il punteggio esiste già. I due giocatori che non chiamano nessuno fanno cento partite, quelli che chiamano un modello ne fanno venti: bastano a vedere la differenza e non ti fanno passare la serata ad aspettare. Riempi questa tabella.

I numeri non te li scrivo io, e il motivo è il laboratorio stesso: dipendono dalle descrizioni che metti in opzioni, che sono la tua parte del lavoro. Quello che ti interessa guardare è la colonna delle monete medie insieme a quella delle vittorie, perché un giocatore che scappa sempre vince poco e porta a casa parecchio, ed è una strategia.

Lo stesso giro, al posto tuo, sul lavoro

Adesso la battuta con cui questa lezione è nata. Se l'AI sa giocare al posto tuo, sa anche lavorare al posto tuo, perché è lo stesso identico giro con altri nomi.

Una differenza c'è, ed è tutta la Lezione 7. Nella grotta la mossa sbagliata ti fa perdere delle monete finte. Sul lavoro parte una mail a un cliente vero, e da quel momento il cancello smette di essere un'idea carina e diventa la ragione per cui puoi lasciare che il giro vada da solo.

Laboratorio: fai giocare l'AI

Obiettivo: una partita giocata da un classificatore, con il cancello acceso e la tabella delle misure riempita.

Consegna

1. Copia la grotta in grotta.py dal blocco qui sopra. Non c'è niente da installare. Se preferisci partire da qualcosa che già gira, il file finito con tutti i giocatori sta in esempi/grotta.py.
2. Fai giocare a_caso per cento partite e segna la riga della tabella. È il tuo pavimento.
3. Riscrivi tre_if con la tua strategia (per esempio: bevi sotto 30, colpo forte appena pronto, scappa sotto 15 senza pozioni) e fai altre cento partite. È il tuo metro vero.
4. Attacca il classificatore con le tre domande (o l'assistente del piano B) e fai venti partite senza cancello.
5. Accendi il cancello a 0,6 e rifai venti partite. Se vuoi vedere il bottone in azione, dieci a 0,4 e dieci a 0,8.
6. Togli dalle opzioni le mosse impossibili con la funzione legali(), e rifai venti partite. Questa è la riga della tabella che ti sorprenderà di più.
7. Lavora sulle descrizioni: prendi il turno in cui la scelta ti sembra più sbagliata, guarda le probabilità, e riscrivi la descrizione dell'opzione che ha vinto a torto. Una modifica alla volta, come nella Lezione 4.
8. Compila la tabella del trasferimento con il tuo processo nella colonna di destra.

Mini-test di autoverifica

Sezione A: risposta multipla

1. Nello stato che mandi al modello va messa:
   a) tutta la cronologia della partita   b) la situazione di adesso con le regole che servono a scegliere   c) solo la vita   d) la strategia
2. Il campo opzioni di una domanda di tipo scelta contiene:
   a) la risposta giusta   b) la descrizione di ogni opzione   c) la soglia   d) il numero di turni
3. Il calcolo dei danni:
   a) lo fa il modello   b) lo fa il gioco   c) lo fa il cancello   d) si chiede in una score
4. Una choice con probabilità 0,44 e 0,41 dice che:
   a) la scelta è netta   b) la scelta è una moneta lanciata   c) il modello ha sbagliato   d) manca un'opzione
5. Alzando la soglia di confidenza il programma:
   a) gioca prudente e vince meno   b) diventa spavaldo   c) fa meno chiamate   d) non cambia
6. Se il classificatore non batte tre if scritti da te:
   a) il modello è rotto   b) si lavora sulle descrizioni in opzioni   c) si alza la soglia   d) si cambia gioco

Sezione B: risposta aperta

7. (3 punti) Scrivi la fotografia dello stato di una pratica del tuo lavoro, con dentro le informazioni che servono a scegliere il passo successivo.
8. (3 punti) Per quella pratica, scrivi una domanda choice con almeno tre opzioni e la descrizione di ognuna, e di' quale mossa fai passare quando la confidenza è bassa.

Riassunto della lezione