Invatare Automata: Laboratorul 12 –

Clasificare folosind Support Vector

Machines
Alexandru Sorici
22. 03. 2020

1 Scoptul Laboratorului
Scopul laboratorului il reprezinta intelegerea si implementarea unui clasifi-
cator SVM, ce poate folosi mai multe tipuri de kernel-uri. In cadrul labora-
torului se vor face operatii de clasificare pe seturi de date sintetice, ce pun in
evidenta utilitatea kernel-urilor atunci cand spatiul de intrare nu este liniar
separabil. Rezolvarea cerintelor se va face pas cu pas urmand indicatiile si
explicatiile primite.

2 Descriere teoretica
SVM-urile sunt clasificatoare decizionale (i.e. nu au ca rezultat o probabili-
tate ca un input sa faca parte dintr-o clasa data).
O proprietate importanta a SVM-urilor este ca determinarea parametrilor
modelului se face prin rezolvarea unei probleme de optimizare convexa, ceea
ce inseamna ca orice solutie locala este si un optim global.
SVM-ul este un clasificator binar, iar problema pe care incearca sa o re-
zolve este gasirea unui hiperplan de separatie care maximizeaza marginea
intre hiperplan si cele mai apropiate exemple pozitive si negative (vezi Figura
2).

2.1 Cazul spatiilor de intrare liniar separabile

Pe cazul liniar, forma pe care o ia clasificatorul este data de ecuatia:

y(x) = wT x + b (1)

1
Figure 1: Vizualizare a hiperplanului de separatie si a vectorilor de suport.

unde y(x) este eticheta ∈ {−1, 1} pentru intrarea x, w este un vector de

ponderi, iar b este termenul de bias.
In acest caz, problema de optimizare corespunzatoare unui SVM se for-
muleaza astfel:
1
minw,b kwk2
2 (2)
a.i. y (i) (wT x(i) + b) ≥ 1, i = 1, . . . , n

Ecuatia (2) reprezinta formularea primara a problemei de optimizare pa-

tratica specifice SVM-ului, care cauta coeficientii w si b a.i. marginea hiper-
planului de separatie sa fie maxima.
Forma obtinuta se rezolva insa dificl, astfel incat, in practica se opteaza
pentru o formulare duala, ce face apel la multiplicatori Lagrange si pentru
care se pot utiliza algoritmi de optimizare patratica mai eficienti. Pentru
cateva detalii privind dualitatea Lagrange in probleme generale de optimizare
parcurgeti sectiunea 5 din aceste notite de curs1 .
1
http://cs229.stanford.edu/notes/cs229-notes3.pdf

2
 In cazul unui SVM liniar, problema de optimizare duala se scrie precum
in ecuatia (3).
n n
X 1 X (i) (j)
maxa L(a) = ai − y y ai aj hx(i) x(j) i
i=1
2 i,j=1
a.i. ai ≥ 0, i = 1, . . . , n (3)
X n
ai y (i) = 0
i=1

unde ai sunt multiplicatorii Lagrange, iar hx(i) x(j) i reprezinta produsul scalar
al inputurilor x(i) si x(j) .
Obtinand valorile multiplicatorilor Lagrange, parametrii initiali ai formularii
primare se obtin astfel:
Xn
w= ai y (i) x(i) (4)
i=1
!
1 X (i) X
b= y − aj y (j) hx(i) x(j) i (5)
NS i∈S j∈S

unde S este multimea vectorilor de suport (|S| = NS ), adica acele intrari

x(i) pentru care multiplicatorul Lagrange aferent ai = 0. Cu alte cuvinte,
doar vectorii de suport vor juca un rol in predictiile pe care le face un SVM
antrenat. Forma initiala a predictorului poate fi rescrisa in functie de multi-
plicatorii Lagrange ca fiind:
X
y(x) = ai y (i) hx(i) xi + b (6)
i∈S

2.2 Cazul spatiilor de intrare ne-separabile liniar

