Indrumar PLIA2014

UNIVERSITATEA TEHNIC A MOLDOVEI
Facultatea Calculatoare, Informatic i Microelectronic

Catedra Informatic Aplicat
PROGRAMAREA LOGIC I INTELIGENA

ARTIFICIAL
ndrumar de laborator
Chiinu
Editura Tehnica-UTM
2014
ndrumarul de laborator include noiuni introductive i sarcini

practice corespunztoare menite s iniieze studentul, att n domeniul
programrii logice, ct i n domeniul inteligenei artificiale. Tipul
sarcinilor este unul generic, care urmrete reiterarea materialului studiat
prin implementarea metodelor descrise i demonstrate n lucrare. O
caracteristic definitorie a lucrrilor este studiul i analiza detaliat a
ndeplinirii sarcinilor utiliznd limbajul de programare Prolog.
n lucrare sunt elucidate teme care au ca subiect sintaxa unui
limbaj de programare logic i structurile lui de date fundamentale, baze de
cunotine, sisteme expert, reele neuronale i aplicarea lor practic n
recunoaterea imaginilor i a vorbirii.
ndrumarul este destinat studenilor specialitilor Calculatoare
526.1 i Tehnologii Informaionale 526.2 pentru nsuirea disciplinei
Programarea Logic i Inteligena Artificial.
Autori: conf. univ., dr. L. Luchianova

lect.sup. V. Lazu
Redactor responsabil: lect. sup. V. Lazu
Recenzent: conf.univ. L. Carcea
U.T.M., 2014
Cuprins
CAPITOLUL I
LUCRAREA DE LABORATOR nr. 1 ............................................ 5
Introducere n limbajul Prolog
LUCRAREA DE LABORATOR nr. 2 .......................................... 15
Mecanisme de control al procesului de backtracking
Structuri de date n Prolog
CAPITOLUL II
Exemple i probleme n limbajul Prolog ....................................... 30
Sisteme expert
Prelucrarea limbajului natural
Algoritmi de recunoatere
Algoritmi de recunoatere a imaginilor
Reelele neuronale Hamming
Reelele neuronale Hebb
BIBLIOGRAFIE ............................................................................ 92
3
ANEXE .......................................................................................... 93
Anexa 1 .......................................................................................... 93
Mediul GNU Prolog
Anexa 2 ........................................................................................ 100

Codul surs al programului care realizeaz o reea neuronal Hamming n
limbajul de programare C++
Anexa 3 ........................................................................................ 104

Codul surs al programului care realizeaz reeaua neuronal Hamming,
n limbajul de programare C#
CAPITOLUL I
LUCRAREA DE LABORATOR nr. 1
Introducere n limbajul Prolog
Scopul: nsuirea principiilor fundamentale de programare a
limbajului Prolog
PARTEA 1. Noiuni teoretice
1.1. Entitile limbajului Prolog
Prolog este un limbaj logic, descriptiv care permite specificarea
spaiului problemei i a soluiei acesteia, opernd n termeni de fapte
cunoscute despre obiectele universului problemei i ale relaiilor existente
ntre aceste obiecte. Execuia unui program Prolog const n deducerea
implicaiilor dintre aceste fapte i relaii, programul definind astfel o
mulime de consecine ce reprezint nelesul sau semnificaia declarativ
a programului.
Un program Prolog conine urmtoarele entiti:
fapte despre obiecte i relaiile existente ntre aceste
obiecte;
reguli despre obiecte i relaiile dintre acestea care
permit deducerea (inferarea) unor fapte noi n baza celor
cunoscute;
ntrebri, numite i scopuri, despre obiecte i relaiile
acestora, la care programul rspunde n baza faptelor i regulilor
existente.
1.1.1. Fapte
Faptele sunt predicate de ordinul nti de aritate n considerate
adevrate (reprezint cea mai simpl forma de predicat din Prolog). Ele
stabilesc relaiile dintre obiectele universului problemei. Numrul de
argumente ale faptelor este reprezentat prin aritatea corespunztoare a

predicatelor.
Exemple:
Fapt:
Aritate:
cine(grivei).
place(ion, ioana).
place(ion, ana).
frumoas(ana).
bun(daniel).
deplaseaz(cub, camera1, camera2).
Interpretarea particular a predicatului i a argumentelor acestuia

depinde de programator. Ordinea argumentelor este important i odat
fixat trebuie pstrat pentru orice utilizare ulterioar a faptului cu aceeai
semnificaie. Mulimea faptelor i regulilor unui program Prolog formeaz
baza de cunotine Prolog.
1.1.2. Scopuri
Obinerea consecinelor sau a rezultatului unui program Prolog se
face prin stabilirea unor scopuri care n funcie de coninutul bazei de
cunotine pot fi adevrate sau false. Scopurile sunt predicatele pentru
care se dorete aflarea valorii de adevr n contextul faptelor existente ale
unei baze de cunotine. Rezultatul unui program Prolog este rspunsul la
o ntrebare (sau la o mbinare de ntrebri). Acest rspuns poate fi
afirmativ - yes, sau negativ - no. n cazul unui rspuns afirmativ la o
ntrebare, un program Prolog poate furniza n continuare i alte informaii
din baza de cunotine.
Exemplu:
Considernd baza de cunotine specificat anterior, se pot stabili diverse
ntrebri, cum ar fi:
?- place(ion, ioana).
Yes
% deoarece acest fapt exist n baza de cunotine
?- papagal(ion).
No
% deoarece acest fapt nu exist n baza de cunotine
n exemplele prezentate de pn acum, argumentele faptelor i

ntrebrilor au fost obiecte particulare, numite i constante sau atomi
simbolici. Predicatele Prolog (ca i orice predicate n logica cu predicate
de ordinul I), permit argumente n form de obiecte generice, numite
variabile. n mod convenional, n Prolog numele argumentelor variabile
ncep cu majuscul iar numele constantelor simbolice ncep cu minuscul.
O variabil poate fi instaniat (legat) dac exist un obiect asociat
acestei variabile, sau neinstaniat (liber) dac nu se tie nc ce obiect va
desemna variabila.
Iniial, la fixarea unui scop Prolog care conine variabile, acestea
sunt neinstaniate, iar sistemul ncearc satisfacerea acestui scop cutnd
n baza de cunotine un fapt care se poate identifica cu scopul printr-o
instaniere adecvat a variabilelor din scopul dat. Eventual, se deruleaz
un proces de unificare a predicatului - scop cu unul din predicatele - fapte
existente n baza de cunotine. La ncercarea satisfacerii scopului,
cutarea pornete ntotdeauna de la nceputul bazei de cunotine. Dac se
stabilete un fapt cu un simbol predicativ identic cu cel al scopului,
variabilele din scop se instaniaz conform algoritmului de unificare, iar
valorile variabilelor astfel obinute sunt afiate ca rspuns la satisfacerea
acestui scop.
Exemple:
?- ciine(CineEste).
CineEste = bobi
?- deplaseaza(Ce, DeUnde, Unde).
Ce = cub, DeUnde = camera1, Unde = camera2
?- deplaseaza(Ce, Aici, Aici).
No
n cazul n care exist mai multe fapte n baza de cunotine care

se unific cu ntrebarea pus, deci exist mai multe rspunsuri la ntrebare,
ce corespund mai multor soluii ale scopului fixat, limbajul Prolog
procedeaz n felul urmtor: prima soluie rezult din prima unificare i
exist attea soluii cte combinaii de unificri exist. La realizarea
primei unificri este marcat faptul care a unificat i care reprezint prima
soluie. La obinerea urmtoarei soluii, cutarea este reluat de la marcaj,
descendent n baza de cunotine. Obinerea primei soluii este, de regul
numit satisfacerea scopului iar obinerea celorlalte soluii, resatisfacerea
scopului. La satisfacerea unui scop cutarea se face ntotdeauna de la
7
nceputul bazei de cunotine. La resatisfacerea unui scop, cutarea se face

ncepnd de la marcajul stabilit de satisfacerea anterioar a aceluiai scop.
Sistemul Prolog, fiind un sistem interactiv, permite utilizatorului
obinerea fie a primului rspuns, fie a tuturor rspunsurilor. n cazul n
care, dup afiarea tuturor rspunsurilor, un scop nu mai poate fi resatisfcut, sistemul rspunde no.
Exemple:
?- place(ion, X).
X = ioana;
X = ana;
no
1.1.3. Reguli
O regul Prolog exprim un fapt care depinde de alte fapte i are
forma:
S :- S1, S2, Sn.
Fiecare Si, i =1,n i S au forma faptelor Prolog, deci sunt
predicate cu argumente constante, variabile sau structuri. Faptul S care
definete regula se numete antet de regul, iar S1, S2, Sn formeaz
corpul regulii i reprezint conjuncia (unificarea) scopurilor care trebuie
satisfcute pentru satisfacerea ulterioar a antetului regulii.
Fie urmtoarea baz de cunotine Prolog:
Ana este frumoas.
frumoasa(ana).
% Ipoteza 1
Ion este bun.
bun(ion).
% Ipoteza 2
Ion o cunoate pe Maria. cunoaste(ion, maria).
% Ipoteza 3
Ion o cunoate pe Ana. cunoaste(ion, ana).
% Ipoteza 4
Mihai o place pe Maria. place(mihai, maria).
% Ipoteza 5
Dac dou persoane X i Y se cunosc i persoana X este bun i
persoana Y este frumoas, atunci cele dou persoane, X i Y, se plac.
place(X, Y) :- bun(X), cunoaste(X, Y), frumoasa(Y). % Ipoteza 6
Enunul de la ipoteza 6 definete o regul Prolog. Relaia
place(Cine, PeCine) este definit att printr-un fapt (Ipoteza 5), ct i
printr-o regul (Ipoteza 6). n condiiile existenei regulilor n baza de
cunotine Prolog, satisfacerea unui scop se face printr-un procedeu
similar cu cel prezentat n seciunea b), iar unificarea scopului se ncearc
att cu fapte din baza de cunotine, ct i cu antetul regulilor de baz. La
8
unificarea unui scop cu antetul unei reguli, pentru satisfacerea acest scop
trebuie satisfcut i regula. Aceasta, se reduce la satisfacerea tuturor
faptelor din corpul regulii, deci conjuncia scopurilor. Scopurile din corpul
regulii devin subscopuri a cror satisfacere se va ncerca printr-un
mecanism similar cu cel al satisfacerii scopului iniial.
Pentru baza de cunotine descris mai sus, satisfacerea scopului
?- place(ion, ana). se va produce astfel: scopul se unific cu antetul
regulii (6) i duce la instanierea variabilelor din regula (6): X = ion i Y =
ana. Pentru ca acest scop s fie ndeplinit, trebuie ndeplinit regula, deci
fiecare subscop din corpul acesteia. Aceasta revine la ndeplinirea
scopurilor bun(ion), care este satisfcut prin unificare cu faptul (2)
cunoaste(ion, ana), satisfcut prin unificare cu faptul (4) i a scopului
frumoasa(ana), care este satisfcut prin unificare cu faptul (1). n
consecin, regula a fost ndeplinit, deci i ntrebarea iniial este
satisfcut (adevrat), iar sistemul rspunde yes.
n continuare vom observa ce se ntmpl dac se pune ntrebarea:
?- place(X, Y).
Prima soluie a acestui scop este dat de unificarea cu faptul (5),
iar rspunsul este:
X = mihai, Y = maria
Sistemul Prolog va pune un marcaj n dreptul faptului (5) care a
satisfcut scopul. Urmtoarea soluie a scopului place(X, Y) se obine
ncepnd cutarea de la acest marcaj n continuare n baza de cunotine.
Scopul se unific cu antetul regulii (6) i se vor fixa trei noi subscopuri de
ndeplinit, bun(X), cunoaste(X, Y) i frumoasa(Y). Scopul bun(X) este
satisfcut de faptul (2) i variabila X este instaniat cu valoarea ion,
X=ion. Se ncearc apoi satisfacerea scopului cunoaste(ion, Y), care este
satisfcut de faptul (3) i determin instanierea Y = maria. Se introduce
n baza de cunotine un marcaj asociat scopului cunoaste(ion, Y), care a
fost satisfcut de faptul (3). Se ncearc apoi satisfacerea scopului
frumoasa(maria). Acesta eueaz. n acest moment sistemul intr ntr-un
proces de backtracking n care se ncearc resatisfacerea scopului anterior
satisfcut, cunoaste(ion, Y), n sperana c o noua soluie a acestui scop
va putea satisface i scopul curent care a euat, frumoasa(Y). Resatisfacerea scopului cunoaste(ion, Y) se face pornind cutarea de la
marcajul asociat scopului n jos, deci de la faptul (3) n jos. O nou soluie
(resatisfacere) a scopului cunoaste(ion, Y) este dat de faptul (4) care
determin instanierea Y = ana. n acest moment se ncearc satisfacerea
9
scopului frumoasa(ana). Cnd este vorba de un scop , cutarea se face de

la nceputul bazei de cunotine i scopul frumoasa(ana) este satisfcut
de faptul (1). n consecin este obinut a doua soluie a scopului place(X,
Y) i sistemul rspunde: X = ion, Y = ana, urmnd un mecanism de
backtracking, descris intuitiv n Figura 1.1 prin prezentarea arborilor de
deducie construii de sistemul Prolog.
La ncercarea de resatisfacere a scopului place(X, Y), printr-un
mecanism similar, se observ c nu mai exist alte soluii. n concluzie,
fiind dat baza de cunotine Prolog anterioar, rspunsul sistemului
Prolog la ntrebarea place(X, Y) este:
?- place(X, Y).
X = mihai, Y = maria;
X = ion, Y = ana;
No
Observaii:
La satisfacerea unei conjuncii de scopuri n Prolog, se ncearc
satisfacerea fiecrui scop pe rnd, de la stnga la dreapta. Prima
satisfacere a unui scop determin plasarea unui marcaj n baza de
cunotine n dreptul faptului sau regulii care a determinat satisfacerea
scopului.
Dac un scop nu poate fi satisfcut (eueaz), sistemul Prolog
reitereaz i ncearc resatisfacerea scopului din stnga, pornind cutarea
n baza de cunotine de la marcaj n mod descendent. nainte de
resatisfacerea unui scop se elimin toate instanierile de variabile
determinate de ultima satisfacere a acestuia. Dac cel mai din stnga scop
din conjuncia de scopuri nu poate fi satisfcut, ntreaga conjuncie de
scopuri eueaz.
Aceast comportare a sistemului Prolog n care se ncearc n
mod repetat satisfacerea i resatisfacerea scopurilor din conjunciile de
scopuri se numete backtracking.
10
Figura 1.1. Algoritmul de satisfacere a scopurilor n Prolog

La general, o regul are urmtoarea sintax:
nume_rel(arg1, , argN) :- nume_rel_1(), , nume_rel_M().
Exemplu:
Putem defini predicatul so astfel Brbat este so dac este brbat i este
cstorit cu o femeie (Femeie). Aceast definiie va fi codificat prin
urmtoarea regul:
sot(Barbat, Femeie):11
barbat(Barbat), cuplu_casatorit(Barbat, Femeie).

Similar,
sotie(Femeie, Barbat):femeie(Femeie), cuplu_casatorit(Barbat, Femeie).
Partea stng a operatorului :- este numit capul regulii (head), iar cea din
dreapta corpul regulii (body).
Observaii:
Un fapt poate fi vzut ca o regul fr corp (fr condiie).
Regulile i faptele care definesc aceeai relaie (au acelai nume de
relaie la seciunea capului) trebuie grupate n sursa programului.
n Prolog, relaiile sunt numite de obicei predicate.
Dup adugarea celor dou reguli, devine posibil introducerea
interogrii:
?- sot(Barbat,Femeie), writeln(Barbat),fail.
Ca rezultat va aprea un rspuns n care se vor conine toate
numele de brbai din baza de cunotine (de exemplu: ion, andrei,
gheorghe, gabriel, mihai.)
Pentru a putea urmri modul n care este rezolvat interogarea,
poate fi utilizat comanda trace. Pe ecran vor aprea diferite subscopuri
care trebuie rezolvate de programul Prolog pentru a obine rspunsul la
interogare.
Urmtoarea regul definete faptul c persoan este printele unui
copil.
parinte(Parinte,Copil):-tata(Parinte,Copil); mama(Parinte,Copil).
n aceast regul, punctul i virgula (;) desemneaz operatorul
logic SAU.
Mai departe putem utiliza regula parinte pentru a crea o nou
regul ce verific dac o persoan este copilul unei persoane anume.
12
Figura 1.2. Graful pentru relaiile bunic- nepot utiliznd relaii deja
definite
copil(Copil,Parinte):-parinte(Parinte,Copil).
Pn la acest moment, am definit reguli bazate pe relaiile directe
dintre persoanele ce alctuiesc baza de cunotine. n continuare, vom
defini dou reguli care reprezint relaiile indirecte dintre persoanele din
baza de cunotine. Vom defini regula bunic i regula nepot utiliznd
relaiile prezentate n Figura 1.2..
Pentru a afla bunicul Z al unei persoane X, procedm astfel:
Cine este printele lui X? (presupunem c este Y).
Cine este printele lui Y? (presupunem c este Z).
Deci, Z va fi bunicul lui X.
Relaia sora, de exemplu, poate fi descris de urmtorul algoritm:
Pentru orice X i Y,
X este sora lui Y dac
(1) X i Y au acelai printe, i
(2) X este femeie.
O posibil implementare n Prolog a algoritmului dat mai sus este
urmtoarea:
sora(X,Y):-parinte(Z,X), parinte(Z,Y), femeie(X), X <>Y.
Menionm c modalitatea n care X i Y au acelai printe a fost
prezentat anterior. n Prolog, operatorul <> are sensul de diferit.
13
PARTEA 2. Desfurarea lucrrii

1. Se va citi breviarul teoretic. Se atrage atenia asupra faptului c
toate cunotinele din aceast lucrare vor fi necesare i la efectuarea
celorlalte lucrri.
2. Se vor studia exemplele propuse, ncercnd gsirea altor
posibiliti de soluionare a acestora. Se vor utiliza i alte scopuri
(interogri) pentru a testa definiiile predicatelor introduse
3. Se va elabora un arbore genealogic i o baz de cunotine
Prolog care ar descrie relaiile existente n familia dumneavoastr proprie
care ar permite cercetarea acestor relaii prin utilizarea scopurilor externe.
Arborele genealogic elaborat trebuie s conin cel puin trei niveluri.
Pentru cercetarea relaiilor existente n familie se vor utiliza nu mai puin
de ase scopuri.
4. Se va prezenta darea de seam.
14

Mecanisme de control al procesului de backtracking
Scopul: nsuirea noiunilor privind mecanismele specifice limbajului
Prolog pentru controlul procesului de backtracking: cut i fail
Sistemul Prolog se implic automat ntr-un proces de backtracking
atunci cnd acest lucru este necesar pentru satisfacerea unui scop. n unele
situaii acest comportament poate fi deosebit de util, pe cnd n altele poate
deveni foarte ineficient. Se consider urmtorul exemplu de program n care
se definesc valorile unei funcii:
f(X, 0) :- X < 3.
%1
f(X, 2) :- 3 =< X, X < 6.
%2
f(X, 4) :- 6 =< X.
%3
La ntrebarea:
?- f(1, Y).
Y=0
rspunsul sistemului indic faptul c valoarea funciei pentru X=1 este
Y=0. Dac se pune ntrebarea format din conjuncia de scopuri:
?- f(1, Y), 2 < Y.
no
sistemul semnaleaz un eec. Arborii de deducie corespunztori sunt
reprezentai n Figura 2.1.
Se observ c se ncearc resatisfacerea primului scop cu regulile
2 i 3, iar acest lucru este inutil datorit semanticii acestor reguli. Astfel,
dac o valoare mai mic dect 3 pentru X duce la eecul scopului S din
conjuncia de scopuri f(X, Y), S, este inutil s se ncerce resatisfacerea
scopului f, deoarece aceasta nu este posibil. ncercarea de resatisfacere a
scopului f(X, Y) poate fi mpiedicat prin introducerea predicatului cut.
15
Figura 2.1. Arbori de deducie a scopurilor f(1,Y) i f(1,Y),2<Y

