F-lärande: Allt du behöver veta om förstärkningslärande



Den här artikeln ger en detaljerad och omfattande kunskap om Q-Learning genom en vacker analogi av Reinforcement Learning via Python-kod.

och är några domäner som är bland de bästa motordorden i branschen och med goda skäl. AI kommer att skapa 2,3 miljoner jobb till 2020 med tanke på att huvudmålet är att göra det möjligt för maskiner att efterlikna mänskligt beteende. Udda är det inte? Så idag ska vi diskutera Q Learning, byggstenen för förstärkningslärande i följande ordning:

Vad är förstärkningslärande?

Låt oss ta en titt på vårt dagliga liv. Vi utför många uppgifter i miljön och några av dessa uppgifter ger oss belöningar medan andra inte gör det. Vi fortsätter att leta efter olika vägar och försöker ta reda på vilken väg som leder till belöningar och utifrån vår handling förbättrar vi våra strategier för att uppnå mål. Detta är mina vänner en av de enklaste analogierna med förstärkningslärande.





Viktiga intresseområden:

  • Miljö
  • Handling
  • Pris
  • stat

förstärkning lärande - q lärande



Förstärkningslärande är den gren av maskininlärning som tillåter system att lära av resultaten av sina egna beslut. Det löser en viss typ av problem där beslutsfattandet är sekventiellt och målet är långsiktigt.

Q-Learning Process

Låt oss förstå vad Q lär sig med vårt problemuttalande här. Det hjälper oss att definiera huvudkomponenterna i en förstärkningslärningslösning, dvs agenter, miljö, handlingar, belöningar och stater.

Bilfabriksanalogi:



Vi är på en bilfabrik fylld med robotar. Dessa robotar hjälper fabriksarbetarna genom att förmedla de delar som krävs för att montera en bil. Dessa olika delar finns på olika platser inom fabriken på 9 stationer. Delarna inkluderar chassi, hjul, instrumentbräda, motor och så vidare. Factory Master har prioriterat platsen där chassit installeras som högsta prioritet. Låt oss ta en titt på installationen här:

Stater:

Platsen där en robot är närvarande vid en viss instans kallas dess tillstånd. Eftersom det är lätt att koda det snarare än att komma ihåg det med namn. Låt oss kartlägga platsen till siffror.

vad är de 6 sätten att använda detta nyckelord?

Åtgärder:

Åtgärder är inget annat än de rörelser som görs av robotarna till någon plats. Tänk på att en robot befinner sig på L2-platsen och de direkta platserna som den kan förflytta sig till är L5, L1 och L3. Låt oss förstå detta bättre om vi visualiserar detta:

Belöningar:

En belöning kommer att ges till roboten för att gå direkt från en stat till en annan. Till exempel kan du nå L5 direkt från L2 och vice versa. Så en belöning på 1 kommer att ges i båda fallen. Låt oss ta en titt på belöningstabellen:

Kom ihåg när Factory Master prioriterade chassiplatsen. Det var L7, så vi ska införliva detta faktum i vår belöningstabell. Så vi tilldelar ett mycket stort antal (999 i vårt fall) på (L7, L7) platsen.

Bellman ekvation

Antag nu att en robot måste gå från punkt A till B. Den väljer den väg som ger en positiv belöning. För det antar att vi ger en belöning när det gäller fotavtryck för att den ska följa.

Men tänk om roboten börjar någonstans där den kan se två eller flera vägar. Roboten kan alltså inte fatta beslut och detta händer främst för att den inte har en minne . Det är här Bellman-ekvationen kommer in i bilden.

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

Var:

  • s = ett visst tillstånd
  • a = handling
  • s '= tillstånd till vilket roboten går från s
  • & # 120632 = rabattfaktor
  • R (s, a) = en belöningsfunktion som tar ett tillstånd (er) och åtgärd (a) och matar ut ett belöningsvärde
  • V (s) = värdet av att vara i ett visst tillstånd

Nu får blocket under destinationen en belöning på 1, vilket är den högsta belöningen, men hur är det med det andra blocket? Det är här rabattfaktorn kommer in. Låt oss anta en rabattfaktor på 0,9 och fylla alla blocken en efter en.

Markovs beslutsprocess

Föreställ dig att en robot är på det orange blocket och måste nå målet. Men även om det finns en liten dysfunktion kommer roboten att bli förvirrad över vilken väg man ska gå snarare än att gå upp.

Så vi måste ändra beslutsprocessen. Det måste Delvis slumpmässig och Delvis under robotens kontroll . Delvis slumpmässigt eftersom vi inte vet när roboten kommer att fungera och delvis under kontroll eftersom det fortfarande är robotens beslut. Och detta utgör basen för Markovs beslutsprocess.

En Markov-beslutsprocess (MDP) är en diskret tidstokastisk kontrollprocess. Det ger en matematisk ram för modellering av beslutsfattande i situationer där resultaten delvis är slumpmässiga och delvis under kontroll av en beslutsfattare.

