INDRUMAR

Ministerul Educaiei si Tineretului
al Republicii Moldova
UNIVERSITATEA TEHNIC A MOLDOVEI
Catedra Tehnologii Informaionale Aplicate
ndrumar de laborator
PROGRAMAREA LOGIC I INTELIGENA

ARTIFICIAL
Autor: conf. univ., dr. L. Luchianova
Chiinu U.T.M., 2013

ndrumarul de laborator include noiuni introductive i sarcini
practice corespunztoare, menite s iniieze studentul, att n domeniul
programrii logice, ct i n domeniul inteligenii artificiale. Tipul
sarcinilor este unul generic, care urmrete reiterarea materialului studiat
prin implementare metodelor descrise i demonstrate n lucrare. O
caracteristic definitorie a lucrrilor este studiul i analiza detaliat a
ndeplinirii sarcinilor utiliznd limbajul de programare Prolog.
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

i Tehnologii Informaionale pentru nsuirea disciplinei Programarea
Logic i Inteligena Artificial.
Autori: conf. univ., dr. L. Luchianova
Redactor responsabil
Recenzent -
U.T.M., 2013
Cuprins:
CAPITOL I........................................................................................5
LUCRAREA DE LABORATOR 1................................................5
Introducere n Limbajul Prolog.........................................................5
PARTEA 1: Noiuni Teoretice.......................................................5
1.1 Entitile limbajului PROLOG............................................5
Observaii:...............................................................................13
Observaii:...............................................................................16
PARTEA 2: Desfurarea lucrrii................................................19
LUCRAREA DE LABORATOR 2..............................................20
Mecanisme de control al procesului de backtracking.....................20
PARTEA 1: Noiuni Teoretice.....................................................20
Structuri de date n Prolog...............................................................29
3.1. Listele n Prolog.............................................................29
3.2 Exemple de utilizare..........................................................31
CAPITOL II.....................................................................................38
Exemple i Probleme n Limbajul Prolog.......................................38
Sisteme Expert.................................................................................38
4.1 Scopul i structura general a sistemelor expert...............38
4.2 Determinarea rezultatului (rspunsului) expert.................39
4.3 Sistem Expert, bazat pe reguli i realizarea lui.................40
4.4 Sistem Expert bazat pe logic i realizarea lui..................43
Prelucrarea Limbajului Natural.......................................................49
5. 1 Prelucrarea Limbajului Natural........................................49
5.2 Modele de analiz sintactic a propoziiilor......................56
PARTEA 2: Desfurarea lucrrii..................................................1
Algoritmi de recunoatere.................................................................2
PARTEA 2: Desfurarea lucrrii..................................................8
Algoritmi de recunoatere a imaginilor.............................................9
7.1 Recunoatere n dependen de unghiul dintre vectori......11
7.2 Recunoaterea imaginilor dup produsul lor scalar...........12
7.3 Recunoaterea imaginilor dup apartenena acestora la o
zon de spaiu dat...................................................................13
Reelele Neuronale Hamming.........................................................17
Reelele Neuronale Hebb.................................................................31
9.1 Neuroni formali ai reelelor neuronale artificiale..............31
9.2 Rezolvarea problemelor pe baz de neuroni independeni.
Regula Hebb............................................................................37
9.3 Reeaua neuronal Hebb....................................................45
BIBLIOGRAFIE.............................................................................49
ANEXA 1........................................................................................50
ANEXA 2........................................................................................58
ANEXA 3........................................................................................63
CAPITOL I
LUCRAREA DE LABORATOR 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 a 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 pe 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 ntre obiectele universului problemei. Numrul
de argumente ale faptelor este reprezentat prin aritatea corespunztoare a
predicatelor.
Exemple:
Fapt: Aritate:
cine(bobi). 1
place(ion, ioana). 2
place(ion, ana). 2
frumoas(ana). 1
bun(daniel). 1
deplaseaz(cub, camera1, camera2). 3
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 ncepe cu o majuscul iar
numele constantelor simbolice ncep cu o 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 i valorile variabilelor
astfel obinute sunt afiate ca rspuns la satisfacerea acestui scop.
Exemple:
?- caine(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, care 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 obicei numit
satisfacerea scopului iar obinerea celorlalte soluii, re-satisfacerea
scopului. La satisfacerea unui scop cutarea se face ntotdeauna de la
nceputul bazei de cunotine. La re-satisfacerea 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 re-satisfcut, 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
antetul 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 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), care este 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 s observm 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 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 re-
satisfacerea 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). Re-satisfacerea 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 (re-satisfacere) a scopului
cunoaste(ion, Y) este dat de faptul (4) care determin instanierea Y
= ana. n acest moment se ncearc satisfacerea 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, a doua soluie a scopului
place(X, Y) este obinut 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 re-satisfacere 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 re-
itereaz i ncearc re-satisfacerea scopului din stnga, pornind
cutarea n baza de cunotine de la marcaj n mod descendent.
nainte de re-satisfacerea 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 re-satisfacerea scopurilor din conjunciile de
scopuri se numete backtracking.
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 ot dac este brbat i
este cstorit cu o femeie (Femeie). Aceast definiie va fi codificat
prin urmtoarea regul:
sot(Barbat, Femeie):-
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 apare 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.
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 relaii directe dintre
persoanele ce alctuiesc baza de cunotine. n continuare, vom defini
dou reguli care prezint relaii indirecte ntre persoanele din baza de
cunotine. Vom defini regula bunic i regula nepot utiliznd
relaiile prezentate n Figura 1. 2 .
Pentru a afla bunicul Z 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 prezentat mai sus
este urmtoarea:
sora(X,Y):-parinte(Z,X), parinte(Z,Y), femeie(X), X <>Y.
Menionm faptul c modalitatea n care X i Y au acelai printe a
fost prezentat anterior. n Prolog, operatorul <> are sensul de diferit.
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 n derularea
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. Arbore genealogic elaborat trebuie s conin cel puin trei
nivele. Pentru cercetarea relaiilor existente n familie se vor utiliza
nu mai puin de ase scopuri.
4. Se va prezenta darea de seam .