Predicatul cut, notat cu atomul special !, este un predicat standard,
fr argumente, care poate fi ndeplinit (este adevrat) ntotdeauna i nu
poate fi resatisfcut.
Predicatul cut are urmtoarele efecte laterale:
La apariia predicatului cut, toate seleciile fcute ntre scopul
antet al regulii i cut sunt "ngheate", deci marcajele de satisfacere a
scopurilor sunt eliminate, ceea ce duce la eliminarea oricror altor soluii
alternative pentru aceast poriune. O ncercare de resatisfacere a unui
scop ntre scopul antet de regula i scopul curent va eua.
Dac clauza n care s-a introdus predicatul cut reuete, toate
clauzele cu acelai antet, succesive clauzei n care a aprut cut, vor fi
ignorate.
Printr-o descriere succint, comportamentul predicatului cut este
urmtorul:
(C1) H :- D1, D2, , Dm, !, Dm+1, , Dn.
(C2) H :- A1, ,Ap.
(C3) H.
Dac D1, D2, , Dm sunt satisfcute, ele nu mai pot fi resatisfcute datorit lui cut. Dac D1, , Dm sunt satisfcute, C2 i C3 nu
vor mai fi utilizate pentru re-satisfacerea lui H. Resatisfacerea lui H se
poate face numai prin resatisfacerea unuia din scopurile Dm+1, , Dn,
dac acestea au mai multe soluii.
16
Utiliznd predicatul cut, definiia funciei f(X, Y) poate fi rescris

mult mai eficient astfel:
f(X, 0) :- X < 3, !.
f(X, 2) :- 3 =< X, X < 6, !.
f(X, 4) :- 6 =< X.
Predicatul cut poate fi util n cazul n care se dorete eliminarea
din deducie a unor pai care nu conin soluii sau eliminarea unor ci de
cutare care, la fel, nu conin soluii. El permite exprimarea n Prolog a
unor structuri de control de tipul:
dac condiie atunci aciune1
altfel aciune2
astfel
daca_atunci_altfel(Cond, Act1, Act2) :- Cond, !, Act1.
daca_atunci_altfel(Cond, Act1, Act2) :- Act2.
Se observ ns c exist dou contexte diferite n care se poate
utiliza predicatul cut: ntr-un context predicatul cut se introduce numai
pentru creterea eficienei programului, caz n care el se numete cut
verde; n alt context utilizarea lui cut modific semnificaia procedural a
programului, caz n care el se numete cut rou.
Exemplul de definire a funciei f(X, Y) cu ajutorul lui cut este un
exemplu de cut verde. Adugarea lui cut nu face dect s creasc
eficiena programului, dar semnificaia procedural este aceeai, indiferent
de ordinea n care se scriu cele trei clauze.
Utilizarea predicatului cut n definirea predicatului asociat
structurii de control daca_atunci_altfel introduce un cut rou, deoarece
efectul programului este total diferit n cazul schimbrii ordinii clauzelor.
Introducerea unui cut rou modific corespondena dintre semnificaia
declarativ i semnificaia procedural a programelor Prolog.
Considerm exemplul de definire a predicatului de aflare a
minimului dintre dou numere n urmtoarele dou variante:
min1(X, Y, X) :- X =< Y, !.
% cut verde
min1(X, Y, Y) :- X > Y.
min2(X, Y, X) :- X =< Y, !.
% cut rou
min2(X, Y, Y).
17
n definiia predicatului min1 se utilizeaz un cut verde; acesta se

folosete pentru creterea eficienei programului, dar ordinea clauzelor de
definire a lui min1 poate fi schimbat fr nici un efect asupra rezultatului
programului. n cazul predicatului min2 se utilizeaz un cut rou,
asemntor structurii daca_atunci_altfel. Dac se schimb ordinea
clauzelor de definire a predicatului min2, rezultatul programului va fi
incorect pentru valorile X < Y.
Oportunitatea utilizrii unui cut rou sau a unui cut verde este,
dintr-un anumit punct de vedere, similar cu cea a utilizrii sau nu a
salturilor n limbajele de programare clasic. Dac s-ar rescrie predicatul
daca_atunci_altfel folosind un cut verde, definiia lui ar fi:
daca_atunci_altfel(Cond, Act1, Act2) :- Cond, !, Act1.
daca_atunci_altfel(Cond, Act1, Act2) :- not (Cond),!,Act2
unde predicatul not(Cond) este satisfcut dac scopul Cond nu este
satisfcut. O astfel de definiie implic evaluarea lui Cond de dou ori i,
dac Cond se definete ca o conjuncie de scopuri, posibil sofisticate,
atunci ineficiena utilizrii unui cut verde n acest caz este evident. De la
caz la caz, programatorul n Prolog trebuie s aleag ntre claritate, adic
pstrarea corespondenei semnificaiei declarative cu cea procedural, i
eficien.
Limbajul Prolog permite exprimarea direct a eecului unui scop
cu ajutorul predicatului fail. Predicatul fail este un predicat standard, fr
argumente, care eueaz ntotdeauna. Datorit acestui lucru, introducerea
unui predicat fail ntr-o conjuncie de scopuri (de obicei la sfrit)
determin intrarea n procesul de backtracking.
Cnd fail este plasat dup predicatul cut, nu se apeleaz
backtracking-ul. Enunul "Un individ este ru dac nu este bun." se
poate exprima astfel:
bun(gelu).
bun(vlad).
bun(mihai.
rau(X) :- bun(X), !,
fail. rau(X).
18
?-rau(gelu).
no
?- rau(petru).
yes
n cazul n care predicatul fail este folosit pentru a determina un
eec, cum i n cazul exemplului de mai sus, acesta este de obicei precedat
de predicatul cut, deoarece procesul de backtracking pe scopurile care l
preced este inutil, scopul eund oricum datorit lui fail.
Exist cazuri n care predicatul fail este introdus intenionat
pentru a genera procesul de backtracking pentru scopurile care l preced,
proces interesant nu att din punctul de vedere al posibilitii de resatisfacere a scopului ce conine fail, ct din punctul de vedere al efectului
lateral al acestuia.
rosu(mar).
rosu(cub).
rosu(soare.
afisare(X) :- rosu(X),
write(X),fail.
afisare( _ ).
Scopul afisare(X) va afia toate obiectele roii cunoscute de
programul Prolog datorit procesului de backtracking generat de fail;
astfel, cu ajutorul lui fail se realizeaz o iteraie pentru faptele rosu().
Clauza afisare( _ ) se adug pentru ca rspunsul final la
satisfacerea scopului s fie afirmativ. n acest caz, introducerea unui cut
nainte de fail ar fi determinat numai afiarea primului obiect rou din
program.
Analiznd combinaia !,fail, se consider n continuare
implementarea n Prolog a afirmaiei: "Mihai iubete toate sporturile cu
excepia boxului". Aceast afirmaie poate fi exprimat n pseudocod n
forma:
dac X este sport i X este box
atunci Mihai iubete X este fals
altfel dac X este sport
atunci Mihai iubete X este adevrat
19
i tradus n Prolog astfel:

iubeste(mihai, X) :- sport(X), box(X), !,
fail. iubeste(mihai, X) :- sport(X)
Predicatul cut utilizat aici este un cut rou. Combinaia !, fail este
deseori utilizat n Prolog i are rolul de negaie. Se mai spune c limbajul
Prolog modeleaz negaia ca eec al satisfacerii unui scop (negaia ca
insucces), aceasta fiind de fapt o particularizare a ipotezei lumii nchise.
Combinaia !, fail este echivalent cu un predicat standard existent n
Prolog - predicatul not. Predicatul not permite drept argument un predicat
Prolog i reuete dac predicatul argument eueaz. Utiliznd acest
predicat, ultimul exemplu dat se poate exprima n Prolog astfel:
iubeste(mihai, X) :-sport(X),not(box(X)).
iubeste(mihai, X) :- sport(X).
Un alt predicat standard este predicatul call, care permite drept
argument un predicat Prolog i are ca efect ncercarea de satisfacere a
predicatului argument. Predicatul call reuete dac predicatul argument
reuete i eueaz n caz contrar. Utiliznd acest predicat, se poate
explicita efectul general al predicatului standard not n urmtorul mod:
not(P) :- call(P), !,fail.
not(P).
Att predicatul not ct i predicatul call sunt predicate de ordinul II n
Prolog (metapredicate), deoarece admit ca argumente alte predicate.
20

1. Citii breviarul teoretic. Se atrage atenia asupra faptului c
toate cunotinele din aceast lucrare vor fi necesare i la efectuarea
celorlalte lucrri.
2. Lansai la executare programul elaborat n lucrarea 1 i
cercetai schimbrile semanticii procedurale:
prin schimbarea ordinii propoziiilor - fapte;
prin schimbarea ordinii propoziiilor - reguli; (dou
variante)
prin schimbarea subscopurilor n reguli; (dou variante)
tragei concluzii.
3. Rezolvai urmtoarele probleme propuse i urmrii execuia lor
corect.
3.1. Elaborai i testai un program pentru determinarea unei
valori minime din dou numere (X i Y), fr utilizarea predicatului cut.
3.2. Elaborai i testai un program pentru determinarea unei
valori minime din dou numere (X i Y), utiliznd predicatul cut rou i
cut verde.
3.3. Care vor fi rspunsurile programului
( 1).
( 2) :- !.
( 3).
Efectuai o analiz comparativ ntre utilizarea predicatelor cut n
spaiul bazei de cunotine i spaiul scopurilor pentru ntrebrile
formulate n lista de scopuri ce urmeaz:
( X).
( X), p(Y).
( X), !, p(Y).
3.4. Doi copii pot juca un meci ntr-un turneu de tenis dac au
aceeai vrst. Fie urmtorii copii i vrstele lor:
copil(peter,9). copil(paul,10). copil(chris,9). copil(susan,9).
Definii un predicat din care rezult toate perechile de copii care
pot juca un meci ntr-un turneu de tenis.
4. Introducei schimbrile corespunztoare n programul din
21
punctul 2., utiliznd cut verde cel puin n dou reguli din baza de
cunotine.
5. Introducei schimbrile corespunztoare n programul din
punctul 2., utiliznd cut rou n reguli din baza de cunotine. Tragei
concluzii.
6. Prezentai darea de seam.
22

Structuri de date n Prolog
Scopul: Folosirea listelor, un instrument puternic al Prologului.

3.1. Listele n Prolog
Lista reprezint unul dintre tipurile cele mai utilizate de structurile
de date att n Prolog, ct i n alte limbaje declarative. O list este o
secven ordonat de obiecte de acelai tip. n Prolog, elementele unei
liste se separ ntre ele prin virgul i ntreaga secven este nchis ntre
paranteze drepte.
Exemple:
[] list vid;
[X, Y, Y] list ale crei elemente sunt variabilele X, Y i Z;
[[0, 2, 4], [1, 3]] list de liste de numere ntregi.
Tipurile de liste utilizate ntr-un program Prolog trebuie declarate
n seciunea domains sub forma:
tip_lista = tip*
unde tip este un tip standard sau definit de utilizator. O list este compus
conceptul din dou pri:
cap (head), care desemneaz primul element din list;
rest (tail), care desemneaz lista elementelor rmase dup
eliminarea primului element.
Restul unei liste se mai numete corpul sau coada unei liste i este
ntotdeauna o list. Exemplele urmtoare ilustreaz modul n care se
structureaz o list (tabelul 3.1).
23
Tabelul 3.1. Exemple de structurare a listelor

Lista
Cap
Coada
['a','b','c']
'a'
['b','c']
['a']
'a'
[]
[]
nedefinit
nedefinit
[[1,2,3],[2,3,4],[ [1,2,3]
]]
[[2,3,4],[]
]
Aceast dihotomie este utilizat n predicatele care prelucreaz

liste folosindu-se de avantajul regulii de unificare (identificare,
substituire):
singurul termen care se identific cu [] este [].
o list de forma [H1|T1] se va identifica numai cu o list de
forma [H2|T2] dac H1 se poate identifica cu H2 i T1 se poate identifica
cu T2.
n tabelul 3.2 sunt date cteva exemple care ilustreaz aceast regula de
unificare.
Tabelul 3.2. Exemple ce ilustreaz regula de unificare
Lista1
Lista2
Legarea variabilelor
[X,Y,Z]
[Ion, Maria, Vasile]
X=Ion, Y=Maria, Z=Vasile
[7]
[X,Y]
X=7, Y=[]
[1,2,3,4]
[X,Y|Z]
X=1, Y=2, Z=[3,4]
[1,2]
[3|X]
esec
3.2. Exemple de utilizare

Majoritatea predicatele care utilizeaz (proceseaz) liste sunt
recursive i sunt definite pentru:
cazul de baz: list vid []
cazul recursiv: pentru o list de forma [H|T], se efectueaz
anumite aciuni asupra capului H, i ulterior se apeleaz predicatul
recursiv cu coada T.
24
Utiliznd listele, putem colecta informaii i/sau date ntr-un

singur obiect Prolog. De exemplu, fie faptele:
luna (1, ianuarie). luna(2, februarie). luna(3,
martie). luna(4, aprilie). luna(5, mai). luna(6,
iunie).
Ele pot fi redate folosind o singur list sub forma faptului:

luni_prima_jumatate_an([ianuarie, februarie, martie,
aprilie, mai, iunie]).
Pentru o comparaie mai ampl, considerm urmtoarele dou

programe i cteva interogri asupra lor:
/* program_1 */
predicates
luna(integer,symbol)
afis
afis_p(integer)
afis_n(integer)
clauses
luna(1,ianuarie). luna(2, februarie). luna(3,
martie).
luna(4, aprilie). luna(5, mai). luna(6, iunie).
afis:-luna(_,X),write(X),nl,fail.
afis.
afis_p(1):-luna(1,X), write(X),nl.
afis_p(N):-N1=N1,afis_p(N1),N2=N1+1,
luna(N2,X),write(X),nl.
afis_n(N):-luna(N, X), write(X),nl.
Goal: afis
ianuarie februarie martie aprilie mai iunie
yes
Goal: afis_p(1)
ianuarie
yes
Goal: afis_p(3)
ianuarie februarie martie
yes
Goal: afis_n(3)
25
Martie
yes
Figura 3.1. Cod listing. Exemplu de folosire a listelor

/* program_2 */
Domains
luni=symbol*
predicates
prima_jumat_an(luni)
clauses
prima_jumat_an([ianuarie,februarie,martie,aprilie,mai,
iunie]).
Goal: prima_jumat_an(X)
X = [ianuarie, februarie, martie, aprilie,
mai,iunie]
1 Solution
Goal: prima_jumat_an([X1, X2, X3, X4, X5, X6])
X1 = ianuarie, X2 = februarie, X3 = martie, X4 =
aprilie, X5 = mai, X6 = iunie
1 Solution
Goal: prima_jumat_an([X|Y])
X = ianuarie, Y = [ februarie, martie, aprilie,
mai, iunie]
1 Solution
Goal: prima_jumatate_an([X|_])
X = ianuarie
1 Solution
Goal: prima_jumat_an([X,Y,Z| R])
X = ianuarie, Y = februarie, Z = martie, R =
[aprilie, mai, iunie]
1 Solution
Goal: prima_jumat_an([X,Y,Z |_])
X = ianuarie, Y = februarie, Z =martie
1 Solution
26
Goal: prima umat_an([_,_,X|_])

X = martie
1 Solution
Figura 3.2. Cod listing. Exemplu de folosire a listelor eterogene

Din exemplele prezentate mai sus limbajul Prolog permite s se
aleag nu doar primul element al unei liste, ci mai multe. De asemenea, se
permite lucrul cu listele n care elementele nu sunt de acelai tip.
n exemplul ce urmeaz obiectele de tip lista sunt liste ale
cror elemente pot fi numere ntregi, reale sau complexe.
domains
complex=z(real,real)
numar=r(real);i(integer);c(complex)
lista=numar*
predicates
p(lista)
clauses.
p([r(2.8),i(9),r(0.89),i(77),c(z(2,6))]).
Goal: p([X|Y])
X = r(2.8), Y = [i(9),r(0.89),i(77),c(z(2,6))]
1 Solution
Goal: p([X|_]) X = r(2.8)
1 Solution
Goal: p([X, i(9) |Y])
X = r(2.8), Y = [r(0.89),i(77),c(z(2,6))]
1 Solution
Goal: p([X, r(0.89) |Y])
No Solution
Figura 3.3. Cod listing. Exemplu de folosire a listelor cu numere ntregi,

reale i complexe
27

1. Se propun spre rezolvare urmtoarele probleme (precizai
varianta corespunztoare la profesor):
Liniarizarea listelor. Scrie predicatul liniar
(ListaListe, Lista), unde ListaListe este o list de elemente care
pot fi la rndul lor liste, iar n Lista se construiete liniarizarea listei
ListaListe. Astfel, liniar([1, 2, [3, 4], [5, [6, 7],
[[8], 9]]], L) va returna n L lista [1, 2, 3, 4, 5, 6, 7, 8,
1.1.
9].
1.2. Scriei un predicat descomp(N, Lista) care

recepioneaz un numr ntreg N i returneaz o list a factorilor primi ai
numrului N; de exemplu: descomp(12, [2, 2, 3]) este adevarat.
1.3. Scriei un predicat invers(Lista, ListaInversata)
care inverseaz elementele unei liste; s se scrie dou variante ale
predicatului de inversare a unei liste: o variant n care lista inversat este
calculata pe ramura de revenire din recursivitate i o variant n care lista
inversat este calculat pe ramura de avans n recursivitate.
1.4. Scriei un predicat palindrom(Lista) care verific
dac o list este palindrom (Un palindrom este o secven care, dac este
parcurs de la stnga la dreapta sau de la dreapta la stnga, este identic,
de exemplu: [a, b, c, b, a] sau [a, b, c, c, b, a]). S se
modifice predicatul anterior astfel, nct s genereze liste palindrom cu
elemente 0 i 1.
1.5. Scriei un predicat rotire(Lista, Directie, Nr,
ListaRez) care rotete Lista cu un numr de Nr elemente la stnga
(dac_ Directie = stg) sau la dreapta (dac_ Directie = dr),
depunnd rezultatul n ListaRez.
1.6. S se scrie predicatul substitutie(X, Y, L1, L2),
unde L2 este rezultatul substituirii tuturor apariiilor lui X din lista L1 cu
Y. Ex: substitutie(a, x, [a, [b,a,] c], L2) va produce: L2 =
[x, [b, x], c].
28
1.7. S se scrie predicatul imparte(L, L1, L2) care

mparte lista L n dou sub-liste L1 i L2, care au un numr de elemente
aproximativ egal, fr a calcula lungimea listei L. Ex: imparte([a, b,
c, d, e], L1, L2) va produce: L2 = [a, b, c] i L3 = [d,
e].
1.8. S se scrie un predicat evenmember(Elem,Lista) care
reflect dac Elem se afl n Lista pe poziie par. De exemplu, apelul
evenmember(X,[1,5,3,4]) va returna pe rnd soluiile X =5; X =4.
1.9. S se scrie un predicat imparte(L1,L2,L3) care
mparte lista L1 n dou liste L2 i L3, coninnd elementele de pe
poziiile impare iar L3 pe cele de pe poziilii pare. Ex:
imparte([a,b,c,d,e],L2,L3)
va produce L2=[a,c,e] i
L3=[b,d].
1.10. S se scrie un program Prolog care s calculeze media
numerelor unei liste.
1.11. S se scrie un program Prolog care calculeaz i afieaz
cel mai mare divizor comun al tuturor numerelor dintr-o list.
1.12. S se scrie un program Prolog care s sorteze
descresctor numerele unei liste.
1.13.
Scriei
un
program
care
utilizeaz
predicatul
listaPara, care are conine dou argumente: o list de numere ntregi,
iar al doilea argument returneaz o list cu toate numerele pare din prima
list.
1.14. S se elimine primele N elemente de la nceputul unei
liste. Numrul elementelor pentru eliminare se va introduce utiliznd
predicatul readln al limbajului Prolog.
1.15. S se elimine ultimele N elemente a unei liste. Numrul
elementelor pentru eliminare se va introduce utiliznd predicatul readln
al limbajului Prolog.
29
CAPITOLUL II
Exemple i probleme n limbajul Prolog
Sisteme expert
Scopul: Studierea principiilor de proiectare i de organizare a sistemelor
expert bazate pe logic i reguli.

4.1. Scopul i structura general a sistemelor expert
Sistemul expert (SE) este un program (pachet de programe), care
simuleaz ntr-o oarecare msur activitatea unui expert uman ntr-un
anumit domeniu. Mai mult dect att, acest domeniu este strict limitat.
Principalul scop al SE este de a consulta n domeniul pentru care acest SE
este proiectat.
Un SE este format din trei componente principale (fig. 4.1):
1) Baza de cunotine (BC). BC este partea central a
sistemului expert. Aceasta conine o colecie de fapte i de cunotine
(regulile) pentru extragerea altor cunotine. Informaiile coninute n baza
de cunotine sunt folosite de ctre SE pentru determinarea rspunsului n
timpul consultrii. De regul, BC sunt separate de programul principal sau
stocate pe alte mijloace fixe.
2) Mecanismul (motorul) de inferen. MI conine descrieri ale
modului de aplicare a cunotinelor cuprinse n baza de cunotine. n
timpul consultrii, MI iniiaz SE s nceap procesrile, ndeplinind
regulile determin admisibilitatea soluiei gsite i transmite rezultatele la
Interfaa sistemului (System User Interface).
3) Interfaa sistemului utilizatorului (ISU) este parte a SE, care
interacioneaz cu utilizatorul. Funciile ISU includ: recepionarea
informaiilor de la utilizator, transferul rezultatelor n forma cea mai
30
convenabil utilizatorului, explicarea rezultatelor recepionate de SE

