Q Leren: alles wat u moet weten over Reinforcement Learning

Dit artikel biedt een gedetailleerde en uitgebreide kennis van Q-Learning door een mooie analogie van Reinforcement Learning via Python-code.

en zijn een paar domeinen die tot de belangrijkste modewoorden in de branche behoren en om een ​​goede reden. AI zal tegen 2020 2,3 miljoen banen creëren, aangezien het belangrijkste doel is om machines in staat te stellen menselijk gedrag na te bootsen. Vreemd is het niet? Dus vandaag gaan we Q Learning, de bouwsteen van Reinforcement Learning, in deze volgorde bespreken:



Wat is Reinforcement Learning?

Laten we eens kijken naar ons dagelijkse leven. We voeren tal van taken uit in de omgeving en sommige van die taken leveren ons beloningen op, andere niet. We blijven zoeken naar verschillende paden en proberen erachter te komen welk pad tot beloningen zal leiden en op basis van onze actie verbeteren we onze strategieën om doelen te bereiken. Dit, mijn vrienden, is een van de eenvoudigste analogieën van Reinforcement Learning.



Belangrijkste interessegebieden:

  • Milieu
  • Actie
  • Beloning
  • Staat

versterkend leren - q leren



Reinforcement Learning is de tak van machine learning die systemen in staat stelt te leren van de resultaten van hun eigen beslissingen. Het lost een bepaald soort probleem op waarbij de besluitvorming opeenvolgend is en het doel de lange termijn is.

geef waarde door en geef verwijzing java door

Q-leerproces

Laten we begrijpen wat Q leert met onze probleemstelling hier. Het zal ons helpen om de belangrijkste componenten van een leeroplossing voor versterking te definiëren, d.w.z. agenten, omgeving, acties, beloningen en toestanden.

Automobile Factory Analogie:



We zijn bij een autofabriek vol robots. Deze robots helpen de fabrieksarbeiders door de benodigde onderdelen te vervoeren die nodig zijn om een ​​auto te monteren. Deze verschillende onderdelen bevinden zich op verschillende locaties in de fabriek in 9 stations. De onderdelen zijn onder meer chassis, wielen, dashboard, motor enzovoort. Factory Master heeft prioriteit gegeven aan de locatie waar het chassis wordt geïnstalleerd als de hoogste prioriteit. Laten we de instellingen hier eens bekijken:

Staten:

De locatie waarop een robot op een bepaald exemplaar aanwezig is, wordt zijn toestand genoemd. Omdat het gemakkelijk is om het te coderen in plaats van het met namen te onthouden. Laten we de locatie toewijzen aan cijfers.

Acties:

Acties zijn niets anders dan de bewegingen die de robots naar elke locatie maken. Bedenk dat een robot zich op de L2-locatie bevindt en de directe locaties waar deze naartoe kan bewegen zijn L5, L1 en L3. Laten we dit beter begrijpen als we dit visualiseren:

Beloningen:

Er wordt een beloning aan de robot gegeven als hij rechtstreeks van de ene staat naar de andere gaat. U kunt L5 bijvoorbeeld rechtstreeks vanuit L2 bereiken en vice versa. Er wordt dus in beide gevallen een beloning van 1 uitgekeerd. Laten we eens kijken naar de beloningstabel:

Onthoud toen de fabrieksmeester prioriteit gaf aan de chassislocatie. Het was L7, dus we gaan dit feit opnemen in onze beloningstabel. We zullen dus een heel groot nummer toewijzen (in ons geval 999) op de (L7, L7) locatie.

Bellman-vergelijking

Stel nu dat een robot van punt A naar punt B moet gaan. Hij kiest het pad dat een positieve beloning oplevert. Stel daarvoor dat we een beloning bieden in termen van voetafdruk die het kan volgen.

Maar wat als de robot ergens tussenin begint, waar hij twee of meer paden kan zien? De robot kan dus geen beslissing nemen en dit gebeurt vooral omdat hij geen geheugen . Dit is waar de Bellman-vergelijking in beeld komt.

__init__ in python

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

Waar:

  • s = een bepaalde staat
  • a = actie
  • s '= toestand waarnaar de robot gaat van s
  • & # 120632 = kortingsfactor
  • R (s, a) = een beloningsfunctie die een staat (en) en actie (a) aanneemt en een beloningswaarde uitvoert
  • V (s) = waarde van het zijn in een bepaalde staat

Nu krijgt het blok onder de bestemming een beloning van 1, wat de hoogste beloning is. Maar hoe zit het met het andere blok? Welnu, hier komt de kortingsfactor om de hoek kijken. Laten we uitgaan van een kortingsfactor van 0,9 en alle blokken een voor een vullen.

Markov beslissingsproces

Stel je voor dat een robot zich op het oranje blok bevindt en de bestemming moet bereiken. Maar zelfs als er een kleine storing is, zal de robot niet weten welk pad hij moet nemen in plaats van omhoog te gaan.

We moeten dus het besluitvormingsproces aanpassen. Het moet Gedeeltelijk willekeurig en Gedeeltelijk onder controle van de robot . Gedeeltelijk willekeurig omdat we niet weten wanneer de robot zal disfunctioneren en gedeeltelijk onder controle omdat het nog steeds de beslissing van de robot is. En dit vormt de basis voor het Markov-beslissingsproces.