In multe probleme de clasificare se poate intampla ca spatiul intrarilor sa nu
admita o separare liniara a inputurilor pozitive si negative. In acest caz, o
tehnica adoptata este cea a unei transformari a vectorilor de intrare intr-un
spatiu al caracteristicilor (input space to feature space mapping), avand o
dimensionalitate mai mare decat cea a spatiului initial de intrare. Intuitia
este ca aceasta mapare poate duce la gasirea unui hiperplan de separatie in
spatiul caracteristicilor.
Forma clasificatorului SVM devine atunci:

y(x) = wT φ(x) + b (7)

3
unde φ(x) este functia de mapare in spatiul caracteristicilor (feature space).

In practica, un spatiu al caracteristicilor mai mare presupune un efort

computational mai mare. Pentru a evita acest lucru, se face uz de asa numitul
0
”kernel trick”2 . Acesta se refera la capacitatea unor functii k(x, x ) definite
peste un domeniu χ de a fi exprimate ca produs scalar intr-un alt domeniu
ν.
0 0
Functia k : χ × χ → R, k(x, x ) = hφ(x), φ(x )iν poarta atunci numele de
functie kernel.
In cadrul laboratorului vom folosi doua astfel de kernel-uri: cel liniar
(care corespunde produsului scalar exact in spatiul de intrare) si Radial Basis
Function3 .
Folosind functiile kernel, reprezentarea duala a problemei de optimizare
din cadrul SVM-urilor (ecuatia (3)) se rescrie astfel:
n n
X 1 X (i) (j)
maxa L(a) = ai − y y ai aj k(x(i) , x(j) )
i=1
2 i,j=1
a.i. ai ≥ 0, i = 1, . . . , n (8)
X n
ai y (i) = 0
i=1

Predictia unui SVM antrenat (i.e. pentru care s-au determinat multipli-
catorii Lagrange) ajunge sub forma:
X
y(x) = ai y (i) k(x(i) , x) + b (9)
i∈S

In practica, in procedura de antrenare a unui SVM, se precalculeaza valo-

