Šta je Q-učenje?

Q-Learning je politika učenja s pojačavanjem koja će pronaći sljedeću najbolju akciju, s obzirom
na trenutno stanje. Ovu akciju bira nasumično i ima za cilj da maksimizira nagradu.

Ilustracija 1 Komponente Q-learninga

Q-učenje je učenje s pojačanjem bez modela, izvan politike koje će pronaći najbolji pravac
akcije, s obzirom na trenutno stanje agenta. Ovisno o tome gdje se agent nalazi u okruženju,
odlučit će sljedeću radnju koju treba poduzeti.

Cilj modela je pronaći najbolji pravac akcije s obzirom na njegovo trenutno stanje. Da bi to
učinio, može smisliti vlastita pravila ili može djelovati van politike koja mu je data da slijedi. To
znači da ne postoji stvarna potreba za politikom, stoga je nazivamo van politike.

Bez modela znači da agent koristi predviđanja očekivanog odgovora okoline kako bi krenuo
naprijed. Za učenje ne koristi sistem nagrađivanja, već pokušaje i greške.

Primjer Q-learninga je sistem preporuke za oglašavanje. U normalnom sistemu za preporuke

oglasa, oglasi koje dobijete zasnivaju se na vašim prethodnim kupovinama ili web lokacijama
koje ste možda posjetili. Ako ste kupili televizor, dobit ćete preporučene televizore različitih
marki.
Koristeći Q-learning, možemo optimizirati sistem preporuka oglasa kako bismo preporučili
proizvode koji se često kupuju zajedno. Nagrada će biti ako korisnik klikne na predloženi
proizvod.

Važni uslovi u Q-Learningu

1. Stanje: Stanje, S, predstavlja trenutnu poziciju agenta u okruženju.
2. Akcija: Akcija, A, je korak koji agent poduzima kada je u određenom stanju.
3. Nagrade: Za svaku akciju agent će dobiti pozitivnu ili negativnu nagradu.
4. Epizode: Kada agent završi u stanju prekida i ne može poduzeti novu radnju.
5. Q-vrijednosti: Koristi se za određivanje koliko je dobra radnja, A, preduzeta u određenom
stanju, S. Q (A, S).
6. Vremenska razlika: Formula koja se koristi za pronalaženje Q-vrijednosti koristeći
vrijednost trenutnog stanja i radnje i prethodnog stanja i radnje.
Šta je Bellmanova jednačina?
Bellmanova jednačina se koristi za određivanje vrijednosti određenog stanja i zaključivanje
koliko je dobro biti u/uuzeti to stanje. Optimalno stanje će nam dati najveću optimalnu
vrijednost.

Jednačina je data u nastavku. Koristi trenutno stanje i nagradu povezanu s tim stanjem, zajedno
sa maksimalno očekivanom nagradom i diskontom, koji određuje njegovu važnost za trenutno
stanje, da pronađe sljedeće stanje našeg agenta. Brzina učenja određuje koliko brzo ili sporo će
model učiti.

Ilustracija 2 Bellmanova jednačina

Kako napraviti Q-tabelu?

Dok pokrećemo naš algoritam, naići ćemo na različita rješenja i agent će ići na više puta. Kako
da saznamo najbolje među njima? To se radi tako što se naši rezultati tabeliraju u tabeli koja se
zove Q-tabela.

Q-tabela nam pomaže da pronađemo najbolju akciju za svako stanje u okruženju. Koristimo
Bellmanovu jednačinu za svako stanje da dobijemo očekivano buduće stanje i nagradu i
spremimo je u tablicu za usporedbu s drugim stanjima.

Omogućava nam da kreiramo q-tabelu za agenta koji mora naučiti da pokreće, preuzima i sjedi
po komandi. Koraci koji su preduzeti da se napravi q-tabela su:

Korak 1: Kreirajte početnu Q-tabelu sa svim vrijednostima inicijaliziranim na 0

Kada u početku počnemo, vrijednosti svih stanja i nagrada će biti 0. Razmotrite Q-tabelu
prikazanu ispod koja prikazuje simulator psa koji uči da izvodi radnje:

Ilustracija 3 Početna Q-tabela

Korak 2: Odaberite radnju i izvršite je. Ažurirajte vrijednosti u tabeli

Ovo je polazna tačka. Do sada nismo izvršili nikakvu drugu radnju. Recimo da želimo da agent u
početku sjedi, što i čini. Tabela će se promijeniti u:

Ilustracija 4 Q-Table after performing an action

Korak 3: Dobijte vrijednost nagrade i izračunajte vrijednost Q-vrijednosti koristeći Bellmanovu

jednačinu

