i hi ha alguns dominis que es troben entre les millors paraules de moda del sector i per una bona raó. AI crearà 2,3 milions de llocs de treball el 2020 tenint en compte que el seu principal objectiu és permetre a les màquines imitar el comportament humà. Senar, no? Per tant, avui parlarem de Q Learning, el bloc bàsic de l’aprenentatge de reforç en l’ordre següent:
- Què és l'aprenentatge de reforç?
- Procés d’aprenentatge Q
- Equació de Bellman
- Procés de decisió de Markov
- Demostració de Q-Learning: NumPy
Què és l'aprenentatge de reforç?
Fem una ullada al nostre dia a dia. Realitzem nombroses tasques a l’entorn i algunes d’aquestes ens aporten recompenses mentre que altres no. Seguim buscant diferents camins i intentem esbrinar quin camí conduirà a recompenses i, en funció de la nostra acció, millorem les nostres estratègies per assolir els objectius. Els meus amics són una de les analogies més senzilles de l’aprenentatge de reforç.
Àrees d'interès clau:
- Medi ambient
- Acció
- Recompensa
- Estat
L’aprenentatge de reforç és la branca de l’aprenentatge automàtic que permet als sistemes aprendre dels resultats de les seves pròpies decisions. Resol un tipus particular de problema en què la presa de decisions és seqüencial i l'objectiu és a llarg termini.
Procés d’aprenentatge Q
Comprenem què és el que aprenem Q amb la nostra declaració de problemes aquí. Ens ajudarà a definir els components principals d’una solució d’aprenentatge de reforç, és a dir, agents, entorn, accions, recompenses i estats.
Analogia de fàbrica d’automòbils:
Som a una fàbrica d’automòbils plena de robots. Aquests robots ajuden els treballadors de la fàbrica transmetent les peces necessàries per muntar un cotxe. Aquestes diferents parts es troben en diferents llocs de la fàbrica en 9 estacions. Les peces inclouen xassís, rodes, tauler de control, motor, etc. Factory Master ha prioritzat la ubicació on s’instal·la el xassís com a màxima prioritat. Vegem la configuració aquí:
Estats:
La ubicació on es troba un robot en una instància concreta s’anomena estat. Ja que és fàcil codificar-lo en lloc de recordar-lo per noms. Mapem la ubicació amb números.
Accions:
Les accions no són res més que els moviments que fan els robots cap a qualsevol lloc. Tingueu en compte que un robot es troba a la ubicació L2 i les ubicacions directes a les quals es pot moure són L5, L1 i L3. Comprenem-ho millor si ho visualitzem:
com instal·lar PHP a Windows 7
Recompenses:
Es donarà una recompensa al robot per passar directament d’un estat a un altre. Per exemple, podeu arribar a L5 directament des de L2 i viceversa. Per tant, es proporcionarà una recompensa d’1 en qualsevol dels casos. Vegem la taula de recompenses:
Recordeu quan Factory Master va prioritzar la ubicació del xassís. Era L7, de manera que incorporarem aquest fet a la nostra taula de recompenses. Per tant, assignarem un nombre molt gran (999 en el nostre cas) a la ubicació (L7, L7).
Equació de Bellman
Ara suposem que un robot ha d’anar del punt A al B. Triarà el camí que donarà una recompensa positiva. Per això suposem que proporcionem una recompensa en termes de petjada perquè segueixi.
java què és una variable d'instància
Però, què passa si el robot parteix d’algun lloc intermedi on pot veure dos o més camins. Per tant, el robot no pot prendre cap decisió i això passa principalment perquè no posseeix cap memòria . Aquí és on apareix l’equació de Bellman.
V (s) = màxim (R (s, a) + & # 120632V (s ’))
On:
- s = un estat concret
- a = acció
- s '= estat al qual passa el robot des de s
- & # 120632 = factor de descompte
- R (s, a) = una funció de recompensa que pren un estat (s) i una acció (a) i genera un valor de recompensa
- V (s) = valor d’estar en un estat concret
Ara, el bloc que hi ha a sota de la destinació tindrà una recompensa d’1, que és la recompensa més alta. Però, què passa amb l’altre bloc? Bé, aquí és on entra el factor de descompte. Suposem un factor de descompte de 0,9 i omplim tots els blocs un per un.
Procés de decisió de Markov
Imagineu-vos que un robot es troba al bloc taronja i que ha d’arribar a la destinació. Però fins i tot si hi ha una lleu disfunció, el robot es confondrà sobre quin camí seguir en lloc de pujar.
Per tant, hem de modificar el procés de presa de decisions. Ha de fer-ho Parcialment aleatori i En part sota el control del robot . Parcialment aleatori perquè no sabem quan el robot funcionarà i parcialment sota control perquè encara és decisió del robot. I això constitueix la base per al procés de decisió de Markov.
Un procés de decisió de Markov (MDP) és un procés de control estocàstic discret. Proporciona un marc matemàtic per modelar la presa de decisions en situacions en què els resultats són en part aleatoris i en part sota el control d’un decisor.
Per tant, farem servir la nostra equació original de Bellman i hi farem canvis. El que no sabem és el següent estat, és a dir. s ’. El que sabem és totes les possibilitats d’un gir i canviem l’equació.
V (s) = màxim (R (s, a) + & # 120632 V (s ’))
V (s) = màx (R (s, a) + & # 120632 & Sigmas 'P (s, a, s ’) V (s)))
P (s, a, s ’): Probabilitat de passar de l'estat s a s ' amb acció a
& Sigmas 'P (s, a, s ’) V (s): Expectatives aleatòries del robot
V (s) = màx (R (s, a) + & # 120632 ((0,8 V (habitació.)amunt)) + (0,1 V (habitacióavall) + ....))
Ara, passem a Q Learning. Q-Learning planteja una idea d’avaluar la qualitat d’una acció que es porta a terme per passar a un estat en lloc de determinar el possible valor de l’estat al qual s’està traslladant.
Això és el que aconseguim si incorporem la idea d'avaluar la qualitat de les accions per passar a un estat determinat. De l’equació de Bellman actualitzada si les eliminem màx component, assumim només una petjada per a una possible acció que no és res més que el Qualitat de l’acció.
Q (s, a) = (R (s, a) + & # 120632 & Sigmas 'P (s, a, s ’) V (s)))
En aquesta equació que quantifica la qualitat de l'acció, podem suposar que V (s) és el màxim de tots els valors possibles de Q (s, a). Per tant, substituïm v (s ’) per una funció de Q ().
Q (s, a) = (R (s, a) + & # 120632 & Sigmas 'P (s, a, s ’) Q màx (s ’, a’))
Estem a un pas de la nostra equació final de Q Learning. Introduirem un Diferència temporal per calcular els valors Q respecte als canvis de l'entorn al llarg del temps. Però, com observem el canvi de Q?
TD (s, a) = (R (s, a) + & # 120632 & Sigmas 'P (s, a, s ’) Q màx (s ’, a’)) - Q (s, a)
Recalcem la nova Q (s, a) amb la mateixa fórmula i li restem la Q (s, a) anteriorment coneguda. Per tant, l’equació anterior es converteix en:
Qt(s, a) = Qt-1(s, a) + α TDt(s, a)
Qt(s, a) = Valor Q actual
Qt(s, a) = Qt-1(s, a) + α (R (s, a) + & # 120632 Q màx (s ’, a’)-Qt-1(s, a))
Demostració d'aprenentatge Q: NumPy
Vaig a utilitzar NumPy per demostrar com funciona Q Learning.
com obtenir la longitud de la matriu javascript
Pas 1: importacions, paràmetres, estats, accions i recompenses
import numpy com np gamma = 0,75 # Factor de descompte alfa = 0,9 # Taxa d'aprenentatge location_to_state = {'L1': 0, 'L2': 1, 'L3': 2, 'L4': 3, 'L5': 4, ' L6 ': 5,' L7 ': 6,' L8 ': 7,' L9 ': 8} accions = [0,1,2,3,4,5,6,7,8] recompenses = np.array ( [[0,1,0,0,0,0,0,0,0,0], [1,0,1,0,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,0,1,0,0,0,1,0], [0,0,0,0, 1,0,1,0,1], [0,0,0,0,0,0,0,0,1,0]])Pas 2: mapeu els índexs a les ubicacions
state_to_location = dict ((estat, ubicació) per a la ubicació, estat a location_to_state.items ())
Pas 3: Obteniu una ruta òptima mitjançant el procés d'aprenentatge Q
def get_optimal_route (start_location, end_location): rewards_new = np.copy (recompenses) ending_state = location_to_state [end_location] rewards_new [ending_state, ending_state] = 999 Q = np.array (np.zeros ([9,9])) # Q- Procés d’aprenentatge per a l’interval (1000): # Recollida d’un estat aleatori current_state = np.random.randint (0,9) # Python exclou el límit superior playable_actions = [] # Iterant a través de la nova matriu de recompenses per a j en l’interval ( 9): if rewards_new [current_state, j]> 0: playable_actions.append (j) # Tria una acció aleatòria que ens portarà al següent estat 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] # Actualització del valor Q mitjançant l'equació de Bellman Q [current_state, next_state] + = alpha * TD # Inicialitzeu la ruta òptima amb la ruta d’ubicació inicial = [start_location] #Initialize next_location amb la ubicació inicial next_location = estrella t_location # No sabem sobre el nombre exacte d'iteracions necessàries per arribar a la ubicació final, per tant, mentre que el bucle serà una bona opció per a la iteració mentre (next_location! = end_location): # Obtingueu l'estat inicial starting_state = location_to_state [start_location] # Obteniu el valor Q més alt relacionat amb l'estat inicial next_state = np.argmax (Q [start_state,]) # Tenim l'índex del següent estat. Però necessitem la lletra corresponent. next_location = state_to_location [next_state] route.append (next_location) # Actualitzeu la ubicació inicial per a la següent iteració start_location = següent_locació ruta de retorn
Pas 4: imprimiu la ruta
print (get_optimal_route ('L1', 'L9'))Sortida:
Amb això, arribem al final del Q-Learning. Espero que conegueu el funcionament de Q Learning juntament amb les diverses dependències que hi ha, com ara la diferència temporal, l’equació de Bellman i molt més.
D’Edureka us permet dominar tècniques com l'aprenentatge supervisat, l'aprenentatge sense supervisió i el processament del llenguatge natural. Inclou formació sobre els darrers avenços i enfocaments tècnics en intel·ligència artificial i aprenentatge automàtic, com ara aprenentatge profund, models gràfics i aprenentatge de reforç.