Mecanisme de control al procesului de backtracking
Scopul: nsuirea ideilor despre mecanisme 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
atele 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

prezentai n Figura 2.1 :
Figura 2.1 - Arbori de deducie a scopurilor f(1,Y) i f(1,Y),2<Y
Se observ c se ncearc re-satisfacerea 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 re-satisfacerea scopului f, deoarece aceasta nu este posibil.
ncercarea de re-satisfacere a scopului f(X, Y) poate fi mpiedicat
prin introducerea predicatului cut.
Predicatul cut, notat cu atomul special !, este un predicat standard,
fr argumente, care poate fi ndeplinit (este adevrat) ntotdeauna i
nu poate fi re-satisfcut.
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 re-
satisfacere 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 re-satisfcute
datorit lui cut. Dac D1, , Dm sunt satisfcute, C2 i C3 nu
vor mai fi utilizate pentru re-satisfacerea lui H. Re-satisfacerea
lui H se poate face numai prin re-satisfacerea unuia din scopurile
Dm+1, , Dn, dac acestea au mai multe soluii.
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.
Se consider 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).
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 valori 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, deci 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.
Atunci cnd fail este plasat dup predicatul cut, atunci 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).
?-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 re-
satisfacere 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 sub 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
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.
1. Citii breviarul teoretic. Se atrage atenia asupra faptului c toate

cunotinele din aceast lucrare vor fi necesare i n derularea
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)
Facei concluzii.
3. Rezolvai urmtoarele probleme propuse i se va urmri

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).
Facei 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 schimbri corespunztoare n program (punct 2.1),

utiliznd cut verde cel puin n dou reguli din baza de cunotine.
5. Introducei schimbri corespunztoare n program (punct 2.1),

utiliznd cut rou n reguli din baza de cunotine. Facei concluzii.
6. Prezentai darea de seam.

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 structuri 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:
[] lista 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:
Tabel 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 in predicatele care prelucreaz liste

folosindu-se de avantajul regulii de unificare (identificare,
substituire):
singurul termen care se identifica cu [] este [].

o list de forma [H1|T1] se va identifica numai cu o list de
forma [H2|T2] daca H1 se poate identifica cu H2 i T1 se poate
identifica cu T2.
Urmtorul tabel, prezint cteva exemple care ilustreaz aceast regula de
unificare:
Tabel 3.2 Exemple ce ilustreaz regula de unificare

Lista1 Lista2 Legarea
[X,Y,Z] [Ion, Maria, variabilelor
X=Ion, Y=Maria,
[7] Vasile]
[X,Y] Z=Vasile
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 baza: lista vida []

cazul recursiv: pentru o lista de forma [H|T], se efectueaz
anumite aciuni asupra capului H, i ulterior se apeleaz predicatul
recursiv cu coada T.
Utiliznd listele, putem acumula 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).
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)
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
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 sa 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 intregi,

reale i complexe
Se propun spre rezolvare urmtoarele probleme (precizai varianta

corespunztoare la profesor):
1. 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 in L lista [1, 2, 3, 4, 5, 6, 7, 8, 9].
2. Scriei un predicat descomp(N, Lista) care primete un numr

ntreg N i ntoarce o list a factorilor primi ai numrului N; de exemplu:
descomp(12, [2, 2, 3]) este adevarat.
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.
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 identica, 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.
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.
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].
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] si L3 = [d, e].
8. S se scrie un predicat evenmember(Elem,Lista) care spune

daca Elem se afl n Lista pe poziie par. De exemplu, apelul
evenmember(X,[1,5,3,4]) va returna pe rind solutiile X = 5; X
= 4.
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] si L3=[b,d].
10. S se scrie un program Prolog care s calculeze media numerelor

unei liste.
11. S se scrie un program Prolog care calculeaz i afieaz cel mai mare
divizor comun al tuturor numerelor dintr-o list.
12. S se scrie un program Prolog care s sorteze descresctor numerele

unei liste.
14. 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.
15. S se elimine primele N elemente de la nceputul unei liste. Numrul

elementelor pentru eliminare se va introduce utiliznd predicatul readln
al limbajului Prolog.
16. S se elimine ultimele N elemente a unei liste. Numrul elementelor

pentru eliminare se va introduce utiliznd predicatul readln al
limbajului Prolog.
CAPITOL II
Exemple i Probleme n Limbajul Prolog
Sisteme Expert
Scopul: Studierea principiile 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 obicei, 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: primirea informaiilor
de la utilizator, transferul rezultatelor n forma cea mai convenabil
utilizatorului, explicarea rezultatelor primite 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 "dac-atunci" 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) este efectueaz prin cutare i comparare a 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
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, de obicei 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, ntr-acel bazat pe logic, utilizatorul primete 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 Sistem Expert, bazat pe reguli i realizarea lui.
SE pe baza regulilor, permite proiectantului de 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 regulile MI, SE este
compus dintr-un interpretator, care selecteaz i activeaz diferite sisteme.
Activitatea acestui interpretator este descris de 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 a SE este rezultatul uneia din regulile de
producie, selecia regulii se efectueaz, n conformitate cu datele de
intrare.
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 atrnata),
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, coad atrnat),
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 sub-categoriilor. 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(cinele are, par scurt), !.
it_is(cu par lung):

positive(cinele 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:
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 determinarea (gsirea) rspunsului
xpositive (X, Y) i xnegative (X, Y) predicatele bazei dinamice de date

pstreaz respectiv, rspunsurile afirmative i negative a 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 primi 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.
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, care caracterizeaz diferite
obiecte. Numrul de trsturi determin gradul de precizie de clasificare.
Interpretatorul n cadrul sistemului ndeplinete funciile sale pe 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 a mai multor dect unei singure
reguli pentru a rezolva conflictul sistemul utilizeaz mecanismul intern de
unificare a Prolog-ului.
3) Sistemul primete 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 procesul de

