Q Apprendimento: tutto ciò che devi sapere sull'apprendimento per rinforzo

Questo articolo fornisce una conoscenza dettagliata e completa del Q-Learning attraverso una bellissima analogia del Reinforcement Learning tramite codice Python.

e sono alcuni dei domini che sono tra le migliori parole d'ordine del settore e per una buona ragione. L'intelligenza artificiale creerà 2,3 milioni di posti di lavoro entro il 2020, considerando che il suo obiettivo principale è consentire alle macchine di imitare il comportamento umano. Strano non è vero? Quindi, oggi discuteremo del Q Learning, l'elemento costitutivo del Reinforcement Learning nel seguente ordine:

Cos'è l'apprendimento per rinforzo?

Diamo uno sguardo alla nostra vita quotidiana. Eseguiamo numerose attività nell'ambiente e alcune di queste attività ci portano ricompense mentre altre no. Continuiamo a cercare percorsi diversi e proviamo a scoprire quale percorso porterà a ricompense e in base alla nostra azione miglioriamo le nostre strategie per il raggiungimento degli obiettivi. Questa, amici miei, è una delle più semplici analogie del Reinforcement Learning.





Principali aree di interesse:

  • Ambiente
  • Azione
  • Ricompensa
  • Stato

apprendimento per rinforzo - q apprendimento



L'apprendimento per rinforzo è la branca dell'apprendimento automatico che consente ai sistemi di apprendere dai risultati delle proprie decisioni. Risolve un particolare tipo di problema in cui il processo decisionale è sequenziale e l'obiettivo è a lungo termine.

Processo di Q-Learning

Capiamo cosa sta imparando Q con la nostra dichiarazione del problema qui. Ci aiuterà a definire i componenti principali di una soluzione di apprendimento per rinforzo, ovvero agenti, ambiente, azioni, ricompense e stati.

Analogia della fabbrica di automobili:



Siamo in una fabbrica di automobili piena di robot. Questi robot aiutano gli operai della fabbrica trasportando le parti necessarie per assemblare un'auto. Queste diverse parti si trovano in posizioni diverse all'interno della fabbrica in 9 stazioni. Le parti includono telaio, ruote, cruscotto, motore e così via. Factory Master ha dato la priorità alla posizione in cui viene installato lo chassis come priorità più alta. Diamo un'occhiata alla configurazione qui:

Stati:

La posizione in cui è presente un robot in una particolare istanza è chiamata stato. Dal momento che è facile codificarlo piuttosto che ricordarlo per nome. Mappiamo la posizione sui numeri.

Azioni:

Le azioni non sono altro che le mosse effettuate dai robot in qualsiasi luogo. Considera, un robot si trova nella posizione L2 e le posizioni dirette verso le quali può spostarsi sono L5, L1 e L3. Comprendiamolo meglio se visualizziamo questo:

Ricompense:

Verrà data una ricompensa al robot per il passaggio diretto da uno stato all'altro. Ad esempio, puoi raggiungere L5 direttamente da L2 e viceversa. Quindi, in entrambi i casi verrà fornita una ricompensa di 1. Diamo un'occhiata alla tabella dei premi:

Ricordare quando il Factory Master ha dato la priorità alla posizione del telaio. Era L7, quindi incorporeremo questo fatto nella nostra tabella dei premi. Quindi, assegneremo un numero molto grande (999 nel nostro caso) nella posizione (L7, L7).

trasforma l'oggetto in array php

Equazione di Bellman

Supponiamo ora che un robot debba andare dal punto A al punto B. Sceglierà il percorso che produrrà una ricompensa positiva. Per questo supponiamo di fornire una ricompensa in termini di impronta da seguire.

installa php su Windows 7

Ma cosa succede se il robot parte da un punto intermedio in cui può vedere due o più percorsi? Il robot non può quindi prendere una decisione e ciò accade principalmente perché non possiede un memoria . È qui che entra in gioco l'equazione di Bellman.

