Q-læring: Alt hvad du behøver at vide om forstærkningslæring

og er et par domæner, der er blandt de bedste buzzwords i branchen og med god grund. AI vil skabe 2,3 millioner job inden 2020 i betragtning af, at dets hovedmål er at gøre det muligt for maskiner at efterligne menneskelig adfærd. Odd er det ikke? Så i dag skal vi diskutere Q Learning, byggestenen til Reinforcement Learning i følgende rækkefølge:

• Hvad er forstærkningslæring?
• Q-læringsproces
• Bellman ligning
• Markov beslutningsproces
• Q-Learning Demo: NumPy

Hvad er forstærkningslæring?

Lad os se på vores daglige liv. Vi udfører adskillige opgaver i miljøet, og nogle af disse opgaver giver os belønninger, mens andre ikke gør det. Vi fortsætter med at kigge efter forskellige veje og forsøger at finde ud af, hvilken vej der vil føre til belønninger, og baseret på vores handling forbedrer vi vores strategier for at nå mål. Dette er mine venner en af ​​de mest enkle analogier med forstærkningslæring.

Nøgleområder af interesse:

• Miljø
• Handling
• Belønning
• Stat

hvad er et navneområde c ++

Forstærkningslæring er den gren af ​​maskinlæring, der tillader systemer at lære af resultaterne af deres egne beslutninger. Det løser en bestemt slags problemer, hvor beslutningstagning er sekventiel, og målet er langsigtet.

Q-læringsproces

Lad os forstå, hvad der lærer Q med vores problemangivelse her. Det hjælper os med at definere hovedkomponenterne i en forstærkningslæringsløsning, dvs. agenter, miljø, handlinger, belønninger og stater.

Analogi til bilfabrik:

Vi er på en bilfabrik fyldt med robotter. Disse robotter hjælper fabriksarbejderne ved at formidle de nødvendige dele, der kræves for at samle en bil. Disse forskellige dele er placeret forskellige fabrikker på 9 stationer. Dele inkluderer chassis, hjul, instrumentbræt, motor og så videre. Factory Master har prioriteret placeringen, hvor chassiset installeres, som den højeste prioritet. Lad os se på opsætningen her:

Stater:

Den placering, hvor en robot er til stede i et bestemt tilfælde, kaldes dens tilstand. Da det er let at kode det i stedet for at huske det ved navne. Lad os kortlægge placeringen til tal.

Handlinger:

Handlinger er intet andet end bevægelserne foretaget af robotterne til et hvilket som helst sted. Overvej, en robot er på L2-placeringen, og de direkte placeringer, som den kan bevæge sig til, er L5, L1 og L3. Lad os forstå dette bedre, hvis vi visualiserer dette:

Belønninger:

Der gives en belønning til robotten for at gå direkte fra en stat til en anden. For eksempel kan du nå L5 direkte fra L2 og omvendt. Så der gives en belønning på 1 i begge tilfælde. Lad os se på belønningstabellen:

Husk, da fabriksmesteren prioriterede chassisets placering. Det var L7, så vi vil indarbejde denne kendsgerning i vores belønningstabel. Så vi tildeler et meget stort antal (999 i vores tilfælde) på (L7, L7) -placeringen.

Bellman ligning

Antag nu, at en robot skal gå fra punkt A til B. Den vælger den vej, der giver en positiv belønning. For det antager vi, at vi giver en belønning med hensyn til fodaftryk, som den kan følge.

Men hvad nu hvis robotten starter et sted imellem, hvor den kan se to eller flere stier. Robotten kan således ikke tage en beslutning, og dette sker primært, fordi den ikke har en hukommelse . Det er her Bellman-ligningen kommer ind i billedet.

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

Hvor:

• s = en bestemt tilstand
• a = handling
• s '= tilstand, som robotten går fra s
• & # 120632 = rabatfaktor
• R (s, a) = en belønningsfunktion, der tager en tilstand (er) og handling (a) og udsender en belønningsværdi
• V (s) = værdi for at være i en bestemt tilstand

Nu får blokken under destinationen en belønning på 1, hvilket er den højeste belønning, men hvad med den anden blok? Nå, det er her rabatfaktoren kommer ind. Lad os antage en rabatfaktor på 0,9 og udfylde alle blokke en efter en.

Markov beslutningsproces

Forestil dig, at en robot er på den orange blok og skal nå destinationen. Men selvom der er en lille dysfunktion, vil robotten være forvirret over, hvilken vej man skal gå i stedet for at gå op.

Så vi er nødt til at ændre beslutningsprocessen. Det skal det Delvis tilfældig og Delvis under robotens kontrol . Delvis tilfældigt, fordi vi ikke ved, hvornår robotten vil fungere dårligt, og delvis under kontrol, fordi det stadig er robotens beslutning. Og dette danner grundlaget for Markov-beslutningsprocessen.