detectare-aciune. Principala diferen n structura SE, bazat pe logic este
n descrierea obiectelor i atributelor sub forma de fapte:
/ * Condiii-caracteristici de rase diferite .* /
cond(1, rasa cu par lung).

cond(2, rasa cu par lung).
cond(3, maimic de 22 inch).
cond(4, mai pare de 30 inch).
cond(5, coada atrnata).
cond(6, urechi lungi).
cond(4, caracter bun).
cond(8, 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, cine, cu par scurt, [1]).

rule(2, cine, cu par lung, [2]).
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 s fac alegerile (seleciile) adecvate.
MI conine regulile de tratarea 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), !,
check(Rule_number, History, Rest_breed_cond_list).
check(_, _, [Breed_cond|_]):
no(Breed_cond), !, fail.
check(Rule_number, History, [Breed_cond|Rest_breed_cond_list]):
cond(Breed_cond, Text),
ask_question(Breed_cond, Text),
check(Rule_number, History, 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 si primirea rspunsurilor da si 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 primite 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, este 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.
1. Pe baza materialului de la 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, i 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 Domeniul
1,5 Microprocesoare
2,6 Dispozitive mobile
3,10 Sisteme operaionale
4,11 Limbaje de programare
7,12,19 Jocuri pe computere
8,15,20 Virui de computere
9,16 Reele de calculatoare
13,17 Algoritmi de sortare
14,18 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 bazat 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.
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, traducere
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.
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 ntr-
un limbaj;
Sintez - procesul efectiv de trimitere a mesajului.
Receptor:
Percepie - procesul de primire al 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 Gigel: "Te rog nchide ua"
locuie ilocuie
interlocuiune ua nchis
Categorii locuionale:
Asertive asculttorul e 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 e 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
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. E 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
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 regulile de extindere a gramaticii.
d) Simbol de nceput 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:
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
7. NP, Verb, NP
8. NP, VP
9. S
5.1.4 Definite Clause Grammar (DCG)
Exist mai multe tipuri de reprezentare pentru gramatici prezentate 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 non-terminali)
Exemplu:
<syntax> : : = <rule> | <rule> <syntax>
<rule> : : = <whitespace> <<rule_name>>
<whitespace> : : = <whitespace >| etc.
BNF este o gramatic dependent de context (GDC), ceea ce e dificil de

transpus ntr-un program automat
b) Gramatici cu clauze definite DCG Definite Clause

Grammar
n modul implicit DCG sunt gramatici independente de context, ce sunt
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 ex.). Aceasta se realizeaz prin faptul c DCG se bazeaz pe
FOPL (First Order Predicate Logic) n reprezentare.
n DCG:
Fiecare regul din gramatica poate fi vzut ca o regul din DCG
Fiecare categorie sintactic se reprezint printr-un predicat cu un
argument ir.
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) NP(s)
n BNF:
Noun ball | book
n LP / DGC
(s = ball s = book) Noun(s)
Tabel 1 - Soluia comparativ cu limbajul PROLOG.
BNF FOPL/DCG PROLOG
S NP VP NP(s1) VP(s2) sentence([S1, S2])
S(append(s1,s2)) :- np(S1), vp(S2).
NP Noun
Noun(s) NP(s) np(S):- noun(S).
Noun
stench (s = stench s = wumpus) noun(stench).
noun(wumpus).
Noun Noun(s)
wumpus
vp(S):- verb(S).
Verb(s) VP(s)
verb(smells).
VP Verb (v = smells v = kills) verb(kills).
Verb Verb(v)
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 este nevoie s realizm 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.
Automat:
Acest automat are 8 stri, starea 1 fiind starea iniial i 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. 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-urile vor fi prezentate ca reelele n mod

declarativ, ca pe 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 se 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).
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. 1 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. 2 Rezultatul execuiei recognize(X).
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
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(rich,adj).
final(8). word(culture,n).
arc(1,n,2). word(english,n).
arc(1,pron,2). word(is,v).
arc(2,v,3). word(the,art).
arc(3,part,6). word(most,adv).
arc(3,art,4). word(widespread,adj)
arc(4,adj,5). .
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).
word(a,art).
?- recognize([i,enjoy,learning,new,things]).
Yes.
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:
/*a recognizer based on the sentence frame grammar
notation*/
/*drive predicate*/
recognize(String):-
transform(String,CatString),
frame(CatString).
/*transform a string of words into a string of lexical
categories*/
transform([],[]).
transform([Word|String],[Cat|CatString]):-
word(Word,Cat),
transform(String,CatString).
Codul surs pentru lex.pl:

/*a lexical database giving the lexical category of
each word*/
word(moldova,n). word(most,adv).
word(has,v). word(widespread,adj).
word(a,art). word(language,n).
word(rich,adj). word(i,pron).
word(culture,n). word(enjoy,v).
word(english,n). word(learning,part).
word(is,v). word(new,adj).
word(the,art). word(things,n).
Codul surs pentru sf.pl:
/*a list of sentence frame*/
frame([n,v,art,adj,n]).
frame([pron,v,part,adj,n]).
frame([n,v,art,adv,adj,n]).
Deschidei fiierul sfg_rec.pl
/*load the lexical and sentence frame files*/

?-consult(lex.pl).
?-consult(sf.pl).
?-
transform([english,is,the,most,widespread,language],
CatString).
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 ea 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 este de forma

Simbol neterminal --> extindere
unde extindere const n unul dintre urmtoarele elemente:

un simbol neterminal (ex. np);
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, 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, este 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])
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.
5.2.5 Recursive Transition Network

MODEL: Our students enjoy learning new things.
Figura 5.3 RTN.
Tabel 5.2 - RTN soluie
String State Stack Comment

