Azberatucdetectareplagiatrogmail.com 601 Licenta Tudor Petre Radu (1) [607274]

Licență

Azberatucdetectareplagiatrogmail.com 601 Licenta Tudor Petre Radu (1) [607274]

Byadmin ianuarie 1, 2024

Universitatea din Bucures ,ti
Facultatea de Matematică s ,i Informatică
LUCRARE DE LICENT ,Ă
Coordonator Absolvent: [anonimizat] ,ti
Iunie 2018

Universitatea din Bucures ,ti
Facultatea de Matematică s ,i Informatică
LUCRARE DE LICENT ,Ă
Agent Inteligent Pentru Jocuri pe Calculator
Antrenat pe Baza Imaginilor Folosind Învăt ,are
Ranforsată
Coordonator Absolvent: [anonimizat] ,ti
Iunie 2018

Referat asupra lucrării de licență “Agent Inteligent pentru Jocuri pe Calculator Antrenat pe baza Imaginilor folosind Învățare Ranforsată” realizată de Petre Radu Tudor Scopul acestei lucrări este de a realiza o incursiune într-un domeniu de actualitate al informaticii și anume antrenarea unui agent inteligent capabil să joace jocuri 2D pe baza capturilor de ecran ale jocurilor, folosind tehnici de utimă oră din Inteligența Artificială. În dezvoltarea modelului, autorul a utilizat limbajul de programare python, precum și librăria tensorflow. Lucrarea este structurată în cinci capitole. În primul capitol, autorul realizează o scurtă prezentare a temei abordate și a tehnicilor folosite pentru construirea agenților inteligenți. În al doilea capitol, autorul realizează o trecere în revistă a conceptelor teoretice studiate, anume învățarea automată, învățarea ranforsată de tip "deep", rețelele neuronale "state-of-the-art". În al treilea capitol sunt descrise metodele recente utilizate pentru rezolvarea problemei abordate în lucrare. Totodată, capitolul al treilea prezintă modelul propus pentru antrenarea bazată pe învățarea ranforsată a unui agent inteligent capabil să joace jocuri 2D având ca intrare capturi de ecran ale jocurilor. Al treilea capitol se încheie cu o serie de rezultate experimentale. În al patrulea capitol, autorul descrie tehnologiile folosite pentru dezvoltarea modelului, anume limbajul de programare python și librăriile numpy, tensorflow, pygame, shapely. Al cincilea capitol prezintă concluziile lucrării de față, precum și posibile dezvoltări ulterioare. În urma unei activități complexe de cercetare și documentare autorul reușește să elaboreze o lucrare originală și riguroasă, susținută și de o demonstrație practică a agentului antrenat. Lucrarea este deosebită prin faptul că încorporează un algoritm de învățare ranforsată "deep", care necesită un timp îndelungat de antrenare. Atât prin prisma temei abordate cât și prin rezultatele experimentale obținute, autorul a dat dovadă că stăpânește concepte avansate din domeniul Inteligenței Artificiale. Consider că lucrarea îndeplinește toate condițiile pentru a fi prezentată drept lucrare de licență. Propun notarea cu 10 (zece). Conf. Dr. Radu Ionescu

Cuprins
1 Introducere 3
2 Concepte Teoretice 5
2.1 Statistică s ,i Teoria Probabilităt ,ii . . . . . . . . . . . . . . . . . . . . . . 5
2.1.1 Eveniment. Spat ,iul de Evenimente. . . . . . . . . . . . . . . . . 5
2.1.2 Probabilitate. Spat ,iu de Probabilitate. . . . . . . . . . . . . . . . 6
2.1.3 Independent ,a Evenimentelor . . . . . . . . . . . . . . . . . . . . 7
2.1.4 Variabile Aleatoare . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2 Învăt ,area Automată . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2.1 Sarcinile, T. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2.2 Măsura performant ,ei,P. . . . . . . . . . . . . . . . . . . . . . 11
2.2.3 Experient ,a,E. . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2.4 Capacitatea de Generalizare . . . . . . . . . . . . . . . . . . . . 12
2.2.5 Hiperparametri s ,i Datele de Validare . . . . . . . . . . . . . . . . 13
2.2.6 Estimatori, "Bias" s ,i Variant ,ă . . . . . . . . . . . . . . . . . . . 14
2.2.7 Consistent ,a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.2.8 Optimizarea pe baza Gradientului . . . . . . . . . . . . . . . . . 17
2.3 Ret ,ele Neuronale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.3.1 Ret ,ele cu Propagare Înainte . . . . . . . . . . . . . . . . . . . . 20
2.3.2 Antrenarea Ret ,elelor pe baza Gradientului . . . . . . . . . . . . . 23
2.3.3 Ret ,ele Neuronale Convolut ,ionale . . . . . . . . . . . . . . . . . 26
2.4 Învăt ,area Ranforsată . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.4.1 Procese de Decizie Markov . . . . . . . . . . . . . . . . . . . . . 30
1

Cuprins
3 Metode recente pentru problema aleasă 35
3.1 Jucând Atari prin Învăt ,are Ranforsată "Deep" . . . . . . . . . . . . . . . 35
3.1.1 Algoritm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.1.2 Rezultate s ,i Experimente . . . . . . . . . . . . . . . . . . . . . . 39
3.2 Control la Nivel Uman prin Învăt ,are Ranforsată "Deep" . . . . . . . . . . 41
3.2.1 Algoritm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.2.2 Rezultate s ,i Experimente . . . . . . . . . . . . . . . . . . . . . . 42
3.3 Depăs ,irea Uitării Catastrofale în Ret ,elele Neuronale . . . . . . . . . . . . 42
3.3.1 Rezultate s ,i Experimente . . . . . . . . . . . . . . . . . . . . . . 45
4 Algoritm s ,i Rezultate 47
4.1 Algoritmul Propus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
4.2 Jocuri Propuse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
4.2.1 Atari . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
4.2.2 Jocuri Implementate Personal . . . . . . . . . . . . . . . . . . . 54
4.3 Rezultate s ,i Experimente . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.3.1 Atari . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
4.3.2 Consolidarea Ponderilor Elastice . . . . . . . . . . . . . . . . . . 65
4.3.3 Jocuri Implementate Personal . . . . . . . . . . . . . . . . . . . 67
5 Tehnologii Folosite 75
5.1 Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
5.2 NumPy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
5.3 Tensorﬂow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
5.4 Arcade Learning Environment . . . . . . . . . . . . . . . . . . . . . . . 90
5.5 Pygame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
5.6 Shapely . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
6 Concluzii 100
Bibliograﬁe 102
2

Capitolul 1
Introducere
În mediul digital, jocurile au apărut cu scopul principal de a oferi utilizatorilor o
formămodernă,accesibilădedestindere,deodisponibilitatesemniﬁcativridicatăfat ,ăde
cea a jocurilor tradit ,ionale (de exemplu, jocurile sportive, jocurile de cărt ,i, s,ahul etc.),
care inevitabil necesitau aproape de ﬁecare dată participarea a mai multor jucători s ,i
pretindeauresurses ,i/saucondit ,iiparticularegreudereprodussaugreudeobt ,inut,inutile
înafaracontextuluijoculuirespectivsaualuneiclaserestrânsedejocuriasemănătoarecu
jocul respectiv (de exemplu, un teren de joc, un pachet de cărt ,i, o tablă de joc). Jocurile
digitale au reprezentat un prim pas în centralizarea resurselor de joc, în eﬁcientizarea s ,i
uniformizarea producerii lor s ,i în automatizarea atât a arbitrajului regulilor jocurilor, cât
s,iajucătorilorpropriu-zis ,i,prinintermediul,înmareparte,aunorprogramedeterministe
care iau decizii perfectibile pe baza stării jocului, cunoscută s ,i controlabilă în întregime
la ﬁecare moment de timp. Astfel s-a produs desolidarizarea unei activităt ,i care a făcut
parte mult timp din sfera ocupat ,iilor umane sociale, fapt care a permis, împreună cu
restul avantajelor platformelor digitale aﬂate în plină dezvoltare, crearea unui domeniu
comercial extraordinar de proﬁtabil.
În esent ,ă, jocurile reprezintă o simulare. Ele imită, incomplet s ,i imperfect, fenomene
s,i concepte care alcătuiesc realitatea obiectivă s ,i realitatea interpretată cu care oamenii
interact ,ionează. În acest sens, jocurile digitale reprezintă o multitudine de reguli s ,i feno-
mene, de data aceasta discrete, cu care utilizatorii interact ,ionează s ,i care interact ,ionează
înapoicuutilizatorii,prinintermediulsimt ,urilor: vederea,auzul,simt ,ultactil. Eleconsti-
3

Capitolul 1. Introducere
tuiemodelealelumiiînconjurătoare,carecompromitcomplexitateînschimbulcontrolului
deplin asupra lor. Des ,i init,ial banale, aceste modele continuă să evolueze împreună cu
capacitatea ﬁzică a platformelor pe care sunt dezvoltate (de la platformele consolelor
trecutului la calculatoarele din prezent s ,i până la dispozitivele de realitate virtuală din
viitor).
În acest viitor context al jocurilor digitale ca simulări verosimile, ele reprezintă un
mediu propice pentru dezvoltarea unor agent ,i inteligent ,i autonomi care să poată opera
în sens general cu lumea obiectivă exterioară. Jocurile oferă o multitudine de avantaje
în acest scop, printre care cele mai semniﬁcative ﬁind eﬁcient ,a cu care un astfel de
agent inteligent ar putea învăt ,a să interact ,ioneze cu un mediu al cărui complexitate este
controlabilă cu un indice de ﬁdelitate atât de ridicat, gestionarea consecint ,elor (nu există
riscuri semniﬁcative sau care să se aﬂe în afara controlului dezvoltatorului agentului) s ,i
accesibilitatea replicării rezultatelor.
Au existat multiple solut ,ii deterministe sau pseudo-deterministe de-a lungul timpului
în vederea dezvoltării unor astfel de solut ,ii automate, performante, pentru problema
descrisă, însă majoritatea întâmpină diﬁcultăt ,i în ceea ce prives ,te generalizarea; solut ,iile
suntpreaspeciﬁcejocurilorpentrucaresuntdezvoltatepentruaputeaﬁfezabilevreodată
în afara domeniului jocurilor. Am ales, astfel, în mod speciﬁc tema antrenării agent ,ilor
inteligent ,i pe baza imaginilor pentru această lucrare, deoarece consider că apropierea de
spat,iulsenzorialuman(încadrulmediuluiinteractivaljocurilor,jucătoriiumaniauacces
numai la ceea ce furnizează înapoi mediul prin intermediul simt ,urilor: imagini, sunete,
vibrat ,ii) reprezintă un pas necesar în direct ,ia unor solut ,ii mai performante s ,i generale.
S,i, des ,i în cadrul acestei lucrări abordez jocuri digitale de o complexitate relativ scăzută
în comparat ,ie cu scopul ultim propus, motivat ,ia rămâne cercetarea unor astfel de solut ,ii
aplicabile în afara domeniului jocurilor digitale.
4

Capitolul 2
Concepte Teoretice
2.1 Statistică s ,i Teoria Probabilităt ,ii
Deﬁnit ,iile,teoremele,propozit ,iiles,iecuat ,iiledinaceastăsect ,iuneaufostpreluatedin
[1], [2].
2.1.1 Eveniment. Spat ,iul de Evenimente.
Teoriaprobabilităt ,iiesteoramurăamatematiciicareseocupădestudiuls ,imodelarea
experimentelor aleatoare. În acest sens se deﬁnes ,te evenimentul elementar pentru un
experimentaleatoriualescaﬁindoricaredintrerezultateleposibileobt ,inuteînurmaunei
singure realizări a experimentului respectiv (cu condit ,ia ca ﬁecare realizare să producă
exact un rezultat) s ,i se deﬁnes ,te spat ,iul de evenimente
,;ca ﬁind mult ,imea tuturor
evenimentelor elementare. În acest context, un eveniment Areprezintă o submult ,ime a
lui
(deci o mult ,ime de evenimente elementare): A
. Un eveniment Aare loc în
urmauneirealizăriaexperimentuluialeatoriu("serealizează")dacă Rrezultatulrealizării
respective apart ,ine mult ,imii evenimentului: R2A. Astfel,
este denumit evenimentul
sigur, deoarece toate rezultatele posibile unei realizări a experimentului aleatoriu vor ﬁ
evenimente elementare s ,i, deci, conform deﬁnit ,iei, vor apart ,ine
, iar;este denumit
evenimentul imposibil, deoarece ﬁecare realizare a experimentului aleatoriu are exact
un rezultat, ci nu mai put ,in. Se împrumută din teoria mult ,imilor terminologia pentru
operat ,iile pe evenimente, a căror însemnătate urmează intuit ,ia:
5