V (s) = max (R (s, a) + & # 120632V (s '))

Dove:

  • s = uno stato particolare
  • a = azione
  • s '= stato a cui il robot va da s
  • & # 120632 = fattore di sconto
  • R (s, a) = una funzione di ricompensa che prende uno stato (i) e un'azione (a) e fornisce un valore di ricompensa
  • V (s) = valore dell'essere in uno stato particolare

Ora il blocco sotto la destinazione avrà una ricompensa di 1, che è la ricompensa più alta, ma per quanto riguarda l'altro blocco? Bene, è qui che entra in gioco il fattore di sconto. Supponiamo un fattore di sconto di 0,9 e riempiamo tutti i blocchi uno per uno.

Processo decisionale di Markov

Immagina che un robot si trovi sul blocco arancione e debba raggiungere la destinazione. Ma anche se c'è una leggera disfunzione, il robot sarà confuso su quale percorso prendere piuttosto che salire.

Quindi dobbiamo modificare il processo decisionale. Deve Parzialmente casuale e In parte sotto il controllo del robot . In parte casuale perché non sappiamo quando il robot non funzionerà e in parte sotto controllo perché è ancora una decisione del robot. E questo costituisce la base per il processo decisionale di Markov.

Un processo decisionale di Markov (MDP) è un processo di controllo stocastico a tempo discreto. Fornisce un quadro matematico per modellare il processo decisionale in situazioni in cui i risultati sono in parte casuali e in parte sotto il controllo di un decisore.

Quindi useremo la nostra equazione di Bellman originale e apporteremo delle modifiche. Quello che non sappiamo è il prossimo stato, ad es. S'. Quello che sappiamo sono tutte le possibilità di una svolta e cambiamo l'equazione.

V (s) = max (R (s, a) + & # 120632 V (s ’))

V (s) = max (R (s, a) + & # 120632 &SigmaS'P (s, a, s ') V (s '))

P (s, a, s '): Probabilità di trasferirsi dallo stato S per S' con l'azione per

&SigmaS'P (s, a, s ') V (s '): Aspettative di casualità del robot

V (s) = max (R (s, a) + & # 120632 ((0,8 V (roomsu)) + (0,1 V (roomgiù) +….))

Ora, passiamo a Q Learning. Il Q-Learning propone l'idea di valutare la qualità di un'azione intrapresa per spostarsi in uno stato piuttosto che determinare il possibile valore dello stato in cui viene spostato.

Questo è ciò che otteniamo se incorporiamo l'idea di valutare la qualità delle azioni per passare a un certo stato s '. Dall'equazione di Bellman aggiornata se li rimuoviamo max componente, stiamo assumendo solo un'impronta per l'azione possibile che non è altro che il Qualità dell'azione.

Q (s, a) = (R (s, a) + & # 120632 &SigmaS'P (s, a, s ') V (s '))

In questa equazione che quantifica la qualità dell'azione, possiamo assumere che V (s) è il massimo di tutti i valori possibili di Q (s, a). Quindi sostituiamo v (s ') con una funzione di Q ().

Q (s, a) = (R (s, a) + & # 120632 &SigmaS'P (s, a, s ') max Q (s ’, a’))

Siamo solo a un passo dalla nostra ultima equazione di Q Learning. Stiamo per introdurre un file Differenza temporale calcolare i valori Q rispetto ai cambiamenti dell'ambiente nel tempo. Ma come osserviamo il cambiamento di Q?

TD (s, a) = (R (s, a) + & # 120632 &SigmaS'P (s, a, s ') max Q (s ’, a’)) - Q (s, a)

Ricalcoliamo i nuovi Q (s, a) con la stessa formula e sottraiamo i Q (s, a) precedentemente noti da esso. Quindi, l'equazione di cui sopra diventa:

Qt(s, a) = Qt-1(s, a) + α TDt(s, a)

Qt(s, a) = Valore Q attuale

Qt-1(s, a) = Valore Q precedente

Qt(s, a) = Qt-1(s, a) + α (R (s, a) + & # 120632 max Q (s ’, a’)-Qt-1(s, a))

Q Demo di apprendimento: NumPy

Userò NumPy per dimostrare come funziona Q Learning.

Passaggio 1: importazioni, parametri, stati, azioni e premi

importa numpy come np gamma = 0.75 # Fattore di sconto alpha = 0.9 # Tasso di apprendimento location_to_state = {'L1': 0, 'L2': 1, 'L3': 2, 'L4': 3, 'L5': 4, ' L6 ': 5,' L7 ': 6,' L8 ': 7,' L9 ': 8} azioni = [0,1,2,3,4,5,6,7,8] ricompense = np.array ( [[0,1,0,0,0,0,0,0,0], [1,0,1,0,0,0,0,0,0], [0,1,0,0, 0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,1,0,0,0,0,0,1,0] , [0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,1,0], [0,0,0,0, 1,0,1,0,1], [0,0,0,0,0,0,0,1,0]])

Passaggio 2: mappa gli indici sulle posizioni

state_to_location = dict ((state, location) for location, state in location_to_state.items ())

Passaggio 3: ottieni un percorso ottimale utilizzando Q Learning Process

def get_optimal_route (start_location, end_location): rewards_new = np.copy (rewards) terminando_state = location_to_state [end_location] rewards_new [finendo_state, finendo_state] = 999 Q = np.array (np.zeros ([9,9])) # Q- Processo di apprendimento per i in range (1000): # Raccogliere uno stato casuale current_state = np.random.randint (0,9) # Python esclude il limite superiore playable_actions = [] # Iterando attraverso la nuova matrice dei premi per j in range ( 9): if rewards_new [current_state, j]> 0: playable_actions.append (j) # Scegli un'azione casuale che ci porterà allo stato successivo next_state = np.random.choice (playable_actions) # Computing Temporal Difference TD = rewards_new [current_state , next_state] + gamma * Q [next_state, np.argmax (Q [next_state,])] - Q [current_state, next_state] # Aggiornamento del valore Q utilizzando l'equazione di Bellman Q [current_state, next_state] + = alpha * TD # Inizializza il percorso ottimale con la posizione di partenza route = [start_location] #Initialize next_location con la posizione di partenza next_location = star t_location # Non conosciamo il numero esatto di iterazioni necessarie per raggiungere la posizione finale, quindi il ciclo while sarà una buona scelta per l'iterazione while (posizione_successiva! = posizione_fine): # Recupera lo stato iniziale stato_inizio = posizione_to_stato [posizione_inizio] # Recupera il valore Q più alto relativo allo stato iniziale next_state = np.argmax (Q [starting_state,]) # Abbiamo ottenuto l'indice dello stato successivo. Ma abbiamo bisogno della lettera corrispondente. next_location = state_to_location [next_state] route.append (next_location) # Aggiorna la posizione di partenza per l'iterazione successiva start_location = next_location return route

Passaggio 4: stampa il percorso

print (get_optimal_route ('L1', 'L9'))

Produzione:

può un costruttore essere privato

Con questo, arriviamo alla fine del Q-Learning. Spero che tu abbia imparato a conoscere il funzionamento di Q Learning insieme alle varie dipendenze come la differenza temporale, l'equazione di Bellman e altro ancora.

Edureka's ti rende esperto in tecniche come l'apprendimento supervisionato, l'apprendimento non supervisionato e l'elaborazione del linguaggio naturale. Include la formazione sugli ultimi progressi e approcci tecnici in Intelligenza Artificiale e Machine Learning come Deep Learning, Modelli grafici e Reinforcement Learning.