Q Učenje: Sve što trebate znati o Učvršćivanju

i nekoliko je domena koje su među najboljim modnim riječima u industriji i to s dobrim razlogom. AI će do 2020. stvoriti 2,3 milijuna radnih mjesta s obzirom na to da je njezin glavni cilj omogućiti strojevima da oponašaju ljudsko ponašanje. Čudno zar ne? Dakle, danas ćemo razgovarati o Q Learningu, gradivnom elementu Armaturnog učenja sljedećim redoslijedom:

• Što je učvršćivanje učenja?
• Proces Q-učenja
• Bellmanova jednadžba
• Postupak odluke Markova
• Q-Learning Demo: NumPy

Što je učvršćivanje učenja?

Pogledajmo naš svakodnevni život. Brojne zadatke obavljamo u okruženju, a neki od njih donose nam nagrade, dok neki ne. Neprestano tražimo različite putove i pokušavamo otkriti koji će put dovesti do nagrada i na temelju svog djelovanja poboljšavamo svoje strategije postizanja ciljeva. Ovo su moji prijatelji jedna od najjednostavnijih analogija učvršćivanja.

Ključna područja interesa:

• Okoliš
• Akcijski
• Nagrada
• država

Pojačano učenje je grana strojnog učenja koja omogućuje sustavima da uče iz ishoda vlastitih odluka. Rješava određenu vrstu problema tamo gdje je donošenje odluka uzastopno, a cilj je dugoročan.

trim () u javi

Proces Q-učenja

Shvatimo što je Q učenje s našom ovdje navedenom problematikom. Pomoći će nam da definiramo glavne komponente rješenja za učenje pojačanja, tj. Agense, okruženje, akcije, nagrade i stanja.

Analogija tvornice automobila:

Nalazimo se u tvornici automobila ispunjenoj robotima. Ovi roboti pomažu radnicima Tvornice prenoseći potrebne dijelove potrebne za sastavljanje automobila. Ti se različiti dijelovi nalaze na različitim mjestima u tvornici u 9 stanica. Dijelovi uključuju šasiju, kotače, nadzornu ploču, motor i tako dalje. Factory Master kao najveći prioritet dao je mjesto na kojem se ugrađuje šasija. Pogledajmo postavke ovdje:

Države:

Mjesto na kojem je robot prisutan u određenoj instanci naziva se njegovim stanjem. Budući da ga je lako kodirati, a ne pamtiti po imenima. Mapirajmo lokaciju u brojeve.

Radnje:

Akcije nisu ništa drugo doli potezi robota na bilo koje mjesto. Uzmite u obzir da se robot nalazi na mjestu L2, a izravna mjesta na koja se može preseliti su L5, L1 i L3. Shvatimo to bolje ako ovo vizualiziramo:

Nagrade:

Nagrada će dobiti robot za prelazak izravno iz jednog stanja u drugo. Na primjer, možete doći do L5 izravno s L2 i obrnuto. Dakle, dobit će se nagrada u oba slučaja. Pogledajmo tablicu nagrada:

Sjetite se kada je Factory Master odredio mjesto šasije. Bio je L7, pa ćemo uvrstiti ovu činjenicu u svoju tablicu nagrada. Dakle, dodijelit ćemo vrlo velik broj (999 u našem slučaju) na mjestu (L7, L7).

Bellmanova jednadžba

Sada pretpostavimo da robot treba prijeći od točke A do B. Odabrat će put koji će donijeti pozitivnu nagradu. Pretpostavimo da za to pružimo nagradu u smislu otiska za nju.

Ali što ako robot krene negdje između toga gdje može vidjeti dvije ili više staza. Robot tako ne može donijeti odluku i to se prije svega događa jer ne posjeduje memorija . Tu dolazi do izražaja Bellmanova jednadžba.

kako ispisati niz u php - u

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

Gdje:

• s = određeno stanje
• a = akcija
• s '= stanje u koje robot prelazi iz s
• & # 120632 = faktor popusta
• R (s, a) = funkcija nagrade koja uzima stanje (stanja) i radnju (a) i daje vrijednost nagrade
• V (s) = vrijednost boravka u određenom stanju

Sad će blok ispod odredišta dobiti nagradu 1, što je najviša nagrada, ali što je s drugim blokom? Pa, tu dolazi do faktora popusta. Pretpostavimo faktor popusta od 0,9 i ispunimo sve blokove jedan po jedan.

Postupak odluke Markova

Zamislite da se robot nalazi na narančastom bloku i treba doći do odredišta. No čak i ako postoji lagana disfunkcija, robot će se zbuniti kojim putem krenuti, a ne ići gore.

Stoga moramo izmijeniti postupak donošenja odluka. To mora Djelomično slučajno i Djelomično pod kontrolom robota . Djelomično slučajno, jer ne znamo kada će robot disfunkcionirati, a dijelom pod kontrolom, jer je to još uvijek odluka robota. I ovo čini osnovu za postupak odlučivanja o Markovu.

Markovljev postupak odlučivanja (MDP) diskretni je vremenski stohastički proces upravljanja. Pruža matematički okvir za modeliranje donošenja odluka u situacijama kada su ishodi dijelom slučajni, a dijelom pod kontrolom donositelja odluka.