Capitolul 2. Concepte Teoretice
•Reuniunea : evenimentul A[Bserealizeazădacăcelput ,inunuldintreevenimentele
AsauBse realizează
•Intersect ,ia: evenimentul A\Bse realizează dacă se realizează atât evenimentul
A, cât s ,i evenimentul B
•Complementarea : evenimentul Acse realizează dacă evenimentul Anu se reali-
zează
•Diferent ,a: evenimentul ABserealizeazădacăserealizeazăevenimentul As,inu
se realizează evenimentul B
Două evenimente A;B2
sunt incompatibile (sau disjuncte) dacă A\B=;.
2.1.2 Probabilitate. Spat ,iu de Probabilitate.
Pentrudeﬁniprobabilitateacafunct ,iedeevenimente,estenecesarăîntâideﬁnireaunei
-algebre a lui
. Dată ﬁind o mult ,ime nevidă
,;, se numes ,te algebră a lui
o
familie nevidăFP (
)(Pmult,imea părt ,ilor lui
i.e.P=fAjA
g) astfel încât:
1.A2F) Ac2F(închiderea la complementare)
2.A;B2F) A[B2F(închiderea la reuniune)
Fse numes ,te-algebră a lui
dacă este închisă la reuniune numărabilă:
A1;A2;:::2F)1[
i=1Ai2F (2.1)
(
;F)se numes ,te spat ,iu măsurabil dacăFeste o-algebră a lui
.
În acest context, o măsură de probabilitate pe spat ,iul măsurabil (
;F)este o funct ,ie
P:F! [0;1)cu următoarele proprietăt ,i:
1.P(
)=1
2.P(1S
i=1Ai)=1P
i=1P(Ai),8A1;A2;:::2Fdisjuncte două câte două
Astfel, spat ,iul de probabilitate complet aditiv se deﬁnes ,te ca tripletul (
;F;P)unde

,;este spat ,iul evenimentelor, Feste o-algebră a lui
, iar Peste măsură de
probabilitate pe spat ,iul măsurabil (
;F).
6

2.1. Statistică s ,i Teoria Probabilităt ,ii
Pentru un spat ,iu de probabilitate (
;F;P)sunt adevărate următoarele:
1.P(;)=0
2.P(A)P(B),8A;B2F,AB
3.0P(A)1,8A2F
4.P(Ac)=1P(A),8A2F
5.P(BA)=P(B)P(A),8A;B2F,AB
6.P(A[B)=P(A)+P(B)P(A\B),8A;B2F
2.1.3 Independent ,a Evenimentelor
Într-un spat ,iu de probabilitate (
;F;P), se numes ,te probabilitate condit ,ionată de un
eveniment B2F, notată P(jB) :F!R, raportul:
P(AjB)=P(A\B)
P(B);8A2F (2.2)
Evenimentele A1;A2;:::; An2F(n2)sunt independente dacă:
P(A1\A2\:::An)=P(A1)P(A2):::P(An) (2.3)
Totodată, As,iBsunt independente condit ,ionat de C2Fdacă:
P(A\B\C)P(C)=P(A\C)P(B\C) (2.4)
2.1.4 Variabile Aleatoare
Fie mult ,imea S(R)=f(a;b)ja<b;a;b2Rg. O variabilă aleatoare reală pe spat ,iul
de probabilitate (
;F;P)este o funct ,ieX:
!Rcu proprietatea că
X1(B)=f!2
jX(!)2Bg2F;8B2B(R) (2.5)
undeB(R)=(S(R))este-algebra mult ,imilor boreliene pe R, sau cea mai mică -
algebră ce cont ,ine toate mult ,imile de forma S(R).
7

Capitolul 2. Concepte Teoretice
O funct ,ie':R!R;n1se numes ,te măsurabilă dacă
'1(B)2B(R);8B2B(R) (2.6)
În acest context, se numes ,te funct ,ia de distribut ,ie sau de repartit ,ie a unei variabile
aleatoare X:
!Rfunct,iaFX:R![0;1]
FX(a)=P(X<a);a2R (2.7)
O variabilă aleatoare poate ﬁ discretă sau continuă. X:
!Reste discretă ddacă
mult,imea valorilor posibile ale lui Xeste ﬁnită sau inﬁnită s ,i numărabilă. În acest caz,
valorileposibilealelui Xsenoteazăcu x1;x2;:::s,iprobabilităt ,ilecorespunzătoarelorcu
P(X=xi);i=1;2;:::, iarXpoate ﬁ reprezentată în felul următor:
X=0
BBBBBB@x1x2:::
p1p2:::1
CCCCCCA(2.8)
Xse numes ,te continuă dacă funct ,ia de distribut ,ie corespunzătoare FX:R![0;1],
FX(a)=P(X<a)esteofunct ,iecontinuă. Înacestcaz,senumes ,tedensitatedeprobabili-
tate a unei variabile aleatoare continue Xo funct ,ief=fX:R![0;+1)integrabilă cu
proprietatea că
P(X2B)=Z
Bf(x)dx;8B2B(R) (2.9)
Media unei variabile aleatoare X:
!Rse deﬁnes ,te în felul următor:
E[X]=X
i1xiP(X=xi)=X
i1xipi, dacă Xeste discretă (2.10)
E[X]=Z+1
1x f(x)dx, dacă Xeste continuă s ,i integrala respectivă există s ,i este ﬁnită
(2.11)
Momentul de ordin ral lui Xse deﬁnes ,te ca ﬁind media variabilei aleatoare Xr.
Momentulcentratdeordin restemediavariabileialeatoare (XE[X])r. Dinacestpunct
de vedere, o proprietate semniﬁcativă a variabilelor aleatoare este momentul centrat de
8

2.2. Învăt ,area Automată
ordin doi, sau dispersia, totodată pătratul deviat ,iei standard, care are, conform deﬁnit ,iei,
următoarea formă:
2(X)=X
i1(xiE[X])2pi, dacă Xeste discretă (2.12)
2(X)=Z+1
1(xE[X])2f(x)dx, dacă Xeste continuă s ,i integrala respectivă există s ,i este ﬁnită
(2.13)
Două variabile aleatoare X;Y:
!Rse numesc independente dacă
P(X2A;Y2B)=P(X2A)P(Y2B);8A;B2B (2.14)
Două variabile aleatoare X;Y:
!Rse numesc necorelate dacă
E[XY]=E[X]E[Y] (2.15)
2.2 Învăt ,area Automată
Deﬁnit ,iile,teoremele,propozit ,iiles,iecuat ,iiledinaceastăsect ,iuneaufostpreluatedin
[3].
Un algoritm de învăt ,are automată (eng. "Machine Learning"), sau un "agent inteli-
gent",esteunprogramcapabilsă"învet ,e"dindateledeintrare. Înacestcontext,sespune
căunprogram"învat ,ă"dintr-oexperient ,ăE,relativlaoclasădesarcini Ts,iconformunei
măsuri a performant ,eiP, dacă performant ,a acestuia pe sarcinile din clasa T, măsurată
conform P, se îmbunătăt ,es,te o dată cu experient ,aE.
2.2.1 Sarcinile, T
Sarcinile de învăt ,are automată sunt deﬁnite în funct ,ie de modul în care trebuie al-
goritmul/agentul inteligent să proceseze exemple. Se numes ,te exemplu o colect ,ie de
trăsături măsurate ale unui obiect sau eveniment care se dores ,te a ﬁ procesat. În acest
sens, un exemplu este reprezentat matematic sub forma unui vector x2Rn,n1, unde
9

Capitolul 2. Concepte Teoretice
xireprezintă respectivele trăsături măsurate, 8i=1;:::; n.
Un prim tip de sarcină este clasiﬁcarea. Clasiﬁcarea presupune, având un număr k
de clase la dispozit ,ie, învăt ,area asocierii unei clase ﬁecăruia dintre exemplele de intrare.
Cu alte cuvinte, dacă Cconstituie mult ,imea claselor, algoritmul învat ,ă ﬁe o funct ,ie
f:Rn!C, ﬁe o funct ,ief:Rn!P (C), unde f(x)reprezintă clasa asociată/clasele
asociate lui x.
Un alt tip de sarcină bazat pe cel de clasiﬁcare este clasiﬁcarea exemplelor având
trăsături lipsă. În acest caz, exemplele nu oferă garant ,ia prezent ,ei tuturor trăsături-
lor lor. Algoritmul trebuie să învet ,e o mult ,ime de funct ,iiff1;f2;:::; f2lj0l
nnumărul maxim de trăsături individuale care pot lipsi dintr-un exemplu g, astfel încât ﬁ-
ecare funct ,ie să clasiﬁce exemple având o mult ,ime distinctă L=fxj1;xj2;:::; xjpj0
pl;ji2f1;:::; ng;8i=1;:::; pgde trăsături care lipsesc simultan.
Regresiuneaesteuntipdesarcinăîncarealgoritmulînvat ,ăofunct ,ienumericăadatelor
de intrare i.e. o funct ,ie de forma f:Rn!R.
Transcriereaesteunalttipdesarcină,carepresupunetranslatareaexemplelorprimite
la intrare dintr-un format speciﬁc în text clar.
În domeniul procesării limbajului natural există s ,i metode s ,i algoritmi de traducere
automată (eng. "machine translation"). Agentul învat ,ă să traducă exemple de text în
limbaj natural dintr-o limbă în alta.
Detect ,ia anomaliilor este o altă sarcină de învăt ,are automată. Ea presupune analiza
nesupervizatăadatelordeintrares ,isemnalarea/marcareacelorcaredeviazăsemniﬁcativ
de majoritatea exemplelor.
Alte tipuri de sarcini cuprind generarea de exemple asemănătoare ca temă s ,i/sau
cont,inut cu cele observate/învăt ,ate, eliminarea "zgomotului" din exemplele de la intrare
(în acest context, "zgomot" – "noise" – reprezintă trăsăturile aleatoare care pot să apară
în date ca rezultat al gres ,elii umane sau a aleatorismului natural inerent lor, în funct ,ie de
caz),învăt ,areaaproximăriitrăsăturilorlipsăaleanumitorexemple,învăt ,areamaximizării-
/minimizăriiuneifunct ,iidecostîncadrulunuijocsaualunuimediuinteractivmăsurabil
prin observarea stărilor etc. Toate acestea sunt sarcini pe care un algoritm de învăt ,are
automatăestecapabilsăîs ,iîmbunătăt ,eascăperformant ,apânălaunnivelsuperiororicăror
10

2.2. Învăt ,area Automată
alte metode de procesare automată a datelor (de exemplu, programatic).
2.2.2 Măsura performant ,ei,P
Pentru a evalua calitatea unui algoritm de învăt ,are automată, este nevoie de o măsură
a performant ,ei acestuia. Aceasta este de obicei speciﬁcă sarcinii pe care algoritmul o
învat,ă. De exemplu, în cazul sarcinilor de clasiﬁcare, o măsură a performant ,ei ar putea o
reprezenta acuratet ,ea algoritmului (procentul de exemple de intrare cărora algoritmul le
atribuieclaselecorectedintotaluldeexemplepentrucaresecunoscclaselerealeasociate),
sau ar putea o reprezenta scorul F1 etc. Tot as ,a, pentru o sarcină de regresiune, se
poatemăsuradistant ,avectorialădintrerezultatulaproximats ,irezultatulcorectalfunct ,iei
modelate. Alegerea unei măsuri a performant ,ei potrivite sarcinii s ,i datelor, des ,i teoretic
nediﬁcilă, deseori se dovedes ,te a ﬁ problematică în practică din cauza naturii anumitor
sarcini sau a unor proprietăt ,i inerente datelor care nu permit o modelare intuitivă s ,i/sau
us,oară.
Pentru a măsura capacitatea de generalizare a algoritmului de învăt ,are, performant ,a
acestuia este măsurată pe o mult ,ime de exemple diferită de cea pe care algoritmul le
observălaînvăt ,are. Astfel,măsuraperformant ,eiîs,iîndeplines ,temaibineroluldeestimare
a calităt ,ii reale a agentului în afara trăsăturilor strict speciﬁce exemplelor învăt ,ate.
2.2.3 Experient ,a,E
Însensgeneral,experient ,aalgoritmilordeînvăt ,areautomatăpoateﬁclasiﬁcatăﬁeca
ﬁind supervizată, ﬁe ca ﬁind nesupervizată.
Un algoritm nesupervizat învat ,ă strict din exemplele de intrare proprietăt ,i importante
ale structurii inerente acestora. Astfel, exemplele pot ﬁ împărt ,ite în categorii implicite
(eng. "clustering"), învăt ,ate de către algoritm numai din proprietăt ,ile pe care anumite
exempleleau(saunu)încomun,sausepoateaproximafunct ,iadedistribut ,ieadatelorde
intrare, pentru a facilita generarea unor exemple statistic asemănătoare etc.
Un algoritm supervizat învat ,ă nu numai din exemplele de intrare, ci s ,i din valorile
realeasociatelor(deexemplu,valorinumericeîncazulsarciniideregresiune,sauclaseîn
cazulclasiﬁcării),pecareseas ,teaptăcaalgoritmulsăleaproximezeînurmaexperient ,ei.
11

Capitolul 2. Concepte Teoretice
Astfel, avantajul constă în generalizarea pe date asemănătoare (până într-un punct) cu
exemplelefolositeînprocesuldeînvăt ,are,s,icontrolulpecarealgoritmulsupervizatîlare
asupra funct ,iei pe care o estimează prin comparat ,ie cu cel nesupervizat.
Înacestsens,seconsiderăcăînvăt ,areanesupervizatăestimeazăofunct ,iederepartit ,ie
p(x)a exemplelor de intrare – vectorii x2Rn- s,i/sau anumite proprietăt ,i semniﬁcative
ale acestei distribut ,ii, în timp ce învăt ,area supervizată presupune observarea exemplelor
xs,iavectorilor"t ,intă"(eng. "target")asociat ,iy2Rm;m1,pentrucaapoisăestimeze
p(yjx). În ciuda acestei clasiﬁcări, conceptele de algoritm supervizat s ,i algoritm
nesupervizat nu sunt formal deﬁnite. Ele au, însă, o utilitate practică.
În afară de aceste două categorii, mai există s ,i alte clase în care sunt amplasate
metodele de învăt ,are automată, cum ar ﬁ clasiﬁcarea semi-supervizată, sau învăt ,area
ranforsată. Aceasta din urmă presupune interact ,iunea continuă cu un mediu în care
agentul act ,ionează conform stării curente a mediului s ,i primes ,te ca rezultat o "răsplată"
(eng. "reward") sau o "penalizare" (cele două sunt echivalente) s ,i starea nouă a mediului
interactiv, agentul învăt ,ând astfel, în sens general, act ,iunile optime ca răsplată/penalizare
în funct ,ie de starea în care se aﬂă.
2.2.4 Capacitatea de Generalizare
Problema centrală s ,i scopul învăt ,ării automate constă în capacitatea de generalizarea
aalgoritmuluipedatedeintrarenoi,nemaivăzute. Aceastăproblemăarputeaﬁ,aparent,
modelată ca o problemă de optimizare: se învat ,ă parametrii pentru care funct ,ia aproxi-
mată maximizează măsura performant ,ei (sau, echivalent, minimizează eroarea). Ceea ce
separă învăt ,area automată de domeniul optimizărilor este faptul că se dores ,te nu numai
maximizareaperformant ,eipedatelede"antrenare"(eng. "training")-celedincareagen-
tul învat ,ă – ci s ,i a performant ,ei pe datele de test, care nu sunt disponibile algoritmului în
timpul procesului de învăt ,are, deci maximizarea capacităt ,ii de generalizare. Eroarea de
generalizaresedeﬁnes ,tecaﬁindvaloareaas ,teptatăaeroriipeunexempludeintrarenou,
unde expectant ,a este calculată în funct ,ie de funct ,ia de repartit ,ie aproximată de algoritm.
Măsurarea capacităt ,ii de generalizare a algoritmului de învăt ,are automată se bazează
pe următoarele presupuneri în legătură cu structura datelor de intrare:
12

2.2. Învăt ,area Automată
1. Toate exemplele sunt independente între ele
2. Dateledeantrenares ,iceledetestsuntdistribuiteidentic,conformaceleias ,idistribut ,ii
În acest context, eroarea as ,teptată a datelor de antrenare este aceeas ,i cu cea a datelor
de test, întrucât ambele sunt distribuite identic. În învăt ,area automată, mai întâi se
es,antionează mult ,imea datelor de antrenare, se aleg parametrii algoritmului astfel încât
eroareapeacestedatesăﬁeminimizată,iarapoisees ,antioneazămult ,imeadatelordetest
pentru a estima eroarea de generalizare. Astfel, factorii care determină capacitatea de
generalizareaunuialgoritmdeînvăt ,areautomatăsunteroareapedateledetests ,idistant ,a
(diferent ,a în modul) între eroarea pe datele de antrenare s ,i cea pe datele de test. Ideal,
ambii factori sunt minimizat ,i. În sens contrar (atunci când cele două sunt prea mari),
aparproblemelecorelatede"underﬁtting",respectiv"overﬁtting",ceadintâiexprimândo
capacitate general scăzută a algoritmului de a învăt ,a orice fel de structură (chiar s ,i cea a
exemplelor de antrenare), în timp ce a doua exprimă o capacitate de generalizare scăzută
drept rezultat al învăt ,ării prea îndeaproape a proprietăt ,ilor speciﬁce datelor de antrenare.
Un mod prin care se poate controla capacitatea algoritmului este alegerea spat ,iului
ipotezei, sau al mult ,imii funct ,iilor pe care algoritmul poate să le considere solut ,ii. De
exemplu, algoritmul poate ﬁ modelat ca aproximare de o funct ,ie liniară: y=0+1x.
Dacă se dovedes ,te că o funct ,ie liniară nu reprezintă satisfăcător mult ,imea datelor de
intrare, atunci se poate aproxima o funct ,ie polinomială de un grad pmai mare: y=
0+1x+2×2+:::+pxp. Numărul de parametri pe care algoritmul trebuie să
îi învet ,e este proport ,ional cu capacitatea acestuia. O capacitate prea mare sau prea mică
– deci un spat ,iu al ipotezelor prea cuprinzător, respectiv prea limitat – poate conduce la
probleme de "overﬁtting", respectiv "underﬁtting".
2.2.5 Hiperparametri s ,i Datele de Validare
Majoritatea algoritmilor de învăt ,are automată dispun de un număr variat de hiperpa-
rametri,deobiceivaloriscalare(darnunumai)folositepentruacontrolamaibinespat ,iul
ipotezelor s ,i funct ,iile aproximate. Hiperparametrii diferă de parametrii obis ,nuit,i ai al-
goritmului prin faptul că sunt ales ,i manual s ,i/sau actualizat ,i cu experient ,a conform unor
reguli deterministe pre-stabilite, ci nu învăt ,at,i deodată cu observarea datelor. Un exem-
13

Capitolul 2. Concepte Teoretice
plu de hiperparametru este rata de învăt ,are, folosită în mult ,i algoritmi ca regularizator a
schimbării parametrilor sistemului. O rată de învăt ,are mai mică duce la o învăt ,are mai
lentă,darmai"sigură",adicămaiprobabilăsăconveargălaminimulglobalalfunct ,ieide
cost căutat sau măcar la un minim local (în lipsa hiperparametrului ratei de învăt ,are, este
posibil ca algoritmul să nu conveargă la o solut ,ie).
Pentru controlarea capacităt ,ii de generalizare, este relevant conceptul de mult ,ime de
date de validare. Mult ,imea datelor de antrenare este împărt ,ită în două părt ,i de obicei
inegale,ceamaicuprinzătoareﬁindfolosităînprocesuldeînvăt ,arecamult ,imededatede
antrenare, iar cea mai redusă în dimensiune ﬁind folosită ca mult ,ime de testare cu scopul
principal de actualizare al hiperparametrilor. Astfel, mult ,imea datelor de test poate ﬁ
"păstrată" pentru ca testarea pe aceasta să reﬂecte mai bine caracterul unor date generale
nemaiîntâlnite până atunci fără a pierde însă avantajul acesteia din punct de vedere al
optimizării hiperparametrilor sistemului. În acest sens se mai deﬁnes ,te s,i conceptul de
"cross-validation",carepresupunenunumaiîmpărt ,ireamult ,imiidatelordeantrenareîntr-
omult ,imenouădedatedeantrenares ,iomult ,imedevalidareosingurădată,laînceputul
procesului de învăt ,are, ci folosirea a ﬁecărei submult ,ime de cardinal [pm](mnumărul
total de exemple în mult ,imea datelor de antrenare, p2(0;1]) din mult ,imea de antrenare
drept mult ,ime de validare, pe rând sau aleator.
2.2.6 Estimatori, "Bias" s ,i Variant ,ă
Pentru o mult ,imefx(1);:::; x(m)gdemexemple independente s ,i identic distribuite, un
estimator sau o statistică este orice funct ,ieˆde aceste puncte:
ˆm=g(x(1);:::; x(m)) (2.16)
Nu este necesar, prin deﬁnit ,ie, ca gsă atribuie exemplelor valori apropiate de valorile
reale/as ,teptate, s,i nici nu este necesar ca gsă întoarcă numere în acelas ,i spat ,iu al
valorilorcu,însăunestimatoresteconsideratperformantdacăseapropiedefunct ,iade
distribut ,iecare a generat datele. ˆeste o variabilă aleatoare. este considerat ﬁxat (s ,i
necunoscut).
14

2.2. Învăt ,area Automată
Una dintre cele mai studiate proprietăt ,i ale estimatorilor este conceptul de "bias". El
se deﬁnes ,te astfel:
bias(ˆm)=E[ˆm] (2.17)
undeconstituiefunct ,iarealădedistribut ,iefolosităpentrugenerareadatelordeantrenare.
Astfel, un estimator se numes ,te "nepărtinitor" (eng. "unbiased") dacă bias(ˆm)=0(care
implică E[ˆm]=), s,i asimptotic "nepărtinitor" dacă lim
m!1bias(ˆm)=0. Un "bias"
prea ridicat indică o incapacitate a estimatorului de a genera rezultate apropiate de cele
reale, deci o inabilitate a algoritmului de a învăt ,a orice fel de structură a datelor, chiar s ,i
exemplelor de antrenare (fenomen denumit anterior "underﬁtting").
Alteproprietăt ,irelevantealeestimatorilorsuntvariant ,as,ideviat ,astandard,deﬁniteca
în teoria probabilităt ,ii (având în vedere că estimatorul este o variabilă aleatoare): Var(ˆ)
respectivq
Var(ˆ). Informal, variant ,a reprezintă o măsură a divergent ,ei datelor. O
variant ,ăridicatăindicăomodelarepreaîndeaproapeaexemplelordeantrenare,s ,ideci,o
capacitate de generalizare scăzută (fenomen denumit anterior "overﬁtting").
Îngeneral,înînvăt ,areaautomatăsedores ,tecavariant ,aestimatoruluis ,iproprietateasa
de "bias" să ﬁe minimizate simultan. O metodă de a măsura această trăsătură este media
erorii pătratice (eng. "mean squared error"):
MSE =E[(ˆm)2]=bias(ˆm)2+Var(ˆm) (2.18)
Caatare,învedereaminimizăriisimultaneacelordouă,sepoateoptapentruminimizarea
MSE.
Relat,ia dintre variant ,ă s,i "bias" s ,i conceptele de "underﬁtting" s ,i "overﬁtting"
15

Capitolul 2. Concepte Teoretice
2.2.7 Consistent ,a
Ideal pentru un algoritm de învăt ,are automată este ca, cu cât numărul mde exem-
ple de antrenare cres ,te, estimările să conveargă către valorile corespondente reale ale
parametrilor. Acest fenomen poate ﬁ formalizat astfel:
plim m!1ˆm= (2.19)
unde plimindicăconvergent ,aînprobabilitatei.e. 8>0,P(jˆmj>)!0atuncicând
m!1. Această condit ,ie se numes ,te consistent ,a sistemului, sau mai exact consistent ,a
slabă, caz în care consistent ,a se deﬁnes ,te ca convergent ,a aproape sigură a lui ˆla
(convergent ,aaproapesigurăauneisecvent ,edevariabilealeatoare x(1);x(2);:::laovaloare
xare loc atunci când P( lim
m!1x(m)=x)=1). Informal, consistent ,a este o condit ,ie care
asigură diminuarea proprietăt ,ii de "bias" o dată cu cres ,terea numărului de exemple de
date.
Consistent ,a este relevantă ca trăsătură a "verosimilităt ,ii maxime" (eng. "maximum
lilelihood"). Dacă pmodel(x;)reprezintă o familie parametrică a distribut ,iilor de proba-
bilitate peste acelas ,i spat ,iu indexat de care îi asociază ﬁecărui exemplu xo estimare a
probabilităt ,ii distribut ,iei reale, dar necunoscute, pdata(x)din care a fost generat indepen-
dent, atunci estimatorul de verosimilitate maximă este:
=argmaxpmodel(fx(0);:::; x(m)g;)=argmaxmY
i=1pmodel(x(i);)(2.20)
unde mreprezintă numărul exemplelor. Acesta este echivalent, dar mai inconvenabil în
practică din considerente numerice, cu:
=argmaxmX
i=1log p model(x(i);) (2.21)
care se poate împărt ,i la numărul de exemple pentru a obt ,ine a treia formă echivalentă:
=argmaxExˆpdata[log p model(x(i);)] (2.22)
16

2.2. Învăt ,area Automată
unde ˆpdatareprezintă distribut ,ia empirică observabilă din care au fost generate exemplele
deantrenare. Estimatorulverosimilităt ,iimaximeminimizeazădefaptdivergent ,eledintre
ˆpdatas,ipmodel. Ranguldedivergent ,ădintreceledouăestemăsuratconformdivergent ,eiKL:
DKL(ˆpdatajjpmodel)=Exˆpdata[logˆpdata(x)log p model(x)] (2.23)
Dinmomentcetermenul logˆpdata(x)nut,inedemodel,înseamnăcăminimizareadivergent ,ei
KLse realizează prin minimizarea Exˆpdata[log p model(x)], care este echivalentă cu ma-
ximizarea anterioară din 2.22. Ca atare, minimizarea divergent ,eiKLs,i maximizarea
verosimilităt ,ii logaritmice sunt echivalente. Pentru ca verosimilitatea maximă să ﬁe
consistentă, pdatatrebuiesăseaﬂeînfamiliamodelelor pmodel(;)s,ipdatatrebuiesăcores-
pundăexactuneivalorialui (numaimult,numaiput ,in). Astfel,datorităconsistent ,eis,i
eﬁcient ,eisale,estimatorulverosimilităt ,iimaximeestedesfolositînalgoritmiideînvăt ,are
automată pentru modelarea funct ,iei de cost (de exemplu, în cazul sarcinilor supervizate,
se pot folosi distribut ,iile condit ,ionate ˆpdata(yjx), respectiv pmodel(yjx)după care sunt
generate rezultatele condit ,ionat de exemplele de intrare).
2.2.8 Optimizarea pe baza Gradientului
Optimizarea reprezintă sarcina de minimizare sau maximizare a unei funct ,ii obiectiv
(sau criterion) f(x)prin schimbarea valorilor lui x. În cazul sarcinii de minimizare a
funct,iei, ea se mai numes ,te s,i funct ,ie de cost sau de eroare. Se notează cu xvaloarea
luixcare minimizează, respectiv maximizează f(x):x=argmin f (x), respectiv x=
argmax f (x). Întrucât cele două sarcini sunt echivalente, în continuare se va face referire
numai la sarcina de minimizare (sarcina maximizării funct ,ieif(x)este echivalentă cu
sarcina minimizării funct ,ieif(x)).
Pentruderivatauneifunct ,iirealeoarecarepevalorirealescalare f(x)=yînpunctul x,
notatădy
dxsauf0(x),s,ipentruun2R
+foartemic,esteadevăratăurmătoareaproprietate:
f(x+)f(x)+f0(x) (2.24)
17

Capitolul 2. Concepte Teoretice
Un exemplu de funct ,ie de cost. Se observă că pentru x=f0(x)<0,x>x, iar pentru f0(x)>0,x<x, s,ix=xpentru f0(x)=0
De unde rezultă că
f(x(f0(x)))f(x)(f0(x))f0(x)<f(x) (2.25)
pentruvalorialelui destuldemici,unde estefunct ,iadesemn((x)=0dacă x=0s,i
(x)=d
dxjxjîn rest,8x).
Algoritmul de coborâre pe gradient (eng. "gradient descent") se bazează pe această
proprietate, astfel că pentru minimizarea lui f(x), pornind de la un x0, se aleg în mod
repetatvalori foartemicis ,isecalculează xipentrupasul i,i1,caxi1(f0(xi1)),
până când derivata este 0 (dacă f0(xj)=0, atunci xk=xj;8kjs,i, deci, continuarea
algoritmului nu mai are sens). Punctele în care f0(x)=0se numesc puncte critice sau
stat,ionare. Unminimlocalesteunpunctîncare f(x)<f(x+),oricare2Rsuﬁcient
de mic. Analog pentru maximul local. Minim global se numes ,tex=argmin f (x).
Analog pentru maximul global al funct ,iei:argmax f (x).
De la stânga la dreapta: minim local, maxim local s ,i punct xcare nu este nici minim, nici maxim local, dar pentru care f0(x)=0
18

2.2. Învăt ,area Automată
Încontextulacestuialgoritms ,ialposibilelorvalorideminimalefunct ,ieif,încadrul
învăt,ăriiautomatenusedores ,teminimizareaformalăalui f,ciaﬂareauneivalorialui f
"suﬁcient de mică" în practică.
În cazul funct ,iilor multidimensionale f:Rn!Rse folosesc derivatele part ,iale:
@
@xif(x)măsoară schimbarea valorii lui fatunci când doar xise schimbă, i2f0;:::; ng.
Gradientul lui f, notatrxf(x), reprezintă vectorul tuturor derivatelor part ,iale ale lui
f. Deﬁnit ,ia punctelor critice se extinde în cazul multi-dimensional la punctele în care
gradientulesteegalcu0întoateelementele. Derivatadirect ,ionalăîndirect ,iau(uvector)
reprezintăpantalui fîndirect ,iau,anume f(x+u)relativla,evaluatcu=0. Astfel,
@
@f(x+u)ia valoarea uTrxf(x)atunci când=0. Derivata direct ,ională este folosită
pentru a găsi direct ,ia în care fdescres ,te cel mai rapid:
min
u;uTu=1uTrxf(x)=min
u;uTu=1jjujj2jjrxf(x)jj2cos (2.26)
undeeste unghiul dintre us,i gradient. Pasul iterativ al algoritmului devine atunci
xi=xi1rxi1f(xi1). În plus,se mai numes ,te s,i rata de învăt ,are (eng. "learning
rate"), s ,i reprezintă un hiperparametru al algoritmului de învăt ,are.
O problemă majoră a algoritmilor de învăt ,are automată este numărul mare de date
necesare pentru o capacitate satisfăcătoare de generalizare. Pentru milioane de exemple
de antrenare, calcularea funct ,iei de cost înseamnă, în majoritatea cazurilor, calcularea
mediei costului în toate rezultatele (alteori a sumei – acelas ,i ordin de complexitate), deci
pentru toate exemplele de antrenare, ceea ce înseamnă că este necesară calcularea unei
medii a milioane de exemple – o operat ,ie costisitoare – pentru obt ,inerea gradientului la
ﬁecarepasiterativalalgoritmuluidecoborârepegradient. Avândînvedere,însă,ofunct ,ie
de cost calculată ca medie a costurilor individuale, înseamnă că este posibilă estimarea
funct,iei de cost s ,i a gradientului prin es ,antionarea exemplelor de antrenare. Deci, în loc
de a calcula costul ﬁecărui exemplu de antrenare la ﬁecare iterat ,ie a algoritmului, se vor
alege uniform aleatoriu m0din cele mexemple de antrenare s ,i vor ﬁ calculate funct ,ia de
costs ,igradientuldoarpentruaceste m0exemples ,i,deci,vorﬁajustat ,iparametriiconform
doaracestor m0parametri. m0esteunnumărﬁxats ,inut,inecontdemărimeamult ,imiide
19

Capitolul 2. Concepte Teoretice
date de antrenare (se aleg de obicei puteri ale lui 2 mai mici de 512). Pentru Lfunct,ie de
cost, estimarea gradientului va trece atunci din forma:
G=1
mrmX
i=1L(x(i);y(i);) (2.27)
în forma
g=1
m0rm0X
i=1L(x(i)
B;y(i)
B;) (2.28)
iarva ﬁ ajustat iterativ conform g,Bmult,imea exemplelor es ,antionate.
Această variantă a algoritmului de coborâre pe gradient se numes ,te coborârea stocastică
pegradient(eng. "stochasticgradientdescent")s ,iesteceafolosită,înpractică,celmaides
în implementarea metodelor de învăt ,are prin optimizarea pe baza gradientului. În plus,
există numeroare îmbunătăt ,iri minore asupra acestui algoritm de coborâre stocastică pe
gradient, dintre
2.3 Ret ,ele Neuronale
Deﬁnit ,iile,teoremele,propozit ,iiles,iecuat ,iiledinaceastăsect ,iuneaufostpreluatedin
[4].
2.3.1 Ret ,ele cu Propagare Înainte
Un perceptron (sau "neuron" artiﬁcial) este o funct ,ief:Rn!f0;1g,n1, de
x=(x1;x2;:::; xn)2Rns,i de parametrii w=(w1;w2;:::; wn)2Rns,ib2R(ponderi),
deﬁnită astfel:
f(x;w;b)=8>>>>><>>>>>:1dacă b+nX
i=1xiwi>0
0altfel(2.29)
pentru clasiﬁcarea binară a valorilor de intrare.
O analogie simplifcată a neuronului cerebral găsit în natură, perceptronul poate ﬁ
folositcaalgoritm(liniar)deînvăt ,areautomată: parametrii"învăt ,at,i"suntreprezentat ,ide
vectorul ws,idescalarul b. Astfel,algoritmulînvat ,ăvalorileponderilorcareaproximează
20

2.3. Ret ,ele Neuronale
celmaibinefunct ,iarealăcăutatăînfelulurmător. Unalgoritmdupăcares-arputearealiza
acest lucru ar ﬁ următorul: pentru ﬁecare exemplu xdin datele de antrenare s ,id2f0;1g
clasa asociată, wk(ponderea la pasul k,k1,w0ales aleator) este calculat conform
wk
j=wk1
j+(df(bk1+Pn
i=1wk1
ixi))xj,8j2f0;:::; ng,x;w2Rn, iarbkconform
bk=bk1+df(bk1+Pn
i=1wk1
ixi). Se repetă până când rezultatul este satisfăcător de
aproape.
O limitare importantă a perceptronului, prin deﬁnit ,ie, este incapacitatea sa de a apro-
ximaofunct ,ieneliniară,saudeaclasiﬁcaexemplecarenusuntliniarseparabile. Unexem-
plu clasic în acest sens este funct ,ia XOR ("sau exclusiv"), XOR : f0;1gf0;1g!f 0;1g,
deﬁnită astfel:
XOR(x1;x2)=8>>><>>>:1dacă x1,x2
0altfel(2.30)
Sistemul liniar de ecuat ,ii asociat ecuat ,iilorb+wx=XOR(x)nu are solut ,ii, precum nu
există solut ,ii nici pentru vreun sistem aproximativ echivalent cu 2Roarecare ﬁxat
foarte mic (XOR (x)=XOR(x)+). În consecint ,ă, pentru a aborda problemele non-
liniare s ,i, în general, un spat ,iu al ipotezelor mai put ,in restrâns, se deﬁnesc ret ,elele de
neuroni artiﬁciali propagată înainte (eng. "feedforward neural network"), denumite s ,i
multiperceptroni. O ret ,ea neuronală are mai multe "straturi" de neuroni, ﬁecărui strat
ﬁindu-iasociatunaltnumărdeponderi bs,iw(caremaisuntnotatecolectiv ),înfunct ,ie
de mărimea straturilor. Astfel, pentru stratul kde dimensiune lk,k1,lk1, valoarea
neuronului zk
i,8i2f0;:::; lkg,estecalculatăconform zk
i=bk1+Plk1
j=1wk1
jiak1
j,akvalorile
"activate"alestratuluianterior. Valoareaneuronuluiesteapoi"propagată"înainteprintr-o
funct,ienon-liniară fk,numităfunct ,iedeactivare,identicăpentrutot ,ineuroniidepestratul
k(exempledeastfeldefunct ,iidesfolositeînpracticăsunt max(0;)saufunct ,iasigmoidă).
Astfel, ak
i=fk(zk
i)pentru k1s,ia0
i=xi,xexemplul de intrare, 8i2f0;:::; lkg. Pentru
21

Capitolul 2. Concepte Teoretice
Exemplu de vizualizare a unei ret ,ele neuronale cu 3 straturi s ,i o singură valoare de ies ,ire; nodurile reprezintă neuronii, iar ﬁecare tranzit ,ie reprezintă o pondere distinctă
o ret,ea cu Lstraturi, rezultatul va ﬁ, deci:
aL
iL=fL(zL
iL)
=fL
bL1
iL+lL1X
jL1=1wL1
jL1;iLaL1
jL1
=fL
bL1
iL+lL1X
jL1=1wL1
jL1;iLfL1
bL2
jL1+lL2X
jL2=1wL2
jL2;jL1aL2
jL2
:::
=fL
bL1
iL+lL1X
jL1=1wL1
jL1;iLfL1
bL2
jL1+lL2X
jL2=1wL2
jL2;jL1fL2
:::f1
b0
j1+jxjX
j0=1w0
j0;j1xj0
:::
(2.31)
unde ik2f0;:::; lkg,8k2f0;:::; Lg, iaraL
iLse mai notează oiLs,i pot reprezenta valorile
de ies ,ire.Lse numes ,te adâncimea ret ,elei. În mod obis ,nuit, fL=id, deci oiL=ziL,
s,ifkse aleg neliniare. De asemenea, rezultatul ret ,eleiaL
iLnu este neapărat rezultatul
căutat/aproximat, ci un rezultat intermediar care este procesat pentru a obt ,ine rezultatul
dorit, păstrând valorile pentru măsurarea erorii. În acest sens se ia, de exemplu, pentru
clasiﬁcare multiplă, clasa c=argmax i2f0;:::;lLg(so ftmax (oi)), unde so ftmax :RlL!RlL
este funct ,ia:
so ftmax (x1;x2;:::; xlL)=0
BBBBBBBBBBBB@ex1
lLP
i=1exi;ex2
lLP
i=1exi;:::;exlL
lLP
i=1exi1
CCCCCCCCCCCCA(2.32)
Sepoateobservacădatorităneliniarităt ,iridicateînsistem,spat ,iulipotezelorestemult
22

2.3. Ret ,ele Neuronale
mai vast. De exemplu, problema aproximării funct ,iei XOR prezentată anterior poate ﬁ
rezolvatăfolosindoret ,eacupropagareînaintemodelatădupăpoartalogicăXOR(circuite
electrice). Ret ,elele neuronale reprezintă, deci, o clasă de algoritmi de învăt ,are automată
pentru toate tipurile de sarcini prezentate anterior (supervizate, nesupervizate etc.) care
pot, teoretic, însă nu neapărat s ,i practic, să aproximeze orice funct ,ie matematică.
2.3.2 Antrenarea Ret ,elelor pe baza Gradientului
Înprimulrând,pentruaputeaantrenaret ,eleleneuronalefolosindceamaidesutilizată
metodă, anume coborârea în gradient (2.28), este necesar ca funct ,iile de activare ale
straturilor să ﬁe derivabile sau să ﬁe prevăzute valori pentru derivata în punctele în care
nusuntderivabile. Exempledeastfeldefunct ,iifolositeînpracticăsuntfunct ,iasigmoidă,
tangentahiperbolicăsau"ReLU",dela"unitatealiniarărectiﬁcată"(eng. "rectiﬁedlinear
unit"), anume funct ,iamaxf0;xg. Des ,i o necesitatea, derivabilitatea funct ,iei de activare
nu reprezintă neapărat un criteriu suﬁcient pentru ca aceasta să ﬁe performantă: funct ,ia
identitateestederivabilă,s ,itotus ,iconducelasistemeliniarecuocapacitatedegeneralizare
insuﬁcientă.
Maiesteapoinevoie,cas ,iîncazulcelorlaltetipuridealgoritmideînvăt ,areautomată,
deofunct ,iedecost. Însensgeneral,majoritatearet ,elelorneuronalesuntantrenatefolosind
verosimilitatea maximă prezentată anterior:
J()=Ex;yˆpdatalog p model(yjx) (2.34)
De exemplu, o funct ,ie de cost folosită pentru a aproxima valori numerice folosind ret ,ele
neuronale ar putea ﬁ:
J()=1
2Ex;yˆpdatajjyf(x;)jj2+c (2.35)
unde ceste o constantă care nu depinde de . Avantajul constă în scopul general al
funct,iilor de cost: o funct ,ie de cost poate ﬁ folosită în mod corect pe mai multe modele
(ret,ele), întrucât depinde de distribut ,ia modelului.
Odatăaleasăfunct ,iadecost,seutilizeazăalgoritmulcoborârii(stocastice)îngradient
pentruaantrenapropriu-zisret ,eaua,gradientulobt ,inându-sefolosindceeacesenumes ,te
23

Capitolul 2. Concepte Teoretice
"propagareaînapoi"(eng. "back-propagation"). Propagareaînapoireprezintăunalgoritm
iterativ de straturile ret ,elei mai fezabil decât metodele analitice din punct de vedere al
costuluicomputat ,ional. Înacestsens,esteutilăreguladerivateifunct ,iilorcompuse: dacă
x;y2R,y=g(x), s,iz=f(g(x))=f(y), atunci
dz
dx=dz
dydy
dx(2.36)
s,i, mai general, pentru x2Rm,y2Rn,g:Rm!Rn,f:Rn!R,y=g(x),z=f(y),
atunci
@z
@xi=X
j@z
@yj@yj
@xi;8i=1;:::; m (2.37)
sau, folosind notat ,ia vectorială:
rxz=JTryz (2.38)
unde JestematriceaJacobianăalui g. Algoritmuldepropagareînapoiseaplicăîngeneral
unortensoridedimensiuniarbitrare,nunumaiunorvectorisauunorvaloriscalare. Regula
seextindes ,ilaastfeldeexempleprin"compactarea"conceptualăatensorilorînvariabile
vectoriale. Gradientul poate ﬁ calculat pentru vectoriii astfel obt ,inut,i utilizând (2.38) s ,i
redimensionatînapoiîntensor. Senoteazăcu (rXz)igradientullui zînraportcutensorul
X2Rn1n2:::nmastfel încât i=(i1;i2;:::; im),1iknksă reprezinte un indice pentru
dimensiunea ka lui X,8k2f1;:::; mgi.e.@z
@Xi. Tot as ,a, dacă Y=g(X)s,iz=f(Y),
atunci:
rXz=X
j(rXYj)@z
@Yj(2.39)
Pentruacalculapropagareaînapoiagradient ,ilor,regulaînlănt ,uiriiderivatelortrebuie
aplicată recursiv, începând de la funct ,ia de cost J()(de aici s ,i denumirea algoritmului).
Conform(2.31),s ,i(2.34),funct ,iadecostesterezultatulacompuneriiamaimultorfunct ,ii,
decisepoatecalculagradientulﬁecăreiponderi s ,ialﬁecăreiactivăridinret ,earaportatla
J(). Aces ,ti gradient ,i sunt folosit ,i ulterior în cadrul coborârii în gradient (2.28) pentru
a minimiza funct ,ia de cost. Ponderile sunt folosite apoi pentru a recalcula funct ,ia de
cost (propagarea înainte), acest întreg procedeu repetându-se până când funct ,ia de cost
24

2.3. Ret ,ele Neuronale
converge la un minim sau pentru un număr pre-determinat de pas ,i. Algoritmul complet
(fără regularizare) pentru antrenarea unei ret ,ele neuronale este următorul:
Intrări:
Lnumărul de straturi ale ret ,elei
W(i),b(i),8i=f1;:::; lg,ponderileret ,elei,init ,ializatecuvalorialeatoaresauconstante
xexemplele de antrenare
yrezultatele reale/"t ,intă" asociate exemplelor de antrenare
Ies,iri:
W(T),b(T)ponderile ﬁnale, după Titerat,ii
Algoritmul: (se respectă notat ,iile anterioare acolo unde nu este precizat)
pentru ﬁecare iterat ,iet:
h(0)=x
pentru kde la 1 la L:
a(k)=b(k)+W(k)h(k1)
h(k)=f(a(k))
ˆy=h(l)
J=L(ˆy;y)
g r ˆyJ=rˆyL(ˆy;y)
pentru kde la Lla 1:
g ra(k)J
rb(k)J=g+rb(k)
rW(k)J=g(h(k1))T+rW(k)
W(k) W(k1)rW(k)J
b(k) b(k1)rb(k)J
g rh(k1)J=(W(k))Tg
În plus, pentru a spori capacitatea de generalizare a ret ,elei, există numeroase metode
de combatere a problemei de "overﬁtting", numite colectiv regularizare. O îmbunătăt ,ire
directăadusăalgoritmuluideînvăt ,areesteadăugareaunuiparametrudepenalizare
(),
care t ,ine cont de toate ponderile ret ,elei, funct ,iei de cost J:
˜J(;X;y)=J(;X;y)+
() (2.40)
undereglează contribut ,ia relativă a penalizării în funct ,ia de cost rezultată, care este
folosită ca funct ,ie propriu-zisă de cost în detrimentul celei originale. Regularizarea
agentuluiconstă,înacestcaz,înalegereauneivaloripentru potriviteastfelîncâtsistemul
să nu învet ,e prea îndeaproape structura datelor de antrenare (prea put ,ină regularizare sau
25

Capitolul 2. Concepte Teoretice
prea mic), însă nici să nu îi ﬁe afectată performant ,a în sens negativ atât pe datele
de antrenare, cât s ,i pe cele de testare ( prea mare). O altă tehnică de regularizare ar
consta în augmentarea exemplelor de antrenare prin transformarea lor în diverse moduri,
ﬁe aleatoare, ﬁe manuale, astfel încât ret ,eaua să ﬁe mai put ,in sensibilă la "zgomotul"
din date (de exemplu, în cazul imaginilor, exemplele de antrenare ar putea ﬁ răsucite la
un unghi aleatoriu s ,i/sau să se adauge pixeli eronat ,i). O metodă recentă de regularizare
a ret,elelor constă în aplicarea de "dropout": la antrenare (dar nu s ,i la testare), o din
neuroni, ales ,i aleator, sunt dezactivat ,i (ponderile nu mai sunt folosite s ,i nici actualizate
conformgradient ,ilor). Înpractică,utilizareauneiastfelderatededezactivarealeatoarea
neuronilorde50%s-ademonstrataﬁutilăpentrucombatereaproblemeide"overﬁtting",
în special în ret ,elele "deep" sau cu număr mare de straturi s ,i/sau neuroni.
2.3.3 Ret ,ele Neuronale Convolut ,ionale
Ret,elele neuronale convolut ,ionale sunt un tip particular de ret ,ele neuronale pentru
procesareadatelor custructurămatricială(cum arﬁdatesecvent ,ialesau imagini). Ele se
numescas ,adeoarecefolosescooperat ,iematematicăliniarănumităconvolut ,ie. Îngeneral,
o ret,ea este numită convolut ,ională dacă straturile folosesc predominant convolut ,ii în loc
de înmult ,iri matriciale.
O convolut ,ieseste o operat ,ie pe două funct ,ii reale xs,iw,x;w:R!R, notată de
obicei cu, care îndeplines ,te următoarea ecuat ,ie:
s(t)=(xw)(t)=Z
x(a)w(ta)da (2.41)
Înpractică,convolut ,iaseaplicămaidegrabăpedatediscretes ,ipefunct ,iimulti-dimensionate
Irespectiv K, numite funct ,ia de intrare respectiv "nucleu" (eng. "kernel"). De exemplu,
pentru imagini bidimensionale, convolut ,ia ar respecta următoarea ecuat ,ie:
S(i;j)=(IK)(i;j)=X
mX
nI(m;n)K(im;jn) (2.42)
26

2.3. Ret ,ele Neuronale
sau, având în vedere comutativitatea convolut ,iei:
(IK)(i;j)=X
mX
nI(im;jn)K(m;n) (2.43)
În ret ,ele neuronale, însă, nu se foloses ,te convolut ,ia cât corelarea încrucis ,ată, o operat ,ie
asemănătoare:
S(i;j)=(IK)(i;j)=X
mX
nI(i+m;j+n)K(m;n) (2.44)
Exemplu de convolut ,ie cu nucleu de dimensiune 22aplicată unei matrici de dimensiune 43
Înplus,înret ,eleleconvolut ,ionalemaiexistăceeacesenumes ,teomărimedepas(eng.
"stride"). În cazul celui mai comun pentru o astfel de ret ,ea, unui tensor tridimensional
deintrare V,carereprezintăoimagine(lăt ,ime,lungime,canale,imaginileﬁinddeobicei
reprezentatestandardizatconformunuimodeldeculoricaRGBsauCYMK),alunuitensor
cvadridimensional K, care reprezintă nucleul, s ,i pentru un rezultat Zal convolut ,ionării
luiKasupra V, tensor tridimensional aﬂat în acelas ,i format ca s ,iV, atunci:
Zi;j;k=X
l;m;nVl;j+m1;k+n1Ki;l;m;n (2.45)
27

Capitolul 2. Concepte Teoretice
Mărimea de pas intervine atunci când se dores ,te a "sări peste" valori din Vpe una sau
mai multe direct ,ii, astfel încât convolut ,ia să se aplice cu un pas de o mărime aleasă între
linii,coloane,canalesauchiarexempleadiacentedeintrare(încazultratăriiimaginilorca
tensoricvadridimensionali,ceade-apatradimensiunereprezentândnumăruldeexemple).
Acestlucruesteposibilprindeﬁnireauneifunct ,iideconvolut ,iecastfelîncâtecuat ,iapentru
Zsă devină, de exemplu, pentru mărimi de pas s1atât pe lungime, cât s ,i pe lăt ,ime:
Zi;j;k=c(K;V;s)i;j;k=X
l;m;nVl;(j1)s+m;(k1)s+nKi;l;m;n] (2.46)
Înplus,pelângăomărimedepassemaipotadăugaliniis ,icoloaneînimagineadeintrare
ca pas de pre-procesare (eng. "padding"), astfel încât convolut ,ia nucleului să poată să
ﬁe aplicată corect pe toate valorile imaginii, luând în calcul dimensiunea nucleului s ,i
mărimile de pas ale convolut ,iei pe ﬁecare dimensiune. Coloanele s ,i rândurile adăugate,
numeric,potﬁnule,saupotreprezentamaximesauminimesaumediialediverselorvalori
ale imaginii, sau pot "oglindi" imaginea sau pot continua cu ultima valoare de pe ﬁecare
rând s ,i coloană etc. Alegerea acestor valori reprezintă s ,i ea un hiperparametru al ret ,elei
s,i un element de arhitectură.
Convolut ,iile reprezintă un avantaj computat ,ional semniﬁcativ, întrucât numărul de
parametri învăt ,abili este semniﬁcativ redus fat ,ă de ret ,elele neuronale obis ,nuite. Un alt
avantaj constă în posibilitatea procesării de date de dimensiuni variate datorită înlocuirii
operat ,iei de înmult ,ire matriceală, care necesita matrici de ponderi de dimensiuni exacte.
Deasemenea,straturileconvolut ,ionale(carefolosescoperat ,iadeconvolut ,ie)suntcovari-
ante la translat ,ii: orice schimbare în datele de intrare produce o schimbare echivalentă în
dateledeies ,ire(douăfunct ,iifs,igsenumesccovariantedacă f(g(x))=g(f(x));fpoate
reprezenta convolut ,ia, iar go funct ,ie oarecare care transformă datele de intrare).
Un alt tip de straturi particulare ret ,elelor convolut ,ionale sunt straturile de "pooling",
care sintetizează regiuni din datele primite folosind diverse operat ,ii matematice, dintre
care cele mai utilizate ﬁind maximul, minimul sau media. Ele se aseamănă cu straturile
convolut ,ionalecamoddeaplicare,doarcăaplicăooperat ,iediferitădeceadeînmult ,irea
operat ,iei de convolut ,ie.
28

2.4. Învăt ,area Ranforsată
2.4 Învăt ,area Ranforsată
Deﬁnit ,iile,teoremele,propozit ,iiles,iecuat ,iiledinaceastăsect ,iuneaufostpreluatedin
[5].
Învăt,arearanforsatăreprezintăoclasădealgoritmideînvăt ,areautomatăpentrusarcini
în care există un mediu interactiv în care agentul învat ,ă să mapeze stări ale sistemului la
act,iuni conform unei funct ,ii de răsplată. Astfel, mediul cu care agentul interact ,ionează
dispune de un spat ,iu al stărilor s ,i îs,i schimbă starea la ﬁecare act ,iune a agentului s ,i,
eventual,înfunct ,iedetimp. Fiecareastfeldeschimbareproduceorăsplată,caremăsoară
empiric performant ,a algoritmului pe sarcina respectivă s ,i de care agentul trebuie să se
folosească cu scopul de a învăt ,a, ca funct ,ie de starea sistemului, ce act ,iuni să asocizeze
ﬁecărei stări pentru a maximiza răsplăt ,ile viitoare s ,i/sau răsplata totală obt ,inută până
la încheierea sarcinii, în cazul sarcinilor ﬁnite sau al posibilităt ,ii es,ecului fatal. Un
exemplu clasic de sarcină rezolvată cu algoritmi de învăt ,are ranforsată este jocul de s ,ah:
starea mediului la ﬁecare moment de timp este pozit ,ia pieselor pe tablă, act ,iunile sunt
reprezentate de mutarea unei piese, iar răsplăt ,ile pot ﬁ reprezentate de valoari numerice
întregi, pozitive atunci când sunt eliminate din joc piese oponente, negative atunci când
sunt eliminate din joc piese proprii, s ,i nule în rest.
Celepatruelementeleprincipalealeunuialgoritmdeînvăt ,areranforsatăsunt: "tactica"
(eng. "policy"), funct ,ia de răsplată, "funct ,ia de valoare" (eng. "value function") s ,i,
opt,ional, un model al mediului interactiv.
Tactica agentului deﬁnes ,te comportamentul acestuia la ﬁecare moment de timp, o
funct,ie care mapează stărilor act ,iuni. În practică, reprezentarea acesteia poate varia de la
tabele sau dict ,ionare simple la procese complexe de căutare. Această componentă stă la
bazaalgoritmuluideînvăt ,areranforsată-tacticaestesingurăsuﬁcientăpentruadetermina
comportamentul agentului. În general, ea este un proces stocastic.
Maximizareafunct ,ieiderăsplatădeﬁnes ,tet,elul/scopulagentului. Înacestsens,funct ,ia
de răsplată deﬁnes ,te ce evenimente sunt "beneﬁce" sau "maleﬁce" pentru agent s ,i repre-
zintă principalul modiﬁcator al tacticii agentului: dacă o act ,iune conduce la o răsplată
redusă, tactica este, de preferat, alterată astfel încât agentul să evite pe viitor să asocieze
29

Capitolul 2. Concepte Teoretice
respectiva act ,iune respectivei stări a sistemului.
În timp ce funct ,ia de răsplată reprezintă o componentă statică a mediului interactiv,
generală s ,i complet separată de agent, funct ,ia de valoare reprezintă o componentă a
algoritmului de învăt ,are. Informal, funct ,ia de valoare măsoară răsplata totală pe care
agentul se as ,teaptă să o dobândească pe viitor, pornind din starea curentă a sistemului.
Funct ,ia de valoare ia, deci, în calcul nu numai răsplata imediată, ci s ,i stările s ,i răsplăt ,ile
ceurmeazădreptrezultatdirects ,iindirectalact ,iunilorprezents ,iviitorposibile. Această
componentăfaceposibilprocesuldeînvăt ,areasarcinilordescriseanterior,întrucâtpermit
dezvoltarea unor tactici pe termen lung, ci nu doar imediate.
Modelul reprezintă o componentă opt ,ională a algoritmilor de învăt ,are automată care
deﬁnes ,te o imitat ,ie a mediului interactiv ce-i permite algoritmului să simuleze tranzit ,iile
dintrestărialemediului fărăaact ,ionapropriu-zisasuprasa, deexemplupentruaprezice
răsplăt ,ile tuturor act ,iunilor viitoarei stări a sistemului în funct ,ie de o act ,iune aleasă în
starea actuală. Folosirea unui model poate îmbunătăt ,i ﬁe performant ,a, ﬁe timpul în
care agentul ajunge la o performant ,ă satisfăcătoare pe sarcină, însă există algoritmi care
funct,ionează în întregime pe baza încercărilor repetate.
2.4.1 Procese de Decizie Markov
ProceselededecizieMarkovreprezintăoformalizarecompletdiscretăasarcinilorde
învăt,are ranforsată. La ﬁecare pas discret t, mediul interactiv îi furnizează agentului o
reprezentare a stării sistemului St2S. După aceea, în cadrul aceluias ,moment t, agentul
îi furnizează mediului interactiv o act ,iuneAt2A(St), dacă mult ,imea act ,iunilor posibile
seschimbăînfunct ,iedestareaîncareseaﬂăagentul,sau At2Adacămult ,imeaact ,iunilor
posibile este aceeas ,i pe întreaga durată a sarcinii. În acest moment, agentul s ,i mediul
interactiv avansează la pasul t+1s,i agentului îi este furnizată de către sistem o răsplată
Rt+12R Rînfunct ,iede Sts,iAt. Acestprocesserepetălainﬁnitsaupânăcândsarcina
se încheie. Într-un proces de decizie Markov ﬁnit, mult ,imile stărilor, a act ,iunilor s ,i a
răsplăt ,ilorS,A,respectivR,auunnumărﬁnitdeelementes ,iexistă,deci,pentruﬁecare
30

2.4. Învăt ,area Ranforsată
Rts,iSt, distribut ,ii de probabilitate dependente doar de starea s ,i act,iunea precedentă:
p(s0;rjs;a)=PrfSt=s0;Rt=rjSt1=s;At1=ag;8s0;s2S;r2R;a2A(s)
(2.47)
Deexemplu,încazuljocurilorpecalculator,stărilemediuluiinteractivpotﬁreprezentate
de imaginile jocului la ﬁecare moment discret de timp, discretizare care există datorită
limiteisuperioareîntregianumăruluideimaginicepotﬁaﬁs ,ateîncadrulﬁecăreisecunde
peecran. Act ,iunilelepotreprezentatastelesaubutoaneleapăsate,iarrăsplăt ,ilediferent ,a
dintrescoruljoculuilamomentulactualdetimps ,iscoruljoculuilamomentulprecedent.
O reprezentare a interact ,iunii agent-mediu într-un proces de decizie Markov
Încadrulsarcinilordeînvăt ,areranforsatăcarecont ,insubdiviziuniizolateﬁnite,numite
s,i episoade, procesul de decizie Markov poate ﬁ modelat asemănător cu un automat ﬁnit,
având stare init ,ială s,i stări ﬁnale sau terminale, care corespund începutului s ,i, respectiv,
sfârs,ituluiunuiepisodalmediului. Agentulpornes ,teîntotdeaunainteract ,iuneadinstarea
init,ialăS0(sau dintr-o stare init ,ială aleasă aleatoriu din distribut ,ia stărilor init ,iale ale
mediului, acolo unde este cazul) s ,i interact ,ionează cu mediul până când acesta este adus
într-o stare terminală, reprezentativă pentru ﬁnalizarea episodului, după care mediul este
resetat la starea init ,ialăS0(respectiv, la o altă stare init ,ială aleasă din distribut ,ia stărilor
init,iale ale mediului), începând un episod nou complet independent de cel precedent s ,i
repetând procesul. Astfel, maximizarea funct ,iei de răsplată la momentul de timp tîn
cadrulunuiepisodsereducelamaximizareasumeiP
t0>tRt0. Aceastăformalizarenumai
este utilă s ,i în cazul sarcinilor de învăt ,are ranforsată inﬁnite, întrucât respectiva sumă nu
are o limită superioară ﬁnită. În acest sens se deﬁnes ,te conceptul de rată de reducere
31

Capitolul 2. Concepte Teoretice
(eng. "discounting rate"), un scalar real
2[0;1)cu puterile consecutive ale căruia sunt
înmult ,ite răsplăt ,ile viitoare în calcularea sumei ce se dores ,te a ﬁ maximizată, pentru a
determinaoinvers-proport ,ionalitateîntredistant ,acatimpdemomentulprezents ,iimpactul
asupra funct ,iei obiectiv; se dores ,te, deci, la momentul de timp t, maximizarea sumei:
Gt=1X
i=0
iRt+i+1 (2.48)
care nu converge nici ea garantat în cadrul sarcinilor inﬁnite, însă care este mai utilă în
exprimarea calculelor aproximative ale răsplăt ,ilor as ,teptate.
În procesul de decizie Markov, tactica reprezintă o funct ,ie care duce o stare în
probabilităt ,ile alegerii ﬁecăreia dintre act ,iunile posibile în starea respectivă, deci pro-
babilitatea(ajs)lamomentuldetimp tcaAt=a,St=s. Rolulalgoritmuluideînvăt ,are
ranforsatăestededeterminacumseschimbăaceastăfunct ,ieîmpreunăcuexperient ,aacu-
mulată. În acest context se deﬁnes ,te valoarea v(s)a stării sconform tacticii , care
reprezintă răsplata totală acumulată de către agentul în mediul interactiv, pornind din
starea ss,i urmând. Formal, valoarea la momentul tpoate ﬁ deﬁnită astfel:
v(s)=E[GtjSt=s]=E2
6666641X
i=0
iRt+i+1St=s3
777775;8s2Sneterminală (2.49)
Pentru stările terminale f2S,v(f)=0. În acest sens se poate deﬁni, în aceleas ,i
condit ,ii, s,i o valoare a tacticii ca funct ,ie de stare s ,i de act ,iune:
Q(s;a)=E[GtjSt=s;At=a]=E2
6666641X
i=0yiRt+i+1St=s;At=a3
777775;8a2A(s)
(2.50)
Qsemainumes ,tes,i"funct ,iadevaloare-act ,iune"(eng. "action-valuefunction")atacticii
. Oproprietatefolositoareafunct ,ieidevaloareestefaptulcăsatisfaceurmătoarearelat ,ie
32

2.4. Învăt ,area Ranforsată
recursivă (8s2S):
v(s)=E[GtjSt=s]
=E[Rt+1+
Gt+1jSt=s]
=P
a(ajs)P
s0P
rp(s0;rjs;a)(r+
E[Gt+1jSt+1=s0])
=P
a(ajs)P
s0;rp(s0;rjs;a)(r+
v(s0))(2.51)
Funct ,ia de valoare a unei tactici poate ﬁ folosită pentru compararea s ,i ordonarea
acesteia cu alte tactici. O tactică este "mai bună sau egală" ca o tactică 0dacă
v(s)v0(s),8s2S. Din moment ce numărul tacticilor posibile este ﬁnit, există o
mult,imedetactici"maibunesauegale"catoatecelelalte: 9
i,v
i(s)v(s),8tactică
pentru acelas ,i proces de decizie Markov, 8s2S,i1. Din moment ce v
i(s)v
j(s),
8s2S,8i;j1, atunci v
i(s)=v
j(s), deci se poate considera o singură astfel de
tactică optimă echivalentă cu toate celelalte. În acest context, funct ,ia sa de valoare
v, respectiv cea de valoare-act ,iune Q, se deﬁnesc ca v(s)=max
v(s), respectiv
Q(s;a)=max
Q(s;a),8s2S,8a2A(s). Drept rezultat:
Q(s;a)=E[Rt+1+
v(St+1)jSt=s;At=a] (2.52)
Întrucât veste funct ,ie valoare pentru o tactică a unui sistem de decizie Markov s ,i,
deci, satisface (2.51), s ,i întrucât este funct ,ia de valoare optimă, ecuat ,ia Bellman asociată
poate ﬁ scrisă independent de vreo tactică :
v(s)=max
a2A(s)Q(s;a)
=max
aE[GtjSt=s;At=a]
=max
aE[Rt+1+
Gt+1jSt=s;At=a]
=max
aE[Rt+1+
v(St+1)jSt=s;At=a]
=max
aP
s0;rp(s0;rjs;a)(r+
v(s0))(2.53)
33

Capitolul 2. Concepte Teoretice
respectiv pentru funct ,ia de valoare-act ,iune:
Q(s;a)=E[Rt+1+
max
a0Q(St+1;a0)jSt=s;At=a]
=P
s0;rp(s0;rjs;a)(r+
max
a0(s0;a0))(2.54)
O consecint ,ă utilă a ecuat ,iilor Bellman optime este eliminarea pas ,ilor recursivi: dată
funct,iadevaloareoptimă vpentruunprocesdedecizieMarkov,atunci,laﬁecaremoment
de timp t, este de ajunsă determinarea act ,iunii sau act ,iunilor ai,i1, pentru care v(St)
este maxim, conform (2.53). Orice tactică care atribuie probabilităt ,i nenule doar acelor
stări va ﬁ o tactică optimă în cadrul respectivului proces de decizie Markov. În acest
fel, algoritmul de învăt ,are ranforsată devine un algoritm "greedy", care alege decizia
imediat-optimălaﬁecarepasalalgoritmului. Diferent ,aconstăînfunct ,iav: optimalitatea
ei garantează optimalitatea globală a deciziei. Analog Q: dacă se cunoas ,teQ, atunci
nu mai este nevoie nici măcar de calcularea act ,iunii sau act ,iunilor aiprin intermediul
ecuat ,ieiBellmanoptime,întrucâtfunct ,iaQ,prindeﬁnit ,ie,cont ,inedejaacesteinformat ,ii.
Act,iuneaoptimă,atâtlocalcâts ,iglobal,lamomentuldetimp t,este argmax aQ(St;a). În
practică, se caută aproximarea lui vsau a lui Q.
34

Capitolul 3
Metode recente pentru problema aleasă
3.1 Jucând Atari prin Învăt ,are Ranforsată "Deep"
Publicată de cercetătorii de la DeepMind Technologies (Google) în 2015, lucrarea
"Playing Atari with Deep Reinforcement Learning" [6] este cea care a prezentat primul
model de învăt ,are ranforsată care reus ,es,te să învet ,e strategii pentru jocuri digitale direct
din imagini. Modelul în sine este o ret ,ea convolut ,ională, iar algoritmul de învăt ,are ran-
forsatăconformcăruiaret ,eauaesteantrenatăestecelde"Q-learning": ret ,eauaîncearcăsă
aproximeze funct ,ia de valoare-act ,iune ideală Q(2.54) folosind un spat ,iu al parametrilor
mai redus decât ar ﬁ nevoie pentru stocarea acesteia în întregime în memorie. Ret ,eaua
primes ,teimaginialejoculuilaintrare(stări)s ,iaproximeazăviitoarelerăsplăt ,ipentruﬁe-
careact ,iuneposibilăînstarearespectivă(conformcărorasepotdetermina"celemaibune"
act,iuni în respectivele stări), folosind aceeas ,i mult ,ime de parametri s ,i de hiperparametri,
independent de jocul particular învăt ,at la un moment de timp.
Autorii aplică algoritmul în mod particular pe jocurile pentru consola Atari 2600,
datorită simultaneităt ,ii dimensiunii lor reduse a spat ,iului imaginilor cu diﬁcultatea lor
relativridicatăchiars ,ipentruagent ,iiumanidinprezent. Dimensiuneaimaginilorjocurilor
estede 210160,laofrecvent ,ădeaﬁs ,ajde60Hz(deci60decadrepesecundă),dispunând
deungamălimitatădeculori( 128). Jocuriledispunderegulis ,icondit ,iidevictoriediverse,
de la jocuri de explorare ("Pac-Man"), până la jocuri "de sumă zero" (eng. "zero-sum
games"), în care scopul este obt ,inerea unui scor pre-ﬁxat înaintea oponentului (controlat
35

Capitolul 3. Metode recente pentru problema aleasă
de consolă), însă toate au în comun condit ,iile clare de victorie, faptul că se desfăs ,oară în
timpreal(spredeosebiredejocurilebazatepeconceptulderândurisauture,cumestede
exemplus ,ahul)s ,ifaptulcăsuntﬁnite(niciunuldintrejocurinupermiteluareunoract ,iuni
care să conducă la un ciclu interminabil).
Jocuri pentru consola Atari 2600 (de la stânga la dreapta): "Pong", "Breakout", "Space Invaders", "Seaquest", "Beam Rider"
Problema poate ﬁ modelată, atunci, printr-un proces de decizie Markov, deoarece
modelulesteaplicatstrictpeunemulatoralconsoleidejocuriAtari2600,prinintermediul
uneiinterfet ,eprogramaticecaresăstandardizezes ,isăus ,urezeinteract ,iuneacuemulatorul
s,i deoarece ﬁecare dintre jocuri este ﬁnit prin proiectare. Ca atare, autorii folosesc
următoarea formalizare: stările sunt imaginile emulatorului, act ,iunile sunt comenzile (în
cazul unui jucător uman, de exemplu, act ,iunile ar ﬁ determinate de apăsarea tastelor),
iar răsplăt ,ile sunt ﬁxe s ,i incluse în interfat ,a de învăt ,are, pentru ﬁecare joc în parte, ca
diferent ,a dintre scoruri la ﬁecare două momente consecutive de timp. În acest context,
modelul învat ,ă să aproximeze funct ,ia de valoare-act ,iune optimă pentru jocul pe care îl
învat,ăQ(s;a),s2S,a2A(s), sau Q(s;a), undeeste tactica ideală pentru sarcina
(jocul) curentă.
Pentru a putea folosi o ret ,ea neuronală de parametrii pentru a aproxima Q, se
deﬁnes ,te următoarea funct ,ie obiectiv dependentă de iterat ,ia curentă i1:
Li(i)=Es;a[(yiQ(s;a;i))2] (3.1)
unde Q(s;a;i)reprezintă aproximarea funct ,iei de valoare-act ,iune optimă al iterat ,ieii,
(s;a)se es,antionează din (s;a), o distribut ,ie peste stări s ,i act,iuni care este denumită
"distribut ,ia comportamentală" (eng. "behaviour distribution"), iar yireprezintă valorile
"t,intă"aleiterat ,ieicurentes ,isecalculeazăînfunct ,iedestăriles ,iact,iunileposibileimediat-
36

3.1. Jucând Atari prin Învăt ,are Ranforsată "Deep"
viitoare după următoarea formulă:
yi=Es0emulator [r+
max
a0Q(s0;a0;i1)js;a] (3.2)
Des,i asemănătoare cu valorile "t ,intă" din algoritmii de învăt ,are automată supervizată
prin faptul că funct ,ia obiectiv măsoară divergent ,ele dintre acestea s ,i valorile calculate de
parametriiret ,elei,elediferăprinfaptulcănureprezintăvaloriobiective,ﬁxes ,icunoscute
dinaintea procesului de învăt ,are, ci, din contră, depind întrutotul de acesta. Astfel, se
minimizează funct ,iaLi(i)prin intermediul algoritmului de coborâre pe gradient pentru
unnumărsuﬁcientdemaredeiterat ,iiipentruapermiteînvăt ,areajoculuicurent. Mediile
Edin (3.1) s ,i (3.2) se pot aproxima folosind es ,antioane coasociate de stări, act ,iuni s ,i
răsplăt ,iconformmediuluiinteractivs ,iadistribut ,iei(s;a). Pentruaceasta,sefoloses ,teo
memorie auxiliară (eng. "replay memory"), care păstrează stările, act ,iunile s ,i răsplăt ,ile
de la ﬁecare moment de timp pentru a facilita învăt ,area independentă de starea curentă
a mediului interactiv. În acest mod, la ﬁecare iterat ,iei, algoritmul es ,antionează un
număr pre-stabilit de "experient ,e" (denumirea colectivă pentru un triplet (s;a;r)de stare,
act,iune, răsplată) conform căruia calculează yi(folosind, deci, parametrii i1) s,iLi(i).
Totodată, se păstrează starea asociată momentului de timp tîn memoria auxiliară, luând
înconsiderarefaptulcămomenteledetimpalemediuluiinteractivnucorespundneapărat
iterat,iilor algoritmului (pentru ﬁecare iterat ,ie au loc kmomente de timp succesive, k1
număr natural). Această memorie auxiliară permite antrenarea agentului "oﬄine", fără
a mai ﬁ nevoie de un mediu interactiv care să ruleze simultan cu procesul de învăt ,are
pentru a furniza experient ,e, în ceea ce autorii denumesc "rederularea experient ,ei" (eng.
"experience replay"). În plus, un alt avantaj creat de izolarea s ,i desincronizarea stărilor
joculuiprinutilizareaacesteimemoriiauxiliareconstăînfaptulcănumaiexistăcorelat ,ii
între stări s ,i, deci, procesul de învăt ,are este nu numai mai rapid, cât s ,i mai stabil (având
învederefaptulcăfunct ,iaminimizatăestedependentădeparametriiiterat ,ieiprecedente),
nu numai evitând variat ,iile mari ale performant ,ei algoritmului de la o iterat ,ie la alta, cât
s,i evitând blocaje în minime locale/cicluri inﬁnite de aproximări ale funct ,ieiQcare nu
se mai îmbunătăt ,esc.
37

Capitolul 3. Metode recente pentru problema aleasă
O diﬁcultate pe care o prezintă spat ,iul imaginilor jocurilor este dependent ,a acestora
de timp: o imagine izolată, din orice moment de timp dintr-un joc care se derulează în
timpreal,nuvaincludeinformat ,iilegatedeconceptedependentedetimp,camis ,careasau
animat ,ile. Deaceea,autoriifolosescpentrustăriosuccesiunedeimagini,alegândﬁecare
ak-a imagine, k1, furnizată de mediul interactiv până la un total de Kimagini de joc
astfel culese, K2, care alcătuiesc toate o stare St. În acest caz, tnu mai corespunde
unuimomentdetimprealalmediuluiinteractiv,ciuneiiterat ,iiaalgoritmului. Unaspect
semniﬁcativ în formarea acestor stări este intersectarea stărilor consecutive: St1s,iSt
diferă prin exact două imagini: cea mai "veche" imagine ca moment de timp a stării
anterioare St1,carelipses ,tedin St,s,iceamai"nouă"imaginecamomentdetimpastării
St,carelipses ,tedin St1. Sesubînt ,elegefaptulcăimaginileprecedenteceleimai"noi"ca
momentdetimpdincadruluneistărinusuntasociateact ,iuniis ,irăsplăt ,iistării,ciprezintă
doar informat ,ii adit ,ionale relevante imortalizării conceptelor temporale ale mediului de
joc. Atâtact ,iuneacâts ,irăsplatasuntdeterminatestrictconformultimei(celeimai"noi")
imagini din stare (în cazul în care nu se alege ﬁecare imagine a emulatorului, ci doar
ﬁecare a k-a, restul ﬁind "sărite", se furnizează emulatorului aceeas ,i act,iune pe decursul
tuturor imaginilor "sărite", iar răsplata se calculează ca suma răsplăt ,ilor ﬁecărei imagini
"sărite").
Un ultim aspect al algoritmului propus este strategia : la ﬁecare iterat ,iei, agentul
ia o act ,iune uniform aleatoare din spat ,iul de act ,iuni posibile cu probabilitatea 2[0;1]
(hiperparametru ales), s ,i altfel ia act ,iunea optimă argmax aQ(Si;a;i)conform parame-
trilor ret ,elei actualii. Autorii folosesc un ca funct ,ie de iterat ,ie, reducându-l treptat
de la valoarea init ,ială de 1(act,iuni100%uniform aleatoare) până la o valoare minimă
pre-stabilită. Motivat ,iaacestuiprocesadit ,ionalînluareadeciziilorconstăîncompromisul
speciﬁc algoritmilor de învăt ,are ranforsată între explorare s ,i exploatare; este nevoie ca
algoritmulsăexplorezecâtmaimultdinspat ,iulstărilor,iarîncadrulunuimediuinteractiv,
init,ial, acest lucru nu este posibil decât prin alegeri uniform aleatoare, deoarece acestea
maximizeazăvariabilitateastărilorîntâlniteînlipsainformat ,iilorlegatedemediulinterac-
tiv, iar ulterior, exploatarea conduce la stări ale jocului inaccesibile unui agent aleatoriu
datorităcomplexităt ,iiregulilorcetrebuieurmateîncadruljoculuipentrucaacesteasăﬁe
38

3.1. Jucând Atari prin Învăt ,are Ranforsată "Deep"
întâlnite.
3.1.1 Algoritm
Pentru Iiimaginialejoculuifurnizatedeemulator, knumăruldeimaginidintr-ostare
s,io funct ,ie de procesare ale imaginilor emulatorului/stărilor înainte de adăugarea în
memorie(deexemplu,prinreducereaspat ,iuluiculorilorlaalb-negru),algoritmuldebază
este următorul:
Se init ,ializează memoria auxiliară Mcumstări alegând act ,iuni uniform aleatoare
Se init ,ializează modelul cu parametri aleatori
pentru ﬁecare episod de la 1laM:
Init,ializează starea neprocesată s0
1 fI1;I2;:::; Ikgs,i starea procesată 1 (s1)
pentru ﬁecare iterat ,iet>k:
Alege act ,iunea aleatoare atcu probabilitatea
altfel, alege at argmax aQ((st);a;)
Comunică act ,iunea atemulatorului s ,i observă răsplata rts,i imaginea It+1
Atribuie st+1 (stfItkg)[fIt+1gs,i procesează st+1:t+1 (st+1)
Amplasează (t;at;rt;t+1)înM
Es,antionează uniform bexperient ,e(j;aj;rj;j+1)dinM
pentru ﬁecare jde la 1lab:
dacăj+1este stare terminală:
yj rj
altfel:
yj rj+
max a0Q(j+1;a0;)
pentru ﬁecare jde la 1lab:
Aplicăoiterat ,ieaalgoritmuluidecoborârepegradient,urmărindminimizarea
funct,iei(yjQ(j;aj;))2, obt,inând astfel parametrii actualizat ,i
3.1.2 Rezultate s ,i Experimente
Procesarea folosită de autori în experimente este de a redimensiona imaginile la
dimensiunea de 8484valori monocrome (alb-negru), pentru a facilita antrenarea mai
eﬁcientă. În continuare, modelul aplică o convolut ,ie cu 16ﬁltre de dimensiune 88
cu un pas de 44asupra stărilor de intrare. Funct ,ia de activarea a acestui prim strat
convolut ,ional din ret ,ea constă în funct ,ia "ReLU". Al doilea strat aplică o convolut ,ie cu
32de ﬁltre de dimensiune 44cu pas 22, s,i acceas ,i funct ,ie de activare. Rezultatul
celuide-aldoileastratestetranspusîntr-oreprezentarevectorialăunidimensionalăpentru
39

Capitolul 3. Metode recente pentru problema aleasă
ﬁecare starede intrare,care vareprezenta intrareapentru celde-al treileastrat, de 256de
unităt ,i. Stratul ﬁnal reduce dimensionalitatea datelor la numărul de act ,iuni posibilejAj,
obt,inând astfel Q(sj;ajl;),l2f1;:::;jAjg, pentru toate stările de intrare sj.
Acelas ,i model, cu aceias ,i hiperparametri, este folosit pentru ﬁecare joc încercat:
"Beam Rider", "Breakout", "Enduro", "Q*bert", "Seaquest", "Space Invaders". Pentru
a utiliza aceeas ,i mult ,ime de hiperparametri indiferent de joc, autorii restrâng răsplăt ,ile
la antrenare astfel încât toate răsplăt ,ile negative să ﬁe reduse la 1, toate cele nule să
rămânănule,iartoatecelepozitivesăﬁeredusela 1. Număruldestăripecarealgoritmul
se antrenează la ﬁecare iterat ,ie este 32.este redus liniar de la 1la0:1de-a lungul
a1000000 de iterat ,ii, de unde rămâne constant la valoarea de 0:1pe durata antrenării.
Dimensiunea maximă a memoriei auxiliare este de 1000000 de experient ,e, păstrând în
ﬁecarestareultimele k=4imaginialejocului. Înplus,modelul"sare"pestecâte 3imagini
ale emulatorului, alegând, deci, doar a 4-a imagine de ﬁecare dată, mai put ,in în cazul
jocului"SpaceInvaders",singuraastfeldediferent ,ăîncadrulacestuialgoritmconstândîn
alegerea a ﬁecărei cea de-a 3-a imaginii, datorită unor particularităt ,i ale modului în care
sunt aﬁs ,ate obiectele în jocul respectiv. Autorii au antrenat modelul timp de 10000000
astfel de iterat ,ii pentru ﬁecare joc în parte s ,i au comparat rezultatele medii obt ,inute, pe
urmă, folosind un =0:05ﬁxat pe decursul a mai multor episoade, cu rezultatele medii
obt,inute de jucători umani în decursul a două ore s ,i cu rezultatele unor solut ,ii anterioare
pentruaceastăproblemă(darcarefoloseschiperparametris ,i/sauinformat ,iispeciﬁcepre-
determinate referitoare la problemă). Pentru
s-a folosit valoarea de 0:99, iar rata de
învăt,are folosită pentru algoritmul de coborâre pe gradient este de 0:00025.
Beam Rider Breakout Enduro PongQ*bert Sequest Space Invaders
Uniform Aleatoriu 354 1.2 0-20.4 157 110 179
SARSA 996 5.2 129 -19614 665 271
Contingency 1743 6 159 -17960 723 268
DQN 4092 168 470 201952 1705 581
Uman 7456 31 368 -318900 28010 3690
Atât solut ,ia SARSA, cât s ,i Contingency (care este bazată pe SARSA), se folosesc de faptul că ﬁecare obiect dintr-un joc Atari 2600 este reprezentat printr-o singură culoare
distinctădecelelalteobiecte,dintrecele128deculoridisponibilepeconsolă,s ,i,deci,nudispundeogeneralitatelafelderidicatăs ,inuprezintăaplicabilitateînafaradomeniului
jocurilor pentru acesată consolă (spre deosebire de solut ,ia DQN sau "Deep Q-Learning", as ,a cum este ea numită de către autori).
40

3.2. Control la Nivel Uman prin Învăt ,are Ranforsată "Deep"
3.2 ControllaNivelUmanprinÎnvăt ,areRanforsată"Deep"
Publicată de către Nature în 2015, lucrarea "Human-level control through deep re-
inforcement learning" [7] aduce îmbunătăt ,iri majore algoritmului anterior de "deep Q-
learning", atât dinpunct de vedere al stabilităt ,ii de antrenarecât s ,i din punctde vedere al
performant ,ei, pe care le testează în cadrul aceloras ,i jocuri pentru consola Atari 2600.
Contribut ,ia esent ,ială pe care o aduce această metodă algoritmului anterior este con-
ceptulde"modelt ,intă". Conform(3.1)s ,i(3.2),laﬁecareiterat ,ieiaalgoritmului,funct ,ia
obiectivminimizatădepindedeparametrii i1aiiterat ,ieiprecedentepentruacalculava-
lorile"t ,intă"sauobiectiv. Apropiereadintrevalorileparametrilor is,ii1conducelaun
procesdeînvăt ,arerelativinstabils ,ichiarinertîncepândcuunmomentdetimpavansat,din
careînvăt ,areaunortacticidejocmaiﬁnenumaiesteposibilă. Înacestsens,autoriifolosesc
unsetseparatdeponderi"t ,intă"
i,carepreiauvaloareaponderiloractualealemodelului
la ﬁecare Cnumăr de iterat ,ii s,i, în rest, rămân ﬁxe:
i=
Ck=
Ck+1=:::=
C(k+1)1,
8i2fCk;:::; C(k+1)1g,8k1. Ca atare, doar (3.2) se modiﬁcă, anume în:
yi=E[r+
max
a0Q(s0;a0;
i)js;a] (3.3)
3.2.1 Algoritm
Algoritmul este în mare parte acelas ,i, având în plus modiﬁcarea prezentată anterior.
Se init ,ializează memoria auxiliară Mcumstări alegând act ,iuni uniform aleatoare
Se init ,ializează modelul cu parametri aleatori
pentru ﬁecare episod de la 1laM:
Init,ializează starea neprocesată s0
1 fI1;I2;:::; Ikgs,i starea procesată 1 (s1)
pentru ﬁecare iterat ,iet>k:
Alege act ,iunea aleatoare atcu probabilitatea
altfel, alege at argmax aQ((st);a;)
Comunică act ,iunea atemulatorului s ,i observă răsplata rts,i imaginea It+1
Atribuie st+1 (stfItkg)[fIt+1gs,i procesează st+1:t+1 (st+1)
Amplasează (t;at;rt;t+1)înM
Es,antionează uniform bexperient ,e(j;aj;rj;j+1)dinM
pentru ﬁecare jde la 1lab:
dacăj+1este stare terminală:
yj rj
41

Capitolul 3. Metode recente pentru problema aleasă
altfel:
yj rj+
max a0Q(j+1;a0;)
pentru ﬁecare jde la 1lab:
Aplicăoiterat ,ieaalgoritmuluidecoborârepegradient,urmărindminimizarea
funct,iei(yjQ(j;aj;))2, obt,inând astfel parametrii actualizat ,i
dacă t mod C =0:
Atribuie
3.2.2 Rezultate s ,i Experimente
Autorii folosesc în experimente aceias ,i hiperparametri ca s ,i în lucrarea originală,
adăugând hiperparametrul C=10000(rata de actualizare a "modelului t ,intă"), s ,i mărind
numărul de ﬁltre ale straturilor pentru o capacitate mai mare. În loc de a antrena timp de
10000000 de iterat ,ii ﬁecare joc în parte, autorii antrenează algoritmul timp de 50000000
de iterat ,ii pentru rezultatele raportate. Mai exact, pe aceeas ,i mult ,ime de jocuri ca s ,i a
solut,iei anterioare (des ,i lucrarea speciﬁcă rezultatele pentru toate jocurile disponibile pe
consola Atari), rezultatele sunt următoarele:
Beam Rider Breakout Enduro PongQ*bert Sequest Space Invaders
Uniform Aleatoriu 354 1.2 0-20.4 157 110 179
DQN 10m 4092 168 470 201952 1705 581
DQN50m 6846 401.2 301.8 18.910596 5286 1976
Uman 7456 31 368 -318900 28010 3690
Înacestcontext,DQNreprezintăsolut ,iadebază,antrenatăpe10milioanedeiterat ,ii,iarDQNreprezintăsolut ,iaactuală,folosindun"modelt ,intă"s,iantrenatăpe50demilioane
de iterat,ii.
Se pot observa îmbunătăt ,iri drastice în rezultatele acestei metode, datorate în special
utilizării "modelului t ,intă", cât s ,i numărului mai ridicat de iterat ,ii de antrenare.
3.3 Depăs ,irea Uitării Catastrofale în Ret ,elele Neuronale
Publicată de către Deepmind în colaborare cu departamentul de bioinginerie al Co-
legiului Imperial din Londra la sfârs ,itul anului 2016, lucrarea "Overcoming catastrophic
forgetting in neural networks" [8] propune o posibilă metodă de utilizare a ret ,elelor ne-
uronale pentru sarcini multiple din acelas ,i domeniu s ,i, deci, de prevenire sau depăs ,ire a
"uitării" inerente procesului de învăt ,are a sarcinilor anterioare atunci când aceeas ,i ret,ea
este folosită pentru a învăt ,a o sarcină nouă, problemă cu care s-au confruntat astfel de
42

3.3. Depăs ,irea Uitării Catastrofale în Ret ,elele Neuronale
modele încă de la concept ,ie. Pentru a demonstra aplicabilitatea algoritmului propus,
autorii experimentează, printre altele, pe acelas ,i domeniu al jocurilor Atari.
"Uitarea"înret ,eleleneuronaleestedatoratăschimbăriidrasticeaparametrilor/ponderi-
lormodeluluipentruaacomodasarcinilenoi. Înciudaprogresuluigeneralaldomeniului,
modelele încă nu sunt pregătite să învet ,e continuu sarcini noi fără a uita complet sau
aproape complet sarcinile vechi. O posibilă solut ,ie aplicată, printre altele, s ,i pe jocurile
atari,esteînvăt ,areaconcomitentăamaimultorsarciniprinîntrepătrundereadatelorpentru
toate sarcinile (în cazul jocurilor Atari, prin utilizarea simultană a mai multor memorii
auxiliare),însăaceastaestenepracticăpentruunnumărmaredesarcinidatoritănecesităt ,ii
unuivolummaredememoriepentruament ,inetoatedatelenecesare. Înacestsens,autorii
dezvoltăunalgoritmde"consolidareaponderilorelastice"(eng. "elasticweightconsoli-
dation"), inspirat din consolidarea sinaptică a creierului uman, care presupune reducerea
plasticităt ,ii sinapselor vitale sarcinilor învăt ,ate anterior atunci când se învat ,ă o sarcină
nouă. Algoritmulsebazeazăpediversitateaponderilorret ,elelorneuronale: oret ,eapoate
avea mai multe conﬁgurat ,ii ale ponderilor sale echivalente din punct de vedere al unei
sarcini speciﬁce, care converg la acelas ,i minim al funct ,iei obiectiv s ,i oferă rezultate care
diferă doar neglijabil sau deloc. Autorii se folosesc de acest fapt pentru a propune pro-
babilitatea semniﬁcativă ca spat ,iile ponderilor optime speciﬁce a două sarcini As,iBale
unei ret ,ele să se intersecteze, fapt care ar demonstra imediat existent ,a unei conﬁgurat ,ii
caresăacomodezeatâtponderile"optime"(înacestcontext,optimeînsemnândponderile
care minimizează cel mai mult eroarea găsite, nu neapărat ponderile care minimizează
eroareacelmaimultposibil)
Apentrusarcina Acâts,iceleoptime
Bpentrusarcina B.
O vizualizare intuitivă a spat ,iului parametrilor optimi pentru sarcinile As,iBs,i a diferent ,ei dintre învăt ,area obis ,nuită a sarcinii Bîn urma minimizării erorii pe sarcina A("No
penalty") s ,i învăt,area folosind penalizarea dată de consolidarea ponderilor elastice ( EWC);L2semniﬁcă aplicarea unei penalizări de tip L2la antrenarea pe sarcina B
43

Capitolul 3. Metode recente pentru problema aleasă
Înaceastădirect ,ie,autoriiconsiderăret ,eleleneuronaledintr-operspectivăprobabilistă:
optimizareaparametrilor presupune,practic,găsireacelormaiprobabilevalorialesale
datﬁinduneimult ,imidedateDi.e. calcularealui p(jD). LogaritmândregulaluiBayes,
se poate deduce că:
log p(jD)=log p(Dj)+log p()log p(D) (3.4)
unde log p(Dj)coincide cu negarea valorii funct ,iei de costL(). DacăDeste format
din două mult ,imi de dateDAs,iDBpentru sarcinile A, respectiv B, atunci ecuat ,ia
precedentă poate ﬁ rescrisă în felul următor:
log p(jD)=log p(DBj)+log p(jDA)log p(DB) (3.5)
Rezultând în următoarea funct ,ie de cost pentru sarcina B:
L()=LB()+X
i
2Fi(i
A;i)2(3.6)
unde iestefolositcaindicealﬁecăreiponderidin ,respectiv
A,
Areprezintăponderile
"optime"găsitepentrusarcina Aînaintedeaîncepeantrenareapesarcina B,Fireprezintă
matricea Fisher asociată gradient ,ilor ponderii
A;i, iarLB()reprezintă funct ,ia de cost
obis,nuită a modelului calculată pentru sarcina B.este un hiperparametru care măsoară
cât de semniﬁcativă este sarcina anterioară ( A) fat,ă de cea curentă ( B). Pentru mai multe
sarcini,sepotadunapenalizărileindividualepentruﬁecaresarcinăanterioarălafunct ,iade
costasarciniicurente. CalculareamatriceiFisherserealizeazăpebazamedieiradicalilor
de ordin doi ai gradient ,ilor ponderilor sarcinii precedente fat ,ă de probabilităt ,ile asociate
act,iunilor calculate pentru o serie de stări oarecare date (calculate cu ajutorul funct ,iei
softmax, înainte de a ﬁ utilizate pentru calcularea funct ,iilor de cost). Mai exact:
Fi=1
mX
j(r
A;iln(so ftmax (x(j))aj))2;ajso ftmax (x(j)) (3.7)
unde mreprezintă numărul de stări furnizate, iar x(j),j2f1;:::; mgconstituie stările de
44

3.3. Depăs ,irea Uitării Catastrofale în Ret ,elele Neuronale
intrare. Aceste matrici Fisher nu trebuie calculate decât la schimbarea sarcinii, penali-
zarea EWC utilizând în continuare aceleas ,i matrici Fisher pe durata antrenării, până la
reschimbarea sarcinii.
3.3.1 Rezultate s ,i Experimente
În cadrul problemei jocurilor pentru consola Atari 2600, autorii aleg ca experiment
câte 10 jocuri aleatoare diferite dintre cele pe care algoritmul de "Deep Q-Learning" dă
dovadă de o performant ,ă mai mare sau egală cu cea umană. Antrenarea alternează între
cele 10 jocuri în ordine aleatoare, reîntorcându-se de mai multe ori asupra aceluias ,i joc.
Conformdescrieriianterioare,estefolosităoaceeas ,isingurăret ,eaneuronalăpentrutoate
jocurile. Diferent ,ele fat ,ă de modelul obis ,nuit sunt următoarele:
1. Ret ,eaua are mai mult ,i parametri ca modelul DQN descris anterior
2. Fiecarestratareelementede"bias"s ,i"gain"distinctepentruﬁecaresarcinăînparte;
elementulde"gain"areaceeas ,idimensiunecacelde"bias"s ,iseînmult ,es,teelement
cu element cu rezultatul stratului de care apart ,ine, înainte de aplicarea funct ,iei de
activare.
3. Se folosesc toate act ,iunile posibile ale emulatorului ca spat ,iu al act ,iunilor posibile
A, în loc de strictul necesar pentru ﬁecare joc în parte. Acest lucru este necesare
pentru deﬁnirea ultimului strat al ret ,elei, al cărui număr de noduri depinde de
numărul de act ,iuni posibile. Pentru a putea antrena modelul pe oricare dintre
jocurile Atari, este nevoie ca ret ,eaua să ﬁe modelată astfel încât să permită acest
lucru.
4. Sefoloses ,teunmodulseparatderecunoas ,tereasarcinii/joculuipecareseantrenează
ret,eaua la ﬁecare moment de timp (pentru a evita speciﬁcarea sa din exteriorul
modelului în cadrul ﬁecărui joc).
5. Se foloses ,te penalizarea de consolidare a ponderilor elastice (3.6).
Pentru a aplica penalizarea de consolidare a ponderilor elastice, autorii calculează
matricileFishernecesarelaﬁecaretreceredelaosarcinălaalta,darnumaipentrujocurile
pe care modelul s-a antrenat deja timp de cel put ,in20000000 iterat,ii. De asemenea,
ﬁecăruijocînparteîiestepermisăomemorieauxiliarăparticulară,pentruacomplementa
45

Capitolul 3. Metode recente pentru problema aleasă
"memoria" pe termen lung furnizată de consolidarea ponderilor elastice. În mare parte,
autoriiutilizeazăaceias ,ihiperparametricaîncazulalgoritmuluioriginal,pentruunsingur
joc, mai put ,in mărimea memoriei auxiliare, pe care o reduc la 500000de la 1000000, s,i
adăugând=400. Autorii nu ment ,ionează exact numărul de iterat ,ii de antrenare pentru
ﬁecare experiment sau rezultate individuale de testare pentru toate jocurile, însă expun
următoarele rezultate în funct ,ie de timp:
Rezultatele obt ,inute de către autori pe o varietate de jocuri Atari
46

Capitolul 4
Algoritm s ,i Rezultate
4.1 Algoritmul Propus
Algoritmul pe care îl propun în această lucrare pentru problema agent ,ilor inteligent ,i
pentru jocuri pe calculator antrenat ,i pe baza imaginilor, folosind învăt ,are ranforsată, este
cel propus în lucrarea anterioară "Human-level Control Through Deep Reinforcement
Learning" (3.2.1), atât în cazurile jocurilor cu un singur participant (jocurile pentru
consola Atari), cât s ,i în cazul sarcinii mai diﬁcile a jocurilor cu mai mult ,i participant ,i,
cu diferent ,e minore precizate în mod explicit în continuare. Pentru învăt ,area a mai
multor jocuri utilizând un acelas ,i model, am utilizat în plus penalizarea de consolidare a
ponderilorelastices ,iamalteratarhitecturaret ,eleis,iadăugatelementede"bias"s ,i"gain"
opt,ionalepeﬁecarestrat,pentruﬁecaresarcină(joc),iarpentruînvăt ,areasarcinilorcumai
mult,ijucători,amimplementatpersonalunnumărrestrânsdejocuricuunspat ,iualstărilor
asemănător cu cel al jocurilor Atari, dar care se diferent ,iază de acestea prin posibilitatea
participăriilajocamaimultorjucători,simultan. Detaliilegatedeimplementareapropriu-
zisăaprogramelors ,iexempledecodaminclusîncapitolulurmător,destinattehnologiilor
folosite (5).
Maiîntâi,înloculutilizăriipătratuluidiferent ,eidintreceledouăvalori(dintrevalorile
funct,iei de valoare-act ,iune optime aproximate utilizând modelul t ,intă s ,i cele calculate
utilizând modelul actual) ca funct ,ie de cost, am optat pentru o funct ,ie care să permită
utilizareaunorrăsplăt ,ivariatefărăaproduceinstabilitate. Maiexact,amutilizatcafunct ,ie
47

Capitolul 4. Algoritm s ,i Rezultate
de cost a modelului, funct ,ia de cost Huber, sugerată de Szymon Sidor s ,i John Schulman
de la OpenAI în articolul corelat cu lucrarea respectivă [9]:
L(y;t)=8>>><>>>:1
2(yt)2, pentrujytj
jytj1
22, altfel(4.1)
unde yreprezintă valorile calculate de ret ,ea, iar tvalorile "t ,intă" sau obiectiv. În imple-
mentareaalgoritmuluipropus,amalesvaloarea 1pentru,astfelcăfunct ,iadecostﬁnală
utilizată este următoarea:
L1(y;t)=8>>><>>>:1
2(yt)2, pentrujytj1
jytj1
2, altfel(4.2)
Un lucru imediat evident este că această funct ,ie de cost este aproape identică cu funct ,ia
init,ialăutilizatădecătreautoripentruvalorimicialdiferent ,eidintreceledouăvalori,însă
ia valori semniﬁcativ mai ridicate pentru diferent ,e mai mari.
În cazul jocurilor implementate personal de doi jucători, am realizat s ,i experimente
utilizândalgoritmideterminis ,tisaupseudo-determinis ,tidedeciziepentrucâteunjucător
odată, pentru a observa ce efect are un astfel de sistem de decizie asupra procesului de
învăt,are al modelului.
Arhitecturaret ,eleiutilizatepentruexperimentelecuunsingurjocesteurmătoarea(în
ordinea succesivă a straturilor):
1. Stratul de intrare al ret ,elei, a cărui dimensiune depinde de dimensiunile stărilor de
intrare (variază în funct ,ie de experiment).
2. Primulstratpropriu-zisalret ,elei,unstratconvolut ,ionalde 32deﬁltrededimensiune
88, cu un pas al convolut ,iei de 44pe orizontală, respectiv verticală, care
utilizează unitatea liniară rectiﬁcată (2.33) (în continuare, funct ,ia ReLU) drept
funct,ie de activare al ies ,irilor stratului.
3. Unaldoileastratconvolut ,ional,dedataaceastade 64deﬁltrededimensiune 44
cu un pas de 22. Funct ,ia de activare este tot funct ,ia ReLU.
4. Un al treilea strat convolut ,ional, de 64de ﬁltre de dimensiune 33cu un pas de
48

4.1. Algoritmul Propus
11, s,i care utilizează aceeas ,i funct ,ie ReLU pentru activare.
5. Un strat de redimensionare al datelor ret ,elei din formă matriceală tridimensională
într-oformăvectorialăuni-dimensională,carenuprelucreazădateleînniciunfels ,i
care nu are funct ,ie de activare (activare prin identitate).
6. Un strat obis ,nuit de 512unităt ,i, care calculează produsul intrărilor cu matricea de
ponderi, adaugă elementul de "bias" s ,i activează rezultatul utilizând funct ,ia ReLU.
7. Stratul ﬁnal al ret ,elii, al cărui număr de unităt ,i este egal cu numărul de clase
furnizate, care variază de la experiment la experiment (în funct ,ie de experiment,
toate act ,iunile permise în emulatorul Atari sau o mult ,ime restrânsă a acestora
sau o mult ,ime speciﬁcă jocurilor implementate în cazul jocurilor cu mai mult ,i
participant ,i). Stratul ﬁnal al ret ,elei nu are funct ,ie de activare.
Ret,eaua este folosită, astfel, împreună cu algoritmul descris, utilizând funct ,ia Huber
ment,ionată anterior drept funct ,ie de cost în vederea optimizării pe baza gradientului. Ea
este implementată cu ajutorul librăriei externe Tensorﬂow, prezentată ulterior în detaliu
cadrul capitolului de tehnologii folosite (5.3).
Pentru experimentele cu jocuri multiple, arhitectura este foarte asemănătoare cu cea
anterioară, diferent ,iindu-se doar prin următoarele:
4. În loc de 64de ﬁltre de dimensiune 33, cel de-al treilea strat dispune de 128de
ﬁltre de aceeas ,i dimensiune.
6. În loc de 512unităt ,i, penultimul strat al ret ,elei are acum 1024de unităt ,i.
7. Stratulﬁnalareunnumărconstantde 18unităt ,i(numărultotaldeact ,iuniposibileîn
emulatorul Atari), indiferent de experiment, pentru a putea cuprinde toate spat ,iile
act,iunilor posibile ale jocurilor Atari.
În plus, în acest caz, ﬁecare strat (în afară de cel de redimensionare a datelor) are câte un
elementde"bias"s ,iunulde"gain"pentruﬁecaresarcinăînparte. Ampresupusnumărul
sarcinilor constant s ,i s,tiut dinainte.
49

Capitolul 4. Algoritm s ,i Rezultate
4.2 Jocuri Propuse
4.2.1 Atari
Pentru experimentele realizate pe jocuri ale consolei Atari 2600 (3.1), am ales o
mult,imerestrânsădejocuridestuldediferitecâtsaexempliﬁcecapacitateadegeneralizare
a algoritmului propus.
4.2.1.1 Breakout
"Breakout" este un joc produs în 1976 pentru consola Atari 2600, în care jucătorul
controleazăopaletăorizontalăaﬂatălabazaecranuluidejocpecaretrebuiesăomanevreze
strict pe orizontală astfel încât să nu lase bila, elementul principal al jocului, să treacă de
baza ecranului de joc. În plus, în partea superioară a ecranului se aﬂă mai multe rânduri
de "cărămizi", obiecte ale jocului care sunt "sparte" prin ciocnirea bilei de ele, fapt care
aduce de la sine puncte în plus la scorul jucătorului, în funct ,ie de distant ,a rândului pe
care se aﬂa cărămida fat ,ă de jucător. Bila ricos ,ează perfect fără fort ,ă de frecare în urma
coliziuniicuﬁecaresuprafat ,ădejoc,ﬁeeaunperetealecranuluidejoc,paletajucătorului
sau o cărămidă, ba chiar capătă o viteză mai mare în urma ricos ,ării din cărămizile aﬂate
pe rândurile superioare (mai diﬁcil de atins). Condit ,ia de victorie constă în spargerea
tuturor cărămizilor, de două ori (în urma spargerii tuturor cărămizilor de pe ecran, jocul
repopulează ecranul cu cărămizi), având mai multe încercări la dispozit ,ie pentru a reus ,i
acest lucru, astfel că ﬁecare încercare se încheie atunci când bila trece de paletă fără
a ﬁ atinsă de aceasta, următoarea încercare repozit ,ionând paleta s ,i păstrând cărămizile
rămase pe ecran. De ﬁecare dată când bila trece de baza ecranului de joc, când jucătorul
sparge toate cărămizile pentru prima dată, precum s ,i când începe jocul, jucătorul trebuie
să lanseze explicit bila pentru a o pune în mis ,care.
4.2.1.2 Pong
"Pong" pentru Atari 2600 este o variantă eponimă a unuia dintre primele s ,i cele
mai recognoscibile jocuri digitale apărute. El este un joc competitiv care necesită doi
participant ,i, ﬁecare dintre aces ,tia controlând o paletă, de data aceasta strict pe direct ,ii
verticale, pe care trebuie să o manevreze pentru a respinge bila, elementul principal al
50

4.2. Jocuri Propuse
Exemple de imagini din jocul "Breakout"; se observă în partea de sus a ecranului scorul, numărul de încercări rămase s ,i numărul de ecrane "curăt ,ate", respectiv
jocului, s ,i pentru a evita pătrunderea acesteia în peretele respectiv părt ,ii lor de ecran.
Atunci când bila trece de peretele stâng, respectiv cel drept, al ecranului, jucătorul din
dreapta, respectiv cel din stânga, primes ,te un punct la scor. Condit ,ia de victorie este
obt,inerea a 21de puncte înaintea oponentului. Bila ricos ,ează atât din palete, cât s ,i din
peretele superior s ,i din cel inferior, fără fort ,ă de frecare, însă capătă o viteză mai ridicată
atunci când ricos ,ează din palete aﬂate în deplasare în aceeas ,i direct ,ie (pe ordonată) cu
ea. Fiecare punct câs ,tigat de un jucător duce la repozit ,ionarea paletelor la mijlocul
axei s ,i la reinit ,ierea jocului (realizată prin lansarea bilei de către jucătorul uman). În
cazulvarianteiutilizateînemulator,jucătoruldinstângaesteîntotdeaunacelcontrolatde
calculator (emulator), iar cel din dreapta este întotdeauna cel aﬂat sub control "uman".
Exemple de imagini din jocul "Pong"
4.2.1.3 Space Invaders
"Space Invaders" este un joc clasic lansat pe platforma Atari 2600 în 1978, în care
jucătorulcontroleazăonavăspat ,ială,manevrabilăstrictpeoaxăorizontalăaﬂatălabaza
ecranului de joc, al cărui scop este să elimine navele oponente din partea superioară
a ecranului de joc, organizate pe rânduri s ,i coloane, care se apropie, treptat, de baza
51

Capitolul 4. Algoritm s ,i Rezultate
ecranului, de sus în jos s ,i de la stânga la dreapta. Jucătorul are la dispozit ,ie, pe lângă
capacitatea de a se deplasa în stânga s ,i în dreapta, abilitatea de lansa proiectile înspre
oponent ,iicontrolat ,idecalculatorpentruaîielimina,obt ,inândastfelpuncteînfunct ,iedecât
dedeparteseaﬂauaces ,tiadejucătorullamomentuleliminării. Oponent ,iiauladispozit ,ie
s,i ei aceeas ,i abilitate, astfel că ﬁecare proiectil care loves ,te nava jucătorului conduce la
scăderea numărului disponibil de încercări; pierderea jocului constă în epuizarea tuturor
acestor încercărilor, sau în es ,ecul de a elimina navele oponente până ce acestea ajung la
baza ecranului de joc. Condit ,ia de victorie constă în eliminarea tuturor oponent ,ilor, de
două ori. În plus, jucătorul mai dispune de trei obiecte de protect ,ie, depărtate unul de
celălalt s ,i aﬂate imediat deasupra sa, pe care atât proiectilele jucătorului, cât s ,i cele ale
oponent ,ilor,ledegradeazălaimpact. Undetaliualjoculuiestenavacareapareocazional
imediatsubperetelesuperioralecranuluidejoc,caresedeplaseazărapiddeladreaptala
stângas ,icare,încazulîncareestelovităcuunproiectildecătrejucător,îiaduceacestuia
un număr mare de puncte.
Exemple de imagini din jocul "Space Invaders"; se observă nava specială din partea superioară a ecranului în imaginea din mijloc s ,i obiectele protectoare de deasupra navei
jucătorului
4.2.1.4 Fishing Derby
"Fishing Derby", lansat pe piat ,ă în 1980, este un joc competitiv de doi participant ,i
pentruconsolaAtari2600,încareparticipant ,ii,reprezentat ,idedoipescari,potscufunda,
ridica s ,i mis,ca înspre stânga sau înspre dreapta undit ,a pentru a prinde pes ,ti, aﬂat ,i la
diverse nivele de adâncime, s ,i valorând puncte direct proport ,ional cu adâncimea la care
se aﬂă, s ,i pentru a îi aduce la suprafat ,ă. Imediat sub nivelul suprafet ,ei apei se aﬂă un
rechin, care se deplasează pe o axă ﬁxă orizontală s ,i încearcă sa consume pes ,tii prins ,i de
către jucători înainte ca aces ,tia să îi aducă la suprafat ,ă, prezentând astfel un risc în ceea
52

4.2. Jocuri Propuse
ceprives ,teprinsulpes ,tiloraﬂat ,ilamaimareadâncime. Condit ,iadevictoriepentruambii
jucătoriesteatingereascoruluide 99depuncte,încondit ,iileîncarepes ,tiidepeprimele2
niveledeadâncimevaloreazăcâte 2puncte,ceidepeurmătoarele 2nivelevaloreazăcâte
4puncte,iarceidepeultimele2niveledeadâncimevaloreazăcâte 6puncte. Înemulator,
jucătorul din dreapta este controlat întotdeauna de către emulator.
Exemple de imagini din jocul "Fishing Derby"; scorul se aﬁs ,ează, convent ,ional, în partea superioară a ecranului de joc
4.2.1.5 Boxing
"Boxing"esteunjocoriginalAtari,produsînanul1980,încaredoijucători,aﬂându-
se ﬁecare în controlul câte unui luptător de Box, pot alege să se deplaseze în interiorul
unui ring s ,i să se lovească reciproc, obt ,inând puncte în funct ,ie de tipul loviturii atunci
cândaceastaîlloves ,tepeoponentînfat ,ă: lovituramaiputernică,darmaiscurtă,îiaduce
agresorului 2puncte, în timp ce lovitura mai sigură, dar mai slabă, îi aduce doar 1punct.
Primul jucător care obt ,ine scorul de 100de puncte este victorios. În emulator, jucătorul
din dreapta (cel negru) este controlat întotdeauna de către emulator.
Exemple de imagini din jocul "Boxing"
53

Capitolul 4. Algoritm s ,i Rezultate
4.2.2 Jocuri Implementate Personal
În vederea aplicării metodelor propuse, am implementat personal s ,i câteva jocuri
asemănătoaredinpunctdevederealcomplexităt ,iiregulilordejocs ,ialspat ,iuluiimaginilor
cu cele din gama jocurilor pentru consola Atari 2600, dar care să permită participarea
simultană,fărăconstrângeri,acâtedoijucători,umanisauartiﬁciali. Jocurileseaseamănă
prin faptul că sunt toate jocuri competitive "de sumă zero": jocuri în care toată utilitatea
câs,tigată,respectivpierdută,deunjucătoresteechilibratădeoaceeas ,icantitatedeutilitate
pierdută, respectiv câs ,tigată, de către oponent (astfel că suma utilităt ,ilor jucătorilor la
ﬁecare moment de timp este întotdeauna zero). În acest context, utilitatea reprezintă
o not ,iune generală a calităt ,ii performant ,ei jucătorului, exempliﬁcată cel mai us ,or, în
jocurile digitale, prin intermediul scorului (des ,i utilitatea nu este neapărat concretizată
printr-un scor numeric în cadrul jocurilor). Ele au în comun faptul că, în esent ,ă, condit ,ia
de victorie depinde întotdeauna de atingerea unui scop (de exemplu, un scor speciﬁc)
înaintea oponentului.
4.2.2.1 Pong
În primul rând, am reimplementat jocul "Pong", descris anterior în cadrul suitei de
jocuri pentru consola Atari (4.2.1.2), pentru a putea antrena, simultan două modele ale
algoritmului (unul pentru ﬁecare jucător), s ,i pentru a putea experimenta prin a juca
împotriva modelului antrenat. Jocul a fost conceput pentru rezolut ,ia de 800800, însă
obiectelejoculuis ,ivitezelesuntscalateastfelîncâtoricerezolut ,iepătratăcompusădintr-
undivizorsaumultiplunaturalallui 800,pânălaminimulde 400,atâtpelungimecâts ,ipe
lăt,ime,săfunct ,ionezeechivalent(acestlucruestenecesardatorităimplementăriijocurilor
în funct ,ie de cadre, ci nu de timp). Spat ,iul act ,iunilor jocului este limitat la deplasarea în
sus sau în jos pe axa Oy. O diferent ,ă pe care o prezintă această implementare a jocului
"Pong" fat ,ă de celelalte este inert ,ia de care dispun paletele jucătorilor, care, des ,i vizual
neglijabilă, oferă jocului un aspect mai corect s ,i mai plăcut. Inert ,ia contribuie activ la
viteza bilei, care, în plus, cres ,te inerent la ﬁecare moment de timp pentru a penaliza
jocurile prelungite. De asemenea, scorul necesar victoriei este 10(în loc de 21), s,i, spre
deosebire de varianta jocului de pe consola Atari, am implementat o generare init ,ială
54

4.2. Jocuri Propuse
aleatoare a vectorului de viteză al bilei, astfel că numărul de direct ,ii posibile în care se
poate lansa bila la începutul jocului este mult mai ridicat (s ,i direct ,iile sunt, deci, mai
variate); acest detaliu, la un loc cu non-determinismul oponentului (agent sau uman),
elimină posibilitatea învăt ,ării unei strategii abuzive (ca în cazul jocului Atari).
Exemple de imagini din jocul implementat personal "Pong"; scorul se aﬁs ,ează după ﬁecare rundă
Întrucâtobiectelejoculuisunttoatedreptunghiulare,detect ,iacoliziunilorsereducela
o veriﬁcare simplă a suprapunerii a două dreptunghiuri:
D1;D2suprapuse,(xD(1)
1xD(2)
2)^(xD(2)
1xD(1)
2)^(yD(1)
1yD(2)
2)^(yD(2)
1yD(1)
2)(4.3)
unde Didreptunghiuri având colt ,urile stângi superioare, respectiv drepte inferioare, în
punctele D(1)
i, respectiv D(2)
i,8i2f1;2g. Detect ,ia coliziunii dintre bilă s ,i peret ,ii din
stânga s ,i din dreapta ecranului de joc (care declans ,ează încheierea rundei respective) am
efectuat-oprinveriﬁcareasuprapuneriiculiniicorespunzătoarerespectivilorperet ,i,liniile
reprezentând, în esent ,ă, dreptunghiuri degenerate.
Pentru deplasare, ﬁecare unitate dispune de un vector de viteză v, compus dintr-o
componentă pe verticală s ,i o componentă pe orizontală, astfel că pozit ,ia(x;y)2N2la
ﬁecare moment de timp, la momentul actualizării uniforme (pentru toate unităt ,ile simul-
tan) a pozit ,iei obiectelor, se actualizează, în paralel cu act ,iunile utilizatorului, conform
formulei:
xt=xt1+xvt
yt=yt1+yvt(4.4)
Jucătorul are, în schimb, control asupra vitezei, astfel că act ,iunile jucătorului (ﬁe primite
de la tastatură, ﬁe generate conform modelului) inﬂuent ,ează în mod direct viteza: atunci
55

Capitolul 4. Algoritm s ,i Rezultate
când se act ,ionează deplasarea în sus, din componenta pe verticală a vitezei se scade o
valoareconstantă(fort ,adedeplasaredebază). Analogpentruact ,ionareadeplasăriiînspre
bazaecranuluidejoc: lacomponentapeverticalăavectoruluidevitezăseadaugăaceeas ,i
constantă pre-deﬁnită. În cazul bilei, viteza este actualizată la ciocnirea cu o platformă
(ﬁe o paletă a vreunui jucător, ﬁe un perete) conform următoarei formule, unde vs,iv0
reprezintăvitezabilei,respectivceaapaleteidecareaceastaseciocnes ,te(acoloundeeste
cazul):
(xvt;yvt)=8>>><>>>:(xvt1;yvt1) , dacă bila se loves ,te de peret ,ii solizi
(xvt1;yvt1+yv0
t1), dacă bila se loves ,te de o paletă(4.5)
Înacestcontext,peret ,iisolizisuntceidincarebilapoatericos ,a,anumecelsuperiors ,icel
inferior. Vitezele paletelor decelerează automat la ﬁecare moment de timp, pierzând un
procentaj mic din viteză în ambele componente (respectiv), astfel simulându-se inert ,ia,
iar bila accelerează automat la ﬁecare moment de timp, crescându-s ,i viteza cu procentaj
mic din viteză în ambele componente (respectiv).
4.2.2.2 Snakes
"Snakes" este un al doilea joc implementat cu scopul experimentării asupra jocurilor
cu multipli participant ,i, inspirat din jocul clasic "Snake" de un singur jucător, în care
jucătorul trebuie să manevreze un s ,arpe pe o tablă de joc bidimensională, în cele patru
direct ,ii (sus, jos, dreapta s ,i stânga), astfel încât să consume un număr cât mai mare de
obiecte de tip "hrană". Hrana apare aleatoriu pe ecran pe pozit ,ii pe care nu se aﬂă vreo
parteas ,arpeluilamomentulaparit ,iei,iarindiferentdelungimeas ,arpelui,manevrarealui
constă doar în schimbarea direct ,iei capului (restul corpului urmărind pozit ,iile trecute ale
capuluipetablă). Joculseîncheieînmomentulîncares ,arpeleseciocnes ,tedeelînsus ,i,s,i,
înfunct ,iedetipuldeimplementareajocului,s ,iatuncicânds ,arpeleseciocnes ,tedeunperete
(înalteimplementări,încazulîncares ,arpeleatingeunperete,elcontinuăsăsedeplaseze
pe aceeas ,i axă, dar din partea opusă a ecranului de joc). Cu ﬁecare hrană consumată,
s,arpele cres ,te în lungime, astfel că des ,i simplu la început, jocul devine cu atât mai diﬁcil
cu cât jucătorul obt ,ine un scor mai mare. Complexitatea jocului este dată de strategiile
56

4.2. Jocuri Propuse
pe care jucătorul trebuie să le urmeze în stadiile avansate ale unei încercări: manevrarea
s,arpelui de as ,a natură încât să nu apară situat ,ii viitoare în care încheierea jocului să ﬁe
garantată (cel mai adesea, aceste situat ,ii apar datorită "încolăcirii" s ,arpelui în spirală,
înspreinterior). Diferent ,adintreimplementareaclasicăajoculuiconstăînexistent ,aadoi
s,erpi, s ,i a câte două surse de hrană simultane, în locul uneia singure. Coliziunea unui
s,arpe de un altul va conduce la aceleas ,i efecte ca s ,i coliziunea de el însus ,i (încheierea
jocului pentru participantul respectiv), iar coliziunea cap în cap a celor doi conducând la
încheierea jocului pentru ambii participant ,i. Am implementat mai multe variante, toate
constândlabazăînacelas ,ijoc,daravândcâteotrăsăturăunică. Deasemenea,joculafost
conceput pentru aceleas ,i rezolut ,ii ca s ,i cel anterior (4.2.2.1), spat ,iul act ,iunilor adăugând
deplasarealastângasauladreaptapeaxa Oxs,idiferent ,iindu-seprindeplasareacontinuă
în lipsa vreunei decizii a jucătorului (fat ,ă de jocul "Pong", unde act ,iunile jucătorului
reprezintă mai degrabă fort ,e imediate exterioare obiectului).
Exemple de imagini din jocul implementat personal "Snakes"; în cea de-a treia imagine, s ,arpele galben este ciocnit, dar continuă să ocupe spat ,iu pe terenul de joc
În prima implementare, cea de joc cooperativ, am ales să implementez, contrar celor
ment,ionate anterior, un scor comun celor doi jucători, astfel că hrana consumată de către
oricare dintre s ,erpi să aducă un plus de utilitate amândurora. Astfel, nu există o condit ,ie
de victorie propriu-zisă, s ,i jocul urmează principiul jocului "Snake" de a obt ,ine doar un
scor cât mai mare. În cea de-a doua implementare, am ales să separ scorurile, pentru a
redaunscopcompetitivparticipant ,ilor. Condit ,iadevictorieconstăînobt ,inereaunuiscor
mai mare ca al oponentului la încheierea jocului (după ce ambii s ,erpi s-au ciocnit de ei
îns,is,i sau de peret ,ii ecranului de joc). Atât în prima implementare, cât s ,i într-a doua, am
ales ca "moartea" unuia dintre s ,erpi să nu conducă numai la încheierea posibilităt ,ii de a
57

Capitolul 4. Algoritm s ,i Rezultate
lua decizii a jucătorului lui, cât s ,i la păstrarea s ,arpelui, în starea în care se aﬂa înainte de
aseciocni,peecranuldejoc. Astfel,des ,ipenalizatpentrugres ,eală,jucătorulies ,itdinjoc
continuă să îngreuneze jocul pentru aliatul, respectiv adversarul său.
Independentdeimplementareaaleasăîncadrulexperimentelor,amalessăfacopt ,ională
ciocnirea jucătorilor de peret ,ii ecranului de joc, astfel că am implementat ambele vari-
ante ale acestei reguli, întrucât am considerat semniﬁcativ efectul său asupra jocului s ,i
relevant în cadrul învăt ,ării unei strategii de joc. Efectul imediat al eliminării regulii este
posibilitateajocurilorinﬁnite: s ,erpiipot,câttimpsuntîncălaînceputuljoculuis ,inusunt
destul de lungi cât sa ocupe întreaga lungime sau întreaga lăt ,ime a ecranului, să aleagă
să se deplaseze nesfârs ,it pe aceeas ,i axă, într-una sens pe una din cele patru direct ,ii. Atât
în cazul variantelor de joc care veriﬁcau coliziunea jucătorilor cu marginile ecranului de
joc, cât s ,i în cazul celor în care această veriﬁcare era eliminată, am ales să implementez
s,erpii,maieﬁcient,subformădecolect ,iidesegmentedelungimevariată,perpendiculare
douăcâtedouă,ﬁecaresegmentﬁindformatdincâtedouăpunctes ,iogrosime: începutul
segmentului s ,i capătul acestuia. Această implementare evită păstrarea tuturor punctelor
care compun s ,arpele, ajută în mod particular la desenarea acestuia pe ecran (care se face
cu ajutorul desenării dreptunghiurilor), s ,i, des ,i aparent cont ,inând informat ,ii redundante,
datorită duplicării capetelor de segmente (pentru majoritatea segmentelor s ,arpelui, cel
de-al doilea punct al segmentului curent din s ,irul de segmente este acelas ,i cu primul
punct al segmentului următor), acest lucru este necesar în vederea ciclării marginilor
ecranului: pentruafaces ,arpelesă aparăînmargineaopusă celeicurente,peaceeas ,iaxă,
atunci când acesta penetrează o margine, este nevoie de păstrarea de astfel de segmente
pentru a semnala începutul primului segment de după aparit ,ia în pozit ,ia nouă (marginea
opusă) s ,i încheierea ultimului segment de dinainte de coliziunea cu marginea (ﬁecare
astfel de coliziune produce, precum s ,i ﬁecare schimbare normală de direct ,ie, conduce
la adăugarea unui nou segment în s ,irul de segmente componente ale s ,arpelui). Pentru
deplasareapropriu-zisăas ,arpelui,nuestenevoiedecâtdemodiﬁcareacoordonatelorcelui
de-aldoileapunctalultimuluisegmentals ,arpelui("coada")îndirect ,iaprimuluipunctal
58

4.2. Jocuri Propuse
aceluias ,i segment:
x(n;2)
t=x(n;2)
t1+sgn(x(n;1)
t1x(n;2)
t1)
y(n;2)
t=y(n;2)
t1+sgn(y(n;1)
t1y(n;2)
t1)(4.6)
unde x(n;i)
ts,iy(n;i)
treprezintă componenta pe orizontală, respectiv pe verticală a punctului
i2f1;2gal ultimului segment, reprezintă valoarea constantă a distant ,ei de deplasare la
ﬁecare moment de timp, iar sgnreprezintă funct ,ia semn:
sgn(x)=8>>>>>><>>>>>>:1,x>0
0,x=0
1,x<0;8x2R (4.7)
Se observă faptul că segmentele sunt întotdeauna paralele cu una dintre cele două axe,
astfel că la ﬁecare moment de timp, nu se actualizează decât una dintre componente.
Pentru "prelungirea" s ,arpelui odată cu consumarea hranei, este deajuns ignorarea acestei
regulidedeplasarelamomentulrespectivdetimp,darnus ,ialdeplasăriiseparateacapului,
creândastfeloîntârziereîntreceledouă,echivalentăcuoprelungireaultimuluisegment.
În vederea incrementării ultimului segment până la degenerarea acestuia într-un singur
punct, am veriﬁcat acest caz s ,i am eliminat ultimul segment la momentele respective de
timp, desemnând, astfel, penultimul segment din s ,arpe ca ﬁind noua coadă a acestuia.
4.2.2.3 Spaceships
Unaltjocimplementatpersonalpentruagorimtulpropusestejocul"Spaceships",rea-
lizatdedataaceastapentrudouărezolut ,iiﬁxe( 600400,respectiv 300200)s,iutilizândo
mult,imedeimaginis ,ianimat ,iiexterne[10]publicatedecătreLuisZunosubpseudonimul
"ansimuz" [11], sub licent ,a "Creative Commons Attribution 4.0 International" [12], care
permitedistribuirea,utilizareas ,imodiﬁcareaacestorachiars ,iînscopcomercial,atâttimp
cât respectivele resurse sunt atribuite autorului lor s ,i se ment ,ionează toate modiﬁcările
efectuate. Fiecare jucător controlează câte o navă spat ,ială, care poate accelera s ,i care
se poate roti, facilitând, astfel, deplasarea (cu inert ,ie) în spat ,iu. Ambele nave pot lansa
proiectile în linie dreaptă, s ,i ambele dispun de o resursă ﬁnită de viat ,ă din care se scade
de oricâte ori are loc o coliziune cu un proiectil inamic. Scopul jocului pentru ﬁecare
59

Capitolul 4. Algoritm s ,i Rezultate
dintre jucători constă în eliminarea oponentului (reducerea în totalitate a resurselor de
viat,ă ale navei oponente). În plus, jocul mai impune o limită de timp, astfel că după un
număr ﬁx de secunde, ambii jucători încep să piardă din resursele de viat ,ă câte un pic
la ﬁecare moment de tip (condit ,ie care asigură ﬁnitudinea episoadelor jocului). Navele
jucătorilor utilizează aceeas ,i imagine s ,i aceleas ,i animat ,ii, diferent ,a constând în culoarea
navei: unadintreeleesteros ,ie(ceaoriginală,preluatădinsurselement ,ionateanterior),iar
cealaltăesteovariantămodiﬁcatăpersonalaprimea,deculoareverde. Restulimaginilor
s,i animat ,ilor nu au fost modiﬁcate (proiectilele, exploziile etc.).
Exemple de imagini din jocul implementat personal "Spaceships"; barele verzi din partea superioară a ecranului reprezintă resursele de viat ,ă rămase
Deplasareaîn"Spaceships"urmeazăunprincipiuasemănătorcuceldincazuljocului
"Pong": navele dispun atât de o pozit ,ie (centrul lor, pentru a ﬁ invariant la rotat ,ii), de un
unghi de rotat ,ie, s,i de un vector de viteză. La ﬁecare moment de timp, pozit ,ia navelor
este actualizată conform (4.4), viteza se reduce automat la ﬁecare moment de timp, iar
accelerarea presupune aplicarea unei fort ,e în direct ,ia curentă de mers asupra obiectului:
xvt=xvt1+cos()
yvt=yvt1sin()(4.8)
undeeste constantă s ,i pre-deﬁnită, iar reprezintă unghiul curent de rotat ,ie. Am
implementatrotat ,iacaneavândunefectasupradeplasăriinavelor(nuseactualizeazănici
vectoruldeviteză,nicipozit ,iacentruluiobiectuluiatuncicândacestaserotes ,te,cidoarse
actualizează valoarea unghiului său de rotat ,ie). Unghiul de rotat ,ie este utilizat nu numai
în cazul deplasării, cât s ,i la desenare: imaginile obiectelor sunt rotite conform acestuia
pentru a reprezenta corect starea jocului (inclusiv proiectilele s ,i efectele speciale).
Pentru coliziuni, am fost nevoit să folosesc poligoane, rotindu-le, astfel, în funct ,ie
60

4.3. Rezultate s ,i Experimente
de unghiul de rotat ,ie al obiectului la ﬁecare moment de detect ,ie de coliziuni. Pentru
implementarea poligoanelor, cât s ,i pentru translat ,ia, rotat ,ia s,i detect ,ia intersect ,iei dintre
poligoane, am utilizat o librărie externă (5.6). Coliziunea cu o margine de ecran nu are
niciunefect,însămarginilenusuntpenetrabile,iarcoliziuneadintrenavenusedetectează
s,i nu are niciun efect asupra jocului.
În plus, pentru a facilita mai multe experimente, am mai implementat o variantă
simpliﬁcată a jocului "Spaceships", în care deplasarea navelor este blocată pe o câte axă
orizontală(înmargineasuperioară,respectivceainferioarăajocului),navelenusepotroti
s,ifundaluldejocestecompletnegru. Înacestformat,navelesedeplaseazămaiîncetatât
timp cât lansează proiectile s ,i pierd surse de hrană proport ,ional cu o fract ,iune a distant ,ei
dintre ele la ﬁecare moment de timp.
Exemple de imagini din varianta simpliﬁcată a jocului implementat personal "Spaceships"
4.3 Rezultate s ,i Experimente
Amexperimentatpejocurile"Breakout"(4.2.1.1),"Pong"(4.2.1.2),"SpaceInvaders"
(4.2.1.3)s ,iasuprajocurilorimplementatepersonalment ,ionateanterior("Pong"(4.2.2.1),
"Snakes"(4.2.2.2)înmultiplelesalevariante,s ,i"Spaceships"(4.2.2.3)învariantasasim-
pliﬁcată)pentruimplementareadebazăaalgoritmului,iarpentruconsolidareaponderilor
elastice, am antrenat un agent simultan pe jocurile "Fishing Derby" (4.2.1.4) s ,i "Boxing"
(4.2.1.5).
Indiferentdeexperimentulales,unaspectimportantalalgoritmuluipropus,încontex-
tul capabilităt ,ilor componentelor hardware din prezent, este dezavantajul creat de timpul
ridicatdeantrenare,carefacenefezabilăantrenareaîntimpreal. Utilizândoplacăgraﬁcă
care dispune de 768nuclee CUDA [13], o frecvent ,ă de procesare de bază de 1290 MHz,
61

Capitolul 4. Algoritm s ,i Rezultate
4GBde memorie virtuală de tip GDDR 5 128 bits,i o lăt ,ime de bandă de 112GB=s,
un procesor cu 6nuclee ﬁzice s ,i12nuclee virtuale, având o frecvent ,ă de aproximativ
3:9GHz,s,iomemorievolatilădecapacitatede 16GBtipDDR 4,laofrecvent ,ăcompusă
de2933MHz, timpul mediu de antrenare pentru jocurile Atari, utilizând placa graﬁcă
pentruantrenareapropriu-zisăs ,iprocesorulpentrurestulprogramuluiînPython,afostîn
mediedeaproximativ 140deiterat ,iipesecundă,sauaproape 2orepentruﬁecare 1000000
de iterat ,ii. Costul antrenării a crescut s ,i mai mult în cazul consolidării ponderilor elas-
tice, numărul aproximativ mediu de iterat ,ii pe secundă scăzând la 60, scăzând la valori
asemănătoare s ,i în cazul jocurilor implementate personal. Memoria auxiliară, pentru a
acomoda capacitatea maximă de 1000000 de stări, chiar s ,i evitând duplicarea cadrelor, a
necesitat aproximativ 9GBde memorie volatilă.
4.3.1 Atari
ExperimentelepejocurileAtariauconstatînaplicareaalgoritmului,utilizândinterfat ,a
construităpesteemulatorpentruagestionastareainternăajocului. Amalesrecept ,ionarea
numai a ﬁecărui cel de-al patrulea cadru de joc, ignorând cadrele dintre acestea, mai
put,in atunci când emulatorul semnala întâlnirea sfârs ,itului jocului, caz în care se lua în
considerare s ,i ultimul cadru de joc, indiferent de pozit ,ia sa în s ,irul de imagini de până
atunci. Amutilizatpentruﬁecarejocspat ,iulminimspeciﬁcalact ,iunilor,pentruareduce
din timpul destinat antrenării. În cazul ﬁecăruia dintre cele 3 jocuri Atari, precum s ,i în
cazuljocurilorimplementatepersonal,modelulafostantrenattimpde 10000000 deiterat ,ii
(ci nu 50000000 , conform speciﬁcat ,iilor lucrării) utilizând următorii hiperparametrii:
•O rată de învăt ,are de 0:00025.
•init,ial egal cu 1:0s,i descrescător liniar ca funct ,ie de numărul de iterat ,ii până la
valoarea minimă de 0:1după 1000000de iterat ,ii.
•Un număr de 32de experient ,e sunt es ,antionate din memorie pentru ﬁecare pas de
antrenare.
•Pas,ii de antrenare au loc la ﬁecare a patra iterat ,ie.
62

4.3. Rezultate s ,i Experimente
•O capacitate maximă a memoriei auxiliare de 1000000 de iterat ,ii, s,i o capacitate
init,ială de 50000de experient ,e init ,iale cu care este populată memoria (prin joc
aleatoriu) înainte de începerea antrenării propriu-zise.
•Formareastărilorseobt ,inedinultimele 4cadreobservate,cadreleobservaterepre-
zentând ﬁecare al patrulea cadru real al jocului (mai put ,in în cazul jocului "Space
Invaders", unde a fost nevoie de ﬁecare al treilea cadru real al jocului datorită ratei
de desenare a proiectilelor).
•Cadrele jocului sunt preprocesate prin reducerea dimensiunii la 8484pixeli s ,i
prin eliminarea canalelor de culoare.
Pentru jocul "Breakout", relevantă este strategia avansată pe care o învat ,ă agentul de
apătrundeprintrerânduriledecărămiziprinspargereaamaimultorcărămizidinaceeas ,i
zonăs ,ideadirect ,iona,pecâtposibil,bilapringolulrespectivobt ,inut,pentruaodetermina
săricos ,ezedinmargineasuperioarăaecranuluidejoc,dinspateleceluimaidepărtatrând
depaletă,înapoiînultimulrânds ,iînapoidinnous ,itotas ,apânăcândsemaiproduceocale
printrecărămiziînapoilapaletă,obt ,inândastfelîntr-untimpfoartescurt,s ,ifărănevoiade
amaireact ,ionalaapropiereabilei(s ,ideariscapierderiiuneiîncercăridejoc),unnumăr
semniﬁcativ de puncte. În ciuda acestei reus ,ite, agentul rareori reus ,es,te să elimine toate
cărămizile de pe ecranul de joc (deci rareori trece la cea de-a doua încercare). Acest fapt
este datorat, în mare parte, numărului scăzut de iterat ,ii de antrenare ( 10000000 în loc de
50000000 ), s,i este un aspect care se îmbunătăt ,es,te strict cu timpul.
Răsplăt,ile totale la antrenare pentru "Breakout"
În cazul jocului "Pong", agentul învat ,ă s,i aplică, cu un suﬁcient de mic (0:001),
63

Capitolul 4. Algoritm s ,i Rezultate
o tactică abuzivă: jocul ﬁind determinat în întregime de către oponentul controlat de
emulators ,idecătredirect ,iaîncareseîndreaptăbilalaînceputulﬁecăruiepisod(stângasau
dreapta),agentulcoboarădeﬁecaredatăpaletaînparteainferioarăaecranului,dupăcare
sedeplaseazăînsusatuncicândseapropiebila,astfelîncâtsăolansezeînapoilaoponent
cu viteză maximă. Datorită implementării deterministe a oponentului, acesta se aﬂă
întotdeaunaînparteasuperioarăaecranuluis ,imultpreadepartepentruaputeareact ,iona
la timp, pierzând bila de ﬁecare dată. Cu except ,ia câtorva episoade, în majoritatea
episoadelor de testare se repetă aceeas ,i tactică, modelul câs ,tigând prin abuzarea unei
slăbiciuni în implementarea oponentului. Se observă în răsplăt ,ile de antrenare durata
comparativlungăaepisoadelor(înnumărdeiterat ,ii)fat ,ădealtejocuris ,ifaptulcăagentul
învat,ă o tactică care îi aduce în majoritatea timpului victoria:
Răsplăt,ile totale la antrenare pentru "Pong"; răsplata totală este diferent ,a dintre scorul agentului s ,i scorul oponentului
În cazul jocului "Space Invaders", agentul loves ,te ocazional vizibil intent ,ionat nava
careapare,rar,înparteasuperioarăaecranului,darnualegesăsepozit ,ionezeastfelîncât
să o lovească atunci când apare dacă nu se aﬂă deja în partea din stânga a ecranului de
joc. În rest, agentul elimină inamici cu succes s ,i se feres ,te de majoritatea proiectilelor,
ajungând de câteva ori chiar să curet ,e un ecran întreg.
Înﬁnal,înurmaantrenării,amefectuatcâte100deepisoadedetestecuﬁecaredintre
modele, o dată utilizând =0:05, iar a doua oară, utilizând =0:001(deci o dată luând
5%din decizii aleatoriu, iar a doua oară doar 0:1%). A fost nevoie de utilizarea unui
maimareca 0datorităcomportamentuluideterministrezultatînunelecazuri(deexemplu,
în cazul jocului "Breakout", atunci când agentul rămânea cu o singură încercare, alegea
să nu mai pornească jocul niciodată). Rezultatele sunt următoarele (se observă cres ,terea
64

4.3. Rezultate s ,i Experimente
Răsplăt,ile totale la antrenare pentru "Space Invaders"; numărul mare de rezultate asemănătoare se datorează determinismului inerent jocului s ,i naturii răsplăt ,ilor
mediilors ,ivariant ,amarearezultateloragentuluipentruun mairidicat,s ,ireducerea,dar
s,i stabilizarea acestora în experimentele în care mai put ,ine act ,iuni sunt luate aleatoriu):
Breakout Pong Space Invaders
=0:050 215:1108:757 14:0263:202 823:55345:092
=0:001 180:84979:826 19:9170:431*623:445126:181
Scor Uman Mediu Ref. [7] 31:8 9:3 1652:527
Valorile ment ,ionate după simbolul " " reprezintă deviat ,ii standard; *agentul a obt ,inut scorul de 21 la 1 în 93 din 100 de jocuri, datorită tacticii abuzive ment ,ionate
4.3.2 Consolidarea Ponderilor Elastice
Experimentele în cadrul aplicării algoritmului de consolidare a ponderilor elastice a
constat în antrenarea alternantă pe cele două jocuri, reducând treptat numărul de iterat ,ii
de antrenare pentru ﬁecare joc în parte. Des ,i, init ,ial, agentul efectua un număr egal de
iterat,iipeceledouăsarcini,ulterior,amalessăscadnumăruldeiterat ,iideantrenarepentru
jocul "Boxing", întrucât am observat empiric că acesta era mai us ,or de învăt ,at (agentul
convergealascoruriperfectestabileextraordinarderapiddupăschimbareasarcini)decât
jocul "Fishing Derby", în care algoritmul nu numai că nu reus ,ea să obt ,ină, stabil, o
diferent ,ă medie de scor fat ,ă de oponent mai mare de 25, dar s ,i convergea încet la această
valoare. Ca s ,i în cazul jocurilor anterioare, durata episoadelor în iterat ,ii de antrenare
variază de la episod la episod s ,i variază semniﬁcativ de la un joc la altul, astfel că axele
nu sunt sincronizate (des ,i cele două jocuri au fost antrenate, în total, pe aproximativ 45
de milioane de iterat ,ii). În ambele jocuri, răsplata este reprezentată de diferent ,a
dintre scorul agentului s ,i scorul oponentului. Se observă în cele două ﬁguri, (4.13) s ,i
65

Capitolul 4. Algoritm s ,i Rezultate
Răsplăt,ile individuale totale la antrenare pentru "Boxing"
Răsplăt,ile individuale totale la antrenare pentru "Fishing Derby"
(4.14),cuochiulliberepisoadelelacaresarcinaesteschimbată(episoadeleacărorrăsplată
totală este brusc semniﬁcativ mai mică decât a celor de dinainte). Starea algoritmului de
consolidare a ponderilor elastice, incluzând sarcina curentă, matricile Fisher ale ultimei
sarcini precum s ,i ponderile ret ,elei de dinainte de schimbarea sarciniii, a fost gestionată
explicit în program, ci nu determinată printr-o ret ,ea antrenată să clasiﬁce sarcina oferită.
Înurmaefectuăriia 100deepisoadedetestare,pentruﬁecaredintreceledouăjocuri,
utilizând aceeas ,i ret,ea antrenată, rezultatele sunt următoarele:
Boxing Fishing Derby
=0:050 90:24210:156 2:96218:626
=0:001 97:8930:880 22:82518:207
Scor Uman Mediu Ref. [7] 4:298 5:519
Se observă că în cazul jocurilor competitive de 2 participant ,i ("Boxing", "Fishing Derby" s ,i "Pong"), o valoare mai redusă pentru conduce la scoruri semniﬁcativ mai mari
De-a lungul antrenării, efectul alternării celor două sarcini era cel mai vizibil imediat
dupăproducereauneiastfeldeschimbări: agentulobt ,ineascoruriextraordinardemicipe
jocul următor timp de un număr de iterat ,ii care descres ,tea cu ﬁecare astfel de alternare a
66

4.3. Rezultate s ,i Experimente
sarcinii. Spresfârs ,itulantrenării,modelulrevenealascorurilemaximepejocul"Boxing"
după aproximativ 100000de iterat ,ii s,i după 1000000 în cazul jocului "Fishing Derby",
caresedovedes ,teaﬁosarcinămaidiﬁcilă. Astfel,reducândtreptatnumăruldeiterat ,iide
antrenare dintre ﬁecare două schimbări de sarcină consecutive, s ,i oprind modelul într-un
punctapropiatdeoastfeldeschimbare,amobt ,inutunmodelcaresăconveargălavalorile
posibile optime în cazul ambelor jocuri.
4.3.3 Jocuri Implementate Personal
Autorii lucrării originale nu speciﬁcă nimic în legătură cu aplicativitatea metodei în
cadrul jocurilor de mai mult ,i participant ,i, precum nici cele ulterioare care augmentează
algoritmul de învăt ,are a aproximării funct ,iei de valoare-act ,iune optimă. Ca atare, am
efectuat numeroase experimente pentru a constata care este procedura corectă de abor-
dare a problemei jocurilor cu mai mult ,i participant ,i, de la antrenarea simultană a două
ret,ele complet separate, până la antrenarea unei singure ret ,ele s,i oglindirea stărilor în
vedereagenerăriiuneiact ,iunipentruoponent. Empiric,utilizareaadouăret ,eleacondus,
asemănător cu varianta init ,ială a algoritmului, cea fără model "t ,intă", instabilitate mare
la antrenare, încetinind-o s ,i crescând semniﬁcativ numărul diferent ,elor dintre cele două
ret,ele.
4.3.3.1 Pong
În cadrul jocului "Pong", pentru a măsura performant ,a agentului, am adaptat unele
dintremăsurătorileperformant ,eidescriseînlucrareadin2015aluiArdiTampuu,Tambet
Matiisen s ,i col. de "Multiagent Cooperation and Competition with Deep Reinforcement
Learning" [14], în care autorii utilizează o ret ,ea foarte similară pentru a învăt ,a doi agent ,i
săjoace"Pong"(variantadepeconsolaAtari2600,modiﬁcatăînemulatorpentruaputea
ﬁ jucată de către doi participant ,i simultan):
•Număruldeciocnirialebileicupaletele ("CP/r"),care,conformautorilorlucrării,
este o măsurătoare semniﬁcativă a performant ,ei deoarece, empiric, un agent care
respingemaimultebileesteunagentcuoperformant ,ămaistabilăs ,imaiapropiată
de cea a oponentului, s ,i, deci, un număr mai mare de ciocniri cu paletele într-o
67

Capitolul 4. Algoritm s ,i Rezultate
rundă indică o durată mai lungă a respectivei runde s ,i un joc mai strâns.
•Număruldeciocnirialebileicumargineasuperioarăs ,iceainferioară ("CM/r"),
relevantă pentru studierea strategiei învăt ,ate de agent, întrucât lovirea bilei de as ,a
natură încât mis ,carea acesteia să ﬁe mai verticală provoacă diﬁcultăt ,i oponentului,
care trebuie să prezică cu o mai mare acuratet ,e pozit ,ia ﬁnală a bilei pentru a putea
react,iona la timp la unghiul redus de ricos ,are
În plus, am mai utilizat următoarele măsurători proprii:
•Vitezamedieabileirelativălavitezainit ,ială("VM/r"),calculatădreptprocentul
din viteza init ,ială a bilei pe care îl reprezintă media normelor 2 ale vectorilor de
viteză ale bilei de-a lungul unei runde.
•Fort,a medie de propulsare a bilei în urma coliziunii cu paletele relativă la
fort,a instantanee aplicată la deplasarea paletelor ("FM/r"), redată de procentul
din fort ,a aplicată la deplasare al vitezei paletelor la ﬁecare moment al ciocnirii
acestora cu bila, în condit ,iile în care viteza unei palete descres ,te semniﬁcativ la
ﬁecare moment de timp scurs de la aplicarea respectivei fort ,e de deplasare (s ,i
în condit ,iile în care bila se poate ciocni s ,i de o paletă stat ,ionară, de viteză 0).
Am considerat această măsurătoare relevantă deoarece, având în vedere faptul că
ciocnirea cu o paletă preia din viteza acesteia pe verticală, o tactică competitivă
constăînmanevrareapaleteideas ,anaturăîncâtbilasăﬁelovităcuputeremaximă.
Modelând funct ,ia de răsplată ca întorcând 1, respectiv1ﬁecărui jucător atunci
când acesta obt ,ine un punct, respectiv când pierde unul, experimentele realizate sunt
următoarele:
•Utilizarea a doi agent ,i separat ,i, ﬁecare controlând un jucător s ,i având o memorie
auxiliarăpropriedecapacitate 500000. Unuldintreagent ,i(celreprezentativjucăto-
ruluidinstânga)aînvăt ,atotacticăstabilă(darîncăneperformantă)chiars ,iîncazul
testării cu adversar uman, respingând o mare parte din bile venind dintr-o varietate
dedirect ,iisicuvitezescăzutes ,iridicate. Jucătoruldindreapta,însă,arămasîntr-un
stadiu aproape complet aleatoriu: nu react ,iona la pozit ,ia bilei s ,i pierdea aproape
68

4.3. Rezultate s ,i Experimente
toate bilele îndreptate înspre jumătatea sa de ecran. Faptul că, în condit ,iile unui
oponent aleatoriu, prima instant ,ă a agentului a reus ,it să învet ,e o tactică minimal
suﬁcientă demonstrează gradul ridicat de independent ,ă strategică a participant ,ilor
jocului "Pong".
•Utilizarea a unui aceluias ,i agent, cu un singur model, care să ia decizii pentru
ambii jucători. Pentru a realiza acest lucru, am inclus în preprocesarea cadrelor
stăriloragentuluisecundarunpasdeoglindirepeorizontalăaimaginilor,astfelîncât
stările să pară a face parte din gama de stări a jucătorului principal. Am păstrat în
continuare memorii auxiliare separate s ,i am antrenat modelul pe stări din ambele
memorii. Acest experiment a dat dovadă de mai multă stabilitate (ambii jucători
erau la nivel egal), însă convergea mult mai încet (datorită dublării numărului de
stări de la ﬁecare moment de timp).
•Experimentulﬁnals ,icelmaidesuccesaconstatînreplicareaexperimentuluiprece-
dent,doarcăutilizândosingurămemorieauxiliară(ceaajucătoruluiprincipal). În
plus,culoareapaletei(diferităîntreceidoijucători)afecteazăneglijabilperformant ,a
agentuluisecundar,demonstrândfaptulcăagentul,ﬁindexpusnumaiexperient ,elor
unui singur jucător la antrenare, învat ,ă mai degrabă pozit ,ia acestuia pe ecran cu
scopul identiﬁcării lui decât alte detalii ale aspectului obiectului de joc.
În ﬁnal, conform măsurătorilor propuse, rezultatele pentru testarea pe 10episoade de
jocalemodeluluiîmpotrivasa,înurmaantrenăriitimpdeaproximativ 9000000deiterat ,ii,
sunt următoarele:
CP/r CM/r VM/r FM/r
=1:000 0:2140:410 0:7140:700 108:599%48:521% **
=0:050 9:33310:165 10:8896:773 279:756%25:083% 63:417%24:088%
=0:001 13:81810:521 16:1829:064 258:759%30:550% 66:403%23:287%
Viteza relativ ridicată a bilei s ,i a fort,ei medie de coliziune a paletelor cu aceasta demonstrează agresivitatea s ,i competivitatea strategiei învăt ,ate de către agent
*=1:0reprezintă un agent complet, uniform aleatoriu
**majoritateameciurilorîntreagent ,ialeatoriseîncheiaufărăcavreopaletăsăloveascăbilamăcarodată,astfelcămăsurătoarea"FM/r"decelemaimulteorinuseputeacalcula
Înjoculcuadversaruman,empiric,modelulareoperformant ,ăsatisfăcătoare,respin-
gând cu succes majoritatea bilelor s ,i chiar ciocnind deseori bila brusc, pentru a scădea
unghiul de ricos ,are s,i pentru a îi cres ,te viteza. Des ,i nu supra-uman prin modul de joc,
69

Capitolul 4. Algoritm s ,i Rezultate
agentul reus ,es,te să învingă de cele mai multe ori datorită stabilităt ,ii performant ,ei lui:
un agent uman riscă să îs ,i piardă răbdarea, să îs ,i asume riscuri care să îi piardă runde
s,i, în general, nu poate juca constant la acelas ,i nivel; în schimb, agentul, prin deﬁnit ,ie,
datoritănaturiisaleartiﬁciale,areaproapemereuacelas ,irandamentdejoc(afectat,totus ,i,
de aleatorismul variabilei ) s,i ia întotdeauna deciziile optime conform stării jocului s ,i
parametrilor săi actuali.
4.3.3.2 Spaceships
Jocul "Spaceships", chiar s ,i în varianta sa mai restrictivă, s-a dovedit a ﬁ o sarcină
mai diﬁcilă, datorită instabilităt ,ii procesului de învăt ,are al agentului împotriva sa s ,i a
imprevizibilităt ,ii oponent ,ilor reali umani, s ,i datorită posibilităt ,ii pasivităt ,ii: modelul
alege când să atace (spre deosebire de "Pong", unde agentul putea, cel put ,in init ,ial, să
învet,edoarsănulasebilasătreacădemargineasadeecrans ,ieradeajunspentruaînvăt ,a
simultan să joace împotriva oponentului), astfel că învăt ,area jocului "Spaceships" limitat
presupune mai întâi învăt ,area evitării proiectilelor inamice, s ,i apoi învăt ,area lansării cu
acuratet ,e a proiectilelor proprii. În vederea estimării performant ,ei, am t ,inut cont de
mediile pe mai multe runde de testare a următoarelor măsurători:
•Numărul de proiectile lansate de agent ("NP/r").
•Acuratet ,eaagentului ("AP/r"),datădeprocentuldeproiectilecarelovescoponen-
tul din numărul total de proiectile lansate de către agent.
•Distant ,a medie relativă la spat ,iul de deplasare fat ,ă de oponent a proiectilelor
propriicarenulovescoponentul ("DP/r"),datdeprocentuldistant ,eipeorizontală
dintre proiectil s ,i jucător din lungimea axei de deplasare a jucătorului
•Numărul de proiectile lansate de către oponent ("NO/r")
•Ratadegres ,elialeoponentului ("IAO/r"),datădeprocentuldeproiectileinamice
care nu lovesc nava agentului.
•Distant ,a medie relativă la spat ,iul de deplasare fat ,ă de sine a proiectilelor
oponentului care nu lovesc jucătorul ("DO/r"), calculată analog cu "DP/r".
70

4.3. Rezultate s ,i Experimente
Experimentelerealizatesunturmătoarele,ment ,ionândfaptulcăîntoateexperimentele,
funct,iaderăsplatăestestrictdependentădeschimbărileînresurseledeviat ,ăalejucătorilor
(pentru ﬁecare punct de viat ,ă pierdut de un jucător la un moment de timp, respectivul
jucător recept ,ionează o răsplată de câte 1, iar oponentul o răsplată de câte 1):
•Utilizarea a doi agent ,i separat ,i, ﬁecare controlând un jucător s ,i având o memorie
auxiliară proprie de capacitate 500000, oferind act ,iunile posibile de deplasare la
stânga,deplasareladreaptas ,idelansaredeproiectil. Cas ,iîncazuljocului"Pong",
acest experiment a produs instabilitate mult prea mare pentru a facilita un proces
de învăt ,are normal. De asemenea, mis ,cările brus ,te ale oponentului s ,i nevoia de
a se opri din deplasare pentru a lansa un proiectil au condus la învăt ,area unei
strategii predominant cinetice, în care lansarea proiectilelor reprezintă o activitate
mai degrabă secundară.
•Utilizareaaunuiaceluias ,iagent,cuunsingurmodel,caresăiadeciziipentruambii
jucători, în contextul aceluias ,i spat ,iu de act ,iuni. Pentru a realiza acest lucru, am
adăugat acelas ,i pas de oglindire pe orizontală a imaginilor ca s ,i în cazul jocului
"Pong", adăugând în plus un pas de preprocesare de oglindire s ,i pe verticală s ,i de
eliminareazoneidescor. Ampăstratosingurămemorieauxiliară(astărilorprimul
agent) s ,i am antrenat modelul doar pe acestea. Rezultatul a fost foarte asemănător
cu cel al experimentului precedent.
•Un alt experiment a constat în programarea unui agent determinist, care se depla-
sează după oponent, evitând pe cât posibil proiectilele atât pe pozit ,ia sa, cât s ,i pe
pozit,iiviitoare,s ,ilansândproiectileatuncicândseaﬂăîndreptuloponentului. Am
utilizat acest agent determinist init ,ial ca oponent al modelului, însă ret ,eaua învăt ,a
o strategie prin care să învingă agentul determinist, dar care es ,ua atunci când avea
de-a face cu un oponent uman sau în jocul împotriva sa. Am încercat, apoi, să
antrenez ret ,eaua pe baza agentului determinist, iar apoi să alternez între un opo-
nent determinist s ,i un agent bazat pe acelas ,i model de învăt ,are automată în timpul
antrenării, însă niciunul dintre experimente nu a dat dovadă de progres.
•Utilizarea a doi agent ,i separat ,i, însă de data aceasta oferind, în plus, act ,iunea de
71

Capitolul 4. Algoritm s ,i Rezultate
deplasare stânga s ,i lansare de proiectil simultană, s ,i act,iunea de deplasare dreapta
s,i lansare de proiectil simultană. În plus, pentru a cres ,te stabilitatea modelului, am
ales,asemănătorcuintroducereamodelului"t ,intă"încadrulalgoritmuluipropus,să
antrenezﬁecareagent(atâtcelprimar,câts ,isecundar)câte 10000deiterat ,iiodată,
ci nu simultan. În contextul acestor două schimbări, procesul de învăt ,are a decurs
mai favorabil s ,i agentul a convers la o performant ,ă satisfăcătoare. În ciuda acestui
fapt,procesuldeantrenareadiversdelaperformant ,arespectivăulteriors ,iatrebuit
oprit din timp, deoarece cei doi agent ,i dezvoltau o strategie optimă prin care jocul
continualainﬁnit,întrucâtniciunuldintreagent ,inuîs ,iasumarisculdeasedeplasa
s,i a intra în focul oponentului.
În ﬁnal, conform măsurătorilor propuse, rezultatele pentru testarea pe 10episoade de
joc ale modelului împotriva sa sunt descrise în tabela următoare.
NP/r AP/r DP/r
NO/r IAO/r DO/r
=1:000 17:1005:941 23:030%13:795% 15:960%7:088%
17:1005:147 75:598%21:743% 16:495%7:149%
=0:050 115:55549:044 7:061%2:693% 6:570%0:344%
59:022:464 93:958%3:769% 6:493%0:133%
=0:001 183:10087:138 4:737%2:180% 6:629%0:528%
92:30042:530 99:166%1:448% 6:483%0:173%
Proximitatea navelor de proiectilele oponente (măsurătorile "DP/r" s ,i "DO/r"), demonstrează faptul că acuratet ,ea agent,ilor, des,i aparent scăzută, este relativ ridicată la
performant ,a modelului împotriva sa
Empiric, împotriva unui adversar uman, agentul se evită o mare parte din proiectile
oponente s ,i, ocazional, lansează proiectile pe pozit ,ii viitoare ale oponentului, astfel că
constituie o provocare suﬁcientă pentru scopul propus.
4.3.3.3 Snakes: Experimente Nereus ,ite
Antrenareapejocul"Snakes",as ,acumafostimplementats ,idescrisanterior,nuafost
posibilă, indiferent de diversitatea încercărilor realizate.
Într-un prim experiment, am implementat jocul ca joc cooperativ, în care cei doi
participant ,i contribuie amândoi prin resursele de hrană consumate la un scor colectiv.
De asemenea, am ales să permit trecerea prin marginile ecranului de joc (s ,i aparit ,ia în
marginea opusă). Indiferent de funct ,ia de răsplată aleasă, agentul nu convergea la o
72

4.3. Rezultate s ,i Experimente
strategie mai performantă ca cea aleatoare: jucătorii, controlat ,i amândoi de câte o ret ,ea
separată, alegeau să se deplaseze nesfârs ,it pe aceeas ,i axă.
Unaldoileaexperimentaconstatîntransformareajoculuiîntr-unulcompetitiv: funct ,ia
de răsplată întorcea, ca s ,i în cazul jocului "Pong", răsplăt ,i de1s,i, respectiv,1pentru
stările în care jucătorul, respectiv oponentul, consuma o sursă de hrană. Rezultatul a fost
acelas ,i.
Următoarea modiﬁcare a constat în penalizarea deplasării: am introdus o răsplată de
1pentru ﬁecare moment de timp în care jucătorul nu consuma o sursă de hrană, fără a
introduces ,iorăsplatăegalăînmoduls ,ipozitivăpentruoponent,însăagentulacontinuat
să es,ueze în a învăt ,a o strategie cel put ,in minimal superioară jocului aleatoriu.
În continuare, am eliminat conceptul de pătrundere prin marginile ecranului, deter-
minând episoade de joc mult mai scurte, însă inﬂuent ,ând doar neglijabil performant ,a
ﬁnală a modelului.
Văzândtoateacesteexperimentenereus ,ite,amrealizatcăproblemaconstaînnumărul
redus de surse de hrană aﬂate în joc la ﬁecare moment de timp ( 2, care, în urma pre-
procesării, ajungeau să aibă dimensiunea de exact 11pixel). În acest sens, am ales
să populez ecranul de joc cu câte 20de surse de hrană în loc de 2. Rezultatul a fost
unul superior, astfel că agentul a învăt ,at cu succes evitarea peret ,ilor ecranului, însă încă
insuﬁcient, întrucât numărul ridicat de surse de hrană îi permiteau agentului deplasarea
"în cerc" cu o probabilitate mare de a consuma, din întâmplare, surse de hrană aﬂate în
zonadedeplasare. Înplus,reducereanumăruluidesursedehranăla 2înapoinudetermina
s,i o schimbare în strategia agentului.
Un alt experiment a constat în implementarea lucrării celor de la Google DeepMind,
"Prioritized Experience Replay" [15], care propune o metodă de augmentare a memoriei
auxiliares ,iapropagăriigradient ,ilorînalgoritm,pentruat ,inecontdeoprioritatecalculată
simultană cu învăt ,area. Lucrarea propune calcularea unor probabilităt ,i pentru ﬁecare
experient ,ă es,antionată la un pas de antrenare în funct ,ie de funct ,ia de cost calculată
pentruacelestări,s ,iadăugareaunorponderigradient ,ilorcalculat ,ipentrustărilerespective
înaintea actualizării parametrilor ai ret ,elei. Experient ,ele sunt, astfel, es ,antionate în
funct,ie de probabilităt ,ile respective, care se însumează toate peste memoria auxiliară în
73

Capitolul 4. Algoritm s ,i Rezultate
valoarea 1.
Acest experiment doar a îngreunat învăt ,area s ,i, în ﬁnal, nu a convers la rezultate
îmbunătăt ,ite.
În ﬁnal, am adaptat un algoritm determinist de tip "greedy" pentru a juca jocul s ,i am
antrenat ret ,eaua pe experient ,ele algoritmului respectiv. Algoritmul avea acces la starea
internăajoculuis ,ialegeaîntotdeaunaact ,iuneacaresă-lapropriecelmaimultdeceamai
apropiatăsursădehrană,evitând,dacăesteposibil,act ,iunilecaresăconducălamomentul
imediat următor de timp la o coliziune cu o parte a sa sau cu oponentul. Am utilizat doi
astfeldeagent ,ideterminis ,tisimultans ,i,surprinzător,experient ,eledeterministenuaufost
de folos, iar agentul nu a învăt ,at o strategie nealeatoare.
Înconcluzie,pelângăinstabilitateacauzatădeprezent ,aînjocamaimultorparticipant ,i,
toate aceste experimente expun un mare dezavantaj al algoritmului: pentru a facilita an-
trenareaconformalgoritmuluipropusîntimputil,estenevoiedeopreprocesaremultprea
severăastărilordeintrare,astfelcăreducereadimensiuniilaunnivelatâtdesemniﬁcativ
produce imagini inutilizabile în vederea antrenării; ret ,elele convolut ,ionale sunt inerent
invariante la "zgomot" în imagini, astfel că imposibilitatea detect ,iei unor surse de hrană
reprezentate printr-un singur pixel alb în imagine nu este deloc surprinzătoare.
Exempledeimaginipentruvariantajoculuicucâte20desursedehrană,dupăactivareaprimuluistratconvolut ,ionalalret ,elei;vizibil,jucătoriinupotﬁdistins ,idesurseledehrană
74

Capitolul 5
Tehnologii Folosite
5.1 Python
În continuare, descrierea limbajului de programare Python s ,i aﬁrmat ,iile legate de
aspectele acestuia, dar nu s ,i exemplele, sunt preluate din [16].
Pythonesteunlimbajdeprogramareinterpretat(s ,icompilabil),dinamic,denivelînalt
s,i multi-paradigmă, disponibil pe o varietate mare de arhitecturi s ,i sisteme de operare.
Dezvoltatîncădin1991decătrecreatorulsăuGuidovanRossum,limbajulafostconceput
cu scopurile de a ﬁ intuitiv s ,i us,or de folosit fără a compromite performant ,a, de a avea
sursele publice pentru a permite s ,i încuraja comunitatea utilizatorilor să contribuie la
dezvoltarea limbajului, de a avea o sintaxă us ,or de înt ,eles, apropiată de cea a limbii
engleze, s ,i de a permite implementarea rapidă a sarcinilor de zi cu zi. Atât în cadrul
jocurilor implementate, cât s ,i a solut ,iilor de învăt ,are ranforsată, am folosit versiunea 2.7
a limbajului de programare Python, datorită compatibilităt ,ii cu librăriile necesare.
Pythonesteunlimbajdeprogramaredinamiccaregestioneazăautomatmemoria(spre
deosebiredelimbajulC,deexemplu,undegestionareamemorieiesteosarcinăcarecade
înresponsabilitateaprogramatorului). Înacestsens,limbajulveriﬁcătipurilevariabilelor
abia la interpretare/rulare, s ,i nu există nicio garant ,ie sintactică cum că o variabilă se
va comporta conform speciﬁcat ,iilor unui tip static, fapt care compromite sigurant ,a în
favoareaﬂexibilităt ,iis,iarapidităt ,iiscrieriiprogramului. Înplus,Pythonfoloses ,teceeace
senumes ,teînengleză"latebinding",astfelcănumelevariabilelor,alefunct ,iilor,claselors ,i
75

Capitolul 5. Tehnologii Folosite
alaltorobiectesuntatribuiterespectivelorobiectedoaratuncicândsuntutilizate/apelate,
la execut ,ie. Limbajul permite urmarea a mai multor paradigme de programare: cea
orientatăpeobiecte,ceaimperativă,ceafunct ,ională,meta-programareaetc. Deasemenea,
Python are o librărie standard comprehensivă care scutes ,te programatorul de nevoia de
a implementa de ﬁecare dată aceleas ,i funct ,ionalităt ,i de uz comun, cum ar ﬁ operat ,iile
matematice (logaritm, maxim, minim etc.) sau operat ,iile pe liste, mult ,imi, dict ,ionare de
date. CPython, interpretorul limbajului, este scris în C.
Atribuirea în python se face analog cu limbajele asemănătoare cu limbajul C, însă
declararea variabilelor fără atribuire nu este posibilă. Declararea unei variabile este
automată s ,i simultană cu prima sa atribuire. Python t ,ine cont de diferent ,a dintre literele
mari s ,i cele mici ale alfabetului, astfel că variabila Xeste diferită de variabila x. De
asemenea,ﬁindunlimbajinterpretat,Pythonrespectănormadelimităriicomentariilorpe
linie prin simbolul "#" a majorităt ,ii limbajelor interpretate, comentariile pe mai multe
linii propriu-zise lipsind din speciﬁcat ,ia limbajului, dar putând ﬁ înlocuite aproximativ
echivalent de s ,iruri libere de caractere (care încep s ,i se încheie cu 3 ghilimele duble).
S,iruriledecaracterepotﬁreprezentateatâtprinunasaudouăghilimele,neexistânduntip
particular pentru caractere, acestea putând ﬁ exprimate prin s ,iruri de un singur caracter.
Sintaxa în Python diferă de cea a limbajelor inspirate din C, astfel că blocurile de
cod nu sunt delimitate prin acolade ("{", "}") sau semnul de punctuat ,ie punct s ,i virgulă
(";"), ci prin indentare (preﬁxarea liniilor de cod cu un număr constant de spat ,ii pentru
ﬁecare nivel de indentare); de ﬁecare dată când este necesară începerea unui bloc nou de
cod (de exemplu la deﬁnirea unei funct ,ii, la utilizarea unor instruct ,iuni ciclice ca "for"
sau "while", sau în cazul ramiﬁcării condit ,ionate a programului prin sintaxa "if-else"),
începerea blocului este semnalată prin suﬁxarea cu semnul de punctuat ,ie două puncte
(":")ainstruct ,iuniideclans ,atoare,ﬁnalulbloculuiﬁindsemnalatprinîncheiereanivelului
adit,ionaldeindentarealiniilordecod. Odiferent ,ăsemanticăsemniﬁcativăîntreblocurile
din Python s ,i cele din limbajele compilate este că variabilele declarate într-un bloc de
cod Python sunt vizibile, disponibile s ,i modiﬁcabile din afara blocului respectiv. Acest
fapt este datorat nu unei convent ,ii, cât modului în care funct ,ionează scopul variabilelor
îninterpretor: indiferentdebloculdeclarăriilorînprogram,variabileledeclarateînafara
76

5.1. Python
funct,iilor intră în scopul global de variabile. Pentru a le accesa în interiorul funct ,iilor
în cazul în care există alte variabile din scopul local al variabilelor funct ,iei cu aceleas ,i
nume (altfel, ele pot ﬁ accesate în mod direct), sau pentru a le modiﬁca în interiorul
funct,iilor,acesteatrebuieredeclarateutilizândcuvântulcheie global(carenureprezintă
o declarare propriu-zisă, deoarece acestea trebuie să existe în scopul global la momentul
apelării funct ,iei).
UnexemplualnivelelordeindentareînPythons ,iechivalent ,adintreacesteas ,iblocurile
delimitate de acolade în alte limbaje:
for i in range(100): # {
if i % 3 == 0: # {
print(i)
# } aici se incheie instructiunea "if"
# } aici se incheie instructiunea "while"
print('Fin')
Tipurile de date elementare în Python 2 sunt tipurile numerice ( int,long,float,
complex),str(s,irurile de caractere), bool(TruesauFalse), valoarea specială None,
echivalentăîntr-ooarecaremăsurăcuvaloareaspecială nulldinaltelimbaje(deexemplu,
Java), al cărui tip este NoneType s,i care se foloses ,te automat acolo unde se as ,teaptă o
valoare,dareanuexistă, list(delimitatînmodspecialprin"["s ,i"]",reprezintăvectori
de dimensiune variabilă care t ,in orice tip de variabilă), tuple(reprezintă colect ,ii de
dimensiuneﬁxată,caret ,inoricetipdevariabilă), dict(delimitatprin"{"s ,i"}",reprezintă
un obiect care mapează bijectiv obiecte la alte obiecte, cel mai des folosit pentru a mapa
valori la s ,iruri de caractere), set(echivalent cu mult ,imile matematice) s ,i altele.
L = [1, 'doi', 3.0] # L este o lista indexabila
t = ('four', 5) # t este un tuplu ("tuple") indexabil cu 2 valori
L.append(t[1]) # va adauga valoarea 5 in lista L
print(L) # va afisa [1, 'doi', 3.0, 5]
print(L[0]) # va afisa primul element din L, 1
print(L[-2]) # va afisa penultimul element din L, 3.0
print(L[:2]) # va afisa [1, 'doi'], echivalent cu "print(L[0:2])"
print(L[2:]) # va afisa [3.0, 5], echivalent cu "print(L[2:4])"
print(L + [18.25]) # va afisa [1, 'doi', 3.0, 5, 18.25]
b = (L[0] >= 0) and not (L[1][0] != 'd' or False) # "and", "or" si "not"
sunt echivalente cu "&&", "||" si respectiv "!" din alte limbaje
imperative
if b: # b are valoarea True
77

Capitolul 5. Tehnologii Folosite
b = None
if b:
print('True') # nu se va apela
d = {'cheie': 15, ('a', 98, 'c'): L} # d este un dictionar
print(d['cheie']) # va afisa 15
print(d[('a', 98, 'c')]) # va afisa [1, 'doi', 3.0, 5]
Declarareafunct ,iilorînPythonsefaceprincuvântulcheie def,asemănătorcudecla-
răriledefunct ,iidinaltelimbajeimperative,diferent ,amajorăconstândînlipsaspeciﬁcării
tipuluivariabileideretur. Limbajulmaidispunes ,ideconceptuldelambdaexpresie,care
reprezintă,înesent ,ă,ofunct ,ieformatădintr-osingurăexpresiediferitădeoatribuire. Atât
funct,iile,câts ,ilambdaexpresiilesuntobiectedeprimăclasăînlimbajs ,inudiferăconcep-
tual de variabilele numerice, s ,iruri de caractere, liste, dict ,ionare s ,i alte clase s ,i tipuri de
obiecte. Funct ,iile pot ﬁ trimise ca parametri, pot ﬁ amplasate în colect ,ii, pot ﬁ declarate
în interiorul altor funct ,ii etc. Except ,ie fac operatorii, care nu pot ﬁ folosit ,i în acest mod
decâtprinapelarealorexplicităprinnumeleintern(deexemplu, __add__ pentruadunare,
ci nu "+"). O consecint ,ă imediată a acestui fapt este imposibilitatea polimorﬁsmului (nu
pot exista două variabile cu acelas ,i nume). Drept solut ,ie, Python oferă valori pentru
parametriicarelipsesclaapel: dacăunuiparametrunuîiesteasociatăovaloarelaapelul
funct,iei, acesta ia valoarea "de bază". Astfel, comportamentul funct ,iei se poate schimba
în funct ,ie de parametrii primit ,i pentru a imita polimorﬁsmul din alte limbaje. Aplicarea
part,ială a funct ,iilor se poate realiza prin intermediul modulului de functools inclus în
librăria standard, mai exact funct ,iapartial, care primes ,te o funct ,ie s,i oricât ,i parametri
s,ireturneazăfunct ,iaprimită,aplicatăpart ,ialpeparametriirespectivi. ÎnPython2, print
esteoexpresieimplicităalimbajului,cinuofunct ,ie. AcestlucruesteschimbatînPython
3.
def foo(x, y, z=0):
return x**2 + y + z # ** este operatorul de ridicare la putere
def bar(f, x):
return f(x, 1)
print(foo(2, 3)) # va afisa 7
print(foo(2, 3, 1)) # va afisa 8
print(bar(foo, 10)) # va afisa 101
foo = lambda x, y: x**2 + y
print(foo(2, 3)) # va afisa 7
78

5.1. Python
ParadigmadeprogramareorientatăpeobiecteesteimplementatăînPythonprinobiec-
tul de tip clasă. Există numeroase convent ,ii incluse în speciﬁcat ,ie pentru funct ,iile unei
clase, s ,i ce reprezintă acestea. De exemplu, pentru suprascrierea comportamentului
operatorilor matematici, trebuie suprascrise metode ca __add__,__div__ etc. Con-
structorul clasei este redat prin intermediul unei funct ,ii speciale denumite prin convent ,ie
__init__ . Claselenuaurestrict ,iialeaccesuluilaatributeles ,imetodelemembre,as ,acă,
prin convent ,ie, metodele care încep cu "_" se subînt ,elege că sunt menite a ﬁ private. În
plus, toate metodele clasei trebuie să accepte implicit ca prim argument variabila self,
analoagă lui thisdin alte limbaje de programare orientate pe obiecte.
# Exemplu (incomplet) de utilizare a claselor din implementarea
algoritmilor propusi.
# Clasa "Memory", din fisierul-modul "Memory.py", reprezinta memoria
auxiliara de stari a modelului
class Memory:
def __init__(self, size=None, num_actions=None):
# Constructorul clasei Memory; atributele acestei instante vor fi
toate cele asignate mai jos obiectului "self"
if size is None or num_actions is None:
# Aceasta verificare este necesara pentru cazul in care se
doreste incarcarea unei memorii auxiliare salvate anterior
return
self.memory = []
self.size = size
self.num_actions = num_actions
self.iteration = 0
self.episode = 0
self.memi = 0
self.full = False
@staticmethod
def load(path):
# Exemplu de metoda statica; se apeleaza prin "Memory.load('cale')"
memory = Memory()
memory.__dict__ = np.load(path).item()
return memory
# Pentru brevitate, am omis restul metodelor clasei
# …
Extensibilitatea s ,i modularitatea limbajului Python este dată de organizarea simplă
s,i eﬁcientă în module. Des ,i nu o unică solut ,ie, ﬁs ,ierele Python în sine pot reprezenta
79

Capitolul 5. Tehnologii Folosite
modulealcărornumecorespundenumeluiﬁs ,ieruluidinspat ,iullocaldestocare(deexem-
plu, ﬁs ,ierului formule.py i-ar corespunde modulul formule). Acest lucru simpliﬁcă
reutilizarea s ,i modularizarea metodelor s ,i a constantelor necesare s ,i oferă o metodă ele-
gantă de a realiza acest lucru. În afară de ﬁs ,iere locale, modulele se mai găsesc s ,i ca
pachete centralizate s ,i descărcabile prin intermediul uneltei "pip", care simpliﬁcă proce-
sul de căutare s ,i procurare a modulelor. Modulele se importă în întregime într-un ﬁs ,ier
interpretabilPythonprincuvântulcheie import,saupart ,ialprinspeciﬁcareaexplicităﬁe
a obiectelor importate, ﬁe a celor care să rămână neimportate. În plus, se poate speciﬁca
unnumealternativprincaresăsefacăreferirelamodululimportat. Importareamodulelor
nu trebuie să aibă loc la începutul ﬁs ,ierului. Ca s ,i în cazul obiectelor clase, obiectelor
funct,ie,s,iatuturorvariabilelordinPython,moduleleimportatesunts ,ieleobiectecatoate
celelalte, au un dict ,ionar al atributelor s ,i utilizează o sintaxă asemănătoare instant ,elor de
obiecte clasă.
import numpy as np # se importa libraria externa "numpy"
print(np.sqrt(64)) # va afisa 8.0
from sys import exit # se importa explicit doar metoda "exit"
exit(11) # se incheie programul cu cod de eroare 11
Înimplementareasolut ,iilorpentrualgoritmiipropus ,i,amutilizatnumeroaseﬁs ,ieres,i
ﬁs,iere-module, dintre care esent ,iale cel pentru memoria auxiliară a agentului, cel pentru
modelulpropriu-ziss ,icelpentruinterfat ,aconstruităpesteemulatorulconsoleiAtari2600.
Am folosit, de asemenea, câte un ﬁs ,ier-modul pentru ﬁecare joc în parte. Modularizarea
sect,iunilordecodmi-apermisunnivelmairidicatdeauto-organizares ,idezambiguizarea
programelor,asemeneaavantajelorpecareleaducfunct ,iiles,iprocedurileîntr-unprogram
prin izolarea s ,i specializarea sect ,iunilor repetitive de cod. Astfel, am ales să urmez
convent ,ia standardului limbajului de programare Java s ,i să includ o singură astfel de
clasă, fără alte funct ,ii exterioare, în ﬁecare ﬁs ,ier-modul, pe lângă ﬁs ,ierele auxiliare care
rulează propriu-zis algoritmii s ,i/sau jocurile.
Python este un limbaj de programare care oferă o multitudine de posibilităt ,i în plus
fat,ă de cele prezentate anterior, inclusiv concepte ca blocuri de gestionare a except ,iilor
try-catch (try-except înPython),cuvântulcheie assertdetestareunitară,instruct ,iunea
80

5.1. Python
"inutilă" pass,s,tergereavariabilelordinscopprincuvântulcheie del,comprehensiunile
pe liste, decoratorii, operatorii "*" respectiv "**" pentru împachetarea s ,i despachetarea
automată a colect ,iilor, funct ,iileexecs,ievalde execut ,ie de cod dinamic etc. Toate
acestea,împreunăcuaccesibilitatealimbajuluis ,ieﬁcientizareamediuluidelucrupecare
o aduce au condus la dezvoltarea a multor librării de calcul s ,tiint,iﬁc în paralel cu lim-
baje concepute cu acest scop speciﬁc (de exemplu, Matlab s ,i limbajul de programare R),
dintre care cele mai populare NumPy (a cărui contribut ,ie majoră o constituie vectorii
n-dimensionali, care folosesc o notat ,ie asemănătoare cu cea a matricilor din limbajul de
programareMatlab),scikit-learn(olibrăriedemetodeeﬁcientepentrudomeniilede"data
mining", al analizei de date s ,i al învăt ,ării automate), Tensorﬂow (librăria ﬁrmei Google
pentruret ,eleneuronaleînparticulars ,ipentruînvăt ,areautomatăînsensgeneral),LibROSA
(pentru prelucrarea s ,i analizarea sunetelor s ,i a muzicii), matplotlib (pentru graﬁce), pan-
das s,i multe altele. Faptul că am avut acces la toate aceste implementări performante ale
diverselor sarcini pe care le impuneau algoritmii propus ,i, de la sarcini majore ca imple-
mentarea coborârii pe gradient pentru ret ,eaua neurală, până la sarcini minore ca scrierea
s,i citirea datelor pe sistemul local de ﬁs ,iere, mi-a permis să mă concentrez pe conceptele
particulare, speciﬁce problemei alese, s ,i pe implementarea lor, ci nu pe rescrierea unor
funct,ionalităt ,i generale deja realizate la o calitate ridicată în industrie.
# O varianta simplificata a functiei folosite pentru antrenare pe jocuri
Atari
def epoch(steps, env, dqn, memory, epsilon, args, training):
# "env" reprezinta variabila interfetei construite peste emulator,
"dqn" reprezinta modelul, "memory" memoria auxiliara
starting_iteration = memory.iteration
while memory.iteration – starting_iteration < steps:
total_reward = 0
s0 = None
env.reset()
while not env.game_over():
if s0 is None or random.random() < epsilon(memory.iteration):
# Alege o actiune aleatoare cu probabilitate epsilon
a = random.randrange(env.num_actions)
else:
# Altfel, alege indicele maximului functiei de
valoare-actiune optime pentru ponderile curente ale
modelului
s = np.reshape(np.concatenate(s0, axis=2), (1,
81

Capitolul 5. Tehnologii Folosite
args.image_shape[1], args.image_shape[2],
args.state_size))
a = np.argmax(dqn.predict(s), axis=1)[0]
s1, r, terminal = env.act(a) # transmite actiunea emulatorului
si asteapta noua stare, rasplata, si indicatia daca starea
noua este sau nu terminala
if training and s0 is not None:
memory.add((s0, a, r, s1, terminal)) # populeaza memoria cu
o experienta noua
if memory.iteration > args.memory_init and \
memory.iteration % args.train_wait == 0:
batch = memory.sample(args.batch_size) # esantioneaza
uniform experiente din memorie…
dqn.train(batch) # … si ajusteaza ponderile modelului
pe baza acestora si a modelului "tinta" (intern
instantei "dqn")
if memory.iteration % args.target_update_freq == 0:
dqn.update_target() # se actualizeaza ponderile
modelului "tinta"
if terminal:
s0 = None
else:
s0 = s1
total_reward += r
memory.iteration += 1
memory.episode += 1
5.2 NumPy
NumPy este o librărie pentru versiunile majore 2 s ,i 3 ale limbajului de programare
Python folosită pentru vectorii n-dimensionali (numit ,indarray), implementat ,i mai eﬁ-
cient ca timp s ,i memorie de alocare decât alternativele oferite atât de limbajul Python în
sine cât s ,i de alte librării, fără a compromite elegant ,a codului sau us ,urint,a de utilizare
[17]. De asemenea, NumPy pune la dispozit ,ie un număr variat de operat ,ii ajutătoare pe
vectori, matematice, logice, de manipulare a formei (de exemplu, transpunerea ar ﬁ o
astfel de operat ,ie), de sortare, de selectare, de citire s ,i scriere rapidă a vectorilor într-un
format standardizat în sistemul local de ﬁs ,iere, operat ,ii de bază de algebră liniară (de
exemplu, aﬂarea inversei), operat ,ii statistice de bază s ,i multe altele. Diferent ,ele dintre
listeles ,isecvent ,ele(deexemplu,tuplurile)incluseînspeciﬁcat ,iaPythons ,ivectoriioferit ,i
82

5.2. NumPy
de librăria NumPy sunt următoarele:
•Vectorii NumPy au o dimensiune ﬁxată, speciﬁcată la creare. Pentru a "redimen-
siona" un vector NumPy, este nevoie de s ,tergerea vectorului vechi s ,i crearea unui
vector nou.
•ElementeleunuivectorNumPytrebuiesăﬁetoatedeacelas ,itip,inclusivdeacelas ,i
tip numeric unde este cazul.
•NumPy facilitează operat ,ii matematice avansate pe cantităt ,i mari de date într-un
mod mai eﬁcient s ,i mai us ,or de scris decât listele s ,i secvent ,ele limbajului Python.
•Majoritatea librăriilor pentru calcul s ,tiint,iﬁc în Python folosesc NumPy extensiv,
s,i ca atare, utilizarea unor astfel de librării presupune utilizarea vectorilor librăriei
NumPy
LabazatuturoracestoravantajestălimbajuldeprogramareC.NumPytransportăoperat ,iile
costisitoare pe vectori de dimensiuni mari în instruct ,iuni echivalente pre-compilate în
C, pentru a evita timpul ridicat de intepretare al interpretorului Python s ,i a executa
instruct ,iunile respective mai rapid, apoi transportă rezultatele înapoi în mediul interpre-
tabil Python pentru a continua execut ,ia. La exterior, acest întreg proces este mascat de
vectorializare: dacă as,ibsunt variabile de tip vector NumPy de aceeas ,i dimensiune
n1n2n3:::nk,k1, atunci produsul element cu element al celor doi vectori se
obt,ine, utilizând NumPy, prin următoarea instruct ,iune: a * b. Înlocuirea instruct ,iunilor
ciclice ( for,while) cu o singură instruct ,iune echivalentă se numes ,te "difuzare" a va-
lorilor (eng. "broadcasting"). În NumPy, majoritatea operat ,iilor se realizează, implicit,
utilizând tehnica de difuzare.
IndexareaînNumPyadaugăposibilitateaundeiindexărimaieﬁcienteprintr-osintaxă
asemănătoare cu cea din limbajul Matlab:
import numpy as np
x = np.random.rand(10, 10) # matrice bidimensionala initializata aleator
print(x.shape) # va afisa (10, 10)
print(x[0,0]) # afiseaza elementul de pe prima linie, prima coloana
print(x[2:6, 3:]) # afiseaza toate elementele de pe liniile 3 pana la 6
inclusiv si de pe coloanele 4 pana la 10 inclusiv
83

Capitolul 5. Tehnologii Folosite
y = np.random.rand(10, 10)
print(y[x >= 0.5]) # va afisa doar elementele din "y" de pe pozitiile
valorilor din "x" care sunt mai mari sau egale cu 0.5
print(y[np.array([0, 2, 4]), 5:8) # va afisa randurile 1, 3 si 5 si
coloanele 6 pana la 8 inclusiv ale matricei "y"
print(x[:, np.newaxis, :].shape) # va afisa (10, 1, 10)
x[:,:] = 0 # toate valorile lui "x" vor deveni 0
Întrucât datele de intrare s ,i de ies ,ire ale ret ,elei neuronale sunt reprezentate de ma-
tricin-dimensionale, am utilizat aproape exclusiv librăria NumPy în vederea modelării
experient ,elor (a memoriei auxiliare) s ,i în vederea antrenării ret ,elei neuronale, utilizând
colect ,iiledinPyhthondoarîncazurileîncareduplicareadateloreraprohibitivdecostisi-
toare (întrucât includerea unui obiect în două liste distincte nu duplică memoria ocupată
de acesta, ci creează doar o nouă referint ,ă la el în ambele liste).
5.3 Tensorﬂow
Înaceastăsect ,iune,descriereas ,iinformat ,iilelegatedesprespeciﬁcat ,ialibrărieiTensor-
ﬂow,împreunăcudocumentat ,iaacesteiapentrumodule,clase,metodes ,ialtecomponente,
dar nu s ,i exemplele, sunt preluate din [19], [20].
Tensorﬂow este o librărie de calcul simbolic dezvoltată de Google pentru limbajul
de programare Python, utilizată în principal pentru algoritmi de învăt ,are automată s ,i
cunoscutăpentrunumărulridicats ,ivariatdeclase,metodes ,icomponenteutileînvederea
dezvoltării s ,i implementării ret ,elelor neuronale.
Principalul avantaj al librăriei este performant ,a sa în comparat ,ie cu operat ,iile Python
obis,nuite,datorată,cas ,iîncazullibrărieiNumPy,unuiprocesdetranslatareaoperat ,iilor
în operat ,ii în limbajul C pre-compilate s ,i executarea lor propriu-zisă în acel context.
Tensorﬂow implementează acest procedeu prin conceptul de graf simbolic de calcul,
astfel că ﬁecare operat ,ie simbolică reprezintă ﬁe un nod, ﬁe un subgraf de astfel de
noduri(încazuloperat ,iilormaicomplexe,compusedinmaimulteoperat ,iielementare)al
respectivuluigraf. Anumitenodurisuntdesemnatecanodurideintrare,elereprezentând
unicul punct de contact al grafului de calcul cu limbajul Python. Operat ,iile grafului sunt
executate,apoi,explicit,prininstruct ,iunispecializate,într-uncontextdatdeovariabilăde
84

5.3. Tensorﬂow
tip sesiune (numele clasei: tensorflow.Session ), atribuindu-le variabilelor simbolice
stat,ionare valori concrete prin intermediul nodurilor de intrare s ,i propagarea lor în restul
grafului. Sesiuneagestioneazăunîntregscopdevariabilesimbolicedisjunctedescopurile
interpretoruluiPython,astfelcăaccesarea,modiﬁcareas ,ichiarinit ,ializarealor(analoagă
declarăriivariabilelorînlimbajeledeprogramare)sepotrealizadoarexplicitprinapeluri
careutilizeazăovariabilădetipsesiunedată. Ungrafcomputat ,ionalînTensorﬂowpoate
dispune de mai multe obiecte de tip sesiune, s ,i un program scris în Tensorﬂow poate
utilizamaimultegrafurisimultanprininstant ,iereaexplicităaclasei tensorflow.Graph
(în locul instant ,ierii implicite a grafului primar, denumit de către dezvoltatorii librăriei
"default graph").
Un exemplu simplu de utilizare al librăriei ar ﬁ următorul:
import tensorflow as tf
x = tf.placeholder(tf.float32) # nod de intrare in graf
y = x * 10 + 2
sesiune = tf.Session() # se initializeaza variabila de sesiune
print(y.eval(session=sesiune, x=5)) # va afisa 52
print(sesiune.run(y, feed_dict={x: 5})) # va afisa 52
print(y.eval(session=sesiune, x=3)) # va afisa 32
Tensorﬂowaducemultebeneﬁciiîncontextulret ,elelorneuronales ,ialalgoritmilorde
învăt,areautomatăîngeneral,dintrecarecelemaisemniﬁcativeﬁindposibilitateautilizării
plăcii graﬁce (sau video, abreviată GPU de la "Graphical Processing Unit" din engleză),
posibilitatea utilizării a mai multor componente hardware (inclusiv procesorul împreună
cu placa graﬁcă), în paralel, prin explicitarea componentei pe care să ﬁe distribuită ﬁe-
care operat ,ie, implementarea automată a propagării înapoi, numărul mare de proceduri
deja implementate pentru a standardiza, us ,ura s,i simpliﬁca implementarea diverselor ar-
hitecturi de ret ,ele neuronale fără a compromite eﬁcient ,a, scalabilitatea s ,i posibilitatea
transportăriigrafurilor(într-oformăimuabilă)pesistemuldeoperareAndroid. Îndezvol-
tarea algoritmilor propus ,i pentru problema aleasă, am utilizat librăria Tensorﬂow pentru
implementarea modelelor s ,i pentru calculele aferente lor.
Un alt aspect relevant pentru performant ,a librăriei, în afară de cele precedente, este
vectorializarea datelor: există s ,i este urmat conceptul de extindere a dimensionalităt ,ii
datelor,astfelîncâtdimensiuneaadit ,ionalăsăspeciﬁcenumărulexemplelor. Caatare,dacă
85

Capitolul 5. Tehnologii Folosite
dateleproblemeisuntreprezentate,deexemplu,înparticular,dematricitri-dimensionale
(lăt,ime,lungimes ,inumăruldecadrecarecompunostareaprocesuluidedecizieMarkov),
atuncidateledeintrarevorﬁreprezentatedematricicvadri-dimensionale,astfelcăﬁecare
matrice de intrare reprezintă mai multe stări ale jocului, ﬁecare reprezentând mai multe
imagini, ﬁecare având o lungime s ,i o lăt ,ime. Reprezentarea stărilor în acest mod asigură
paralelizareaeﬁcientăacalculelor. Număruldeexempleoferitelaﬁecarepasdeantrenare
poate ﬁ constant sau variabil s ,i depinde de posibilităt ,ile de procesare de care dispune
programatorul(unnumărpreamarededateconcomitentenuvorîncăpeaînmemorie,însă
unnumărpreamicproduceinstabilitateînalgoritmuldecoborârestocasticăpegradient).
Datorită naturii plăcilor graﬁce s ,i a modului în care se execută calculele pe acestea, se
utilizeazădeobiceioputerealui2pentrunumăruldeexempledeintrarealﬁecăruipasde
antrenare. Înparticular,înimplementareasolut ,iilorpentrualgoritmiipropus ,i,amutilizat
unnumărconstantde32deexemple. Înplus,amutilizatcanodadit ,ionaldeintrareunnod
asociatuneimăs ,tivectorialedevaloribinaredeadevărpentruact ,iuni,astfelîncâtfunct ,ia
decost(funct ,iaHuber)sănut ,inăcontdecâtdevalorilefunct ,ieidevaloare-act ,iunepentru
act,iunile speciﬁcate s ,i de valorile "t ,intă" pentru act ,iunile speciﬁcate; tratând respectiva
mască vectorială ca un vector numeric în care valorile adevărate să ﬁe echivalate cu 1,
iar cele false să ﬁe echivalate cu 0, implementarea acestui aspect minor se reduce la o
înmult ,ire matriceală element cu element.
În multitudinea de module, funct ,ii s,i clase de care dispune librăria Tensorﬂow, se
regăsesc multiple operat ,ii pre-deﬁnite echivalente cu diferitele tipuri de straturi de ret ,ele
neuronale, de la straturile clasice, bazate pe înmult ,ire matriceală, până la straturile de
convolut ,ie, cele recurente etc. Am optat pentru o implementare de un nivel mai put ,in
ridicat pentru straturile obis ,nuite (cel ﬁnal s ,i penultimul strat), dar am folosit operat ,ia de
convolut ,iealibrăriei,datorităcomplexităt ,iisporites ,iredundanteaimplementăriimanuale
aacesteia. Indiferentdeaceastăalegere,deﬁnireaunornoduri"antrenabile"(deexemplu,
a unor ponderi, iar în general, al unor noduri a căror valoare este schimbată prin inter-
mediul unui algoritm de optimizare) se realizează prin clasa tensorflow.Variable ,
al cărui constructor as ,teaptă, printre altele, un parametru care să delege init ,ializarea va-
riabilei unei alte operat ,ii (ﬁe prin valori constante, ﬁe prin valori aleatoare etc.). Atât
86

5.3. Tensorﬂow
timp cât există variabile declarate în scopul local obiectului sesiune activ într-un punct
al programului, este necesar ca toate variabilele să ﬁe init ,ializate înainte de executa-
rea oricărei operat ,ii din graf, ﬁe independent, ﬁe simultan, prin executarea operat ,iei
tensorflow.global_variables_initializer() (se face apel la funct ,ie deoarece
funct,ia propriu-zisă nu este un obiect init ,ializator, ci o funct ,ie care întoarce un astfel
de obiect). De exemplu, o variantă echivalentă a declarării straturilor convolut ,ionale
speciﬁce pe care am folosit-o în clasa DQNdin modulul DQNeste următoarea:
import tensorflow as tf
with tf.variable_scope('conv3'): # numele variabilelor nu au niciun
efect practic asupra grafului computational, dar sunt utile pentru
identificarea lor ulterioara; un scop de variabile cu nume va
prefixa toate numele variabilelor din scop cu sirul respectiv de
caractere si un separator
w = tf.Variable(tf.truncated_normal([8,8,4,32], stddev=0.01),
trainable=True, name='w') # "tf.truncated_normal" este o
functie de initializare, in cazul acesta, o functie care
initializeaza aleator variabila de ponderi cu valori
esantionate dintr-o distributie normala trunchiata de deviatie
standard 0.01 si medie 0
b = tf.Variable(tf.fill([32], 0.1), trainable=True, name='b') #
"tf.fill" va initializa toate valorile variabilei b ("bias")
cu 0.1
a = tf.nn.relu(tf.nn.conv2d(input=x, filter=w, strides=[1,4,4,1],
padding='VALID') + b, name='a') # "tf.nn.conv2d" aplica
operatia de convolutie, folosind variabila de ponderi data de
w; "strides" specifica marimea pasului convolutiei (aici, 4 pe
orizontala si 4 pe verticala), iar parametrul de "padding"
specifica modul in care trebuie tratate randurile si coloanele
ramase la sfarsitul convolutiei, atunci cand aceasta nu se
potriveste perfect pe dimensiunea datelor de intrare; in plus,
"tf.relu", functia de activare in acest caz, reprezinta
operatia de unitate lineara rectificata si calculeaza max(0,
input)
Pentruamodularizaimplementareaalgoritmilor,amoptatpentrudeﬁnireas ,iutilizarea
unei funct ,ii Python auxiliare care să elimine repetit ,iile din program (de exemplu, în
cazul algoritmului propus pentru învăt ,area unui singur joc, declararea ret ,elei presupune
declararea a trei astfel de straturi, deci repetarea aceloras ,i patru linii de cod de trei
ori cu foarte put ,ine modiﬁcări de la un strat la altul) s ,i am utilizat aceeas ,i funct ,ie în
implementarea straturilor neuronale obis ,nuite (cel ﬁnal s ,i penultimul).
87

Capitolul 5. Tehnologii Folosite
În vederea implementării optimizării propriu-zise a ret ,elei neuronale prin interme-
diul algoritmului de coborâre pe gradient, librăria automatizează calculul gradient ,ilor s,i
actualizarea operat ,iilor prin clasa Optimizer s,i clasele derivate din aceasta. Ca atare,
ajunge furnizarea unei funct ,ii de cost pe care obiectul de optimizare să o minimizeze
automat printr-o operat ,ie aparent unitară. Des ,i inﬂexibilă, având în vedere popularita-
tea algoritmului de coborâre pe gradient (care nu este sigurul algoritm de optimizare
furnizat de Tensorﬂow), librăria cuprinde majoritatea cazurilor de utilizare s ,i, deci, îi
permite programatorului să evite reimplementarea a multor aspecte repetitive în proiec-
tarea solut ,iilor de învăt ,are automată. Iar dacă este nevoie de un algoritm de optimizare
particular, sau dacă utilizatorul vrea să folosească o funct ,ie pentru care derivata în forma
sa simbolică nu este deja implementată în Tensorﬂow, natura modulară a librăriei per-
mite extinderea claselor s ,i modulelor deja existente. În particular, pentru funct ,ia de
cost s ,i pentru optimizare am folosit funct ,iatensorflow.losses.huber_loss s,i, res-
pectiv,clasa tensorflow.train.RMSPropOptimizer derivatădinsuper-clasaabstractă
tensorflow.train.Optimizer . Singuriiparametriobligatoriiaifunct ,ieihuber_loss
suntlabelss,ipredictions ,caresemniﬁcăvalorile"t ,intă"furnizate(nodurideintrare,
semniﬁcă valorile funct ,iei de valoare-act ,iune calculate utilizând ponderile modelului
t,intă), respectiv valorile funct ,iei de valoare-act ,iune calculate folosind ponderile ret ,elei
actuale. Funct ,ia este implementată, în rest, conform deﬁnit ,iei, cu ment ,iunea că aplică
o însumare asupra costurilor individuale obt ,inute pentru exemplele de intrare pentru a
obt,ine costul total scalar rezultat, ci nu o mediere. Clasa RMSPropOptimizer acceptă
un singur parametru obligatoriu: learning_rate , sau rata de învăt ,are, a cărui valoare
este0:00025,conformalgoritmuluipropus. Clasaimplementează,astfel,algoritmulRM-
SProp, o variantă îmbunătăt ,ită a algoritmului de coborâre stocastică pe gradient, care
converge mai repede s ,i mai stabil la minimul global al funct ,iei de cost. Pentru toate
acestea sunt de ajuns următoarele trei linii de cod:
loss = tf.huber_loss(y, t) # unde y reprezinta nodul computational
asociat stratului final al retelei, iar t reprezinta valorile de
intrare pentru valorile "tinta"
optimizer = tf.train.RMSPropOptimizer(learning_rate=0.00025)
train_step = optimizer.minimize(loss) # in continuare, evaluarea nodului
"train_step" oriunde altundeva in program cu datele de intrare
88

5.3. Tensorﬂow
necesare va antrena reteaua o iteratie a algoritmului de coborare pe
gradient
Amimplementatmodelul"t ,intă"prinintermediuloperat ,ieideatribuire tensorflow.assign ,
care acceptă ca parametri un nod al grafului s ,i o valoare sau un alt nod al aceluias ,ii graf.
Atunci când este executată, operat ,ia declans ,ează atribuirea valorii respective în cazul
valorilor constante, sau atribuirea valorii curente a variabilei sursă, variabilei destinat ,ie.
Astfel,clonândnodurilegrafuluiret ,elei,transformândret ,eauaclonatăîntr-oformăimua-
bilă(prindeclarareanoduriloreicuvaloarefalsăpentruparametrul trainable ),s,icreând
câte o operat ,ie de atribuire pentru ﬁecare pondere, am obt ,inut nis ,te operat ,ii Tensorﬂow
prin evaluarea cărora se efectuează actualizarea valorilor ponderilor modelului "t ,intă".
Am sincronizat variabilele clonate cu cele originale prin utilizarea unor scopuri de nume
de variabile clare s ,i prin atribuirea unui nume unic ﬁecărei variabile:
target_update_ops = []
trainable_vars = tf.trainable_variables() # se obtine o lista cu toate
variabilele antrenabile ale grafului
global_vars = tf.global_variables() # se obtine o lista cu toate
variabilele grafului
for i in range(len(trainable_vars)):
match = list(filter(lambda var: var is not trainable_vars[i] and
var.name.split('/')[1:] == trainable_vars[i].name.split('/')[1:],
global_vars))[0] # aceasta linie cauta dupa nume in lista
variabilelor globale variabila clonata dupa cea curenta
target_update_ops.append(tf.assign(match, trainable_vars[i]))
Am inclus toată conﬁgurat ,ia modelului în clasa DQN, din modulul DQN, oferind la ex-
teriormetodeneambiguedeutilizareaacestuia. Deexemplu,ometodăcareas ,teaptăstări
caparametrudeintrares ,iîntoarcevalorilefunct ,ieivaloare-act ,iunepentruﬁecareact ,iune,
pentru ﬁecare stare de intrare. În exteriorul clasei, apelul la funct ,ie este unul intuitiv:
se apelează model.predict(states) . Am procedat analog pentru ﬁecare utilizare a
modelului, de la antrenare până la funct ,iile de mentenant ,ă (salvare/încărcare, utilizând
tensorflow.train.Saver ). În cazul consolidării ponderilor elastice, am creat o clasă
nouă distinctă de DQN, modiﬁcată astfel încât să ia în calcul existent ,a a mai multor seturi
de variabile de "bias" s ,i "gain", metode noi pentru calcularea s ,i actualizarea matricilor
Fisher s ,i funct ,ia nouă de cost, care include s ,i penalizarea EWC. Nu am implementat
89

Capitolul 5. Tehnologii Folosite
metodele necesare determinării automate a sarcinii, ci am realizat acest lucru explicit la
apel, păstrând o stare a procesului de antrenare:
# Definirea operatiilor asociate functiei de cost cu penalizarea EWC
# Se poate extinde usor la antrenarea pe mai mult de 2 sarcini simultan
previous_task_weights = [tf.placeholder(v.dtype, v.get_shape()) for v in
self.trainable_weights] # nod de intrare pentru ponderile sarcinii
anterioare
fisher = [tf.placeholder(v.dtype, v.get_shape().as_list()) for v in
self.trainable_weights] # nod de intrare pentru matricile Fisher
calculate la schimbarea sarcinii
y_a, y_a_ = [], []
loss, EWC_loss = [], []
for i in range(num_tasks): # "num_tasks" reprezinta numarul de sarcini
with tf.variable_scope('task_%d' % (i)):
y_a.append(tf.multiply(y[i], a))
y_a_.append(tf.multiply(y_[i], a))
loss.append(tf.losses.huber_loss(t, y_a[i])) # functia de cost
obisnuita pentru sarcina cu indicele i
EWC_loss.append(0)
for j, var in enumerate(trainable_weights):
EWC_loss[i] += tf.reduce_sum(tf.multiply(tf.cast(fisher[j],
tf.float32), tf.square(var – previous_task_weights[j])))
EWC_loss[i] *= lbd / 2.0 # lbd este parametrul lambda
final_loss = [loss[i] + EWC_loss[i] for i in range(num_tasks)] # toate
acestea sunt operatii, iar "+" este automat tradus de catre
Tensorflow, prin suprascriere de operatori, in operatie de adunare
element cu element; final_loss va reprezenta o lista de operatii
evaluabile
5.4 Arcade Learning Environment
În cazul jocurilor pentru consola Atari 2600, am utilizat librăria "Arcade Learning
Environment", construită peste emulatorul Stella [18]. Ea permite interact ,ionarea cu
emulatorul printr-o interfat ,ă care respectă formalizarea proceselor de decizie Markov,
astfel că jocurile nu rulează în timp real, ci avansează cu câte un cadru la ﬁecare apel
al funct ,ieiactdin clasa ALEInterface , care întoarce o răsplată. Clasa principală a
librăriei, ALEInterface ,puneladispozit ,ietoatefunct ,iilenecesaredezvoltăriiunuiagent,
ﬁe determinist, ﬁe antrenat prin algoritmi de învăt ,are ranforsată automată (de exemplu,
getScreenRGB pentru obt ,inerea imaginii actuale a emulatorului, reset_game pentru
90

5.5. Pygame
gestiunea episoadelor, getLegalActionSet pentru obt ,inerea listei cu act ,iunile permise
s,i multe altele). Librăria prezintă multiple avantaje, dintre care cele mai relevante:
•speciﬁcat ,ia orientată pe obiecte, care suportă adăugarea de jocuri s ,i agent ,i noi
•decuplarea emulatorului de bază de modulele de aﬁs ,are s,i de generare a sunetelor,
pentru a minimiza dependent ,ele librăriei (emulatorul s ,i, deci, librăria pot rula
în continuare chiar s ,i pe platforme care nu dispun de interfet ,e graﬁce, sau de
componente de redare a sunetului)
•extract ,ia automată a scorului din jocuri s ,i detect ,ia automată a ﬁnalului ﬁecărui joc
dintr-o gamă variată de jocuri pentru consola Atari 2600
Pentru a utiliza ALE, este nevoie de obt ,inerea manuală a jocurilor sub formă de
ﬁs,ierebinares ,ifurnizarealorinterfet ,ei. UnexempluagentaleatorpejoculBreakoutarﬁ
următorul:
import random
from ale_python_interface import ALEInterface
env = ALEInterface()
env.loadROM('breakout.bin')
action_set = env.getLegalActionSet()
total_reward = 0
while not env.game_over():
a = random.sample(action_set, 1)[0]
total_reward += env.act(a)
print(total_reward)
Încontextulproiectuluiamconstruitoclasăs ,iunmodul-ﬁs ,iereponim Environment ,
prin care să gestionez prelucrarea imaginilor (reducerea dimensiunii lor s ,i reducerea
spat,iului culorilor la alb-negru) s ,i procesarea act ,iunilor în cazul în care se "sar" cadre
consecutive (lucru pe care librăria nu îl suportă inerent).
5.5 Pygame
Pygame este o librărie de module dezvoltate cu scopul de a us ,ura implementarea
jocurilorpecalculatorînlimbajulPython[21]. Astfel,Pygamefurnizeazămetodes ,iclase
convenabiledenivelînaltcareapeleazăsubrutinedenivelmaijospentruarandas ,idesena
91

Capitolul 5. Tehnologii Folosite
peecranformegeometrices ,iimaginis ,ipentruaredasunete. JocurilerealizateînPython
rulează, teoretic, pe orice platformă rulează s ,i interpretorul Python s ,i submodulele de
nivel scăzut necesare librăriei, ﬁind posibilă chiar proiectarea jocurilor pentru platforma
de telefoane mobile Android.
Construit peste librăria SDL ("Simple DirectMedia Layer"), o librărie menită să izo-
leze implementarea solut ,iilor multimedia (sunet, video) de platforma pe care acestea
rulează, Pygame adaugă acesteia operat ,ii vectoriale, detect ,ie de coliziuni, gestiunea ima-
ginilor (denumite tradit ,ional "sprites" în contextul jocurilor pe calculator), suport MIDI,
transformări geometrice, suport avansat pentru fonturi de tip "freetype" s ,i altele. Astfel,
Pygame permite programarea de jocuri în timp real suﬁcient de performante încât să nu
ﬁe nevoie de a apela la limbaje de programare de nivel mai jos, compromit ,ând neglijabil
performant ,a în schimbul avantajelor pe care le are un limbaj ca Python.
Dezvoltarea unui joc funct ,ional în pygame presupune următorii pas ,i:
1. Init ,ializarea librăriei, ﬁe explicită prin init ,ializarea ﬁecărei componente în parte
(în cazul în care se dores ,te utilizarea exclusivă a anumitor componente, de exem-
plu a modulului video) prin apelarea funct ,ieiinitdisponibilă în ﬁecare sub-
modul init ,ializabil, ﬁe implicită a tuturor componentelor prin apelarea metodei
pygame.init .
2. Declararea s ,i ment ,inerea unei variabile asociate ecranului de joc, pe care vor ﬁ
desenateulteriorobiectelejocului,prinutilizareasubmodulului pygame.display .
Acesta este pasul la care ecranul de joc este creat propriu-zis în cadrul sistemului
de operare. Tot aici se speciﬁcă s ,i dimensiunea ecranului, dacă ocupă tot ecranul
(eng. "fullscreen") sau dacă trebuie reprezentat ca o aplicat ,ie graﬁcă obis ,nuită, la
dimensiunile reale (eng. "windowed"), în cazul din urmă, ce operat ,ii sunt permise
asupra acestuia (redimensionare, minimizare, maximizare, închidere) etc.
3. Încărcareaimaginilors ,isunetelorjoculuiacoloundeestenecesar,prinintermediul
submodulului pygame.image ,maiexactprinintermediulfunct ,ieipygame.image.load ,
respectiv al submodulului pygame.mixer , mai exact prin intermediul funct ,iei
pygame.mixer.load . Acesta este un moment propice pentru preprocesarea ima-
ginilor, acolo unde este nevoie, de exemplu prin redimensionarea lor, sau prin co-
92

5.5. Pygame
municarealibrărieiPythonaculoriireprezentativepentrutransparent ,ăînimaginile
carenucont ,inuncanalspecializatalfapentruacestlucrus ,icaretrebuiesăutilizeze
o culoare în spat ,iul culorilor RGB pentru a semnala pixelii complet transparent ,i.
De asemenea, în cazul muzicii de fundal sau al sunetelor constante, acestea se pot
redalapasulacestaprinintermediulfunct ,ieipygame.mixer.Sound.play ,apelată
asupra unui obiect pygame.mixer.Sound încărcat în memorie, speciﬁcând para-
metrul loops=-1 pentru a determina redarea sa ciclică până la terminarea jocului
sau oprirea sa explicită. Se continuă cu pasul 4, care reprezintă începutul ciclului
principal al jocului. Ciclul principal al jocului continuă atât timp cât jocul nu este
întrerupt explicit drept rezultat al îndeplinirii unei condit ,ii de joc.
4. Parsarea evenimentelor de joc aﬂate în coada de evenimente implicită a librăriei,
care poate ﬁ obt ,inută prin apelarea funct ,ieipygame.event.get . Fiecare eve-
niment din coadă, amplasat în coadă ﬁe explicit de către utilizator, ﬁe implicit
de către Pygame, este o instant ,ă a clasei pygame.Event (sau a unei clase care o
mos,tenes,te pe aceasta) s ,i dispune cel put ,in de atributul type, folosit pentru a dis-
tinge între diversele tipuri de evenimente. Un tip de evenimente important dintre
cele pre-deﬁnite de către librărie, s ,i obligatoriu în vederea respectării as ,teptărilor
utilizatorului legate de funct ,ionalitatea unei aplicat ,ii graﬁce în sistemul de ope-
rare,este pygame.QUIT :evenimenteledetip pygame.QUIT sedeclans ,eazăimplicit
la apăsarea butonului de închidere din decorat ,iile ecranului în cadrul interfet ,ei
graﬁce a sistemului de operare. Astfel, se recomandă trecerea imediată la pa-
sul 8 în cazul în care acest eveniment este întâlnit în coada de evenimente a jo-
cului. Tot aici se pot întâlni evenimente legate de începerea apăsării sau înce-
tarea apăsării tastelor ( pygame.KEYDOWN , respectiv pygame.KEYUP ), evenimente
legatedemis ,cărialemausului( pygame.MOUSEMOTION ,pygame.MOUSEBUTTONUP ,
pygame.MOUSEBUTTONDOWN ),evenimentelegatederedimensionareaecranului(pen-
tru a permite gestionarea imaginilor obiectelor jocului, care nu mai corespund
dimensiuniiinit ,ialeaecranuluiînurmaredimensionării),evenimentelegatedeuti-
lizareaunui"joystick"s ,ialtele. Toateevenimenteleîncapsulează,pelângătipulsău,
informat ,ii esent ,iale legate de evenimentul respectiv; de exemplu, tasta apăsată în
93

Capitolul 5. Tehnologii Folosite
cazulevenimentuluispeciﬁcapăsăriiuneitaste. Totaiciseparseazăs ,ievenimentele
amplasateexplicitîncoadădecătreutilizator,alcărorscoparputeaﬁ,deexemplu,
interpretarea "mort ,ii" unuia dintre jucători, sau gestionarea consecint ,elor ciocni-
rii dintre un proiectil s ,i un jucător. Izolarea logicii jocului de restul pas ,ilor prin
utilizarea evenimentelor produce un mediu interactiv identic, dar creează avantajul
modularizăriiprogramuluis ,i,deci,îmbunătăt ,es,tescalabilitateas ,iﬂexibilitateaaces-
tuia. În plus, gestionarea evenimentelor poate reprezenta un moment bun în ciclul
joculuideredareaefectelorspecialesonore(deexemplu,pentrucândunjucătoreste
lovit de un proiectil), prin apelarea aceleias ,i funct ,iipygame.mixer.Sound.play
asupra unui ﬁs ,ier de sunet încărcat în memorie la pasul precedent.
5. Gestionareacomponentelorhardwaredeintrareîncazulîncarenus-arealizatdeja
acest lucru la pasul anterior: tastatura, mausul, microfonul, camera etc. Se poate
accesa listă de taste apăsate la un moment de timp în joc prin apelarea funct ,iei
pygame.key.get_pressed , care întoarce o listă în care valoarea de adevăr a
tuturortastelorapăsatelamomentulgenerăriilisteiesteadevărată,ﬁindfalsăînrest,
astfel că se poate veriﬁca starea de apăsare a unor taste speciﬁce prin veriﬁcarea
valorii de adevăr a tastelor respective în listă. Gestionarea intrărilor, ﬁe la pasul de
gestiune a evenimentelor, ﬁe aici, constituie o condit ,ie necesară pe care o aplicat ,ie
multimedia trebuie să o îndeplinească pentru a putea ﬁ considerată joc.
6. Opt ,ional, se pot gestiona coliziunile între obiecte. Acest pas depinde în mare
parte de jocul speciﬁc implementat s ,i de informat ,iile pe care le are programatorul
despre obiectele de joc (pozit ,ia, forma s ,i dimensiunea ﬁind obligatorii în vederea
determinării coliziunilor dintre mai multe obiecte).
7. Sereprezintăobiecteledejocpeecran. Acestpasjoacărolulimportantdefurnizare
a răspunsului utilizatorului în mediul interactiv, s ,i prezent ,a sa în ciclul principal al
jocului este s ,i ea o condit ,ie necesară al aspectului interactiv al deﬁnit ,iei jocului.
Librăria Pygame pune la dispozit ,ie mai multe obiecte în aceste sens, dar esent ,iale
suntobiecteledetipsuprafat ,ă(clasa pygame.Surface ). Pesuprafet ,esepotdesena
obiectegeometrice( pygame.Rect ),culori(prinspeciﬁcareaculoriiînformatRGB,
de exemplu (255;0;0)pentru ros ,u), sau alte suprafet ,e, prin intermediul metodelor
94

5.5. Pygame
pygame.Surface.blit , care as ,teaptă ca parametri o suprafat ,ă s,i o locat ,ie, de-
senând suprafat ,a dată ca parametru începând cu colt ,ul din stânga sus de la locat ,ia
speciﬁcată peste suprafat ,a pe care este apelată, s ,ipygame.Surface.fill , care
desenează peste tot ,i pixelii suprafet ,ei, pixeli de o aceeas ,i culoare speciﬁcată. La
sfârs,it, toate suprafet ,ele sunt desenate pe ecranul de joc, într-o formă sau alta (ﬁe
direct, ﬁe prin desenarea lor pe o suprafat ,ă care este apoi desenată pe ecranul de
joc), s ,i este apelată metoda pygame.display.update pentru a îns ,tiint,a jocul de
actualizarea suprafet ,ei de joc. Nu există conceptul de "s ,tergere" de pe o suprafat ,ă
a unor pixeli, ﬁind necesară suprascrierea respectivilor pixeli la ﬁecare pas de de-
senareîncazulîncaresedores ,teeliminarealor. Serecomandăumplereaecranului
de joc cu o suprafat ,ă de fundal, pre-încărcată la pasul 3, la ﬁecare astfel pas de
desenare. În continuare, se revine la pasul 4.
8. Seîncheiejoculpropriu-ziss ,iserevinelaprogramcuscopuldearealizaprocesări
ulterioare de date. Până la eliberarea automată a memoriei variabilelor jocului de
către sistemul de gestiune automată a memoriei a interpretorului Python sau până
laapelareaexplicităametodei pygame.quit ,toatecomponentelejocului(ecranul,
mixerulaudio)vorrămâneconectatelasistemuldeoperare(deexemplu,ecranulva
rămâne deschis).
Pentruament ,ineolimităsuperioarăacadrelorcarepotﬁaﬁs ,ateînﬁecaresecundăde
joc,încazuljocuriloralcărorlogicădepindedecadre,cinudetimpulpropriu-zisderulat
între acestea (de exemplu, acest lucru se poate întâmpla atunci când viteza obiectelor de
joc este calculată ca o valoare constantă pe care obiectele de joc le adaugă la vectorii
propriidepozit ,ielaﬁecarecicludejoc;întrucâtnumăruldecicluridejocesteidenticcu
numărul de aﬁs ,ări pe ecran, acesta este un joc al cărei logică depinde în mod direct de
cadre,cinudetimp),seinstant ,iazăclasa pygame.time.Clock pentruaobt ,ineun"ceas"
aljocului. Laﬁecarecicludejoc,semaiadaugăunapelasupraobiectuluiceaslaunadin-
tremetodele pygame.time.Clock.tick saupygame.time.Clock.tick_busy_loop ,
ambele acceptând ca unic parametru obligatoriu numărul maxim de cadre permise a ﬁ
aﬁs,atedecătrejocîntr-osecundă. Ambelemetodeasigură,cuomarjădeeroare,atingerea
acestui număr dat de cadre, prin adăugarea de apeluri "inutile" de o durată medie care să
95

Capitolul 5. Tehnologii Folosite
compenseze pentru ﬁecare ciclu de joc cu timpul necesar atingerii duratei sale medii în
milisecunde. Deexemplu,pentruatingereauneiratedeaﬁs ,arede60decadrepesecundă,
obiectul ceas va adăuga operat ,ii artiﬁciale (de exemplu, time.sleep sau instruct ,iuni de
ciclaregoale)pentruaasiguraoduratăaproximativăde 16:(6)milisecundepentruﬁecare
ciclu de joc (chiar s ,i atunci când un ciclu de joc ar dura mai put ,in).
AmoptatpentruPygameînvedereaimplementăriituturorjocurilorpersonaleprezen-
tate anterior. Astfel, am utilizat câte un modul-ﬁs ,ier pentru ﬁecare joc în parte, deﬁnind
în ﬁecare o clasă care să cont ,ină starea jocului propriu-zis s ,i alte clase ajutătoare. De
asemenea, ﬁecare joc include o clasă internă pentru gestionarea modelului de învăt ,are
automată, care tratează jocurile asemenea emulatorului pentru consola Atari 2600, in-
terpretând starea curentă s ,i luând câte o decizie la ﬁecare ciclu de joc. Des ,i inclus în
programuljocurilor,modelulnuareacceslaalteinformat ,iilegatedeacestas ,iînvat ,ăs,iia
decizii, ca s ,i în cazul jocurilor pentru consola Atari, strict pe baza imaginilor jocurilor;
el este inclus astfel strict pentru a us ,ura s,i eﬁcientiza comunicarea cu intefet ,ele jocurilor.
Înplus,ammaiinclusoclasăsecundarăpentruﬁecarejoc,denumităuniform Unit,care
să reprezinte starea unei unităt ,i de joc, cu atributele s ,i metodele ei speciﬁce, s ,i alte clase
auxiliare ajutătoare în ment ,inerea s ,i deﬁnirea modulară a stării jocului, evenimentelor
particulare jocului etc. Am implementat ﬁecare dintre jocuri ca ﬁind dependente de rata
de aﬁs ,are, ci nu de timp. Aproape pentru ﬁecare dintre pas ,ii ment ,ionat,i anterior, am
implementat o metodă separată, s ,i, în plus, o metodă pentru ciclul de joc propriu-zis. De
exemplu, funct ,ia de gestiune a evenimentelor pentru jocul Spaceships din cadrul clasei
Spaceships este următoarea:
def _manage_events(self):
if self.frames >= 30 * self.framerate: # odata atins pragul de 30 de
secunde, ambii jucatori incep sa piarda din viata disponibila
self.player1.hp -= 1
self.player2.hp -= 1
self.AI.notify_reward(Unit.Roles.PLAYER1, -1)
self.AI.notify_reward(Unit.Roles.PLAYER2, -1) # obiectul AI este o
instanta a clasei SpaceshipsAI, care inglobeaza starea
sistemului de invatare automata pentru acest joc
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.state = Spaceships.States.QUIT
96

5.5. Pygame
elif event.type == Spaceships.Events.PLAYER_DEATH:
self._finish_game()
self.AI.notify_terminal(self.get_screen())
elif event.type == pygame.KEYUP:
if event.key == self.player1.keys[Unit.Keys.FIRE]:
self.player1.fired = 0
if event.key == self.player2.keys[Unit.Keys.FIRE]:
self.player2.fired = 0 # necesare pentru gestionarea
focului automat al navelor (care este mai incet decat
focul manual)
Pentru implementarea jucătorului automat determinist sau pseudo-determinist nu am
folosit vreo librărie externă, ci doar starea jocului, a obiectelor, s ,i algoritmii prezentat ,i
anterior. Amalessădezvoltjucătoriideterminis ,tiastfelîncâtsăimiteinterfat ,amodelului
deînvăt ,areautomatăcucareinteract ,ioneazăjocul,pentruarescriecâtmaiput ,inmetodele
deja implementate pentru cazul respectiv.
Învedereareprezentăriivizualeaanimat ,ilor,amfolositceeacesenumes ,teîndomeniul
dezvoltăriijocurilorpecalculator"bitstrip",oimagine,deobiceidetip"bitmap"(extensia
.bmp) sau PNG (extensia .png), care cont ,ine cadrele animat ,iei concatenate (de obicei
pe orizontală), s ,i din care se extrage în timpul jocului, la ﬁecare pas al redării animat ,iei,
cadrul necesar. Astfel, în locul încărcării unei singure imagini pentru ﬁecare obiect
de joc, am încărcat în memorie, în cazul jocului Spaceships, un ﬁs ,ier de tip "bitstrip"
care se gestionează intern singur prin intermediul unei clase auxiliare, s ,i asupra căruia
funct,ia de actualizare a ecranului să poată apela o metodă pentru a obt ,ine imaginea
actuală a obiectului la ﬁecare moment de timp. De exemplu, pentru pasul de desenare
a suprafet ,elor, în cadrul aceluias ,i joc, am folosit următoarele funct ,ii în interiorul clasei
Spaceships :
def _blit_unit(self, surface, unit):
image = pygame.transform.rotate(unit.anims[unit.moving].next(),
(unit.rotation – np.pi/2).in_degrees())
rect = image.get_rect()
rect.center = tuple(unit.center)
surface.blit(image, rect)
def _render(self):
self.game_screen.blit(self.background, (0, 0))
for projectile in self.projectiles:
self._blit_unit(self.game_screen, projectile)
97

Capitolul 5. Tehnologii Folosite
if self.player1.alive():
self._blit_unit(self.game_screen, self.player1)
if self.player2.alive():
self._blit_unit(self.game_screen, self.player2)
for i in xrange(len(self.explosions) – 1, -1, -1):
try:
image = pygame.transform.rotate(self.explosions[i][0].next(),
(self.explosions[i][2] – np.pi/2).in_degrees())
rect = image.get_rect()
rect.center = tuple(self.explosions[i][1])
self.game_screen.blit(image, rect)
except StopIteration:
del self.explosions[i]
if self.args.debug:
self._render_debug()
self.score_screen.fill((0,0,0))
self.score_screen.blit(self.player1_tag, self.player1_tag_pos)
pygame.draw.rect(self.score_screen, (0, 200, 0),
[self.player1_hp_pos[0], self.player1_hp_pos[1], 1.0 *
self.player1.hp / Unit.DEFAULT_HP * self.hp_full_length,
self.hp_full_height])
self.score_screen.blit(self.player2_tag, self.player2_tag_pos)
pygame.draw.rect(self.score_screen, (0, 200, 0),
[self.player2_hp_pos[0] – 1.0 * self.player2.hp / Unit.DEFAULT_HP
* self.hp_full_length, self.player2_hp_pos[1], 1.0 *
self.player2.hp / Unit.DEFAULT_HP * self.hp_full_length,
self.hp_full_height])
self.display.blit(self.score_screen, (0, 0))
self.display.blit(self.game_screen, (0, self.score_height))
pygame.display.update()
În ﬁnal, funct ,ia pentru ciclul principal de joc în Spaceships este următoarea:
def start(self):
self._init_sprites()
self._init_units()
self._init_game()
self._render()
self.AI.notify_game_start(self.get_screen())
self.state = Spaceships.States.PLAYING
while self.state != Spaceships.States.QUIT and \
self.state != Spaceships.States.FINISHED:
self._manage_events()
self._manage_input()
self._manage_collisions()
self._render()
self.frames += 1
98

5.6. Shapely
if not self.args.training:
self.clock.tick_busy_loop(self.framerate)
if self.state == Spaceships.States.FINISHED:
self.AI.notify_game_end()
5.6 Shapely
Shapelyesteolibrăriepentruanalizareas ,imanipulareaobiectelorgeometriceînplan
cartezian[22]. AmutilizatlibrăriaînvederearealizăriijoculuiSpaceships,undeamavut
nevoie de rotat ,ii de poligoane s ,i de coliziuni între poligoane. Shapely pune la îndemâna
programatorului astfel de clase s ,i metode eﬁcient implementate, de la transformări aﬁne
ca translat ,ia, rotat ,ia, scalarea, până la calculul intersect ,iei între două obiecte geometrice
oarecare,aldiferent ,ei,calcululfrontiereiunuiobiectgeometricetc. s ,ideasemenea,clase
pentru o multitudine de obiecte geometrice, de la puncte s ,i linii până la poligoane. Ca
atare, librăria mi-a fost de folos în mod extins în implementarea acestor aspecte. De
exemplu,metodadinclasa Unitdestinatăobt ,ineriipoligonuluidecoliziunealobiectului,
în pozit ,ia sa curentă s ,i cu rotat ,ia sa curentă, este următoarea:
def get_collision_box(self):
cb = self.collision_box # poligonul cu coltul in (0,0)
c = cb.centroid.coords[0] # coordonatele centrului poligonului
cb = shapely.affinity.translate(cb, *tuple(self.center – c)) #
translateaza poligonul astfel incat sa aiba centrul in centrul
obiectului
cb = shapely.affinity.rotate(cb, -self.rotation.in_degrees()) #
roteste poligonul fata de centrul sau conform rotatiei obiectului
return cb
Pentru instant ,ierea unui poligon nu este nevoie de mai mult decât de speciﬁcarea
punctelor sale:
collision_box = shapely.geometry.Polygon([(0, 0), (size.y, 0), (size.y,
size.x), (0, size.x)])
99

Capitolul 6
Concluzii
Înaceastălucrare,amabordatmultiplesolut ,iipentruproblemapropusă,atâtprinexpe-
rimenteclasiceîndomeniu(jocurileAtari),câts ,iprinexperimenteasupraunorjocuride2
participant ,iimplementatepersonal,carepunelaîncercarealgoritmulpropusîncontextul
învăt,ării oglindite. Am observat posibilele dezavantaje ale metodei propuse s ,i diﬁculta-
tea empirică a antrenării unor astfel de agent ,i inteligent ,i prin intermediul tehnologiilor
disponibile la momentul actual, atât din punct de vedere al resurselor (timpul, resursele
hardware), cât s ,i din punct de vedere al depistării problemelor în cazul experimentelor
nereus ,ite. De asemenea, în vederea aplicabilităt ,ii, solut ,iile necesită un mediu de lucru
specializat s ,i este diﬁcilă transportarea s ,i executarea acestora în contexte oarecare (de
exemplu, în browser), atât datorită resurselor hardware necesare rulării cât s ,i diﬁcultăt ,ii
corelăriiacestoracujocuridigitalecareruleazăîntimprealînafaracontroluluilor,deciîn
contexteîncarepotapăreaproblemedecomunicareîntreprocese,problemedeîntârziere
a răspunsului (în jocurile în care react ,iile rapide constituie o obligat ,ie pentru a reus ,i).
Totodată, algoritmul propus prezintă diﬁcultăt ,i în adaptarea la alterarea sau evoluarea
obiectelor de joc s ,i/sau a regulilor (de exemplu, drept rezultat al avansării la un alt nivel
sau drept rezultat al pătrunderii într-o încăpere etc.). În ciuda acestor dezavantaje, algo-
ritmul reprezintă un prim pas într-o direct ,ie promit ,ătoare, astfel că solut ,iile dezvoltate în
domeniulagent ,ilorinteligent ,ipentrujocuripecalculator(s ,ichiarîncelalproblemelorde
învăt,areranforsatăasarcinilorrealeprinsimulări)continuă,înprimulrând,săsedezvolte
solut,iipentruagent ,iantrenat ,ipebazaimaginilor(cinuaaltorinformat ,iimaispecializate),
100

iarînaldoilearând,continuăsăsedezvoltesolut ,iilabazacărorastăexplicitacestalgoritm
deaproximareafunct ,ieidevaloare-act ,iuneoptimăprocesuluidedecizieMarkovasociat.
De exemplu, lucrarea recentă "World Models" [23], în care autorul propune utilizarea
unui model generator care să învet ,e o reprezentare simpliﬁcată a unui joc, putând genera
ulterior stări ale acestuia, simulând jocul respectiv. Astfel, ret ,eaua poate ﬁ antrenată pe
jocul simulat, având în plus informat ,ii "reale" (în contextul asemănării dintre simulare s ,i
joc) legate de răsplăt ,ile viitoare (deci eliminând dependent ,a de ponderile proprii în acest
sens s ,i sporirea stabilităt ,ii), fără a compromite semniﬁcativ spat ,iul experient ,elor jocului.
Alt exemplu îl constituie colaborarea dintre DeepMind s ,i Blizzard Entertainment pentru
realizarea unui model de învăt ,are ranforsată pe bază de imagini care să învet ,e să joace
jocul Starcraft 2 la un nivel competitiv, prin intermediul unei speciﬁcat ,ii simpliﬁcate
a imaginilor jocului (prin înlocuirea unităt ,ilor cu o reprezentare vizuală simpliﬁcată a
acestora) [24].
101

Bibliograﬁe
[1] Robert B. Ash. Basic Probability Theory , Dover ed., 1970
[2]http://civile.utcb.ro/curs/master/probabilitati.pdf
[3] IanGoodfellow,YoshuaBengio,AaronCourville. Deep Learning ,MITPress,2016
(http://www.deeplearningbook.org )
[4] Michael A. Nielsen. Neural Networks and Deep Learning , Determination Press,
2015 ( http://neuralnetworksanddeeplearning.com )
[5] Richard S. Sutton, Andrew G. Barto. Reinforcement Learning: An Introduction ,
MIT Press, 2017
[6] Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Anto-
noglou, Daan Wierstra, Martin Riedmiller. Playing Atari with Deep Reinforcement
Learning, 2015 ( https://www.cs.toronto.edu/~vmnih/docs/dqn.pdf )
[7] Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Ve-
ness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland,
Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antono-
glou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, Demis Ha-
ssabis. Human-level control through deep reinforcement learning , 2015 ( https:
//storage.googleapis.com/deepmind-media/dqn/DQNNaturePaper.pdf )
[8] James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume
Desjardins, Andrei A. Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnies-
zka Grabska-Barwinska, Demis Hassabis, Claudia Clopath, Dharshan Kumaran,
102

Bibliograﬁe
and Raia Hadsell. Overcoming catastrophic forgetting in neural networks , 2016
(https://arxiv.org/pdf/1612.00796.pdf )
[9] Szymon Sidor, John Schulman. Articolul OpenAI Baselines: DQN (https://
blog.openai.com/openai-baselines-dqn/ )
[10] https://ansimuz.itch.io/spaceship-shooter-environment
[11] Luis Zuno, website personal: http://ansimuz.com/site/
[12] https://creativecommons.org/licenses/by/4.0/legalcode
[13] https://developer.nvidia.com/cuda-zone
[14] Ardi Tampuu, Tambet Matiisen, Dorian Kodelja, Ilya Kuzovkin, Kristjan Korjus,
Juhan Aru, Jaan Aru, Raul Vicente. Multiagent Cooperation and Competition with
Deep Reinforcement Learning , 2015 ( https://arxiv.org/pdf/1511.08779.
pdf)
[15] Tom Schaul, John Quan, Ioannis Antonoglou and David Silver. Prioritized Expe-
rience Replay , 2016 ( https://arxiv.org/pdf/1511.05952.pdf )
[16] https://en.wikipedia.org/wiki/Python_(programming_language)
[17] https://docs.scipy.org/doc/numpy/about.html
[18] https://github.com/mgbellemare/Arcade-Learning-Environment
[19] https://www.tensorflow.org/api_docs
[20] https://www.tensorflow.org/programmers_guide/low_level_intro
[21] https://www.pygame.org/wiki/about
[22] https://github.com/Toblerity/Shapely
[23] David Ha, Jürgen Schmidhuber. World Models , 2018
[24] DeepMind and Blizzard open StarCraft II as an AI research environment
103

Copyright Notice

© Licențiada.org respectă drepturile de proprietate intelectuală și așteaptă ca toți utilizatorii să facă același lucru. Dacă consideri că un conținut de pe site încalcă drepturile tale de autor, te rugăm să trimiți o notificare DMCA.

Acest articol: Azberatucdetectareplagiatrogmail.com 601 Licenta Tudor Petre Radu (1) [607274] (ID: 607274)

Dacă considerați că acest conținut vă încalcă drepturile de autor, vă rugăm să depuneți o cerere pe pagina noastră Copyright Takedown.

Azberatucdetectareplagiatrogmail.com 601 Licenta Tudor Petre Radu (1) [607274]

Copyright Notice

Licenta Septembrie 2017 Claudia Sterian [608695]

Originea cuvântului cadastru provine din cuvântul grecesc katastikon care înseamnă carte de însemnări și carte de comerț. [309556]

Academia de Științe a Moldovei [619003]

Manole Ana-Maria [308862]

Motor 1,9l TDI cu [600943]

Arta Și Civilizaţia Romei Antice 2014 15 [626781]

Copyright Notice

Similar Posts