og er noen domener som er blant de beste moteordene i bransjen og med god grunn. AI kommer til å skape 2,3 millioner jobber innen 2020, med tanke på at hovedmålet er å gjøre det mulig for maskiner å etterligne menneskelig atferd. Odd er det ikke? Så i dag skal vi diskutere Q Learning, byggesteinen til Reinforcement Learning i følgende rekkefølge:
- Hva er forsterkningslæring?
- Q-læringsprosess
- Bellman ligning
- Markov beslutningsprosess
- Q-Learning Demo: NumPy
Hva er forsterkningslæring?
La oss ta en titt på vårt daglige liv. Vi utfører mange oppgaver i miljøet, og noen av disse oppgavene gir oss belønning mens noen ikke gjør det. Vi fortsetter å lete etter forskjellige veier og prøver å finne ut hvilken vei som vil føre til belønninger, og basert på vår handling forbedrer vi våre strategier for å nå mål. Dette vennene mine er en av de enkleste analogiene til forsterkningslæring.
Viktige interesseområder:
- Miljø
- Handling
- Belønning
- Stat
Forsterkningslæring er grenen av maskinlæring som tillater systemer å lære av resultatene av egne beslutninger. Det løser en bestemt type problem der beslutningstaking er sekvensiell, og målet er langsiktig.
Q-læringsprosess
La oss forstå hva Q lærer med vår problemstilling her. Det vil hjelpe oss med å definere hovedkomponentene i en forsterkningslæringsløsning, dvs. agenter, miljø, handlinger, belønninger og stater.
Bilfabriksanalogi:
Vi er på en bilfabrikk fylt med roboter. Disse robotene hjelper fabrikkarbeiderne ved å formidle de nødvendige delene som kreves for å montere en bil. Disse forskjellige delene er lokalisert på forskjellige steder i fabrikken på 9 stasjoner. Delene inkluderer chassis, hjul, dashbord, motor og så videre. Factory Master har prioritert stedet der chassiset installeres som høyeste prioritet. La oss ta en titt på oppsettet her:
hvordan fungerer tostring i java
Stater:
Stedet der en robot er tilstede i en bestemt forekomst, kalles dens tilstand. Siden det er enkelt å kode det i stedet for å huske det ved navn. La oss kartlegge plasseringen til tall.
Handlinger:
Handlinger er ikke annet enn bevegelsene gjort av robotene til et hvilket som helst sted. Tenk på at en robot er på L2-stedet, og de direkte stedene den kan bevege seg til er L5, L1 og L3. La oss forstå dette bedre hvis vi visualiserer dette:
Belønninger:
En belønning vil bli gitt til roboten for å gå direkte fra en stat til en annen. For eksempel kan du nå L5 direkte fra L2 og omvendt. Så, en belønning på 1 vil bli gitt i begge tilfeller. La oss ta en titt på belønningstabellen:
Husk når Factory Master prioriterte chassisplasseringen. Det var L7, så vi skal innlemme dette i belønningstabellen vår. Så vi tilordner et veldig stort antall (999 i vårt tilfelle) på (L7, L7) -stedet.
hva er en metode i javascript
Bellman ligning
Anta at en robot må gå fra punkt A til B. Den vil velge den stien som vil gi en positiv belønning. For det antar at vi gir en belønning når det gjelder fotavtrykk for at den skal følge.
Men hva om roboten starter et sted imellom der den kan se to eller flere stier. Roboten kan dermed ikke ta en beslutning, og dette skjer først og fremst fordi den ikke har en hukommelse . Det er her Bellman-ligningen kommer inn i bildet.
V (s) = maks (R (s, a) + & # 120632V (s ’))
Hvor:
- s = en bestemt tilstand
- a = handling
- s '= tilstand som roboten går fra s
- & # 120632 = rabattfaktor
- R (s, a) = en belønningsfunksjon som tar en tilstand (er) og handling (a) og gir ut en belønningsverdi
- V (s) = verdien av å være i en bestemt tilstand
Nå vil blokken under destinasjonen ha en belønning på 1, som er den høyeste belønningen. Men hva med den andre blokken? Vel, det er her rabattfaktoren kommer inn. La oss anta en rabattfaktor på 0,9 og fylle alle blokkene en etter en.
Markov beslutningsprosess
Tenk deg at en robot er på den oransje blokken og må nå destinasjonen. Men selv om det er en liten dysfunksjon, vil roboten være forvirret om hvilken vei du skal ta i stedet for å gå opp.
Så vi må endre beslutningsprosessen. Det må det Delvis tilfeldig og Delvis under robotens kontroll . Delvis tilfeldig fordi vi ikke vet når roboten vil fungere dårlig, og delvis under kontroll fordi det fortsatt er robotens beslutning. Og dette danner basen for Markov-beslutningsprosessen.
En Markov beslutningsprosess (MDP) er en diskret tidstokastisk kontrollprosess. Det gir et matematisk rammeverk for modellering av beslutningstaking i situasjoner der resultatene er delvis tilfeldige og delvis under kontroll av en beslutningstaker.
Så vi skal bruke vår opprinnelige Bellman-ligning og gjøre endringer i den. Det vi ikke vet er den neste staten dvs. s ’. Det vi vet er alle mulighetene for en sving, og la oss endre ligningen.
V (s) = maks (R (s, a) + & # 120632 V (s ’))
V (s) = maks (R (s, a) + & # 120632 & Sigmas ’P (s, a, s ’) V (s))
P (s, a, s ’): Sannsynligheten for å flytte fra staten s til s ’ med handling til
& Sigmas ’P (s, a, s ’) V (s ’): Tilfeldighetsforventninger om robot
V (s) = maks (R (s, a) + & # 120632 ((0,8V (romopp)) + (0,1V (romned) +….))
La oss nå gå over til Q-læring. Q-Learning gir en idé om å vurdere kvaliteten på en handling som blir tatt for å flytte til en stat i stedet for å bestemme den mulige verdien av staten den blir flyttet til.
Dette er hva vi får hvis vi innlemmer ideen om å vurdere kvaliteten på handlinger for å flytte til en bestemt tilstand. Fra den oppdaterte Bellman-ligningen hvis vi fjerner dem maks komponent, antar vi bare ett fotavtrykk for mulig handling som ikke er annet enn Kvalitet av handlingen.
Q (s, a) = (R (s, a) + & # 120632 & Sigmas ’P (s, a, s ’) V (s))
I denne ligningen som kvantifiserer handlingens kvalitet, kan vi anta at V (s) er maksimum av alle mulige verdier av Q (s, a). Så la oss erstatte v (s) med en funksjon av Q ().
Q (s, a) = (R (s, a) + & # 120632 & Sigmas ’P (s, a, s ’) maks Q (s ’, a’))
Vi er bare ett skritt nær vår endelige ligning av Q-læring. Vi skal introdusere en Temporal Difference å beregne Q-verdiene med hensyn til endringene i miljøet over tid. Men hvordan observerer vi endringen i Q?
TD (s, a) = (R (s, a) + & # 120632 & Sigmas ’P (s, a, s ’) maks Q (s ’, a’)) - Q (s, a)
Vi beregner den nye Q (s, a) på nytt med samme formel og trekker den tidligere kjente Q (s, a) fra den. Så blir ligningen ovenfor:
hvordan lage en jframe i java
Qt(s, a) = Qt-1(s, a) + α TDt(s, a)
Qt(s, a) = Gjeldende Q-verdi
Qt-1(s, a) = Tidligere Q-verdi
Qt(s, a) = Qt-1(s, a) + α (R (s, a) + & # 120632 maks Q (s ’, a’)-Qt-1(s, a))
Q Læringsdemo: NumPy
Jeg skal bruke NumPy for å demonstrere hvordan Q Learning fungerer.
Trinn 1: Import, parametere, stater, handlinger og belønninger
importer numpy som np gamma = 0,75 # Rabattfaktor alfa = 0,9 # Læringsgrad location_to_state = {'L1': 0, 'L2': 1, 'L3': 2, 'L4': 3, 'L5': 4, ' L6 ': 5,' L7 ': 6,' L8 ': 7,' L9 ': 8} handlinger = [0,1,2,3,4,5,6,7,8] belønninger = 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]])Trinn 2: Kartindekser til steder
state_to_location = dict ((state, location) for location, state in location_to_state.items ())
Trinn 3: Få optimal rute ved hjelp av Q-læringsprosessen
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.zeros ([9,9])) # Q- Læringsprosess for i innen rekkevidde (1000): # Plukker opp en tilfeldig tilstand current_state = np.random.randint (0,9) # Python ekskluderer den øvre grensen playable_actions = [] # Itererer gjennom den nye belønningsmatrisen for j innen rekkevidde ( 9): hvis rewards_new [current_state, j]> 0: playable_actions.append (j) # Velg en tilfeldig handling som vil føre oss til neste tilstand next_state = np.random.choice (playable_actions) # Computing Temporal Difference TD = rewards_new [current_state , neste_stat] + gamma * Q [neste_stat, np.argmax (Q [neste_stat,])]] - Q [nåværende_tilstand, neste_stat] # Oppdatering av Q-verdien ved bruk av Bellman-ligningen Q [nåværende tilstand, neste stat] + = alfa * TD # Initialiser den optimale ruten med startposisjonen rute = [start_location] #Initialiser neste_location med startplassen next_location = star t_location # Vi vet ikke om det nøyaktige antall iterasjoner som trengs for å nå til den endelige plasseringen, og mens loop vil være et godt valg for iteratiing mens (neste_location! = end_location): # Hent starttilstanden startstat = location_to_state [start_location] # Hent den høyeste Q-verdien som gjelder starttilstand next_state = np.argmax (Q [startstatus,]) # Vi fikk indeksen for neste tilstand. Men vi trenger tilsvarende bokstav. next_location = state_to_location [next_state] route.append (next_location) # Oppdater startplasseringen for neste iterasjon start_location = next_location returvei
Trinn 4: Skriv ut ruten
skriv ut (get_optimal_route ('L1', 'L9'))Produksjon:
Med dette kommer vi til en slutt på Q-Learning. Jeg håper du ble kjent med arbeidet med Q Learning sammen med de forskjellige avhengighetene som den tidsmessige forskjellen, Bellman-ligningen og mer.
Edureka’s gjør deg dyktig i teknikker som Supervised Learning, Unsupervised Learning, and Natural Language Processing. Det inkluderer opplæring i de siste fremskrittene og tekniske tilnærmingene innen kunstig intelligens og maskinlæring som dyp læring, grafiske modeller og forsterkningslæring.