Za izvršenu radnju trebamo izračunati vrijednost stvarne nagrade i Q( S, A ) vrijednost

 Ilustracija 5 Ažuriranje Q-tablice s Bellmanovom jednačinom

Korak 4: Nastavite isto dok se tabela ne popuni ili dok se epizoda ne završi

Agent nastavlja poduzimanje radnji i za svaku akciju se izračunavaju nagrada i Q-vrijednost i

ažurira tabelu.

Ilustracija 6 Konačna Q-tabela na kraju episode

Bitni parametri :
 Stopa učenja: lr ili stopa učenja, koja se često naziva alfa ili α, može se jednostavno
definirati kao koliko prihvaćate novu vrijednost u odnosu na staru vrijednost. Iznad
uzimamo razliku između novog i starog, a zatim množimo tu vrijednost sa stopom
učenja. Ova vrijednost se zatim dodaje našoj prethodnoj q-vrijednosti koja je u suštini
pomiče u smjeru našeg najnovijeg ažuriranja.
 Gama: gama ili γ je faktor popusta. Koristi se za balansiranje trenutne i buduće nagrade.
Iz našeg pravila ažuriranja iznad možete vidjeti da primjenjujemo popust na buduću
nagradu. Obično ova vrijednost može biti u rasponu od 0,8 do 0,99.
 Nagrada: nagrada je vrijednost primljena nakon završetka određene radnje u datom
stanju. Nagrada se može dogoditi u bilo kojem vremenskom koraku ili samo u krajnjem
vremenskom koraku.
  Max: np.max() koristi biblioteku numpy i uzima maksimum buduće nagrade i primjenjuje
ga na nagradu za trenutno stanje. Ovo utiče na trenutnu akciju mogućom budućom
nagradom. Ovo je ljepota q-učenja. Buduću nagradu dodjeljujemo trenutnim radnjama
kako bismo pomogli agentu da odabere najvišu radnju povrata u bilo kojem stanju.

Q-Learning koristeći Python

Učenje s pojačanjem (RL) je grana mašinskog učenja koja se bavi problemima gdje ne postoje
eksplicitni podaci o obuci. Q-učenje je algoritam koji se može koristiti za rješavanje nekih vrsta
RL problema. U ovom članku demonstriram kako Q-učenje može riješiti problem lavirinta.

Najbolji način da vidite kuda vodi ovaj članak je da pogledate sliku jednostavnog lavirinta na
slici 1 i snimak ekrana povezanog demo programa na slici 2. Lavirint 3x5 ima 15 ćelija,
numeriranih od 0 do 14. Cilj je doći od ćelije 0 u gornjem levom uglu, do ćelije 14 u donjem
desnom uglu, u najmanje poteza. Možete se kretati lijevo, desno, gore ili dolje, ali ne
dijagonalno.

Demo program postavlja prikaz lavirinta u memoriji, a zatim koristi algoritam Q-učenja da
pronađe Q matricu. Q označava kvalitet, gdje su veće vrijednosti bolje. Indeksi reda su ćelije
"od", a indeksi stupaca su ćelije "do". Ako je početna ćelija 0, onda skeniranje tog reda pokazuje
da je najveća Q vrijednost 0,02 u ćeliji 5. Zatim u ćeliji 5, najveća vrijednost u redu je 0,05 u
ćeliji 10. Proces se nastavlja sve dok program ne dostigne ciljno stanje u ćeliji 14.

Nije vjerovatno da će vaš šef na poslu tražiti od vas da napišete kod za Q-učenje za rješavanje
lavirinta, ali ovaj problem je "Hello World" za Q-učenje jer je problem lako razumjeti i
vizualizirati.

Ilustracija 7 Simple Maze Problem

 Ilustracija 8 Q-Learning Demo Program

# maze.py

import numpy as np

# =============================================================

def my_print(Q, dec): . . .

def get_poss_next_states(s, F, ns): . . .

def get_rnd_next_state(s, F, ns): . . .

def train(F, R, Q, gamma, lrn_rate, goal, ns, max_epochs): . .

def walk(start, goal, Q): . . .

# =============================================================
def main():

np.random.seed(1)

print("Setting up maze in memory")

F = np.zeros(shape=[15,15], dtype=np.int) # Feasible

F[0,1] = 1; F[0,5] = 1; F[1,0] = 1; F[2,3] = 1; F[3,2] = 1

F[3,4] = 1; F[3,8] = 1; F[4,3] = 1; F[4,9] = 1; F[5,0] = 1

F[5,6] = 1; F[5,10] = 1; F[6,5] = 1; F[7,8] = 1; F[7,12] = 1