(ofer informaii cu privire la atingerea rezultatelor).
Figura 4.1. Structura general a SE

n funcie de metoda de clasificare i plasare a informaiei exist
mai multe tipuri de Baze de cunotine: de producie, de reea i de cadru
(frame-uri) modele de reprezentare a cunotinelor.
Modelul de reea se bazeaz pe reprezentarea cunotinelor n
forma unei reele ale crei noduri corespund conceptelor iar arcele
relaiilor dintre ele.
La baza modelului pe cadre (frame-uri) se afl o grupare logic
de atribute a obiectului, precum i depozitarea i prelucrarea grupurilor
logice care sunt descrise n cadre.
Modelul de producie se bazeaz pe regulile de forma "dacatunci" i permite introducerea fragmentelor de cunotine faptice n
regulile limbajului Prolog. Anume astfel sunt construite SE bazate pe
reguli.
La punerea n aplicare a SE bazat pe logic, baza de cunotine
reprezint un set de afirmaii, fapte. Elaborarea concluziei unui expert n
acest caz se bazeaz pe mijloacele standard de lucru cu listele.
4.2. Determinarea rezultatului (rspunsului) expert
Prin concluzia SE, se subnelege dovada faptului c n setul de
ipoteze se conine concluzia cutat. Logica de obinere a rspunsului
(concluziei) sunt specificate de regulile de inferen. Concluzia
(rezultatul) se obine prin cutarea i compararea modelului.
n SE, bazat pe reguli, ntrebrile (scopurile) utilizatorului sunt
transformate ntr-o form care este comparabil cu normele de forma BC.
Motorul de inferen iniiaz procesul de corelare de la regula de "top"
(vrf). Recursul la reguli este numit "apelare". Apelarea regulilor
relevante n procesul de corelare continu atta timp, ct nu exist o
31
comparaie sau nu este epuizat toat BC, iar valoarea nu este gsit. n
cazul n care MI detecteaz c pot fi apelate mai mult dect o regul,
ncepe procesul de soluionare a conflictului. n soluionarea conflictului
prioritate se d regulilor care sunt mai specifice, sau regulilor ce in de
mai multe date actuale.
n SE, bazate pe logic, interogrile sunt transformate n valori
care sunt comparate cu listele de valori prezente n BC.
Procesul de unificare n programele Turbo Prolog i Visual Prolog
ajut la rezolvarea problemei de gsire i comparare dup exemplu i nu
necesit scrierea unor reguli suplimentare. Ca i n sistemele bazate pe
reguli, n cel bazat pe logic, utilizatorul obine rspunsuri la interogrile
(scopurile) sale, n conformitate cu logica stabilit n SE. Pentru punerea
n aplicare a mecanismului de extragere a rspunsului expertului este
suficient s se scrie specificaiile necesare.
4.3. Sistemul expert bazat pe reguli i realizarea lui
SE pe baza regulilor permite proiectantului a construi regulile
care sunt n mod natural combinate n grupuri de fragmente de cunotine.
Independena reciproc a regulilor de producie face ca baza de reguli s
fie semantic modular i capabil de dezvoltare.
Realizarea n Turbo Prolog (sau Visual Prolog) a SE bazat pe
reguli conine un set de reguli care sunt invocate de ctre datele de intrare
n momentul de corelare (comparare). mpreun cu regulile MI, SE este
compus dintr-un interpretator care selecteaz i activeaz diferite sisteme.
Activitatea acestui interpretator este descris ntr-o succesiune de
trei etape:
1) Interpretatorul compar un exemplu de regul cu elementele de
date n baza de cunotine.
2) n cazul n care este posibil apelarea mai multor reguli, pentru
a selecta o regul, se utilizeaz mecanismul de soluionare a conflictelor.
3) Regula selectat este folosit pentru a gsi un rspuns la
aceast ntrebare.
Acest proces n trei etape este ciclic i se numete ciclul de
detectare-aciune. Rspunsul afirmativ al SE este rezultatul uneia din
regulile de producie. Selecia regulii se efectueaz, n conformitate cu
datele de intrare.
32
Elaborarea a SE n Turbo Prolog (sau Visual Prolog), bazat pe

reguli, ncepe cu declaraia bazei de fapte. Baza de fapte stocheaz
(pstreaz) rspunsurile utilizatorului la ntrebrile ISU. Aceste date sunt
rspunsurile pozitive sau negative. n continuare, se vor construi regulile
de producie care vor descrie fragmente de cunotine actuale. Exemplu
(SE de identificare i selectare a rasei cinilor):
dog_is(buldog englez): it_is(cu par scurt),
positive(are,mai mic de 22 inch),
positive(are, coada atirnata),
positive(are, caracter bun), !.
/ * n mod similar sunt descrise cunotinele cu privire la alte rase de cini

*/
dog_is(cocher-spaniel): it_is(cu par lung),
positive(are, mai mic de 22 inch),
positive(are, coada atirnata),
positive(are, urechi lungi),
positive(are, caracter bun), !.
Mai mult dect att, n scopul de a limita spaiul de cutare care

descrie fragmentele de cunotine de reguli, ultimele pot fi grupate n baz
prin introducerea de reguli auxiliare pentru identificarea subcategoriilor.
De exemplu, n SE alegerea rasei de cine va fi regula it_is, care
identific rasa de cine pe motive de apartenen la un grup de cini cu
prul lung sau cu prul scurt:
it_is(cu par scurt):positive(cainele are, par scurt), !.
it_is(cu par lung):
positive(cainele are, par lung), !.
n exemplul considerat aici, datele pentru selectarea rasei de cini

sunt cunoscute, deoarece sunt selectate rasele de cini comune. Setul de
caracteristici de clasificare a speciilor este selectat n baza urmtoarelor
criterii:
33
toate atributele utilizate sunt necesare pentru a identifica rasa.

nici unul dintre atribute nu este comun pentru toate speciile
simultan.
Regulile MI compar datele utilizatorului cu datele ce se conin n
regulile de producie (regulile pozitive i negative n acest SE),
precum i pstrarea n continuare "a traseului" rspunsurilor afirmative i
negative (regula remember pentru adugarea n baza de date a
rspunsurilor 1 (da) i 2 (nu)), care sunt utilizate n comparare cu modelul:
Mecanismul de determinare a (gsirea) rspunsului
xpositive (X, Y) i xnegative (X, Y) predicatele bazei
dinamice de date pstreaz respectiv, rspunsurile afirmative i negative
ale utilizatorului la ntrebrile care ISU le pune pe baza faptelor
argumentelor predicatului positive n corpul regulii dog_is
positive(X, Y):
xpositive(X,Y), !.
positive(X, Y):
not(negative(X,Y)), !, ask(X,Y).
negative(X, Y):
xnegative(X,Y), !.
Mecanismul de consultare
Predicatul dlg_Ask creeaz o fereastr standard de dialog pentru
a obine rspunsul utilizatorului la ntrebarea Da/Nu.
ask(X, Y):
concat(Intrebare : X, Temp),
concat(Temp, , Temp1),
concat(Temp1, Y, Temp2),
concat(Temp2, ?, Quest),
Reply1=dlg_Ask(Consultare, Quest, [D, Nu]),
Reply=Reply1+1,
remember(X, Y, Reply).
Introducerea rspunsurilor utilizatorului n baza de date dinamic.

remember(X, Y, 1): !,
assertz(xpositive(X, Y)).
remember(X, Y, 2): !, assertz(xnegative(X, Y)), fail.
34
4.4. Sistem expert bazat pe logic i realizarea lui

n acest caz, BC const n declaraii sub form de enunuri n
logica predicatelor. O parte din afirmaii descrie obiectele, iar cealalt
parte a afirmaiilor descrie condiiile i atributele, ce caracterizeaz
diferite obiecte. Numrul de trsturi determin gradul de precizie de
clasificare. Interpretatorul n cadrul sistemului ndeplinete funciile sale
n baza schemei urmtoare:
1) Sistemul conine n baza de cunotine enunuri (fapte) care
guverneaz (conduc) cutarea i compararea. Interpretatorul compar
aceste enunuri cu elementele aflate n baza de date.
2) n cazul n care este posibil apelarea mai multor dect a unei
singure reguli, pentru a rezolva conflictul sistemul utilizeaz mecanismul
intern de unificare a Prolog-ului.
3) Sistemul recepioneaz rezultatele procesului de unificare n
mod automat, de aceea ele sunt trimise pe dispozitivul necesar (logic)
pentru output-ul informaiei.
La fel ca n SE, bazat pe reguli, acest proces ciclic este proces de
detectare-aciune. Principala diferen n structura SE bazat pe logic
const n descrierea obiectelor i atributelor sub form de fapte:
Condiii-caracteristici de rase diferite.
cond(1,
cond(2,
cond(3,
cond(4,
cond(5,
cond(6,
cond(4,
cond(8,
rasa cu par lung).

rasa cu par lung).
mai mic de 22 inch).
mai mare de 30 inch).
coada atirnata).
urechi lungi).
caracter bun).
greutate mai mare de 100 pounds).
Datele despre tipurile de rase:

topic(cu par scurt).
topic(cu par lung).
Datele despre rasele concrete:

rule(1, ciine, cu par scurt, [1]).
rule(2, ciine, cu par lung, [2]).
35
rule(3, cu par scurt, buldog englez, [3,5,4]).

rule(4, cu par scurt, copoi, [3,6,4]).
rule(5, cu par scurt, dog danez, [5,6,4,8]).
rule(6, cu par scurt, foxterier american, [4,6,4]).
rule(4, cu par lung, cocher-spaniel, [3,5,6,4]).
rule(8, cu par lung, setter irlandez, [4,6]).
rule(9, cu par lung, colli, [4,5,4]).
rule(10, cu par lung, senbernar, [5,4,8]).
Al treilea argument al predicatului rule reprezint o list de

numere ntregi - condiii, din enunurile tipului cond. Fiecare enun (fapt)
specific tipul de cond i stabilete condiia de selecie a clasificrii de
rase de cini utilizate aici. n SE bazate pe logic, interpretatorul
utilizeaz aceste numere de condiie pentru a efectua alegerile (seleciile)
adecvate.
MI conine regulile de tratare a listelor de atribute n descrierea
obiectelor. Prin utilizarea predicatului go MI verific afirmaiile BC rule
i cond pentru a clarifica cu ajutorul regulii check existena sau lipsa de
valori adecvate de date:
Regula iniial a mecanismul de determinare a rspunsului:
go(_, Mygoal):
not(rule(_, Mygoal, _, _)), !, concat(Rasa
recomandata : , Mygoal, Temp), concat(Temp, .,
Result),
dlg_Note(Concluzia expertului : , Result).
go(History, Mygoal):
rule(Rule_number, Mygoal, Type_of_breed,
Conditions), check(Rule_number, History,
Conditions), go([Rule_number|History],
Type_of_breed).
Compararea datelor de intrare a utilizatorului cu listele de atribute

a raselor aparte de cini:
check(Rule_number, History,
[Breed_cond|Rest_breed_cond_list]):
yes(Breed_cond), !,
Rest_breed_cond_list).
check(_, _, [Breed_cond|_]):
no(Breed_cond), !, fail.
36
[Breed_cond|Rest_breed_cond_list]):
cond(Breed_cond, Text),
ask_question(Breed_cond, Text),
Rest_breed_cond_list).
check(_, _, [ ]).
do_answer(Cond_number, 1): !,
assertz(yes(Cond_number)).
do_answer(Cond_number, 2): !,
assertz(no(Cond_number)), fail.
Solicitarea i recepionarea rspunsurilor da i nu de la

utilizator:
ask_question(Breed_cond, Text):
concat(Intrebare : , Text, Temp),
concat(Temp, , Temp1),
concat(Temp1, ?, Quest),
Response1=dlg_Ask(Consultare, Quest,
[Da,Nu]), Response=Response1+1,
do_answer(Breed_cond, Response).
Regula go ncearc s potriveasc obiectele care sunt clasificate

prin numrul de condiii. Dac potrivirea se produce, modulul
programului ar trebui s adauge la baza de cunotine valorile potrivite i
s continue procesul cu noile date recepionate din partea utilizatorului. n
cazul n care potrivirea nu se produce, mecanismul oprete procesul
actual i alege o alt cale. Cutarea i compararea continu pn cnd
toate posibilitile sunt epuizate.
Avantajul SE bazat pe logic const n capacitatea de a stoca
faptele bazei de cunotine n afirmaiile bazei de date dinamice. Baza de
cunotine poate fi plasat ntr-un fiier pe disc, ceea ce o face
independent de codul surs.
37

1. Pe baza materialului nsuit n cadrul acestui curs i exemplului
discutat anterior se va studia realizarea ambelor tipuri de sisteme de expert
prin intermediul limbajului Prolog.
2. Se va elabora un sistem expert pentru un anumit domeniu
selectat n conformitate cu numrul variantei din Tabelul 4.1., sau n orice
alt domeniu corelat cu profesorul. Numrul de obiecte descrise ar trebui s
fie cel puin 12, iar descrierea atributele lor nu mai puin de 8.
3. Se va analiza realizarea unui sistem expert bazat pe logic i
sistem expert care se bazeaz pe reguli, realiznd mecanismul deductiv i
inductiv.
Tabelul 4.1. Domeniul pentru sistemul expert
Varianta
1,5
2,6
3,10
4,11
7,12,19
8,15,20
9,16
13,17
14,18
Domeniul
Microprocesoare
Dispozitive mobile
Sisteme operaionale
Limbaje de programare
Jocuri pe computere
Virui de computere
Reele de calculatoare
Algoritmi de sortare
Algoritmi de cutare
Raportul trebuie s conin:

1) formularea scopului i obiectivelor de cercetare;
2) descrierea caracteristicilor sistemului expert elaborat;
3) diagramele datelor de intrare i diagrama structural a sistemului expert
att bazat pe reguli, ct i pe logic;
4) listing-ul programului cu comentarii i explicaii, justificri;
5) descrierea mecanismelor de determinarea rspunsului n sistemul
expert;
6) concluzii cu privire la experimentele efectuate.
38

Prelucrarea limbajului natural
Scopul: nsuirea principiilor fundamentale de prelucrarea limbajului
natural.

5. 1. Prelucrarea limbajului natural
Prelucrarea limbajului natural (PLN) reprezint o tehnologie (un
ansamblu de procese, metode operaii) care creeaz modaliti de a
executa diferite sarcini referitoare la limbajul natural cum ar fi construcia
unor interfee bazate pe limbaj natural ca baze de date, traducerea
automat etc. Procesarea limbajului natural reprezint i astzi o problem
dificil i n cea mai mare parte nerezolvat. Gsirea unei tehnologii
adecvate este extrem de grea datorit naturii multidisciplinare a problemei,
fiind implicate urmtoarele tiine i domenii: lingvistic, lingvistica
computaional, informatic i inteligen artificial.
Aplicaiile procesrii limbajului natural se nscriu n trei mari
categorii:
a. Aplicaiile bazate pe text:
clasificarea documentelor (gsirea documentelor
legate de anumite subiecte);
regsirea informaiei (cutarea unor cuvinte-cheie);
extragerea informaiei (legate de un anumit subiect);
nelegerea textelor (ce presupune o analiz profund
a structurii acestora);
traducerea automat i traducerea asistat de
calculator dintr-o limb n alta;
alctuirea de sinteze;
achiziia de cunotine.
39
b. Aplicaiile bazate pe dialog, care implic comunicarea ntre om i

main, aplicaii cum ar fi sistemele de nvare, sistemele de
interogare i rspuns la ntrebri, rezolvarea problemelor etc.
c. Procesarea vorbirii.
Comunicarea este schimbul intenionat de informaie generat de
producerea i perceperea semnelor dintr-un sistem partajat de semne
convenionale.
Pentru comunicare trebuie folosit un limbaj ce poate fi de mai multe
tipuri: verbal (auditiv), text, mimic, etc.
5.1.1. Componentele comunicrii
Schema de baz a comunicrii:
E emitor
C - bloc de codificare
Z - zgomot extern
D - bloc de decodificare
R receptor
M - mesaj
f(M) mesajul codificat n limbaj
f1(M) codificarea modificat de zgomot
M1 mesajul nou
Emitor:
intenie - dorina emitorului de a transmite un mesaj ctre un
receptor;
generare - crearea inteniei de a comunica i a coninutului ei ntrun limbaj;
sintez - procesul efectiv de trimitere a mesajului.
40
Receptor:
percepie - procesul de recepionare a mesajului;
analiza - interpretarea mesajului din punct de vedere lexical,
sintactic, semantic, pragmatic;
dezambiguizarea selecia dintre posibilele rezultate ale analizei;
ncorporare introducerea coninutului mesajului.
Actul de comunicare
Acesta conine mai multe interpretri/sensuri:
Locuia fraza, aa cum e spus de locutor (emitor);
Ilocuie nelesul frazei ce se dorete a fi comunicat;
interlocuiune aciunea ce rezult din locuie.
Exemplu:
Maria i-a spus lui Ionic: "Te rog nchide ua"
locuie
ilocuie
interlocuiune
ua nchis
Categorii locuionale:
asertive asculttorul este informat n legtur cu fraza;
directive asculttorul efectueaz o aciune dup aflarea
informaiei;
comisive (angajamente) asculttorul afl de aciuni viitoare;
expresive mesaje ce exprim atitudinea emitorului legat
de un fapt.
5.1.2. Definirea unui limbaj
Un prim element ntr-un limbaj este lexiconul. Acesta conine
termenii vocabularului pentru limbajul respectiv.
Exemplu:
Lexicon:
Noun breeze | wumpus | ball
Verb is | see | smell | hit
Adjective right | left | smelly
Adverb here | there | ahead
Pronoun me | you | I | it
41
RelPronoun that | who