Dakle, koristit ćemo našu izvornu Bellmanovu jednadžbu i unijeti promjene u nju. Ono što ne znamo je sljedeće stanje tj. s ’. Ono što znamo su sve mogućnosti skretanja i promijenimo jednadžbu.

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 ’): Vjerojatnost prelaska iz stanja s do s ’ s akcijom do

& Sigma_{s ’}P (s, a, s ’) V (s): Slučajna očekivanja robota

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

Sada, prijeđimo na Q učenje. Q-Learning postavlja ideju procjene kvalitete radnje koja se poduzima za prelazak u neko stanje, a ne određivanje moguće vrijednosti stanja u koje se premješta.

To dobivamo ako ugradimo ideju procjene kvalitete akcija za prelazak u određeno stanje. Ako ih uklonimo iz ažurirane Bellman-ove jednadžbe maks komponenta, pretpostavljamo samo jedan trag za moguće djelovanje koji nije ništa drugo do Kvaliteta akcije.

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

U ovoj jednadžbi koja kvantificira kvalitetu djelovanja možemo pretpostaviti da je V (s) maksimum svih mogućih vrijednosti Q (s, a). Zamijenimo dakle v (s ’) funkcijom Q ().

kako prikazati niz u php - u

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

Samo smo jedan korak blizu naše konačne Jednadžbe Q učenja. Uvest ćemo a Privremena razlika za izračunavanje Q-vrijednosti s obzirom na promjene u okolišu tijekom vremena. Ali kako promatrati promjenu u Q?

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

Novi Q (s, a) preračunavamo istom formulom i od njega oduzimamo prethodno poznati Q (s, a). Dakle, gornja jednadžba postaje:

P_t(s, a) = Q_t-1(s, a) + α TD_t(s, a)

P_t(s, a) = Trenutna Q-vrijednost

P_t-1(s, a) = Prethodna Q-vrijednost

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

Q učenje demo: NumPy

Idem koristiti NumPy kako bi pokazao kako Q učenje funkcionira.

Korak 1: Uvoz, parametri, stanja, radnje i nagrade

uvoz numpy kao np gama = 0,75 # Faktor popusta alfa = 0,9 # Stopa učenja location_to_state = {'L1': 0, 'L2': 1, 'L3': 2, 'L4': 3, 'L5': 4, ' L6 ': 5,' L7 ': 6,' L8 ': 7,' L9 ': 8} akcije = [0,1,2,3,4,5,6,7,8] nagrade = 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,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,0,1,0]])

Korak 2: Mapiranje indeksa na lokacije

state_to_location = dict ((stanje, mjesto) za lokaciju, stanje u location_to_state.items ())

Korak 3: Dođite do optimalne rute pomoću Q procesa učenja

def get_optimal_route (start_location, end_location): rewards_new = np.copy (rewards) END_STATE = location_to_state [end_location] rewards_new [END_START, END_STATE] = 999 Q = np.array (np.zeros ([9,9])) # Q- Proces učenja za i in range (1000): # Preuzimanje slučajnog stanja current_state = np.random.randint (0,9) # Python isključuje gornju granicu playable_action = [] # Iteracija kroz novu nagradnu matricu za j u rasponu ( 9): ako je rewards_new [current_state, j]> 0: playable_actions.append (j) # Odaberite slučajnu radnju koja će nas dovesti do sljedećeg stanja next_state = np.random.choice (playable_actions) # Izračunavanje privremene razlike TD = rewards_new [current_state , next_state] + gama * Q [next_state, np.argmax (Q [next_state,])] - Q [current_state, next_state] # Ažuriranje Q-vrijednosti pomoću Bellmanove jednadžbe Q [current_state, next_state] + = alpha * TD # Inicijalizirajte optimalnu rutu s početnim mjestom route = [start_location] # Inicijalizirajte next_location s početnim mjestom next_location = star t_location # Ne znamo tačan broj iteracija potrebnih za dosezanje konačnog mjesta, stoga će while petlja biti dobar izbor za iteraciju dok je (next_location! = end_location): # Dohvaćanje početnog stanja start_state = location_to_state [start_location] # Dohvati najveću Q-vrijednost koja se odnosi na početno stanje next_state = np.argmax (Q [start_state,]) # Dobili smo indeks sljedećeg stanja. Ali trebamo odgovarajuće slovo. next_location = state_to_location [next_state] route.append (next_location) # Ažurirajte početno mjesto za sljedeću iteraciju start_location = next_location return route

Korak 4: Ispišite rutu

ispis (get_optimal_route ('L1', 'L9'))

Izlaz:

Ovim smo došli do kraja Q-učenja. Nadam se da ste upoznali rad Q učenja zajedno s raznim ovisnostima koje postoje poput vremenske razlike, Bellmanove jednadžbe i još mnogo toga.

Edureka’s čini vas vještima u tehnikama poput nadzora pod nadzorom, učenja bez nadzora i obrade prirodnog jezika. Uključuje obuku o najnovijim dostignućima i tehničkim pristupima u umjetnoj inteligenciji i strojnom učenju kao što su duboko učenje, grafički modeli i učenje ojačanja.