F[8,3] = 1; F[8,7] = 1; F[9,4] = 1; F[9,14] = 1; F[10,5] = 1

F[10,11] = 1; F[11,10] = 1; F[11,12] = 1; F[12,7] = 1;

F[12,11] = 1; F[12,13] = 1; F[13,12] = 1; F[14,14] = 1

R = np.zeros(shape=[15,15], dtype=np.int) # Rewards

R[0,1] = -0.1; R[0,5] = -0.1; R[1,0] = -0.1; R[2,3] = -0.1

R[3,2] = -0.1; R[3,4] = -0.1; R[3,8] = -0.1; R[4,3] = -0.1

R[4,9] = -0.1; R[5,0] = -0.1; R[5,6] = -0.1; R[5,10] = -0.1

R[6,5] = -0.1; R[7,8] = -0.1; R[7,12] = -0.1; R[8,3] = -0.1

R[8,7] = -0.1; R[9,4] = -0.1; R[9,14] = 10.0; R[10,5] = -0.1

R[10,11] = -0.1; R[11,10] = -0.1; R[11,12] = -0.1

R[12,7] = -0.1; R[12,11] = -0.1; R[12,13] = -0.1

 R[13,12] = -0.1; R[14,14] = -0.1

# =============================================================

Q = np.zeros(shape=[15,15], dtype=np.float32) # Quality

print("Analyzing maze with RL Q-learning")

start = 0; goal = 14

ns = 15 # number of states

gamma = 0.5

lrn_rate = 0.5

max_epochs = 1000

train(F, R, Q, gamma, lrn_rate, goal, ns, max_epochs)

print("Done ")

print("The Q matrix is: \n ")

my_print(Q, 2)

print("Using Q to go from 0 to goal (14)")

walk(start, goal, Q)
if __name__ == "__main__":

main()

Funkcija main() počinje postavljanjem F matrice koja definira izvodljivost prelaska iz jedne
ćelije/stanja u drugu. Na primjer, F[7][12] = 1 znači da možete preći iz ćelije/stanja 7 u
ćeliju/stanje 12, a F[6][7] = 0 znači da ne možete preći iz ćelije 7 u ćeliju 8 (jer postoji zid na
putu).

R matrica definira nagradu za prelazak iz jedne ćelije u drugu. Većina izvodljivih poteza daje
negativnu nagradu od -0,1, što kažnjava poteze koji ne napreduju i stoga obeshrabruje kruženje.
Jedna velika nagrada je R[9][14] = 10,0, što vas pomera u ciljno stanje.

Većinu posla obavlja funkcija train(), koja izračunava vrijednosti Q matrice. Q-učenje je
iterativno, tako da je postavljen maksimalan broj iteracija, 1000. Q-učenje ima dva parametra,
brzinu učenja i gama. Veće vrijednosti stope učenja povećavaju utjecaj kako trenutnih nagrada,
tako i budućih nagrada (istraživanje) na račun prošlih nagrada (exploit). Vrijednost gama, koja se
naziva i faktor popusta, utiče na važnost budućih nagrada. Ove vrijednosti se moraju odrediti
metodom pokušaja i grešaka, ali korištenje 0,5 je obično dobro polazište.

Nakon što je Q matrica izračunata, funkcija walk() koristi matricu da prikaže najkraći put kroz
labirint: 0->5->10->11->12->7->8->3->4- >9->14->gotovo.

Helper funkcija
Funkcija train() koristi dva pomoćnika, get_poss_next_states() i get_rnd_next_state(). Funkcija
get_poss_next_states() je definirana:

def get_poss_next_states(s, F, ns):

poss_next_states = []

for j in range(ns):

if F[s,j] == 1: poss_next_states.append(j)
 return poss_next_states

Za dato stanje ćelije s, funkcija koristi F matricu da odredi koja stanja se mogu postići i vraća ta
stanja kao listu. Na primjer, ako je s = 5, povratna lista je [0, 6, 10].

Funkcija get_rnd_next_state() je definirana:

def get_rnd_next_state(s, F, ns):

poss_next_states = get_poss_next_states(s, F, ns)

next_state = \

poss_next_states[np.random.randint(0,\

len(poss_next_states))]

return next_state

Za dato stanje s određuju se sva moguća sljedeća stanja, a zatim se jedno od tih stanja nasumično
bira. Na primjer, ako je s = 5, kandidati su [0, 6, 10]. Poziv np.randomint() vraća slučajnu
vrijednost od 0 do 2, koja djeluje kao indeks na listi kandidata.

Izračunavanje Q matrice

