Esercizio - Ambienti, PEAS e tipo di agente (slide del corso)

Esercizio ricavato dalle slide del corso di Intelligenza Artificiale, Ing. dell'Informazione UniPD, sugli agenti: descrizione PEAS di un compito, classificazione dell'ambiente con le sette coppie di proprietà, scelta del tipo di agente e un calcolo esatto sul mondo dell'aspirapolvere, a partire dalla variante delle slide in cui "il quadrato può restare sporco anche dopo l'aspirazione" e il sensore di sporco è rotto. Teoria in Agenti intelligenti - ambienti, PEAS e tipi di agenteUn agente è una funzione dalle sequenze di percezioni alle azioni; è razionale se per ogni sequenza sceglie l'azione che massimizza il valore atteso della misura di prestazione, date le percezioni e la conoscenza incorporata. L'ambiente di lavoro si descrive con PEAS (Performance, Environment, Actuators, Sensors) e si classifica con sette coppie di proprietà (osservabile, deterministico, episodico, statico, discreto, singolo/multi-agente, noto). Le architetture crescono in complessità: reattivo semplice, reattivo basato su modello, basato su obiettivi, basato su utilità, più l'agente che apprende (elemento esecutivo, di apprendimento, critico, generatore di problemi).Agenti intelligenti - ambienti, PEAS e tipi di agente →. I numeri sono verificati con il programma in fondo (calcolo esatto e simulazione).

Testo

1. Aspirapolvere con il sensore di sporco rotto. Due quadrati $A$ e $B$, entrambi sporchi; il robot parte in $A$, percepisce solo la propria posizione, non se il quadrato è sporco. L'azione Suck pulisce il quadrato corrente con probabilità $p$ (con probabilità $1 - p$ il quadrato resta sporco). Azioni: Left, Right, Suck, NoOp. Misura di prestazione: $+1$ per ogni quadrato pulito a ogni passo, su un orizzonte di $T = 20$ passi. (a) Scrivere il PEAS. (b) Classificare l'ambiente. (c) Dire quale tipo di agente serve. (d) Si usa la politica "aspira $k$ volte e poi cambia quadrato, e ripeti": calcolare la prestazione attesa per $k = 1, \dots, 5$ con $p = 1$, $p = 0{,}8$, $p = 0{,}5$ e dire quale $k$ è razionale.
2. Classificare (sette proprietà) il solitario, un videogioco i cui tasti sono sconosciuti, il riconoscimento di volti in una fotografia, il cruciverba e un taxi a guida autonoma.
3. Tipo di agente. Per ognuno di questi comportamenti di un taxi dire se è un agente reattivo semplice, con modello, basato su obiettivi o basato sull'utilità: (a) frena quando le luci dell'auto davanti sono rosse; (b) frena solo se si muove e c'è un passaggio da bassa ad alta intensità delle luci davanti, se non può cambiare corsia, ecc.; (c) guida verso una destinazione; (d) guida verso una destinazione tenendo conto del consumo di carburante.

Punto 1 - aspirapolvere con sensore di sporco rotto

(a) PEAS. Performance: quadrati puliti per passo, sull'orizzonte di 20 passi. Environment: due quadrati, ciascuno pulito o sporco. Actuators: ruote (Left, Right) e aspirazione (Suck), più NoOp. Sensors: sensore di posizione (il sensore di sporco è rotto).

(b) Proprietà dell'ambiente.