Our students enjoy S1 - Push to NP-net
learning new things NP1 S2 Recognize
Our students enjoy NP2 S2 pron
learning new things NP3 S2 Recognize
students enjoy learning S2 - noun
new things VP1 S3 Pop to S-net
enjoy learning new VP2 S3 Push to VP-net
things VP3 S3 Recognize
enjoy learning new NP1 VP4,S3 verb
things NP2 VP4,S3 Recognize
enjoy learning new NP3 VP4,S3 verb part1
things VP4 S3 Push to NP-net
learning new things S3 - Recognize
new things adj
new things Recognize
things noun
- Pop to VP-net
- Pop to S-net
- SUCCESS!
Codul surs pentru pdr.pl:
% Define predicate which sets up initial
configuration
recognize(String):-
initial(s,State),
config(s:State,String,[]).
% Final configuration
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|
Stack]).
Codul surs pentru rtn.pl:
initial(s,1). initial(vp,1).
final(s,3). final(vp,4).
arc(s,1,np,2). arc(vp,1,v,2).
arc(s,2,vp,3). arc(vp,2,vp1,3).
arc(vp,3,np,4).
initial(np,1).
final(np,3). initial(np,1).
arc(np,1,pron,2). final(np,3).
arc(np,2,n,3). arc(np,1,adj,2).
arc(np,1,adj,2). arc(np,2,n,3).
Codul surs pentru lex.pl:

word(our,pron).
word(students,n).
word(enjoy,v).
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 caracteristicilor sistemului expert elaborat;
3) Diagramele datelor de intrare i diagrama structural a Sistemului
Expert, att bazat pe reguli, ct i bazat 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.
Algoritmi de recunoatere
Scopul: Achiziionarea i consolidarea cunotinelor

i deprinderilor practice de lucru cu algoritmi simpli de
recunoatere a obiectelor dup caracteristici 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 schimbare 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 a
imaginilor este 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 la o gam de lungimi de und specific undelor
electromagnetice, n limitele creia se schimb culoarea.
Exist abordri diferite pentru recunoaterea caracteristicilor

calitative a imaginii. n acest laborator vom lua n considerare una
dintre ele, bazndu-ne pe codare binar, prezena sau absena unei
trsturi de calitate.
n aceast abordare analizm o imagine concret Xk.

Caracteristicile calitative pot fi reprezentate ca un vector binar
X k 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 exemplul patru obiecte (viin, portocal, mr, pepene
galben), fiecare obiect are
trei caracteristici: culoare, prezena de smburi sau de
semine (Tabelul 6.1). n Tabelul 6.2 sunt aduse 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 - reduce problema iniial la
rezolvarea problemei recunoaterii imaginii
cu caracteristicile cantitative ale spaiului vectorial n-dimensional.
Pentru aceasta e necesar ca pentru 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. n rezultat obinem un
spaiu multi-dimensional caracteristic binar, unde poate fi calculat
o gam de distane, utilizat pentru recunoaterea
obiectelor cu caracteristici cantitative.
Tabelul 6.1 - Prezena de smburi sau semine n imagini

Vector galben oranj rou smbure semine
Viin X1 nu nu da da nu
Portocal X2 nu da nu nu da
Mr X3 da nu da nu da
Pepene X4 da nu nu nu da
Tabelul 6.2 - Trsturile calitative a imaginelor

Vector galben oranj rou smbure semine
semn
Viin X1 x11 = 0 x12=0 x13= 1 x14= 1 x15=0
Portocal X2 x21= 0 x22= 1 x23=0 24=0 x25= 1
Mr X3 x31= 1 x32=0 x33= 1 x34=0 x35= 1
Pepene X4 x41= 1 x42=0 x43=0 x44 =0 x45= 1
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):
L1 S i , X j s x jk
n
ik
2
(1)
k 1
L2 S i , X j s x jk
n

ik
(2)
k 1
L3 S i , X j sik x jk
n
(3)
k 1
Unde
L p S i , X j , p 1,3
corespunde distanei dintre imaginea de intrare (4)
S i si1 ,..., sin
cu imaginea model (5)
X i xi1 ,..., xin
iar parametrul j reprezint numrul modelului i (6) 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, atunci distana dintre ei
este zero, n cazul n care vectorul nu are o component echivalent,
atunci 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, cu ajutorul .
Tabelul 6.3 - Compatibilitatea i diferena

Xj Xi
1 0
1 h
0 g b
Variabila a n este proiectat pentru a contoriza