Name John | Mary
Article the | a | an
Preposition to | in | on
Conjunction and | or | but
Pe baza lexiconului se construiesc propoziii/fraze n limbajul
respectiv. Aceste fraze se construiesc pe baza unor gramatici.
Aceste fraze (construcii lexicale) se pot analiza din mai multe
perspective:
analiza lexical procesul de conversie a frazei n atomi (realizat
de un procesor)
analiza semantic procesul de asociere a unui sens pentru
fiecare atom; sens folosit ulterior pentru a reine cunotine
dobndite din fraz
analiza pragmatic - procesul de considerare al contextului n
analiza unei fraze. Este necesar pentru a elimina ambiguitile
(apar ambiguiti cnd un cuvnt poate avea mai multe sensuri,
cel efectiv depinznd de fraz sau de contextul dialogului).
Gramaticile definesc regulile pe care o fraz trebuie s le respecte, din
punct de vedere al structurii, pentru a face parte dintr-un limbaj.
Ele se pot defini n mai multe moduri, unul dintre ele folosind
urmtoarele concepte:
a) Neterminali expresii care se substituie cu alte expresii/ elemente
din gramatic sau lexicon:
sentence S
noun phrase NP
verb phrase VP
prepositional phrase PP
Exemplu:
S NP VP | S Conjunction S
NP Pronoun | Noun | Article Noun | NP PP
VP Verb | VP NP | VP Adjective | VP PP | VP Adverb
PP Preposition NP
42
b) Terminali expresii care nu se mai substituie cu alte expresii din

gramatic (ei reprezint direct categoriile din lexicon):
Noun | Verb | Adjective | Adverb | Pronoun
c) Reguli de rescriere sunt regulile de extindere a gramaticii.
d) Simbol de nceput este un neterminal din care poate fi derivat
orice fraz corect din punct de vedere gramatical.
5.1.3. Analiza sintactic
Procesul de recunoatere a structurii unei propoziii de ctre un
calculator se numete parsing (procesare). Se poate realiza n mai multe
moduri:
top-down parsing (de sus n jos);
bottom-up parsing (de jos n sus).
Top-Down parsing se pleac de la regulile gramaticii pn cnd se
identific fraza.
Exemplu: "John hit the ball"
1. S
2. S NP, VP
3. S Noun, VP
4. S John, Verb, NP
5. S John, hit, NP
6. S John, hit, Article, Noun
7. S John, hit, the, Noun
8. S John, hit, the, ball
Bottom down parsing - se pleac de la fraz i se ncearc obinerea
simbolului de nceput al gramaticii.
Exemplu: "John hit the ball"
1. John, hit, the, ball
2. Noun, hit, the, ball
3. Noun, Verb, the, ball
4. Noun, Verb, Article, ball
5. Noun, Verb, Article, Noun
6. NP, Verb, Article, Noun
43
7. NP, Verb, NP
8. NP, VP
9. S
5.1.4. Definite Clause Grammar (DCG)
Exist mai multe tipuri de reprezentare pentru gramatici pe care le
expunem n continuare:
a) Gramatici n forma BNF (Backus Normal Form sau
BackusNaur Form) modul formal matematic de descriere a
limbajului.
Sunt gramatici dependente de context, bazate pe expresii de
forma:
<simbol> ::= _expresie_
unde,
<simbol> - un neterminal, iar _expresie_- o secven de
simboluri (terminali i neterminali).

Exemplu:
<syntax> : : = <rule> | <rule> <syntax>
<rule> : : = <whitespace> <<rule_name>>
<whitespace> : : = <whitespace >| etc.
BNF este o gramatic dependent de context (GDC), ceea ce e

dificil a fi transpus ntr-un program automat.
b) Gramatici cu clauze definite DCG Definite Clause
Grammar
n modul implicit, DCG sunt gramatici independente de context
folosite pentru prelucrarea de limbaje formale sau naturale, cu proprietatea
c se pot integra foarte uor n limbaje de programare logic (cum e
Prolog de exemplu). Aceasta se realizeaz prin faptul c DCG se bazeaz
pe FOPL (First Order Predicate Logic) n reprezentare.
n DCG:
fiecare regul din gramatic poate fi vzut ca o regul din DCG;
fiecare categorie sintactic se reprezint printr-un predicat cu un
argument ir.
44
Proprieti:
aceeai gramatic se folosete i pentru analiz (recunoatere) i
pentru generare;
procesul de analiz lexical (parsing) se realizeaz exclusiv prin
inferene logice;
ca abordare:
a. Bottom-up parsing forward chaining;
b. Top-down parsing backward chaining.
Folosirea predicatelor are loc astfel:
NP(s) este adevrat dac s este NP
deci,
S NP VP
va deveni
NP(s1) VP(s2) S(append(s1,s2)).
n BNF:
S NP VP
n LP / DGC:
NP(s1) VP(s2) S(append(s1, s2)).
n BNF:
NP Pronoun | Noun
n LP / DGC:
Pronoun(s) Noun(s)
n BNF:
Noun ball | book
n LP / DGC
(s = ball s = book)
45
NP(s)
Noun(s) .
Tabelul 5.1. Soluia comparativ cu limbajul Prolog.

BNF
FOPL/DCG
NP VP NP(s1) VP(s2)
S(append(s1,s2))
NP Noun
Noun(s) NP(s)
Noun
stench
(s = stench s = wumpus)
Noun
Noun(s)
wumpus
Verb(s) VP(s)
VP Verb (v = smells v = kills)
Verb
Verb(v)
smells
Verb kills
PROLOG
sentence([S1, S2])
:- np(S1), vp(S2).
np(S):- noun(S).
noun(stench).
noun(wumpus).
vp(S):- verb(S).
verb(smells).
verb(kills).
?- sentence([wumpus,
smells]).
?-sentence([S1,
S2]).
5.2. Modele de analiz sintactic a propoziiilor

5.2.1. Reele de tranziie cu stri finite - Finite State Transition
Network
MODEL: Moldova has a rich culture.
English is the most widespread language.
I enjoy learning new things.
Pentru a implementa o reea de tranziie cu stri finite RTSF n
limbajul Prolog trebuie s efectum o descriere a reelei, precum i a
modului n care se efectueaz parcurgerea ei. O descriere a RTSF const
din trei componente: numele reelei, o mulime de declarri i o mulime
de descrieri ale arcelor. Exemplu de reea este dat prin automatul de mai
jos figura 5.1.
Acest automat are 8 stri, starea 1 fiind starea iniial, iar starea 8
starea final. Cele opt stri sunt conectate prin 10 arce etichetate.
Numele reelei nu joac un rol anume i nici o alt component nu
face referire la el. El este introdus din motive de consisten i joac un rol
important n definirea reelelor de tranziie recursive.
46
Figura 5.1. Automat

Cea de-a doua component const dintr-o unic declarare
obligatorie a unor stri iniiale i finale. Cea de-a treia component major
a reprezentrii const dintr-o mulime alctuit din una sau mai multe
descrieri ale arcelor, fiecare din acestea avnd aceeai form.
n Prolog, RTSF vor fi prezentate ca reele n mod declarativ, ca
nite structuri de date (fapte din baza de fapte), care pot fi examinate i
manipulate. Avnd o astfel de descriere, se vor putea scrie programe
generale de recunoatere i de generare.
Reprezentarea RTSF ca structuri de date va specifica: nodurile
iniiale, nodurile finale, arcele unde fiecare arc este definit prin nodul de
plecare, nodul de destinaie i eticheta arcului.
Aceste informaii pot fi comunicate n Prolog, utiliznd
predicatele de forma:
initial(Nod).
final(Nod).
arc(Nod_Plecare,Nod_Destinaie,eticheta).
Exemplu:
initial(1).
final(8).
arc(1,n,2).
arc(1,pron,2).
arc(2,v,3).
Desigur, descrierea reelei trebuie completat prin specificarea

semnificaiei abrevierii pe care o reprezint cel de-al treilea argument al
predicatului arc. Aceasta va fi indicat prin utilizarea predicatului:
word(moldova,n).
47
word(has,v).
word(a,art).
Atunci cnd reeaua este utilizat pentru recunoatere, fiecare

moment al parcurgerii ei este caracterizat de dou elemente:
R1. numele unui nod (locaia curent)
R2. irul de intrare rmas
Exemplu:
?- recognize([i,enjoy,learning,new,things]).
Figura 5.2. Rezultatul execuiei recognize().

Atunci cnd reeaua este utilizat pentru generare aceste
elemente vor fi nlocuite cu urmtoarele
G1. numele unui nod (locaia curent)
G2. irul de ieire generat pn la acel moment
Exemplu:
?- recognize(X). /*Figura 5.3*/
Lexicon:
Noun (n) - Moldova | culture | language | things | english
Verb (v) - has | is | enjoy |
Participle (part) - learning
Article (art) a | the | I
Adjective (adj) rich | most | widespread | new
Gramatica:
S NP VP
NP
N | Adj N | Art Adj Adj N |
VP V | V Part
48
Figura 5.3. Rezultatul execuiei recognize(X).

Codul surs:
config([],State):-final(State).
config([Word|Rest],State):word(Word,Cat),
arc(State,Cat,State1),
config(Rest,State1).
recognize(String):initial(State),
config(String,State).
initial(1).
word(a,art).
final(8).
word(rich,adj).
arc(1,n,2).
word(culture,n).
arc(1,pron,2).
word(english,n).
arc(2,v,3).
word(is,v).
arc(3,part,6).
word(the,art).
arc(3,art,4).
word(most,adv).
arc(4,adj,5).
word(widespread,adj).
arc(5,n,8).
word(language,n).
arc(6,adj,5).
word(i,pron).
arc(4,adv,7).
word(enjoy,v).
arc(7,adj,5).
word(learning,part).
word(moldova,n).
word(new,adj).
word(has,v).
word(things,n).
?- recognize([i,enjoy,learning,new,things]).
Yes.
49
5.2.3. Analiza propoziiei bazat pe cadre - Sentence Frame

Grammars.
MODEL: Moldova has a rich culture.
English is the most widespread language.
I enjoy learning new things.
Codul surs pentru sfg_rec.pl:
/* sentence frame grammar */
recognize(String):transform(String,CatString),
frame(CatString).
/*transformarea unui sir de cuvinte intr-un sir de
categrorii lexicale*/
transform([],[]).
transform([Word|String],[Cat|CatString]):word(Word,Cat),
transform(String,CatString).
Codul surs pentru lex.pl:

/*baza
de
fapte
lexicale*/
word(moldova,n).
word(has,v).
word(a,art).
word(rich,adj).
word(culture,n).
word(english,n).
word(is,v).
word(the,art).
cuvintelor
cu
categoriile
word(most,adv).
word(widespread,adj).
word(language,n).
word(i,pron).
word(enjoy,v).
word(learning,part).
word(new,adj).
word(things,n).
Codul surs pentru sf.pl:

/*lista propoziiilor cadre*/
frame([n,v,art,adj,n]).
frame([pron,v,part,adj,n]).
frame([n,v,art,adv,adj,n]).
Deschidei fiierul sfg_rec.pl

/*incarcarea fisierelor cu baza de fapte si lista cadrelor*/
?-consult(lex.pl).
?-consult(sf.pl).
50
?transform([english,is,the,most,widespread,language],Ca
tString).
CatString=[n,v,art,adj,n]
5.2.4. Definite Clause Grammars (DCG)

Conversia regulilor structurii propoziiei (phrase structure PS) n
clauze Prolog este att de simpl, nct se poate efectua n mod automat.
Prologul include o facilitate pentru a realiza acest lucru, i anume, o
extindere a notaiei numit notaie DCG (Definite-Clause Grammar).
Aceasta reprezint o notaie special pentru regulile unei gramatici.
Exemple de clauze scrise prin notaia DCG sunt:
s --> np, vp.
np --> adj, n.
n --> [elev].
Aceste clause vor fi automat convertite, n faza de consultare, la:

s(X,Z):-np(X,Y),vp(Y,Z).
np(X,Z) :-adj(X,Y), n(Y,Z).
n([elev|X],X).
Sistemul DCG reprezint un compilator pentru regulile gramaticii

pe care le traduce direct n clauze Prolog executabile.
Prin gramatici DC se nelege acele gramatici ale cror reguli de
rescriere sunt exprimate n notaia DCG. O gramatic scris n DCG
reprezint un program de parsing pentru ea nsi.
Un program Prolog poate conine att reguli DCG, ct i clauze
Prolog obinuite. Translatorul DCG afecteaz numai clauzele ce conin
functorul -->. Toate celelalte clauze sunt presupuse a fi clauze Prolog
obinuite i sunt lsate neschimbate. Translatorul transform regulile
DCG n clauze Prolog prin adugarea a dou argumente suplimentare
corespunztor fiecrui simbol care nu se afl inclus ntre paranteze sau
acolade. Argumentele sunt n mod automat aranjate astfel, nct s poat fi
corect utilizate n procesul de analiz sintactic.
O regul DCG are forma:
Simbol neterminal --> extindere
unde extindere const n unul dintre urmtoarele elemente:

un simbol neterminal (ex. np);
51
o list de simboluri terminale (ex. [husband] sau [husband,

drinks]);
un scop Prolog inclus ntre acolade cum ar fi {write (Gasit
NP)};
un element vid reprezentat prin [ ];
o serie de oricare dintre aceste elemente, separate prin virgule.
n ce privete sintaxa DCG, e de notat c simbolurile neterminale nu
se mai afl ntre paranteze, n timp ce simbolurile terminale sunt incluse
ntre paranteze drepte, ceea ce le transform n liste Prolog. Simbolurile
sunt separate prin virgule i fiecare regul se ncheie prin punct.
Fiecare regul DCG este tradus ntr-o clauz Prolog conform
urmtoarei scheme:
dac regula DCG conine n membrul drept numai simboluri
neterminale, este de forma:
n->n1,n2,...,nn cu n1,n2,...,nn simboluri
neterminale, atunci ea este tradus n clauza Prolog
n(X,Y):-n1(X,Y1), n2(Y1,Y2),...,
nn(Yn-1,Y).
dac regula DCG conine n membrul drept att simboluri

neterminale, ct i terminale, are forma:
n-->n1, [t2],n3, [t4].
cu n1,n3 simboluri neterminale i t2,t4 simboluri terminale,
atunci ea este tradus n clauza Prolog:
n(X,Y):-n1(X, [t2|Y1]), n3(Y1, [t4|Y])
Figura 5.4. Analiza propoziiei
52
Codul surs:
s(s(GN1,GV))-->gn1(GN1),gv(GV).
gn1(gn1(PRON,N))-->pron(PRON),n(N).
gv(gv(V,GN3,GN2))-->v(V),gn3(GN3),gn2(GN2).
gn3(gn3(ADJ1,N1,PREP1,ADJ2,N2)-->
adj1(ADJ1),n1(N1),prep1(PREP1),adj2(ADJ2),n2(N2).
gn2(gn2(PREP2,ART,N3))-->
prep2(PREP2),art(ART),n3(N3).
pron(pron(my))-->[my].
n(n(husband))-->[husband].
v(v(drinks))-->[drinks].
adj1(adj1(innumerable))-->[innumerable].
n1(n1(cups))-->[cups].
prep1(prep1(of))-->[of].
adj2(adj2(black))-->[black].
n2(n2(coffee))-->[coffee].
prep2(prep2(during))-->[during].
art(art(the))-->[the].
n3(n3(day))-->[day].
?-phrase(s(X),[my, husband, drinks, innumerable, cups,
of, black, coffee, during, the, day]).
X = s(gn1(pron(my), n(husband)), gv(v(drinks),
gn3(adj1(innumerable), n1(cups), prep1(of),
adj2(black), n2(coffee)), gn2(prep2(during), art(the),
n3(day))))
Yes.
53
5.2.5. Recursive Transition Network

MODEL: Our students enjoy learning new things.
Figura 5.5. RTN

Tabelul 5.2. RTN soluie
String
Our students enjoy
learning new things
Our students enjoy
learning new things
students enjoy learning
new things
enjoy learning new
things
enjoy learning new
things
enjoy learning new
things
learning new things
new things
new things
things
-
State
S1
NP1
NP2
NP3
S2
VP1
VP2
VP3
NP1
NP2
NP3
VP4
S3
Stack
S2
S2
S2
S3
S3
S3
VP4,S3
VP4,S3
VP4,S3
S3
-
54
Comment
Push to NP-net
Recognize
pron
Recognize
noun
Pop to S-net
Push to VP-net
Recognize
verb
Recognize
verb part1
Push to NP-net
Recognize
adj
Recognize
noun
Pop to VP-net
Pop to S-net
SUCCESS!
Codul surs pentru pdr.pl:

% Definirea predicatului ce seteaza
initiala
recognize(String):initial(s,State),
config(s:State,String,[]).
configurarea
% Configurarea finala
config(s:State,[],[]):final(s,State).
% If in final state for network pop back to previous
network
config(Network:State,String,[Network1:State1|Stack]):final(Network,State),
config(Network1:State1,String,Stack).
% Process next lexical item
config(Network:State,[Word|String],Stack):word(Word,Cat),
arc(Network,State,Cat,State1),
config(Network:State1,String,Stack).
% If next arc label refers to a network push to it
config(Network:State,String,Stack):arc(Network,State,Network1,State1),
initial(Network1,State2),
config(Network1:State2,String,[Network:State1|S
tack]).
Codul surs pentru rtn.pl:

initial(s,1).
final(s,3).
arc(s,1,np,2).
arc(s,2,vp,3).
initial(vp,1).
final(vp,4).
arc(vp,1,v,2).
arc(vp,2,vp1,3).
arc(vp,3,np,4).
initial(np,1).
final(np,3).
arc(np,1,pron,2).
arc(np,2,n,3).
arc(np,1,adj,2).
initial(np,1).
final(np,3).
arc(np,1,adj,2).
arc(np,2,n,3).
Codul surs pentru lex.pl:

word(our,pron).
word(students,n).
word(enjoy,v).
55
word(learning,vp1).
word(new,adj).
word(things,n).
?-consult(rtn.pl).
?-consult(lex.pl).
?-recognize([our,students,enjoy,learning,new,things]).
Yes.

S se elaboreze un program n limbajul Prolog, care ar analiza sintactic
trei propoziii/fraze n limba romn dup exemplele prezentate mai sus
(implementarea a cel puin 2 metode).
Raportul trebuie s conin:
1) formularea scopului i obiectivelor de cercetare;
2) descrierea lexiconului i gramaticii;
3) analiza propoziiilor prin metodele utilizate;
4) listing-ul programul cu comentarii i explicaii, justificri;
5) concluzii cu privire la experimentele efectuate.
56

Algoritmi de recunoatere
Scopul: nsuirea i consolidarea cunotinelor i deprinderilor practice
de lucru cu algoritmi simpli de recunoatere a obiectelor dup
caracteristicile de calitate.
n cele mai multe cazuri, imaginile sunt caracterizate cu ajutorul
unor caracteristici cantitative: dimensiuni geometrice, greutate, arie,
volum, i altele.
n aceste cazuri schimbrile cantitative ce caracterizeaz o anumit
imagine, de obicei nu duc imediat la schimbarea de comportament.
Atingnd doar anumite limite pentru fiecare imagine, schimbrile
cantitative cauzeaz un salt cuantic pentru a trece la urmtoarea imagine.
Imaginile propriu-zise i imaginile specifice pot fi caracterizate nu
numai cantitativ, dar i de caracteristicile calitative (proprieti, semne,
atribute).
Aceste semne nu pot fi descrise (sau de obicei nu au fost descrise)
cantitativ cum ar fi culoarea, gustul, simul, mirosul.
Imaginile pot avea sau nu avea unele caracteristici de calitate.
ntre caracteristicile calitative i cantitative ale imaginilor exist o
diferen important, cu toate acestea, diferena n multe cazuri nu e
necesar s fie evideniat, deoarece pentru fiecare atribut calitativ exist n
anumite zone ale parametrilor cantitativi, limite care schimb i atributul
de calitate.
De exemplu, o imagine cu o culoare specific corespunde unei
game de lungimi de und specific undelor electromagnetice, n limitele
creia se schimb culoarea.
Exist abordri diferite privind recunoaterea caracteristicilor
calitative ale imaginii. n acest laborator vom lua n considerare una dintre
ele, bazndu-ne pe codarea binar, prezena sau absena unei trsturi de
calitate.
n cadrul acestei abordri analizm o imagine concret Xk.
57
Caracteristicile calitative pot fi reprezentate ca un vector binar:
Xk
x k1 , x k 2 , ... , x kn
unde: n - dimensiunea spaiului de caracteristic.