En Markov-beslutningsproces (MDP) er en diskret tidsstokastisk kontrolproces. Det giver en matematisk ramme til modellering af beslutningstagning i situationer, hvor resultaterne dels er tilfældige og dels under kontrol af en beslutningstager.

Så vi skal bruge vores originale Bellman-ligning og foretage ændringer i den. Hvad vi ikke ved er den næste stat, dvs. s ’. Det vi ved er alle mulighederne for en drejning og lad os ændre ligningen.

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

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

P (s, a, s ’): Sandsynligheden for at flytte fra staten s til s ' med handling til

& Sigma_{s '}P (s, a, s ’) V (s): Tilfældighedsforventninger om robot

V (s) = max (R (s, a) + & # 120632 ((0,8V (rum_op)) + (0,1V (rum_ned) +….))

Lad os nu gå over til Q-læring. Q-Learning udgør en idé om at vurdere kvaliteten af ​​en handling, der træffes for at flytte til en tilstand i stedet for at bestemme den mulige værdi af den tilstand, den flyttes til.

Dette er hvad vi får, hvis vi inkorporerer ideen om at vurdere kvaliteten af ​​handlinger for at flytte til en bestemt tilstand. Fra den opdaterede Bellman-ligning, hvis vi fjerner dem maks komponent, antager vi kun et fodaftryk for mulig handling, som ikke er andet end Kvalitet af handlingen.

sum af cifre i java

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

servicenow tutorial for begyndere pdf

I denne ligning, der kvantificerer handlingens kvalitet, kan vi antage, at V (s) er det maksimale af alle mulige værdier af Q (s, a). Så lad os erstatte v (s) med en funktion af Q ().

Q (s, a) = (R (s, a) + & # 120632 & Sigma_{s '}P (s, a, s ’) maks. Q (s ', a'))

Vi er kun et skridt tæt på vores endelige ligning af Q-læring. Vi vil introducere en Temporal forskel at beregne Q-værdierne i forhold til ændringer i miljøet over tid. Men hvordan observerer vi ændringen i Q?

TD (s, a) = (R (s, a) + & # 120632 & Sigma_{s '}P (s, a, s ’) maks. Q (s ', a')) - Q (s, a)

Vi genberegner den nye Q (s, a) med den samme formel og trækker den tidligere kendte Q (s, a) fra den. Således bliver ovenstående ligning:

Spørgsmål_t(s, a) = Q_t-1(s, a) + a TD_t(s, a)

Spørgsmål_t(s, a) = Nuværende Q-værdi

Spørgsmål_t-1(s, a) = Tidligere Q-værdi

Spørgsmål_t(s, a) = Q_t-1(s, a) + α (R (s, a) + & # 120632 max Q (s ’, a’)_-Spørgsmål_t-1(s, a))

Q Læringsdemo: NumPy

Jeg skal bruge NumPy for at demonstrere, hvordan Q Learning fungerer.

Trin 1: Import, parametre, stater, handlinger og belønninger

importer numpy som np gamma = 0,75 # Rabatfaktor alpha = 0,9 # Læringshastighed 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]])

Trin 2: Kortindekser til placeringer

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

Trin 3: Få en optimal rute ved hjælp af Q-læringsprocessen

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æringsproces for i inden for rækkevidde (1000): # Opsamling af en tilfældig tilstand current_state = np.random.randint (0,9) # Python ekskluderer den øvre grænse play__actions = [] # Iterering gennem den nye belønningsmatrix for j i området ( 9): hvis rewards_new [current_state, j]> 0: playable_actions.append (j) # Vælg en tilfældig handling, der fører os til næste tilstand 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] # Opdatering af Q-værdien ved hjælp af Bellman-ligningen Q [current_state, next_state] + = alpha * TD # Initialiser den optimale rute med startplaceringsruten = [start_location] #Initialiser næste_location med startplacering next_location = star t_location # Vi ved ikke om det nøjagtige antal iterationer, der er nødvendige for at nå til den endelige placering, og mens loop vil være et godt valg til iteratiing mens (next_location! = end_location): # Hent starttilstanden startstat = placering_til_stat [startlokation] # Hent den højeste Q-værdi, der vedrører starttilstand next_state = np.argmax (Q [startstatus,]) # Vi fik indekset for den næste tilstand. Men vi har brug for det tilsvarende brev. next_location = state_to_location [next_state] route.append (next_location) # Opdater startplaceringen for den næste iteration start_location = next_location returrute

Trin 4: Udskriv ruten

udskriv (get_optimal_route ('L1', 'L9'))

Produktion:

Med dette kommer vi til slutningen af ​​Q-Learning. Jeg håber, du lærte at arbejde med Q Learning sammen med de forskellige afhængigheder, der er som den tidsmæssige forskel, Bellman-ligning og mere.

Edureka's gør dig dygtig i teknikker som Supervised Learning, Unsupervised Learning og Natural Language Processing. Det inkluderer træning i de nyeste fremskridt og tekniske tilgange inden for kunstig intelligens og maskinindlæring som dyb læring, grafiske modeller og forstærkningslæring.