numrul de caracteristici comune ale obiectelor Xj, i Xi. Ea
poate fi calculat utiliznd relaia:
n
a 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
b 1 x jk 1 xik
n
(8)
k 1
Variabilele g i h sunt, respectiv, pentru a calcula
numrul de caracteristici care sunt prezente n obiectul Xi i lipsesc
n Xj i sunt prezente n obiectul Xj i lipsesc din Xi
x 1 x
n
(9)
g k 1
ik jk
n
h 1 xik x jk (10)
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.
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
(11)
ab g h n
funcia de similitudine Zhokara si Nidmena
S2 X i , X j
a
(12)
nb
funcia de similitudine Dice
S3 X i , X j
a (13)
2a g h
funcia de similitudine de Snifa i Sokal
S4 X i , X j
a (14)
a 2( g h )
funcia de similitudine de Sokal i Michener
ab
S5 X i , X j (15)
n
funcia de similitudine Kulzhinskogo
S6 X i , X j
a (16)
gh
funcia de similitudine Yule
ab gh
S7 X i , X j (17)
ab gh
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 imagini (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 de la punctul 2.
4. Se va compune o funcie proprie n aa fel ca s fie similar cu

exemplele de recunoatere prezentate n S1-S7, totodat una din
funcii trebuie s ia o valoare minim, i alta - maxim.
5. Se va 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.
Algoritmi de recunoatere a imaginilor
Scopul: Cptarea cunotinelor i primirea 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 n-dimensional
continuu.
Msura asemnrii imaginilor n spaiu 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, primete 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:
L S k , S k max L S k , Si
(1)
i
L S k , S k min L S k , Si (2)
i
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
proeciile 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 dependen 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
(3)
s ik x j
s i1 x j1 s i 2 x j 2 ... s in x jn
L S i , X k 1
j arccos arccos S X
s i1 s i22 ... s in2 x 2j1 x 2j 2 ... x 2jn
2
i j

unde |Si|, |Xj| - lungimile vectorilor Si i Xj.
Apartenena imaginii de intrare Si la una dintre m imagini, se

determin din urmtoarea regul decisiv:

S i 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 aceiai notare

X j j 1, m .
7.2 Recunoaterea imaginilor dup produsul lor scalar
Msura asemnrii imaginilor dup unghiul dintre (3) se

bazeaz pe produsul scalar al vectorilor:
n (5)
S j , X j Si X j cos sik x jk
k 1
Unele sisteme de recunotere folosesc nemijlocit produsul scalar n calitate

de msur de asemnare a imaginilor ntr-un spaiu n-dimensional
vectorial:
(6)
n
L S i , X j sik x jk
k 1
n acest caz apartenena imaginii de intrare Si la careva imagine etalon, se

determin din urmtoarea regul decisiv:

S i X j , dac L S i , X j max L S i , X j
j
(7)
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, care se refer la imaginile
virtuale date. n acest caz apartenena imaginii de intrare Si = (Si1, Si2, ...,
Sin) la o oarecare imagine virtual j ( j 1, m ) se determin din regula
decisiv
Si X j , dac ( s i1 , s i 2 ,..., s in ) V j (8)
Dac zona Vj ( j 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 primi forma

Si X j , dac L S i , X j x*jk sik
k 1
n
2
Rj (9)
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
L Si , X j s x jk
n
2 (10)
k ik
k 1
L Si , X j s x jk
n
(11)(11)
k ik
k 1
L Si , X j k sik x jk
n
(12)
k 1
sik x jk (13)
L Si , X j
n

k 1 sik x jk
(13)
unde k k 1, n coeficienii cu capacitate;

numr ntreg pozitiv, mai mare ca 2.
Regula decisiv (8) pentru distanele (10) (12) va primi forma
S i X j , dac L S i , X j Rij R j (14)
unde Rij distana dat din 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, i
regula decisiv are forma
si1 x j1 s i 2 x j 2 ... (15)
sin x jn
Si X j , dac L S i , X j ij arccos
s i21 si22 ... s in2 x 2j1 x 2j 2 ... x 2j

unde ij - unghiul dintre imaginile prezentate Si i imaginile etalon Xj,
j max - 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 n-
dimensional 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. Cu
zonelor sferice sau conice ce conin obiectele etalon, determinai
apartenena obiectelor prezentate pentru testare la un oarecare obiect
etalon.
Reelele Neuronale Hamming

Scopul: Cptarea i consolidarea cunotinelor, precum i formarea
deprinderilor practice pentru lucrul cu reelele neuronale Hamming.
Reeaua Hamming este una dintre cele mai performante reele

neuronale pentru recunoatere i clasificare. n aceast reea imaginile alb-
negru sunt prezentate sub form de vectori bipolari m-dimensionali.
Denumirea reelei provine de la distana Hamming, care se folosete de
reea n msurarea asemnrii a R imagini de intrare i celor etalon,
pstrate cu ajutorul balanei de legturi a reelei. Msura asemnrii se
determin din relaia:
R = m-Rx, (1)
(1)
unde m componenta numeric a vectorilor de intrare i etalon; Rx

distana Hamming dintre vectori.
Definiie:
Distana Hamming dintre doi vectori binari prezint 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:
unde a numrul de componente identice
ale vectorului; d numrul de componente diferite ale vectorilor
S i Z.
Deoarece dimensiunea vectorilor, atunci m = + d, rezult c

produsul scalar (2) poate fi scris n forma:
SZ = 2 - m.
De aici nu este greu de determinat:
(3)
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 a vectorului de intrare S = (s1, .., sm). Aceast interpretare a
prii drepte a expresiei (3) prezint arhitectura unei subreele neuronale,
care este redat de partea de jos a Figura 1. n unele surse reeaua din
Figura 1 este numit reea Hamming, altele numesc reea Hamming doar
partea de jos a figurii, socotind c reeaua e format din dou subreele -
Hamming i MaxNet. Noi vom considera c este o reea Hamming.
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:
(4)
Unde, Uout > U ieire
Uin -> U intrare ;
rezult c semnalul de ieire a elementului S, repet semnalul lui de
intrare:
Uout Si = Uin Si = sqi .
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:
Vk = (v1k,, vmk):
w1k = v1k/2, , wmk=vmk/2. (5)
Funcia de activare a Z-elemente este descris de relaia:
(6)
Unde Uin semnalul de intrare a neuronului; k1, U constante.
La descrierea imaginii S* = (s1*, , sm*) fiecare Z-neuron calculeaz

semnalul lui de intrare n conformitate cu expresia (3):
(7)
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 se dau de relaia:
unde constanta care satisface inegalitatea 0 < 1/n.
Reeaua funcioneaz ciclic, dinamica neuronilor este redat de relaia

iterativ:
(8)
cu condiiile iniiale
Ui(0)=ai=UinZi, i=1,n
Dac printre semnalele de intrare 1 ,..., an a neuronilor A1, ..., An

este un semnal cel mai nalt ( {1, 2, ..., n}), atunci n rezultatul
procesului iterativ n subreeaua MaxNet va prezenta un singur neuron ,
care va rmne cu semnal de ieire, mai mare ca 0, adic va deveni
"nvingtor". Cu toate c semnalele de ieire U1, ..., Up, ..., Un a -
elemente vin la intrrile a Y-neuroni, care au funcia de activare de
forma:
(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 a 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 - ea nu produce dou sau mai multe imagini de referin, avnd cu
imaginile impuse acelai nivel de asemnare.
Exemple:
De elaborat o reea Hamming, avnd n calitate de etalon 5 imagini alb-
negru V1, ..., V5; artate n Figura 2. De determinat influena imaginilor
prezentate n Figura 3.
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).
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:
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)
(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.
tiind toi parametrii reelei Hamming, vom urmri funcionarea ei la
prezentarea imaginii S1 = (-1, -1, 1, 1, 1, 1, 1,-1, 1), Figura 3.
Dup prezentarea imaginii S1 la ieirea neuronilor S, cu toate

semnalele lor de ieire 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):
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:
Vectorul:
Uout Z = (0,2; 0,6; 0,8; 0,4; 0,4) (12)
(12)
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
Folosind vectorul (Uout A1(1), ..., Uout A5 (1)) 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
abelul 8.1
Timpul Dimensiunea semnalelor de ieire a neuronilor Ak

(k=1,5)
Uout A1 Uout A2 Uout A3 Uout A4 Uout A5
0 0,200 0,600 0,800 0,400 0,400

1 0,000 0,240 0,480 0,000 0,000
2 0,000 0,144 0,432 0,000 0,000
3 0,000 0,058 0,403 0,000 0,000
4 0,000 0,000 0,402 0,000 0,000
abelul 8.1 - Rezultatele calculelor procesului iterativ n
subreeaua MaxNet
Procesul iterativ n subreeaua MaxNet se termin cnd t = 5, la acest 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 1.1., vine la intrarea elementelor Y. Neuronii Y
avnd funcia de activare (9), la ieirea unui singur element Y3 va aprea
semnalul unitate. Apariia acestui semnal ne vorbete despre faptul c,
imaginea redat S1 cel mai mult se aseamn cu imaginea etalon V3.
Comparaia vizual a Figura 8.2 i Figura 8.3 confirm funcionarea
corect a reelei.
Acum vom determina funcionarea reelei la redarea imaginii S2 = (-1, -1,

1,-1, 1,-1,-1,-1, -1). Calculele sunt identice, vom prezenta doar cele mai
importante rezultate intermediare :
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 rezultatul
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 maxim cu imaginea etalon V5,
ceia ce confirm comparaia vizual a Figura 8.2 i Figura 8.3 .
Vom determina reacia reelei Hamming la imaginea de intrare S3 = (-1,-

1,-1,-1,1,-1,-1,1,-1) (Figura 3). La prezentare imaginii S3 vom avea:
Deoarece semnalele Uin Z1(S3) = 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 a
neuronilor A (1 (S3) = 5(S3) = 0,8). n consecin, subreeaua MaxNet
nu va putea aloca un semnal maximal unic i n rezultatul 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 a numelui i prenumelui d-voastr, n
acelai timp motivai alegerea:
numrului de receptori a neuronilor;
numrului de neuroni a 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 imaginilor etalon a caracterelor. Facei
cunotin cu posibilitile reelei pentru determinarea imaginilor
distorsionate (eronate).
3. Alegei imaginea de intrare, egal ndeprtat pe distana Hamming de

la 2 imagini etalon. Care va fi efectul analizei acestei imagini? Ai
putea propune o metod de comportare mai informativ a reelei la
prezentarea unor astfel de imagini ?
Reelele Neuronale Hebb
Scopul: Cptarea i consolidarea cunotinelor, precum i formarea

deprinderilor practice pentru lucrul cu reelele neuronale Hebb.
9.1 Neuroni formali ai reelelor neuronale artificiale

n timpul modelrii reelelor neuronale n calitate de neuroni artificiali de
obicei se folosete un simplu element procesor, ilustrat n . La intrrile lui
vine vectorul X=(x1, ..., xn) de semnale de intrare, care la rndul lor sunt
semnale de ieire al altor neuroni, de asemeni conine i un semnal unic
de deplasare.
Toate semnalele de intrare, inclusiv i semnalul de deplasare, se nmulesc
la coeficienii ponderilor de legtur i se sumeaz:
(1)
(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 primit S vine la intrarea blocului, care realizeaz funcia f de

activare a neuronului. Funciile tipice de activare sunt binare:
(2)
sau bipolare :
(3)
Muli autori la descrierea modelului neuronului folosesc nu semnalul de

deplasare, dar pragul al neuronului, ceia ce ne duce la modelul
elementului echivalent. n acest caz expresiile (2) i (3) vor avea forma:
(4)
(5)
(6)
Imaginea grafic a funciei de activare binare i bipolare pentru acest caz

este artat n Figura 9. 2 a i b.
Figura 9. 2 - Funcia de activare a neuronilor.
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.
Rar se utilizeaz funcii liniare binare i liniare bipolare de activare

(Figura 9. 2 c i d):
unde a este egal cu 0 pentru

semnalele de intrare binare al
neuronilor i a este egal cu -1 pentru semnalele bipolare; k, a0
coeficieni permaneni.
n afar de cele prezentate mai sus, n teoria reelelor neuronale se
folosesc i urmtoarele funcii neliniare de activare:
sigmoida binar i sigmoida logic (Figura 2e):
(8)
unde coeficient permanent;
sigmoida bipolar (Figura 9. 2 f):
(9)
radial simetric (Figura 9. 2 g):
(10)
binar de rangul k (Figura 9. 2 h):
(11)
bipolar de rangul k (Figura 9. 2 i):
(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 se excit nu imediat cu venirea
impulsurilor, dar cu secvene de semnale de excitare, care vin n intervale
scurte de timp. De asemeni nu se ia 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
uor continuat, numai c reelele neuronale artificiale totui depisteaz un
ir de proprieti interesante, caracteristice pentru prototipurile biologice.
9.2 Rezolvarea problemelor pe baz de neuroni independeni. Regula

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 cu funcie 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 rezolvat i n multe cazuri este echivalent.
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 1) primete 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}, X1U X2 = M, X1 X2=, i fie c primei clase X1 i
corespunde semnalul de ieire y=1, i clasei X2 semnalul y = -1. Dac, de
exemplu este prezentat o imagine oarecare X = {X1,, X2}, X
M i sum capacitilor semnalelor de intrare depete valoare zero:
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 2.
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
aceia, dac imaginea de intrare X duce la apariia semnalului y = 1,
atunci X Xi, dac y = -1 (i y = 0, dac se folosete codificarea
binar), atunci aceasta ne arat c imaginea prezentat nu corespunde
clasei rezervate.
Sistemul de recunoatere n baza neuronului unic, mparte toat suprafaa
de soluii posibile n dou suprafee cu ajutorul hiperplanului :
Pentru vectori de intrare bidimensionali, pragul dintre dou clase
de imagini este o linie dreapt: vectori de intrare, care se afl mai sus de
aceast dreapt, aparine unei singure clase, dar mai jos alte clase.
Pentru adaptarea, setarea sau nvarea ponderilor (capacitilor)

legturilor neuronilor pot fi folosite mai multe moduri. Vom descrie unul
din el, primind numele de regula Hebb. Hebb, studiind mecanismele de
funcionare a sistemului nervos central (SNC), a presupus c nvarea se
produce pe calea mririi legturilor dintre neuroni, activitatea crora
corespunde dup timp. Dei n sistemele biologice aceast presupunere nu
se execut ntotdeauna i nu epuizeaz toate felurile de nvare, numai c
la nvarea reelelor neuronale pe un strat cu semnale bipolare este foarte
efectiv.
n conformitate cu regula 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:
unde wi (t), wi (t+1) respective 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 al neuronului.
ntr-o form mai complet algoritmul de setare a ponderilor legturilor

neuronului cu folosirea regulii 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:
Pasul 2. Pentru fiecare pereche (Xk, tk), k = 1 .. m, pn ce nu se

ndeplinesc condiiile de stopare, se ndeplinesc paii 3 5.
Pasul 3. Se iniiaz mulimea de intrri a neuronului:
Pasul 4. Se iniiaz semnalul de ieire a neuronului: y = tk.

Pasul 5. Se corecteaz ponderile legturilor neuronului dup regula:
Pasul 6. Controlul condiiilor de stopare.
Pentru fiecare imagine de intrare Xk se determin semnalul corespunztor

de ieire yk:
Dac vectorul (y1, ... , ym) semnalelor de ieire este identic 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
Exemplu:
Fie c trebuie s nvm un neuron bipolar pentru recunoaterea
imaginilor X1 i X2, ilustrate n Figura 3.
Figura 9.3 - Imaginile de intrare.
n acelai timp vom cere ca imaginii X1 s-i corespund semnalul de ieire

+1 al neuronului, i imagini X2 semnalul -1.
Aplicarea algoritmului Hebb ne ofer urmtoarele rezultate:

Pasul 1. Se dau mulimile:
se iniiaz ponderile legturilor neuronului: wi = 0, i = 0 .. 9.

Pasul 2. Pentru fiecare din perechile (X1,1), (X2,-1), se ndeplinesc paii 3
5.
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 Hebb
wi = wi + xi1y (i = 0 .. n):
Pasul 3. Se iniiaz mulimea de intrri ale neuronului pentru imaginea X 2

a perechii a doua: x0 = 1, xi = xi2, i = 0 .. 9.
Pasul 4. Se iniiaz semnalul de ieire al neuronului pentru imaginea din a

doua pereche (X2, t2):
y = t2 = -1
Pasul 5. Se corecteaz ponderile legturilor neuronului:
Pasul 6. Se verific condiiile de stopare.

Se calculeaz semnale de intrare i semnalele de ieire ale neuronului la
prezentare imaginii X1:
Se calculeaz semnalele de ieire i de intrare ale neuronului la
prezentarea imaginii X2:
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.
Ideea esenial a regulii (13) de a mri legturile, care leag neuronii cu

aceiai 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 Hebb (13) pentru reele binare cu un singur strat
poate fi scris n forma:
Exemplu:
Fie c trebuie de nvat 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 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:
Pasul 4. Se iniiaz semnalul de ieire al neuronului pentru imaginea X1:
Pasul 5. Se corecteaz ponderile legturilor neuronului cu ajutorul

relaiilor (14), (15):
Pasul 3. Se iniiaz mulimea intrrilor neuronului cu elementele imaginii
X2:
Pasul 4. Se iniiaz semnalul de ieire al neuronului pentru imaginea X2:
Pasul 5. Se corecteaz ponderile legturilor neuronului cu ajutorul

relaiilor (14), (15):
Pasul 6. Verificarea condiiilor de stopare.

Se determin semnalele de intrare i de ieire ale neuronului la
prezentarea imaginilor X1 i X2 :
ntruct vectorul (y1 ,y2) = (1, 0) este egal cu vectorul (t1 ,t2),
atunci calculele se stopeaz, deoarece a fost atins scopul.
9.3 Reeaua neuronal Hebb
Utilizarea grupului din m neuroni bipolari sau binari A1, ... Am

Figura 9.4 ne permite de a mri considerabil posibilitile reelei
neuronale i de a 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 pentru adaptarea ponderilor
legturilor reelei neuronale. De aceia, 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 primeasc 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
algoritmul 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 neuronului:
Pasul 2. Fiecare pereche (Xk, tk), se verific la corectitudinea reaciei

reelei neuronale la imaginea de intrare. Dac vectorul de ieire primit al
reelei (y1k, ..., ymk), se deosebete de cel iniial t1 = (t1k, tmk), atunci
ndeplinim paii 3 5.
Pasul 3. Se iniiaz mulimea de intrar a neuronilor: x0 = 1, xj = xjk, j =
1 .. n.
Pasul 4. Se iniiaz semnalele de ieire ale neuronilor: yi = tik, i = 0..m.
Pasul 5. Se corecteaz ponderile legturilor neuronilor dup regula:
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. Stopare
1. Elaborai structura reelei Hebb, care va fi capabil s recunoasc 4

litere diferite ale numelui i prenumelui d-voastr 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 recunoaterii a 4 caractere date.
4. Prezentai un set d simboluri de intrare i semnale de ieire dorite, cnd

n reea apare situaia cu proleme nerezolvabile de adaptare a
ponderilor legturilor.
5. Se va prezenta darea de seam .

BIBLIOGRAFIE
Cri:
A. Florea, A. Boangiu. Elemente de Ineligena Artificial.
A. Florea. Bazele logice ale Inteligentei Artificiale. Cap. 4, 6.
A. Florea, B. Dorohonceanu, C. Francu. Programare in 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
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 mai apoi este translat n limbajul mini-assembly,
care a fost 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
acestei scheme de compilare este producerea codului nativ i viteza de
compilare. O alt caracteristic este c executabilele sunt de dimensiune
mic.
Caracteristicile GNU Prolog:
este conform 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:
ANEXA 1 (continuare)
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
rapid dect rularea unui program interpretat. ns, nu e posibil de depanat
programul precum permite aceasta interpretatorul i nici de 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 s execute nsi interpretatorul,

cu alte cuvinte, s execute 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 e nevoie de tastat secvena de taste pentru
end-of-file (Ctrl-D) sau aliasul su end_of_file. La fel e posibil de folosit
predicatul predefinit halt/0 (cifra de dup / indic numrul de argumente
a predicatului).
Ciclul interactiv de citire-execuie-afiare al interpretatorului
GNU Prolog top-level se bazeaz pe un ciclu interactiv de citire-execuie-

afiare care permite re-executri 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 n aa mod 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)
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 creia este calea
relativ sau absolut ctre 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 depnare a programelor
Predicatul trace/0 activeaz regimul de depanare al interpretatorului.

