Q Apprendimento in Python: che cos'è, definizioni [Esempi di codifica]

L'apprendimento per rinforzo è quando un agente di apprendimento impara a comportarsi in modo ottimale in base al suo ambiente attraverso interazioni costanti. L'agente attraversa varie situazioni, note anche come stati. Come avrai intuito, l'apprendimento per rinforzo ha molte applicazioni nel nostro mondo. Scopri di più se sei interessato a saperne di più sugli algoritmi di data science.

Inoltre, ha molti algoritmi, tra i più popolari c'è l'apprendimento Q. In questo articolo, discuteremo cos'è questo algoritmo e come funziona.

Quindi, senza ulteriori indugi, iniziamo.

Che cos'è l'apprendimento Q?

L'apprendimento Q è un algoritmo di apprendimento per rinforzo e si concentra sulla ricerca della migliore linea d'azione per una particolare situazione. È fuori policy perché le azioni da cui apprende la funzione di apprendimento Q sono al di fuori della policy esistente, quindi non ne richiede una. Si concentra sull'apprendimento di una politica che aumenti la sua ricompensa totale. È una semplice forma di apprendimento per rinforzo che utilizza valori di azione (o valori Q) per migliorare il comportamento dell'agente di apprendimento.

L'apprendimento Q è uno degli algoritmi più popolari nell'apprendimento per rinforzo, poiché è facile da comprendere e implementare. La "Q" nell'apprendimento Q rappresenta la qualità. Come accennato in precedenza, l'apprendimento Q si concentra sulla ricerca dell'azione migliore per una situazione particolare. E la qualità mostra quanto sia utile un'azione specifica e quale ricompensa può aiutarti a raggiungere.

Definizioni importanti

Prima di iniziare a discutere di come funziona, dovremmo prima dare un'occhiata ad alcuni concetti essenziali dell'apprendimento di q. Iniziamo.

Q-Valori

I valori Q sono anche noti come valori di azione. Sono rappresentati da Q(S, A) e forniscono una stima di quanto sia buona l'azione A da intraprendere nello stato S. Il modello calcolerà questa stima in modo iterativo utilizzando la regola di aggiornamento della differenza temporale di cui abbiamo discusso in seguito in questa sezione.

Episodi e premi

Un agente inizia da uno stato iniziale, attraversa diverse transizioni, quindi passa dal suo stato attuale a quello successivo in base alle sue azioni e al suo ambiente. Ogni volta che l'agente agisce, ottiene una ricompensa. E quando non sono possibili transizioni, è il completamento dell'episodio.

Aggiornamento TD (differenza temporale)

Ecco la regola TD-Update o Differenza temporale:

Q(S,A) Q(S,A) + (R + Q(S',A')-Q(S,A))

Qui, S rappresenta lo stato corrente dell'agente, mentre S' rappresenta lo stato successivo. A rappresenta l'azione corrente, A' rappresenta la seguente migliore azione in base alla stima del valore Q, R mostra la ricompensa corrente in base all'azione in corso, rappresenta il fattore di sconto e mostra la lunghezza del passo.

Leggi anche: Prerequisito per Data Science. Come cambia nel tempo?

Esempio di Q Learning Python

Il modo migliore per comprendere l'apprendimento di Q Python è vedere un esempio. In questo esempio, utilizziamo l'ambiente palestra di OpenAI e alleniamo il nostro modello con esso. Prima di tutto, dovrai installare l'ambiente. Puoi farlo con il seguente comando:

palestra di installazione pip

Ora importeremo le librerie di cui avremo bisogno per questo esempio:

importare palestra

importare itertools

importa matplotlib

importa matplotlib.style

importa numpy come np

importa panda come pd

importazione sist

dalle raccolte import defaultdict

da windy_gridworld import WindyGridworldEnv

importare la stampa

matplotlib.style.use('ggplot')

Senza le librerie necessarie, non saresti in grado di eseguire queste operazioni con successo. Dopo aver importato le librerie, creeremo l'ambiente:

env = WindyGridworldEnv()

Ora creeremo la politica -greedy:

def createEpsilonGreedyPolicy(Q, epsilon, num_actions):

“””

Crea una politica basata su epsilon-greedy

su una data funzione Q ed epsilon.

Restituisce una funzione che prende lo stato

come input e restituisce le probabilità

per ogni azione sotto forma di un array numpy

della lunghezza dello spazio d'azione (insieme di possibili risposte).

“””

def policyFunction(state):

Azione_probabilità = np.ones(num_azioni,

dtype = float) * epsilon / num_actions

best_action = np.argmax(Q[stato])

Azione_probabilità[miglior_azione] += (1.0 – epsilon)

restituisce Azione_probabilità

politica di restituzioneFunzione

Ecco il codice per costruire un modello q-learning:

def qLearning(env, num_episodes, discount_factor = 1.0,

alfa = 0,6, epsilon = 0,1):

“””

Algoritmo Q-Learning: controllo TD fuori policy.

Trova la politica avida ottimale mentre migliora

seguendo una politica epsilon-greedy”””

# Funzione valore azione

# Un dizionario annidato che mappa

# stato -> (azione -> valore-azione).

Q = defaultdict(lambda: np.zeros(env.action_space.n))

# Tiene traccia di statistiche utili

stats = plotting.EpisodeStats(

lunghezza_episodio = np.zeros(num_episodi),

episodio_ricompense = np.zeros(num_episodes))

# Creare una funzione di politica avida di epsilon

# in modo appropriato per lo spazio di azione ambientale

policy = createEpsilonGreedyPolicy(Q, epsilon, env.action_space.n)

# Per ogni episodio

per ith_episode nell'intervallo(num_episodes):

# Ripristina l'ambiente e scegli la prima azione

stato = ambiente.reset()

per t in itertools.count():

# ottieni le probabilità di tutte le azioni dallo stato corrente

action_probabilities = politica(stato)

# scegli l'azione in base a

# la distribuzione di probabilità

azione = np.random.choice(np.arange(

len(azione_probabilità)),

p = azione_probabilità)

# agisci e ottieni ricompensa, passa allo stato successivo

stato_successivo, ricompensa, fatto, _ = env.step(azione)

# Aggiorna le statistiche

stats.episode_rewards[i_episode] += ricompensa

stats.episode_lengths[i_episode] = t

# Aggiornamento TD

migliore_azione_successiva = np.argmax(Q[stato_successivo])

td_target = ricompensa + fattore_sconto * Q[next_state][best_next_action]

td_delta = td_target – Q[stato][azione]

Q[stato][azione] += alfa * td_delta

# done è True se l'episodio è terminato

se fatto:

rottura

stato = stato_successivo

ritorno Q, statistiche

Alleniamo ora il modello:

Q, statistiche = qApprendimento(env, 1000)

Dopo aver creato e addestrato il modello, possiamo tracciare le statistiche essenziali dello stesso:

plotting.plot_episode_stats(stats)

Utilizzare questo codice per eseguire il modello e tracciare il grafico. Che tipo di risultati vedi? Condividi i tuoi risultati con noi e, in caso di confusione o dubbi, faccelo sapere.

Leggi anche: Algoritmi di apprendimento automatico per la scienza dei dati

Impara i corsi di scienza dei dati dalle migliori università del mondo. Guadagna programmi Executive PG, programmi di certificazione avanzati o programmi di master per accelerare la tua carriera.

Pensieri finali

Quando tracci il grafico, vedrai che la ricompensa per episodio aumenta progressivamente nel tempo. E dopo alcuni episodi, la trama riflette anche che livella il limite elevato di ricompense per episodio. Cosa indica questo?

Significa che il tuo modello ha imparato ad aumentare la ricompensa totale che può guadagnare in un episodio assicurandosi che si comporti in modo ottimale. Devi anche aver visto perché q learning Python vede applicazioni in così tanti settori e aree.