Dac imaginea Xk conine j-m semne, atunci Xkj = 1, n caz
contrar avem Xkj = 0. Aici este identificat imaginea i vectorul binar
descriptiv.
Lum ca exemplu patru obiecte (viin, portocal, mr, pepene
galben), fiecare obiect avnd trei caracteristici: culoare, prezena
smburilor sau seminelor (tabelul 6.1). n tabelul 6.2 sunt date valorile
numerice ale atributelor pentru prob dup codificarea lor binar.
Cea mai simpl metod pentru rezolvarea problemelor de
recunoatere a obiectelor cu caracteristici de calitate, dup codificarea
binar a atributelor const n reducerea problemei iniiale la rezolvarea
problemei recunoaterii imaginii cu caracteristicile cantitative ale spaiului
vectorial n-dimensional.
Pentru aceasta e necesar ca la fiecare tip de atribut de calitate s
fie introdus o ax n spaiul vectorial n-dimensional. Dac pentru analiza
imaginii semnul exist, atunci pe ax este indicat unitatea, dac nu,
atunci zero.
Tabelul 6.1. Prezena smburilor sau seminelor n imagini
Vector
galben oranj
rou
smbure
Viin
X1
nu
nu
da
da
Portocal X2
nu
da
nu
nu
Mr
X3
da
nu
da
nu
Pepene X4
da
nu
nu
nu
gal.
galben 6.2. Trsturile calitative ale imaginilor
Tabelul
Vector
galben
oranj
rou
smbure
semn
Viin
X1
x11 = 0 x12=0
x13= 1 x14= 1
Portocal X2
x21= 0 x22= 1 x23=0
24=0
Mr
X3
x31= 1 x32=0
x33= 1 x34=0
Pepene X4
x41= 1 x42=0
x43=0
x44 =0
gal.
58
semine
nu
da
da
da
semine
x15=0
x25= 1
x35= 1
x45= 1
Drept rezultat obinem un spaiu multidimensional caracteristic

binar, unde poate fi calculat o gam de distane, utilizat pentru
recunoaterea obiectelor cu caracteristici cantitative.
n acest exemplu, ca urmare a caracteristicilor cantitative, sau mai
bine spus a trsturilor calitative (tabelul 6.2), obinem un spaiu de cinci
dimensiuni cu valori binare, unde putem utiliza distana lui Euclid (1) i
Minkowski (2), distane ce folosesc suma diferenelor absolute dintre
componentele respective ale vectorilor n-dimensionali (3):
n
L1 S i , X j
sik
x jk
sik
x jk
sik
x jk ,
(1)
(2)
k 1
n
L2 S i , X j
k 1
n
L3 S i , X j
(3)
k 1
unde:
L p Si , X j ,
p 1,3
(4)
corespunde distanei dintre imaginea de intrare:
Si
s i1 ,..., s in
(5)
cu imaginea model:
Xi
xi1 ,..., xin ,
(6)
iar parametrul j reprezint numrul modelului, iar un rezultat pozitiv
ntreg, mai mare ca doi.
Distanele (1) - (3) pot fi, de asemenea, utilizate cu coeficieni de
greutate. Codificarea binar a caracteristicilor calitative poate fi aplicat i
la distana Hamming, care este introdus pentru toi vectorii binari.
Distana Hamming dintre doi vectori binari este numrul de componente
distincte de vectori binari. n cazul n care vectorii au aceleai
componente, distana dintre ei este zero, n cazul n care vectorul nu are o
component echivalent, distana este egala cu dimensiunea vectorilor.
O clasificare mai fin a obiectelor cu caracteristici calitative se
obine prin introducerea compatibilitii sau diferenei, pentru fiecare
pereche de obiecte Xj, Xi pentru care sunt introduse caracteristici
calitative binare de codare, utiliznd tabelul 6.3.
59
Tabelul 6.3. Compatibilitatea i diferena

Xi
Xj
1
0
1
h
0
g
b
Variabila a n tabelul 6.3 este proiectat pentru a contoriza
numrul de caracteristici comune ale obiectelor Xj i Xi. Ea poate fi
calculat utiliznd relaia:
n
x jk xik ;
(7)
k 1
unde: xjk, xik sunt componente binare de vectori care descriu Xj obiecte,
i Xi obiecte.
Cu ajutorul variabilei b calculm numrul de cazuri n care
obiectele Xj, i Xi nu au acelai semn:
n
1 x jk 1 xik .
(8)
k 1
Variabilele g i h sunt folosite, respectiv, pentru a calcula numrul de

caracteristici care sunt atestate la obiectul Xi i lipsesc n Xj i sun atestate
la obiectul Xj i lipsesc din Xi:
n
xik 1 x jk ;
(9)
1 xik x jk .
(10)
k 1
n
h
k 1
Din analiza variabilelor a, b, g, h rezult urmtoarele: cu ct este

mai mare asemnarea dintre obiectele Xj i Xi, cu att mai mare trebuie s
fie variabila a. Msura de apropiere a obiectelor sau a funciei de
asemnare trebuie s fie o funcie cresctoare a lui a, funcia de asemnare
trebuie s fie simetric n raport cu variabilele g i h.
Relativ la ncheiere, variabila b nu poate fi utilizat, pentru c pe
de o parte lipsa caracteristicilor similare n obiecte poate fi un indiciu al
asemnrii lor, pe de alt parte, n cazul n care obiectul nu are aceleai
semne, nseamn c aceste obiecte nu se pot referi la aceeai clas.
60
De cele mai multe ori sunt utilizate n mod obinuit funciile de

similitudine reprezentate mai jos:
Funcia de similitudine de Russell i Rao:
S1 X i , X j
a
a b g
a
;
n
(11)
Funcia de similitudine Zhokara i Nidmena:
S2 X i , X j
n b
Funcia de similitudine Dice:
a
2a g
S3 X i , X j
(12)
(13)
Funcia de similitudine de Snifa i Sokal:
a
a 2( g
S4 X i , X j
h)
(14)
Funcia de similitudine de Sokal i Michener:
S5 X i , X j
a b
;
n
(15)
Funcia de similitudine Kulzhinskogo:
S6 X i , X j
a
g
(16)
Funcia de similitudine Yule:
ab gh
;
ab gh
S7 X i , X j
61
(17)

1. Se va proiecta un algoritm i un program care simuleaz
recunoaterea diferitor obiecte cu caracteristici calitative i a caracteristici
de asemnare S1-S7.
2. Se va seta numrul de caracteristici calitative ale obiectelor n i
numrul de tone a imaginilor, avnd ca referin imaginile (gropile trebuie
s fie de cel puin 4). Se va adresa la cteva obiecte i caracteristici de
similitudine S1-S7, astfel indicnd apartenena la un ablon anumit.
3. Se va oferi o funcie unic de similitudini ale obiectelor cu
caracteristici de calitate i se va arta performana de lucru, utiliznd
exemplele din punctul 2.
4. Se va compune o funcie proprie n aa fel, nct s fie similar
cu exemplele de recunoatere prezentate n S1-S7, totodat una din funcii
trebuie s ia o valoare minim, iar alta - maxim.
5. Se vor sugera cteva exemple de recunoatere folosind distana
Hamming. ntr-un exemplu distana Hamming ar trebui s ia o valoare
egal cu numrul de pe list din grup, conform registrului.
6. Se va propune un exemplu de recunoatere n cadrul cruia
valoarea distanei Hamming este egal cu una dintre funciile de
similitudine S1-S7.
62

Algoritmi de recunoatere a imaginilor
Scopul: Obinerea cunotinelor i abilitilor practice pentru lucrul cu cei
mai simpli algoritmi de recunoatere, care au la baz prezentarea
imaginilor n form de puncte sau de vectori n-dimensionali ntr-un spaiu
vectorial
Exist un numr mare de forme de reprezentare ale imaginilor n
dispozitivele de recunoatere sau n aplicaii. Una dintre cele mai simple i
pe nelesul tuturor este forma, care folosete reprezentarea imaginilor ca
fiind nite puncte sau vectori ntr-un oarecare spaiu n-dimensional.
Fiecare ax a acestui spaiu, n mod natural, corespunde cu una din n intrri
sau cu unul din n receptori ai reelei de recunoatere. Fiecare receptor
poate s se afle n una dintre m stri, dac ele sunt discrete sau s posede o
infinitate de stri n cazul cnd receptorii sunt continui.
n funcie de tipul receptorilor utilizai, se poate genera un spaiu
vectorial n-dimensional continuu, discret sau continuu-discret.
n aceast lucrare de laborator vom examina un spaiu ndimensional continuu.
Msura asemnrii imaginilor n spaiul vectorial n-dimensional se
introduce ca funcie de dou variabile L(Sk, Si), unde Sk, Si S;
S = {S1, S2, ..., Sn} mulimea final de imagini n spaiul examinat.
n acelai timp, funcia L(Sk, Si) posed urmtoarele caracteristici:
este simetric, adic L(Sk, Si) =L(Si, Sk);
valorile funciei sunt numere nenegative;
msura asemnrii imaginii cu sine nsui, ia o valoare

extrem n comparaie cu oricare alt imagine, adic, n funcie de
modul introducerii msurii de asemnare, se ndeplinete una din
urmtoarele dou expresii:
(1)
L S ,S
max L S , S ;
k
63
L Sk , Sk
min L S k , S i ;
(2)
n cazul imaginilor compacte, funcia L(Sk, Si) este o

funcie monoton la funcia de ndeprtare a punctelor Sk i Si n
spaiul n-dimensional.
n spaiul n-dimensional, msura de asemnare a imaginilor poate
fi introdus n multe moduri. Vom examina mai multe din ele. n fiecare
mod se considera c imaginea etalon 1, X2, .. ,. clase diferite de
imagini n spaiul vectorial n-dimensional, se introduc n form de vectori
cu proieciile la axele de coordonate: 1 = (x11, x12, , x1n), X2 = (x21, x22,
, x2n), ..., = (xm1, xm2, , xmn). Orice imagine de intrare Si S la fel se
reprezint n form de vector Si = (Si1, Si2, ..., Sin) n aceast dimensiune.
7.1. Recunoatere n funcie de unghiul dintre vectori
Msura asemnrii dintre doi vectori ntr-un spaiu n-dimensional
poate fi reprezentat sub form de unghi. Dac este dat imaginea de
intrare Si = (Si1, Si2, ..., Sin) i vectorii imaginilor - etalon 1=(x11, x12, ,
x1n), X2 = (x21, x22, , x2n), ..., = (xm1, xm2, , xmn), atunci msura asemnrii
ntre imaginile de intrare i cele etalon, se determin din relaia
n
L Si , X j
arccos
si1 x j1
si21
si22
si 2 x j 2
... sin2
sik x jk
... sin x jn
x 2j1
x 2j 2
...
x 2jn
arccos
k 1
Si
Xj
(3)
unde: |Si|, |Xj| - lungimile vectorilor Si i Xj.

Apartenena imaginii de intrare Si la una dintre m imagini se
determin din urmtoarea regul decisiv:
Si
X j , dac L S i , X j
min L S i , X j .
j
(4)
n acelai timp, n aceast regul i mai departe n text, pentru

notarea imaginii j i a imaginii - etalon se folosete aceeai notare
Xj j
1, m .
64
7.2. Recunoaterea imaginilor dup produsul lor scalar

Msura asemnrii imaginilor dup unghiul dintre (3) se
bazeaz pe produsul scalar al vectorilor:
n
Sj,X j
S i X j cos
sik x jk .
(5)
k 1
Unele sisteme de recunotere folosesc nemijlocit produsul scalar n

calitate de msur de asemnare a imaginilor ntr-un spaiu n-dimensional
vectorial:
n
L Si , X j
(6)
sik x jk .
k 1
n acest caz apartenena imaginii de intrare Si la o oarecare

imagine - etalon, se determin din urmtoarea regul decisiv:
(7)
S i X j , dac L S i , X j max L S i , X j .
j
7.3. Recunoaterea imaginilor dup apartenena acestora la o zon de

spaiu dat
La acest mod de recunoatere, tot spaiul de imagini V se mparte
n zone care nu se intersecteaz V1, V2, ..., Vm, Vm+1, unde V1, V2, ..., Vm zone ce conin imagini numai la o imagine virtual corespunztoare 1,
2, ..., ; Vm+1 - zon care nu conine imagini, ce se refer la imaginile
virtuale date. n acest caz, apartenena imaginii de intrare Si = (Si1, Si2, ...,
Sin) la o oarecare imagine virtual j ( j
decisiv:
Si
1, m ) se determin din regula
X j , dac (si1 , si 2 ,..., sin ) V j .
Dac zona Vj ( j
(8)
1, m ) este reprezentat n spaiul euclidian n

*
*
*
form de sfere cu centrul n punctele ( x j1 , x j 2 ,..., x jn ) i cu razele Rj ,
atunci regula decisiv (8) va lua forma:
65
Si
X j , dac
x *jk
L Si , X j
sik
Rj .
(9)
k 1
Pentru construirea zonelor n spaiul de imagini se pot folosi

oricare din metodele de asemnare, ca de exemplu, dinstanele cu
coeficiente care posed o capacitate (10)-(12), distana dup Camberr (13)
.a.m.d.:
n
L Si , X j
sik
x jk
sik
x jk
sik
x jk ;
(10)
(11)
k 1
L Si , X j
k 1
n
L Si , X j
(12)
k 1
n
sik
x jk
k 1
sik
x jk
L Si , X j
unde:
(13)
1, n coeficienii cu capacitate;
numr ntreg pozitiv, mai mare dect 2.

Regula decisiv (8) pentru distanele (10)-(12) va lua forma:
Si
X j , dac L S i , X j
Rij
Rj ,
(14)
unde: Rij distana dat de una din relaiile (10)-(13), ntre imaginea
prezentat Si i centrul sferei, care conine imaginea virtual j;
Rj raza sferei care conine imaginea virtual j.
n cazul folosirii pentru recunoaterea unghiului dintre vectorii
zoneleor ce nu se intersecteaz Vj ( j
1, m ), se reprezint n form de
conuri, iar regula decisiv va avea forma: Si
66
X j , dac
L Si , X j
unde:
j max
ij
ij
arccos
s i1 x j1
s i21
s i 2 x j 2 ... s in x jn
s i22 ... s in2
x 2j1
x 2j 2 ... x 2jn
j max
(15)
- unghiul dintre imaginile prezentate Si i imaginile etalon Xj,
- unghiul maxim admisibil pentru imaginea virtual j dintre etalon
i imaginile pentru recunoatere.

1. Se va elabora algoritmul i programul care modeleaz
recunoaterea a ctorva obiecte diferite ntr-un spaiu vectorial ndimensional dup unghiul dintre vectori i dup produsul lor scalar.
2. Se va stabili dimensiunea vectorului n-dimensional al spaiului
cu numrul de obiecte etalon (n i m trebuie s fie nu mai mici dect 5)
i cu cteva obiecte pentru recunoatere. Cu ajutorul unghiului dintre
vectori i produsul lor scalar se va determina apartenena obiectelor
prezentate pentru testare la un oarecare obiect - etalon.
3. Se va elabora algoritmul i programul care modeleaz
recunoaterea a ctorva obiecte diferite la apartenena lor la zonele sferice
sau conice ntr-un spaiu vectorial n-dimensional.
4. Se va stabili dimensiunea vectorului n-dimensional al spaiului
cu numrul de obiecte - etalon i cu cteva obiecte pentru recunoatere.
Prin intermediul zonelor sferice sau conice ce conin obiectele - etalon
determinai apartenena obiectelor prezentate pentru testare la un oarecare
obiect - etalon.
67

Reelele neuronale Hamming
Scopul: nsuirea i consolidarea cunotinelor, precum i formarea
deprinderilor practice privind lucrul cu reelele neuronale Hamming.

Reeaua Hamming este una dintre cele mai performante reele
neuronale pentru recunoatere i clasificare. n aceast reea imaginile albnegru sunt prezentate sub form de vectori bipolari m-dimensionali.
Denumirea reelei provine de la distana Hamming, care se folosete n
reea pentru msurarea asemnrii a R imagini de intrare i a celor etalon, pstrate cu ajutorul balanei de legturi a reelei. Msura
asemnrii se determin din relaia:
R = m-Rx,
(1)
unde: m componenta numeric a vectorilor de intrare i etalon;
Rx distana Hamming dintre vectori.
Definiie:
Distana Hamming dintre doi vectori binari este componenta numeric n
care vectorii sunt diferii.
Din definiie rezult c msura de asemnare a imaginilor (1)
poate fi redat prin numrul , care este componenta vectorilor binari n
care ei coincid: R = .
Vom deduce pentru vectorii bipolari S = (S1 ,...,sm) Z = (z1
,...,zm) produsul lor scalar prin numrul de componente care coincid i de
componentele care sunt diferite:
68
SZ
Si Z i
d,
(2)
i 1
unde: a numrul de componente identice ale vectorului;

d numrul de componente diferite ale vectorilor S i Z.
Deoarece dimensiunea vectorilor, atunci m = + d i rezult
c produsul scalar (2) poate fi scris n forma:
SZ = 2 - m.
De aici nu este greu de determinat:
m
2
SZ
2
m
2
Si Z i .
(3)
i 1
Partea dreapt a expresiei (3) poate fi privit ca semnalul de

intrare a neuronului, care are m sinapse, cu coeficientul de greutate zi/2 (i
= 1,m) i cu deplasamentul m/2. Sinapsele neuronului recunosc m
componente ale vectorului de intrare S = (s1, .., sm). Aceast interpretare a
prii drepte a expresiei (3) reprezint arhitectura unei subreele
neuronale, care este redat de partea de jos a figurii 8.1. n unele surse
reeaua din figura 8.1. este numit reea Hamming, altele numesc reea
Hamming doar partea de jos a figurii, considernd c reeaua este format
din dou subreele - Hamming i MaxNet. Noi vom considera c este o
reea Hamming.
69
Figura 8.1. Exemplu de Reea Hamming

Reeaua Hamming are m neuroni de intrare S1, , Sm , care
recunosc componentele bipolare s1q, , smq ale imaginilor de intrare Sq
(q=1,L). Semnalele de ieire ale elementelor S se determin din relaia:
U out Si
unde:
1, dac Siq 1
1, dac Siq
(4)
Uout > U ieire;

Uin -> U intrare .
Rezult c semnalul de ieire a elementului S repet semnalul lui

de intrare:
Uout Si = Uin Si = siq .
70
Fiecare neuron Sj (j=1, m) este legat cu intrarea fiecrui element

Zk (k=1, n). Capacitatea acestor legturi W1k, , Wmk conine informaia
despre imaginea - etalon k:
(5)
Vk = (v1k,, vmk): w1k = v1k/2, , wmk=vmk/2.
Funcia de activare a Z-elemente este descris de relaia:
g z U in
0, dac U in 0
k1U in , dac 0 U in U n
(6)
U n , dac U in U n
unde: Uin semnalul de intrare a neuronului; k1 i U constante.
La descrierea imaginii S* = (s1*, , sm*) fiecare Z-neuron
calculeaz semnalul lui de intrare n conformitate cu expresia (3):
U in z k
m
2
wik si*
(7)
i 1
i cu ajutorul funciei de activare determin semnalul de ieire UinZk.

Semnalele de ieire UinZ1, , UinZn a Z-elemente sunt semnale de intrare
1, ..., n a subreelei de sus, care este o reea MaxNet. Funcia de activare
a neuronilor Ap (p=1,n) i capacitatea lor de legtur sunt date de relaia:
g U in
wij
U in , dac U in
0, dac U in
0
0
1, dac i j
, dac i j, i, j 1, n
unde: constanta care satisface inegalitatea 0 < 1/n.