Orice urmtoare invocare de predicate va fi depanat.
Predicatul debug/0 activeaz regimul de depanare al interpretatorului.

Doar urmtoarea invocare a careva 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.
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.
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 a
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).
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.
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;
}
}
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++)
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;
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;
}
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;
}
}
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);
ANEXA3 (continuare)
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();
}
}
}
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;
}
}
ANEXA3 (continuare)
private int _n, _m;
public int N
{ get
{ return _n;
}
set
{ _n = value;
_symbols.Clear();
}
}
public int M
{ get
{ return _m;
}
set
{ _m = value;
_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++)
ANEXA3 (continuare)
_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;
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)
ANEXA3 (continuare)
{ _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++)
{ 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);
ANEXA3 (continuare)
_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)
ANEXA3 (continuare)
{ if (!(e.OriginalSource is StackPanel)) return;
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
}
}

INDRUMAR

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

INDRUMAR

Transféré par

Droits d'auteur :

Formats disponibles

Ministerul Educaiei si Tineretului

PROGRAMAREA LOGIC I INTELIGENA

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

Chiinu U.T.M., 2013

Sunt elucidate teme, care au ca subiect sintaxa unui limbaj de

ndrumarul este destinat studenilor specialitilor Calculatoare

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

Introducere n Limbajul Prolog