(c) Tipo di agente. Un agente reattivo semplice sceglie l'azione dalla sola percezione corrente, ma qui la percezione è solo A oppure B: l'azione sarebbe sempre la stessa per ogni quadrato (per esempio "aspira e basta" non lo fa mai muovere, "muoviti" non pulisce niente). Serve uno stato interno: un contatore che dice quante volte ha già aspirato nel quadrato corrente (e, volendo, una stima di quali quadrati sono puliti). È quindi un agente con stato interno (con modello dell'ambiente: la probabilità $p$ di riuscita) a differenza del reattivo semplice. Il comportamento delle slide "aspira due volte, poi cambia quadrato, qualunque sia il risultato" è proprio la politica con $k = 2$.

(d) Prestazione attesa. Con la politica $k$ e orizzonte $T = 20$, la prestazione dipende da $p$ (e dalla misura). Per $p = 1$ si calcola a mano: con $k = 1$: passo 1 Suck in $A$ ($1$ quadrato pulito), passo 2 Right ($1$), passo 3 Suck in $B$ ($2$), poi per 17 passi $2$ quadrati puliti: $1 + 1 + 2 + 17 \cdot 2 = 38$. Con $k = 2$: Suck in $A$ ($1$), Suck di nuovo ($1$, il quadrato è già pulito), Right ($1$), Suck in $B$ ($2$), poi 16 passi da $2$: $1 + 1 + 1 + 2 + 32 = 37$. Per $p < 1$ si calcola in modo esatto seguendo la catena di Markov sugli stati (posizione, $A$ sporco o no, $B$ sporco o no, aspirazioni fatte nel quadrato): a ogni passo si propaga la distribuzione di probabilità e si somma il valore atteso del punteggio del passo. Risultati ($T = 20$, valori attesi):

Il $k$ razionale cambia con $p$: $k = 1$ se Suck riesce sempre, $k = 2$ se riesce nell'80% dei casi (è la politica delle slide), $k = 3$ se riesce una volta su due. Aspirare di più costa passi senza muoversi, aspirare di meno rischia di lasciare sporco e di non tornare: la misura di prestazione e $p$ decidono l'agente razionale. Con $k$ grande l'agente non lascia più $A$ e $B$ resta sporco (la prestazione cala). Il calcolo esatto coincide con una simulazione di 100 000 partite per $p = 0{,}8$ (35,98; 36,16; 35,41; 34,48; 33,49).

Punto 2 - classificazione di cinque ambienti

Sono i casi usati dalle slide per far vedere che osservabilità (che cosa vedono i sensori) e conoscenza (che cosa sa l'agente delle regole) sono proprietà indipendenti: il solitario è noto ma parzialmente osservabile; il videogioco è ignoto ma completamente osservabile.

Punto 3 - tipo di agente nel taxi

Programma di verifica

import random
from fractions import Fraction

def valore_atteso(k, p, T=20):
    """Politica senza sensore di sporco: k volte Suck, poi un passo, e si ripete.
    Punteggio: +1 per ogni quadrato pulito a ogni passo. Calcolo esatto sulla catena di Markov."""
    dist = {('A', 1, 1, 0): Fraction(1)}   # (posizione, A sporco, B sporco, aspirazioni fatte qui) -> probabilità
    totale = Fraction(0)
    for _ in range(T):
        nuova = {}
        for (pos, dA, dB, n), pr in dist.items():
            if n < k:                                    # azione Suck
                sporco = dA if pos == 'A' else dB
                esiti = [(0, p), (1, 1 - p)] if sporco else [(0, 1)]
                for resta, q in esiti:
                    a = resta if pos == 'A' and sporco else dA
                    b = resta if pos == 'B' and sporco else dB
                    s = (pos, a, b, n + 1)
                    nuova[s] = nuova.get(s, 0) + pr * q
                    totale += pr * q * ((1 - a) + (1 - b))
            else:                                        # azione Move
                s = ('B' if pos == 'A' else 'A', dA, dB, 0)
                nuova[s] = nuova.get(s, 0) + pr
                totale += pr * ((1 - dA) + (1 - dB))
        dist = nuova
    return totale

for p in (Fraction(1), Fraction(4, 5), Fraction(1, 2)):
    print(p, [round(float(valore_atteso(k, p)), 2) for k in range(1, 6)])

Output:

1 [38.0, 37.0, 36.0, 35.0, 34.0]
4/5 [36.0, 36.17, 35.42, 34.48, 33.5]
1/2 [30.31, 32.41, 32.61, 32.23, 31.57]

L'uso di Fraction rende il calcolo esatto (niente errori di arrotondamento), e valore_atteso somma, a ogni passo, la probabilità di ogni stato per il punteggio del passo: è l'applicazione diretta della definizione di valore atteso.