Concetti di IA in Python

Apprendimento per rinforzo: value iteration e Q-learning in Python

Nell'apprendimento per rinforzo un agente agisce in un ambiente e riceve ricompense. Impara quanto è buono ogni stato o azione, così può scegliere le azioni che portano più ricompensa nel tempo.

Il concetto in parole semplici

Nell'apprendimento per rinforzo un agente agisce in un ambiente e riceve ricompense. Impara quanto è buono ogni stato o azione, così può scegliere le azioni che portano più ricompensa nel tempo.

Insegna a un agente a raggiungere un obiettivo: calcola i valori degli stati con la value iteration, poi imparali per tentativi ed errori con il Q-learning.

Idee chiave

Il fattore di sconto γ rende più preziose le ricompense che arrivano prima.
La value iteration richiede un modello dell'ambiente; il Q-learning impara dall'esperienza.
Q(s, a) è la ricompensa totale attesa eseguendo l'azione a nello stato s.
Serve esplorazione (qui il 20% di mosse casuali) perché l'agente scopra l'obiettivo.

Quando si usa?

Capire cosa succede dentro le reti neurali e le librerie di IA.
Imparare l'idea prima di implementarla nelle sfide corrispondenti.
Prepararti a corsi di machine learning, colloqui e progetti.

Guardalo in azione

Premi Avvia a sinistra per diffondere i valori dall'obiettivo a tutta la griglia. A destra, guarda l'agente imparare lo stesso percorso per tentativi ed errori.

Codice di esempio

Esegui codice →

main.py

import random

# A corridor of 5 cells: start in cell 0, reward +10 for reaching cell 4.
N, GOAL, GAMMA = 5, 4, 0.9

# Value iteration: a cell is worth its reward plus the discounted best neighbour.
values = [0.0] * N
for _ in range(50):
    values = [0.0 if s == GOAL else max((10 if n == GOAL else 0) + GAMMA * values[n]
              for n in (max(0, s - 1), min(N - 1, s + 1))) for s in range(N)]
print("state values:", [round(v, 2) for v in values])

# Q-learning learns the same thing from trial and error.
random.seed(0)
Q = [[0.0, 0.0] for _ in range(N)]   # actions: 0 = left, 1 = right
for episode in range(200):
    s = 0
    while s != GOAL:
        a = random.randrange(2) if random.random() < 0.2 else Q[s].index(max(Q[s]))
        n = max(0, s - 1) if a == 0 else min(N - 1, s + 1)
        reward = 10 if n == GOAL else 0
        target = reward + (0 if n == GOAL else GAMMA * max(Q[n]))
        Q[s][a] += 0.5 * (target - Q[s][a])   # move the estimate toward the target
        s = n
print("best action per cell:", ["right" if q[1] >= q[0] else "left" for q in Q[:GOAL]])
print("Q(0, right):", round(Q[0][1], 2))

Output previsto

state values: [7.29, 8.1, 9.0, 10.0, 0.0]
best action per cell: ['right', 'right', 'right', 'right']
Q(0, right): 7.29

Come funziona

La value iteration ripete l'aggiornamento di Bellman, in cui il valore di una cella è la ricompensa migliore più il valore scontato della cella successiva; si ottengono 10, 9, 8.1 e 7.29 allontanandosi dall'obiettivo. Il Q-learning non conosce le regole. Dopo ogni passo sposta la stima verso reward + γ·max Q(next) e impara ad andare sempre a destra.

Modifica i valori ed esegui il programma nel compilatore Python online CodeUtility senza installare Python.

Esercizi pratici

Modifica gli input e verifica i casi limite prima di usare dataset più grandi.

Cambia gli input o i pesi e prevedi l'output prima di eseguire.
Stampa i valori intermedi per seguire ogni passo del calcolo.
Risolvi le sfide collegate qui sotto per implementare l'idea da solo.

Esegui nell’IDE Python →

Esercitati con una sfida

Usa ciò che questa lezione spiega per risolvere un problema reale. Ogni sfida gira nel browser, con test immediati e una revisione dell'IA.

Tutte le sfide