Reeaua funcioneaz ciclic, iar dinamica neuronilor este redat de
relaia iterativ:
71
Ui t 1
g Ui t
U j t , i 1, n
(8)
j 1, j i
cu condiiile iniiale:
Ui(0)=ai=UinZi, i=1,n.
Dac printre semnalele de intrare 1 ,..., an alr neuronilor A1, ...,
An este un semnal cel mai nalt ( {1, 2, ..., n}), atunci n urma
procesului iterativ, n subreeaua MaxNet va figura un singur neuron ,
care va rmne ca semnal de ieire, mai mare ca 0, adic va deveni
"nvingtor", dei semnalele de ieire U1, ..., Up, ..., Un ale -elemente vin
la intrrile a Y-neuroni care au funcia de activare de forma:
gY U in
1, dac U in 0
0, dac U in 0
(9)
Atunci la ieirea reelei Hamming doar un singur neuron Yp va

avea un singur semnal de ieire. Ieirea unic a acestui neuron i ieirile
nule ale celorlali neuroni vor indica c imaginea redat S*=(s1*, , sm*)
este cea mai aproape, n sensul msurii de asemnare date (1) de
imaginea- etalon Vp=(v1p, , vmp).
Un avantaj esenial al reelei Hamming const n faptul c nu
necesit proceduri complicate de calcul pentru nvarea sa. Un neajuns
esenial al reelei const n faptul c aceasta nu produce dou sau mai
multe imagini de referin, avnd acelai nivel de asemnare cu imaginile
impuse.
Exemple:
S se elaboreze o reea Hamming, avnd n calitate de etalon 5
imagini alb-negru V1, ..., V5 artate n figura 8.2. S se determine
influena imaginilor prezentate n figura 8.3.
72
Figura 8.2. Imagini-etalon
Figura 8.3. Imagini pentru testare
Figura 8.4. Numerotarea elementelor-imaginii

ntruct avem doar 5 imagini-etalon, reeaua va trebui s aib cte
5 Z-, -, Y-neuroni. Prezena a 9 elemente alb-negru n imaginile din
figura 8.2 i figura 8.3 determin 9 S-neuroni, care recunosc elementele
imaginilor de intrare.
Vom numerota elementele imaginilor din Figura 8.2. i Figura
8.3. n conformitate cu Figura 8.4. i vom prezenta imaginile Vp ( = 1,S)
n form vectorial, folosind reprezentarea bipolar a vectorilor:
V 1 = (-1,1, -1,-1, 1,-1, -1,1,-1);
V 2=(1, 1,1, 1,-1, 1,1,-1,1);
V 3=(1,-1,1, 1,1, 1,1,-1,1);
V 4=(1, 1,1, 1,-1,-1, 1,-1,-1);
V 5=(-1, -1,-1, -1,1,-1,-1,-1,-1).
73
Cunoscnd vectorii imaginilor de intrare i numrul lor n raport

cu (5), determinm matricea |Wik| (i = 1,9, k = 1,5) de capaciti a
legturilor prii de jos a subreelei reelei Hamming:
Wik
V 1 ( Z1 ) V 2 ( Z 2 ) V 3 ( Z 3 ) V 4 ( Z 4 ) V 5 ( Z 5 )
S1 0.5
0.5
0.5
0.5
0.5
S 2 0.5
0.5
0.5
0.5
0.5
S3 0.5
0.5
0.5
0.5
0.5
S 4 0.5
0.5
0.5
0.5
0.5
S5 0.5
0.5
0.5
0.5
0.5
S6 0.5
0.5
0.5
0.5
0.5
S7 0.5
0.5
0.5
0.5
0.5
S8 0.5
0.5
0.5
0.5
0.5
S9 0.5
0.5
0.5
0.5
0.5
(10)
unde pentru claritate rndurile i coloanele matricei sunt numerotate

corespunztor cu ajutorul elementelor S i a imaginilor-etalon V sau
neuronilor Zp, luai n paranteze.
Deplasrile b1,..., b5 neuronilor Z se calculeaz cu ajutorul
expresiei (11):
b1 = b2 = = b5 = m/2 = 9/2 = 4,5.
(11)
Funcia de activare a neuronilor Z este redat de expresia (6) cu

k1= 0,1 i U =1/k1 =1/0.1=10. Funciile de activare a neuronilor Y le
determinm ca funcii (9). Constanta determin capacitatea invers a
legturilor n subreeaua MaxNet. Vom determina egalitile = 1/n, unde
= 5 i = 0,2.
Cunoscnd toi parametrii reelei Hamming, vom urmri
funcionarea ei la prezentarea imaginii S1 = (-1, -1, 1, 1, 1, 1, 1,-1, 1)
(figura 8.3).
74
Dup prezentarea imaginii S1 la ieirea neuronilor S, cu toate

semnalele lor de ieire ce le repet pe cele de intrare [relaia (4)], vom
obine vectorul de semnale Sout s = S1. Folosind semnalele de ieire a
elementelor semnalelor S, fiecare neuron S calculeaz semnalul propriu de
intrare conform relaiei (7), matricea capacitilor (10) i deplasamentul
bk, k=1,5 (11):
9 9
U in.Z 1
wi1 S i1 4,5 ( 0,5) ( 1) 0,5 ( 1) ( 0,5) 1 ( 0,5) 1
2 i1
0,5 1 ( 0,5 1) ( 0,5) 1 ( 0,5) ( 1) ( 0,5) 1 2;
9
9
U in.Z 2
wi 2 S i1 4,5 0,5 ( 1) 0,5 ( 1) 0,5 1 0,5 1
2 i1
( 0,5) 1 0,5 1 0,5 1 ( 0,5) ( 1) 0,5 1 6;
U in.Z 3
9
2
wi 3 S i1
4,5 0,5 ( 1)
( 0,5) ( 1)
0,5 1 0,5 1
i 1
0,5 1 0,5 1 ( 0,5) ( 1)

U in.Z 4
0,5 1 8;
9
2
wi 4 S i1
4,5 0,5 ( 1)
0,5 ( 1)
0,5 1 0,5 1
i 1
( 0,5 1)
( 0,5) 1 0,5 1 ( 0,5) ( 1)
( 0,5) 1 4;
9 9
wi 5 S i1 4,5 ( 0,5) ( 1) ( 0,5) ( 1) ( 0,5) 1
2 i1
( 0,5) 1 0,5 1 ( 0,5) 1 ( 0,5) 1 ( 0,5) ( 1) ( 0,5) 1 4.
U in.Z 5
Dup semnalul de intrare Uin Zk, folosind funcia proprie de

activare (6) cu k1= 0,1 i U =10, fiecare neuron Z determin semnalul su
de ieire:
U out .Z 1
k1U in.Z 1
0,1 2
0,2 ;
U out .Z 2
k1U in.Z 2
0,1 6
0,6 ;
U out .Z 3
k1U in.Z 3
0,1 8
0,8 ;
U out .Z 4
k1U in.Z 4
0,1 4
0,4 ;
U out .Z 5
k1U in.Z 5
0,1 4
0,4 .
75
Vectorul:
Uout Z = (0,2; 0,6; 0,8; 0,4; 0,4)
reprezint vectorul de intrarea a subreelei MaxNet i ncepe procesul
iterativ de alocare a semnalului maxim de ieire cu condiiile iniiale
(12). Pentru t =1 vom avea:
5
U out . A1 (1)
g (U outA1 (0)
U outAk (0))
g (0,2 0,2(0,6 0,8 0,4
k 2
0,4))
g ( 0,24)
0;
U out . A2 (1)
g (U outA2 (0)
U outAk (0))
g (0,6 0,2(0,2 0,8 0,4
k 1, k 2
0,4))
g (0,24)
0,24;
U out . A3 (1) g (U outA3 (0)
U outAk (0))
g (0,8 0,2(0,2 0,6 0,4
k 1, k 3
0,4))
g (0,48) 0,48;
U out . A4 (1) g (U outA4 (0)
U outAk (0))
g (0,4 0,2(0,2 0,6 0,8
k 1, k 4
0,4))
g (0) 0;
U out . A5 (1) g (U outA5 (0)
U outAk (0))
g (0,4 0,2(0,2 0,6 0,8
k 1
0,4))
g (0) 0;
Folosind vectorul (Uout A1(1), ..., Uout A5 (1)) al semnalelor de

ieire a elementelor A cu t = 1, analogic se determin semnalele de ieire
a neuronilor A cu t = 2, 3 i 4. Rezultatele calculelor sunt redate n
tabelul 8.1.
Procesul iterativ n subreeaua MaxNet se termin cnd t =5. n
cadrul acestui pas funcionalitatea subreelei nu modific nici un semnal
de ieire a elementelor A. Vectorul semnalelor de ieire a elementelor A,
nscris n ultimul rnd din tabelul 8.1. vine la intrarea elementelor Y.
Neuronii Y, avnd funcia de activare (9), la ieirea unui singur element
Y3 va condiiona apariia semnalului unitate.
Apariia acestui semnal ne vorbete despre faptul c, imaginea
redat S1 cel mai mult se aseamn cu imaginea-etalon V3. Comparaia
vizual a figurii 8.2 i figurii 8.3 confirm funcionarea corect a reelei.
76
abelul 8.1. Rezultatele calculelor procesului iterativ n subreeaua

MaxNet
Timpul Dimensiunea semnalelor de ieire a neuronilor Ak (k=1,5)
Uout A1
Uout A2
Uout A3
Uout A4
Uout A5
0,200
0,600
0,800
0,400
0,400
0,000
0,240
0,480
0,000
0,000
0,000
0,144
0,432
0,000
0,000
0,000
0,058
0,403
0,000
0,000
0,000
0,000
0,402
0,000
0,000
Acum vom determina funcionarea reelei la redarea imaginii S2

= (-1, -1, 1,-1, 1,-1,-1,-1, -1). Calculele sunt identice, de aceea vom
prezenta doar cele mai importante rezultate intermediare :
U in.Z 1 ( S 2 )
6 , U in.Z 2 ( S 2 )
2 ,U in.Z 3 ( S 2 )
U in.Z 4 ( S 2 )
4 ,U in.Z 5 ( S 2 )
8;
U out .Z 1 ( S 2 )
a1
0,6 ,U out .Z 2 ( S 2 )
U out .Z 3 ( S 2 ) U out .Z 4 ( S 2 )
U out .Z 5 ( S 2 )
a5
a3
a4
a2
4,
0,2 ,
0,4 ,
0,8 .
Deoarece vectorul de intrare (0,6; 0,2; 0,4; 0,4; 0,8) a subreelei

MaxNet conine doar un singur element maxim 5 = 0,8, atunci n urma
procesului iterativ, numai la ieirea elementului 5 vom avea un semnal
pozitiv, care va provoca un semnal unitate la ieirea neuronului Y5.
Rezult c imaginea redat se aseamn foarte mult cu imaginea-etalon
V5, ceea ce confirm comparaia vizual a figurii 8.2i figurii 8.3.
Vom determina reacia reelei Hamming la imaginea de intrare
3
S = (-1,-1,-1,-1,1,-1,-1,1,-1) figura 8.3. La prezentarea imaginii S3 vom
obine:
77
U in.Z 1 ( S 3 )
8 , U in.Z 2 ( S 3 )
0 ,U in.Z 3 ( S 3 ) 1,
U in.Z 4 ( S 3 )
2 ,U in.Z 5 ( S 3 )
8.
Deoarece semnalele Uin Z1(S ) = Uin Z5(S3) sunt maximal identice

cu semnalele de intrare, atunci vor fi identice i semnalele maxime de la
ieirea elementelor Z (Uout Z1(S3) = Uout Z5(S3) =0,8) i la intrarea
neuronilor A (1 (S3) = 5(S3) = 0,8). n consecin, subreeaua MaxNet
nu va putea crea un semnal maximal unic i n urma funcionrii la
ieirile neuronilor A, Y vom avea semnale nule.
Rezult c reeaua Hamming nu va putea determina pentru
fiecare imagine-etalon imaginea redat de vectorul S3.
1. Elaborai o reea neuronal Hamming, care va putea identifica nu mai
puin de 6 caractere diferite ale numelui i prenumelui d-voastr, n
acelai timp motivai alegerea:
numrului de receptori ai neuronilor;
numrului de neuroni ai stratului de intrare;
dimensiunea parametrului n subreeaua MaxNet;
tipul funciilor de activare a neuronilor fiecrui strat;
dimensiunea capacitilor (ponderilor) de legtur i de
deplasare n subreeaua Hamming.
2. Studiai reeaua neuronal a imaginilor-etalon a caracterelor. Examinai
posibilitile reelei pentru determinarea imaginilor distorsionate
(eronate).
3. Alegei imaginea de intrare egal ndeprtat pe distana Hamming de la
dou imagini-etalon. Observai efectul analizei acestei imagini.
Propunei o metod de comportare mai informativ a reelei la
prezentarea unor astfel de imagini.
78

Reelele neuronale Hebb
Scopul: nsuirea i consolidarea cunotinelor, precum i formarea
deprinderilor practice privind lucrul cu reelele neuronale Hebb.
9.1. Neuroni formali ai reelelor neuronale artificiale
n timpul modelrii reelelor neuronale, n calitate de neuroni
artificiali se folosete un simplu element procesor, ilustrat n figura 9.1.
La intrrile lui vine vectorul X=(x1, ..., xn) de semnale de intrare,
care la rndul lor sunt semnale de ieire al altor neuroni. Aceasta mai
conine i un semnal unic de deplasare.
Toate semnalele de intrare, inclusiv ale semnalul de deplasare, se
nmulesc la coeficienii ponderilor de legtur i se sumeaz:
n
xi wi
w0 ,
(1)
i 1
unde:S suma semnalului de intrare; wi (i = 1..n) coeficienii ponderilor

legturilor semnalelor de intrare x1, ..., xn; w0 coeficientul ponderii de
legtur al semnalului de deplasare.
Figura 9.1. Element procesor folosit n reelele neuronale simple

Semnalul recepionat S vine la intrarea blocului care realizeaz
funcia f de activare a neuronului. Funciile tipice de activare sunt binare:
79
1, dac S
0 , dac S
0
.
0
(2)
1, dac S 0
.
1, dac S 0
(3)
sau bipolare:
Muli autori, la descrierea modelului neuronului, nu folosesc nu

semnalul de deplasare, dar pragul al neuronului, ceea ce conduce la
modelul elementului echivalent. n acest caz, expresiile (2) i (3) vor avea
forma:
1, dac S
0 , dac S
1, dac S
1, dac S
(4)
(5)
unde:
n
(6)
wi xi .
Imaginea grafic a funciei de activare binare i bipolare pentru

acest caz este artat n figura 9.2 a i b.
Din relaiile (1)-(3) i (4)-(6) rezult c pentru fiecare valoare de
prag a neuronului poate fi prezentat n conformitate cu capacitatea
coeficientului w0 de legtur a semnalului de deplasare, i invers.
ns mai rar se utilizeaz funcii liniare binare i liniare bipolare
de activare (figura 9.2 c i d):
a pentru S
1,
(7)
y
kS a pentru
S
0
1 pentru S
80
unde a este egal cu 0 pentru semnalele de intrare binare ale neuronilor iar
a este egal cu -1 pentru semnalele bipolare; k, a0 coeficieni permaneni.
Figura 9.2. Funcia de activare a neuronilor

n afar de cele expuse mai sus, n teoria reelelor neuronale se
folosesc i urmtoarele funcii neliniare de activare:
Sigmoida binar sau sigmoida logic (figura 9.2, e):
1
1 e
(8)
1.
(9)
unde: coeficient permanent.

Sigmoida bipolar (figura 9.2 f):
2
1 e
81
Radial simetric (figura 9.2 g):
S2
Binar de rangul k (figura 9.2 h):

0 pentru S
(10)
1,
1 ( K 1) pentru 1 S
2 ,
2 ( K 1) pentru 2 S
3,
.......... .......... .......... .......... ...
K 2
pentru k 1 S
k ,
K 1
1 pentru S
k .
Bipolar de rangul k (figura 9.2 i):

1 pentru S
(11)
1,
1 2 ( K 1) pentru 1 S
1 4 ( K 1) pentru 2 S
.......... .......... .......... .......... ...
2( K 2)
1
pentru k 1 S
K 1
1 pentru S
k .
,
3,
2
(12)
Modelele neuronilor artificiali prezentate anterior ignoreaz multe

proprieti cunoscute ale prototipurilor biologice. De exemplu, nu iau n
consideraie reinerile n timp ale neuronilor, efectele modulrii n
frecven, excitrii locale i consecinele legate de ele a sumrii spaiale i
temporale de prag, atunci cnd celula nu se excit imediat dup venirea
impulsurilor, dar cu secvene de semnale de excitare care vin n intervale
scurte de timp. De asemenea nu se iau n consideraie perioadele absolute
de refractare n timpul crora celulele nervoase nu pot fi excitate, adic ca
i cum ar avea o perioad de excitare infinit, care apoi timp de cteva
milisecunde dup trecerea semnalului se micoreaz la nivelul normal.
Aceast list de deosebiri, pe care muli biologi le socot decisive, poate fi
82
uor continuat, numai c reelele neuronale artificiale totui depisteaz un

ir de proprieti interesante, caracteristice pentru prototipurile biologice.
9.2. Rezolvarea problemelor de recunoatere n baza neuronilor
independeni. Regula lui Hebb
Reelele neuronale artificiale destinate pentru soluionarea
diferitor probleme, pot conine de la civa neuroni pn la mii i milioane
de elemente. ns un neuron aparte (figura 9.1) cu funcia de activare
bipolar sau binar, poate fi folosit pentru rezolvarea problemelor simple
de recunoatere i clasificare a imaginilor. Alegerea reprezentrii bipolare
(1, -1) sau binare (1, 0) a semnalelor n reele neuronale se face reieind
din problema ce se rezolv i n multe cazuri este echivalent.Totodat
avem un spectru de probleme n care codificarea binar a semnalelor este
mai comod, ns este mai util de ales o prezentare bipolar a informaiei.
ntruct semnalul de ieire a neuronului binar (figura 9.1) ia
numai dou valori, atunci acest neuron poate fi folosit pentru clasificarea
imaginilor prezentate n dou clase.
Fie c avem o mulime M de imagini pentru care sunt cunoscute
clasificarea corect n dou clase X1 = {X11, X12,, X1q}, X2 = {X21, X22,,
X2p}, X1 U X2 = M, X1 X2=, i fie c primei clase X1 i corespunde
semnalul de ieire y=1, iar clasei X2 semnalul y = -1. Dac, de exemplu
este prezentat o imagine oarecare X
X 1 ,...., X n , X
M i suma
capacitilor semnalelor de intrare depete valoare zero:
n
xi wi
i 1
w0
0,
atunci semnalul de ieire y=1 i, respectiv, imaginea de intrare X

corespunde clasei X1. Dac S 0, atunci y = -1 i imaginea prezentat
aparine clasei a doua.
Este posibil folosirea unui neuron aparte i pentru rezervarea din
mulimea de clase M ={ X1 = {X11,, X1k},..., Xi = {Xi1,, Xiq}, ..., Xp =
{Xp1,, Xpm}} a imaginilor din clasa unic Xi. n acest caz se consider c
unul din dou semnale posibile de ieire ale neuronului (de exemplu, 1)
corespunde clasei Xi, al doilea tuturor celorlalte clase. De aceea, dac
imaginea de intrare X duce la apariia semnalului y = 1, atunci X Xi,
dac y = -1 (sau y = 0, dac se folosete codificarea binar), atunci aceasta
ne arat c imaginea prezentat nu corespunde clasei atribuite.
83
Sistemul de recunoatere n baza neuronului unic mparte toat

suprafaa de soluii posibile n dou suprafee cu ajutorul hiperplanului:
x1w1
x2 w2
... xn wn
w0
0.
Pentru vectorii de intrare bidimensionali, pragul dintre dou clase