Srce demo programa je funkcija train(), koja izračunava Q matricu. Kod za train() je predstavljen
u Listingu 2. Jednačina ažuriranja Q-učenja, prikazana na dnu slike 1, zasniva se na pametnoj
ideji koja se zove Bellmanova jednačina. Ne morate razumjeti Bellmanovu jednačinu da biste
koristili Q-učenje, ali ako ste zainteresovani, članak na Wikipediji o Bellmanovoj jednačini je
dobro mjesto za početak.

The train() Function

def train(F, R, Q, gamma, lrn_rate, goal, ns, max_epochs):

for i in range(0,max_epochs):

curr_s = np.random.randint(0,ns) # random start state

while(True):

next_s = get_rnd_next_state(curr_s, F, ns)

poss_next_next_states = \

get_poss_next_states(next_s, F, ns)

max_Q = -9999.99

for j in range(len(poss_next_next_states)):

nn_s = poss_next_next_states[j]

q = Q[next_s,nn_s]

if q > max_Q:

max_Q = q

# Q = [(1-a) * Q] + [a * (rt + (g * maxQ))]

Q[curr_s][next_s] = ((1 - lrn_rate) * Q[curr_s] \

[next_s]) + (lrn_rate * (R[curr_s][next_s] + \

(gamma * max_Q)))
 curr_s = next_s

if curr_s == goal: break

Riječima, u lavirintu stalno počinjete u nasumičnom stanju. Zatim, na svakoj poziciji ćelije,
birate nasumično sljedeće stanje i također određujete sva moguća stanja nakon sljedećeg stanja -
to se ponekad nazivaju "sljedeća-sljedeća stanja". Ispitujete trenutne Q vrijednosti i pronalazite
najveću vrijednost od sljedećeg stanja do bilo kojeg sljedećeg stanja. Ova najveća vrijednost,
max_Q, koristi se u iskazu koji ažurira Q matricu.

Za svako nasumično početno stanje, ponavljate ovaj proces dok ne dođete do ciljnog stanja. Ovo
pretpostavlja da je ciljno stanje dostižno, tako da u nekim problemima morate primijeniti
maksimalnu kontrolnu varijablu petlje.

Na primjer, pretpostavimo da ste u nekom trenutku tokom treninga u ćeliji 4 i sljedeće

nasumično stanje je odabrano kao ćelija 9. Sljedeća stanja su 4 i 14. Budući da prelazak u ćeliju
14 ima nagradu od +10,0, vrijednost Q[4][9] će se povećati, čineći taj put privlačnijim od putanje
od ćelije 4 do ćelije 3. Pametno!

Hodanje po Q matrici

Nakon što je Q matrica izračunata, može je koristiti funkcija walk() da pokaže najkraći put od
bilo koje početne ćelije do bilo koje ciljne ćelije u lavirintu. Funkcija walk() je definirana:

def walk(start, goal, Q):

curr = start

print(str(curr) + "->", end="")

 while curr != goal:

next = np.argmax(Q[curr])

print(str(next) + "->", end="")

curr = next

print("done")

Ključ funkcije walk() je funkcija np.argmax(), koja vraća indeks najveće vrijednosti ulaznog
vektora funkcije. Na primjer, ako je vektor v imao vrijednosti (8, 6, 9, 4, 5, 7), tada bi poziv
np.argmax(v) vratio 2. Funkcija walk() pretpostavlja da je ciljno stanje dostupno.

Demo program definira pomoćnu metodu my_print() za prikaz izračunate Q matrice:

def my_print(Q):

rows = len(Q); cols = len(Q[0])

print(" 0 1 2 3 4 5\

6 7 8 9 10 11 12\

13 14")

for i in range(rows):

print("%d " % i, end="")

if i < 10: print(" ", end="")

for j in range(cols): print(" %6.2f" % Q[i,j], end="")

print("")
 print("")

Funkcija my_print() je tvrdo kodirani hak dizajniran da radi samo sa demo labirintom.

Wrapping Up

Ovdje predstavljeni primjer Q-učenja trebao bi vam dati razumno dobro razumijevanje
uključenih općih principa. Glavni problemski scenario je onaj u kojem imate skup diskretnih
stanja, a izazov je izvršiti niz radnji koje pronalaze dugoročnu nagradu, bez eksplicitnog
definiranja pravila. Q-učenje može biti korisno kada možete bezbedno da trenirate fizički sistem
sa mnogo pokušaja, kao što je obučavanje robota za usisivač kako da se kreće kroz prostoriju.
Ali Q-učenje nije primjenjivo u scenarijima kao što je obučavanje automobila bez vozača kako
da se kreće kroz saobraćaj (osim ako nemate dostupan vrlo sofisticiran sistem simulacije).