Scopul: nsuirea principiilor fundamentale de programare a

PARTEA 1: Noiuni Teoretice

1.1 Entitile limbajului PROLOG

Prolog este un limbaj logic, descriptiv, care permite specificarea

Un program Prolog conine urmtoarele entiti:

Faptele sunt predicate de ordinul nti de aritate n considerate

Obinerea consecinelor sau a rezultatului unui program

n exemplele prezentate de pn acum, argumentele

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

Fie urmtoarea baz de cunotine Prolog:

Enunul de la ipoteza 6 definete o regul Prolog.

Pentru baza de cunotine descris mai sus, satisfacerea

La satisfacerea unei conjuncii de scopuri n Prolog, se ncearc

Figura 1.1 - Algoritmul de satisfacere a scopurilor n Prolog.

La general, o regul are urmtoarea sintax:

Un fapt poate fi vzut ca o regul fr corp (fr condiie).

Dup adugarea celor dou reguli, devine posibil introducerea

Figura 1. 2 - Graful pentru relaiile bunic- nepot utiliznd relaii deja

Pentru a afla bunicul Z unei persoane X procedm astfel:

1. Se va citi breviarul teoretic. Se atrage atenia asupra faptului c

2. Se vor studia exemplele propuse , ncercnd gsirea altor