Een Markov-beslissingsproces (MDP) is een discreet tijdstochastisch controleproces. Het biedt een wiskundig raamwerk voor het modelleren van besluitvorming in situaties waarin uitkomsten deels willekeurig zijn en deels onder controle staan ​​van een besluitvormer.

We gaan dus onze oorspronkelijke Bellman-vergelijking gebruiken en er wijzigingen in aanbrengen. Wat we niet weten is de volgende toestand, dwz. s ’. Wat we weten zijn alle mogelijkheden van een bocht en laten we de vergelijking veranderen.

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 ’): Waarschijnlijkheid om van staat te veranderen s naar s ' met actie naar

& Sigmas 'P (s, a, s ’) V (s ’): Toevalligheidsverwachtingen van Robot

V (s) = max (R (s, a) + & # 120632 ((0,8V (kameromhoog)) + (0,1V (kamernaar beneden) +….))

Laten we nu overgaan op Q Learning. Q-Learning stelt een idee voor om de kwaliteit te beoordelen van een actie die wordt ondernomen om naar een staat te gaan, in plaats van de mogelijke waarde te bepalen van de staat waarnaar deze wordt verplaatst.

Dit is wat we krijgen als we het idee opnemen om de kwaliteit van acties te beoordelen om naar een bepaalde staat te verhuizen. Van de bijgewerkte Bellman-vergelijking als we ze verwijderen max. hoogte component, gaan we uit van slechts één voetafdruk voor mogelijke actie die niets anders is dan de Kwaliteit van de actie.

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

In deze vergelijking die de kwaliteit van actie kwantificeert, kunnen we aannemen dat V (s) het maximum is van alle mogelijke waarden van Q (s, a). Dus laten we v (s ’) vervangen door een functie van Q ().

is hadoop gemakkelijk te leren

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

We zijn slechts een stap in de buurt van onze laatste vergelijking van Q Learning. We gaan een Temporeel verschil om de Q-waarden te berekenen met betrekking tot de veranderingen in de omgeving in de tijd. Maar hoe observeren we de verandering in Q?

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

We herberekenen de nieuwe Q (s, a) met dezelfde formule en trekken er de eerder bekende Q (s, a) van af. Dus de bovenstaande vergelijking wordt:

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

Qt(s, a) = Huidige Q-waarde

Qt-1(s, a) = Vorige Q-waarde

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

Q Learning Demo: NumPy

Ik ga gebruiken NumPy om te laten zien hoe Q Learning werkt.

Stap 1: invoer, parameters, statussen, acties en beloningen

import numpy als np gamma = 0.75 # Kortingsfactor alpha = 0.9 # Learning rate location_to_state = {'L1': 0, 'L2': 1, 'L3': 2, 'L4': 3, 'L5': 4, ' L6 ': 5,' L7 ': 6,' L8 ': 7,' L9 ': 8} actions = [0,1,2,3,4,5,6,7,8] rewards = 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]])

Stap 2: Wijs indices toe aan locaties

state_to_location = dict ((staat, locatie) voor locatie, staat in location_to_state.items ())

Stap 3: Verkrijg een optimale route met behulp van Q Learning Process

def get_optimal_route (start_location, end_location): rewards_new = np.copy (rewards) ending_state = location_to_state [end_location] rewards_new [ending_state, ending_state] = 999 Q = np.array (np.zeros ([9,9])) # Q- Leerproces voor i binnen bereik (1000): # Een willekeurige toestand oppakken current_state = np.random.randint (0,9) # Python sluit de bovengrens playable_actions = [] # Itereren door de nieuwe beloningsmatrix voor j binnen bereik ( 9): if rewards_new [current_state, j]> 0: playable_actions.append (j) # Kies een willekeurige actie die ons naar de volgende staat zal leiden next_state = np.random.choice (playable_actions) # Tijdsverschil berekenen TD = rewards_new [current_state , next_state] + gamma * Q [next_state, np.argmax (Q [next_state,])] - Q [current_state, next_state] # De Q-waarde bijwerken met behulp van de Bellman-vergelijking Q [current_state, next_state] + = alpha * TD # Initialiseer de optimale route met de startlocatie route = [start_location] #Initialize next_location met startlocatie next_location = star t_location # We weten niet precies hoeveel iteraties nodig zijn om de uiteindelijke locatie te bereiken, dus while loop is een goede keuze voor iteratie terwijl (next_location! = end_location): # Haal de startstatus op start_state = location_to_state [start_location] # Haal de hoogste Q-waarde op die betrekking heeft op de startstatus next_state = np.argmax (Q [start_state,]) # We hebben de index van de volgende staat. Maar we hebben de bijbehorende brief nodig. next_location = state_to_location [next_state] route.append (next_location) # Update de startlocatie voor de volgende iteratie start_location = next_location retourroute

Stap 4: Druk de route af

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

Uitgang:

Hiermee komen we aan het einde van Q-Learning. Ik hoop dat je de werking van Q Learning hebt leren kennen, samen met de verschillende afhankelijkheden die er zijn, zoals het temporele verschil, de Bellman-vergelijking en meer.

Edureka's maakt je bekwaam in technieken zoals leren onder toezicht, leren zonder toezicht en natuurlijke taalverwerking. Het omvat training over de nieuwste ontwikkelingen en technische benaderingen op het gebied van kunstmatige intelligentie en machine learning, zoals diep leren, grafische modellen en versterkend leren.