Så vi ska använda vår ursprungliga Bellman-ekvation och göra ändringar i den. Vad vi inte vet är nästa tillstånd, dvs. s ’. Vad vi vet är alla möjligheter för en sväng och låt oss ändra ekvationen.

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

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

skillnaden mellan css och css3

P (s, a, s ’): Sannolikheten för att flytta från staten s till s ’ med handling till

& Sigmas ’P (s, a, s ’) V (s): Slumpmässiga förväntningar på robot

V (s) = max (R (s, a) + & # 120632 ((0,8V (rumupp)) + (0,1 V (rumner) + ....))

Låt oss nu övergå till Q-lärande. Q-Learning ger en idé om att bedöma kvaliteten på en åtgärd som vidtas för att flytta till ett tillstånd snarare än att bestämma det möjliga värdet av det tillstånd det flyttas till.

Detta är vad vi får om vi införlivar idén att bedöma kvaliteten på åtgärder för att flytta till ett visst tillstånd. Från den uppdaterade Bellman-ekvationen om vi tar bort dem max komponent, antar vi bara ett fotavtryck för eventuella åtgärder som inte är något annat än Kvalitet av åtgärden.

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

I denna ekvation som kvantifierar åtgärdens kvalitet kan vi anta att V (s) är det maximala av alla möjliga värden på Q (s, a). Så låt oss ersätta v (s) med en funktion av Q ().

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

Vi är bara ett steg nära vår slutliga Equation of Q Learning. Vi ska introducera en Temporal skillnad att beräkna Q-värdena med hänsyn till förändringarna i miljön över tiden. Men hur observerar vi förändringen i Q?

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

Vi beräknar om den nya Q (s, a) med samma formel och subtraherar tidigare kända Q (s, a) från den. Så ovanstående ekvation blir:

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

Ft(s, a) = Aktuellt Q-värde

Ft-1(s, a) = Tidigare Q-värde

c ++ sorteringsmatris i stigande ordning

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

Q Learning Demo: NumPy

Jag ska använda NumPy för att visa hur Q Learning fungerar.

Steg 1: Import, parametrar, tillstånd, åtgärder och belöningar

importera numpy som np gamma = 0,75 # Rabattfaktor alfa = 0,9 # Inlärningshastighet location_to_state = {'L1': 0, 'L2': 1, 'L3': 2, 'L4': 3, 'L5': 4, ' L6 ': 5,' L7 ': 6,' L8 ': 7,' L9 ': 8} åtgärder = [0,1,2,3,4,5,6,7,8] belöningar = np.matris ( [[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]])

Steg 2: Kartlägg index till platser

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

Steg 3: Få optimal väg med hjälp av Q-inlärningsprocessen

def get_optimal_route (startlocation, 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. nollor ([9,9])) # Q- Inlärningsprocess för i inom intervall (1000): # Plocka upp ett slumpmässigt tillstånd current_state = np.random.randint (0,9) # Python exkluderar den övre gränsen playable_actions = [] # Iterering genom den nya belöningsmatrisen för j inom intervallet ( 9): om rewards_new [current_state, j]> 0: playable_actions.append (j) # Välj en slumpmässig åtgärd som leder oss till nästa tillstånd next_state = np.random.choice (playable_actions) # Computing Temporal Difference TD = rewards_new [current_state , nästa_stat] + gamma * Q [nästa_stat, np.argmax (Q [nästa_stat,])]] - Q [nuvarande_stat, nästa_stat] # Uppdatering av Q-värdet med Bellman-ekvationen Q [nuvarande_stat, nästa_stat] + = alfa * TD # Initiera den optimala rutten med startplatsen rutt = [start_location] #Initialisera nästa_location med startplats next_location = star t_location # Vi vet inte om det exakta antalet iterationer som behövs för att nå den slutliga platsen, och därmed medan loop kommer att vara ett bra val för iteratiing while (next_location! = end_location): # Hämta starttillståndet startstat = läge_till_stat [startlokalisering] # Hämta det högsta Q-värdet som hör till starttillståndet nästa_stat = np.argmax (Q [startstatus,]) # Vi har index för nästa tillstånd. Men vi behöver motsvarande bokstav. next_location = state_to_location [next_state] route.append (next_location) # Uppdatera startplatsen för nästa iteration start_location = next_location returväg

Steg 4: Skriv ut rutten

skriv ut (get_optimal_route ('L1', 'L9'))

Produktion:

Med detta kommer vi till ett slut på Q-Learning. Jag hoppas att du lär känna hur Q Learning fungerar tillsammans med de olika beroenden som det finns temporär skillnad, Bellman-ekvation och mer.

Edureka's gör dig skicklig i tekniker som Supervised Learning, Unsupervised Learning och Natural Language Processing. Det inkluderar utbildning om de senaste framstegen och tekniska tillvägagångssätten inom artificiell intelligens och maskininlärning som djupinlärning, grafiska modeller och förstärkningslärande.