de imagini este o linie dreapt: vectorii de intrare, care se afl mai sus de
aceast dreapt, aparin unei singure clase, iar cei care se alf mai jos
altei clase.
Pentru adaptarea, setarea sau nvarea ponderilor (capacitilor)
legturilor neuronilor pot fi folosite mai multe metode. Vom descrie una
dintre ele care se numete regula lui Hebb. Hebb, studiind mecanismele
de funcionare a sistemului nervos central (SNC), a presupus c nvarea
se produce pe calea augmetrii ponderilor legturilor dintre neuroni,
activitatea crora coincide n timp. Dar n sistemele biologice aceast
presupunere nu se ndeplinete ntotdeauna i nu epuizeaz toate tipurile
de nvare, dei la nvarea reelelor neuronale pe un strat cu semnale
bipolare este foarte efectiv.
n conformitate cu regula lui Hebb, dac imaginii bipolare
prezentate X=(x1, ..., xn) i corespunde un semnal incorect de ieire y,
atunci ponderile wi (i 1, n) ale legturilor neuronului se adapteaz dup
formula:
(13)
wi (t 1) wi (t ) xi y , i 0, n ,
unde: wi (t), wi (t+1) respectiv ponderea legturii i a neuronului pn i
dup adaptare; xi (i 1, n) componentele imaginii de intrare; x0 1
semnalul de deplasare; y semnalul de ieire a neuronului.
ntr-o form mai complet, algoritmul de setare a ponderilor
legturilor neuronului cu folosirea regulii lui Hebb arat n felul urmtor:
Pasul 1. Se d mulimea M ={ (X1, t1),, (Xm, tm)} care const din perechi
(imaginea de intrare Xk = (X1k,, Xnk), este necesar semnalul de ieire a
neuronului tk), k 1, m) . Se iniiaz ponderile legturilor neuronilor:
wi
0, i
0, n.
Pasul 2. Pentru fiecare pereche (Xk, tk), k 1, m pn ce nu se

ndeplinesc condiiile de stopare, se ndeplinesc paii 3-5.
84
Pasul 3. Se iniiaz mulimea de intrri a neuronului:
x0
xik , i 1, n.
1, xi
Pasul 4. Se iniiaz semnalul de ieire a neuronului: y = tk.

Pasul 5. Se corecteaz ponderile legturilor neuronului dup regula:
wi (new)
wi (old ) xi y, i
0, n.
Pasul 6. Controlul condiiilor de stopare.

Pentru fiecare imagine de intrare Xk se determin semnalul
corespunztor de ieire yk:
1, dac S k
1, dac S
1, m,
unde:
n
Sk
xik wi
i 1
m
w0 .
Dac vectorul (y1, ... , y ) semnalelor de ieire este identic cu

vectorului (t1, ... , tm) semnalelor iniiale ale neuronului, adic fiecrei
imagini de intrare i corespunde un semnal de ieire dat anterior, atunci
calculele se sfresc (trecem la pasul 7), dar dac (y1, ... , ym) (t1, ... , tm),
atunci trecem la pasul 2 al algoritmului.
Pasul 7. Stop.
85
Exemplu:
Fie c trebuie s nvm un neuron bipolar s recunoasc
imaginiler X1 i X2, ilustrate n figura 9.3.
Figura 9.3. Imaginile de intrare

n acelai timp vom cere ca imaginii X1 s-i corespund semnalul
de ieire +1 al neuronului, iar imaginii X2 semnalul -1.
Aplicarea algoritmului Hebb ne ofer urmtoarele rezultate:
Pasul 1. Se dau mulimile:
X1
(X
1, 1,1,1,1, 1, 1,1 ,1 ;
(1,1,1,1, 1,1,1, 1,1), 1) ;
se iniiaz ponderile legturilor neuronului: wi = 0, i 0,9 .

Pasul 2. Pentru fiecare din perechile (X1,1), (X2,-1) se ndeplinesc paii 35.
Pasul 3. Se iniiaz mulimea intrrilor neuronului pentru imaginea primei
perechi: x0 1, xi xi1 , i 0,9.
Pasul 4. Se iniiaz semnalul de ieire al neuronului pentru imaginea
primei perechi: y = t1 = 1.
Pasul 5. Se corecteaz ponderile legturilor neuronului dup regula lui
Hebb wi
wi
w0
xi1 y ( i
w0
0, n) :
x0 y
0 1 1 1;
1
1
w1 w1 x y 0 1 1 1;
w1 w3 w4 w5 w6 w9 1;
w2
w2 x12 y 0 ( 1) 1
w2 w7 w8
1.
86
1;
Pasul 3. Se iniiaz mulimea de intrri ale neuronului pentru imaginea X2

a perechii a doua: x0 1, xi xi2 , i 0,9.
Pasul 4. Se iniiaz semnalul de ieire a neuronului pentru imaginea din a
doua pereche (X2, t2):
y = t2 = -1.
Pasul 5. Se corecteaz ponderile legturilor neuronului:
w0
w0
x0 y 1 1 ( 1)
0;
w1 w1 x12 y 1 1 ( 1) 0 ;
w1 w3 w4 w6 w9 0 ;
w2
w2
x22 y
1 1 ( 1)
w2 w7
2;
2;
w5
w5
x52 y 1 ( 1) ( 1)
2;
w8
w8
x82 y
1 ( 1) ( 1) 0 ;
Pasul 6. Se verific condiiile de stopare.

Se calculeaz semnalele de intrare i semnalele de ieire ale
neuronului la prezentarea imaginii X1:
9
S1
xi1wi
w0
1 0 ( 1) ( 2) 1 0 1 0 1 2 1 0
i 1
( 1) ( 2) ( 1) 0 1 0 0 6;
y1=1, deoarece S1>0.
Se calculeaz semnalele de ieire i de intrare ale neuronului la
prezentarea imaginii X2:
9
S2
xi2 wi
w0 1 0 1 ( 2) 1 0 1 0 ( 1) 2 1 0
i 1
1 ( 2) ( 1) 0 1 0 0
y =-1, deoarece S2<0.
6;
ntruct vectorul (y1 ,y2)=(1, -1) este egal cu vectorul (t1 ,t2),
atunci calculele se stopeaz, deoarece a fost atins scopul neuronul corect
recunoate imaginile prezentate.
87
Ideea esenial a regulii (13) de a mri legturile care leag

neuronii cu aceeai activitate n timp i de a micora legturile, care leag
elementele cu activitate diferit, poate fi folosit la setarea reelelor
neuronale cu elemente binare. Regula lui Hebb (13) pentru reelele binare
cu un singur strat poate fi scris n forma:
(14)
wi (t 1) wi (t )
wi ,
unde:
1, dac xi y 1,
0, dac xi 0 ,
wi
(15)
0 i y
1, dac xi
0.
Exemplu:
Fie c trebuie s nvm un neuron binar pentru recunoaterea
imaginilor X1 i X2 ale exemplului precedent. Imaginii X1 fie c-i va
corespunde semnalul de ieire +1 al neuronului, iar imaginii X2 0.
Aplicarea regulii lui Hebb n acest caz ne va da urmtoarele
rezultate:
Pasul 1. Se d mulimea:
M = {(X1 = (1, 0, 1, 1, 1, 1, 0, 0, 1), 1), (X2 = (1, 1, 1, 1, 0, 1, 1, 0, 1), 0)} ,
i se iniiaz ponderile legturilor neuronului wi = 0, i 0,9 .
Pasul 2. Pentru perechile (X1, 1), (X2, 0) se ndeplinesc paii 3-5.
Pasul 3. Se iniiaz mulimea intrrilor neuronului cu elementele imaginii
X1:
x0
xi1 , i
1, xi
0,9.
Pasul 4. Se iniiaz semnalul de ieire a neuronului pentru imaginea X1:

y = t1 =1.
Pasul 5. Se corecteaz ponderile legturilor neuronului cu ajutorul
relaiilor (14, 15):
w0
w0
w1 w1
w1 w3 w4
w2
w2
w0
0 1 1;
w1 0 1 1;
w5 w6 w9 1;
w2
88
0 0
0;
w2
w7
w8
0.
Pasul 3. Se iniiaz mulimea intrrilor neuronului cu elementele imaginii

X2:
x0
xi2 , i
1, xi
0,9.
Pasul 4. Se iniiaz semnalul de ieire al neuronului pentru imaginea X2:

y = t2 =0.
Pasul 5. Se corecteaz ponderile legturilor neuronului cu ajutorul
relaiilor (14,15):
w0
w0
w1
w1
w1
w3
w2
w0
w2
w5
w7
w8
0;
w1 1 ( 1) 0 ;
w4 w6 w9 0 ;
w2
w5
1 ( 1)
w8
0 ( 1)
1;
w5 1 0 1;
w2
1;
w8 0 0 0 .
Pasul 6. Verificarea condiiilor de stopare.

Se determin semnalele de intrare i de ieire ale neuronului la
prezentarea imaginilor X1 i X2 :
9
S1
xi1wi
w0
1 0 0 ( 1) 1 0 1 0 1 1 1 0
i 1
0 ( 1) 0 0 1 0 0 1;
y =1, deoarece S1>0.
1
S2
xi2 wi
w0 1 0 1 ( 1) 1 0 1 0 0 1 1 0
i 1
1 ( 1) 0 0 1 0
2;
2
y =-1, deoarece S <0.
ntruct vectorul (y1 ,y2)=(1, 0) este egal cu vectorul (t1 ,t2), atunci
calculele se stopeaz, deoarece a fost atins scopul.
2
9.3. Reeaua neuronal Hebb

Utilizarea grupului din m neuroni bipolari sau binari A1, ... Am (Figura
9.4 permite de a mri considerabil posibilitile reelei neuronale i a
89
recunoate pn la 2m imagini diferite. ns aplicarea acestei reele pentru

recunoaterea a 2m (sau aproape de 2m) de imagini diferite poate duce la
probleme nerezolvabile privind adaptarea ponderilor legturilor reelei
neuronale. De aceea, deseori se recomand folosirea acestei arhitecturi
doar pentru recunoaterea numai a m imagini diferite, fiecrei atribuindu-i
o ieire unic numai la ieirea unui element A (ieirile celorlali n acelai
timp trebuie s ia valoarea -1 pentru neuroni bipolari i valoarea 0
pentru cei binari).
Figura 9.4. Reea neuronal din m elemente

Reeaua neuronal pe un singur strat cu neuroni binari, ilustrat n
Figura 9.4, poate fi nvat cu ajutorul unui algoritm bazat pe regula
Hebb. n acest caz se numete reea Hebb. Folosirea n denumirea reelei a
algoritmului de nvare este caracteristic pentru teoria reelelor neuronale.
Pentru prezentarea bipolar a semnalelor este posibil nvarea
reelei neuronale cu ajutorul urmtorului algoritm:
Pasul 1. Se d mulimea M = {(X1, t1),, (Xm, tm)}, care const din perechi
(imaginea de intrare Xk=(X1k, Xnk), semnalul necesar de ieire al
neuronului tk, k 1, m ). Se iniiaz ponderile legturilor
neuronului:
w ji
0, j 1, n , i 1, m.
Pasul 2. Fiecare pereche (X , tk) se verific la corectitudinea reaciei

reelei neuronale la imaginea de intrare. Dac vectorul de ieire
recepionat al reelei (y1k, ..., ymk), se deosebete de cel iniial
t1= (t1k, tmk), atunci ndeplinim paii 3-5.
k
90
Pasul 3. Se iniiaz mulimea de intrari ale neuronilor:
xkj , j 1, n.
x0 1, x j
Pasul 4. Se iniiaz semnalele de ieire ale neuronilor: yi = tik, i= 0, m .

Pasul 5. Se corecteaz ponderile legturilor neuronilor dup regula:
w ji (new)
w ji (old ) x j yi , j
0, n , i
0, m.
Pasul 6. Se verific condiia de stopare, adic corectitudinea funcionrii

reelelor la prezentarea fiecrei imagini de intrare. Dac
condiiile nu se ndeplinesc, atunci trecem la pasul 2 al
algoritmului, altfel se sfresc calculele (trecem la pasul 7).
Pasul 7. Stop.

1. Elaborai structura reelei Hebb care va fi capabil s
recunoasc 4 litere diferite ale numelui i prenumelui dvs. i motivai
alegerea:
numrului de receptori ai neuronilor(numrul n de
elemente ale reelei trebuie s fie n limitele 12 n 30);
numrului de neuroni de ieire;
alegerea vectorului de semnale de ieire.
2. Elaborai algoritmul i programul de modelare al reelei Hebb.
n algoritm numaidect luai n considerare posibilitatea apariiei situaiei
cu probleme nerezolvabile la adaptarea ponderilor legturilor n reeaua
neuronal.
3. nvai reeaua neuronal Hebb a recunoaterii a 4 caractere
date.
4. Prezentai un set de simboluri de intrare i semnale de ieire
dorite, cnd n reea apare situaia cu proleme nerezolvabile de adaptare a
ponderilor legturilor.
91
BIBLIOGRAFIE
Cri:
A. Florea, A. Boangiu. Elemente de inteligena artificial.
A. Florea. Bazele logice ale inteligenei artificiale. Cap. 4, 6.
A. Florea, B. Dorohonceanu, C. Francu. Programare n Prolog.
Articole on-line:
Turing, A.M. Computing Machinery and Intelligence, Mind, 59,
1950, 433-460.
AI's Greatest Trends and Controversies, IEEE Intelligent Systems
January/February 2000.
Marvin Minsky. A Framework for Representing Knowledge,
MIT-AI Laboratory Memo 306, June, 1974.
J. Austin - How to do things with words, 1962, J. Searle - Speech
acts, 1969
92
ANEXE
Anexa 1
MEDIUL GNU Prolog
Introducere
GNU Prolog este un compilator Prolog gratuit, dezvoltat de
Daniel Diaz. GNU Prolog reprezint un compilator bazat pe maina
abstract Warren (WAM). GNU Prolog, mai nti, compileaz programul
ntr-un fiier WAM, care apoi este translat n limbajul mini-assembly,
elaborat special pentru GNU Prolog. Fiierul obinut este la fel translat,
ns deja n limbajul assembler specific staiei pe care ruleaz. Acest fapt
permite GNU Prolog s produc un executabil nativ, independent dintr-un
fiier surs Prolog (.pl, .pro). Avantajul principal al acestei scheme de
compilare const n producerea codului nativ i viteza de compilare. O
alt caracteristic este c executabilele sunt de dimensiune mic.
Caracteristicile GNU Prolog:
corespunde standardului ISO pentru Prolog;
posed extensii ca: variabile globale, sockets API, OS API, suport

pentru gramatica DC etc;
peste 300 de predicate Prolog predefinite;
Prolog debugger i WAM debugger de nivel jos;
facilitatea de editare a liniilor de cod prin intermediul

interpretatorului interactiv;
interfa bidirecional ntre Prolog i C;
generarea direct de cod assembler de 15 ori mai rapid dect n

wamcc + gcc.
Interpretatorul GNU Prolog
GNU Prolog ofer dou posibiliti de executare a programelor:
interpretarea lor, utiliznd interpretatorul interactiv GNU Prolog;
compilarea lor, utiliznd compilatorul GNU Prolog.

Rularea programului n cadrul interpretatorului permite utilizatorului
vizualizarea i depanarea codului. Compilarea programelor n cod nativ
permite producerea executabilelor de dimensiune mic i vitez de
execuie optimizat. Rularea unui program compilat e de 3-5 ori mai
93
rapid dect rularea unui program interpretat. ns nu e posibil a fi

depanat programul precum permite aceasta interpretatorul i nici a fi
vizualizat codul surs. De regul se recomand rularea programului,
utiliznd interpretatorul pe durata dezvoltrii lui, permind astfel
depanarea uoar. Apoi, produsul final urmeaz a fi compilat n cod nativ,
pentru a produce un executabil autonom.
Lansarea/nchiderea interpretatorului
GNU Prolog ofer un interpretator interactiv Prolog clasic numit top-level.
Acesta permite utilizatorului s execute interogri, s consulte un program
Prolog, s-l vizualizeze i s-l depaneze. Top-level poate fi invocat
utiliznd urmtoarea comand din terminal:
% gprolog [OPTION]
Opiuni:
-init-goal GOAL execut scopul nainte s intre n top-level;
-consult-file FILE consult fiierul n cadrul top-level;
-entry-goal GOAL execut scopul n cadrul top-level;
-query-goal GOAL execut scopul drept interogare pentru top-level;
-help afieaz comenzile disponibile;
-version afieaz numrul versiunii curente;
- evit parsarea liniei curente.
Rolul principal al comenzii gprolog este de a executa nsi interpretatorul,
cu alte cuvinte, a executa predicatul predefinit top_level/0 care va produce
urmtorul lucru:
GNU Prolog 1.4.0
By Daniel Diaz
Copyright (C) 1999-2012 Daniel Diaz
| ?-
Interpretatorul este pregtit s execute interogrile prestate de utilizator.

Pentru a prsi interpretatorul trebuie tastat secvena de taste pentru endof-file (Ctrl-D) sau end_of_file. La fel, e posibil a fi folosit predicatul
predefinit halt/0 (cifra de dup / indic numrul de argumente ale
94
predicatului).
Ciclul interactiv de citire-execuie-afiare al interpretatorului
GNU Prolog top-level se bazeaz pe un ciclu interactiv de citire-execuieafiare care permite reexecutri dup cum urmeaz:
afiarea prompt| ?-;
citirea unei interogri;
executarea interogrii;
n caz de succes se afieaz valorile variabilelor din interogare;
dac mai rmn alternative (cu alte cuvinte interogarea nu este

determinist), se afieaz ? unde utilizatorul poate interveni cu una din
comenzile disponibile: RETURN pentru a stopa execuia, ; pentru a
estima urmtoarea soluie sau a pentru estimarea tuturor soluiilor rmase.
Mai jos este prezentat un exemplu de execuie a unei interogri (gsete
listele X i Y astfel nct concatenarea lor s fie [a,b,c]):
| ?- append(X,Y,[a,b,c]).
X = []
Y = [a,b,c] ? ; (aici utilizatorul tasteaz ';' ca s estimeze o
soluie)
X = [a]
Y = [b,c] ? a (aici utilizatorul tasteaz 'a' ca s estimeze toate
soluiile rmase)
X = [a,b]
Y = [c] (aici utilizatorul nu mai este interogat i soluia urmtoare este
estimat automat)
X = [a,b,c]
Y = [] (aici utilizatorul nu mai este interogat i soluia urmtoare este
estimat automat)
no (nu mai sunt soluii)
95
ncrcarea unui program Prolog

Interpretatorul permite utilizatorului s ncarce fiiere surs Prolog.
Predicatele ncrcate pot fi vizualizate, executate i depanate, n timp ce
cele compilate nu. Pentru a ncrca n memorie un program Prolog,
utilizm predicatul predefinit consult/1 argumentul cruia este calea
relativ sau absolut spre fiierul ce conine programul Prolog. Aceasta
permite utilizatorului s introduc predicatele direct n terminal. O
scurttur pentru apelul consult(FILE) este [FILE], de exemplu
urmtoarele sunt echivalente:
| ?- consult('C:\example.pro').
| ?- ['C:\example.pro'].
Cnd predicatul consult/1 este invocat asupra unui fiier surs, GNU
Prolog nti compileaz acest fiier pentru a genera un fiier WAM
temporar. Dac compilarea nu eueaz, programul se ncarc n memoria
calculatorului utiliznd predicatul load/1.
Predicate de depanare a programelor
Predicatul trace/0 activeaz regimul de depanare a interpretatorului.
Orice urmtoare invocare de predicate va fi depanat.
Predicatul debug/0 activeaz regimul de depanare a interpretatorului.
Doar urmtoarea invocare a unui oarecare predicat va fi depanat.
Predicatul debugging/0 afieaz n terminal informaii de depanare
referitoare la starea curent.
Predicatele notrace/0 i nodebug/0 dezactiveaz regimul de depanare.
Predicatul wam_debug/0 invoc regimul de depanare specific structurilor
de date WAM. Acest regim la fel mai poate fi invocat, utiliznd comanda
W.
96
Predicate predefinite n Prolog

Operatorii de unificare:
(=)/2 operatorul de unificare n Prolog
Term1 = Term2
(\=)/2 operatorul care verific dac operatorii nu pot fi unificai
Term1 \= Term2
Operatorii de comparare general a termenilor n GNU Prolog:
(==)/2 operatorul de egalitate
(\==)/2 operatorul diferit de
(@<)/2 operatorul mai mic ca
(@=<)/2 operatorul mai mic sau egal cu
(@>)/2 operatorul mai mare ca
(@>=)/2 operatorul mai mare sau egal cu
Operatorii aritmetici n GNU Prolog:
(=:=)/2 operatorul de egalitate
(=\=)/2 operatorul diferit de
(<)/2 operatorul mai mic ca
(=<)/2 operatorul mai mic sau egal cu
(>)/2 operatorul mai mare ca
(>=)/2 operatorul mai mare sau egal cu
(is)/2 evaluarea unei expresii aritmetice, de exemplu:
Result is Expression1 + Expression2
Predicatele de prelucrare a listelor:
append/3
append(List1, List2, List12) concateneaz lista List1 i lista
List2 n List12.
97
member/2
member(Element, List) verific dac elementul Element aparine
listei List.
reverse/2
reverse(List1, List2) inverseaz lista List1 n List2.
delete/3
delete(List1, Element, List2) elimin toate apariiile Element
n lista List1 n cadrul listei List2.
prefix/2
prefix(Prefix, List) verific dac lista Prefix este prefixul listei
List.
suffix/2
suffix(Suffix, List) verific dac lista Suffix este sufixul listei
List.
sublist/2
sublist(List1, List2) verific dac n lista List1 toate
elementele apar n aceeai ordine ca i n List2.

last/2
last(List, Element) verific dac elementul Element este ultimul
n cadrul listei List.
length/2
length(List, Length) estimeaz lungimea listei List n Length.
sort/2
sort(List1, List2) sorteaz lista List1 n cadrul listei List2
(elementele duplicate sunt eliminate).

msort/2
msort(List1, List2) sorteaz lista List1 n cadrul listei List2
(elementele duplicate nu sunt eliminate).

98
nth/3
nth(N, List, Element) returneaz al N-lea element din lista List
n Element.
min_list/2
min_list(List, Min) returneaz elementul minimal din lista List
n Min.
max_list/2
max_list(List, Max) returneaz elementul maximal din lista List
n Max.
sum_list/2
sum_list(List, Sum) returneaz suma elementelor listei List n
Sum.
99
Anexa 2
Codul surs al programului care realizeaz o reea
neuronal Hamming n limbajul de programare C++
#include <iostream.h>
#include <string.h>
#define true 1
#define false 0
using namespace std;
class Hemming
{
private:
float* Uin;
float* Uout;
float** W;
int N;
int M;
int* s;
float e;
float b;
float k;
void InitUin();
void InitUout();
float g(float x);
bool Compare(float* v1, float* v2);
public:
int GetVectorLength(); //returns Image's length
int GetEtalonsCount();// returns Etalon count
void SetImage(int* image);// Set recognizing Image's
vector
void SetEtalons(int** images);// set etalons
void Hemming::Final(int* rezult, int &counter);//
recognize Image
Hemming(int n,int m);
Hemming(Hemming& hemming);
~Hemming();
};
void Hemming::InitUin()
{
int i,j;
for (i = 0; i < N; i++)
{
float temp = 0;
for ( j = 0; j < M; j++)
temp += s[j] * W[j][i];
Uin[i] = temp;
100
}
}
void Hemming::InitUout()
{
int i;
for (i = 0; i < N; i++)
Uout[i] = Uin[i] * k;
}
float Hemming::g(float x)
{
return x < 0 ? 0 : x;
}
bool Hemming::Compare(float* v1, float* v2)
{
int i;
for ( i = 0; i < N; i++)
if (v1[i] != v2[i]) return false;
return true;
}
int Hemming::GetVectorLength(){ return N;}
int Hemming::GetEtalonsCount(){ return M;}
void Hemming::SetImage(int* image)
{
int i;
for( i=0; i<M; i++)
s[i]= image[i];
}
void Hemming::SetEtalons(int** images)
{
int i,j;
for ( i = 0; i < M; i++)
for ( j = 0; j <N; j++)
W[i][j] = (float)images[j][i] / 2;
}
void Hemming::Final(int* rezult, int &counter)
{
InitUin();
InitUout();
int i,j;
while (!Compare(Uin, Uout))
{
for(i=0; i<N; i++)
Uin[i]=Uout[i];
for (i = 0; i < N; i++)
{
//Uout[i] = g(Uin[i] - e *
(Uin.Where((r, index) => index != i).Sum()));
float temp=0;
for(j=0; j<N; j++)
if(i!=j) temp+=Uin[j];
Uout[i] = g(Uin[i] - e*temp);
}
}
int max = 0;
for ( i = 1; i < N; i++)
101
if (Uout[max] < Uin[i]) max = i;

counter = 0;
for( i=max; i<N; i++)
if(Uout[max]==Uout[i])
{
rezult[counter]=i;
counter++;
}
}
Hemming::Hemming(int n,int m)
{
N=n; M=m;
b = M / 2;
e = 1 / N;
k = 0.1;
s= new int[M];
Uin = new float[N];
Uout = new float[N];
W= new float*[M];
for(int i=0; i<M; i++)
W[i] = new float[N];
}
Hemming::Hemming(Hemming& hemming)
{
N=hemming.N;
M=hemming.M;
b = M / 2;
e = 1 / N;
k = 0.1;
int i;
s= new int[N];
Uin = new float[N];
Uout = new float[N];
W= new float*[M];
for( i=0; i<M; i++)
W[i] = new float[N];
for( i=0; i<N; i++)
{
s[i] = hemming.s[i];
Uin[i]=hemming.Uin[i];
Uout[i]=hemming.Uout[i];
}
int j;
for( i=0; i<M; i++)
for( j=0; j<N; j++)
W[i][j] = hemming.W[i][j];
}
Hemming::~Hemming()
{
if(s!=NULL) delete s;
if(Uin!=NULL) delete Uin;
if(Uout!=NULL) delete Uout;
102
if(W!=NULL)
{
for (int i=0; i<M; i++)
if (W[i]!=NULL) delete W[i];
delete W;
}
}
int _tmain(int argc, _TCHAR* argv[])
{
int rezult[5];
int n,m,i,j;
n=5; m=9;
int etalons[5][9] =
{
{ -1, 1, -1, -1, 1, -1, -1, 1, -1 },
{ 1, 1, 1, 1, -1, 1, 1, -1, 1 },
{ 1, -1, 1, 1, 1, 1, 1, -1, 1 },
{ 1, 1, 1, 1, -1, -1, 1, -1, -1 },
{ -1, -1, -1, -1, 1, -1, -1, -1, -1 }
};
int** etalonPt= new int* [5];
for( i =0; i<5; i++)
etalonPt[i]=new int[9];
for( i=0; i<5; i++)
for( j=0; j<9; j++)
etalonPt[i][j] = etalons[i][j];
int s[9]= {-1,-1,1,1,1,1,1,-1,1};
//s3={-1,-1,-1,1,-1,-1,-1,1,-1};
Hemming h(n,m);
h.SetEtalons(etalonPt);
h.SetImage(s);
int counter;
h.Final(rezult,counter);
cout<<"Mached image indexes: "<<endl;
for(i=0; i<counter; i++)
cout<<rezult[i]<<",";
cout<<endl;
char c; cin>>c;
for( i =0; i<5; i++)
delete etalonPt[i];
delete etalonPt;
return 0;
}
103
Anexa 3
Codul surs al programului care realizeaz reeaua neuronal
Hamming, n limbajul de programare C#
Clasa neuronului:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Plia_Interface
{ public class Newrons
{ protected int _m = 9;
protected int _n;
public Newrons(int n, int m)
{ _m = m; _n = n;
b = m / 2;
e = 1 / _n;
k = 0.1;
}
private double b;
private double e;
private sbyte[][] etalons;
public sbyte[][] Etalons
{ get
{ return etalons;
}
set
{ if (value.GetLength(0) != _n
|| value.Any(v => v.Length != _m))
throw new ArgumentException("Wrong size of vector");
etalons = value;
InitW();
}
}
private double[,] W;
private double[] Uin;
private double[] Uout;
private sbyte[] _s;
public sbyte[] S
{ get
{ return _s;
}
set
{ if (value.Length != _m)
throw new ArgumentException("Wrong vector size");
_s = value;
104
}
}
private double k;
protected void InitW()
{ W = new double[_m, _n];
for (int i = 0; i < W.GetLength(0); i++)
for (int j = 0; j < W.GetLength(1); j++)
W[i, j] = (double)etalons[j][i] / 2;
}
protected void InitUin()
{ Uin = new double[_n];
for (int i = 0; i < _n; i++)
{ double temp = 0;
for (int j = 0; j < _m; j++)
temp += _s[j] * W[j, i];
Uin[i] = temp;
}
}
protected void InitUout()
{ Uout = new double[_n];
for (int i = 0; i < _n; i++)
Uout[i] = Uin[i] * k;
}
protected double g(double x)
{ return x < 0 ? 0 : x;
}
private bool Compare(double[] v1, double[] v2)
{ if (v1.Length != v2.Length) return false;
for (int i = 0; i < v1.Length; i++)
if (v1[i] != v2[i]) return false;
return true;
}
public List<int> Final()
{ InitUin();
InitUout();
while (!Compare(Uin, Uout))
{ Array.Copy(Uout, Uin, Uout.Length);
for (int i = 0; i < Uout.Length; i++)
Uout[i] = g(Uin[i] - e * (Uin.Where((r, index) => index
!= i).Sum()));
}
int max = 0;
for (int i = 1; i < Uout.Length; i++)
if (Uout[max] < Uin[i]) max = i;
return Uout.Select((u, index) => new { U = u, Index =
index }).Where(u => u.U == Uout[max]).Select(u =>
u.Index).ToList();
105
}
}
}
Clasa coleciei de abloane:

using System;
using System.Linq;
using System.Text;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
{ [Serializable]
public class Symbol
{ public string Name { get; set; }
public sbyte[] Vector { get; set; }
}
[Serializable]
public class SymbolCollection
{ public SymbolCollection()
{ _symbols = new List<Symbol>();
_n=0; _m=0;
}
private List<Symbol> _symbols;
public List<Symbol> Symbols
{ get
{ return _symbols;
}
set
{ _symbols = value;
}
}
private int _n, _m;
public int N
{ get
{ return _n;
}
set
{ _n = value;
_symbols.Clear();
}
}
public int M
{ get
{ return _m;
}
set
{ _m = value;
106
_symbols.Clear();
}
}
public sbyte[][] GetVectors()
{ return _symbols.Select(s => s.Vector).ToArray();
}
public void AddSymbol(Symbol s)
{ if (s.Vector.Length != _n * _m)
throw new ArgumentException();
}
private static string path = "data.dat";
public void LazyInit()
{ _n = 3;
_m = 3;
var etalons = new sbyte[5][];
etalons[0] = new sbyte[9] { -1, 1, -1, -1, 1, -1, -1, 1, 1 };
etalons[1] = new sbyte[9] { 1, 1, 1, 1, -1, 1, 1, -1, 1 };
etalons[2] = new sbyte[9] { 1, -1, 1, 1, 1, 1, 1, -1, 1 };
etalons[3] = new sbyte[9] { 1, 1, 1, 1, -1, -1, 1, -1, -1
};
etalons[4] = new sbyte[9] { -1, -1, -1, -1, 1, -1, -1, -1,
-1 };
for (int i = 0; i < etalons.Length; i++)
_symbols.Add(
new Symbol()
{ Name = i.ToString(),
Vector = etalons[i]
});
}
public static SymbolCollection Load()
{ BinaryFormatter serializer = new BinaryFormatter();
var file = File.Open(path, FileMode.Open);
var result =
(SymbolCollection)serializer.Deserialize(file);
return result;
}
public static void Save(SymbolCollection collection)
{ BinaryFormatter serializer = new BinaryFormatter();
var file = File.Create(path);
serializer.Serialize(file, collection);
}
}
}
Clasa de redactare a elementelor:

using System;
107
using System.Linq;
using System.Text;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows;
using System.Windows.Shapes;
using System.Windows.Media;
{ public class SymbolEditor
{ private int _n, _m;
private Grid _grid;
private SolidColorBrush selected;
private SolidColorBrush deselected;
private LinearGradientBrush hylighted;
private Rectangle mask;
public SymbolEditor(int n, int m, Grid grid)
{ _n = n; _m = m; _grid = grid;
#region Fiture Initialization
_grid.ShowGridLines = true;
selected = new SolidColorBrush(Colors.DarkBlue);
deselected = new SolidColorBrush(Colors.AntiqueWhite);
hylighted = new
LinearGradientBrush(Colors.Azure, Colors.Crimson, 0.5);
mask = new Rectangle();
mask.Fill = hylighted;
mask.RadiusX = 5;
mask.RadiusY = 5;
mask.Opacity = 0.35;
mask.Visibility = Visibility.Visible;
#endregion
InitGrid();
}
protected void InitGrid()
{ _grid.Children.Clear();
_grid.RowDefinitions.Clear();
_grid.ColumnDefinitions.Clear();
for (int i = 0; i < _n; i++)
{ var row = new RowDefinition();
_grid.RowDefinitions.Add(row);
}
for (int j = 0; j < _m; j++)
{ var column = new ColumnDefinition();
//column.Width = new GridLength(0, GridUnitType.Star);
_grid.ColumnDefinitions.Add(column);
}
for (int i = 0; i < _n; i++)
{ for (int j = 0; j < _m; j++)
108
{ var panel = new StackPanel();

panel.Background = deselected;
panel.SetValue(Grid.RowProperty, i);
panel.SetValue(Grid.ColumnProperty, j);
panel.MouseEnter += new
MouseEventHandler(Canvas_MouseEnter);
panel.MouseLeave += new
MouseEventHandler(Canvas_MouseLeave);
_grid.Children.Add(panel);
}
}
_grid.MouseDown += new
MouseButtonEventHandler(MyGrid_MouseDown);
}
public sbyte[] GetVector()
{ var panels = _grid.Children.OfType<StackPanel>()
.Select(p =>
p.Background == selected ? (sbyte)1 : (sbyte)-1
).ToArray();
if (panels.Length < _n * _m)
throw new Exception("Something wrong here");
return panels;
}
public void ApplyVector(sbyte[] v)
{ if (v.Length != _n * _m)
throw new ArgumentException("argument size is not much to
the grid");
var panels = _grid.Children.OfType<StackPanel>();
for (int i = 0; i < v.Length; i++)
{ var panel = panels.Single(p =>
((int)p.GetValue(Grid.RowProperty) * _m
+ (int)p.GetValue(Grid.ColumnProperty)) == i);
if (v[i] == 1)
panel.Background = selected;
else panel.Background = deselected;
}
}
#region Gui Event Hendlers
private void switchColor(StackPanel canv)
{ if (canv.Background.Equals(selected))
canv.Background = deselected;
else
canv.Background = selected;
}
private void Canvas_MouseEnter(object sender,
MouseEventArgs e)
{ if (!(e.OriginalSource is StackPanel)) return;
109
var canv = (StackPanel)e.OriginalSource;

mask.Width = canv.ActualWidth;
mask.Height = canv.ActualHeight;
if (e.LeftButton == MouseButtonState.Pressed)
switchColor(canv);
canv.Children.Add(mask);
}
private void Canvas_MouseLeave(object sender,
MouseEventArgs e)
{ if (!(e.OriginalSource is StackPanel)) return;
var canv = (StackPanel)e.OriginalSource;
canv.Children.Remove(mask);
}
private void MyGrid_MouseDown(object sender,
MouseButtonEventArgs e)
{ if (e.OriginalSource != mask) return;
var canv = mask.Parent as StackPanel;
if (canv == null) return;
switchColor(canv);
}
#endregion
} }
110
PROGRAMAREA LOGIC I INTELIGENA

ARTIFICIAL
ndrumar de laborator
111

Indrumar PLIA2014

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Indrumar PLIA2014

Încărcat de

Drepturi de autor:

Formate disponibile

UNIVERSITATEA TEHNIC A MOLDOVEI

Facultatea Calculatoare, Informatic i Microelectronic

PROGRAMAREA LOGIC I INTELIGENA

ndrumarul de laborator include noiuni introductive i sarcini

Autori: conf. univ., dr. L. Luchianova

Redactor responsabil: lect. sup. V. Lazu

Recenzent: conf.univ. L. Carcea

Anexa 2 ........................................................................................ 100

Anexa 3 ........................................................................................ 104

argumente ale faptelor este reprezentat prin aritatea corespunztoare a

deplaseaz(cub, camera1, camera2).

Interpretarea particular a predicatului i a argumentelor acestuia

n exemplele prezentate de pn acum, argumentele faptelor i

n cazul n care exist mai multe fapte n baza de cunotine care

nceputul bazei de cunotine. La resatisfacerea unui scop, cutarea se face

scopului frumoasa(ana). Cnd este vorba de un scop , cutarea se face de

Figura 1.1. Algoritmul de satisfacere a scopurilor n Prolog

barbat(Barbat), cuplu_casatorit(Barbat, Femeie).

PARTEA 2. Desfurarea lucrrii

LUCRAREA DE LABORATOR nr. 2

f(X, 2) :- 3 =< X, X < 6.

Figura 2.1. Arbori de deducie a scopurilor f(1,Y) i f(1,Y),2<Y

Utiliznd predicatul cut, definiia funciei f(X, Y) poate fi rescris

n definiia predicatului min1 se utilizeaz un cut verde; acesta se

i tradus n Prolog astfel:

PARTEA 2. Desfurarea lucrrii

LUCRAREA DE LABORATOR nr. 3

PARTEA 1. Noiuni teoretice

Tabelul 3.1. Exemple de structurare a listelor

Aceast dihotomie este utilizat n predicatele care prelucreaz

[Ion, Maria, Vasile]

X=Ion, Y=Maria, Z=Vasile

X=1, Y=2, Z=[3,4]

3.2. Exemple de utilizare

Utiliznd listele, putem colecta informaii i/sau date ntr-un

Ele pot fi redate folosind o singur list sub forma faptului:

Pentru o comparaie mai ampl, considerm urmtoarele dou

Figura 3.1. Cod listing. Exemplu de folosire a listelor

Goal: prima umat_an([_,_,X|_])

Figura 3.2. Cod listing. Exemplu de folosire a listelor eterogene

Figura 3.3. Cod listing. Exemplu de folosire a listelor cu numere ntregi,

PARTEA 2. Desfurarea lucrrii

1.2. Scriei un predicat descomp(N, Lista) care

1.7. S se scrie predicatul imparte(L, L1, L2) care

listaPara, care are conine dou argumente: o list de numere ntregi,

PARTEA 1. Noiuni teoretice

convenabil utilizatorului, explicarea rezultatelor recepionate de SE

Figura 4.1. Structura general a SE

Elaborarea a SE n Turbo Prolog (sau Visual Prolog), bazat pe

/ * n mod similar sunt descrise cunotinele cu privire la alte rase de cini

Mai mult dect att, n scopul de a limita spaiul de cutare care

n exemplul considerat aici, datele pentru selectarea rasei de cini

toate atributele utilizate sunt necesare pentru a identifica rasa.

Introducerea rspunsurilor utilizatorului n baza de date dinamic.

4.4. Sistem expert bazat pe logic i realizarea lui

rasa cu par lung).

Datele despre tipurile de rase:

Datele despre rasele concrete:

rule(3, cu par scurt, buldog englez, [3,5,4]).

Al treilea argument al predicatului rule reprezint o list de

Compararea datelor de intrare a utilizatorului cu listele de atribute

Solicitarea i recepionarea rspunsurilor da i nu de la

Regula go ncearc s potriveasc obiectele care sunt clasificate