3. Se va elabora un arbore genealogic i o baz de cunotine Prolog

4. Se va prezenta darea de seam .

Mecanisme de control al procesului de backtracking

Scopul: nsuirea ideilor despre mecanisme specifice limbajului

PARTEA 1: Noiuni Teoretice

Sistemul Prolog se implic automat ntr-un proces de backtracking

sistemul semnaleaz un eec. Arborii de deducie corespunztori sunt

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

Se observ c se ncearc re-satisfacerea primului scop cu regulile 2

Predicatul cut are urmtoarele efecte laterale:

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

Predicatul cut poate fi util n cazul n care se dorete eliminarea din

dac condiie atunci aciune1

daca_atunci_altfel(Cond, Act1, Act2) :- Cond, !, Act1.

min1(X, Y, X) :- X =< Y, !. % cut verde

min2(X, Y, X) :- X =< Y, !. % cut rou

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

Oportunitatea utilizrii unui cut rou sau a unui cut verde

daca_atunci_altfel(Cond, Act1, Act2) :- Cond, !, Act1.

unde predicatul not(Cond) este satisfcut dac scopul Cond nu este

Atunci cnd fail este plasat dup predicatul cut, atunci nu se

Scopul afisare(X) va afia toate obiectele roii cunoscute de

Analiznd combinaia !,fail, se consider n continuare

Un alt predicat standard este predicatul call, care permite

Att predicatul not ct i predicatul call sunt predicate de ordinul II n

1. Citii breviarul teoretic. Se atrage atenia asupra faptului c toate

2. Lansai la executare programul elaborat n lucrarea 1 i cercetai

3. Rezolvai urmtoarele probleme propuse i se va urmri

Facei o analiz comparativ ntre utilizarea predicatelor cut

copil(peter,9). copil(paul,10). copil(chris,9). copil(susan,9).

Definii un predicat din care rezult toate perechile de copii care

4. Introducei schimbri corespunztoare n program (punct 2.1),

5. Introducei schimbri corespunztoare n program (punct 2.1),

6. Prezentai darea de seam.