rile functiei kernel alese pentru orice pereche x(i) , x(j) , stocand valorile intr-o
matrice Ki,j = k(x(i) , x(j) , denumita matricea Gram sau matricea kernel.

Cazul claselor suprapuse si gestiunea regularizarii

Trecerea intr-un spatiu al caracteristicilor de dimensionalitate mai mare (ex-
plicat in sectiunea 2.2) creste de multe ori probabilitatea ca datele sa ajunga
separabile liniar. Totusi, acest lucru nu poate fi garantat.
In plus, in unele cazuri nu este clar daca a gasi un hiperplan de separatie
exacta este lucrul cel mai de dorit, pentru ca putem ajunge susceptibili la
valori extreme (outliers).
2
https://en.wikipedia.org/wiki/Kernel method
3
https://en.wikipedia.org/wiki/Radial basis function kernel

4
 Pentru a aborda problemele acestea, in problema de optimizare a SVM-
ului se introduc variabile de regularizare ce au menirea sa reduca ”strictetea”
cu care se urmareste gasirea hiperplanului cu margine maximala.
Forma problemei de optimizare primara se modifica astfel:
n
1 X
minw,b kwk2 + C ξi
2 i=1
(10)
a.i. y (i) (wT x(i) + b) ≥ 1 − ξi , i = 1, . . . , n
ξi ≥ 0, i = 1, . . . , n

Astfel, pentru fiecare vector de intrare permitem acum de a avea o margine

≤ 1, iar daca un exemplu din setul de date are marginea 1−ξi , costul functiei
obiectiv ar creste cu Cξi . Parametru C controleaza astfel importanta pe care
o acordam clasificarii corecte a fiecarui punct din setul de date. Pentru valori
mari (e.g. 1000) se poate obtine un hiperplan cu margine mai mica, daca
acel hiperplan va clasifica in mod corect fiecare exemplu. Pentru valori mici
(e.g. 0.1), hiperplanul va avea margine mai mare, dar va permite clasificarea
incorecta a catorva exemple.
In privinta problemei duale, formularea acesteia devine:
n n
X 1 X (i) (j)
maxa L(a) = ai − y y ai aj k(x(i) , x(j) )
i=1
2 i,j=1
a.i. 0 ≤ ai ≤ C, i = 1, . . . , n (11)
X n
ai y (i) = 0
i=1

Formularea pentru predictia SVM-ului ramane aceeasi, dar setul vecto-

rilor de suport S se modifica, incluzand doar acele intrari x(i) pentru care
0 < ai < C

5
Învăt, are Automată - Laboratorul 4
Metode de programare dinamică pentru rezolvarea proceselor markov de decizie

Tudor Berariu

Facultatea de Automatică s, i Calculatoare

Scopul laboratorului

• Scopul laboratorului ı̂l reprezintă ı̂nt, elegerea conceptelor de proces markov de decizie,
politică, valoare de stare, precum s, i implementarea unor metode de programare dinamică
pentru rezolvarea problemei de control a unui MDP.

• În cadrul laboratorului vet, i:

1. implementa algoritmul de iterare a politicilor;
2. implementa algoritmul de iterare a valorilor de stare.

1
Proces Markov de decizie finit. Politică

• Un proces Markov de decizie finit este un obiect matematic compus din:

• o mult, ime finită de stări S
• submult, imea S − ⊂ S reprezintă stările neterminale.
• o mult, ime finită de act, iuni A
• o mult, ime finită de valori, numite recompense R
• o funct, ie p : S × A × S × R → [0, 1] ce descrie dinamica mediului:
not.
p(s, a, s 0 , r ) = p(s 0 , r |s, a) = P St+1 = s 0 , Rt+1 = r | St = s, At = a

• un factor de atenuare γ ∈ [0, 1].

• O politică deterministă reprezintă o funct, ie π : S − → A care indică o act, iune pentru
fiecare stare neterminală.
• Un proces Markov de decizie finit s, i o politică induc traiectorii de tipul:

S0 , A0 , R1 , S1 , A1 , . . . , St , At , Rt+1 , St+1 , . . . , RT , ST

2
Valoare de stare

• Câs, tigul mediu dintr-o stare s ∈ S indus de o politică π:

"  #
X 
π 2 τ −t−1
  
v (s) = Eπ Rt+1 + γRt+2 + γ Rt+3 + . . .St = s = Eπ γ Rτ St = s


τ =t+1

= Eπ [Gt |St = s]

• Relat, iile dintre valorile de stare induse de o politică deterministă (ecuat, iile Bellman):
XX
v π (s) = p(s 0 , r |s, π(s)) [r + γv π (s 0 )]
s 0 ∈S r ∈R

• Scopul ı̂nvăt, ării prin recompensă ı̂l reprezintă găsirea unei politici optime π ∗ :

π ∗ = argmax Eπ [Gt ] = argmax Eπ [v π (St )]

π π

3
Evaluarea unei politici

• Problema evaluării unei procedure PolicyEvaluation(hS, A, R, p, γi, π, )

politici presupune for all s ∈ S do
determinarea funct, iei v (s) ← 0 . Valorile init, iale sunt zero.
valoare v π : S → R indusă end for
de acea politică. repeat
δ←0
v π (s) = Eπ [Gt | St = s] for all s ∈ S − do
vold ← v (s)
• Algoritmul Policy
v (s) ← s 0 ∈S r ∈R p(s 0 , r |s, π(s)) [r + γv (s 0 )]
P P
Evaluation construies, te o
δ ← max(δ, |v (s) − vold |)
estimare a acestei funct, ii
end for
pentru o politică
until δ < 
detrministă.
return v
v (s) ≈ v π (s), ∀s ∈ S end procedure

4
Iterarea politicilor
procedure PolicyIteration(hS, A, R, p, γi, )
for all s ∈ S do
π(s) ← random(A)
• Fiind dată o politică deterministă π v (s) ← 0
end for
s, i funct, ia valoare v π indusă de repeat
aceasta se poate obt, ine o politică repeat . Se evaluează politica curentă.
δ←0
mai bună π 0 alegând act, iunile ı̂n −
for all s ∈ S do
mod lacom ı̂n raport cu v π . vold ← v (s)
P P 0
 0

X v (s) ← s 0 ∈S r ∈R p(s , r |s, π(s)) r + γv (s )
π 0 (s) ← argmax p(s 0 , r |s, a) [r + γv (s 0 )] δ ← max(δ, |v (s) − vold |)
a∈A end for
s 0 ,r
until δ < 
done ← True
• Algoritmul Policy Iteration găses, te for all s ∈ S − do . Se ı̂mbunătăt, es, te politica.
aold ← π(s)
o politică optimă alternând pas, i de P
π(s) ← argmax s 0 ∈S
P 0
 0

r ∈R p(s , r |s, a) r + γv (s )
a∈A
evaluare s, i de ı̂mbunătăt, ire a politicii. done ← done ∧ (aold = π(s))
π0 → v π 0 → π1 → v π 1 → π2 → . . . → π ∗ end for
until done
return π, v
end procedure 5
Iterarea politicilor
procedure PolicyIteration(hS, A, R, p, γi, )
for all s ∈ S do
π(s) ← random(A) . Politica init, ială este aleatoare.
• Fiind dată o politică deterministă π v (s) ← 0 . Valorile init, iale sunt zero.
end for
s, i funct, ia valoare v π indusă de repeat
aceasta se poate obt, ine o politică repeat . Se evaluează politica curentă.
δ←0
mai bună π 0 alegând act, iunile ı̂n −
for all s ∈ S do
mod lacom ı̂n raport cu v π . vold ← v (s)
P P 0
 0

X v (s) ← s 0 ∈S r ∈R p(s , r |s, π(s)) r + γv (s )
π 0 (s) ← argmax p(s 0 , r |s, a) [r + γv (s 0 )] δ ← max(δ, |v (s) − vold |)
a∈A end for
s 0 ,r
until δ < 
done ← True
• Algoritmul Policy Iteration găses, te for all s ∈ S − do . Se ı̂mbunătăt, es, te politica.
aold ← π(s)
o politică optimă alternând pas, i de P
π(s) ← argmax s 0 ∈S
P 0
 0

r ∈R p(s , r |s, a) r + γv (s )
a∈A
evaluare s, i de ı̂mbunătăt, ire a politicii. done ← done ∧ (aold = π(s))
π0 → v π 0 → π1 → v π 1 → π2 → . . . → π ∗ end for
until done . se opres, te atunci când politica devine stabilă.
return π, v
end procedure 5
Iterarea valorilor
procedure ValueIteration(hS, A, R, p, γi, )
• Algoritmul de iterare a for all s ∈ S do
politicilor (slide-ul anterior) v (s) ← 0
alocă efort computat, ional end for
pentru aproximarea cu repeat
δ←0
precizie a funct, iei de valoare
for all s ∈ S − do
pentru fiecare politică.
vold ← v (s)
• Algoritmul poate fi v (s) ← maxa s 0 ∈S r ∈R p(s 0 , r |s, a) [r + γv (s 0 )]
P P
modificat prin reducerea δ ← max(δ, |v (s) − vold |)
acestui efort fără a pierde end for
garant, ia convergent, ei until δ < 
cobinând ı̂ntr-o singură for all s ∈ S − do . Se extrage politica optimă
π(s) ← argmax s 0 ∈S r ∈R p(s 0 , r |s, a) [r + γv (s 0 )]
P P
operat, ie un pas de evaluare a∈A
a politicii s, i unul de end for
ı̂mbunătăt, ire a acesteia. return π, v
end procedure 6
Iterarea valorilor
procedure ValueIteration(hS, A, R, p, γi, )
• Algoritmul de iterare a for all s ∈ S do
politicilor (slide-ul anterior) v (s) ← 0
alocă efort computat, ional end for
pentru aproximarea cu repeat
δ←0
precizie a funct, iei de valoare
for all s ∈ S − do
pentru fiecare politică.
vold ← v (s)
• Algoritmul poate fi v (s) ← maxa s 0 ∈S r ∈R p(s 0 , r |s, a) [r + γv (s 0 )]
P P
modificat prin reducerea δ ← max(δ, |v (s) − vold |)
acestui efort fără a pierde end for
garant, ia convergent, ei until δ < 
cobinând ı̂ntr-o singură for all s ∈ S − do . Se extrage politica optimă
π(s) ← argmax s 0 ∈S r ∈R p(s 0 , r |s, a) [r + γv (s 0 )]
P P
operat, ie un pas de evaluare a∈A
a politicii s, i unul de end for
ı̂mbunătăt, ire a acesteia. return π, v
end procedure 6
Problema de rezolvat

• Un agent se mis, că pe o hartă bidimensională.

• La fiecare moment de timp agentul se află ı̂ntr-o celulă s, i poate alege o act, iune de
deplasare către una din cele patru direct, ii: nord, est, sud, sau vest.
• Efectele unei act, iuni sunt stocastice.
• Act, iunea agentului reus, es, te cu probabilitatea .8.
• Agentul va ajunge deviat cu 90◦ spre stânga cu probabilitatea .1 s, i deviat spre dreapta cu
90◦ cu probabilitatea .1.
• Dacă agentul se ı̂ndrreaptă către un perete, atunci rămâne ı̂n celula curentă.
• Se cere găsirea unei politici optime pentru astfel de hărt, i.

7
Hărt, ile de test

Hartă simplă cu două stări finale. Hartă care cere să fii precaut. Mai bine mor decât să sufăr.

A:-10 A:-10 A:-1

B:1 B:-10 B:1
default:0 C:1 default:-.5
xxxxxxxxx default:0 xxxxxxxxx
x Bx xxxxxxxxx x Bx
x xxx x x Bx x xxx x
x A x x xxx Cx x A x
x x x A x x x
xxxxxxxxx x x xxxxxxxxx
xxxxxxxxx

8
Clasa Maze

class Maze:
Metoda effects primes, te o stare s s, i o
def __init__(self, map_name):
... act, iune a s, i ı̂ntoarce o listă de tupluri (s 0 , p, r )
cu următoarea semnificat, ie:
@property
def actions(self):
... p = P (St+1 = s 0 , Rt+1 = r | St = s, At = a)

@property In [2]: m = Maze("simple")

def states(self):
In [3]: m.effects((1, 1), Maze.NORTH)
...
Out[3]: [((1, 1), 0.9, 0.0), ((1, 2), 0.1, 0.0)]

def is_final(self, state): In [4]: m.effects((1, 2), Maze.SOUTH)

Out[4]: [((1, 3), 0.1, 0.0), ((2, 2), 0.8, 0.0), ((1, 1), 0.1, 0.0)]
...
In [7]: m.print_policy({s: choice(m.actions) for s in m.states if not m.is_final(s)})
def effects(self, state, action): ...
...

9
Cerint, e
1. Implementat, i algoritmul
Policy Iteration pentru
găsirea unei politici
optime pentru jocul
Maze.
2. Implementat, i algoritmul
Value Iteration pentru
găsirea unei politici
optime pentru jocul
Maze.
• Modificat, i codul din cele
două funct, ii.
def policy_iteration(game, args):
gamma = args.gamma
max_delta = args.max_delta
v = {s: 0 for s in game.states}
policy = {s: choice(game.actions)
for s in game.states if not game.is_final(s)}
return policy, v
def value_iteration(game, args):
gamma = args.gamma
max_delta = args.max_delta
v = {s: 0 for s in game.states}
policy = {s: choice(game.actions)
for s in game.states if not game.is_final(s)}
return policy, v
10
Învăt, are Automată - Laboratorul 5
Algoritmul Q-Learning

Tudor Berariu

Facultatea de Automatică s, i Calculatoare

Scopul laboratorului

• Scopul laboratorului ı̂l reprezintă ı̂nt, elegerea s, i implementarea algoritmului Q-Learning.

1
Amintiri din laboratorul 4

• În cadrul laboratorului 4 at, i implementat doi algoritmi de programare dinamică pentru
găsirea unei politici optime pentru un MDP.
• Algoritmii Policy Iteration s, i Value Iteration presupuneau o cunoas, tere completă a
dinamicii mediului.
• În majoritatea problemelor reale dinamica mediului nu este cunoscută, iar agentul trebuie
să estimeze câs, tigurile s, i să ı̂s, i ı̂mbunătăt, ească politica pe baza interact, iunii directe cu
mediul.

2
Valoarea act, iunii ı̂ntr-o stare

• Câs, tigul mediu adus de o act, iune a dintr-o stare s indus de o politică π:

q π (s, a) = Eπ Rt+1 + γRt+2 + γ 2 Rt+3 + . . .St = s, At = a

  
"  #
X 
τ −t−1
= Eπ γ Rτ St = s, At = a = Eπ [Gt |St = s, At = a]


τ =t+1

• Relat, iile dintre valorile q induse de o politică deterministă (ecuat, iile Bellman):

q π (s, a) = Eπ [Rt+1 + γq π (St+1 , At+1 )|St = s, At = a]

XX
= p(s 0 , r |s, a) [r + γq π (s 0 , π(s 0 ))]
s 0 ∈S r ∈R

3
Algoritmul Q-learning

• Agentul ı̂nvat, ă prin interact, iune cu procedure Q-Learning(hS, A, γi, )

for all s ∈ S, a ∈ A do
mediul observând consecint, ele q(s, a) ← 0 . Valorile init, iale sunt zero.
act, iunilor pe care le ia. end for
for all episodes do
s ← stare init, ială
while s nu este stare finală do
alege act, iunea a conform -Greedy(s, q, )
execută a s, i observă recompensa r s, i noua stare s 0
q(s, a) ← q(s, a) + α r + γmaxa0 q(s 0 , a0 ) − q(s, a)


0
s ←s
end while
end for
for all s ∈ S do . Construim politica lacomă ı̂n raport cu q.
π(s) ← argmax q(s, a)
procedure -Greedy(s, q, ) a∈A
cu probabilitate : return random(A) end for
cu probabilitate 1 − : return argmax q(s, a) return π
a∈A end procedure
end procedure

4
Algoritmul Q-learning

• Agentul ı̂nvat, ă prin interact, iune cu procedure Q-Learning(hS, A, γi, )

for all s ∈ S, a ∈ A do
mediul observând consecint, ele q(s, a) ← 0 . Valorile init, iale sunt zero.
act, iunilor pe care le ia. end for
for all episodes do
• Valorile q sunt ajustate prin diferent, e s ← stare init, ială
temporale. while s nu este stare finală do
alege act, iunea a conform -Greedy(s, q, )
execută a s, i observă recompensa r s, i noua stare s 0
q(s, a) ← q(s, a) + α r + γmaxa0 q(s 0 , a0 ) − q(s, a)


0
s ←s
end while
end for
for all s ∈ S do . Construim politica lacomă ı̂n raport cu q.
π(s) ← argmax q(s, a)
procedure -Greedy(s, q, ) a∈A
cu probabilitate : return random(A) end for
cu probabilitate 1 − : return argmax q(s, a) return π
a∈A end procedure
end procedure

4
Algoritmul Q-learning

• Agentul ı̂nvat, ă prin interact, iune cu procedure Q-Learning(hS, A, γi, )

for all s ∈ S, a ∈ A do
mediul observând consecint, ele q(s, a) ← 0 . Valorile init, iale sunt zero.
act, iunilor pe care le ia. end for
for all episodes do
• Valorile q sunt ajustate prin diferent, e s ← stare init, ială
temporale. while s nu este stare finală do
alege act, iunea a conform -Greedy(s, q, )
• Învăt, area este off-policy execută a s, i observă recompensa r s, i noua stare s 0
q(s, a) ← q(s, a) + α r + γmaxa0 q(s 0 , a0 ) − q(s, a)


• politica ı̂nvăt, ată este lacomă s ←s 0

• politica de joc permite explorare end while

end for
for all s ∈ S do . Construim politica lacomă ı̂n raport cu q.
π(s) ← argmax q(s, a)
procedure -Greedy(s, q, ) a∈A
cu probabilitate : return random(A) end for
cu probabilitate 1 − : return argmax q(s, a) return π
a∈A end procedure
end procedure

4
Algoritmul Q-learning

• Agentul ı̂nvat, ă prin interact, iune cu procedure Q-Learning(hS, A, γi, )

for all s ∈ S, a ∈ A do
mediul observând consecint, ele q(s, a) ← 0 . Valorile init, iale sunt zero.
act, iunilor pe care le ia. end for
for all episodes do
• Valorile q sunt ajustate prin diferent, e s ← stare init, ială
temporale. while s nu este stare finală do
alege act, iunea a conform -Greedy(s, q, )
• Învăt, area este off-policy execută a s, i observă recompensa r s, i noua stare s 0
q(s, a) ← q(s, a) + α r + γmaxa0 q(s 0 , a0 ) − q(s, a)


• politica ı̂nvăt, ată este lacomă s ←s 0

• politica de joc permite explorare end while

end for
for all s ∈ S do . Construim politica lacomă ı̂n raport cu q.
π(s) ← argmax q(s, a)
procedure -Greedy(s, q, ) a∈A
cu probabilitate : return random(A) end for
cu probabilitate 1 − : return argmax q(s, a) return π
a∈A end procedure
end procedure

4
Greuceanu s, i Balaurul

• Pe o hartă bidimensională se ı̂nfruntă Greuceanu s, i-un balaur. Greuceanu trebuie să

găsească mărul fermecat ı̂nainte de a fi prins de balaur s, i ı̂nainte ca balaurul să calce pe
măr.
• Balaurul simte direct, a ı̂n care se află Greuceanu s, i se ı̂ndreaptă către el.
• Greuceanu câs, tigă jocul s, i primes, te 10 puncte dacă ajunge primul la mărul fermecat.
Greuceanu pierde jocul dacă este prins de balaur sau dacă balaurul calcă pe măr. De
asemenea, la fiecare moment de timp Greuceanu pierde câte 0.1 puncte. Dacă ajunge la
-20 de puncte Greuceanu pierde jocul.

5
Abstractizarea jocului

• get initial state(input file) primes, te calea unui fis, ier ce cont, ine harta jocului s, i
ı̂ntoarce starea init, ială.
• get valid actions(state) primes, te o stare s, i ı̂ntoarce o listă de act, iuni ce pot fi
executate ı̂n acea stare.
• apply action(state, action) primes, te o stare s, i o act, iune s, i ı̂ntoarce starea ı̂n care se
ajunge, recompensa s, i un mesaj despre joc
• is final state(state, score) primes, te starea s, i scorul curente s, i verifică dacă
episodul s-a ı̂ncheiat.
• display state(state) afis, ează starea curentă.

6
Cerint, e

[6p] Implementat, i algoritmul Q-learning.

[2p] Implementat, i strategia -Greedy de select, ie a unei act, iuni. Dacă există act, iuni
ce nu au fost explorate, atunci se va alege aleator una dintre acelea. Altfel, cu o
probabilitate  se va alege aleator o act, iune, iar cu probabilitate 1 −  se va alege
cea mai bună act, iune din starea respectivă.
[2p] Implementat, i rutine de evaluare a politicii lacome ı̂nvăt, ate.
[2p] Găsit, i parametrii potrivit, i pentru o ı̂nvăt, are cât mai rapidă pe toate cele trei
hărt, i. Încercat, i s, i modificarea lui  pe parcursul ı̂nvăt, ării.