Inteligenta Artificiala

DAN ROTAR
D
D
A
A
N
N

R
R
O
O
T
T
A
A
R
R

MINISTERUL EDUCAIEI I CERCETRII
UNIVERSITATEA DIN BACU
FACULTATEA DE INGINERIE

INTELIGEN

A
A
A
RTIFICIA
A
A
L

I
I
N
N
T
T
E
E
L
L
I
I
G
G
E
E
R
R
T
T
I
I
F
F
I
I
C
C
I
I
N
N
L
L
EDITURA ALMA MATER

Bazele inteligenei artificiale
3

CUPRINS
Pag.
Capitolul 1
DOMENIILE INTELIGENEI ARTIFICIALE 5

Capitolul 2
BAZELE INTELIGENEI ARTIFICIALE 7
2.1. Logica clasic a propoziiilor 7
2.1.1. Simboluri, formule 7
2.1.2. Evaluare, funcie de adevr 9
2.1.3. Tautologie, validitate, consisten 10
2.1.4. Metoda lui Quine 13
2.1.5. Metoda reducerii 14
2.1.6. Echivalene 16
2.1.7. Reguli de manipulare i substituie 16
2.1.8. Dualitate 17
2.1.9. Conectori adecvai 18
2.1.10. Consecine logice 19
2.1.11. Forme normale 19
2.2. Sistemul deductiv al calculului propoziiilor 20
2.2.1. Demonstraie i deducie 20
2.3. Limbajul calculului cu predicate de ordinul nti 22

Capitolul 3
SISTEME EXPERT 24
3.1. Sisteme expert generaliti 24
3.2. Structura general a unui sistem expert 25
3.3. Funcionarea unui sistem expert 25

Capitolul 4
REALIZAREA UNUI PROGRAM N MEDIUL DE
PROGRAMARE CLIPS 28
4.1. Introducere 28
4.2. Execuia unui program n mediul de programare CLIPS
4.3. Structura programului CLIPS 32
4.3.1. Constructorii 32
4.3.2. Faptele 32
4.3.3. Constructorul deftemplate 33
4.3.4. Constructorul deffacts 34
4.3.5. Fapte ordonate 35
4.3.6. Adugarea i tergerea faptelor 36
4.3.7. Modificarea i duplicarea faptelor 39
4.3.8. Comanda watch 40
4.3.9. Definirea regulilor 41

4
4.3.10. Afiarea agendei 43
4.3.11. Urmrirea activrilor, regulilor i a statisticilor 44
4.3.12. Afiarea listei membrilor unei construcii specificate 45
4.3.13. Afiarea textului membrilor unei construcii specificate 45
4.3.14. tergerea membrilor unei construcii specificate 46
4.3.15. tergerea tuturor construciilor din mediul CLIPS 47
4.3.16. Comanda printout 48
4.3.17. Tipuri de date 48
4.3.18. Funciile 50
4.3.19. Constructorii 51
4.3.20. Faptele 51

Capitolul 5
REELE NEURALE 53
5.1. Modelul general al unei reele neuronale 53
5.2. Ecuaia de evoluie a reelei 55
5.3. Paradigme ale instruirii 56
5.4. Topologia multistrat a reelelor neurale 57

Capitolul 6
MULIMI NUANATE 58
6.1. Noiunea de mulime nuanat 58
6.2. Sisteme expert bazate pe mulimi nuanate 60

Capitolul 7
ALGORITMI GENETICI 62
7.1. Generaliti 62
7.2. Algoritmul genetic canonic 62

SEMINAR 66
Seminar 1 66
Seminar 2 68
Seminar 3 70
Seminar 4 71
Seminar 5 72
Seminar 6 72
Seminar 7 74

Laborator
Laborator 1,2,3 77
Laborator 4,5,6 90
Laborator 7,8,9 123
Laborator 10,11,12,13,14 134

BIBLIOGRAFIE 151


CAPITOLUL 1

DOMENIILE INTELIGENEI ARTIFICIALE

Inteligena artificial este o ramur a tinei calculatoarelor care se ocup cu
studiul posibilitii calculatoarelor de a avea o comportare asemntoare cu cea
omeneasc. Termenul a fost introdus n 1956 de ctre John McCarthy de la
Massachusetts Institute of Technology. Inteligena artificial cuprinde:

Jocuri: programarea calculatoarelor s joace jocuri cum ar fi ahul sau jocul
de dame;
Sisteme expert: programarea calculatoarelor s ia decizii n situaii reale (din
viaa real) de exemplu anumite sisteme expert ajut doctorii s stabileasc
diagnosticul bolii pe baza simptomelor.
Limbaje naturale: programarea calculatoarelor s neleag limbajul uman
natural.
Reele neurale: sisteme care simuleaz inteligena prin ncercarea
reproducerii tipurilor de conexiuni fizice ntlnite n creerul animalelor.
Sisteme fuzzy: numite i sisteme cu mulimi vagi bazate pe o logic n care
ntre cele dou valori de adevr: adevrat i fals exist o infinitate de valori
ce pot modela mai bine lumea real;
Algoritmi genetici: algoritmi bazai pe modul de dezvoltare evoluionist
copiind multe din principiile geneticii;
Robotic: programarea calculatoarelor s vad, s aud i s reacioneze ali
stimuli senzoriali;
Noi tehnici ale domeniului inteligenei artificiale care apar i se dezvolt
continuu indicnd marele interes de care se bucura aceast tiin.

n mod obinuit calculatoarele nu sunt dotate cu inteligen artificial complet
(adic cu posibilitatea s simuleze comportamentul uman). Cele mai mari progrese s-au
realizat n domeniul programrii jocurilor. Cel mai bun program de ah pentru
calculator este acum capabil s nving omul. n mai 1997 un supercalculator al firmei
IBM numit Deep Blue a nvins campionul mondial Gary Kasparov ntr-un meci de
ah.
n domeniul roboticii calculatoarele sunt larg utilizate n maini de asamblare
dar acestea sunt capabile s ndeplineasc numai sarcini extrem de limitate. Roboii au
mari dificulti n identificarea obiectelor pe baza imaginii sau prin palpare i de
asemenea mutarea sau apucarea obiectelor este nc stngace.
5

nelegerea limbajelor naturale ofer cel mai mare potenial de utilizare din
cauz c acestea vor permite oamenilor s interacioneze cu calculatoarelor fr a fi
necasare cunotiine de specialitate. Din pcate sarcina de a programa calculatorul s
neleag limbajele naturale s-a dovedit mult mai dificil dect s-a crezut la nceput.
Exist cteva sisteme care reusesc s fac traducerea automat dintr-un limbaj n altul
dar ele sunt departe de a fi la fel de bune ca traductorii umani. Sunt de asemenea
sisteme de recunoatere a vocii care pot converti sunetele pronunate n cuvinte scrise
dar acestea nu neleg ceea ce scriu; aceste sisteme sunt destinate numai dictrii. Chiar i
aceste sisteme sunt destul de limitate trebuie vorbit ncet i clar.
La nceputul anilor 1980 s-a crezut c sistemele expert vor constitui viitorul
inteligenei artificiale i ale calculatoarelor n general. Pn acum ns aceste sisteme n-
au rspuns ateptrilor. Multe sisteme expert ajut experii umani n diferite domenii
cum ar fi medicina sau ingineria dar aceste sisteme sunt foarte scumpe i sunt de folos
doar n situaii speciale.
Astzi cel mai fierbinte domeniu al inteligenei artificiale este cel al reelelor
neurale care sunt folosite cu succes n anumite domenii cum ar fi recunoaterea vocii i
procesarea limbajelor naturale.
Exist limbaje de programare care sunt cunoscute drept limbajele inteligenei
artificiale deoarece acestea sut folosite aproape exclusiv pentru aplicaii ale inteligenei
artificiale. Limbajele de programare mai cunoscute utilizate n acest scop sunt LISP i
Prolog.
Inteligena artificial se mparte n dou clase: inteligen artificial tare (strong
artificial intelligence) i inteligen artificial slab (weak artificial intelligence).
Inteligena artificial tare se refer la domeniul n care calculatoarele pot gndi
(cel puin) la fel ca oamenii. Inteligena artificial slab se refer doar la elemente de
gndire (raionamente) adugate calculatoarelor n scopul de a le face ct mai
folositoare i acest lucru este deja realizat prin sisteme expert martor, comanda i
conducerea automobilelor i programele de recunoatere a vorbirii.
Ce nseamn a gndi i a gndi ca este (nc) un domeniu pentru dezbateri
aprinse de acum ncolo.

6


CAPITOLUL 2

BAZELE INTELIGENEI ARTIFICIALE

2.1. Logica clasic a propoziiilor

2.1.1. Simboluri, formule

Obiectul logicii este identificarea i folosirea legilor raionamentului uman.
Logica simbolic utilizeaz simboluri pentru unitile de gndire i pentru operaiile
asupra lor.
Considerm propoziiile:

p Ion citeste.
q Ion scrie.

Notaia de mai sus arat c propoziia Ion citete va fi reprezentat prin
simbolul p. Propoziia trebuie s fie adevrat sau fals fr a putea fi adevrat i fals
n acelai timp. Pentru propoziia neadevrat se folosete negaia:

~ p Nu este adevrat c Ion citete (Ion nu citete).

Ct timp nu admitem dect cele dou valori de adevr (fals, adevrat) suntem n
cadrul logicii clasice sau a logicii bivalente.
n logica de tip propoziional, propoziiile sunt uniti nedecompozabile. Orice
consideraie asupra structurii lor interne este irelevant.
Propoziiile simple sau atomi p, q, r, ... sunt compozabile. Ele se pot combina
dnd natere la noi propoziii, la rndul lor adevrate sau false. Simbolurile numite
conectori indic operaiile de asociere sau combinare, care sunt cele mai frecvente n
vorbire sau raionament:

^ pentru i : p ^ q Ion citete i Ion scrie
v pentru sau : p v q Ion citete sau Ion scrie
pentru dac p atunci q : p q Dac Ion citete atunci Ion scrie
pentru p dac i numai dac q: p q

7

Propoziiile p ^ q, p v q, p q sunt formule propoziionale. Formulele vor fi notate cu
majuscule: P, Q, R, ... . De exemplu:

P : (p ^ q) r,

unde:
r Ion este mulumit.

Interpretarea formulei P este: dac Ion citete i Ion scrie, atunci Ion este
mulumit. Formula P este format din trei atomi. Ea poate fi privit drept o funcie de
atomii p, q, r, care, din acest motiv, se numesc variabile propoziionale.
n logica propoziional unitatea principal de lucru este formula.
Totalitatea simbolurilor logicii propoziiilor constituie un alfabet.
n cele ce urmeaz simbolurile logice vor fi urmtoarele:

p, q, r, ..., ~, ^, v, , , (, )

cu alte cuvinte, simbolurile pentru mulimea finit sau infinit de atomi: p, q, r, ... sau
p
1
, p
2
, p
3
, ..., p
n
, ...; simbolurile pentru conectorii logici, ce vor fi definii mai jos;
parantezele, stng, (, i dreapt, ).
Simbolurile ce nu sunt cuprinse n alfabet sunt simboluri metalogice. Aceast
restricie surprinde de la nceput: simbolurile P, Q, R, ... sau P
1
, P
2
, P
3
, ... utilizate n
formule care nu figureaz n alfabet.
Alfabetul mpreun cu formulele formeaz limbajul. Proprietile, legile, regulile
pot fi enunate pentru atomi i atunci avem nevoie de o regul suplimentar de trecere
de la atomi la formule (regula substituiei) sau pot fi enunate direct pentru formule, caz
n care poart denumirea de scheme.

Exemplu:

p^(pq)q

este o formul ntotdeauna adevrat (tautologie), oricare ar fi atomii p, q.
Iar:

P^(PQ)Q

unde P, Q sunt formule, este i ea totdeauna adevrat, oricare ar fi P, Q, de exemplu:

P=(p q)

i:

Q=(pvq) ^ (p v ~ q)

Legea tautologic enunat pentru atomi poate fi generalizat prin regula
substituiei. Este convenabil s o enunm ca o schem n forma general pentru
formule, fr a mai meniona substituia.
8

O formul P se obine din atomii p, q, r, ... prin operaiile efectuate de conectori.
Definiia recursiv a formulei este:

1) un atom este o formul;
2) dac P este o formul, (~P) este o formul;
3) dac P i Q sunt formule, atunci (P^Q), (PvQ), (PQ), (PQ) sunt
formule;
4) toate formulele se obin prin aplicarea regulilor 1) 3).

2.1.2. Evaluare, funcie de adevr

Introducem pe mulimea atomilor o funcie, numit de evaluare, care aplic
fiecare atom pe mulimea (adevrat, fals):

v(p)=1 (adevrat) sau v(p)=0 (fals)

Prima problem a calculului propoziiilor const n determinarea valorii de
adevr a unei formule n funcie de valoarea de adevr a atomilor. Notm valoarea de
adevr a unei formule P cu P
v
[0,1], sau cu notaia echivalent v(P).
Stabilim prin recuren urmtoarele reguli pentru evaluarea formulelor:

1) dac P este un atom, P
v
= v(P);
2) dac P= ~ Q, atunci P
v
= 1 dac Q = 0 sau P
v
= 0 dac Q = 1;
3) (P ^ Q)
v
= 1 dac P
v
= Q
v
= 1 sau (P ^ Q)
v
= 0 n celelalte cazuri;
4) (P v Q)
v
= 0 dac P
v
= Q
v
= 0 sau (P ^ Q)
v
= 1 n celelalte cazuri;
5) (P Q)
v
= 0 dac P
v
=1 i Q
v
= 0 sau (P Q)
v
= 1 n celelalte
cazuri (implicaie, se citete: P implic Q);
6) (P Q)
v
= 1 dac P
v
= Q
v
sau (P Q)
v
= 0 n celelalte cazuri
(dubla implicaie, se citete: dac P, atunci i numai atunci Q);

Un tablou care arat valoarea de adevr a unei formule pentru toate valorile
posibile ale atomilor din formul se numete tabel de adevr. Un exemplu de tabel de
adevr este:

P
v
Q
v
~P
v
(P^V)
v
(PvV)
v
(P Q)
v
(P Q)
v

1 1 0 1 1 1 1
1 0 0 0 1 0 0
0 1 1 0 1 1 0
0 0 1 0 0 1 1

Funcia de adevr face s corespund n mod unic fiecrei evaluri a atomilor
unei formule una din valorile de adevr 0 sau 1. Reprezentarea grafic a unei funcii
de adevr este tabela de adevr.
De exemplu funcia de adevr a conjunciei (a formulei P^Q ) se va nota:
f^(P,Q).
Unei formule cu n atomi, concepui ca variabile propoziionale, i va corespunde
o funcie de adevr cu n variabile. Tabela de adevr va avea 2
n
linii pentru cele 2
n

evaluri posibile.
9

Exist funcii de adevr distincte pentru o formul cu n variabile, deoarece
exist moduri de aranjare a lui 0 i 1 n ultima coloan a unei tabele de adevr
cu 2
n
2
2
n
2
2
n
linii. n cazul n=2 al formulelor cu 2 atomi exist 16 formule de adevr. Se pot
astfel defini 16 conectori binari, din care n aceast prezentare au fost selectai doar
patru.
Numrul formulelor care pot fi construite cu n variabile propoziionale este
infinit. Rezult c diferite formule corespund uneia i aceleiai funcii de adevr (tabele
de adevr).
Fie o formul P avnd atomii p
1
, ... , p
n
. O interpretare a lui P este o evaluare (o
atribuire de valori) a atomilor, fiecare primind valoarea de adevr 0 sau 1. Formula
P este adevrat ntr-o interpretare, dac este evaluat ca 1; altfel este fals ca
interpretare. O formul cu n atomi va avea 2
n
interpretri diferite. Liniile unei tabele de
adevr reprezint astfel de interpretri.
O interpretare I se reprezint prin mulimea a
1
, ..., a
n
, unde a
i
este p
i
sau ~p
i
.
Astfel {p, ~q, ~r, s} este o interpretare, n care p, q, r, s au respectiv valorile 1, 0,
0, 1. Dac P este adevrat n interpretarea I, se spune c I satisface pe P sau P este
satisfcut de I. Dac P este fals n interpretarea I, atunci I falsific pe P sau P este
falsificat de I. O interpretare I care satisface pe P se numete model a lui P.

Exemplu:

Fie formula P:

~(p v q) v ~ (q v p),

cu tabela de adevr:

p q p v q ~(p v q) ~(p v q) ~(p v q) v ~ (q v
p)
1 1 1 0 0 0
1 0 1 0 0 0
0 1 1 0 0 0
0 0 0 1 1 1

Formula P este satisfcut de interpretarea {~p, ~q} care constituie un model a
lui P. Interpretarea {p, q} falsific pe P.

2.1.3. Tautologie, validitate, consisten

O formul este valid, dac i numai dac este adevrat n toate interpretrile.
Altfel (dac i numai dac nu este valid) este nevalid.
O formul este inconsistent dac i numai dac este fals n toate interpretrile.
O formul este consistent dac i numai dac nu este inconsistent.
Denumirea clasic a formulei valide din punct de vedere semantic este
tautologie, iar a celei inconsistente este contradicie.

10

Exemple:

1) Formula P: p v ~ p este o tautologie (formul valid), ntruct funcia sa de
adevr ia n toate interpretrile valoarea 1.
2) Formula P: p ^ ~ p este o contradicie (formul nevalid) pentru c funcia sa de
adevr ia n toate interpretrile valoarea 0.

Propoziii.

1) O formul este valid dac i numai dac negaia ei este valid.
2) O formul este inconsistent dac i numai dac negaia ei este valid.
3) O formul este nevalid dac i numai dac exist o interpretare n care este
fals.
4) O formul este consistent dac i numai dac exist o interpretare n care este
adevrat.
5) O formul valid este consistent.
6) O formul consistent nu este neaprat valid.
7) O formul inconsistent este nevalid.
8) O formul nevalid nu este neaprat inconsistent.

ntruct folosirea terminologiei de mai nainte depete necesitile ce se ivesc
n demonstrarea automat a teoremelor, sunt folosite cu precdere urmtoarele expresii:

O formul consistent se numete realizabil.
O formul este nerealizabil (inconsistent) dac i numai dac nu este
realizabil.

Definiiile proprietilor de validitate (tautologii), consisten (realizabile),
inconsisten (contradicii, nerealizabile) i nevaliditate a formulelor sunt reprezentate n
schema urmtoare:

CONTRADICIE=NEREALIZABIL
P
v
= 0 ntotdeauna
NEVALID
P
v
= 0 uneori
VALID=TAUTOLOGIE
P
v
= 1 ntotdeauna
CONSISTEN=REALIZABIL
P
v
= 1 uneori

Proprietatea de formul nerealizabil devine central, dat fiind abordarea
caracteristic demonstrrii automate a teoremelor care folosete cu precdere principiul
contradiciei.
O formul este nerealizabil cnd este fals n toate interpretrile, deci cnd nu
admite model. Dac reuim s demonstrm c exist cel puin o interpretare pentru care
este adevrat (admite cel puin un model), ipoteza nu este adevrat i formula se
dovedete a fi realizabil.
Proprietatea poate fi enunat pentru o mulime S de formule: o astfel de
mulime este realizabil (ca funcie de adevr), dac exist o evaluare v pe mulimea
formulelor astfel ca P
v
= 1 pentru toi PS ; altfel S este nerealizabil. Dac S const
11

dintr-o singur formul, se spune c aceasta este realizabil, dac S este realizabil, i
nerealizabil, dac S este nerealizabil.
n limbajul evalurilor o tautologie este o formul T pentru care T
v
=1, oricare ar
fi valoarea v.

Tautologii fundamentale.

Urmtoarele formule valide sunt folosite cu precdere, ceea ce le-a fcut s se
disting uneori prin nume proprii. Ele sunt tutologii:

T0 PP
T1 (PQ) ((QR) (PR)) legea silogismului
T2 P(P v Q)
T3 Q(P v Q)
T4 (PQ) ((QR) ((P v Q)R))
T5 P ^ Q P
T6 P ^ Q Q
T7 (RP) ((RQ) (R (P ^ Q)))
T8 (P(QR)) ((P ^ Q) R) legea importrii
T9 ((P ^ Q) R) (P (QR)) legea exportrii
T10 (P ^ ~P) Q
T11 (P(P ^ ~P)) ~P
T12 P ^ ~P legea terului exclus sau
tertium non datur

Sunt frecvente i urmtoarele legi:

T13 (P ^ (P Q)) Q modus ponendo ponens sau
modus ponens sau
regula detarii
T14 (~Q ^ (P Q)) ~ P modus tollendo tollens
T15 (~P ^ (P v Q)) Q modus tollendo ponens
T16 ((P Q) ^ ~ Q) ~ P absurditate
T17 ~ (P ^ ~ P) negare (contradicie)
T18 P (Q P) simplificare
T19 (P (Q R)) (Q (P R)) schimbarea premiselor
T20 (P (Q R)) ((P Q) (P R)) legea lui Frege
T21 P ~ ~ P
T22 ~ ~ P P
T23 (P Q) (~P v Q)
T24 (~P v Q) (P Q)
T25 ~ (P v Q) (~P ^ ~Q) T25 T28: legile lui De
Morgan
T26 (~P ^ ~Q) ~ (P v Q)
T27 ~(P ^ Q) (~ P v ~ Q)
T28 (~ P v ~ Q) ~(P ^ Q)
12

T29 (P Q) (~Q ~P) T29 T32: legile
transpunerii
T30 (P ~Q) (Q ~P)
T31 (~P Q) (~Q P)
T32 (~P ~Q) (Q P)
T33 ((P Q) P) P legea lui Pierce

Demonstraia caracterului tautologic al formulelor T0 T33 se face prin scrierea
tabelei de adevr a fiecrei formule, a crei ultim coloan va fi compus din 1.

2.1.4. Metoda lui Quine

Un procedeu de a decide asupra realizabilitii unei formule (sau a caracterului
de tautologie sau de contradicie) care nu recurge la tabela de adevr a fost dat de
Quine.
Procedeul const din urmtorii pai:

1) Atomul care intervine cel mai frecvent este nlocuit o dat cu V
(adevr) i a doua oar cu F (fals), obinndu-se dou formule.
2) n fiecare din ele se aplic urmtoarele reguli:

a) se suprim V ca element al conjunciei;
b) se suprim F ca element al disjunciei;
c) o conjuncie cu F se nlocuiete cu F;
d) o disjuncie cu V se nlocuiete cu V;
e) o implicaie coninnd pe V se nlocuiete cu consecventul;
f) o implicaie coninnd pe F se nlocuiete cu negaia
antecedentului
g) se suprim V ca membru al unei duble negaii;
h) se nlocuiete dubla negaie, care conine F ca membru, cu
cellalt membru al ei.

3) Se aplic regula 1) la urmtorul atom cu frecvena cea mai mare i se
trece la regula 2), apoi la regula 3), pn la epuizarea atomilor.
Toate regulile se bazeaz pe tabele de adevr ce definesc conectorii.
Astfel regula b), F v q =q, exprim faptul c dac p este fals, p v q ia valoarea de
adevr a lui q.
Regula d), V v q = V, se reduce la faptul c o disjuncie este adevrat dac un
element este adevrat.
Regula f), cu privire la F q, sau p F, se deduce din:

p q p q
1 1 1
1 0 0
0 1 1
0 0 1

13

n primul caz F q nseamn c p q este adevrat, deci putem s-o nlocuim
cu negaia antecedentului (V). n al doilea caz, p F, evalurile (1,0) i (0,0), rezult
din tablou c are ntotdeauna valoarea lui ~p.

Exemplu:

Fie formula (p ^ q) v (~p ^ ~r) (q r). Este o tautologie sau o contradicie?
Aplicm metoda lui Quine:

((p ^ q) v (~p ^ ~r)) (q r)
((V ^ q) v (F ^ ~r)) (q r), ((F ^ q) v (V ^ ~r)) (q r)
(q v (F ^ ~r) (q r) (F v (V ^ ~r) (q r)
(q v F) (q r) (V ^ ~r) (q r)
q (q r) ~r) (q r)

V (Vr) F (Fr) F (qV) V (qF)

Vr V V qF

r q

V F F V

Formula nu este tautologie sau contradicie, ea este realizabil.
2.1.5. Metoda reducerii

Metoda reducerii se bazeaz pe ncercarea de a falsifica formula dat, al crei
caracter vrem s-l demonstrm. Presupunem c exist o evaluare v pentru care F
v
= 0.
nscriem aceast valoare (0) sub conectorul principal, iar deasupra lui numrul pasului
efectuat (1). Dac formula este de forma P Q, pasul 1 va consta n:

1
P Q
0

Dar implicaia P Q este fals numai cnd P este fals i Q este adevrat. Vom
scrie deci sub conectorul principal din P valoarea 1, sub conectorul principal din Q
valoarea 0 i deasupra ambilor conectori numrul pasului (2). Continum n acelai
fel pn cnd:

(a) obinem o evaluare consistent (necontradictorie) pentru toate
variabilele propoziionale sau
14

(b) nu gsim o asemenea evaluare. n primul caz, ipoteza iniial este
corect i formula este fals; n al doilea caz falsificarea nu a reuit i
dei formula este este valid.

Cnd formula este de forma:

1
P Q
0

din atribuirea valorii 0 nu rezult n mod unic c P este adevrat sau fals, de aceea
trebuie s considerm toate cazurile:

2 1 2 2 1 2 2 1 2
p ^ Q P ^ Q P ^ Q
1 0 0 0 0 1 0 0 0

unde valorile i indicii se pun i deasupra conectorilor principali din formulele P i Q.
Dac fiecare din cele trei cazuri conduc la contradicii, formula iniial este
valid. n caz c cel puin unul din ele permite gsirea unei evaluri necontradictorii,
formula a putut fi falsificat i este inconsistent. Evalurile pentru care se obine o
contradicie sunt subliniate.

Exemple:

1) Fie formula ((p q) ^ r) ((~r v p) q). Aplicnd metoda reducerii, se obine o
contradicie prin faptul c la pasul 3: v(r)=1, iar la pasul 9: v(r)=0

6 3 5 2 3 1 8 9 4 7 2 4
((p q) ^ r) ((~ r v p) q)
0 1 0 1 1 0 1 0 1 0 0 0
Observm c la pasul 3 din faptul c valoarea conjunciei din membrul nti este 1,
rezult c v(p q) =1 i v(r)=1. ntruct v(q)=0 (rezult din membrul 2 la pasul 4),
v(p)=0 (altfel v(pq)=0). Dar dac introducem v(p)=0 (din membrul nti, pasul 6) n
membrul doi (pasul 7), obinem v(~r)=1 i v(r)=0, ceea ce contrazice valoarea care i s-a
atribuit lui r la pasul 3. Formula este o tautologie.

2) Fie formula ((~r v p) q) ((p q) ^ r). ntruct la pasul 3 valoarea lui ~r v p nu
rezult n mod unic, trebuie s considerm urmtoarele trei cazuri:

3 2 3 1 2
a) ((~r v p) q) ((p q) ^ r)
1 1 1 0 0

15

3 2 3 1 2
b) ((~r v p) q) ((p q) ^ r)
0 1 1 0 0

3 2 3 1 2
c) ((~r v p) q) ((p q) ^ r)
0 1 0 0 0

Cazul b) i cazul c) duc la contradicii, dar cazul a) permite o evaluare consistent:

((~ r v p) q) ((p q) ^ r)
1 0 1 1 1 1 0 1 0 0 0 0

v(p)=1, v(q)=1, v(r)=0. Formula nu este o tautologie. Ea este falsificat de interpretarea
{p, q, ~r}. Formula este realizabil, pentru c alte interpretri, ca de exemplu {p, q, r},
contrazic ipoteza nerealizabilitii ei.

2.1.6. Echivalene

Definiie. Dou formule sunt (logic) echivalente (P echivalent cu Q) dac iau
aceleai valori de adevr pentru orice interpretare (au aceeai tabel de adevr); P Q
dac pentru orice evaluare P
v
Q
v
.

Definiie echivalent: dou formule P i Q sunt echivalente dac P Q este o
tautologie.

Echivalene fundamentale.

1. Absorbia P ^ (P v Q) P i P v (P ^ Q) P
2. Idempotena P ^ P P i P v P P
3. Comutativitatea P ^ Q Q ^ P i P v Q Q v P
4. Asociativitatea P ^ (Q ^ R) (P ^ Q) ^ R
P v (Q v R) (P v Q) v R
5. Distributivitatea P ^ (Q v R) (P ^ Q) v (P ^ R)
P v (Q ^ R) (P v Q) ^ (P v R)
6. Dubla negaie ~ (~ P) P
7. Legile lui De Morgan ~ (P ^ Q) ~ P v ~ Q, ~ (P v Q) ~ P ^ ~ Q
8. Transpunerea P Q ~ Q ~ P
9. Negaia implicaiei ~ (P Q) P ^ ~ Q
10. Formula bicondiional P Q (P ^ Q) v (~P ^ ~Q)

2.1.7. Reguli de manipulare i substituie

Regul. Dac P i P Q sunt tautologii, atunci Q este o tautologie.
Vom nota aceast regul MP de la modus ponens.
16

Fie F o formul n care apar atomii p
1
, p
2
, ..., p
n
. Fie P
1
, ... , P
n
formule oarecare.
Dac F este o tautologie, atunci obinut prin substituirea peste tot n F a fiecrei
apariii a lui p
i
prin P
i
(1 i n) este de asemenea o tautologie.

Exemple:

1. Prin tabela de adevr se demonstreaz c formula urmtoare este o tautologie:

~ (p ^ q) ~ p v ~ q (De Morgan)

nlocuind atomii p, q cu formulele P, Q, avem tautologia:

~ (P ^ Q) ~ P v ~ Q

unde P i Q sunt formule oarecare.

2. ntruct p
1
^ (p
2
^ p
3
) (p
1
^ p
2
) ^ p
3
este o tautologie (asociativitatea), oricare ar fi
formulele P, Q, R,

P ^ (Q ^ R) (P ^ Q) ^ R

va fi o tautologie.

ntr-o forml n care intervine subformula P, nlocuim pe P n unul sau mai
multe locuri cu formula echivalent Q. Rezultatul Q este logic echivalent cu . S
artm c Q este o tautologie. Fie o evaluare a atomilor. Formula are aceeai
valoare ca i Q, deoarece difer de aceasta numai prin faptul c P este nlocuit cu Q
avnd aceeai valoare de adevr. Deci P Q ia ntotdeauna valoarea 1.

Exemplu:

Formula (p^p) q este echivalent cu formula p q, deoarece am fcut
substituia p^p p, care reprezint o echivalen logic.

Prin folosirea semnului egalitii toate tautologiile sunt echivalente i toate
formulele nerealizabile sunt echivalente. ntruct P
v
=1 pentru toi v i Q
v
= 0 pentru toi
v determin pe P ca o tautologie i pe Q ca o formul nerealizabil, putem scrie 1 i
0 pentru orice formul care este tautologie, respectiv nerealizabil. De aceea P=1
nseamn c P este tautologie i Q=0 c Q este o formul nerealizabil.

2.1.8. Dualitate

O formul restrns este o formul care nu are dect conectorii ~, ^, v.
Dac ntr-o formul restrns schimbm ntre ele simbolurile ^ i v i nlocuim
fiecare atom prin negaia lui, obinem formula P
*
. Atunci P
*
este logic echivalent cu cu
~P: P
*
~ P (principiul dualitii).
Principiul general al dualitii afirm c un enun corect implicnd ^, v, 0, 1
poate fi tradus ntr-un alt enun corect prin schimbrile ntre ele ale simbolurilor 0 i
17

1, ^ i v. Noiunile definite n termenii acestor simboluri trebuie traduse prin dualele
lor. Astfel dualul termenului tautologie este nerealizabil pentru c cele dou
enunuri duale sunt:

P
v
=1 pentru toi v i P
v
=0 pentru toi v.

Astfel dualul enunului dac P este o tautologie, P v Q este o tautologie este
dac P este nerealizabil, P ^ Q este nerealizabil.

2.1.9. Conectori adecvai

O mulime de conectori se numete mulime adecvat, dac fiecare formul
poate fi exprimat cu ajutorul conectorilor acestei mulimi.

{~, ^, v}, {~, ^}, {~, v} i {~, } sunt mulimi adecvate de conectori.

Mulimi adecvate formate dintr-un singur conector:

1) - rejecie sau conectorul lui Nicod se citete nici ..., nici ... = NOR
(tehnic)

tabelul de adevr:

p q p q
-------------------------
1 1 0
1 0 0
0 1 0
0 0 1

Relaiile care leag acest conector de negaie i conjuncie sunt:

~p = p p i p ^ q = (p p) (q q)

2) | - incompatibilitate sau conectorul lui Sheffer NAND

p|q = ~p v ~q

tabelul de adevr:

p q p|q
-----------------------
1 1 0
1 0 1
0 1 1
0 0 1

Relaiile care leag acest conector de negaie i conjuncie sunt:
18


~ p = p|p i p ^ q = (p|p) | (q|q).

Avantajul de a micora numrul de conectori este pltit prin lungimea scrierii
formulelor.

2.1.10. Consecine logice

Fie n formule P
1
, P
2
, ..., P
n
. Formula P este o consecin logic (tautologic) a
premiselor P
1
, P
2
, ..., P
n
dac pentru fiecare evaluare v pentru care P
1
v
= P
2
v
= ... = P
n
v
=
1 avem P
v
= 1.
Pentru consecina logi folosim notaia P
1
, P
2
, ..., P
n
|= P. Simbolul |= n faa
unei formule denot c este o tautologie: |= P (citim P este o tautologie).
Cu alte cuvinte, orice model al conjunciei premiselor P
1
, P
2
, ..., P
n
este i model
al concluziei.
Fie formulele P
1
, P
2
, ..., P
n
. Formula P este o consecin logic a premiselor P
i
,
dac i numai dac P
1
^ P
2
^ ...^ P
n
^ ~P este nerealizabil.
Problema stabilirii dac o formul este consecin logic (numit i interferen
tautologic) revine astfel la stabilirea faptului dac o alt formul este tautologie sau
nerealizabil (pentru un numr redus de variabile propoziionale se poate recusge la
tabela de adevr a acestei formule).

2.1.11. Forme normale

1. Orice formul care nu este o contradicie este logic echivalent cu o formul
restrns normal disjunctiv:

ij
n j m i
l

unde l
ij
sunt literale.

2. Orice formul care nu este o tautologie este logic echivalent cu o formul
de form normal conjunctiv:
ij
m j n i
l

unde l
ij
sunt literale.

Conjunciile i disjunciile care au proprietatea de a lua valoarea formulei n cte
o interpretare a ei se numesc minitermeni sau clauze conjunctive, respectiv m
sau clauze disjunctive.
axitermeni

19

2.2. Sistemul deductiv al calculului propoziiilor

2.2.1. Demonstraie i deducie

Abordarea sintactic este susceptibil de un grad nalt de formalizare.
Simbolurile sunt iniial neinterpretate i servesc la construirea unui sistem deductiv
abstract. Prin interpretarea ca propoziii se obin consecine noi despre logica acestora.
Un sistem formal este definit de:

1) un alfabet de simboluri,
2) o mulime de formule bine formale,
3) o mulime de axiome,
4) reguli de deducie.

Sistemul formal L este definit astfel:

1) alfabetul simbolurilor este infinit, ~, , (, ), p
1
, p
2
, ...;
2) o formul bine format (pe scurt fbf) este definit recursiv:
a) p
i
este o formul fbf;
b) dac A i B sunt formule fbf, (~A) i (~B) sunt formule fbf;
c) mulimea formulelor fbf este generat numai prin regulile a) i b);
3) oricare ar fi formulele fbf A, B, C, urmtoarele formule fbf sunt axiomele lui
L:
L1 (A (B A)),
L2 ((A (B C)) (( A B) (A C))),
L3 ((( ~ A) (~ B)) (B A)).
4) regula de inferen este MP (modus ponens): oricare ar fi formulele fbf A, B,
din A i (A B) rezult B.

Din categoria simbolurilor primitive fac parte:

a) variabilele individuale;
b) conectivele logice: conjuncie, negaie;

ntruct reducerea numrului conectivelor logice duce la pierderea
semnificaiei naturale a proceselor infereniale, pentru raiuni practice se
accept drept primitive toate conectivele logice uzuale ale calculului
propoziional:

c) cuantificatorul existenial . Cuantificatorul universal poate fi exprimat
cu ajutorul cuantificatorului existenial prin transcrierea:

xF ~()~F

d) simbolurile relaionale;
e) simbolurile funcionale;
f) cte o constant individual.

20

Prima noiune care este introdus n cadrul unui sistem formal este aceea de
demonstraie.

Definiie. Se numete demonstraie secvena de formule A
1
, A
2
, ..., A
n
astfel c:

1) A
i
(1 i n) este axiom sau
2) A
i
urmeaz din A
j
, A
k
(j <i, k<i) dou formule anterioare ale secvenei prin aplicarea
lui MP.

Ultima formul A
n
este o teorem n L, iar secvena este demonstraia lui A
n
n
L.

Exemplu:

Fie: A
1
=p
1
(p
2
p
3
),
A
2
=(p
1
(p
2
p
3
)) ((p
1
p
2
) (p
1
p
1
)),
A
3
=(p
1
p
2
) (p
1
p
1
)

Deci, A
3
este o teorem n L iar A
1
, A
2
, A
3
demonstraia lui A
3
n L.

ntr-adevr, ntruct axiomele sunt scrise pentru A, B, C din L, este suficient s
punem A = p
1
, B = p
2
, C = p
1
, i se obin:

L1 p
1
(p
2
p
1
),
L2 (p
1
(p
2
p
1
)) ((p
1
p
2
) (p
1
p
1
)).

Aplicm acum regula MP formulelor A=p
1
(p
2
p
1
) i B=(p
1
p
2
) (p
1
p
1
).
Din A afirmat de L1 i A B afirmat de L2, deducem B adic:

(p
1
p
2
) (p
1
p
1
), MP (L1, L2)

Noiunea de demonstraie este lrgit de cea de deducie.

Definiie. Fie o mulime de formule L. Se numete deducie din o secven A
1
, A
2
,
..., A
n
, astfel c:

1) A
i
este o axiom (1 i n) sau
2) A
i
este un membru a lui sau
3) A
i
urmeaz din MP din doi membri antecedeni ai irului A
j
, A
k
(j <i, k<i).

Spunem c ultimul termen A
n
este deductibil din sau consecin a lui i
scriem:

|-

A
n.
L
21


Structura unei inferene.

inferen
Concluzie
Premise

Un lan inferenial exprimat n limbaj obiect, ale crui premise sunt axiome se
numete demonstraie iar concluzia se numete teorem.
Se consider c limbajele obiect cel mai larg utilizate n inteligen artificial
sunt limbajul calculului propoziional i limbajul calculului cu predicate de ordinul
nti.

2.3. Limbajul calculului cu predicate de ordinul nti

Limbajul calculului cu predicate de ordinul nti reprezint o extensie a
calculului propoziional prin luarea n considerare a componentelor propoziiilor, pentru
a interpreta modul n care acestea particip la determinarea valorilor de adevr ale
formulelor. Extensia se refer la simbolurile primitive ale limbajului. Propoziia este
considerat a avea o structur cu dou componente:

predicatul ce specific semnificaia funcional a propoziiei;
argumentul predicatului specific semnificaia suportului funcional al
propoziiei.

Orice predicat este P(x) joac rolul de funcie propoziional deoarece pentru
orice valoare a argumentului independent x, acesta ia ca valoare o propoziie, cu
valoarea de adevrat sau fals. Numrul de obiecte individuale ce compun argumentul
reprezint aritatea predicatului. Astfel pentru:

n=0 predicatul este o propoziie;
n=1 predicatul specific o proprietate a argumentului;
n=2 predicatul specific o proprietate binar;
n=3 relaie n-ar.

Orice predicat este de ordinul nti dac variabilele sale nu sunt predicate (se
poate spune despre astfel de variabile c pot fi considerate predicate de ordinul zero).
Un predicat care are cel puin una din variabilele sale individuale predicate de ordinul
nti se spune c este un predicat de ordinul doi. Se poate spune n general c un
predicat este de ordin n dac cel puin una din variabilele sale este un predicat de
ordinul n-1. Pentru calculul cu predicate de ordinul nti formulele se formeaz dup
regulile limbajului calculului propoziional, n care variabilele propoziionale sunt
nlocuite cu predicate. n relaia folosit pentru predicate, variabilele au semnificaie nu
prin simbolurile folosite, ci prin poziia i rolul pe care l joac n definirea predicatului
respectiv. Variabilele folosite n aceste notaii sunt denumite variabile formale, iar
notaia definitorie pentru predicate este denumit expresie predicativ sau ion.
Se spune c P(x,y) i P(u,v) sunt diferite atari de variabile formale pentru
aceeai expresie predicativ primar P(_1, _2) iar P(a, b) este o instan a acestei
expresii predicative n care a i b au fost asignate primului i respectiv celui de-al doilea
22

argument al predicatului. Pentru aprecierea valorii de adevr n raport cu domeniul n
care iau valori variabilele individuale ale predicatelor componente, se introduc o serie
de operatori unari denumii i cuantificatori ce acioneaz asupra variabilelor.

cuantificatorul universal indic faptul c formula prefixat este valid pentru
toate valorile posibile n domeniul variabilei x;
cuantificatorul existenial indic faptul c formula prefixat este valid
pentru cel puin o valoare din domeniul variabilei x.

Teoria demonstraiei la calculul cu predicate de ordinul nti folosete pe lng
axiomele i regulile de inferen ale limbajului calculului propoziional i urmtoarele
axiome:

|= xA(x) A(r)
|= A(r) xA(x)

n care:
x este orice variabil
A(x) este o formul
r reprezint orice variabil nu neaprat distinct de x
A(r) este rezultatul substituiei libere cu r a oricrei apariii libere a variabilei x
n A(x).

23


CAPITOLUL 3

SISTEME EXPERT

3.1. Sisteme expert generaliti

Sistemele expert bazate pe cunotiine sau pe scurt sistemele expert utilizeaz
cunotiinele omeneti pentru a rezolva probleme care necesit n mod normal
inteligena omeneasc. Aceste sisteme expert reprezint cunotiine de expert ca date
sau reguli ntr-un calculator. Aceste reguli i date pot fi apelate atunci cnd este
necesar rezolvarea unei probleme. Crile i manualele conin o cantitate impresionant
de informaii dar este necesar un om care s le citeasc i s le interpreteze pentru ca
aceste cunotiine s poat fi utilizate. Programele de calculator convenionale
realizeaz sarcini utiliznd logic de decizie convenional -- coninnd puine
cunotiine n afara algoritmului de baz pentru rezolvarea unei probleme specifice i
condiiile de grani necesare. Cunotiinele programului sunt adesea parte integrat a
codului programului i deci dac cunotiinele se schimb atunci se va schimba i
programul i va trebui s fie rescris. Sistemele bazate pe cunotiine colecteaz
fragmente mici de cunotiine omeneti eseniale (know-how) ntr-o baz de cunotiine,
cunotiine care au fost utilizate pentru raionamente n cazul rezolvrii unor probleme
utiliznd informaia cea mai adecvat. O problem diferit care se ncadreaz n
domeniul bazei de cunotiine poate fi rezolvat utiliznd acelai program fr
reprogramare. Abilitatea acestor sisteme de a simula raionamentele prin intermediul
reaciilor inverse (feedback) i de a permite un anumit grad de siguran i incertitudine
furnizeaz o facilitate suplimentar pe care nu o ntlnim n cazul programrii
convenionale.
Multe sisteme expert sunt dezvoltate prin intermediul unor unelte software
specializate numite shells. Aceste shells sunt echipate cu un mecanism de interfa
(nlnuire napoi backward chaining, nlnuire nainte - forward chaining sau
amndou) i solicit ca introducerea cunotiinelor n concordan cu un anumit format
(de exemplu toate care au aceeai importan). De asemenea shells au un anumit
numr de faciliti cum ar fi unelte pentru scrierea hipertextului, pentru construirea
interfeelor prietenoase, pentru manipularea listelor, irurilor i obiectelor i interfaarea
cu programe i baze de date externe. Aceste shells sunt calificate ca limbaje cu toate
c au un domeniu de aplicare mult mai ngust dect cele mai multe limbaje de
programare. Pentru mai multe detalii cu privire la shells pentru sisteme expert vezi
Expert System Shells at Work serie de Schmuller, PC AI (1991-1992).

24


3.2. Structura general a unui sistem expert

O ramur a inteligenei artificiale este reprezentat i de ctre sistemele expert.
Un sistem expert este un program care urmrete cunotinele, raioneaz pentru
obinerea rezultatelor ntr-o activitate dificil ntreprins de regul de experii umani.
Dac un expert uman are cunotine ntr-un domeniu specific, un sistem expert
utilizeaz cunotinele ce sunt stocate ntr-o baz de cunotine, baz format din
cunotinele asociate domeniului respectiv. Experii umani raioneaz i ajung la
concluzii pe baza cunotinelor pe care le posed, sistemele expert raioneaz utiliznd
cunotinele stocate n baza de cunotine.
Din punct de vedere funcional, un sistem expert poate fi definit astfel: un sistem
expert este un program care urmrete un grup de cunotine pentru a obine n acelai
mod ca i experii umani a rezultatelor despere activiti dificil de examinat. Principala
caracteristic a sistemelor expert este derivat din baza de cunotine mpreun cu un
algoritm de cutare specific metodei de raionare. Un sistem expert trateaz cu succes
probleme pentru care nu exist o soluie algoritmic clar.
Structura general a unui sistem expert este prezentat n figura urmtoare:

Utilizarea
cunotinelor
Tratarea
cunotinelor
Reprezentarea
cunotinelor
Achiziia de
cunotine
Utilizator
I
n
t
e
r
f
a
a

u
t
i
l
i
z
a
t
o
r

Modul de
explicare
Mecanism
de inferen
Baza de
fapte
Baza de
cunotine
M
o
d
u
l

d
e

a
c
h
i
z
i
i
e

a

c
u
n
o
t
i
n
e
l
o
r

Inginer de
cunotine
Expert
uman

3.3. Funcionarea unui sistem expert

Un sistem expert presupune existena unor reguli de forma:

Dac situaie Atunci aciune.

Un loc aparte l ocup regulile deductive (sau inferene) care sunt de tipul:

Dac premisa este adevrat atunci concluzia este adevrat.

Reprezentarea cunotiinelor.
Cunotiinele care sunt reprezentate n baza de fapte sunt cunotiine afirmative.
25

Cunotiinele coninute n reguli se numesc cunostiine operatorii. Ele indic
modul cum sunt folosite faptele. Din acestea se obin raionamente sau moduri de
aciune.
Mulimea de reguli i de fapte formeaz baza de cunotiine.
Cunotiinele sistemului de control se numesc strategii de control.

Motorul inferential.
La un sistem expert este necesar s fie dat o stare a bazei de fapte n care s
poat fi recunoscute regulile aplicabile. Acest operaie se numete filtrare. Preselecia
regulilor naintea filtrrii se numete restrictionare.
Dup ce s-a facut preselecia i filtrarea trebuie aleas o strategie de control
(operatie de selectare).

Strategiile de control la sistemele expert.
Fie o mulime de reguli coninute n baza de cunotiine sau o submulime din
aceste reguli. Filtrarea const n a gsi printre aceste reguli pe acelea a cror precondiie
este satisfcut. Trebuie deci, comparat precondiia cu informaiile care exist n baza
de fapte. De regul se aplic o regul deductiv de tipul celei artate mai sus.
n cazul n care asupra acestei operaii nu se aplic restricii atunci activitatea
decurge conform schemei logice prezentate n continuare.

Restricia nul
La nivelul filtrrii propriu zise se poate ameliora procesul prin introducerea
uneia sau mai multor restricii. n acest caz ntre informaiile coninute n baza de fapte
i precondiiile existente se aplic anumite restricii care vor selecta numai acele fapte
sau reguli care respect restricia respectiv obinndu-se mulimea faptelor i a
regulilor ca in figura de mai jos.
26


Funcionarea unui sistem cu restricie

27

28

CAPITOLUL 4

REALIZAREA UNUI PROGRAM N MEDIUL DE
PROGRAMARE CLIPS

4.1. Introducere

CLIPS este un limbaj destinat dezvoltrii sistemelor expert, realizat de Software
Technology Branch (STB), n cadrul laboratoarelor NASA Johnson Space Center.
Denumirea de CLIPS este o prescurtare pentru C Language Integrated Production
System. Este un limbaj bazat pe reguli, orientat-obiect i procedural, asemntor cu alte
limbaje de acest gen OPS5, ART, ART_IM, Eclipse, Cognate, dar mult mai puternic.
Fa de sistemul expert LISP care prezint o slab compatibilitate ntre diferitele tipuri
de calculatoare, un cost nalt pentru componentele software i hardware, precum i o
slab integrare cu alte limbaje, realizarea CLIPS-ului sub mediul de dezvoltare C a
permis nlturarea acestor lipsuri.
Partea orientat obiect numit i COOL (CLIPS Object-Oriented Language) este
o combinaie ntre trsturile gsite i la alte limbaje orientate obiect ,cum ar fi CLOS
(Common Lisp Object System) i SmalTalk, la care s-au adus i idei noi. Partea
procedural a CLIPS-ului este asemntoare cu limbajele C, Ada, Pascal i foarte
apropiate sintactic de LISP. Versiunea 5.0 a CLIPS-ului este cea care introduce suportul
de programare procedural i orientat obiect; versiunea 5.1 aduce cu ea suportul
software pentru programarea sub Windows, MS-DOS i interfeele Macintosh.
Datorit integrrii totale cu alte limbaje asemntoare cu C i Ada, CLIPS-ul
poate fi apelat de un alt limbaj procedural i dup execuia funciilor acesta returneaz
controlul napoi programului ce a realizat apelul. De asemenea codul procedural poate
defini i funcii externe, care dup ce vor fi apelate de CLIPS i i vor termina execuia
vor returna controlul napoi CLIPS-ului.

4.2. Execuia unui program n mediul de programare CLIPS

Pentru nceput vom ncrca n mediul de programare CLIPS un exemplu
realizat, pe care l vom studia. Acest exemplu se gsete n fiierul d1.clp.
Pentru execuia unui program n mediul CLIPS, mai nti se lanseaz n execuie
acest mediu de programare cu ajutorul comenzii: clipswin.exe pentru sistemul de
operare Windows sau clips386.exe pentru sistemul de operare DOS.
Dac CLIPS-ul a fost instalat corect va apare pe ecran prompter-ul:

29
CLIPS>
Din acest moment utilizatorul poate introduce comenzi, acestea fiind executate
direct de CLIPS. Acest mod de a lansa direct comenzi mai este denumit i top level.
Modul normal de ieire din CLIPS este comanda:
(exit)
dar mai exist uneori i alte posibiliti (de exemplu sub Windows se poate nchide
fereastra sau se poate folosi scurttura CTRL-Q, corespunztoare comenzii Quit
CLIPS din meniul File).
Diferena ntre (exit) cu paranteze i exit fr paranteze este ca nucleul CLIPS-
ului l va identifica pe primul ca fiind o comand i l va asocia pe al doilea cu un
simbol.
ncrcarea n mediul CLIPS-ului a construciilor aflate ntr-un fiier se
realizeaz cu ajutorul comenzii load. Sintaxa comenzii load este urmtoarea :
( load <file-name> )
Fiierul al crui nume este specificat cu <file-name>, poate fi realizat cu
ajutorul editorului de text al CLIPS-ului sau cu un alt editor. Marile avantaje pe care le
prezint folosirea unui fiier pentru stocarea construciilor se observ n momentul n
care CLIPS-ul verific sintaxa construciilor sau cnd se lanseaz n execuie
programul. Dac s-ar realiza introducerea construciilor direct de la prompter n
momentul n care ar fi fost semnalat o eroare, ar fi trebuit s reintroducem construcia
respectiv.
Presupunnd c avem ntr-un fiier exemplu.clp aflat pe discul C: construcii de
tipul deffacts, deftemplate, defrule, atunci ncrcarea acestora se va face cu:
(load C:exemplu.clp )
Dac fiierul respectiv se afl ntr-un director i trebuie s specificm calea,
atunci pentru a rezolva problema backslash-ului care este interpretat de CLIPS ca fiind
un caracter special, vor trebui folosite dou backslash-uri pentru a crea un singur
backslash. Specificarea cii se face astfel:
( load C : \ \ temp \ \ programe \ \ exemplu.clp )
Comanda load returneaz simbolul TRUE atunci cnd nu sunt erori n fiierul
ncrcat, respectiv simbolul FALSE n caz contrar. Dac este activat watch
compilations atunci va fi afiat un mesaj informaional (incluznd numele i tipul
construciei) pentru fiecare construcie ncrcat. Dac nu este activat atunci pentru
fiecare construcie va fi afiat un caracter (* pentru defrule; $ pentru deffacts; %
pentru deftemplate; : pentru defglobal; ! pentru deffunctions; ^ pentru defgeneric;
& pentru defmethod; # pentru defclass; @ pentru definstances; ~ pentru
defmessage-handler ; + pentru defmodule). Nu este obligatorie punerea tuturor
construciilor ntr-un singur fiier, dar n cazul folosirii mai multor fiiere trebuiesc
ncrcate toate fiierele pentru o bun execuie a programului. Dac se folosesc
construcii deffacts se d comanda reset pentru a introduce faptele n baza de fapte, iar
apoi comanda run.
LIPS> (watch compilations)
CLIPS> (load exemplu.clp)
Defining deftemplate: template_1
Defining deffacts: initial_facts
Defining defrule: regula_1 +j
TRUE

30
In acest exemplu fictiv se observ mesajele afiate pentru fiecare construcie
ncrcat. irul +j afiat la sfritul lui Defining defrule este un mesaj intern al
CLIPS-ului despre structura intern a regulii compilate. Pentru acelai exemplu fictiv
dac nu ar fi activat watch compilations, efectul ncrcrii fiierului ar fi urmtorul:
LIPS> (clear)
CLIPS> (unwatch compilations)
CLIPS> (load exemplu.clp)
%$*
TRUE
CLIPS>
Pentru a salva toate construciile existente n CLIPS la un moment dat, se
folosete comanda save a crei sintaxa este urmtoarea:
( save <file-name> )
In general folosirea unui editor de ctre utilizator implic i realizarea
modificrilor i salvarea construciilor cu acelai editor, din acest motiv folosirea
comenzii save este mai rar (dezavantaj: nu se pot salva n fiier doar anumite
construcii).
La fel ca i la comanda open se poate realiza salvarea construciilor ntr-un
fiier aflat ntr-un anumit director prin specificarea cii acestuia.
( save C : \ \ temp \ \ programe \ \ exemplu.clp )
Coninutul fiierului d1.clp este:
(deftemplate persoana
(multislot nume)
(slot grupa)
(slot an)
(slot ochi)
)
(deffacts date_initiale
(persoana (nume Ion)(grupa 1202)(an 2)(ochi verzi))
(persoana (nume Mihai)(grupa 1202)(an 2)(ochi albastri))
(persoana (nume Lucian)(grupa 1204)(an 2)(ochi caprui))
(persoana (nume Razvan)(grupa 1203)(an 2)(ochi verzi))
(persoana (nume Petrica)(grupa 1202)(an 2)(ochi negri))
(persoana (nume Marcel Tanase Radu)(grupa 1203)(an 3)(ochi rosii))
(persoana (nume Vasile Piulita)(grupa 1203)(an 3)(ochi albastri))
)
(defrule ochi_deschisi
(and (persoana (nume $?n1) (ochi ?c1&albastri|verzi) )
(persoana (nume $?n2 &~ $?n1) (ochi ?c2&albastri|verzi) ))
=>
(printout t "Persoanele " $?n1 " si " $?n2 " sunt frati " crlf )
)
Shell-ul unui limbaj bazat pe reguli cum este CLIPS-ul sau oricare alt sistem
expert are practic trei componente de baz:
o Lista de fapte conine datele ce vor interaciona cu programul;
o Baza de cunoatere conine toate regulile;
o Motorul de inferen controleaz execuia general a regulilor
programului.

31
CLIPS-ul este destinat dezvoltrii de software ca s ajute la o apropiere de
modelul de cunoatere i expertiz uman. Avem trei modaliti de reprezentare a
cunoaterii n CLIPS:
o Regula care reprezint cunoaterea euristic bazat pe experien;
o Funciile care reprezint cunoaterea procedural;
o Programarea Orientat Obiect cerut tot de cunoaterea procedural.
Se poate realiza n CLIPS software care s foloseasc fie doar reguli, fie doar
obiecte, fie o combinaie ntre acestea. Motorul de inferen este cel care va decide care
dintre reguli va fi executat i cnd, dei se va vedea ca utilizatorul are posibilitatea s
stabileasc pentru fiecare regul o prioritate i chiar un moment de timp la care s
nceap execuia regulii. Datele reprezentate n CLIPS de fapt sunt cele care vor stimula
execuia unei reguli, funcii sau obiect.
n figura 1 se prezint comenzile scrise pentru ncrcarea construciilor din
fiierul d1.clp n mediul CLIPS.
Selectnd din meniul principal Windows, opiunea Facts Window se afieaz
fereastra din figura 2.
Figura 1
Figura 2.

32
Putem nelege rezultatul execuiei programului.
La nceputul programului se afl constructorul deftemplate.

4.3. Structura programului CLIPS

4.3.1. Constructorii
Mai muli constructori de definiie apar n CLIPS: defmodule, defrule, deffacts,
deftemplate, defglobal, deffunction, defclass, definstances, defmessagehandler,
defgeneric i defmethod. Toate construciile n CLIPS sunt cuprinse ntre paranteze,
ncepnd cu o parantez deschis ( i terminndu-se cu o parantez nchis ) .
Aceti constructori se folosesc pentru a adauga o informaie la baza de cunoatere a
CLIPS-ului.
Fa de funciile apelate acetia nu returneaz niciodat o valoare. Se ofer
posibilitatea adugrii unui comentariu la numele construciei (excepie face doar
defglobal). Comentariile pot fi amplasate n CLIPS utiliznd punctul i virgula ;
(semicolon), iar CLIPS-ul va ignora tot ce va gsi dup punct i virgul. Dac avem la
nceput de linie punct i virgul ntreaga linie va fi tratat ca fiind un comentariu. n
momentul n care se va dori lansarea n execuie a unui program CLIPS-ul va ncerca
toate construciile ignornd comentariile.

4.3.2. Faptele
n CLIPS sunt trei forme principale de reprezentare a informaiei : fapte (facts),
obiecte i variabilele globale. Faptele sunt forma principal de reprezentare a
informaiei n sistemul CLIPS. Fiecare fapt reprezint un element de informaie care va
fi plasat n lista de fapte numit factlist. Faptul este forma fundamental de date folosit
de reguli i const ntr-un nume de relaie urmat de zero sau mai multe sloturi
(cmpuri simbolice crora li se pot asocia valori). Forma general a unui fapt va fi
urmtoarea :
fact => ( nume_relaie [ (slot)* ] [ (multislot)* ] )
Parantezele ptrate indica faptul ca existena sloturilor este opional, iar semnul * arat
faptul c putem avea zero sau mai multe sloturi. Se observ faptul c n CLIPS trebuie
s cuprindem ntre paranteze att numele de relaie ct i sloturile. Un slot este la rndul
su format dintr-un nume de slot, cruia i se poate asocia o valoare. Exist ns i
posibilitatea asocierii de mai multe valori i n acest caz spunem ca avem un multislot.
Acest lucru este posibil datorit existenei n CLIPS a multicmpului (multifield) care
este de fapt o secven de zero sau mai multe cmpuri. Afiarea n CLIPS a unei valori
multicmp se va realiza prin nchiderea acestuia ntre paranteze. Trebuie reinut faptul
c o valoare multifield (a) nu este unul i acelai lucru cu o valoare cmp (single field)
(a) .
slot => ( nume_slot valoare )
ultislot => ( nume_slot [ valoare ]* )
Un slot trebuie s aib obligatoriu asociat o valoare, pe cnd la un multislot
asocierea unei valori nu e obligatorie. Valorea pe care o asociem unui slot poate lua
forma unui tip de dat primitiv (integer, float, symbol, string) .
Exemple de fapte ar putea fi :
(start)
(adresa (nume-strada Alexandru cel Bun)
(numar-strada 47)

33
(bloc E1)
(scara D)
(apartament 31))
(persoana (nume Ion Vasile)
(culoare-par)
n primul caz faptul (start) nu are nici un slot. n al doilea caz faptul cu numele
de relaie adresa are mai multe sloturi i anume : nume-strada, numar-strada, bloc,
scara, apartament. Se observ faptul c putem asocia unui slot valori de diferite tipuri.
Astfel valoarea slotului nume-strada este un ir de caractere, valorile sloturilor numar-
strada i apartament sunt ntregi, iar valorile sloturilor bloc i scara sunt simboluri. n
ultimul caz, pentru faptul persoana, att slotul nume, ct i slotul culoare-par sunt
multisloturi (au asociate dou i respectiv zero valori).
Trebuie reinut faptul c n CLIPS nu are nici o importan ordinea apariiei
sloturilor i de aceea urmtoarele dou fapte sunt vzute ca fiind identice dei au
schimbat ordinea a dou sloturi :
(student (nume Pascal B. Mihaita)
(nr_grupa 1407)
(an IV))
(student (nr_grupa 1407)
(nume Pascal B. Mihaita)
(an IV)) .

4.3.3. Constructorul deftemplate
Pentru crearea unor fapte care sunt formate din sloturi, trebuie mai nti ca
acestea s fie declarate, astfel nct CLIPS-ul s poat s interpreteze acele sloturi ca
fiind valide i nu ca fiind nite funcii. Special pentru acest lucru avem construcia
deftemplate care va face ca o grupare de fapte cu acelai nume de relaie s conin un
anumit tip de informaie. Un constructor deftemplate are rolul de a crea un ablon ce va
fi folosit pentru a accesa cmpurile faptului dup nume. Acesta este identic cu o
nregistrare sau structur definit ntr-un limbaj de programare cum ar fi Pascal sau C.
Sintaxa unui constructor deftemplate este:
(deftemplate <deftemplate-name> [<comment>]
<slot-definition>*)
<slot-definition> ::= (slot <slot-name> ) | (multislot <slot-name> )
Folosind aceast sintax faptul student de mai sus ar putea fi descris astfel:
(deftemplate student Comentariu optional
(multislot nume)
(slot nr_grupa)
(slot an))
Redefinirea unui deftemplate duce la ignorarea definiiei anterioare. Nu putem
redefini un deftemplate ct timp acesta este folosit (de ex. dac o regul folosete un
fapt definit de acel deftemplate). O construcie deftemplate poate avea orice combinaie
de sloturi single-field i sloturi multi-field. CLIPS-ul va aplica ntotdeauna definiiile
pentru sloturi i de aceea vor aprea ntotdeauna erori la asocierea unei valori multiple
pentru un cmp single-field.
De asemenea n program se folosete constructorul deffacts.

34
4.3.4. Constructorul deffacts

ntr-un program este foarte avantajos ca dup ce au fost declarate construciile
deftemplate (dac este necesar prezena lor) s poat fi asertate toate faptele ce
reprezint baza iniial de cunoatere ntr-o singur aseriune. Aceste fapte sunt
cunoscute a fi adevrate nc nainte de rularea programului. Se poate defini un grup de
fapte care reprezint baza iniial de cunoatere cu ajutorul construciei deffacts. Sintaxa
comenzii este urmtoarea:
(deffacts <deffacts name> [<optional comment>]
<facts>* )
n cadrul construciei deffacts poate fi folosit ca nume orice simbol valid. Dup
numele construciei urmeaz comentariile, acestea sunt opionale i trebuiesc puse ntre
paranteze. Dup acestea urmeaz faptele ce vor fi asertate n lista de fapte.
Pentru a realiza asertarea faptelor dintr-o declaraie deffacts trebuie obligatoriu
utilizat comanda reset. Efectul acestei comenzi este acela c terge toate faptele din
baza de fapte (ca i comanda clear ) i introduce faptele din declaraiile deffacts.
Sintaxa comenzii este:
(reset)
Se va putea observa de asemenea c o dat cu comanda reset este introdus n
lista de fapte un nou fapt generat de aceasta, numit i iniial fact. CLIPS-ul folosete
acest fapt pentru a aprinde o regul care nu are nici un element condiional n LHS (se
va vedea n continuare). Introducerea acestui fapt se face automat de ctre CLIPS cu
ajutorul a doua construcii :
(deftemplate initial-fact)
(deffacts initial-fact
(initial-fact))
Identificatorul de fapt al lui initial-fact este ntotdeauna f-0 , deoarece acesta este
primul fapt ce va fi introdus de CLIPS n lista de fapte dup ce a fost dat comanda
reset. Dac se dorete o vizualizare a tuturor construciilor deffacts de poate utiliza
comanda get-deffacts-list.
CLIPS> (clear)
CLIPS> (assert (a))
<Fact-0>
CLIPS> (facts)
f-0 (a)
For a total of 1 facts.
CLIPS> (get-deffacts-list)
(initial-fact)
CLIPS> (watch facts)
CLIPS> (deftemplate data (slot zi) (slot luna) (slot an) )
CLIPS> (deftemplate angajat (multislot nume) (slot salariu) )
CLIPS> (deffacts date-initiale Baza de salarizare
(angajat (nume Cozma George) (salariu 1500000) )
(angajat (nume Miron Liliana) (salariu 1650000) )
(angajat (nume Mazilu Razvan) (salariu 1580000) )
(data (zi 31) (luna 9 ) (an 1991) ) )
CLIPS> (deffacts salariu_maxim)
CLIPS>(get-deffacts-list)

35
(initial-fact date-initiale salariu_maxim)
CLIPS> (reset)
<== f-0 (a)
==> f-0 (initial-fact)
==> f-1 (angajat (nume Cozma George) (salariu 1500000) )
==> f-2 (angajat (nume Miron Liliana) (salariu 1650000) )
==> f-3 (angajat (nume Mazilu Razvan) (salariu 1580000) )
==> f-4 (data (zi 31) (luna 9) (an 1991) )
CLIPS>
Se observ existena nc de la startarea CLIPS-ului a construciei deffacts
initial-fact. Funcia get-deffacts-list ne informeaz de existena celor trei construcii
deffacts, dar abia dup ce se d comanda reset n lista de fapte vor fi introduse faptele
acestora. Ultima construcie deffacts salariu_minim nu are nici un fapt, existena ei
fiind oarecum inutil.

4.3.5. Fapte ordonate
Un fapt ordonat (ordered fact) const ntr-un nume de relaie urmat de zero sau
mai multe cmpuri separate de spaii. Ar putea fi comparat cu un slot de tip multifeld n
care se pun toate valorile ce urmeaz dup numele de relaie. Lipsa sloturilor nu face
necesar existena unei construcii deftemplate care s le expliciteze. Din acest motiv
faptele care corespund unei construcii deftemplate se mai numesc i deftemplate facts
sau non-ordered facts. Faptele ordonate sunt create automat de un deftemplate implicit
al CLIPS-ului (fa de celelalte fapte care necesit existena unui deftemplate explicit).
n acest mod se poate implementa foarte uor o stiv sau o coad, sau se pot reprezenta
iruri de elemente. De exemplu:
(numere_pare 2 4 6 8 10) (numere_prime 2 3 5 7 11)
Aceste fapte se pot realiza n mod echivalent, folosind o construcie deftemplate:
(deftemplate numere_pare
(multislot valori))
n acest caz faptul echivalent va arta astfel:
(numere_pare (valori 2 4 6 8 10))
Cmpurile ntr-un fapt ordonat pot fi, orice tip de dat primitiv (cu excepia
primului cmp care reprezint numele de relaie i trebuie s fie de tip simbol), i nu
exist restricii privitoare la ordinea acestora. Totui urmtoarele simboluri sunt
rezervate i nu pot fi primul cmp dintr-un fapt (numele de relaie) : test, and, or, not,
declare, logical, object, exists, i forall. Aceste simboluri rezervate pot fi folosite la
numele unui slot, dar oricum acest lucru nu este recomandat. n urmtoarele exemple de
fapte :
(test de inteligenta artificiala)
(Test de inteligenta artificiala)
n primul caz CLIPS-ul ne va informa c nu putem folosi ca nume de relaie simbolul
test, dar n al doilea caz acesta va accepta ca nume de relaie simbolul Test, deoarece
dup cum s-a mai spus CLIPS-ul este case-sensitive i vede cele dou cmpuri ca fiind
total diferite. n al doilea fapt lista de elemente este format din trei cmpuri: de ,
inteligenta, artificial. CLIPS-ul face deosebirea ntre un ordered fact i un deftemplate
fact extrgnd primul cmp din fapt (numele de relaie) i comparnd-ul apoi cu numele
fiecrui deftemplate. Dac la un deftemplate fact schimbnd ordinea sloturilor se

36
obinea acelai fapt, n schimb la ordered fact schimbnd ordinea cmpurilor se obine
un alt fapt. Din acest motiv urmtoarele fapte sunt vzute de CLIPS ca nefiind identice:
(tatal_lui Toma Costache) | (lista 2 3 4)
(tatal_lui Costache Toma) | (lista 4 3 2)
n cazul unui fapt ordonat de forma :
(adresa Alexandru cel Bun 47 E1 D 31)
este n mod evident mai avantajoas folosirea unui fapt de tip deftempate unde s se
specifice clar prin numele sloturilor semnificaia fiecrui cmp. De aceea de cele mai
multe ori este recomandat folosirea unui deftemplate, deoarece numele sloturilor fac un
fapt mai uor de neles i folosit.
(adresa (nume_strada Alexandru cel Bun) (numar_srada 47)
(bloc E1) (scara D) (apartament 31))
Exist dou cazuri n care folosirea unui fapt ordonat este mai avantajoas i
anume unul n care faptul conine un singur slot (numele de slot ar putea fi sinonim cu
numele de fapt), i al doilea caz n care faptul este folosit ca un flag sau ca un indicator.
De exemplu:
(conditie_satisfacuta_prematur)
(timp 7:00)

4.3.6. Adugarea i tergerea faptelor
Toate faptele cunoscute de CLIPS sunt pstrate n lista de fapte ( fact list ).
Pentru a realiza adugarea sau tergerea unui fapt se folosesc comenzi, cum ar fi assert
pentru adugarea la list i retract pentru tergerea din list. Sintaxa comenzii assert
este urmtoarea :
(assert <fact>+)
Prin <fact>+ se nelege faptul c putem aserta un nou fapt sau chiar mai multe fapte noi
deodat. Astfel pentru a adauga un fapt cu mai multe sloturi procedm astfel:
CLIPS> (deftemplate adresa
(multislot nume-strada)
(slot bloc)
(slot scara)
(slot apartament))
CLIPS>(assert (adresa (nume-strada Alexandru cel Bun 47)
(bloc E1)
(scara D)
(apartament 31))
<Fact-0>
CLIPS>
Trebuie reinut faptul c funcia assert returneaz o valoare i anume adresa de
fapt. n cazul n care se aserteaz mai multe fapte deodat valoarea returnat va fi
indexul ultimului fapt introdus. n cazul nostru s-a realizat introducerea unui singur fapt
adresa care dup ce a fost introdus n lista de fapte, i-a fost asociat identificatorul 0.
Parantezele unghi < > sunt folosite ca delimitatori pentru a ncadra numele unui articol.
La fiecare nou adugare se va realiza automat o incrementare a numrului de fapte,
aceast valoare fiind returnat de funcia assert.
Comanda facts este utilizat pentru afiarea faptelor aflate n lista de fapte. n
cazul n care se utilizeaz comanda (facts) fr nici un parametru se va realiza afiarea
tuturor faptelor din list, dar dac se dorete o afiare a anumitor fapte, dorite de

37
utilizator se pot folosi i parametrii adiionali ai acestei comenzi. Aceast facilitate se
dovedete a fi foarte util atunci cnd avem un numr mare de fapte n list. Sintaxa
pentru comanda facts este:
(facts [<start> [<end> [<maximum>] ] ] )
, unde <start>, <end>, <maximum> sunt numere ntregi pozitive. Dup cum se vede toi
parametrii sunt opionali (n paranteze ptrate) i deci comanda poate funciona cu zero
pn la trei parametri. Dac apare primul parametru <start> toate faptele cu indexul mai
mare sau egal dect valoare lui <start> vor fi afiate. Dac apare i al doilea parametru
<end> atunci toate faptele cu indexul mai mici sau egale dect valoarea lui <end> vor fi
afiate. Dac apare i al treilea parametru <maximum>, atunci vor fi afiate evident un
numr maxim de <maximum> fapte. Dac se va da comanda (facts) rezultatul va fi
urmtorul.
CLIPS> (facts)
f-0 (adresa (nume-strada Alexandru cel Bun 47) (bloc E1)
(scara D) (apartament 31))
CLIPS>
Dup cum se observa comanda (facts) ne spune la sfrit i numrul de fapte pe
care le-a afiat pe display. De asemenea pentru fiecare fapt n parte va fi afiat i
identificatorul de fapt, n cazul nostru acesta fiind f-0. Orice fapt inserat n list are
asociat de ctre CLIPS un identificator unic care ncepe cu litera f i este urmat de un
ntreg numit i index de fapt.
n mod normal, CLIPS-ul nu accept introducerea unui duplicat n lista de fapte
i de aceea ncercarea de asertare a unui fapt identic cu un altul anterior , va duce la
returnarea unui mesaj de eroare.
CLIPS>(assert (adresa (nume-strada Alexandru cel Bun 47) (bloc E1)
FALSE
CLIPS>(assert (adresa (nume-strada Alexandru cel Bun 47) (bloc E1)
<Fact-1>
CLIPS>
Tot aa cum un fapt poate fi asertat n lista de fapte, tot aa poate fi i ters.
Operaia de tergere a unui fapt se mai numete i retractare i se realizeaz cu comanda
(retract) a crei sintaxa este urmtoarea:
(retract <fact-index>+)
Dup cum se vede avem posibilitatea de a terge unul sau mai multe fapte din
list. ncercarea de a terge un fapt care nu exist sau care a fost ters anterior duce de
asemenea la afiarea unui mesaj de eroare. Comanda (retract) nu returneaz nici o
valoare.
CLIPS> (retract 0)
LIPS> (retract 1)
CLIPS> (retract 1)
[PRNTUTIL1] Unable to find fact f-1
CLIPS>
Pentru a terge faptele f-0 i f-1 din list amndou o dat se putea folosi
comanda retact i astfel:
(retract 0 1)

38
n CLIPS mai exist i comanda (clear) al crei efect este acela de tergere a
tuturor faptelor din list, indexul de fapt ncepnd dup aceasta din nou cu valoarea 0.
CLIPS> (clear)
LIPS> (assert (a) (b) (c) (d))
<Fact-3>
CLIPS>(facts 1 3 2)
f-1 (b)
f-2 (c)
CLIPS>(assert (d))
FALSE
LIPS>(retract 0 2 3)
CLIPS> (assert (d))
Fact-4> ;indexul de fapt este incrementat de unde a rmas
LIPS> (facts 0)
-1 (b)
-4 (d)
or a total of 2 facts.
LIPS> (retract 5 1)
PRNTUTIL1] Unable to find fact f-5
LIPS>(assert ( e ))
Fact-5>
LIPS>(facts) ;se observ c f-1 a fost ters mai sus !!!
-4 (d)
-5 (e)
LIPS> (retract *)
LIPS> (facts)
LIPS> (assert ( numar (+ 3 5)))
Fact-6>
LIPS> (facts)
-6 (numar 8)
Putem observa din exemplul de mai sus c dei faptul (d) a fost ters i apoi
reintrodus, indexul de fapt a fost incrementat n continuare. CLIPS-ul nu se ocup de o
reactualizare a indexului faptelor din list, ceea ce face ca un fapt s aib ntotdeauna
acelai index din momentul asertrii sale n list, pn n momentul tergerii sale. Se
mai observ de asemenea c la asertarea faptului (e) spaiile sunt ignorate i c efectul
comenzii (retract 5 1) este acela de a ne ateniona c faptul cu indexul 5 nu exist, fr
ns a se opri de la tergerea faptului cu indexul 1. Efectul comenzii (retract *) este
asemntor cu cel al comenzii (clear) , singura excepie fiind indexul de fapte care nu
este resetat pe valoarea 0, ci i continu incrementarea de la valoarea rmas. La
asertarea faptului numar CLIPS-ul va realiza automat operaia de adunare astfel nct
atunci cnd se va da comanda (facts) vom avea n list faptul (numar 7). Se va vedea c
tergerea faptelor, duce i la tergerea regulilor aprinse de acele fapte din agend.

39
4.3.7. Modificarea i duplicarea faptelor
Pentru modificarea sloturilor unui fapt avem la dispoziie comanda modify a
crei sintaxa este urmtoarea:
(modify <fact-index> <slolt-modifier>+)
unde <slot-modifier> este:
(<slot-name> <slot-value>)
Dup cum se observ avem posibilitatea modificrii mai multor sloturi deodat.
Aceast comand practic terge faptul pe care dorim s-l modificm i introduce un nou
fapt care are valorile sloturilor modificate de utilizator. Odat asertat noul fapt modificat
are n mod evident i un alt index de fapt. Trebuie reinut faptul c nu se poate modifica
dect un singur fapt, iar acesta trebuie s fie de tip template, adic s conin sloturi (un
fapt ordonat nu conine sloturi i deci nu poate fi modificat). Valoarea returnat de
aceast funcie n caz de succes este adresa faptului nou, iar n caz de eroare (de
exemplu exista deja un fapt identic cu cel modificat, sau faptul cu numrul de index
specificat nu exist n lista de fapte) se returneaz simbolul FALSE.
CLIPS> (deftemplate student (multislot nume) (slot nr_grupa) (slot an) )
CLIPS> (assert (student (nume Husleag Dumitru) (nr_grupa 1406) (an IV) )
(student (nume Colotin Florin) (nr_grupa 1305) (an III) ) )
<Fact-1>
CLIPS> (modify 1 (nr_grupa 1406) (an IV) )
<Facts-2>
CLIPS> (facts)
f-0 (student (nume Husleag Dumitru) (nr_grupa 1406) (an IV))
f-2 (student (nume Colotin Florin) (nr_grupa 1406) (an IV))
CLIPS> (modify 1 (nume Violeta Diaconu))
[PRNTUTIL 1] Unable to find fact f-1
CLIPS> (modify 2 (nume Husleag Dumitru))
FALSE
CLIPS> (facts)
Se observ faptul c se obin dou erori, prima deoarece nu exista n list un fapt
cu numrul de index f-1, a doua deoarece faptul modificat nu este acceptat de CLIPS
fiind identic cu un alt fapt f-0 deja existent. Funcia modify a returnat simbolul FALSE,
dar faptul f-2 ce se dorea a fi modificat a fost deja retractat. La a doua eroare practic s-a
pierdut o nregistrare din lista de fapte i de aceea se recomand a se verifica mai nti
dac nu exista deja faptul ce se dorete a fi introdus.
Comanda duplicate ofer posibilitatea utilizatorului de a realiza o copie
modificat a unui fapt din lista de fapte (nu se poate realiza o copie identic, deoarece
CLIPS-ul nu accept acest lucru). Aciunea acestei comenzi este aproape similar cu cea
a comenzii modify, cu excepia faptului c de aceast dat nu este retractat faptul ce se
modific, n lista de fapte existnd att vechiul fapt ct i faptul nou modificat. Sintaxa
comenzii duplicate este:
(duplicate <fact-index> <slolt-modifier>+)
unde <slot-modifier> este:
(<slot-name> <slot-value>)

40
De asemenea nu putem duplica dect un singur fapt, iar n cadrul acestuia putem
modifica valorile cmpurilor unui slot sau a mai multor sloturi. Funcia returneaz ca i
funcia modify n caz de succes adresa de fapt, a noului fapt duplicat, iar n caz de eroare
simbolul FALSE.
CLIPS> (duplicate 0 (an II) (nr_grupa 1207))
<Fact-3>
CLIPS> (facts)
f-3 (student (nume Husleag Dumitru) (nr_grupa 1207) (an II))
CLIPS> (duplicate 0 (an II) (nr_grupa 1207)
FALSE
CLIPS> (duplicate 1 (an I))
[PRNTUTIL 1] Unable to find fact f-1
CLIPS> (facts)
f-3 (student (nume Husleag Dumitru) (nr_grupa 1207) (an II))
i de aceast dat s-a urmrit realizarea unor greeli similare cu cele fcute la
funcia modify , dar dup cum era de ateptat nu s-a mai pierdut informaie, deoarece
funcia duplicate nu retracteaz faptul ce se dorete a fi duplicat.

4.3.8. Comanda watch
CLIPS ofer o serie de comenzi pentru depanarea unui program. Cu ajutorul
comenzii watch se pot urmri mai uor faptele care sunt asertate sau retractate, fiind mai
uor de observat, ce schimbri se produc n lista de fapte. Sintaxa general a comenzii
este:
(watch <watch-item>)
unde <watch-item> poate fi unul din simbolurile: facts, rules, activations, statistics,
complilations, focus sau all .
Dac se folosete cuvntul all atunci se valideaz toate watch-urile. Se pot realiza orice
combinaii de watch-uri. La startarea CLIPS-ului este activat doar watch compilations,
toate celelalte nefiind active. Se poate observa acest lucru la ncrcarea i compilarea
unui program. n momentul de faa prezint interes doar watch facts. Cu ajutorul
acestei comenzi putem urmri faptele dup cum urmeaz :
CLIPS> (clear)
CLIPS> (assert (a) (b))
==> f-0 (a)
==> f-1 (b)
<Fact-1>
CLIPS> (deftemplate copil (slot nume) (slot tata) (slot mama))
CLIPS> (assert (copil (nume Ion) (tata Vasile) (mama Ana)))
==> f-2 (copil (nume Ion) (tata Vasile) (mama Ana))
<Fact-2>
CLIPS> (modify 2 (nume Oana))
<== f-2 (copil (nume Ion) (tata Vasile) (mama Ana))
==> f-3 (copil (nume Oana) (tata Vasile) (mama Ana))

41
<Fact-3>
CLIPS> (retract 3 1)
<== f-3 (copil (nume Oana) (tata Vasile) (mama Ana))
<== f-1 (b)
Secvena de caractere ==> ne arat c faptul a fost asertat, intrnd n lista de
fapte; pe cnd secvena de caractere <== ne arat c faptul a fost retractat. Comanda
(watch facts) ne arat lista de fapte ntr-un mod dinamic, utilizatorul poate observa ce
fapte intr i ce fapte ies din list. Comanda (facts) ns ne prezint ntr-un mod static
lista de fapte.
Pentru a opri efectul unui watch se folosete comanda unwatch. Sintaxa
comenzii unwatch este urmtoarea:
(unwatch <watch-item>)
Evident c pentru a dezactiva urmrirea faptelor trebuie s dm comanda
(unwatch facts).
Dup constructorii deftemplate i deffacts n programul prezentat ca exemplu
(d1.clp) urmeaz definirea regulilor.

4.3.9. Definirea regulilor
Una din metodele primare de reprezentare a cunoaterii n CLIPS este regula. O
regul este o colecie de condiii i de aciuni ce urmeaz a fi executate dac condiiile
sunt ndeplinite. Un sistem expert trebuie s aib att reguli, ct i fapte. Regulile
executate sau aprinse se bazeaz pe existena sau non-existena unor fapte sau instane
ale unei clase definite de utilizator. Mecanismul (motorul de inferen) al CLIPS-ului
ateapt potrivirea regulilor cu starea curent a sistemului (reprezentat de lista de fapte
i lista de instane) i apoi aplic aciunile.
Regulile pot fi scrise direct n CLIPS sau pot fi ncrcate dintr-un fiier cu reguli,
creat cu un editor. Se poate folosi n acest scop editorul ncorporat al CLIPS-ului sau
oricare alt editor. Fa de introducerea direct n top level a regulilor sau comenzilor,
folosirea unui editor aduce posibilitatea corectrii eventualelor erori, fr a mai fi
necesar rescrierea din nou a regulii. Ne putem imagina cazul n care un calculator ce
are introduse deja faptele i regulile, avertizeaz operatorul ca n acea zi se dau salariile.
Pseudocodul ar fi:
IF ziua curenta este 31
HEN rspunsul este caseria trebuie s distribuie salariile
Presupunem din exemplul anterior ca fiind deja asertat faptul data. n acest caz
regula noastr ar putea arta astfel:
(defrule actiunea_zilei Comentariu
(data (zi 31))
=>
(assert (actiune caseria da banii) ) )
Dac s-a introdus corect regula i nu s-a omis nici o parantez, atunci prompter-
ul CLIPS> va reapare. n caz contrar va apare un mesaj de eroare n care se indic
cuvntul cheie greit sau amplasarea greit a parantezelor. Sintaxa comenzii defrule
este:
(defrule <rule-name> [<comment>]
[<declaration>] ; Rule Properties
<conditional-element>* ; Left-Hand Side (LHS)

42
=>
<action>* ) ; Right-Hand Side (RHS)
Redefinirea unei reguli deja existente, face ca regula anterioar cu acelai nume
s fie tears, chiar dac regula actual nou introdus are erori. Dup cum se observ
dup numele regulii care poate fi orice simbol valid, dup comentariu opional care
trebuie cuprins ntre ghilimele (comentariile pot fi introduse i dup punct i virgula ;)
urmeaz zero sau mai multe condiii (pattern-uri) i apoi zero sau mai multe aciuni.
Practic o regul este format din dou pri LHS i RHS separate de secvena de
caractere ( => ) pe care o putem numi i sgeat, format dintr-un semn egal i un
semn mai mare dect . n comparaia regulii cu un IF-THEN sgeata marcheaz
nceputul prii THEN. Partea stng LHS este format din zero sau mai multe elemente
condiionale ( CE ) , care sunt legate ntre ele de un and implicit. RHS-ul este format
dintr-o list de aciuni care sunt executate dac i numai dac toate elementele
condiionale (pattern-urile) sunt satisfcute. Nu exist nici o limit pentru numrul de
condiii sau de reguli dintr-o regul, singura limitare o constituie memoria actual
valabil. CLIPS-ul ateapt ndeplinirea pattern-urilor unei reguli verificnd faptele din
lista de fapte. Atunci cnd toate pattern-urile se potrivesc cu faptele, regula este activat
i este pus n agenda. Agenda reprezint n CLIPS o colecie de reguli activate. n
agend pot fi zero sau mai multe fapte, retractarea unui fapt din lista de fapte putnd
duce la stingerea unor reguli i scoaterea lor automat din agend. Dac avem mai multe
reguli care se pot aprinde CLIPS-ul este cel care hotrte care din reguli este cea mai
apropiat i le ordoneaz pe toate n agend (CLIPS-ul ine cont i de prioritatea pe care
a oferit-o eventual utilizatorul regulii, numit i salience).
Dac o regul nu are nici o condiie n LHS, atunci CLIPS-ul va aduga automat
pattern-ul special initial-fact. Orice regul care nu are condiii se va aprinde automat i
va fi plasat n agend, dup ce va fi dat comanda reset i faptul initial-fact va fi
introdus n lista de fapte. Se poate ntmpla de asemenea ca o regul s nu aib nici o
aciune n RHS. Acest lucru nu este prea util, dar e bine de tiut c este posibil
realizarea unei astfel de reguli.
Lansarea n execuie n CLIPS a unui program se face cu ajutorul comenzii run a
crei sintaxa este urmtoarea :
( run [ <limit> ] )
unde argumentul opional <limit> este un numr ntreg, ce specific numrul maxim de
reguli ce vor fi aprinse. Dac acest argument nu apare, atunci el are implicit valoarea 1
i toate regulile vor fi aprinse pn ce nu va mai rmne nici una n agend. n caz
contrar execuia regulilor va nceta dup ce un numr de <limit> reguli au fost aprinse.
Urmtoarea comanda run va continua execuia din locul de unde s-a oprit, astfel nct
comanda (run 1) ar fi echivalentul unei rulri pas cu pas a programului.
Trebuie reinut faptul c o regul o dat aprins, nu mai poate fi activat de
obicei din nou. Este necesar ori remprosptarea ei cu ajutorul comenzii refresh, ori
apelarea comenzii reset, care terge toate faptele i reintroduce baza iniial de fapte din
construciile deffacts de la care s-a plecat. Odat refcut baza iniial de cunoatere se
poate da din nou comanda run .
Alte exemple de reguli ar putea fi:
(defrule bariera_coborita
tren_apropiat da)
=>
actiune Coboara bariera.)

43
(defrule bariera_ridicata
tren_apropiat nu)
=>
actiune Ridica bariera.)

4.3.10. Afiarea agendei
Agenda este o colecie de reguli activate, iar aceast list poate fi afiat cu
ajutorul comenzii agenda a crei sintaxa este urmtoarea:
(agenda)
Dac nu avem nici o regul activat, atunci prompter-ul CLIPS-ului va apare
imediat. Dac n schimb avem una sau mai multe reguli n agend, atunci acestea vor fi
afiate n felul urmtor. Mai nti este afiat un numr ce indic prioritatea regulii,
aceasta avnd n mod implicit valoarea 0, dac utilizatorul nu a asociat o prioritate
regulii respective. Dup prioritate (salience) este afiat numele regulii urmat de
identificatorii de fapt ce s-au potrivit cu pattern-urile (condiiile) regulii.
n exemplul urmtor presupunem deja introduse construcia deffacts date-initiale
i regula actiunea_zilei.
CLIPS> (defrule find_person Die or life
(angajat (nume Cozma George))
=>
(assert (mesaj Exista un angajat cu acest nume.) ) )
LIPS> (agenda)
0 find_person: f-1
0 actiunea_zilei: f-4
For a total of 2 activations.
CLIPS> (run 1)
==> f-5 (mesaj Exista un angajat cu acest nume.)
CLIPS>(agenda)
For a total of 1 activation.
CLIPS> (run 1)
==> f-6 (actiune caseria da banii)
CLIPS> (agenda)
CLIPS>
n exemplul nostru la aprinderea unei reguli, se aserteaz n lista de fapte un fapt
nou ce specific o aciune sau un mesaj. Dup cum se observ fiecare regul aprins
este scoas din agend, astfel nct la un moment dat nu se mai gsete nici o regul
activat n agend. Din acest moment comanda run nu mai are nici un efect. n CLIPS o
regul nu se aprinde mai mult de o singur dat pentru un anumit set de fapte, aceast
proprietate purtnd i numele de refracie. Fr aceast proprietate un sistem expert s-ar
afla ntotdeauna ntr-o bucl infinit, fiecare regul fiind din nou i din nou aprins de
acelai fapt. Pentru a reaprinde regula, este necesar retractarea faptului ce a aprins-o
(dac sunt mai multe fapte, se alege unul la ntmplare) i apoi asertarea acestuia din
nou. Noul fapt va avea un nou identificator de fapt, iar regula va putea fi aprins din
nou. Alt posibilitate este folosirea comenzii refresh a crei sintaxa este urmtoarea:
(refresh <rule-name>)

44
Comanda refresh pune napoi n agend toate activrile regulii, ce au fost deja aprinse
(singura restricie este ca n lista de fapte s fie nc prezent faptul ce a dus la activarea
acesteia).
CLIPS> (modify 1 (salariu 1700000))
<== f-1 (angajat (nume Cozma George) (salariu 1500000) )
==> f-7 (angajat (nume Cozma George) (salariu 1700000) )
<Fact-7>
CLIPS> (agenda)
0 find_person: f-7
For a total of 1 activation.
CLIPS> (refresh actiunea_zilei)
CLIPS> (agenda)
0 find_person: f-7
For a total of 2 activations.
CLIPS> (unwatch facts)
CLIPS> (retract 4 7)
CLIPS> (agenda)
CLIPS> (assert (angajat (nume George Cozma) ) )
CLIPS> (refresh actiunea_zilei)
CLIPS> (agenda)
CLIPS>
Se observ faptul ca la ultima asertare s-au inversat n mod intenionat numele
cu prenumele, din acest motiv CLIPS-ul vede cele dou fapte ca fiind distincte, iar
regula nu se mai aprinde. Dac la asertarea unui fapt se omite asocierea unei valori unui
slot, atunci CLIPS-ul va asocia implicit simbolul nil acelui slot. Ultimul refresh nu are
nici un efect deoarece faptul care a aprins regula a fost retractat.

4.3.11. Urmrirea activrilor, regulilor i a statisticilor
La fel cum se putea urmri ntr-un mod dinamic asertarea i retractarea faptelor,
tot aa cu ajutorul comenzii watch pot fi urmrite i activrile. Efectul este aproape
similar cu cel al comenzii agenda putndu-se observa faptele din agend care sunt
activate, sau care sunt dezactivate de retractarea sau modificarea vreunui fapt. n mod
similar secvena de caractere <== specific tergerea unei activri din agend, iar
secvena de caractere ==> adugarea unei activri la agend. Se d urmtorul exemplu
n continuarea celui anterior:
CLIPS> (watch activations)
CLIPS> (reset)
==> Activation 0 find_person: f-1
==> Activation 0 actiunea_zilei: f-4
CLIPS> (retract 1)
<== Activation 0 find_person: f-1
CLIPS> (run)
CLIPS> (unwatch activations)
CLIPS> (agenda)
CLIPS>

45
Se observ c faptul watch activations nu afieaz nici un mesaj atunci cnd o
regul este aprins (executat) dup ce a fost dat comanda run ,dei aceasta a fost
tears din agend n momentul aprinderii sale.
Dac se urmresc regulile atunci se va afia un mesaj de fiecare dat cnd o
regul este aprins.
CLIPS> (reset)
CLIPS> (watch rules)
CLIPS> (run)
FIRE 1 actiunea_zilei: f-4
FIRE 2 find_person: f-1
CLIPS>(unwatch rules)
CLIPS>
Numrul aflat dup simbolul FIRE indic ct de multe reguli s-au aprins dup ce
a fost dat comanda run. Dac se urmresc statisticile vor fi afiate pe ecran o serie de
mesaje informaionale dup cum se va vedea:
CLIPS> (reset)
CLIPS> (watch statistics)
CLIPS> (run)
2 rules fired Run time is 0.054 seconds.
36.4 rules per second.
6 mean number of facts (7 maximum)
1 mean number of instances (1 maximum)
2 mean number of activations (2 maximum)
CLIPS> (unwatch statistics)
CLIPS>

4.3.12. Afiarea listei membrilor unei construcii specificate
Pentru afiarea listei regulilor aflate la un moment dat n CLIPS se utilizeaz
comanda list-defrules. De asemenea comenzile list-deftemplates i list-deffacts sunt
utilizate pentru afiarea construciilor deftemplate, respectiv a construciilor deffacts.
Sintaxa acestor comenzi este urmtoarea:
(list-defrules)
(list-deftemplates)
(list-deffacts)
CLIPS> (list-deffacts)
initial-fact
date-initiale
For a total of 2 deffacts.

4.3.13. Afiarea textului membrilor unei construcii specificate
Ca i mai sus avem la dispoziie trei comenzi ppdefrule (pretty print defrule),
ppdeftemplate i ppdeffacts utilizate la afiarea textului (coninutului) unei construcii
defrule, deftemplate sau deffacts. Sintaxa acestor comenzi este urmtoarea:

(ppdefrule <defrule-name>)
(ppdeftemplate <deftemplate-name>)
(ppdeffacts <deffacts-name>)

46
Singurul argument pe care l accept aceste funcii este numele construciei
defrule, deftemplate sau deffacts. CLIPS-ul realizeaz afiarea ntr-o manier proprie de
aranjare a liniilor i spaiilor, astfel nct textul s fie ct mai uor de citit. De exemplu:
CLIPS> (ppdefrule actiunea_zilei)
(defrule MAIN::actiunea_zilei Comentariu
(data (zi 31))
=>
(assert (actiune caseria da banii)))
CLIPS>(ppdeftemplate data)
(deftemplate MAIN::data
(slot zi)
(slot luna)
(slot an)))
CLIPS>(ppdeffacts date-initiale)
(deffacts MAIN::date-initiale Baza de salarizare
(angajat (nume Cozma George) (salariu 1500000) )
(angajat (nume Miron Liliana) (salariu 1650000) )
(angajat (nume Mazilu Razvan) (salariu 1580000) )
(data (zi 31) (luna 9 ) (an 1991)))
CLIPS> (ppdeffacts initial-fact)
CLIPS>
Simbolul MAIN:: care precede fiecare construcie, indic modulul n care au fost
amplasate. Modulele sunt un mecanism de partiionare a bazei de cunoatere,
utilizatorul avnd posibilitatea s grupeze regulile n funcie de aciunile realizate de
acestea i de preferinele sale n module. n cazul de fa nu exist dect modulul
principal i anume modulul MAIN.
Se observ c la ncercarea de afiare a construciei deffacts iniial fact nu se
obine nici un rezultat, aceasta fiind automat realizat de ctre CLIPS.

4.3.14. tergerea membrilor unei construcii specificate
Comenzile undefrule , undeftemplate i undeffacts sunt utilizate pentru
tergerea unei construcii defrule, deftemplate i deffacts. Sintaxa acestora este:
(undefrule <defrule-name>)
(undeftemplate <deftemplate-name>)
(undeffacts <deffacts-name>)
Dup cum se observ comenzile nu accept dect un singur argument, iar acela
este numele construciei ce se dorete a fi tears.
CLIPS> (undefrule actiunea_zilei)
CLIPS> (list-defrule)
find_person
For a total of 1 defrules.
CLIPS> (undeffacts date_initiale)
initial-fact
CLIPS> (undeffacts initial-fact)
CLIPS> (list deffacts)
CLIPS>

47
Se observ faptul c putem terge construciile deffacts initial-fact i deftemplate
initial-fact ca pe oricare alt construcie definit de utilizator. ns dac se va da
comanda reset de aceast dat (initial-fact) nu va mai fi adugat la lista de fapte. n
acest caz dac avem reguli care nu au condiii n LHS, acestea nu se mai aprind i
programul poate funciona incorect. Pentru a reintroduce acest fapt n lista de fapte este
necesar execuia comenzii clear i rencrcarea bazei de cunotine.
Se poate folosi ca i la comanda retract simbolul * ca argument, n acest caz
fiind terse toate construciile de acel tip. De exemplu ( undefrule *) terge toate
construciile de tip defrule.
Trebuie reinut i faptul ca toate construciile ce sunt referite (cerute) de alte
construcii nu pot fi terse. Dup cum se va vedea n urmtorul exemplu construcia
deftemplate initial-fact nu poate fi tears pn cnd construcia deffacts initial-fact nu
este tears. De asemenea va trebui s fie tears i construcia defrule exemplu, care
utilizeaz faptul initial-fact n LHS pattern.
CLIPS> (defrule exemplu
=> ) ;cea mai simpl regul
CLIPS> (undeftemplate initial-fact)
Unable to delete deftemplate initial-fact while
outstanding references to it still exist.
CLIPS> (undeffacts initial-fact)
Unable to delete deftemplate initial-fact while
outstanding references to it still exist.
CLIPS> (undefrule exemplu)
CLIPS>
Dac ar mai fi aprut mesaje de eroare, ar fi nsemnat c nc mai exist
construcii ce utilizeaz initial-fact i n acest caz ar fi trebuit s fie terse fiecare n
parte.

4.3.15. tergerea tuturor construciilor din mediul CLIPS
Comanda clear este cea care terge toat informaia din mediul CLIPS. Sunt
terse toate construciile i toate faptele din lista de fapte. Sintaxa comenzii clear este
urmtoarea :
(clear)
Dup tergerea mediului CLIPS, comanda clear adaug i construcia initial-fact
dup cum urmeaz:
CLIPS> (clear)
CLIPS> (list-deftemplates)
initial-fact
For a total of 1 deftemplates.
Initial-fact
CLIPS>
La sfritul programului se gsete comanda printout.

48
4.3.16. Comanda printout

Comanda printout trimite spre un dispozitiv ataat unui nume logic un ir de
caractere. Numele logic trebuie specificat pentru ca dispozitivul spre care se trimite s
fie pregtit (de exemplu un fiier trebuie deschis mai nti). Pentru a avea ieirea spre
stdout (ieirea standard-n general monitorul) se folosete numele logic t. Sintaxa
comenzii printout este urmtoarea :
( printout <logical-name> <expresion>* )
Aceast comand i dovedete utilitatea atunci cnd este amplasat n RHS-ul regulilor
cu scopul de a se afia mesaje. Orice numr de expresii poate fi amplasat ntr-o
comand printout pentru a fi afiate. Fiecare expresie este evaluat n vederea eliminrii
spaiilor adiionale aflate ntre expresiile ce se doresc a fi printate. Simbolul crlf utilizat
ca o <expresie> poate fi amplasat oriunde n lista de expresii, el fornd carriage return /
new line (salt la nceput de linie nou). Funcia printout i marcheaz irurile pe care le
afieaz ncadrndu-le ntre ghilimele. Pot fi printate de asemenea i adresele de fapt,
adresele de instan i adresele externe. Aceast funcie nu returneaz nici o valoare.
Dispozitivul spre care se trimite poate fi redefinit, astfel nct se pot transmite informaii
spre un modem sau o imprimant.
Urmtoarea regul demonstreaz utilitatea comenzii printout :
(defrule cartela_telefonica
(card yes)
=>
(printout t Puteti forma numrul de telefon crlf) )
n aceasta regul prezena comenzii printout n RHS-ul regulii duce la afiarea
spre terminal (standard output device) a unui ir de caractere. Singurul argument al
funciei este irul:
Puteti forma numrul de telefon
care va fi afiat pe ecran fr ghilimele. Dac s-ar fi dorit trimiterea irului spre un
fiier, ar fi trebuit mai nti deschis fiierul cu funcia open .
S vedem acum cteva din elementele programelor CLIPS.
n CLIPS avem trei elemente primare de scriere a programelor : tipuri primitive
de date, funcii pentru manipularea datelor i constructori pentru adugarea datelor la
baza de cunoatere.

4.3.17. Tipuri de date
n CLIPS exist opt tipuri de date primitive i acestea sunt : float , integer ,
symbol , string , external address , fact address , instance name i instance
address. Informaiile de tip numeric pot fi reprezentate evident de float i integer, iar
informaiile de tip simbolic pot fi reprezentate de symbol i string.
Primele dou tipuri de cmpuri float i integer sunt numite cmpuri numerice
sau numere. Un cmp numeric este alctuit din trei pri : semnul, valoarea, i
exponentul. Semnul este opional i poate fi + sau -. Valoarea conine una sau mai multe
cifre (0-9), un punct opional (.) i din nou una sau mai multe cifre. Exponentul este i
el opional i const n litera e sau E urmata de un + sau opional i de una sau mai
multe cifre. Orice numr format doar din semnul opional i din cifre este considerat a
fi de tip ntreg. Toate celelalte numere sunt de tip float.
Exemple de ntregi : 1 +7 -2 79
Exemple de float: 1.3 3.0 8e-1 6.5E+3

49
n concluzie un ntreg folosete urmtorul format:
<integer> ::= [ +| - ] <digit>+
<digit> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
Un numr n virgul mobil folosete formatul urmtor:
<float> ::= <integer> <exponent> |
<integer> . [exponent] |
. <unsigned integer> [exponent] |
<integer > . <unsigned integer> [exponent]
<exponent> ::= e|E <integer>
<unsigned-integer> ::= <digit>+
Un symbol este un cmp ce ncepe cu un caracter ASCII printabil i este urmat
de unul sau mai multe caractere. Sfritul unui simbol este marcat de un delimitator i
anume : orice caracter ASCII neprintabil ( spaiu , tab, CR Enter, LF Line feeds),
ghilimelele , paranteza deschis ( , paranteza nchis ) , punct i virgul ; ,apsnd & ,
bara verticala | , tilda ~ , caracterul mai mic dect < . Un simbol nu poate conine un
delimitator ( singura excepie este caracterul < care poate fi doar primul caracter din
simbol). De asemenea ? i $? sunt secvene de caractere ce nu pot s apar la nceputul
unui simbol deoarece acestea sunt folosite pentru a marca variabilele. Orice secven de
caractere care nu este un cmp numeric este tratat ca un simbol.
Exemple de simboluri:
data-an viata Mihai nr_prim
!#$%?$? 1234A 091-345-67
Se observ folosirea underscore-ului i a liniuei de unire pentru utilizarea mai
multor simboluri ntr-un singur cmp. CLIPS este case-sensitive i deci face deosebire
ntre literele mari i cele mici, din acest motiv urmtoarele simboluri sunt considerate ca
fiind diferite:
nr-prim Nr-prim NR-PRIM nr-Prim .
Urmtorul tip de cmpuri este string (irul de caractere). Un ir trebuie s nceap i s
se termine cu ghilimele. Trebuie reinut faptul c ghilimelele fac parte din ir i c ntre acestea
pot fi zero sau mai multe caractere inclusiv delimitatorii.
Exemple de iruri :
Introducei caracterele
caractere !@#$%^^&*
Popescu N. Ionescu
Trebuie reinut faptul c irul abcd i simbolul abcd nu sunt unul i acelai
lucru. Dei conin aceleai caractere prezena ghilimelelor face ca acestea s fie tipuri de
date diferite. De obicei spaiul este folosit n CLIPS ca delimitator pentru a separa
cmpurile (mai ales pentru simboluri) i celelalte tokens (grup de caractere cu o
semnificaie special pentru limbaj). Spaiile adiionale utilizate ntre tokens sunt
neglijate. ntr-un ir ns spaiul este considerat ca aparinnd irului, oriunde ar fi
acesta amplasat. Din acest motiv sunt considerate a fi iruri diferite:
spaiu spaiu spaiu .
Fr ghilimele spaiile ar fi ignorate.
Mai trebuie reinut faptul c nu se pot plasa direct ntr-un ir ghilimelele i de exemplu
niruirea de caractere: trei_cmpuri
este interpretat de CLIPS ca fiind trei tokens separate :
trei_cmpuri
.

50
Pentru introducerea ntr-un ir a ghilimelelor este necesar folosirea caracterului
backslash \ . De exemplu : \ un_cmp \
este interpretat de CLIPS ca fiind cmpul: un_cmp .
De aceast dat a fost creat un singur cmp deoarece folosirea caracterului
backslash mpiedica interpretarea ghilimelelor ca fiind delimitatori. Introducerea unui
caracter backslash ntr-un ir presupune folosirea a dou astfel de caractere succesiv.
De exemplu : \\ un_cmp \\
va fi interpretat de CLIPS ca fiind cmpul: \ un_cmp \ .
Celelalte patru tipuri de cmpuri external address , fact address , instance
name i instance address prezint un interes mai mic pentru utilizatorul obinuit.
External address reprezint adresa unei structuri de date externe returnat de un user-
defined function (funcie definit de utilizator scris ntr-un limbaj ca C sau Ada i
legat cu CLIPS-ul pentru a adauga o funcionalitate adiional). Dar valoarea unei
adrese externe nu poate fi specificat ca fiind o secven de caractere ce formeaz un
tokens i nu este posibil crearea unui astfel de cmp de ctre utilizator ntr-o variant
nemodificat a CLIPS-ului. Reprezentarea unei astfel de adrese externe este:
<pointer-XXXXXX> , unde XXXXXX este external
address.
Un fapt este o list de valori atomice i este referit poziional (fapte ordonate - ordered
facts) sau dup nume (fapte neordonate sau ablon non-ordered or template facts).
Referirea unui fapt se face cu ajutorul unui index sau adres. Formatul pentru fact
address este:
<Fact-XXX> , unde XXX este indexul de fapt.
Instance name i instance address sunt cmpuri utilizate n conjuncie cu COOL.
Obiectele n CLIPS sunt definite a fi floats, integers, symbols, strings, multifield
values (valori multicmp), external addresses, fact addresses sau o instan a unei
user-defined class. O clas definit de utilizator este realizat, folosind un constructor
defclass. O instan a unei clase definite de utilizator este creat cu funcia
makeinstance i poate fi referit n mod unic cu ajutorul adresei acesteia. Cteva
exemple de instance name sunt:
[pump-1] [foo] [+++] [123-890]
Parantezele ptrate nu sunt parte component din instan, ele indicnd faptul c
simbolul nchis ntre acestea este o instance-name. O adres de instan poate fi obinut
prin asocierea unei variabile, valorii returnate de funcia instance-address.
Reprezentarea unei instance address este:
<instance-XXX> ,unde XXX este numele instanei.

4.3.18. Funciile
O funcie n CLIPS este un element format din cod executabil cu un nume
specific, care returneaz o valoare util sau are un anumit efect asupra informaiei.
Exist dou tipuri de funcii : user defined functions i system defined functions,
acestea fiind elemente de cod scrise n limbaje externe (cum ar fi C, FORTRAN sau
ADA) i linkeditate cu mediul CLIPS. Funciile definite de sistem sunt acele funcii ce
au fost definite intern de mediul CLIPS-ului, iar funciile definite de utilizator sunt
funcii care au fost definite extern mediului CLIPS-ului.
Constructorul deffunction ajut utilizatorii s defineasc noi funcii direct n
mediul CLIPS-ului utiliznd sintaxa acestuia. Pot fi definite i funcii generice cu
ajutorul constructorilor defgeneric i defmethod. Funciile apelate n CLIPS folosesc o

51
notaie prefix, argumentele unei funcii apar ntotdeauna dup numele funciei. Funcia
apelat ncepe cu o parantez deschis ( , urmat de numele funciei, de argumentele
acesteia (fiecare argument separat de unul sau mai multe spaii) i se termin cu o
parantez nchis ) . Argumentele pot fi tipuri primitive de date, variabile sau chiar
alte funcii apelate de aceasta. De exemplu funciile de adunare + i de multiplicare * :
(+ 1 2)
(* 3 4.5 6)
(+ 3 (* 7 8) 4)
(* 5 (+ (* 2 3 4) 1 2) (* 5 6))
Aceste exemple sunt expresii care apeleaz funciile + i *. Amplasarea
greit a parantezelor duce la modificarea numrului de argumente i de aici la
obinerea unui rezultat greit.

4.3.19. Constructorii
Mai muli constructori de definiie apar n CLIPS: defmodule, defrule, deffacts,
deftemplate, defglobal, deffunction, defclass, definstances, defmessagehandler,
defgeneric i defmethod. Toate construciile n CLIPS sunt cuprinse ntre paranteze,
ncepnd cu o parantez deschis ( i terminndu-se cu o parantez nchis ) .
Aceti constructori se folosesc pentru a adauga o informaie la baza de cunoatere a
CLIPS-ului.
Fa de funciile apelate acetia nu returneaz niciodat o valoare. Se ofer
posibilitatea adugrii unui comentariu la numele construciei (excepie face doar
defglobal). Comentariile pot fi amplasate n CLIPS utiliznd punctul i virgula ;
(semicolon), iar CLIPS-ul va ignora tot ce va gsi dup punct i virgul. Dac avem la
nceput de linie punct i virgul ntreaga linie va fi tratat ca fiind un comentariu. n
momentul n care se va dori lansarea n execuie a unui program CLIPS-ul va ncerca
toate construciile ignornd comentariile.

4.3.20. Faptele
n CLIPS sunt trei forme principale de reprezentare a informaiei : fapte (facts),
obiecte i variabilele globale. Faptele sunt forma principal de reprezentare a
informaiei n sistemul CLIPS. Fiecare fapt reprezint un element de informaie care va
fi plasat n lista de fapte numit factlist. Faptul este forma fundamental de date folosit
de reguli i const ntr-un nume de relaie urmat de zero sau mai multe sloturi
(cmpuri simbolice crora li se pot asocia valori). Forma general a unui fapt va fi
urmtoarea :
fact => ( nume_relaie [ (slot)* ] [ (multislot)* ] )
Parantezele ptrate indica faptul ca existena sloturilor este opional, iar semnul
* arat faptul c putem avea zero sau mai multe sloturi. Se observ faptul c n CLIPS
trebuie s cuprindem ntre paranteze att numele de relaie ct i sloturile. Un slot este la
rndul su format dintr-un nume de slot, cruia i se poate asocia o valoare. Exist ns i
posibilitatea asocierii de mai multe valori i n acest caz spunem ca avem un multislot.
Acest lucru este posibil datorit existenei n CLIPS a multicmpului (multifield) care
este de fapt o secven de zero sau mai multe cmpuri. Afiarea n CLIPS a unei valori
multicmp se va realiza prin nchiderea acestuia ntre paranteze. Trebuie reinut faptul
c o valoare multifield (a) nu este unul i acelai lucru cu o valoare cmp (single field)
(a) .
slot => ( nume_slot valoare )

52
multislot => ( nume_slot [ valoare ]* )
Un slot trebuie s aib obligatoriu asociat o valoare, pe cnd la un multislot
asocierea unei valori nu e obligatorie. Valorea pe care o asociem unui slot poate lua
forma unui tip de dat primitiv (integer, float, symbol, string) .
Exemple de fapte ar putea fi :
(start)
(adresa (nume-strada Alexandru cel Bun)
(numar-strada 47)
(bloc E1)
(scara D)
(apartament 31))
(persoana (nume Ion Vasile)
(culoare-par)
n primul caz faptul (start) nu are nici un slot. n al doilea caz faptul cu numele
de relaie adresa are mai multe sloturi i anume : nume-strada, numar-strada, bloc,
scara, apartament. Se observ faptul c putem asocia unui slot valori de diferite tipuri.
Astfel valoarea slotului nume-strada este un ir de caractere, valorile sloturilor numar-
strada i apartament sunt ntregi, iar valorile sloturilor bloc i scara sunt simboluri. n
ultimul caz, pentru faptul persoana, att slotul nume, ct i slotul culoare-par sunt
multisloturi (au asociate dou i respectiv zero valori).
Trebuie reinut faptul c n CLIPS nu are nici o importan ordinea apariiei
sloturilor i de aceea urmtoarele dou fapte sunt vzute ca fiind identice dei au
schimbat ordinea a dou sloturi :
(student (nume Pascal B. Mihaita)
(nr_grupa 1407)
(an IV))
(student (nr_grupa 1407)
(nume Pascal B. Mihaita)
(an IV)) .

53

CAPITOLUL 5

REELE NEURALE

5.1. Modelul general al unei reele neuronale

n cadrul inteligenei artificiale problemele de nvare ocup un loc aparte.
Aceste preocupri se constituie ntr-o direcie distinct de cercetare, cea a mainilor
autoinstruibile (machine learning).
nvarea automat reprezint studiul modelelor de sisteme capabile s-i
mbunteasc performanele n mod semnificativ, utiliznd o mulime de date de
instruire.
O reea neural const dintr-o mulime de elemente de prelucrare (neuroni,
elemente cognitive sau noduri ale reelei) nalt interconectate.
Considerm o reea de p neuroni conectai prin ponderi de conexiune sau
ponderi sinaptice.
Un neuron i are n
i
intrri i o ieire y
i
. Reprezentarea grafic a acestui neuron
este prezentat n figura urmtoare:

Intrrile sunt notate:

x
1
i
, x
2
i
, ..., x
n
i

acest neuron are i ponderi sinaptice, cte una pentru fiecare intrare.
Ponderile sunt notate:

w
1
i
, w
2
i
, ..., w
n
i

dac w
j
i
> 0 avem o pondere sinaptic excitatoare
dac w
j
i
< 0 avem o pondere sinaptic inhibitoare
=
j
j j
x w s
y=f(s)
w
n
w
1
w
2
t
y
x
1
x
2
x
n

54
Pentru simplitate se suprim indicile i.
Starea intern sau activarea (excitaia) neuronului se exprim cu relaia:

n modelul McCulloch-Pitts fiecare neuron este caracterizat de un prag de
excitare t. Ieirea y este unu dac s t.
Definim funcia rspuns f:R R

Ieirea se scrie:

Pentru eliminarea valorii de prag t se introduce o intrare cu valoarea 1
permanent i ponderat:

x
n+1
=1
w
n+1
=t

rezult activitatea total a neuronului:

relaie care poate fi pus i sub form matriceal.
Ieirea se scrie:

y=f(s)

Avantajul acestei abordri: pragul poate fi ajustat mpreun cu celelalte ponderi.
Forma funciei de rspuns f depinde de modelul de reea neuronal studiat.
Funcia f se mai numete funcie neural, funcie de ieire sau funcie de activare
a neuronului.
Principalele tipuri de funcii neurale sunt:
1. Funcia prag

=
=
n
j
j j
x w s
1
<
=
0 0
0 1
) (
x daca
x daca
x f
|
|
.
|
\
|
+ =

=
n
j
j j
t x w f y
1
+
=
=
1
1
'
n
j
j j
x w s
<
=
0 0
0 1
) (
x daca
x daca
x f

55
2. Funcia signum

3. Funcia prag liniar f : R [0, 1]

4. Funcia sigmoidal (var 1)

5. Funcia sigmoidal (var 2)

5.2. Ecuaia de evoluie a reelei

Considerm o reea format din n neuroni.
Vectorul de stare al reelei este vectorul ale crui componente sunt strile
neuronilor reelei. Notm acest vector cu X.
Admind un model de activare aditiv, activarea total a neuronului i este:
unde w
ij
reprezint ponderea conexiunilor neuronilor i i j.
Considerm toi neuronii reelei conectai ntre ei:

<

=
0 1
0 1
) (
x daca
x daca
x f
0
1
1
) ( >
+
=

k
e
x f
kx
0 ) ( >
+
k
e e
e e
x f
kx kx
kx kx
+
=
=
1
1
n
j
j ij
x w s
|
|
|
|
|
.
|
\
|
=
n i
i
i
i
w
w
w
V
,
2 ,
1 ,
...

56
i=1, 2, ..., n

reprezint vectorul pondere asociat neuronului i i conine toate ponderile spre
neuronul i.
Activarea neuronului se scrie:

S = V
iT
X

Dac se noteaz:

matricea de conexiune a reelei, rezult vectorul total de activare a reelei:

S=WX

Pentru studiul dinamicii reelei introducem parametrul timp.
Ecuaia de evoluie va fi:

X(t+1) = F(W X(t))

5.3. Paradigme ale instruirii

Considerm modelul de reea neural prezentat n figura urmtoare:

n aceast figur x
k
reprezint vectorul de intrare iar y
k
vectorul de ieire.
Se presupune c o secven de intrare definind o form (pattern) sau o
configuraie este prezentat reelei sub forma unui vector. Mulimea acestor vectori
reprezint spaiul vectorilor de intrare.
Reelele neurale transform o anumit configuraie de intrare ntr-o configuraie
de ieire. Ieirile reelei pot corespunde unei aciuni pe care reeaua trebuie s-o
realizeze. Aceasta poate fi, de exemplu, o problem de control. De asemenea, ieirile
reelei pot reprezenta o clasificare a obiectelor prezentate la intrare. n general, ieirea
|
|
|
|
|
.
|
\
|
=
n
V
V
V
W
...
2
1
I
1
I
2
I
n
O
1
O
2
O
n
x
k
1
x
k
2
x
k
n
yk
1
yk
2
yk
m

57
poate fi orice transformare a spaiunui de intrare, deci funcionarea reelei reprezint o
aplicaie (proiecie, transformare) a spaiului vectorilor de intrare n spaiul vectorilor de
ieire.
Prin instruire sau nvare vom nelege o metod prin care este construit o
astfel de aplicaie. n mod obinuit nstruirea presupune c se furnizeaz reelei suficient
de multe exemple de perechi intrare-ieire. Folosind aceste exemple reeaua este forat
s se adapteze n sensul generalizrii unei aplicaii de intrare-ieire. Aceast aplicaie i
va permite reelei s trateze corect i valori de intrare care ni i-au mai fost prezentate
niciodat.

Liste de asociere.

Considerm vectorii:

R = (x
1
x
2
... x
m
)
T
form (vectorul de intrare n reea)
S = (s
1
s
2
... s
n
)
T
forma asociat

O asociere este o pereche ordonat (R,S), unde R este forma cheie iar S este
forma asociat.
Numim list de asociere pe lungime p sau mulime de instruire o mulime LA de
p asocieri:

LA = {(R
1
,S
1
), ..., (R
p
,S
p
)} p1

unde toate formele cheie au aceeai dimensiune:

dim R
j
= m j = 1,2, ..., p

Se admite c i toate formele asociate au aceeai dimensiune:

dim S
j
= n j = 1,2, ..., p

5.4. Topologia multistrat a reelelor neurale

Neuronii pot fi conectai n diferite moduri pentru a forma o reea neural. Un
model uzual de topologie consider neuronii organizai n mai multe straturi. O reea
nural multistrat conine dou sau mai multe straturi de neuroni. Primul strat primete
intrrile din mediu. Ieirile neuronilor din acest strat constituie intrri pentru neuronii
stratului urmtor. Ieirea reelei este format din ieirile neuronilor de pe ultimul strat.
Straturile situate ntre primul i ultimul nivel sunt straturi ascunse ale reelei.

58

CAPITOLUL 6

MULIMI NUANATE

6.1. Noiunea de mulime nuanat

Noiunea de mulime nuanat a fost introdus de L. Zadeh ca mijloc de
reprezentare i utilizare a datelor care care nu sunt precise ci mai degrab vagi (fuzzy)
L. A. Zadeh, Fuzzy Sets, Information and Control, 8 (1965) 338-353. Aa cum s-a artat
pn acum, n logica bivalent se opereaz cu dou valori de adevr: adevrat i fals.
Acest lucru reprezint o problem serioas n modelarea lumii reale n care foarte multe
dintre noiuni au un caracter subiectiv raportat la un anumit observator. Utilizarea
logicilor polivalente i a mulimilor nuanate (vagi) permite obinerea unor rezultate
superioare, de multe ori surprinztoare. Trebuie precizat faptul c utilizarea mulimilor
nuanate este recomandat n special n domenii ale cunoaterii unde nu sunt elaborate
legi matematice precise i deci fenomenele nu sunt stpnite deplin. O mulime nuanat
reprezint n esen valorile de adevr asociate unei noiuni i care ntre valorile extreme
de fals i adevrat poate avea o infinitate de valori intermediare. Prezentm n
continuare elementele de baz ale teoriei mulimilor nuanate.
Fie X o mulime nevid. O mulime nuanat (fuzzy) este perechea (X, A) unde:

A:X [0, 1]

X este universul mulimii nuanate
A este funcia de apartenen a mulimii nuanate

Observaie: dac A(x) =1 atunci cu certitudine x este un element din A. ntre
neapartenena total i apartenena total exist o infinitate de situaii intermediare. Cele
dou situaii extreme pot fi asociate cu valorile de adevr adevrat respectiv fals.

Pentru simplitate vom identifica mulimea nuanat cu funcia ei de apartenen.
Vom spune deci c A este o mulime nuanat peste universul X.
Prezentm n continuare vor fi prezentate cteva exemple de definire a
mulimilor nuanate.

Exemplul 1.

Considerm universul X format din trei elemente:

59

X = {x
1
, x
2
, x
3
}

i o mulime nuanat A peste X, ale crei grade de apartenen sunt date de formula:

3 , 2 , 1 i ,
2 i
1
) x ( A
i
=
+
=

Exemplul 2.

Fie universul:

X = {x
1
, x
2
, x
3
}

Gradele de apartenen ale mulimii nuanate A sunt indicate prin valorile numerice:

A(x
1
)=0,7; A(x
2
)=0,5; A(x
3
)=0,9

Exemplul 3.

Fie:

X=R

Definim peste X mulimea nuanat a temperaturilor de aproximativ 10
o
C. Mulimea A
se poate reprezenta ca n figura urmtoare. Aceast reprezentare poate fi considerat
satisfctoare pentru o anumit problem particular.

Continum prezentarea elementelor de baz ale teoriei mulimilor nuanate.
Fie A o mulime nuanat peste X. Suportul mulimii nuanate A, notat supp A,
este mulimea clasic definit prin:

Supp A = { x X | A(x) > 0}

Egalitatea mulimilor nuanate:

A = B A(x) = B(x), x X

A(t)
1
t (
o
C)
5 10 15

60
Mulimea nuanat A este inclus n mulimea nuanat B i notm A B dac
i numai dac:

A(x) B(x), x X

Complementara A a unei mulimi nuanate este:

A = 1 A(x), x X

Mulimea vid:

(x) = 0, x X

Complementara mulimii vide :

X(x) =1

Principiul Modus-Ponens generalizat:

X este A
*
Premiz
Dac x este A atunci y este B Implicaie
----------------------------------------------------------
Y este B
*
Concluzie

Dac n principiul Modus-Ponens prezentat mai sus se introduce A ca predicat se
obine regula clasic.

6.2. Sisteme expert bazate pe mulimi nuanate

Una din aplicaiile importante ale mulimilor nuanate este realizarea sistemelor
expert. Aa cum s-a artat n capitolul 4 unul din aspectele cele mai importante legate de
sistemele expert este legat de modul de prelucrare a informaiilor aflate n baza de date a
sistemului. Avnd n vedere faptul c mulimile nuanate permit o reprezentare mai
flexibil a realitii, mainile de inferen bazate pe aceast tehnic permit obinerea
unor rezultate foarte bune. Schema bloc a unui astfel de sistem expert este prezentat n
figura 6.1.
Intrrile n maina de inferen sufer procesul de nuanare care permite
definirea universului mulimii nuanate i gradul de apartenen pentru mrimea de
intrare.
Regulile de evaluare sunt de genul:

Dac IN1 este ... i IN2 este ... atunci OUT1 este ...

unde IN1 i IN2 sunt elemente ale universului mulimilor nuanate de intrare iar OUT1
este un element al universului mulimii nuanate de ieire.
Obinerea mrimii de ieire a sistemului expert se face prin denuanarea mulimii
nuanate de ieire. Metoda clasic de denuanare este metoda centrului de greutate sau a
centroidei:

61

( )

=
x toti
x toti
x A
x x A
centroida
) (
) (

Funciile de
apartenen a
mrimilor de
intrare

Reguli
Funciile de
apartenen a
mrimilor de ieire
Nuanare
(fuzificare)
- universul
mulimii nuanate-
Evaluarea regulilor
Denuanare
(defuzificare)
intrri
fuzzy
ieiri
fuzzy
Intrri
Ieiri
Baza de cunotine
a sistemului expert
Maina de
inferen nuanat
Figura 6.1. Sistem expert realizat cu ajutorul mulimilor nuanate

62

CAPITOLUL 7

ALGORITMI GENETICI

7.1. Generaliti

Algoritmii genetici reprezint o familie de modele computaionale inspirate de
teoria evoluiei. Aceti algoritmi codific soluiile posibile ale unor probleme specifice
ntr-o structur de date de tip cromozom i aplic acestor structuri operatori de
recombinare, pentru a pstra informaia util.
Implementarea unui algoritm genetic ncepe cu o populaie de cromozomi (n
general aleas aleator). Se evalueaz, apoi, aceste structuri i se aloc faciliti
reproductive astfel nct acei cromozomi, care reprezint o soluie mai bun pentru
problema int, s aib mai multe anse de a se reproduce dect acei cromozomi care
sunt soluii mai proaste. Definirea unei soluii bune se face, n general, n raport cu
populaia curent.
Algoritmii genetici se pot utiliza pentru optimizarea unei funcii F(x
1
, x
2
, ... x
M
)
ceea ce nseamn c dorim s minimizm sau s maximizm aceast funcie. n acest
caz variabilele ce desemneaz paramerii sunt reprezentate n general prin iruri binare
(variabilele fiind discretizate apriori).

7.2. Algoritmul genetic canonic

Primul pas n implementarea unui algoritm genetic const n generarea
populaiei iniiale.
n algoritmul genetic canonic fiecare membru al acestei populaii va fi un ir
binar de lungime L corespunznd codificrii problemei. Fiecare ir este denumit fie
genotip fie cromozom. n majoritatea cazurilor populaia iniial este generat aleator.
Fiecare ir este evaluat i i se atribuie un fitness.
Funcia de evaluare sau funcia obiectiv reprezint o msur a performanei n
raport cu o anumit mulime de parametrii. Funcia fitness transform aceast msur a
performanei n alocare de faciliti reproductive.
n algoritmul genetic canonic fitness-ul este definit prin relaia:

f
f
i

unde:

63
f
i
reprezint evaluarea asociat cu irul i;
f - evaluarea medie a tuturor irurilor populaiei.

Este util ca execuia unui algoritm genetic s fie considerat ca un proces n
dou etape:

1. prima etap const n aplicarea unei selecii populaiei curente rezultnd o
populaie intermediar;
2. a doua etap const n aplicarea recombinrilor i mutaiilor populaiei
intermediare pentru a crea o populaie urmtoare.

Trecerea de la populaia curent la populaia urmtoare reprezint o generaie n
execuia unui algoritm genetic.
Figura urmtoare explic acest lucru: o generaie se compune din faza seleciei i
faza recombinrii. Mutaia (nu apare n desen) poate interveni dup crossover.

n figura de mai sus irurile care alctuiesc o generaie reprezint variabilele
funciei de optimizat, variabile ce sunt de regul anumii parametrii ai unui fenomen.
Aceste variabile sunt convertite n iruri binare prin operaia de discretizare. Generaiei
curente i se aplic operaia de selecie astfel: se calculeaz fitness-ul
f
f
i
i apoi se
asociaz anse mai mari irurilor cu fitness mai mare. Metoda de asociere a anselor
depinde de algoritmul folosit. De exemplu poate fi folosit o metod similar cea
utilizat la jocul de rulet. La jocul de rulet, pe roat, fiecrui numr i se aloc un
anumit spaiu inegal pe circumferina roii. Numerele care vor avea alocat un sector de
cerc mai mare au anse mai mari s capteze bila ruletei.
O alt metod poate fi cea a extragerii aleatoare cu rest. Pentru a aplica aceast
metod se parcurg urmtoarele etape:
Sir 1
Sir 2
Sir 3
...
Sir 1
Sir 2
Sir 3
...
Descendent A (1x2)
Descendent B (1x2)
Descendent A (2x4)
Descendent D (2x4)
.............
Selecie
(duplicare)
Recombinare
(crossover)
Generaie
curent t
Generaia
intermediar t
Generaia
urmtoare t+1

64

- se calculeaz fitness-ul i pentru
f
f
i
>1 partea ntreag indic numrul de
iruri identice plasate n populaia intermediar;
- partea fracionar
f
f
i
reprezint ansa de a mai plasa o copie a irului. De
exemplu pentru un fitness egal cu 1,36 se plaseaz o copie n generaia
intermediar i se mai poate plasa una cu probabilitatea 0,36.

Prin recombinare se nelege aplicarea cu o probabilitate p
c
operatorul crossover
perechilor de iruri aleator formate.
Funcionarea operatorului de crossover va fi explicat prin urmtorul exemplu.
Presupunem dou iruri binare din generaia intermediar. Pentru a putea urmri modul
de funcionare a operatorului cel de-al doilea ir a fost reprezentat cu simbolurile x i
y n loc de 1 i 0. Cele dou iruri sunt:

primul ir: 1101011011
al doilea ir: yxxyxxxxyy

Folosind un punct de recombinare aleator ales, un crossover simplu (1-point
crossover) apare ca:

1101\/011011
yxxy/\xxxxyy

n urma aplicrii operatorului de recombinare obinem descendenii:

1101xxxxyy
i
yxxy011011

Dup recombinare se poate aplica operatorul de mutaie. Fiecare bit din
populaie se va schimba cu o mic probabilitate p
m
(n general rata mutaiei este sub
1%).
Dup ce procesele de selecie, recombinare i mutaie au luat sfrit, populaia
urmtoare poate fi evaluat. Evaluarea, selecia, recombinarea i mutaia formeaz o
generaie n executarea unui algoritm genetic. Generaia urmtoare devine generaie
curent i algoritmul este reluat pn se atinge obiectivul propus definit de funcia
obiectiv.
Teoria algoritmilor genetici presupune o mare varietate de metode i tehnici
utilizate, ncepnd de la modul de reprezentare a variabilelor funciei de optimizat i
terminnd cu metodele de calcul.
Rezultatele foarte bune obinute n unele domenii ale inteligenei artificiale au
impus aceast metod pe lng reelele neurale i mulimile nuanate ca instrumente
foarte puternice de lucru.
n concluzie putem spune c un lucru izbitor la algoritmii genetici i modelele
paralele este bogia acestor forme de calcul. Ceea ce pare o mic schimbare n algoritm
duce adeseori la comportri surprinztoare.

65
Reelele neurale, mulimile nuanate i algoritmii genetici sunt adesea utilizate
mpreun, n diverse domenii ale inteligenei artificiale cum ar fi analiza imaginilor,
recunoaterea formelor i a vorbirii, sisteme expert etc.

66

SEMINAR

Seminar 1

Problema 1.1.
S se construiasc tabelele de adevr pentru conectorii ~, v, ^, , (negare,
sau, i, implicare i respectiv, echivalen).

Rezolvare

Tabelul 1.1.
a b ~ a
a negat
~ b
b negat
a v b
a I b
a ^ b
a SAU b
a b
a IMPLIC b
ab
a ECHIVALENT b
0 0 1 1 0 0 1 1
0 1 1 0 1 0 1 0
1 0 0 1 1 0 0 0
1 1 0 0 1 1 1 1

Problema 1.2.
Se consider egalitatea: p v q = ~ (~p ^ ~ q) s se demonstreze cu ajutorul
tabelelor de adevr c aceast egalitate este adevrat.

Rezolvare
Tabelul 1.2.
p q ~p ~q ~p ^ ~q p v q ~ (~p ^ ~ q)
0 0 1 1 1 0 0
0 1 1 0 0 1 1
1 0 0 1 0 1 1
1 1 0 0 0 1 1

Pentru ca formula s fie adevrat, ultimile dou coloane ale tabelului de adevr
1.2. trebuie s fie identice. Cu alte cuvinte, toate interpretrile din ultimile dou coloane
trebuie s aib valoarea corespunztoare, egal.

Problema 1.3.
S se arate, cu ajutorul tabelelor de adevr c formula P: p v q ~ (~p ^ ~ q)
este o tautologie.

67
Rezolvare

Dac lum n considerare ultimile dou coloane din tabelul 1.2. obinem:

Tabelul 1.3.
p v q ~ (~p ^ ~ q) p v q ~ (~p ^ ~ q)
0 0 1
1 1 1
1 1 1
1 1 1

Ceea ce arat c formula este o tautologie (este adevrat n toate interpretrile
ei).

Problema 1.4.
S se arate cu ajutorul tabelelor de adevr c egalitatea: p ^ (q v r) =(p ^ q) v (p
^ r) distributivitate este adevrat.

Rezolvare

Tabelul 1.4.
p q r q v r p ^ q p ^ r p ^ (q v r) (p ^ q) v (p ^ r)
0 0 0 0 0 0 0 0
0 0 1 1 0 0 0 0
0 1 0 1 0 0 0 0
0 1 1 1 0 0 0 0
1 0 0 0 0 0 0 0
1 0 1 1 0 1 1 1
1 1 0 1 1 0 1 1
1 1 1 1 1 1 1 1

Aa cum s+a artat i la problema 1.2. ultimile dou coloane ale tabelului de
adevr 1.4. trebuie s fie egale pentru ca egalitatea s fie adevrat.

Problema 1.5
Se consider formula P: p ^ (q v r). S se rspund la urmtoarele ntrebri:

1. Formula P este realizabil? Rspuns: DA
2. Formula P este o tautologie? Rspuns: NU
3. Formula P este nevalid? Rspuns: DA
4. Formula P este o contradicie? Rspuns: NU

Not: rspunsurile se obin avnd n vedere tabelul de adevr 1.4. i diagrama de la
pagina 11 din curs.

Problema 1.6.
Se consider formula: P: p ^ (q v r) s se rspund la urmtoarele ntrebri
referitoare la interpretarea {p, ~q, r}. S se rspund la urmtoarele ntrebri:

68
1. Interpretarea satisface pe P? Rspuns: DA
2. Interpretarea falsific pe P? Rspuns: NU

Not: rspunsurile se obin avnd n vedere tabelul de adevr 1.4. i explicaiile de la
pagina 10 din curs.

Problema 1.7.
S se scrie toate modelele formulei: P: p ^ (q v r).

Rezolvare

Un model reprezint o interpretare care satisface formula P (o interpretare pentru
care formula P este adevrat). Folosindu-ne de tabelul 1.4, obinem modelele formulei
P:

{p, ~q, r}, {p, q, ~r} i {p, q, r}

Seminar 2

Problema 2.1.
Cu ajutorul metodei lui Quine, prezentat n curs la pagina 13, s se determine
caracterul formulei: P: ((p ^ q ^ ~r) ^ (p v r)) ((p v r) ^ (q v r)).

Rezolvare

Atomul care apare cel mai frecvent este atomul r. l nlocuim mai nti cu V
(adevrat) i apoi cu F (fals).
Dac nlocuim atomul r cu adevrat (V) obinem:
1.a. ((p ^ q ^ ~V) ^ (p v V)) ((p v V) ^ (q v V))
din care se obine:
2.a. ((p ^ q ^ F) ^ V)) (V ^ V)
apoi:
3.a. ((p ^ F) ^ V)) V
dup care:
4.a. (F ^ V) V
ceea ce duce la:
5.a. F V
i n final:
6.a. F
nlocuim acum atomul r cu fals (F) i obinem:
1.b. ((p ^ q ^ ~F) ^ (p v F)) ((p v F) ^ (q v F))
rezult:
2.b. ((p ^ q ^ V) ^ p) (p ^ q)
deci:
3.b. ((p ^ q) ^ p) (p ^ q)
n acest moment atomul r este eliminat. Vom nlocui n continuare atomul care apare
cel mai des nti cu adevrat i apoi cu fals. Acesta este atomul p:

69
((p ^ q) ^ p) (p ^ q)

((V ^ q) ^ V) (V ^ q) ((F ^ q) ^ F) (F ^ q)
ceea ce duce la:
(q ^ V) q (F ^ F) F
i deci:
q q F F
n final:
V V F F V

V V
Rezultat obinut prin nlocuirea atomului q cu adevrat i apoi fals.
S-a obinut astfel o interpretare n care formula este fals (punctul 6.a.) iar restul
n care formula este adevrat. Putem spune c formula este consistent dar nu este o
tautologie.

Problema 2.2.
S se demonstreze cu ajutorul metodei lui Quine c formula: P: (pq)
((qr) ((p v q)r)) este o tautologie.

Rezolvare

Ca n exemplul precedent, se va nlocui atomul care apare cel mai frecvent, q,
mai nti cu adevrat (V) i apoi cu fals (F).

a. q = V
1.a. (pV) ((Vr) ((p v V)r))
2.a. V (r (Vr)
3.a. V (r r)
4.a. V (r r)
n acest situaie se nlocuiete atomul r, mai nti cu adevrat i apoi cu fals. Se obine:
4.a.1. V (V V) rezult: V V i ceea ce n final duce la V (adevrat);
4.a.2. V (F F) rezult: V V i ceea ce n final duce la V (adevrat);
b. q = F
1.b. (pF) ((Fr) ((p v F)r))
2.b. ~p (V (pr))
Se nlocuiete acum atomul care apare cel mai frecvent, p, mai nti cu adevrat i apoi
cu fals.
2.b.1. ~V (V (Vr)), rezult: F (V r) i deci: F r care este V
(adevrat);
2.b.2. ~F (F (Fr)), rezult: V (F V) deci: V V care d rezultatul V
(adevrat).
S-a obinut n toate cazurile rezultatul adevrat i deci formula este o
tautologie.

Not: Seminarul se va completa cu exemplele din curs.

70
Seminar 3.

Problema 3.1.
S se demonstreze prin metoda reducerii c formula de la problema 2.2. este o
tautologie.

Rezolvare

Formula este: P: (pq) ((qr) ((p v q)r))
ncercm s falsificm aceast formul. Conectorul principal va fi conectorul
IMPLICARE aa cum se arat n continuare:
2 1 3 2 3
(pq) ((qr) ((p v q)r))
1 0 1 0 0
n cazul pasului 2 avem dou situaii ce presupun mai multe variante de studiat: o
operaie IMPLICARE a crui rezultat este unu i o operaie SAU a crui rezultat este de
asemenea unu. Se studiaz fiecare caz n parte.
a) n primul caz, operaia de implicare are rezultatul unu cnd ambii termeni sunt
zero, se studiaz aceast situaie:
5 4 5 2 6 4 6 1 7 3 7 2 3
(pq) ((qr) ((p v q)r))
1 0 0 1 1 0 0 0 1 1 0 0 0
valoarea atomului q este v(q) = 0 la pasul 5 (valoare introdus pentru ca rezultatul
operaiei de IMPLICARE s fie zero) i v(q) = 1 la pasul 6 (valoare introdus, de
asemenea pentru ca rezultatul operaiei de IMPLICARE s fie zero). Cele dou valori
contradictorii ne arat c formula nu poate fi falsificat n aceast interpretare. Toate
celelalte cazuri pentru situaia 0 0, indiferent de combinaia folosit pentru funcia
SAU la pasul 3, conduc la acelai rezultat.
b) n al doilea caz, operaia de implicare are rezultatul unu cnd unul din termeni
este zero i cellalt este unu:
6 4 6 2 4 1 3 2 3
(pq) ((qr) ((p v q)r))
1 0 0 1 1 0 1 0 0
vom analiza acest rezultat deoarece sunt mai multe combinaii posibile. La pasul 4
prima operaie de IMPLICARE egal cu zero impune v(p) = 1 i v(q) = 0. Cea de-a treia
operaie de IMPLICARE, egala cu unu premite urmtoarele combinaii: v(p) = 0 i v(q)
= 0, care duce la o contradicie, v(p) = 0 i v(q) = 1, care conduce de asemenea lo o
contradicie i, de asemenea, v(p) = 1 i v(q) = 1 care este, evident iari o contradicie.
Din nou nu s-a putut gasi o vombinaie v(p), v(q) care sa permita falsificarea formulei.
c) n al treilea caz, operaia de implicare are rezultatul unu cnd ambii termeni sunt
egali cu unu. Evident c n aceast situaie, n partea stng a ecuaiei vom putea
gsi combinaii v(p), v(q) care sa satisfac ambele implicaii:
4 2 4 1 3 2 3
(pq) ((qr) ((p v q)r))
1 1 1 0 1 0 0
Studiem in acest caz membrul drept al ecuaiei: combinaia v(p) = 0 i v(q) = 0, impune
v (q) = 0, v(r) = 1 ceea ce intr n contradicie cu valoarea lui r stabilita la pasul 3,
combinaia v(p) = 0 i v(q) = 1, impune v (q) = 1, v(r) = 1 ceea ce intr iari n

71
contradicie cu valoarea lui r stabilita la pasul 3 iar combinaia v(p) = 1 i v(q) = 1,
impune v (q) = 1, v(r) = 1 ceea ce intr n contradicie cu valoarea lui r stabilita la pasul
3. Dup cum s-a putut vedea nu mai este necesar studierea combinaiilor posibile
pentru conectorul SAU deoarece nu se poate gasi o combinaie convenabil pentru
atomii p,q,r din analiza celorlali conectori. Rezult c n toate interpretrile formula nu
poate fi falsificat i deci ea este o tautologie.

Not: Seminarul se va completa cu exemplele din curs.

Seminar 4.

ntrebri pentru testul gril.

1. Alegei rspunsul corect, n funcie de modul n care definiia urmtoare este
corect (ADEVRAT) sau incorect (FALS). O formul este valid dac i
numai dac este adevrat n toate interpretrile.
A. ADEVRAT B. FALS
Rspuns: A
2. Alegeti varianta cea mai corect din cele prezentate mai jos. Metoda lui Quine
reprezint:
A. O metod de reprezentare a funciilor logice.
B. O metod de determinare a realizabilitii unei formule.
C. Un operator logic.
Rspuns: B
corect (ADEVRAT) sau incorect (FALS). Dou formule sunt logic
echivalente dac au aceeai tabel de adevr.
A. ADEVRAT B. FALS
Rspuns: A
corect (ADEVRAT) sau incorect (FALS). O formul nerealizabil este
adevrat n toate interpretrile ei deci admite model.
A. ADEVRAT B. FALS
Rspuns: B
5. Alegeti varianta cea mai corect din cele prezentate mai jos. Metoda reducerii
se bazeaz pe:
A. ncercarea de falsificare a formulei date.
B. ncercarea de validare a formulei date.
C. nlocuirea termenilor negai cu cei nenegai.
Rspuns: A
corect (ADEVRAT) sau incorect (FALS). Un lan inferenial exprimat n
limbaj obiect, ale crui premise sunt axiome se numete demonstraie iar
concluzia se numete teorem.
A. ADEVRAT B. FALS
Rspuns: A

72
corect (ADEVRAT) sau incorect (FALS). n cazul logicii propoziiilor: o
formul valid poate fi i inconsistent.
A. ADEVRAT B. FALS
Rspuns: B
corect (ADEVRAT) sau incorect (FALS). Metoda lui Quine permite
determinarea caracterului de tautologie al unei formule.
A. ADEVRAT B. FALS
Rspuns: A
corect (ADEVRAT) sau incorect (FALS). n cazul logicii propoziiilor: o
tautologie reprezint o formul valid.
A. ADEVRAT B. FALS
Rspuns: A
10. Alegei varianta incorect din cele prezentate mai jos.
A. O formul valid este consistent.
B. O formul este nevalid dac i numai dac exist o interpretare n care este fals.
C. O formul este valid dac i numai dac negaia ei este inconsistent.
Rspuns: C

Seminar 5.

S se deseneze schema bloc a unui sistem expert. Se vor explica urmatoarele
blocuri: Modul de achiziie a cunotinelor, Baza de cunotine, Baza de fapte,
Mecanismul de inferen, Modulul de explicare, Interfaa utilizator (curs pagina 25).

Se va desena i se va explica schema bloc a stratergiei de control cu restricie
nul (curs pagina 26).

Se vor discuta i explica principalele elemente ale limbajului CLIPS (curs de la
pagina 27).

Seminar 6.

Problema 6.1.
Folosind universul de discurs, mulimea oamenilor, s se defineasc mulimea
TNR care rspunde la ntrebarea: care este gradul de tineree al unei persoane

Rezolvare.
Noiunea de TNAR este o noiune imprecis. Putem considera persoanele cu
vrsta mai mic de 20 de ani ca fiind tinere. Vrsta unei persoane o notam cu v(x).
Un exemplu de definire este:
>
<

=
30 ) ( , 0
30 ) ( 20 ,
10
) ( 30
20 ) ( , 1
) (
x v
x v
x v
x v
x A
TANAR

73
Problema 6.2.
S se defineasc mulimea oamenilor nali pe universul de discurs mulimea
oamenilor.

Rezolvare.
Caracteristica unei persoane de a fi nalt este de asemenea o noiune imprecis.
Pentru a specifica un model fuzzy, notm h(x) nlimea n centimetrii a unei persoane
i considerm c oamenii cu nlimea sub 150 cm sunt scunzi (nu sunt nali) iar cei cu
nlimea peste 200 cm sunt nali. Funcia de apartenen la clasa oamenilor nali se
definete atunci prin:
>

<
=
200 ) ( , 1
200 ) ( 150 ,
200
150 ) (
150 ) ( , 0
) (
x h
x h
x h
x h
x A
INALT

Problema 6.3.
S se defineasc mulimea fuzzy a numerelor reale foarte apropiate de numrul
zero.

Rezolvare.
Dac X este mulimea fuzzy dorit, atunci un model pentru funcia de
apartenen A(x) poate fi:
2
1
1
) (
x
x A
+
=
ceea cene conduce la: A(1) = 0,5; A(0) = 1; A(2) = 0,2; A(-2) = 0,2; A(3) = 0,1; A(-3) =
0,1.
Un alt model ar putea fi:
2
2
1
1
) (
|
.
|
\
|
+
=
x
x A
ceea cene conduce la: A(1) = 0,25; A(0) = 1; A(2) = 0,04; A(-2) = 0,04; A(3) = 0,01;
A(-3) = 0,01.
Similar, putem defini mulimea fuzzy a numerelor apropiate de numrul real a,
cu ajutorul funciei de apartenen:
( )
2
1
1
) (
a x
x A
+
=
Problema 6.4.
Se consider universul de discurs mulimea numerelor reale. S se defineasc
funcia de apartenen pentru numerele reale care ndeplinesc condiia a < b.

Rezolvare.
n acest caz se folosete o mulime interval. Modelul interval este:
| |
| |

= =
altfel
b a x
x x A
b a
, 0
, , 1
) ( 1 ) (
,

Se spune c funcia de apartenen furnizeaz o reprezentare pe vertical a unei
mulimi fuzzy.

74
Seminar 7.

Test gril final.

11. Alegeti varianta cea mai corect din cele prezentate mai jos. Problemele tratate
cu succes de un sistem expert sunt:
A. Probleme de optimizare.
B. Probleme de conducere.
C. Probleme pentru care nu exist o soluie algoritmic clar.
Rspuns: C
corect (ADEVRAT) sau incorect (FALS). O reea neural const dintr-o
mulime de elemente de prelucrare (neuroni, elemente cognitive sau noduri ale
reelei) nalt interconectate.
A. ADEVRAT B. FALS
Rspuns: A
corect (ADEVRAT) sau incorect (FALS). Funcia de ieire a neuronului
reprezint funcia de activare.
A. ADEVRAT B. FALS
Rspuns: A
corect (ADEVRAT) sau incorect (FALS). O reea neural multistrat poate
conine cel mult un strat ascuns.
A. ADEVRAT B. FALS
Rspuns: B
corect (ADEVRAT) sau incorect (FALS). Algoritmul de instruire a
perceptronului se bazeaz pe modificarea ponderilor i a valorii de prag.
A. ADEVRAT B. FALS
Rspuns: A
corect (ADEVRAT) sau incorect (FALS). O mulime nuanat nu poate
avea complementar.
A. ADEVRAT B. FALS
Rspuns: B
corect (ADEVRAT) sau incorect (FALS). Populaia iniial a unui algoritm
genetic este stabilit de funcia de evaluare.
A. ADEVRAT B. FALS
Rspuns: B
corect (ADEVRAT) sau incorect (FALS). Un sistem expert conine o baz
de cunotiine i un mecanism de interferen.
A. ADEVRAT B. FALS
Rspuns: B

75
corect (ADEVRAT) sau incorect (FALS). Ponderile sinaptice sunt asociate
ieirilor neuronului.
B. ADEVRAT B. FALS
Rspuns: B
20. Alegeti varianta corect din cele prezentate mai jos. n activitatea de instruire a
unei reele neurale sunt folosite:
A. Listele cu ponderile ateptate.
B. Listele de conexiuni cunoscute.
C. Listele de asociere.
Rspuns: C
21. Alegeti varianta incorect din cele prezentate mai jos. Perceptronul reprezint:
A. Cea mai simpl reea neural.
B. O reea neural cu un singur strat.
C. Perceptronul nu poate avea dect dou intrri.
Rspuns: C
22. Alegeti varianta incorect din cele prezentate mai jos. O mulime nuanat este
caracterizat de:
A. Universul mulimii nuanate.
B. Tabelul de adevr.
C. Funcia de apartenen.
Rspuns: B
corect (ADEVRAT) sau incorect (FALS). n cazul unui algoritm genetic
fiecare ir component al unei generaii se numete cromozom sau genotip.
A. ADEVRAT B. FALS
Rspuns: A
corect (ADEVRAT) sau incorect (FALS). ntr-un algoritm genetic trecerea
de la generaia curent la generaia urmtoare se face prin selecie,
recombinare i mutaie.
A. ADEVRAT B. FALS
Rspuns: A
corect (ADEVRAT) sau incorect (FALS). Pentru un perceptron ponderile
sinaptice pot fi inhibitoare sau excitatoare.
A. ADEVRAT B. FALS
Rspuns: A
26. Alegei varianta incorect din cele prezentate mai jos. Funciile unui sistem
expert sunt:
A. Funcia de nvare.
B. Funcia de evaluare a cunotiinelor pe baza raionamentelor.
C. Funcia de elaborare a unor algoritmi simplii.
Rspuns: C
27. Alegei varianta corect din cele prezentate mai jos. Listele de asociere n cazul
reelelor nurale reprezint:
A. Asocierea intrrilor cu ponderile sinaptice..
B. Asocierea intrrilor cu funciile de excitaie.

76
C. Perechi de valori intrare-ieire furnizate reelei neurale n procesul de instruire.
Rspuns: C
corect (ADEVRAT) sau incorect (FALS). Universul unei mulimi nuanate
poate fi continuu sau discret.
A. ADEVRAT B. FALS
Rspuns: A

77

LABORATOR

Laborator 1, 2, 3.

Demonstrarea tautologiilor cu ajutorul calculatorului.

S se ntocmeasc un program n limbaj C sau Pascal cu ajutorul cruia s se
verifice tautologiile din formulele de la paginile 12 i 13 din curs (tautologiile
fundamentale).

Indicaie:
Ne vom baza pe metoda tabelelor de adevr n care trebuie s demonstrm c formula
este adevrat n toate interpretrile ei.
Pentru aceasta se vor construi funcii (proceduri) pentru conectorii: ~ (negare), v (sau), ^
(i), (implicare). Cu ajutorul acestora vor fi evaluate formulele pentru toate valorile
posibile pentru variabilele P,Q, R.

Tabelul de adevr pentru conectori:

a b ~ a
a negat
~ b
b negat
a v b
a I b
a ^ b
a SAU b
a b
a IMPLIC b
ab
a ECHIVALENT b
0 0 1 1 0 0 1 1
0 1 1 0 1 0 1 0
1 0 0 1 1 0 0 0
1 1 0 0 1 1 1 1

Un exemplu de realizare a unui program de verificre a tautologiilor, n C++ va fi
prezentat n continuare.
Pentru nceput vor fi realizate funciile logice de baza de care avem nevoie. n
C++ funciile logice I (&&) i SAU (||) sunt definite, deci trebuie realizate doar
funciile implicare i echivalen.
Realizarea acestor functii este facut in programul binar1.cpp:

PROGRAMUL binar1.cpp

/* testare operatiilor logice */

#include <stdio.h>
#include <conio.h>

78
char impl (char a,char b)
{
char c;
if (a==0) c=1;
if ((a==1) && (b==0)) c=0;
if ((a==1) && (b==1)) c=1;
return c;
}

char echiv (char a,char b)
{
char c;
if (a==b) c=1;
if (a != b) c=0;
return c;
}

void main(void)
{
unsigned char alfa, beta, gama,pas;
clrscr();
for (alfa=0; alfa<=1; alfa++)
for (beta=0; beta<=1; beta++)
{
printf("\n alfa= %d", alfa);
printf("\n beta= %d", beta);
gama=alfa && beta;
printf("\n gama(si)= %d", gama);
gama=alfa || beta;
printf("\n gama(sau)= %d", gama);
printf("\n gama(nu)= %d", !gama);
gama=impl(alfa,beta);
printf("\n gama(implicare)= %d", gama);
gama=echiv(alfa,beta);
printf("\n gama(echivalenta)= %d", gama);
scanf("%c",pas);
}
}

La inceputul programului sunt definite cele dou funcii logice necesare:
IMPLICARE funcia impl:
{
char c;
if (a==0) c=1;
if ((a==1) && (b==0)) c=0;
if ((a==1) && (b==1)) c=1;
return c;

79
}
i ECHIVALEN funcia echiv:

{
char c;
if (a==b) c=1;
if (a != b) c=0;
return c;
}

Dac ne uitm la tabela de adevr prezentat mai sus este uor s nelegem cum
au fost realizate aceste funcii:

Funcia impl are ca variabile de intrare variabilele a i b i ca rezultat variabila c.
Variabila c ia valoarea 1 (unu) logic dac variabila a este zero (prima
instruciune if) i ia valoarea logic a variabilei b dac variabila a este 1 (unu)
urmtoarele dou instruciuni if.

Funcia echiv are ca variabile de intrare variabilele a i b i ca rezultat variabila
c. Variabila c ia valoarea 1 (unu) logic dac variabila a i variabila b au valori
egale (prima instruciune if) i ia valoarea logic 0 (zero) n caz contrar (a doua
instructiune if).

Prin executia programului se obtine urmatorul rezultat:

alfa= 0
beta= 0
gama(si)= 0
gama(sau)= 0
gama(nu beta)= 1
gama(implicare)= 1
gama(echivalenta)= 1

alfa= 0
beta= 1
gama(si)= 0
gama(sau)= 1
gama(nu beta)= 0
gama(implicare)= 1

alfa= 1
beta= 0
gama(si)= 0
gama(sau)= 1
gama(nu beta)= 1
gama(implicare)= 0

80

alfa= 1
beta= 1
gama(si)= 1
gama(sau)= 1
gama(nu beta)= 0
gama(implicare)= 1

n aceste rezultate, variabilele de intrare sunt notate cu alfa i beta n loc de a i
b iar rezultatul este gama fiind specificat n parantez ce funcie este reprezentat.
Dup cum se vede rezultatul obinut este identic cu cel din tabela de adevr.

n continuare vom arta cum se face verificarea unei tautologii.
Pentru verificarea formulei:
((a si b) implica c) i (d i e) implica (d sau e) care poate fi scris i :
((a ^ b) c) ^ (d ^ e) (d v e)

vom folosi programul binar2.ccp.

Acest exemplu a fost ales mult mai complex dect formulele 1) 34) n aa fel nct s
se neleag modul de lucru pentru toate cazurile.

PROGRAMUL binar2.ccp

/* testare operatiilor logice */
// pentru functia ((a si b) implica c) si (d si e) implica (d sau e)
#include <stdio.h>
#include <conio.h>

//pentru inceput sunt definite functiile logice implicare si ecuvalenta

{
char c;
if (a==0) c=1;
if ((a==1) && (b==0)) c=0;
if ((a==1) && (b==1)) c=1;
return c;
}

{
char c;
if (a==b) c=1;
if (a != b) c=0;
return c;

81
}

void main(void)
{
unsigned char a, b, c, d, e, AS[4], A[8], B[8], C[8], D[8], E[8], contor, pas;
FILE *fisier;
fisier=fopen("rezultat","w+");
clrscr();

// se calculeaza functia a si b
// se memoreaza temporar in vectorul AS
printf("\n Se calculeaza (a SI b)");
fprintf(fisier,"\n Se calculeaza (a SI b)");
contor=0;
for (a=0; a<=1; a++)
for (b=0; b<=1; b++)
{
// rezultatul se pastreaza in vectorul AS
AS[contor]=a && b;
printf("\n a: %d",a);
printf("\n b: %d",b);
printf("\n Valoare iesire a SI b: %d",AS[contor]);
fprintf(fisier,"\n a: %d",a);
fprintf(fisier,"\n b: %d",b);
fprintf(fisier,"\n Valoare iesire a SI b: %d",AS[contor]);
contor++;
scanf("%c",pas);
}

// se calculeaza (a si b) implica c
// (a si b) a fost deja calculat si se afla in vectorul AS
// se calculeaza deci AS implica c
// AS are 4 valori rezultate din calculul precedent valoarea lui c va
// fi 0 si 1 rezulta ca vor fi 8 valori la sfirsit
// rezultatul se pune in vectorul A.
printf("\n Se calculeaza (a SI b) IMPLICA c");
fprintf(fisier,"\n Se calculeaza (a SI b) IMPLICA c");
contor=0;
for (c=0; c<=1; c++)
// se foloseste temporar variabila a pentru a contoriza cele patru
// stari ale vectorului AS
for (a=0; a<=3; a++)
{
A[contor]=impl(AS[a],c);
printf("\n (a si b): %d",AS[a]);
printf("\n c: %d",c);
printf("\n Valoare iesire (a SI b) IMPLICA c: %d",A[contor]);
fprintf(fisier,"\n (a si b): %d",AS[a]);

82
fprintf(fisier,"\n c: %d",c);
fprintf(fisier,"\n Valoare iesire (a SI b) IMPLICA c: %d",A[contor]);
contor++;
scanf("%c",pas);
}

// se calculeaza acum formula (d si e) iar rezultatul acesteia se
// memoreaza in B si formula (d sau e) care se memoreaza in C.
// Pentru ca vectorii obtinuti sa fie compatibili cu vectorul A,
// vectorii B si C vor avea si ei 8 valori desi nu sunt necesare decit
// patru (valorile se vor repeta de doua ori.
printf("\n Se calculeaza separat cele doua functii. Prima: d SI e iar a doua d SAU e");
fprintf(fisier,"\n Se calculeaza separat cele doua functii. Prima: d SI e iar a doua d SAU e");
contor=0;
for (a=0; a<=1; a++)
// se foloseste temporar variabila a pentru a dubla cele patru
// stari ale vectorilor B si C
for (d=0; d<=1; d++)
for (e=0; e<=1; e++)
{
B[contor]=d && e;
C[contor]=d || e;
printf("\n d: %d",d);
printf("\n e: %d",e);
printf("\n Valoare iesire (d SI e): %d",B[contor]);
printf("\n Valoare iesire (d SAU e): %d",C[contor]);
fprintf(fisier,"\n d: %d",d);
fprintf(fisier,"\n e: %d",e);
fprintf(fisier,"\n Valoare iesire (d SI e): %d",B[contor]);
fprintf(fisier,"\n Valoare iesire (d SAU e): %d",C[contor]);
if (contor==4)
{printf("\n Valorile se repeta");
fprintf(fisier,"\n Valorile se repeta");}
contor++;
scanf("%c",pas);
}

// se calculeaza formula ((a SI b) IMPLICA c) SI (d SI e) care, cu notatiile
// facute se poate scrie A SI B iar rezultatul se va pune in vectorul D.
printf("\n Se calculeaza formula ((a SI b) IMPLICA c) SI (d SI e)");
fprintf(fisier,"\n Se calculeaza formula ((a SI b) IMPLICA c) SI (d SI e)");
for (contor=0; contor<=7; contor++)
{
D[contor]=A[contor] && B[contor];
printf("\n ((a SI b) IMPLICA )c: %d",A[contor]);
printf("\n (d SI e): %d",B[contor]);
printf("\n Valoare iesire (A SI B): %d",D[contor]);
fprintf(fisier,"\n ((a SI b) IMPLICA )c: %d",A[contor]);

83
fprintf(fisier,"\n (d SI e): %d",B[contor]);
fprintf(fisier,"\n Valoare iesire (A SI B): %d",D[contor]);
scanf("%c",pas);
}

// se calculeaza formula ((a SI b) IMPLICA c) SI (d SI e) IMPLICA (d SAU e)
// care, cu notatiile facute se poate scrie D IMPLICA C
// iar rezultatul se va pune in vectorul E.
printf("\n Se calculeaza formula ((a SI b) IMPLICA c) SI (d SI e) IMPLICA (d SAU e)");
fprintf(fisier,"\n Se calculeaza formula ((a SI b) IMPLICA c) SI (d SI e) IMPLICA (d SAU e)");
for (contor=0; contor<=7; contor++)
{
E[contor]=impl(D[contor],C[contor]);
printf("\n ((a SI b) IMPLICA )c SI (d SI e): %d",D[contor]);
printf("\n (d SAU e): %d",C[contor]);
printf("\n Valoare iesire D IMPLICA C: %d",E[contor]);
fprintf(fisier, "\n ((a SI b) IMPLICA )c SI (d SI e): %d",D[contor]);
fprintf(fisier, "\n (d SAU e): %d",C[contor]);
fprintf(fisier, "\n Valoare iesire D IMPLICA C: %d",E[contor]);
scanf("%c",pas);
}
printf("\n Verificarea s-a terminat!");
scanf("%c",pas);
fclose(fisier);
}

Pentru nceput vom construi tabelul de adevr pentru aceast formul. Prima
observaie care se poate face este c prima parte a formulei: ((a ^ b) c) depinde de
variabilele a, b i c care nu apar n partea a doua a formulei. n acest fel vom construi
tabelul de adevar din dou tabele.
Primul tabel:

c b a (a ^ b) (a ^ b) c notat mai departe cu A
0 0 0 0 1
0 0 1 0 1
0 1 0 0 1
0 1 1 1 0
1 0 0 0 1
1 0 1 0 1
1 1 0 0 1
1 1 1 1 1

Formula (a ^ b) c nu este valid (este nevalid) i deci nu este o tautologie.

Pentru a evalua formula se construieste acum cel de-al doilea tabel pentru
formula:

A ^ (d ^ e) (d v e)

84
este :

Formula este egala cu unu in toate interpretrile ei i deci este o tautologie.

Acelasi lucru a fost realizat i cu ajutorul programului Binar2. Reyultatele acestuia sunt:

Se calculeaza (a SI b)
a: 0
b: 0
Valoare iesire a SI b: 0
a: 0
b: 1
a: 1
b: 0
a: 1
b: 1

Se calculeaza (a SI b) IMPLICA c
(a si b): 0
c: 0
Valoare iesire (a SI b) IMPLICA c: 1
(a si b): 0
c: 0
(a si b): 0
c: 0
(a si b): 1
c: 0
(a si b): 0
c: 1
(a si b): 0
A d e (d ^ e)
notat B
(d v e)
notat C
A ^ B
notat D
D C care este de fapt formula
((a ^ b) c) ^ (d ^ e) (d v e)
0 0 0 0 0 0 1
0 0 1 0 1 0 1
0 1 0 0 1 0 1
0 1 1 1 1 0 1
1 0 0 0 0 0 1
1 0 1 0 1 0 1
1 1 0 0 1 0 1
1 1 1 1 1 1 1

85
c: 1
(a si b): 0
c: 1
(a si b): 1
c: 1

Se calculeaza separat cele doua functii. Prima: d SI e iar a doua d SAU e
d: 0
e: 0
Valoare iesire (d SI e): 0
Valoare iesire (d SAU e): 0
d: 0
e: 1
d: 1
e: 0
d: 1
e: 1
d: 0
e: 0
Valorile se repeta
d: 0
e: 1
d: 1
e: 0
d: 1
e: 1

Se calculeaza formula ((a SI b) IMPLICA c) SI (d SI e)
((a SI b) IMPLICA )c: 1
(d SI e): 0
Valoare iesire (A SI B): 0

86
(d SI e): 0
(d SI e): 0
(d SI e): 1
(d SI e): 0
(d SI e): 0
(d SI e): 0
(d SI e): 1

Se calculeaza formula ((a SI b) IMPLICA c) SI (d SI e) IMPLICA (d SAU e)
((a SI b) IMPLICA )c SI (d SI e): 0
(d SAU e): 0
Valoare iesire D IMPLICA C: 1
(d SAU e): 1
(d SAU e): 1
(d SAU e): 1
(d SAU e): 0
(d SAU e): 1
(d SAU e): 1
(d SAU e): 1

87
Se poate observa faptul c rezultatele sunt identice cu cele din tabele.
Vom verifica acum cu ajutorul unui program similar tautogogia numarul 7):
P ^ Q Q din tabelul de nceput al acestei lucrari.
Programul realizat este programul Binar3.
Pentru a simplifica lucrurile vom modifica fiierul binar1.ccp i-l vom salva sub
numele flogic.ccp, astfel :

PROGRAMUL flogic.ccp

/* testarea operatiilor logice */

{
char c;
if (a==0) c=1;
if ((a==1) && (b==0)) c=0;
if ((a==1) && (b==1)) c=1;
return c;

har echiv (char a,char b)
{
har c;
if (a==b) c=1;
if (a != b) c=0;
return c;
}

Dup aceasta, se creaz fiierul flogic.h cu urmatorul coninut:

extern char impl (char a,char b);
extern char echiv (char a,char b);

putem s realizm acum fiierul binar3.ccp pentru verificarea formulei P ^ Q Q:

PROGRAMUL binar3.ccp
// programul Binar3 de verificare a formulei (p SI q) IMPLICA q

#include <stdio.h>
include<conio.h>
#include<flogic.h>

void main (void)
{
unsigned char p,q,r,pas;
FILE *fisier;
isier=fopen("rezultat","w+");

88
clrscr();
for (p=0; p<=1; p++)
or (q=0; q<=1; q++)
{
r = impl((p && q),q);
printf("\n p= %d",p);
printf("\n q= %d",q);
printf("\n Rezultatul pentru (p SI q) IMPLICA q este: %d",r);
scanf("%c",pas);
fprintf(fisier,"\n p= %d",p);
fprintf(fisier,"\n q= %d",q);
fprintf(fisier,"\n Rezultatul pentru (p SI q) IMPLICA q este: %d",r);
fscanf(fisier,"%c",pas);
}
fclose(fisier);
}

Datele se afieaz pe ecran i se salveaz i n fiierul rezultat pentru a fi
accesibile mai trziu.
Dupa ce au fost create aceste fisiere se creaz proiectul cu numele binar3.prj.
Acest lucru se realizeaz prin selectarea meniului PROJECT -> OPEN PROJECT i
n fereastra care se descide se scrie numele proiectului binar3.prj.
Dup aceasta se deschide din nou meniul PROJECT i se selecteaz ADD
ITEM. n fereastra care se deschide se selecteaz binar3.ccp i flogic.ccp cu opiunea
ADD dup care se selecteaz DONE. Proiectul poate fi acum compilat i executat. La
sfrit se selecteaz opiunea CLOSE PROJECT din meniul PROJECT.
Din execuia programului se vede c formula este o tautologie:

p= 0
q= 0
Rezultatul pentru (p SI q) IMPLICA q este: 1
p= 0
q= 1
p= 1
q= 0
p= 1
q= 1

La sfrit se prezint un exemplu similar pentru formula 9) din tabelul prezentat
la nceput: (P(QR)) ((P ^ Q) R) legea importrii.

PROGRAMUL binar4.cpp

// programul Binar3 de verificare a formulei (p IMPLICA (q IMPLICA r)) IMPLICA ((p SI Q)
IMPLICA r)

89

#include <stdio.h>
#include<conio.h>
#include<flogic.h>

void main (void)
{
unsigned char p,q,r,s,pas;
FILE *fisier;
fisier=fopen("rezultat","w+");
clrscr();

for (p=0; p<=1; p++)
for (q=0; q<=1; q++)
for (r=0; r<=1; r++)
{
s=impl(impl(p,impl(q,r)) , impl(p && q, r));
printf("\n p= %d",p);
printf("\n q= %d",q);
printf("\n q= %d",r);
printf("\n Rezultatul pentru (p IMPLICA (q IMPLICA r)) IMPLICA ((p SI Q) IMPLICA r) este:
%d",s);
fprintf(fisier,"\n p= %d",p);
fprintf(fisier,"\n q= %d",q);
fprintf(fisier,"\n q= %d",r);
fprintf(fisier,"\n Rezultatul pentru (p IMPLICA (q IMPLICA r)) IMPLICA ((p SI Q) IMPLICA r) este:
%d",s);
scanf("%c",pas);
}
fclose(fisier);
}

Se observ c diferenele sunt mici fa de programul binar3.ccp i programul
binar4.cpp se poate obine din modificarea acestuia. Mai mti sa salveaz fiierul
binar3.cpp sub numele binar4.cpp prin selectarea meniului FILE -> SAVE AS.
n fiierul nou creat se adaug o nou variabil s, se modific ecuaia de calculat
corespunztor:

s=impl(impl(p,impl(q,r)) , impl(p && q, r));

i se modific mesajele de afiat. Odat terminat programul binar4.cpp se creaz
proiectul binar4.prj la fel ca mai sus i programul poate fi executat.
Din execuia programului se vede c formula (P(QR)) ((P ^ Q) R) este
de asemenea o tautologie:

p= 0
q= 0

90
q= 0
Rezultatul pentru (p IMPLICA (q IMPLICA r)) IMPLICA ((p SI Q) IMPLICA r) este: 1
p= 0
q= 0
q= 1
p= 0
q= 1
q= 0
p= 0
q= 1
q= 1
p= 1
q= 0
q= 0
p= 1
q= 0
q= 1
p= 1
q= 1
q= 0
p= 1
q= 1
q= 1

Lucrrile de laborator vor conine: schema logic sau pseudocodul
programului utilizat, rezultatele obinute n urma verificrii tuturor formulelor
prezentate la nceputul lurrii, listate conform exemplului dat n aceast lucrare de
laborator i ecuaiile formulelor incluse n program.

Laborator 4, 5, 6.
Sistem expert

Programul DIAG2.PAS este un program demonstrativ pentru utilizarea
sistemelor expert. Acest program este destinat in principal pentru nvarea modului de
definire a termenilor introdui n baza de date. Rezultatele obinute sunt n general
modeste datorit faptului c maina de inferen utilizat este extrem de simpl. Chiar i
aa se poate vedea modul de funcionare al unui sistem expert i faptul c definirea
corect a informaiei duce la rezultate bune.
De asemenea este prezentat i listingul complet al programului n aa fel nct s
se poat urmri modul de realizare al diverselor funcii program. Dei pentru sisteme

91
expert exist limbaje consacrate s-a preferat scrierea programului n PASCAL pentru
veleitile didactice ale acestuia.
Dup lansarea programului este afiat urmtorul meniu:

Acest meniu permite realizarea urmtoarelor aciuni:

nvare. Permite introducerea noiuniilor i a atributelor acestora n baza de
date. Atributele trebuie s rspund la ntrebarile: ce este noiunea la care se
refer? ce caracterizeaz noiunea? care sunt proprietile noiunii? etc. i ce
NU este noiunea la care se refer? ce NU caracterizeaz noiunea? care NU
sunt proprietile noiunii? etc. n acest fel, n baza de date, se vor forma trei
categorii de propoziii: adevrate, false i nedefinite.

Actualizare. Permite definirea atributelor nedefinite. Introducerea unui
atribut nou la o noiune, face ca acesta s fie nedefinit la toate noiunile
anterioare. Regimul actualizare permite definirea acestor atribute la toate
noiunile din baza de date.

Modificare. Permite tergerea unei noiuni, tergerea unui atribut,
modificarea valorii de adevr a atributelor existente, introducerea atributelor
noi pentru o noiune.

Consultare. Permite afiarea unei noiuni cu toate atributele asociate acesteia
adevrate i false fiind ignorate cele nedefinite.

Analiz. Opiunea permite afiarea asocierilor noiunilor pe baza atributelor
introduse. Cele trei tipuri de asocieri sunt: identitate, asemnare i diferite.
Regimul permite estimarea corectitudinii i suficienei atributelor introduse.

Estimare. Permite aflarea unei noiuni (din baza de date) pe baza atributelor
acesteia.

tergere baz de date. Permite tergerea bazei de date curente i crearea unei
baze de date complet goal. Baza de date curent are denumirea standard:
Introduceti:
I -> invatare
A -> actualizare
M -> modificare
C -> consultare
D -> analiza
E -> estimare
S -> stergere baza de date
Q -> parasire program

Introduceti optiunea: _

92
diag2.dat. Dac datele din baza de date vor fi utilizate mai trziu atunci este
necesar ca, nainte de tergerea bazei de date, s se copie baza de date
curent ntr-un fiier cu un alt nume.

Dac este prima rulare a programului sau se dorete crearea unei baze de date
noi se alege opiunea S tergere baz de date pentru iniilalizarea respectiv tergerea
bazei de date. Dup aceasta se vor introduce datele n baza de date prin selectarea
opiunii I - nvare. Dup selectarea acestei opiuni este afiat pe ecranul
monitorului:

fapt ce permite introducerea numelui unei noiuni. Din cauz c numrul de caractere
pentru o noiune este limitat, pe ecran este afiat i dimensiunea acesteia (cu linie
punctat) n aa fel nct denumirea noiunii s fie introdus corect.
Dup introducerea noiunii vor fi introduse atributele acesteia. Dac au fost
definite atribute anterior (pentru alte noiuni), atunci se va cere utilizatorului s
defineasc valoarea de adevr a acestor atribute, pentru noiunea nou introdus. Valorile
de adevr pot fi: adevrat dac atributul respectiv reprezint o caracteristic (n
general definitorie) pentru noiunea respectiv, fals dac atributul respectiv este o
caracteristic a noiunii respective dar precizeaz diferena (nendeplinirea unei
caracteristici) fa de alte noiuni i nedefinit dac atributul n discuie nu este
definitoriu pentru noiunea respectiv. Dup definirea atributelor existente n baza de
date sau atunci cnd se introduce prima noiune se va cere introducerea atributelor noi.
Atributele noi vor fi definite aici pentru noiunea n lucru i vor fi automat nedefinite
pentru celelalte noiuni din baza de date. Pentru actualizarea valorilor de adevr a
atributelor cu valoarea de adevr nedefinit pentru toate noiunile din baza de date se
utilizeaz opiunea A Actualizare dup terminarea fazei de nvare. Revenind la
faza de nvare, introducerea atributelor noi, pentru nceput se vor introduce atributele
care reprezint afirmaii legate de noiunea respectiv. Ecranul afiat este:

Urmeaz introducerea atributelor care reprezint negaii legate de noiunea
respectiv. Ecranul afiat este:

=============== INVATARE ===============

Introduceti notiunea:
|-----------------------|
_
Introduceti ce este ADEVARAT pentru notiunea TEST:
|-----------------------|
_

93

Introducerea datelor n faza de nvare este esenial pentru buna funcionare a
sistemului expert. Datorit faptului c acest program este demonstrativ, destinat
nvrii, numrul maxim al noiunilor diferite, posibil de introdus n baza de date, este
de 100 iar al atributelor de tot 100. Este limpede ca noiunile introduse trebuie s aib
atribute asemntoare i deci rezultate bune se vor obine dac se construiete o baz de
date pentru un domeniu al cunoaterii ct mai ngust. Un alt aspect este reprezentat de
alegerea atributelor i definirea corect a valorilor de adevr ale acestora. Din acest
motiv mai nti se va explica modul de stabilire a atributelor i valorilor de adevr ale
acestora.
Atributele unei noiuni, att cele care reprezint o caracteristic adevrat ct i
una fals trebuie alese astfel nct ele s reprezinte caracteristici de baz ale noiunii
alese. Aceste atribute vor trebui sa permit individualizarea noiunii respective, prin
definirea unor caracteristici proprii numai pentru acea noiune, fa de celelalte noiuni
introduse n baza de cunotiine, pe de o parte i, n acelai timp s permit asocierea
noiunilor, prin definirea unor atribute care sunt comune unei clase de noiuni dar care
individualizeaz aceast clas de celelalte din baza de noiuni, pe de alt parte.
Pentru clarificarea ideilor vom alctui o baza de date referitoare la arhitectura
calculatoarelor. Prima noiune introdus va fi cea de microprocesor. Pentru aceast
notiune se vor introduce atributele cu valoarea de adevar adevrat:

face calcul aritmetic atribut specific
face calcul logic atribut specific
achita intreruperi atribut specific
executa program atribut specific
modul master atribut de departajare
genereaza adrese atribut de departajare
comunica cu periferice atribut de departajare
trensfer blocuri date atribut de departajare
comunica cu interfetele atribut de departajare
circuit integrat atribut de departajare
pe placa de baza atribut de departajare

Primele patru atribute sunt specifice noiunii microprocesor n domeniul
cunoaterii pentru care se construiete baza de date. Ele au fost stabilite pe baza
urmtorului raionament: n mod obinuit ntr-un sistem de calcul unitatea central
(respectiv microprocesorul) este elementul care efectueaz calcule aritmetice i logice,
execut programe din memorie i achit ntreruperile. Urmtoarele atribute care sunt de
departajare trebuie sa permit gruparea noiunilor pe clase. Astfel, clasa modulelor
master este cea care poate genera adrese spre deosebire de clasa modulelor slave care nu
poate face acest lucru. De asemenea, pentru a departaja componentele interne de cele
externe calculatorului s-au introdus atributele: circuit integrat i pe placa de baza. Pentru
Introduceti ce este FALS pentru notiunea TEST:
|-----------------------|
_

94
a putea face distincia ntre interfee, periferice i celelalte elemente s-au mai introdus
atributele: transfer blocuri date, comunic cu perifericele i comunic cu interfeele.
Atributele cu valoarea de adevr fals pentru noiunea microprocesor vor fi:

modul slave atribut de departajare
dispozitiv programabil atribut de departajare
genereaza intreruperi atribut de departajare
transfer rapid date atribut de departajare
memoreaza programe atribut de departajare
introducere de date atribut de departajare
este periferic atribut de departajare
definit de capacitate atribut de departajare
dispozitiv extern atribut de departajare
electro-mecanica atribut de departajare
consola sistem atribut de departajare
utilizeaza cod ASCII atribut de departajare

Se observ c toate atributele din aceast clas sunt de departajare. n general
aici sunt mai greu de stabilit atributele specifice din cauz c este mai uor de spus ce
este un obiect dect ce nu este. Dac aceste atribute sunt suficiente pentru caracterizarea
corect a noiunii de microprocesor se va vedea mai trziu n faza de analiz i estimare.
Urmtoarea noiune definit va fi cea de memorie. Pentru aceast noiune
atributele cu valoarea de adevr adevrat vor fi:

memoreaza date atribut specific
memoreaza programe atribut specific
modul slave atribut de departajare
circuit integrat atribut de departajare
pe placa de baza atribut de departajare
definit de capacitate atribut de departajare

Pentru aceast noiune au fost stabilite numai dou atribute specifice ceea ce n
general ar trebui s fie suficient dac aceste atribute sunt proprii numai noiunii
respective. De asemenea, fiind definite atribute specifice cu valoarea de adevr adevrat
la noiunea de microprocesor acestea vor avea de regul valoarea de adevr fals pentru
noiunea de memorie i pentru toate noiunile care vor fi introduse dup aceasta. Trebuie
notat faptul c nu este o regul general ca un atribut specific unei noiuni s fie
obligatoriu fals pentru toate celelalte existnd i situaii cnd un atribut specific este
adevrat pentru mai multe noiuni (a nu se confunda cu atributele de departajare care
sunt destinate departajrii claselor de noiuni) Atributele cu valoarea de adevr fals sunt:

face calcul aritmetic atribut specific
face calcul logic atribut specific
achita intreruperi atribut specific
executa program atribut specific
genereaza adrese atribut de departajare
modul master atribut de departajare

95
comunica cu periferice atribut de departajare
dispozitiv programabil atribut de departajare
genereaza intreruperi atribut de departajare
introducere de date atribut de departajare
este periferic atribut de departajare
comunica cu interfetele atribut de departajare
dispozitiv extern atribut de departajare
electro-mecanica atribut de departajare
consola sistem atribut de departajare

Dup introducerea celei de-a doua noiuni se poate observa faptul c nu se poate
stabili uor o grani precis ntre atributele de departajare i cele specifice. Dup o
prim faz de stabilire a acestora, se vor face analize prin compararea tuturor noiunilor
care sunt caracterizate de acelai atribut, cu opiunea C consultare i clasificarea
noiunilor cu ajutorul opiunii D analiz.
n tabelul urmtor sunt prezentate urmtoarele noiuni introduse i valorile de
adevr pentru atributele acestora.

Noiune

Atribut
Interfa Modul DMA Tastur Imprimant
Face calcul aritmetic Fals Fals Fals Fals
Face calcul logic Fals Fals Fals Fals
Executa program Fals Fals Fals Adevrat
Genereaz adrese Fals Adevrat Fals Fals
Achita intreruperi Fals Fals Fals Fals
Modul master Fals Adevrat Fals Fals
Modul slave Adevrat Fals Nedefinit Nedefinit
Memoreaza date Nedefinit Fals Fals Nedefinit
Memoreaza programe Fals Fals Fals Adevrat
Definit de capacitate Fals Fals Fals Fals
Comunic cu periferice Adevrat Nedefinit Fals Fals
Dispozitiv programabil Adevrat Adevrat Fals Adevrat
Genereaz ntreruperi Adevrat Adevrat Nedefinit Nedefinit
Noiune

Atribut
Interfa Modul DMA Tastur Imprimant
Transfer blocuri date Adevrat Adevrat Fals Adevrat
Introducere de date Adevrat Adevrat Adevrat Fals
Circuit integrat Adevrat Adevrat Fals Fals
Pe placa de baz Adevrat Adevrat Fals Fals
Transfer rapid date Fals Adevrat Fals Fals
Este periferic Fals Fals Adevrat Adevrat
Comunica cu interfetele Fals Adevrat Adevrat Adevrat
Dispozitiv extern Fals Fals Adevrat Adevrat
Electro-mecanica Fals Fals Adevrat Adevrat
Consola sistem Fals Fals Adevrat Fals

96
Utilizeaz cod ASCII Nedefinit Nedefinit Adevrat Adevrat
Din inspectarea acestui tabel se observ c ponderea atributelor nedefinite este
relativ mic ceea ce este un lucru bun din cauz c acest lucru demonstreaz c s-au
ales, pe ct posibil trsturile eseniale pentru noiunile respective. Vom comenta n
continuare atributele nedefinite. Pentru interfa atributul memoreaz date are
valoarea de adevr nedefinit din cauz c marea majoritate a interfeelor pot memora
date n scopul programrii lor dar acest lucru nu este esenial n caracterizarea interfeei.
Din acest motiv, dei atributul ar putea avea n principiu valoarea adevrat el nu trebuie
s fie luat n considerare la evaluarea noiunii interfa. Acelai lucru se ntmpl cu
atributul utilizeaz cod ASCII. Unele interfee cum sunt: interfaa serial, cea paralel
sau interfaa cu tastatura utilizeaz codurile ASCII pe cnd interfaa cu monitorul, spre
exemplu, nu utilizeaz aceste coduri. Pentru c nu se poate stabili precis valoarea de
adevr a acestui atribut (care a aprut la caracterizarea noiunii tastatur) el este aici
nedefinit.
Pentru noiunea modul DMA sunt nedefinite atributele: comunic cu
periferice i utilizeaz cod ASCII. Atributul comunic cu periferice este adevrat
n sensul c modulul DMA poate comunica cu perifericele prin intermediul interfeelor.
Nefiind o caracteristic direct ea a cptat valoarea de adevr nedefinit. De asemenea
codurile ASCII pot fi utilizate n transferuri DMA dar acest situaie reprezint un caz
particular.
Noiunea tastatur are nedefinite atributele: modul slave i genereaz
ntreruperi pentru c sunt parial adevrate. Tastatura este un periferic i deci nu intr
in discuie aceast caracterizare dar ea este conectat la interfa care este un modul
slave. n acelai sens, tastatura nu poate genera direct ntreruperi dar face acest lucru
prin intermediul interfeei. Aceast discuie este valabil i pentru noiunea de
imprimant. n plus, la aceast noiune mai apare atributul memoreaz date cu
valoarea de adevr nedefinit. Majoritatea imprimantelor actuale sunt dotate cu memorie
ceea ce le face s aib o vitez de lucru crescut. Aceast proprietate nu este esenial
pentru domeniul cunoaterii (arhitectura calculatoarelor) pentru care se construiete
baza de date i deci acest atribut va avea i el valoarea de adevr nedefinit.
Dup introducerea noiunilor i a atributelor acestora, urmtoarea etap n
definitivarea bazei de cunotiine o reprezint reevaluarea atributelor cu valoarea de
adevr nedefinit, din cauz c introducerea succesiv a noiunilor duce la apariia unor
atribute noi care iniial vor fi definite automat ca avnd valoarea de adevr nedefinit
pentru toate noiunile introduse anterior. Se selecteaz opiunea A actualizare,
programul afieaz urmtorul ecran:

==================== ACTUALIZARE =====================
================ MARIME NEDEFINITA ===================

Pentru: microprocesor este ADEVARAT: memoreaza date ?
DA - D
NU - N
NU SE POATE DEFINI - I
Introduceti raspunsul (ENTER - nemodificat):
_

97

care permite (eventual) modificarea valorii de adevr a atributelor cu valoarea de adevr
nedefinit. Dac se doresc alte modificri n baza de date cum ar fi: stergerea unei
noiuni, stergerea unui atribut, schimbarea valorii de adevr a atributelor definite ca
adevrat sau fals sau introducerea unor atribute noi pentru o noiune se va utiliza
opiunea M modificare.
Dup definirea atributelor cu valoarea de adevr nedefinit este bine s se fac o
inspectare a bazei de date afind noiunile corespunztoare unui atribut cu ajutorul
opiunii C consultare din care se selecteaz opiunea C consultare dup atribute.
Rezultatele obinute pot fi spre exemplu urmtoarele:

Verificarea final a bazei de cunotiine se va face cu opiunea D analiz.
Dac asocierile fcute ntre noiuni nu sunt corecte atunci se va reveni cu modificri
asupra bazei de cunotiine prin:

reevaluarea atributelor cu valoarea de adevr nedefinit;
introducerea unor atribute noi.

n final clasificarea noiunilor poate fi conform figurii urmtoare.

==================== CONSULTARE =======================
===================== Atribute ========================

modul master este valabil pentru:

microprocesor
modul DMA

Apasati Enter pentru continuare
==================== CONSULTARE =======================
===================== Atribute ========================

modul master NU este valabil pentru:

memorie
interfata
tastatura
imprimanta

Apasati Enter pentru continuare

98

Aceast clasificare poate fi considerat mulumitoare deoarece dei o interfa
nu este identic cu un modul DMA totui ele au multe trsturi comune. Astfel, i
interfaa i modulul DMA vehiculeaz date, lucreaz cu interfeele, lanseaz ntreruperi
etc. Asemnrile sunt corecte deoarece microprocesorul i modulul DMA sunt module
master, memoria i interfaa sunt module slave iar tastatura i imprimanta sunt
dispozitive periferice. Diferenele sunt evidente i corecte.
n concluzie putem spune c dup stabilirea unui prim coninut al bazei de
cunotiine este necesar prelucrarea acesteia n scopul determinrii dac atributele
noiunilor au fost corect folosite i programul poate face distincia ntre corect ntre
noiuni. Pentru aceasta se vor folosi succesiv opiunile C Consultare, M
modificare i D analiz. Activitatea de realizare a bazei de cunotiine testarea i
corectarea acesteia este realizat n general de un expert n domeniul cunoaterii pentru
care se construiete sistemul expert asistat (eventual) de un informatician.
Dup punerea la punct a bazei de cunotiine reprezentat de baza de date
sistemul expert este pregtit pentru utilizare. Utilizarea se refer la evaluarea anumitor
noiuni n general necunoscute (diagnosticarea unor cunotiine) i introducerea
noiunilor noi care dup evaluare reprezint cunotiine valide pentru sistemul expert.
Evaluarea unei cunotiine se va face cu opiunea E estimare din meniul
principal. Utilizarea acestei opiuni se face att pentru noiuni existente n baza de date
ct i pentru noiuni noi.
Vom considera mai nti c utilizatorul are un dispozitiv periferic la care
cunoate anumite caracteristici i consult sistemul expert pentru aflarea numelui
acestuia. Presupunem cazul ipotetic cnd acest dispozitiv este o imprimant dar
utilizatorul nu tie acest lucru. Evident c acest exemplu este pur teoretic i prin
simplitatea lui permite nelegerea utilizrii sistemului expert. Se selecteaz opiunea E
estimare din meniul principal care afieaz:

Identice Asemanatoare Diferite

interfata-modul DMA microprocesor-modul DMA microprocesor-memorie
memorie-interfata microprocesor-interfata
tastatura-imprimanta microprocesor-imprimanta
memorie-modul DMA
memorie-tastatura
memorie-imprimanta
interfata-tastatura
interfata-imprimanta
modul DMA-tastatura
modul DMA-imprimanta

Apasati ENTER
_

99

n continuare este prezentat lista atributelor pentru care se solicit stabilirea unei valori
de adevr i un exemplu de valori de adevr stabilite. Trebuie observat faptul c
utilizatorul nu a stabilit corect toate valorile de adevr (prin comparare cu cele stabilita
la crearea bazei de cunotiine prezentate n tabelul de mai sus) iar pentru caracteristicile
la care nu a tiut s rspund a ales valoarea de adevr nedefinit.
Lista atributelor i a valorilor de adevr este:

Face calcul aritmetic fals
Face calcul logic fals
Genereaz adrese fals
Modul master fals
Achit ntreruperi fals
Modul slave adevrat
Memoreaz date adevrat
Execut program adevrat
Comunic cu periferic fals
Dispozitiv programabil adevrat
Genereaz ntreruperi adevrat
Transfer rapid de date adevrat
Transfer blocuri date nedefinit
Memoreaz programe adevrat
Introduce date fals
Este periferic adevrat
Comunic cu interfeele adevrat
Circuit integrat nedefinit
Pe placa de baz fals
Definit de capacitate nedefinit
Dispozitiv extern adevrat
Electro-mecanic adevrat
Consol sistem adevrat
Utilizeaz cod ASCII adevrat

Este evident faptul c n stabilirea valorilor de adevr este de preferat n primul
rnd ca valorile de adevr nedefinit s fie n numr ct mai mic. n al doilea rnd ntre o
valoare de adevr greit stabilit (cu valoarea de adevrat sau fals) i una cu valoarea de
adevr nedefinit este de preferat cea din urm. Dup introducerea valorilor de adevr
vor fi afiate urmtoarele informaii:
Introduceti valorile de adevar pentru atributele notiunii de estimat.
Atributul: face calcul aritmetic
Introduceti valoarea de adevar:
D - pentru ADEVARAT
N - pentru FALS
I - pentru NEDEFINIT
ENTER pentru a-l lasa nedefinit
_

100

care arat c noiunea cu cea mai mare probabilitate (88,89%), care are trsturile
specificate de utilizator, este cea de imprimant, ceea ce este corect. Sunt afiate toate
noiunile din baza de cunotiine cu probabilitatea asociat n aa fel nct utilizatorul s
poat alege noiunea ce rspunde cel mai bine situaiei date (n cazul probabilitilor
apropiate).
Vom considera acum c se evalueaz o noiune care nu exist n baza de
cunotiine, cea de monitor. Valorile de adevr stabilite pentru aceast noiune vor fi:

Face calcul aritmetic fals
Face calcul logic fals
Genereaz adrese fals
Modul master fals
Achit ntreruperi fals
Modul slave nedefinit
Memoreaz date fals
Execut program fals
Comunic cu periferice fals
Dispozitiv programabil fals
Genereaz ntreruperi fals
Transfer rapid de date nedefinit
Transfer blocuri date fals
Memoreaz programe fals
Introduce date fals
Este periferic adevrat
Comunic cu interfeele adevrat
Circuit integrat fals
Pe placa de baz fals
Definit de capacitate fals
Dispozitiv extern adevrat
Electro-mecanic fals
Consol sistem adevrat
Utilizeaz cod ASCII fals

De la nceput se observ c sunt puine valori de adevr adevrat ceea ce va
impune introducerea unor atribute noi. Rezultatul afiat de program va fi:
Este: imprimanta 88.89 %
Este: tastatura 68.42 %
Este: memorie 52.63 %
Este: interfata 42.11 %
Este: modul DMA 33.33 %
Este: microprocesor 15.00 %
Apasati ENTER
_

101

Acest rezultat arat c notiunea estimat este un periferic (tastatura i
imprimanta au scorurile cele mai mari) dar evident este grait evaluat pentru c tastatura
este un dispozitiv periferic de intrare iar monitorul un dispozitiv periferic de ieire. Vor
trebui introduse atribute suplimentare care s asigure diferenierea intre noiunea de
tastatur i cea de monitor. La solicitarea programului de a introduce noiunea vom
rspunde afirmativ i se va introduce noiunea de monitor deocamdat fr atribute
suplimentare. Dup aceasta selectm opiunea D analiz din meniul principal.
Rezultatul afiat va fi:

Rezultat evident inacceptabil pentru c s-ar fi putut admite eventual o identitate
(in sens larg) ntre imprimant i monitor dar n nici un caz ntre monitor i tastatur.
Acest lucru indic faptul c trebuie introduse atribute care s diferenieze n primul rnd
noiunea de tastatur de cea de monitor. Pentru aceasta selectm meniul M
modificare i din acesta introducere atribute noi. Vor fi introduse suplimentar
urmtoarele atribute pentru noiunea monitor:

Reprezentare grafic - adevrat
Reprezentare text - adevrat
Reprezentare color - adevrat
Principiu tub catodic - adevrat

Este: tastatura 85.71 %
Este: imprimanta 65.00 %
Este: memorie 55.00 %
Este: modul DMA 45.45 %
Este: interfata 45.00 %
Este: microprocesor 38.10 %
Apasati ENTER
_

tastatura-monitor memorie-interfata microprocesor-interfata
tastatura-imprimanda microprocesor-imprimanda
imprimanda-monitor microprocesor-monitor
memorie-modul DMA
memorie-tastatura
memorie-imprimanda
memorie-monitor
interfata-tastatura
interfata-imprimanda
interfata-monitor
modul DMA-tastatura
modul DMA-imprimanda
modul DMA-monitor

102
Dup aceasta se selecteaz din meniul principal opiunea A actiualizare i se
actualizeaz valoarea de adevr a axcestor atribute astfel:

- pentru noiunile de microprocesor, memorie, interfa, modul DMA i
tastatur atributele noi au valoarea de adevr: fals.
- pentru noiunea de imprimant, atributele: reprezentare grafic,
reprezentare text i reprezentare color au valoarea de adevr: adevrat
iar atributul principiu tub catodic are valoarea de adevr: fals.

n sfrit, din meniul principal se selecteaz opiunea D analiz care afieaz
urmtoarele informaii:

Rezultat considerat mulumitor i deci sistemul expert este pregtit pentru o
nou estimare.
Maina de inferen utilizat aici este ct se poate de simpl i ea se bazeaz pe
compararea propoziiilor formate cu o noiune i grupurile de atribute asociate acesteia.
Propoziiile (afirmaiile sau negaiile) adevrate sau false cu excepia celor nedefinite
sunt evaluate cu regula de inferen modus ponens: din A i (AB) rezult B. Pentru
stabilirea asocierilor ntre noiuni se folosete un principiu statistic simplu i oarecum
arbitrar care stabilete asocierea pe baza numrului de propoziii adevrate comune
celor dou noiuni comparate. n procedura Analiza din programul Diag2.pas se
poate vedea modul de implementare celor prezentate mai sus.

-------------------------------- Sursa programului Diagnostic ------------------------------------

Program Diagnostic;

{
Programul Diagnostic este un program demonstrativ pentru sisteme expert. Acest
program are mai multe regimuri:

memorie-interfata microprocesor-interfata
tastatura-imprimanta microprocesor-tastatura
tastatura-monitor microprocesor-imprimanta
imprimanta-monitor microprocesor-monitor
memorie-modul DMA
memorie-tastatura
memorie-imprimanta
memorie-monitor
interfata-tastatura
interfata-imprimanta
interfata-monitor
modul DMA-tastatura
modul DMA-imprimanta
modul DMA-monitor

Apasati ENTER

103

Invatare - care permite introducerea notiuniilor si a atributelor acestora in baza de date.
Atributele trebuie sa raspunda la intrebarile: Ce este notiunea la care se refera? Ce
caracterizeaza notiunea? Care sunt proprietatile notiunii? etc. si Ce NU este notiunea la
care se refera? Ce NU caracterizeaza notiunea? Care NU sunt proprietatile notiunii? etc.
In acest fel in baza de date se vor forma trei categorii de propozitii: adevarate, false si
nedefinite.

Actualizare care permite definirea atributelor nedefinite. Introducerea unui atribut nou la
o notiune face ca acesta sa fie nedefinit la toate notiunile anterioare. Regimul actualizare
permite defineirea acestor atribute la toate notiunile din baza de date.

Modificare care permite stergerea unei notiuni, stergerea unui atribut, modificarea valorii
de adevar a atributelor existente, introducerea atributelor noi pentru o notiune.

Consultare care permite afisarea unei notiuni cu toate atributele asociate acesteia
adevarate si false fiind ignorate cele nedefinite.

Analiza in care sunt prezentate asocierile notiunilor pe baza atributelor introduse. Cele
trei tipuri de asocieri sunt: identitate, asemanare si diferite. Regimul permite estimarea
corectitudinii si suficientei atributelor introduse.

Estimare care permite aflarea unei notiuni (din baza de date) pe baza atributelor acesteia.

Stergere baza de date in care baza de date este stearsa si se creaza una noua complet
goala.
}

uses
Crt;

const
{
Numarul maxim de notiuni sau atribute ce pot fi introduse in baza de date. Se pot
introduce DimensiuneMaximaBazaDeDate notiuni si DimensiuneMaximaBazaDeDate
atribute.
}
DimensiuneMaximaBazaDeDate=100;
{
Dimensiunea maxima a numelui unei notiuni sau a unui articol.
}
DimensiuneArticol=25;

type
{
Descrierea bazei de date a sistemului expert.
}

104
BazaDeDate_t = record
{
Baza de date cu notiuni.
}
notiuni:array[1..DimensiuneMaximaBazaDeDate] of string[DimensiuneArticol];
{
Baza de date cu atributele notiunilor.
}
atribute:array[1..DimensiuneMaximaBazaDeDate] of string[DimensiuneArticol];
{
Legaturile dintre notiuni si atribute.
Se foloseste 0 pentru FALS, 1 pentru ADEVARAT, 2 pentru NEDEFINIT pentru notiunea
respectiva.
}
legatura:array[1..DimensiuneMaximaBazaDeDate,
1..DimensiuneMaximaBazaDeDate] of byte;
ContorNotiuni:byte;
ContorAtribute:byte;
end;

var
{
Baza de date a sistemului expert.
}
BazaDeDate:BazaDeDate_t;
{
Fisierul in care se salveaza baza de date.
}
FisierBazaDeDate:file of BazaDeDate_t;
{
Optiunile introduse in program.
}
optiune:char;
{
Numarul notiunii in lucru.
}
NrNotiuneInLucru:byte;

procedure StergeEcran;
{
Procedura sterge ecranul intr-o maniera care sa nu impiedice functionarea sub
procesoarele noi.
}
var
contor1:byte;

begin
for contor1:=1 to 24 do

105
writeln;
gotoxy(1,1);
end;

procedure Dimensiune;
{
Procedura afiseaza grafic pe ecran dimensiunea maxima a sirului care poate fi introdus
pentru a permite incadrarea in dimensiunea impusa de DimensiuneArticol.
}
var
contor1:byte;
begin
write('|');
for contor1:=1 to DimensiuneArticol-2 do
write('-');
writeln('|');
end;

procedure CitescOptiune;
{
Procedura citeste optiunea si intoarce majuscula caracterului apasat.
}
begin
readln(optiune);
optiune:=upcase(optiune);
end;

procedure CitescBazaDeDate;
{
Citire baza de date din fisier in memorie.
}
begin
assign(FisierBazaDeDate,'diag2.dat');
reset(FisierBazaDeDate);
read(FisierBazaDeDate,BazaDeDate);
close(FisierBazaDeDate);
end;

procedure ScriuBazaDeDate;
{
Scriere baza de date din memorie in fisier.
}
begin
assign(FisierBazaDeDate,'diag2.dat');
rewrite(FisierBazaDeDate);
write(FisierBazaDeDate,BazaDeDate);
close(FisierBazaDeDate);
end;

106

procedure IntroducereAtributeNoi;
{
Procedura permite introducerea atributelor noi pentru o notiune.
}
var
{
Atributul introdus la un moment dat.
}
atribut:string[DimensiuneArticol];
{
Semnaleaza ca atributul care s-a introdus exista deja in baza de date.
}
ExistaAtribut:boolean;
contor1:byte;
begin
{Introducere atribut nou}
with BazaDeDate do
begin
atribut:='';
write('Introduceti afirmatii? D/N: ');
CitescOptiune;
if optiune='D' then
repeat
StergeEcran;
ExistaAtribut:=false;
writeln('Introduceti ce este ADEVARAT pentru ',
notiuni[NrNotiuneInLucru],':');
Dimensiune;
readln(atribut);
if atribut<>'' then
begin
{Verificare existenta atribut}
for contor1:=1 to ContorAtribute-1 do
if atribute[contor1]=atribut then ExistaAtribut:=true;
if ExistaAtribut then
writeln('Atributul exista!')
else
begin
atribute[ContorAtribute]:=atribut;
legatura[NrNotiuneInLucru,ContorAtribute]:=1;
inc(ContorAtribute);
end;
end;
write('Mai introduceti afirmatii? D/N: ');
CitescOptiune;
until optiune<>'D';
write('Introduceti negatii? D/N: ');

107
CitescOptiune;
if optiune='D' then
repeat
StergeEcran;
ExistaAtribut:=false;
writeln('Introduceti ce este FALS pentru '
,notiuni[NrNotiuneInLucru],':');
Dimensiune;
readln(atribut);
if atribut<>'' then
begin
{Verificare existenta atribut}
if atribute[contor1]=atribut then ExistaAtribut:=true;
if ExistaAtribut then
writeln('Atributul exista!')
else
begin
atribute[ContorAtribute]:=atribut;
legatura[NrNotiuneInLucru,ContorAtribute]:=0;
inc(ContorAtribute);
end;
end;
write('Mai introduceti negatii? D/N: ');
CitescOptiune;
until optiune<>'D';
end;
end;

procedure Invatare;
{
Procedura de completare a bazei de date cu notiuni noi.
}
var
contor1:byte;
{
Notiunea introdusa la un moment dat.
}
notiune:string[DimensiuneArticol];
{
Semnaleaza faptul ca notiunea introdusa se gaseste deja in baza de date.
}
ExistaNotiune:boolean;
begin
CitescBazaDeDate;
{Introducerea datelor in baza de date}
StergeEcran;
writeln('================================= INVATARE

108
===============================')
writeln;
writeln;
repeat
ExistaNotiune:=false;
notiune:='';
writeln('Introduceti notiunea: ');
Dimensiune;
readln(notiune);
if notiune<>'' then
begin
{Verificare existenta notiune.}
for contor1:=1 to BazaDeDate.ContorNotiuni-1 do
if BazaDeDAte.notiuni[contor1] = notiune then
ExistaNotiune:=true;
if ExistaNotiune then
writeln('Notiunea: ',notiune,' a fost introdusa!')
else
begin
with BazaDeDate do
begin
{Notiune noua - introducere atribute}
NrNotiuneInLucru:=ContorNotiuni;
{Completare atribute vechi.}
begin
writeln('Pentru: ',notiune,' este ADEVARAT:
',atribute[contor1],' ?');
writeln('DA - D');
writeln('NU - N');
writeln('NU SE POATE DEFINI - I');
write('Introduceti raspunsul: ');
CitescOptiune;
if optiune='N' then
legatura[ContorNotiuni,contor1]:=0;
if optiune='D' then
legatura[ContorNotiuni,contor1]:=1;
if optiune='I' then
legatura[ContorNotiuni,contor1]:=2
end;
write('Introduceti atribute noi? D/N: ');
CitescOptiune;
if optiune='D' then
IntroducereAtributeNoi;
end;
end;
end;
write('Introduceti o noua notiune? D/N: ');

109
CitescOptiune;
BazaDeDate.notiuni[BazaDeDate.ContorNotiuni]:=notiune;
inc(BazaDeDate.ContorNotiuni);
until optiune<>'D';
ScriuBazaDeDate;
end;

procedure Consultare;
{
Procedura de consultare a bazei de date. Permite afisarea unei notiuni cu toate atributele
asociate acesteia adevarate si false fiind ignorate cele nedefinite.
}
var
NumarNotiune, NumarAtribut, contor1:byte;
begin
CitescBazaDeDate;
NumarNotiune:=0;
NumarAtribut:=0;
repeat
StergeEcran;
writeln('================================= CONSULTARE
===============================');
writeln('Introduceti:');
writeln('N - consultare dupa notiuni');
writeln('A - consultare dupa atribute');
writeln('P - abandon');
CitescOptiune;
with BazaDeDate do
begin
case optiune of
'N':
{Consultare dupa notiuni.}
begin
StergeEcran;
===============================');
writeln('================================== Notiuni
================================');
for contor1:=1 to ContorNotiuni-1 do
begin
writeln(contor1,'. ',notiuni[contor1]);
if contor1 mod 20 = 0 then
begin
writeln;
write('Apasati ENTER pentru continuare');
readln;
StergeEcran;
writeln('=================================

110
CONSULTARE ===============================');
writeln('==================================
Notiuni ================================');
end;
end;
writeln;
readln;
StergeEcran;
===============================');
writeln('================================== Notiuni
================================');
writeln;
write('Introduceti numarul notiunii
(0 - abandon): ');
readln(NumarNotiune);
if NumarNotiune<>0 then
begin
StergeEcran;
writeln('=================================
CONSULTARE ===============================');
writeln('==================================
Notiuni ================================'); writeln;
writeln('Pentru ',notiuni[NumarNotiune],
' este ADEVARAT:');
writeln;
if legatura[NumarNotiune,contor1]=1 then
writeln(atribute[contor1]);
writeln;
writeln('Apasati Enter pentru continuare');
readln;
StergeEcran;
writeln('=================================
CONSULTARE ===============================');
writeln('==================================
Notiuni ================================');
writeln;
writeln('Pentru ',notiuni[NumarNotiune],
' NU este ADEVARAT:');
writeln;
writeln(atribute[contor1]);
writeln;
readln;

111
end;
end;
'A':
{Consultare dupa atribute.}
begin
StergeEcran;
===============================');
writeln('================================== Atribute
===============================');
begin
writeln(contor1,'. ',atribute[contor1]);
begin
writeln;
readln;
StergeEcran;
writeln('=================================
CONSULTARE ===============================');
writeln('==================================
Atribute ================================');
end;
end;
writeln;
readln;
StergeEcran;
===============================');
writeln('================================== Atribute
================================');
writeln;
write('Introduceti numarul atributului
(0 - abandon): ');
readln(NumarAtribut);
if NumarAtribut<>0 then
begin
StergeEcran;
writeln('=================================
CONSULTARE ===============================');
writeln('==================================
Atribute ================================');
writeln;
writeln(atribute[NumarAtribut],
' este valabil pentru:');

112
writeln;
if legatura[contor1,NumarAtribut]=1 then
writeln(notiuni[contor1]);
writeln;
readln;
StergeEcran;
writeln('=================================
CONSULTARE ===============================');
writeln('==================================
Atribute ================================');
writeln;
writeln(atribute[NumarAtribut],
' NU este valabil pentru:');
writeln;
if legatura[contor1,NumarAtribut]=0 then
writeln(notiuni[contor1]);
writeln;
readln;
end;
end;
end;
end;
until optiune='P';
end;

procedure StergereBazaDeDate;
{
Procedura creaza o baza de date goala pe disc.
}
begin
with BazaDeDate do
begin
for ContorNotiuni:=1 to DimensiuneMaximaBazaDeDate do
for ContorAtribute:=1 to DimensiuneMaximaBazaDeDate do
begin
notiuni[ContorNotiuni]:='';
atribute[ContorAtribute]:='';
legatura[ContorNotiuni,ContorAtribute]:=2;
end;
ContorNotiuni:=1;
ContorAtribute:=1;
end;
ScriuBazaDeDate;
end;

113

procedure Actualizare;
{
Procedura permite actualizarea atributelor introduse mai tarziu pentru notiunile introduse
mai devreme. Este posibil sa se defineasca valoarea de adevarat sau fals sau sa se lase
nedefinita.
}
var
contor1,contor2:byte;
begin
CitescBazaDeDate;
with BazaDeDate do
begin
begin
if legatura[contor2,contor1]=2 then
begin
StergeEcran;
writeln('================================= ACTUALIZARE
===============================');
writeln('============================= MARIME
NEDEFINITA ===============================');
writeln;
writeln('Pentru: ',notiuni[contor2],
' este ADEVARAT: ',atribute[contor1],' ?');
writeln('DA - D');
writeln('NU - N');
writeln('NU SE POATE DEFINI - I');
write('Introduceti raspunsul
(ENTER - nemodificat): ');
CitescOptiune;
if optiune='N' then legatura[contor2,contor1]:=0;
if optiune='D' then legatura[contor2,contor1]:=1;
if optiune='I' then legatura[contor2,contor1]:=2
end;
end;
end;
ScriuBazaDeDate;
end;

procedure Analiza;
{
Procedura analizeaza asemanarile pe baza atributelor si produce o statistica a notiunilor.
In cazul in care la una din notiuni nu este definit atributul nu se face comparatia.
}
const
{

114
Pozitia initiala pe axa y a listei afisate.
}
PozitieInitiala=3;
{
Pozitia finala pe axa y a listei afisate. Depasirea acestei pozitii duce la afisarea unui ecran
nou dupa apasarea tastei ENTER.
}
PozitieFinala=20;
var
{
Numarul de comparari efectuate pentru o notiune cu alta notiune.
}
Comparari:byte;
{
Numarul de asemanari gasite pentru doua notiuni comparate.
}
Asemanari:byte;
contor1,contor2,contor3:byte;
{
Cele trei pozitii curente pe axa y corespunzatoare celor trei liste afisate: Identitate,
Asemanare si Diferit.
}
pozitie1,pozitie2,pozitie3:byte;
begin
Comparari:=0;
Asemanari:=0;
CitescBazaDeDate;
pozitie1:=PozitieInitiala;
StergeEcran;
gotoxy(1,1);
write('Identice');
gotoxy(DimensiuneArticol+2,1);
write('Asemanatoare');
gotoxy(2*DimensiuneArticol+4,1);
write('Diferite');
{Incepe compararea notiunilor doua cate doua}
with BazaDeDate do
begin
begin
for contor2:=contor1+1 to ContorNotiuni-1 do
begin
Comparari:=0;
Asemanari:=0;
begin

115
if (legatura[contor1,contor3]<>2) and
(legatura[contor2,contor3]<>2) then
begin
if legatura[contor1,contor3]=
legatura[contor2,contor3] then inc(Asemanari);
inc(Comparari);
end;
end;
{Criteriul pentru notiuni identice}
if Asemanari >= (Comparari * 4 div 5) then
begin
gotoxy(1,pozitie1);
write(notiuni[contor1],'-',notiuni[contor2]);
inc(pozitie1);
{S-a depasit un ecran de afisare}
if pozitie1>PozitieFinala then
begin
writeln('Apasati ENTER.');
readln;
StergeEcran;
end;
end
else
begin
{Criteriul pentru notiuni asemanatoare}
if (Asemanari < (Comparari * 4 div 5)) and
(Asemanari >= (Comparari * 2 div 3))then
begin
gotoxy(DimensiuneArticol+2,pozitie2);
write(notiuni[contor1],
'-',notiuni[contor2]);
inc(pozitie2);
begin
readln;
StergeEcran;
end;
end
else
{Criteriul pentru notiuni diferite}
if (Asemanari < (Comparari * 2 div 3)) and
(Asemanari >= (Comparari div 3)) then
begin
gotoxy(2*DimensiuneArticol+4,pozitie3);

116
write(notiuni[contor1],
'-',notiuni[contor2]);
inc(pozitie3);
begin
readln;
StergeEcran;
end;
end;
end;
end;
end;
gotoxy(1,23);
writeln('Apasati ENTER');
readln;
end;
end;

procedure AfisareNotiuni;
{
Procedura permite afisarea tuturor notiunilor din baza de date.
}
var
contor1:byte;
begin
with BazaDeDate do
begin
begin
writeln(contor1,'. ',notiuni[contor1]);
begin
writeln;
readln;
StergeEcran;
end;
end;
end;
writeln;
readln;
StergeEcran;
end;

117
procedure AfisareAtribute;
{
Procedura afiseaza toate atributele din baza de date.
}
var
contor1:byte;
begin
with BazaDeDate do
begin
StergeEcran;
begin
writeln(contor1,'. ',atribute[contor1]);
begin
writeln;
readln;
StergeEcran;
end;
end;
writeln;
readln;
StergeEcran;
end;
end;

procedure Modificare;
{
Procedura permite stergerea notiunilor si a atributelor, de asemenea permite modificarea
valorilor de adevar a atributelor unei notiuni la alegere sau introducerea atributelor noi.
}
var
{
Numarul notiunii in lucru.
}
NumarNotiune:byte;
begin
CitescBazaDeDate;
NumarNotiune:=0;
with BazaDeDate do
begin
StergeEcran;
write('Stergeti notiune? D/N: ');
CitescOptiune;

118
if optiune='D' then
begin
AfisareNotiuni;
write('Introduceti numarul notiunii (0 - abandon): ');
begin
for contor1:=NumarNotiune to ContorNotiuni-1 do
begin
notiuni[contor1]:=notiuni[contor1+1];
legatura[contor1]:=legatura[contor1+1];
end;
ContorNotiuni:=ContorNotiuni-1;
end;
end;
StergeEcran;
write('Stergeti atribute? D/N: ');
CitescOptiune;
if optiune='D' then
begin
AfisareAtribute;
write('Introduceti numarul atributului (0 - abandon): ');
begin
for contor1:=NumarNotiune to ContorAtribute-1 do
atribute[contor1]:=atribute[contor1+1];
for contor1:=NumarNotiune to ContorAtribute-1 do
legatura[contor2,contor1]:=legatura[contor2,contor1+1];
ContorAtribute:=ContorAtribute-1;
end;
end;
StergeEcran;
write('Modificati caracteristica atribut? D/N: ');
CitescOptiune;
if optiune='D' then
begin
AfisareNotiuni;
begin
StergeEcran;
writeln('Modificare atributele notiunii: ',
notiuni[NumarNotiune],' :');
begin

119
write('Atributul: ',atribute[contor1],' este: ');
writeln('FALS');
writeln('ADEVARAT');
writeln('NEDEFINIT');
writeln('Introduceti noua valoare de adevar: ');
writeln('D - pentru ADEVARAT');
writeln('N - pentru FALS');
writeln('I - pentru NEDEFINIT');
writeln('ENTER pentru a-l lasa neschimbat');
CitescOptiune;
if optiune='N' then
legatura[NumarNotiune,contor1]:=0;
if optiune='D' then
if optiune='I' then
end;
end;
end;
StergeEcran;
write('Introduceti atribute noi? D/N: ');
CitescOptiune;
if optiune='D' then
begin
AfisareNotiuni;
begin
StergeEcran;
NrNotiuneInLucru:=NumarNotiune;
IntroducereAtributeNoi;
end;
end;
end;
ScriuBazaDeDate;
end;

procedure Estimare;
{
Procedura estimeaza o notiune noua (necunoscuta) pe baza atributelor existente in baza
de date. La sfarsit daca este o notiune noua ea poate fi introdusa in baza de date cu
valorile de adevar pentru atributele existente. Daca se doreste introducerea atributelor noi
atunci se apeleaza meniul Modificare.
}

120
var
{
Modelul valorilor atributelor notiunii de estimat.
}
model:array[1..DimensiuneMaximaBazaDeDate] of byte;
{
Contorizeaza numarul de potriviri dintre notiunea de estimat si cele
existente in baza de date.
}
NumarPotriviri:array[1..DimensiuneMaximaBazaDeDate] of byte;
{
Contorizeaza numarul de comparari (exceptand atributele nedefinite) efectuate intre
notiunea de estimat si o notiune din baza de date.
}
NumarComparari:array[1..DimensiuneMaximaBazaDeDate] of byte;
{Numarul maxim de potriviri intre notiunea de estimat si una dintre notiunile din baza de
date la un moment dat.
}
Maxim:byte;
{
Pozitia unei notiuni cu care se lucreaza la un moment dat in baza de date.
}
Pozitie:byte;
{
Numele notiunii noi
}
Notiune:string[DimensiuneArticol];
begin
CitescBazaDeDate;
for contor1:=1 to DimensiuneMaximaBazaDeDate do
begin
model[contor1]:=2;
NumarPotriviri[contor1]:=0;
end;
Notiune:='';
StergeEcran;
with BazaDeDate do
begin
writeln('Introduceti valorile de adevar pentru atributele
notiunii de estimat.');
begin
writeln('Atributul: ',atribute[contor1]);
writeln('Introduceti valoarea de adevar: ');
writeln('D - pentru ADEVARAT');
writeln('N - pentru FALS');
writeln('I - pentru NEDEFINIT');

121
writeln('ENTER pentru a-l lasa nedefinit');
CitescOptiune;
if optiune='N' then model[contor1]:=0;
if optiune='D' then model[contor1]:=1;
if optiune='I' then model[contor1]:=2;
end;
for contor1:=1 to DimensiuneMaximaBazaDeDate do
NumarComparari[contor1]:=0;
if (legatura[contor1,contor2]<>2) and (model[contor2]<>2) then
begin
if legatura[contor1,contor2]=model[contor2] then
inc(NumarPotriviri[contor1]);
inc(NumarComparari[contor1]);
end;
{
Afisare rezultat.
}
StergeEcran;
begin
Maxim:=0;
Pozitie:=0;
if NumarPotriviri[contor1]>Maxim then
begin
Maxim:=NumarPotriviri[contor1];
Pozitie:=contor1;
end;
if Pozitie<>0 then
begin
writeln('Este: ',notiuni[Pozitie],' ',
Maxim/NumarComparari[Pozitie]*100:2:2,' %');
NumarPotriviri[Pozitie]:=0;
end;
end;
writeln('Apasati ENTER');
readln;
write('Introduceti noua notiune? D/N: ');
CitescOptiune;
if optiune='D' then
begin
write('Introduceti notiunea: ');
readln(Notiune);
if Notiune<>'' then
begin
notiuni[ContorNotiuni]:=Notiune;

122
legatura[ContorNotiuni,contor1]:=Model[contor1];
inc(ContorNotiuni);
end;
ScriuBazaDeDate;
end;
end;
end;

{
Program principal.
Optiunile sunt:
Invatare - in acest regim se pot introduce notiuni noi.
Pentru atributele existente se cer valori de adevar
(ADEVARAT, FALS, NEDEFINIT) dupa care se permite
introducerea unor atribute noi.
Actualizare - pentru toate notiunile se reiau atributele
nedefinite
si se cere precizarea acestora. Acest lucru deoarece
la introducerea unei notiuni pot aparea atribute noi
care
nu au fost definiti la notiunile anterioare.
Modificare - Permite modificarea valorii de adevar a tuturor
atributelor
de la o notiune. Dupa aceea se pot introduce
atribute noi.
Consultare - Se pot afisa atributele unei notiuni sau notiunile
unui atribut.
Analiza - Permite aflarea notiunilor identice, asemanatoare
sau diferite.
Stergere
baza de date - Baza de date este initializata
}
begin
repeat
StergeEcran;
writeln('Introduceti:');
writeln('I -> invatare');
writeln('A -> actualizare');
writeln('M -> modificare');
writeln('C -> consultare');
writeln('D -> analiza');
writeln('E -> estimare');
writeln('S -> stergere baza de date');
writeln('Q -> parasire program');
writeln;
write('Introduceti optiunea: ');

123
CitescOptiune;
case optiune of
'I': Invatare;
'A': Actualizare;
'M': Modificare;
'C': Consultare;
'D': Analiza;
'E': Estimare;
'S': StergereBazaDeDate;
end;
until optiune='Q';
end.

n lucrarea de laborator studenii vor efectua urmtoarele activiti:

1. Se vor familiariza cu modul de funcionare al programului Diagnostic
nsuindu-i meniul acestuia, modul de aciune al fiecrei comenzi i
opiunile de lucru.
2. Vor lucra pe o baz de date deja definit (Arhitectura calculatoarelor),
condorm celor artate n exemplul prezentat, vor verifica modul de
evaluare a noiunilor deja definite i vor introduce noiuni noi.
3. Vor crea o baz de date nou, ntr-un domeniu ales i n final vor verifica
baza de date pentru noiunile deja introduse i pentru noiuni noi.

Lucrrile de laborator vor conine meniul programului Diagnostic cu
explicaii privind modul de funcionare a acestora, modul n care a fost verificat o
noiune existent i una nou introdus conform exemplului artat n aceast
lucrare de laborator. La baza de date nou creat se va pune n referatul de
laborator tabelul afiat de comanda D analiz din meniul principal.

Laborator 7, 8, 9.
Perceptronul

Perceptronul cu un singur strat este cea mai simpl reea neural. Modelul
perceptronului este smburele din care s-au dezvoltat toate celelalte reele neurale.
Instruirea perceptronului se face cu ajutorul unui algoritm simplu i eficient
reprezentativ pentru o clas larg de algoritmi de instruire.
Programul PERCEPT1.PAS realizeaz modelarea perceptronului cu un singur
strat cu n intrri. Pentru exemplificare se utilizeaza perceptronul cu dou intrri instruit
s separe punctele dintr-un plan. Programul este destinat nvrii modului de
funcionare a perceptronului, modul de instruire a acestuia i limitele acestuia. De
asemenea este prezentat lista codului programului scris n limbaj de programare
PASCAL pentru nelegerea modului de implementare a perceptronului, a tehnicii de
instruire i utilizarea perceptronului.
Perceptronul cu un singur strat cu dou intrri este prezentat n figura urmtoare:

124

Valoarea ieirii perceptronului se calculeaz n felul urmtor. Se calculeaza
suma ponderat a intrrilor dup relaia:

2 2 1 1
x w x w y + =

n care w
1
, w
2
reprezint valorile ponderilor intrrilor perceptronului. Dup aceasta se
calculeaz valoarea ieirii perceptronului dup regula:

>
<
=
t y daca
t y daca
f
1
0

unde t este valoarea pragului perceptronului.
Pentru antrenarea perceptronului se aplic la intrare mai multe seturi de date la
care este cunoscut valoarea ateptat a ieirii. n funcie de rezultatul obinut la ieirea
perceptronului, sunt modificate ponderile w
1
, w
2
i valoarea de prag t dup un anumit
algoritm, n aa fel nct rspunsul perceptronului sa corespund cu rspunsul ateptat.
Seturile de date utilizate pentru nvare (antrenarea perceptronului) se numesc forme
cheie i ele sunt alctuite din mulimea vectorilor de intrare i mulimea vectorilor de
ieire ateptai ca rspuns ai perceptronului pentru vectorii de intrare dai. Pentru
programul prezentat n continuare formele cheie sunt alctuite din vectorul de intrare
(Intrare) ce conine un anumit numar de seturi de date de intrare i vectorul int
(Tinta) care conine rspunsul ateptat de la perceptron pentru un anumit set de date.
Trebuie de notat faptul c modificarea ponderilor intrrilor i a valorii de prag se
face numai pe durata nvrii perceptronului. Daca procesul de nvare a reuit atunci
valorile ponderilor i a pragului rmn fixate si perceptronul poate fi utilizat la
evaluarea datelor pentru care ieirea (rezultatul evalurii) este necunoscut.
Programul Perceptron1 prezentat n continuare are vectorul de intrare de
dimensiunea n x m unde n reprezinta numrul seturilor de date prezentate la intrare, n
exemplul prezentat acesta fiind de patru iar m reprezint numrul intrrilor
perceptronului (n numar de dou n acest exemplu).
Utilizarea perceptronului cu dou intrri prezint avantajul posibilitii
reprezentrii grafice a datelor de intrare i a rezultatelor obinute. Astfel un set de date
poate fi reprezentat n plan asociind intrrii 1 a perceptronului coordonata x iar intrrii 2
coordonata y. n acest fel cele patru seturi de date de intrare, propuse pentru test n
program, n scopul antrenrii perceptronului vor putea fi reprezentate n plan conform
figurii de mai jos.
y=w
1
x
1
+
+w
2
x
2

f=y(t)
f
w
1
w
2
x
1
x
2
t

125

n figur, setul valorilor de intrare pentru care vectorul int are valoarea unu
sunt reprezentate cu + iar cele pentru care vectorul int are valoarea zero sunt
reprezentate cu o. n aceasta situaie, nvarea perceptronului reprezinta de fapt
determinarea unei drepte care sa separe planul n dou pri, fiecare parte a planului
trebuind s conin numai punctele de acelai fel. In acest fel relaia:

2 2 1 1
x w x w y + =

poate fi transformat n:

0
2 1
= + t y w x w

ce reprezint ecuaia dreptei de separaie. Este limpede faptul ca perceptronul nu poate
separa dect puncte (n plan sau hiperplan) liniar separabile. n cazul n care
configuraia punctelor este mai complicat i acestea nu sunt liniar separabile se vor
utiliza reele neuronale cu mai multe straturi.
Algoritmul de nvare utilizat pentru perceptron n acest program este
urmtorul:

1. se calculeaz un vector de ieire pentru cele patru seturi de date de intrare
utilizate la instruire;
2. se compara vectorul de ieire calculat la punctul 1 cu vectorul int;
3. dac cei doi vectori sunt diferii atunci se modific ponderile i pragul astfel:

w = w + dw
t = t + dt

unde dw i dt sunt valori adugate la vechea pondere, respectiv prag.
Aceste valori se calculeaza astfel:

126

dW = I x (T - O)
T

) O T ( dt
=

unde dW este vectorul coloana cu dou elemente al valorilor cu care se
modific ponderea pe intrarea 1 respectiv 2, I este matricea de 2 x 4
elemente a seturilor de date de intrare, T este vectorul int cu 4 elemente
iar O este vectorul de ieire cu 4 elemente.
Dupa calculul noilor ponderi i al pragului algoritmul este reluat de la
punctul 1.
4. Dac vectorul de ieire coincide cu vectorul int atunci instruirea
perceptronului se consider ncheiat.

Acest algoritm nu se va ncheia intotdeauna. Din acest moiv se stabileste un
anumit numr de pai limit care vor fi efectuai. Dac instruirea nu se termin dup
numrul de pai impus, se consider nvarea perceptronului euat.
Poziia iniial a dreptei ce corespunde valorilor de test pentru ponderi i prag,
fa de punctele de instruire este prezentat n figura urmtoare.

Pentru datele de test propuse n program algoritmul se ncheie i programul
afieaz urmtorul mesaj:

127

Reprezentarea grafic a rezultatului obinut este prezentat n figura urmtoare.

Din aceast reprezentare grafic se observ modul n care este separat planul n
cele dou regiuni. Dup instruire perceptronul este capabil s clasifice puntele din plan.
Se propune ca exerciiu s se completeze programul n aa fel nct utilizatorul, dup
faza de instruire, s poat introduce valorile punctelor de intrare i s primesac ca
rspuns evaluarea acestora de ctre perceptronul cu un strat.

---------------------------- Sursa programului Perceptron1 ------------------------------------

Program perceptron1;

{
Programul implementeaza in Pascal perceptronul cu doua intrari.
=============== REZULTAT ===================

Procesul de invatare a reusit.
Invatarea s-a facut in 4 pasi.

Ponderile obtinute sunt:
- ponderea intrarii 1: -2.6161
- ponderea intrarii 2: -0.6922

Pragul obtinut: -0.1680

Apasati tasta ENTER.

128
Este vorba de o retea cu un singur strat realizata cu un perceptron cu doua intrari instruita
sa separe valorile dintr-un plan (care sunt liniar separabile).
}

const
{
Numarul seturilor de date (asocieri) folosite pentru instruirea
perceptronului.
}
NrSeturiDate=4;

type
{
Vectorul de lucru - dimensiunea lui este data de numarul de date de intrare folosite pentru
instruirea perceptronului.
}
VectorDate_t=array[1..NrSeturiDate] of real;

var
{
Forma cheie.
Vectorul datelor de intrare pentru instruire; acest vector contine
NrSeturiDate seturi de date pentru cele 2 intrari ale perceptronului;
primul indice se refera la numarul intrarii iar cel de-al doilea la numarul lotului de date
prezentat la intrarea perceptronului.
De exemplu pentru o matrice de forma:

[a11 a12 a13 a14]
[a21 a22 a23 a24]

la un moment dat la intrarea perceptronului vor fi datele:

a13 (intrare 1) \
O- iesire perceptron
a23 (intrare 2) /
}
Intrare:array[1..2] of VectorDate_t;
{
Vectorul datelor de iesire. Aceste date reprezinta iesirea perceptronului pentru fiecare set
de date de intrare, calculata cu algoritmul:

yi = a1i*w1+a2iw2 unde a1i, a2i, i=1 ... NrSeturiDate sunt
intrarile pentru lotul i, iar w1 si w2 sunt ponderile celor
2 intrari

daca yi<-t atunci iesirea este egala cu zero
daca yi>-t atunci iesirea este egala cu unu
}

129
Iesire:VectorDate_t;
{
Forma asociata.
Vectorul tinta care contine rezultatele asteptate de la perceptron pentru setul de date
furnizat.
}
Tinta:VectorDate_t;
{
Ponderile pe cele doua intrari ale perceptronului.
}
Pondere:array[1..2] of real;
{
Valoarea de prag pentru perceptron.
}
Prag:real;
{
Numarul maxim de pasi efectuati pentru instruirea perceptronului.
Daca instruirea nu se termina inainte de acest numar de pasi se considera instruirea
esuata.
}
NumarMaximPasi:integer;
{
Variabila invatare arata daca procesul de invatare a perceptronului a
reusit sau nu. Invatare=FALSE daca procesul de invatare nu a reusit si TRUE in caz
contrar.
}
Invatare:boolean;
{
Variabila pentru contorizarea pasilor facuti pentru instruirea perceptronului.
}
ContorPasi:integer;

procedure StergeEcran;
{
Procedura sterge ecranul intr-o maniera care sa nu impiedice functionarea sub
procesoarele noi.
}
var
contor1:byte;

begin
writeln;
end;

procedure IntroducereDate;
{Procedura IntroducereDate solicita utilizatorului introducerea urmatoarelor date:

130
- datele de intrare pentru antrenarea perceptronului
- vectorul tinta
- ponderile initiale
- pragul initial
- numarul maxim de pasi de efectuat pentru instruire
Se lucreaza cu variabilele globale ale programului.
}
var
begin
Writeln('Introduceti datele de intrare pentru instruirea
perceptronului.');
Writeln('Aceste date se introduc perechi, mai intai pentru intrarea 1 si');
Writeln('apoi pentru intrarea 2. Numarul total de perechi este: ',
NrSeturiDate);
Writeln('Pentru test se propune setul de date:');
Writeln(' 1 2 3 4');
Writeln(' intrare 1: -0.5 -0.5 +0.3 +0.0');
Writeln(' intrare 2: -0.5 +0.5 -0.5 +1.0');
Writeln;
for contor1:=1 to NrSeturiDate do
begin
Write('Introduceti data ',contor1,' pentru intrarea ',
contor2,': ');
Readln(Intrare[contor2,contor1]);
end;
Writeln('Datele introduse sunt:');
begin
Write(' intrarea ',contor2,': ');
begin
Write(Intrare[contor2,contor1]:3:3,' ');
end;
Writeln;
end;
Writeln;
Writeln('Introduceti datele tinta. Aceste date se introduc in aceeasi
ordine');
Writeln('ca si datele vectorului de intrare.');
Writeln('Pentru datele de intrare propuse ca test se propune
urmatorul');
Writeln('vector tinta:');
Writeln(' Setul de date: 1 2 3 4');
Writeln(' Iesire perceptron: 1 1 0 0');
Writeln;

131
begin
Write('Introduceti valoarea iesirii perceptronului pentru
setul ',contor1,' de date: ');
Readln(Tinta[contor1]);
end;
Writeln;
Writeln('Introduceti ponderile intrarilor.');
Writeln('Pentru datele propuse ca test se propun urmatoarele
ponderi:');
Writeln(' pondere intrare 1: -0.8161');
Writeln(' pondere intrare 2: +0.3078');
Writeln;
begin
Write('Introduceti ponderea pentru intrarea ',contor1,': ');
Readln(Pondere[contor1]);
end;
Writeln;
Writeln('Introduceti valoarea de prag pentru perceptron.');
Writeln('Pentru datele de test propuse, valoarea de prag este: -
0.1680');
Write('Introduceti valoarea de prag: ');
Readln(Prag);
Writeln;
Writeln('Introduceti numarul maxim de pasi pentru instruire.');
Writeln('Pentru datele de test propuse, numarul maxim de pasi este:
20');
Write('Introduceti numarul maxim de pasi: ');
Readln(NumarMaximPasi);
Writeln;
Writeln('Datele de intrare au fost introduse. Apasati tasta ENTER.');
Readln;
end;

procedure InmultireMatrici;
{
Procedura inmulteste matricea Intrare cu vectorul Ponderi, rezultatul fiind depus in
matricea Iesire.
}
var
begin
iesire[contor1]:=0;
iesire[contor1]:=iesire[contor1]+intrare[contor2,contor1]*
pondere[contor2];

132
end;

procedure CalculVectorIesire;
{
Procedura calculeaza vectorul de iesire dupa urmatorul algoritm:
yi = a1i*w1+a2iw2 unde a1i, a2i, i=1 ... NrSeturiDate sunt
intrarile pentru lotul i, iar w1 si w2 sunt ponderile
celor 2 intrari

daca yi<-t atunci iesirea este egala cu zero
daca yi>-t atunci iesirea este egala cu unu

Pentru efectuarea acestui calcul se apeleaza procedura de inmultire a doua matrici
InmultireMatrici.
}
var
contor1:byte;
begin
InmultireMatrici;
if Iesire[contor1] >= -Prag then Iesire[contor1]:=1 else
Iesire[contor1]:=0;
end;

procedure TestTerminareInvatare;
{
Testul de terminare a invatarii compara vectorul Iesire cu vectorul Tinta.
Daca cei doi vectori sunt egali, element cu element atunci procesul de invatare s-a
incheiat. Terminarea procesului de invatare este semnalata prin variabila logica Invatare
care capata valoarea logica TRUE.
}
var
contor1:byte;
begin
if Tinta[contor1]=Iesire[contor1] then Invatare:=true else
begin
Invatare:=false;
exit;
end;
end;

procedure ModificarePonderi;
{
Procedura modifica ponderile intrarilor perceptronului si a valoarea de prag.
Pentru modificarea ponderilor intrarilor se utilizeaza relatia:
intrarea 1 Pondere(1) = Pondere(1) +
+ a11*(tinta(1)-iesire(1)) +

133
+ a13*(tinta(3)-iesire(3)) + ...
intrarea 2 Pondere(2) = Pondere(2)
+ a23*(tinta(3)-iesire(3)) + ...
unde aij sunt datele de intrare.
prag = prag +
+ tinta(1)-iesire(1) +
+ tinta(2)-iesire(2) +
+ tinta(3)-iesire(3) + ...
}
var
begin
Pondere[contor1]:=Pondere[contor1]+Intrare[contor1,contor2]*
(Tinta[contor2] - Iesire[contor2]);
Prag:=Prag+(Tinta[contor1] - Iesire[contor1]);
end;

{
Programul principal
}
begin
Invatare:=false;
ContorPasi:=0;
StergeEcran;
IntroducereDate;
repeat
CalculVectorIesire;
TestTerminareInvatare;
if not(Invatare) then
begin
ModificarePonderi;
Inc(ContorPasi);
end;
until (ContorPasi > NumarMaximPasi) or Invatare;
StergeEcran;
Writeln('=============== REZULTAT ===================');
Writeln;
Writeln;
if Invatare then
begin
Writeln('Procesul de invatare a reusit.');
Writeln('Invatarea s-a facut in ',ContorPasi,' pasi.');

134
Writeln;
Writeln('Ponderile obtinute sunt:');
Writeln(' - ponderea intrarii 1: ',Pondere[1]:3:4);
Writeln(' - ponderea intrarii 2: ',Pondere[2]:3:4);
Writeln;
Writeln('Pragul obtinut: ',Prag:3:4);
Writeln;
end
else
begin
Writeln;
Writeln('Invatarea a esuat.');
Writeln;
end;
Writeln('Apasati tasta ENTER.');
Readln;
end.

n lucrarea de laborator studenii vor efectua urmtoarele activiti:

1. Realizarea schemei logice sau pseudocodul algoritmului de instruire a
perceptronului pe baza descrierii din referatul de laborator i a
programului.
2. Execuia programului pentru valorile furnizate ca exemplu i explicarea
modului n care s-a obinut rezultatul.
3. Introducerea unor valori iniiale diferite de cele de exemplu, inclusiv valori
limita de tipul 0, 0, 0, sau 1, 1, 1, i explicarea celor constatate.
4. Realizarea unui tabel cu numrul de pai necesari instruirii perceptronului
n funcie de valorile alese.

Lucrarile de laborator vor conine: descrierea algoritmului de instruire
realizat cu ajutorul schemelor logice sau a pseudocodului, modelul perceptronului
instruit cu valorile obinute pentru ponderi i valorile de prag, realizarea unei
reele nurale pentru mprirea planului n trei domenii neconexe.

Laborator 10, 11, 12, 13, 14.

Lucrul cu mediul CLIPS

Activitatea 1.
S se realizeze un program n CLIPS care s gseasc toate aranjamentele
posibile a patru culori (rosu, albastru, galben, verde) luate cte trei.

Rezolvare
Rezolvarea acestei probleme cu ajutorul limbajelor procedurale cunoscute
(Pascal, C, Java etc.) presupune realizarea unui program relativ complex. Avantajul
limbajului CLIPS const n motorul de inferen bazat pe un algoritm foarte performant.

135
Din acest motiv sintaxa acestuia permite definirea foarte succint a unor cutri dup
modele foarte complexe. Un exemplu l constituie i problema de fa.
Programul pentru rezolvarea problemei se scrie cu ajutorul unui editor de text
(eventual cel oferit de mediul de programare CLIPS) i se scrie pe disc n directorul:
C\CLIPS\PROG cu numele ex1.clp.
Coninutul fiierului este:
(deffacts obiecte
(obiect rosu)
(obiect galben)
(obiect albastru)
(obiect verde)
)
(defrule aranjamente
(obiect ?o1)
(obiect ?o2 &~?o1)
(obiect ?o3 &~?o2 &~?o1)
=>
(printout t "(" ?o1 " " ?o2 " " ?o3 ")" crlf)
)
Dup ce programul a fost scris, se ncarc n mediul de programare CLIPS:
CLIPS> (load c:\\clips\\prog\\ex1.clp)
i dup ce se apas tasta ENTER, programul afieaz:
Defining deffacts: obiecte
Defining defrule: aranjamente +j+j+j
TRUE
Ceea ce semnific faptul c programul s-a ncrcat cu succes.
Lansarea n execuie se face astfel:
CLIPS> (reset)
CLIPS> (run)
Programul afieaz rezultatul execuiei, aranjamentele posibile a patru culori n grupe de
cte trei, ca n figura de mai jos:

Referatele de laborator vor conine:
- explicarea sintaxei i a rolului
constructorului defrule;
- explicarea sintaxei i a rolului comenzii
printout;
- explicarea modului de definire a
constructorului defrule pentru gsirea
aranjamentelor posibile;
- explicarea modului de definire a
comenzii printout pentru afiarea
aranjamentelor;
- listingul programului i rezultatele
obinute.
Not: explicaiile se vor baza pe materialul
prezentat n curs (pag. 27-51) i pe informaiile
luate din reeaua Internet (cu specificarea sursei).

136
Activitatea 2.
S se iniializeze o baz de cunotine cu numele i prenumele unor persoane,
apoi s se afieze persoanele cu un anumit nume de familie.

Rezolvare:
Se editeaz programul cu ajutorul editorului CLIPS (File -> New) sau cu un alt
editor de text.
Se definete structura (template-ul) pentru persoan:
(deftemplate persoana
(slot nume)
(slot prenume)
)
Se iniializeaz baza de cunotine (se introduc datele iniiale ale problemei):
(deffacts init
(persoana (nume Popescu) (prenume Ion))
(persoana (nume Ionescu) (prenume Vasile))
(persoana (nume Pop) (prenume Carmen))
Se definete regula pentru afiarea persoanelor cu numele dorit:
(defrule Popescu
(persoana (nume Popescu) (prenume ?p))
=>
(printout t ?p " Popescu " crlf)
)
Se salveaz fiierul cu numele ex2.clp n directorul C\CLIPS\PROG.
Comenzile pentru ncrcarea i execuia programului:
CLIPS> (clear)
se terg eventualele fapte din execuiile anterioare
CLIPS> (load c:\\clips\\prog\\ex2.clp)
se ncarc programul
CLIPS> (reset)
se activeaz faptele iniiale i regulile corespunztoare pentru nceperea execuiei
CLIPS> (run)
se lanseaz n execuie.

Referatele de laborator vor conine explicarea programului, introducerea
nc unui nume de persoana Popescu, modul de modificare pentru cutarea
numelui altei persoane, introducerea interactiv a numelui i listingul
programului.

Activitatea 3.
S se realizeze o stiv cu operaiile elementare cunoscute (push = depunere n
stiv, pop = extragere din stiva, top = afiarea vrfului stivei).

Rezolvare
Listingul programului este:
(deffacts init
(push 5)
(pop)

137
(push abc)
(push 12)
(top)
(pop)
(top)
)
(defrule stack_init
; nu avem nicio conditie LHS (Left-Hand Side); regula se executa la inceputul
;programului
=>
; se initializeaza stiva cu un fapt vid
; celelalte reguli nu se vor aprinde decit daca exista un fapt stack
(assert (stack))
)
(defrule stack_push
?f1 <- (push ?element)
?f2 <- (stack $?stacklist)
=>
; o regula se aplica o singura data pentru aceeasi conditie
; in acest caz se sterge f1 pentru ca se schimba f2 si deci se schimba LHS ca intreg
(retract ?f1 ?f2)
; se introduce elementul in stiva
(assert (stack ?element $?stacklist))
(printout t "Push: " ?element crlf)
)
(defrule stack_pop
?f1 <- (pop)
?f2 <- (stack ?element $?stacklist)
=>
(retract ?f1 ?f2)

; se scoate elementul din stiva
(assert (stack $?stacklist))
(printout t "Pop: " ?element crlf)
)

(defrule stack_top
(top)
(stack ?element $?stacklist)
=>
(printout t "Top: " ?element crlf)
; aici nu avem nevoie sa stergem fapte, LHS ramine neschimbata
)

Not: dei faptele sunt definite ntr-o anumit ordine: push, pop, push, top, pop, top),
execuia programului nu ine seama de aceasta ordine:
Push: 5
Push: abc

138
Push: 12
Pop: 12
Top: abc

De asemenea, pop i top se execut o singur dat deoarece CLIPS admite numai fapte
unice n lista de fapte.

Lucrarile de laborator vor conine: listingul programului, explicarea
programului, rezultatele afiate. Se va arta de asemenea, considernd listingul
prezentat aici, cum se poate face ca pop i top s se execute de mai multe ori. Se vor
face propuneri de mbunataire a programului.

Activitatea 4.
S se realizeze un program CLIPS care s permit identificarea unei cri ntr-o
bibliotec.

Rezolvare
Indicaie:
Se va folosi o structur de tipul:
(deftemplate carte
(multislot prenume_autor)
(slot nume_autor)
(multislot titlu)
)

O varianta posibil a programului este:
;******++++++******++++++*******+++++++********+++++++++********%%%%%%
; PROGRAM GESTIUNARE BIBLIOTECA PERSONALA
;******++++++******++++++*******+++++++********+++++++++********%%%%%%

(deftemplate autor
(slot nume)
(slot prenume)
(slot titlu))

(defrule deschidere_fisier
=>
(open "bibl.txt" b "r+")
(bind ?nr_carti 0)
(bind $?linie (readline b))
(while (neq $?linie EOF)
(bind ?nr_carti (+ ?nr_carti 1))
(bind $?linie (explode$ $?linie))
(assert (autor (nume (nth$ 1 $?linie))
(prenume (nth$ 2 $?linie))
(titlu (nth$ 3 $?linie)) ))
(bind $?linie (readline b))
)

139
(assert (nr_carti ?nr_carti))
)

(defrule meniu-de-optiuni
=>
(printout t t "Optiuni:" crlf)
(printout t "1. Cautare carte dupa nume autor" crlf)
(printout t "2. Cautare carte dupa prenume autor" crlf)
(printout t "3. Cautare carte dupa titlu" crlf)
(printout t "4. Introducere carte noua in baza de date" crlf)
(printout t "5. Afisare numar de carti din biblioteca" crlf)
(printout t "Alegeti una din optiuni (1-5): ")
(assert (optiune (read)))
)

(defrule optiune_incorecta
?f <- (optiune ?c & ~1 & ~2 & ~3 & ~4 & ~5)
=>
(retract ?f)
(printout t "Alegeti una din optiuni (1-5): ")
(assert (optiune (read)))
)

(defrule introducere_nume
(optiune 1 | 4)
=>
(printout t t "Introduceti numele autorului: ")
(bind ?n (read))
(while (or (not (symbolp ?n)) (< (str-length (str-cat ?n)) 3))
(printout t "Introduceti numele autorului: ")
(bind ?n (read))
)
(assert (nume ?n))
)

(defrule introducere_prenume
(optiune 2 | 4)
=>
(printout t "Introduceti prenumele autorului: ")
(bind ?p (read))
(while (or (not (symbolp ?p)) (< (str-length (str-cat ?p)) 3))
(printout t "Introduceti prenumele autorului: ")
(bind ?p (read))
)
(assert (prenume ?p))
)

(defrule introducere_titlu

140
(optiune 3 | 4)
=>
(printout t "Introduceti titlul cartii: ")
(bind ?t (readline))
(while (not (stringp ?t))
(printout t "Introduceti titlul cartii: ")
(bind ?t (readline))
)
(assert (titlu ?t))
)

(defrule cautare_dupa_nume
(optiune 1)
(nume ?x)
(autor (nume ?n) (prenume ?p) (titlu ?t) )
(test (eq (lowcase ?x) (lowcase ?n)))
=>
(printout t ?n " " ?p " -- " ?t crlf)
)

(defrule cautare_dupa_prenume
(optiune 2)
(prenume ?x)
(test (eq (lowcase ?x) (lowcase ?p)))
=>
)

(defrule cautare_dupa_titlu
(optiune 3)
(titlu ?x)
(test (str-index (lowcase ?x) (lowcase ?t)))
=>
)

(defrule introducere_inregistrare
?f1 <- (nume ?n)
?f2 <- (prenume ?p)
?f3 <- (titlu ?t)
?f4 <- (nr_carti ?nr)
(not (autor (nume ?n) (prenume ?p) (titlu ?t)))
=>
(retract ?f1 ?f2 ?f3 ?f4)
(assert (autor (nume ?n) (prenume ?p) (titlu ?t) )
(nr_carti (+ ?nr 1)) )

141
(printout b ?n " " ?p " \"" ?t "\"" crlf)
)

(defrule afisare_numar_carti
(optiune 5)
(nr_carti ?n)
=>
(printout t t "In aceasta baza de date sunt " ?n " volume." crlf)
)

(defrule stergere_date
(declare (salience -5))
(or ?f <- (nume ?)
?f <- (prenume ?)
?f <- (titlu ?) )
=>
(retract ?f)
)

(defrule alta_optiune
?f <- (optiune ?)
=>
(retract ?f)
(printout t t "Doriti o alta optiune (Y/y)? ")
(bind ?raspuns (readline))
(if (or (eq ?raspuns "y") (eq ?raspuns "Y"))
then
(refresh meniu-de-optiuni)
)
)

(defrule inchidere_fisier
=>
(close)
)

Referatele de laborator vor conine programul realizat, explicarea
funcionrii acestuia, baza de date, rezultatele obinute, propuneri de imbunataire
a programului.

Activitatea 5.
S se construiasc un sistem expert care s identifice un animal pe baza
caracteristicilor acestuia.

Rezolvare
Exemplul unui astfel de program este prezentat n continuare.

142
;;;======================================================
;;; Sistem expert de identificare a unui animal
;;;
;;; Acest program reprezinta un sistem expert simplu
;;; care incearca sa determine un animal pe baza
;;; caracteristicilor sale.
;;; Baza de cunostinte este o colectie de fapte
;;; ce reprezinta un lant de regulibackward.
;;; Lantul CLIPS de reguli forward este folosit
;;; pentru a simula o masina de inferenta backward
;;;
;;; Exemplu pentru CLIPS Version 6.0
;;;
;;; Pentru executie: load, reset si run.
;;; Raspunsul la intrebari este da sau nu.
;;;======================================================

;;;***************************
;;;* DEFTEMPLATE DEFINITIONS *
;;;***************************

(deftemplate rule
(multislot if)
(multislot then))

;;;**************************
;;;* INFERENCE ENGINE RULES *
;;;**************************

(defrule propagate-goal ""
(goal is ?goal)
(rule (if ?variable $?)
(then ?goal ? ?value))
=>
(assert (goal is ?variable)))

(defrule goal-satified ""
(declare (salience 30))
?f <- (goal is ?goal)
(variable ?goal ?value)
(answer ? ?text ?goal)
=>
(retract ?f)
(format t "%s%s%n" ?text ?value))

(defrule remove-rule-no-match ""

143
(variable ?variable ?value)
?f <- (rule (if ?variable ? ~?value $?))
=>
(retract ?f))

(defrule modify-rule-match ""
?f <- (rule (if ?variable ? ?value and $?rest))
=>
(modify ?f (if ?rest)))

(defrule rule-satisfied ""
?f <- (rule (if ?variable ? ?value)
(then ?goal ? ?goal-value))
=>
(retract ?f)
(assert (variable ?goal ?goal-value)))

(defrule ask-question-no-legalvalues ""
(not (legalanswers $?))
?f1 <- (goal is ?variable)
?f2 <- (question ?variable ? ?text)
=>
(retract ?f1 ?f2)
(format t "%s " ?text)
(assert (variable ?variable (read))))

(defrule ask-question-legalvalues ""
(legalanswers ? $?answers)
?f1 <- (goal is ?variable)
?f2 <- (question ?variable ? ?text)
=>
(retract ?f1)
(format t "%s " ?text)
(printout t ?answers " ")
(bind ?reply (read))
(if (member (lowcase ?reply) ?answers)
then (assert (variable ?variable ?reply))
(retract ?f2)
else (assert (goal is ?variable))))

;;;***************************
;;;* DEFFACTS KNOWLEDGE BASE *

144
;;;***************************

(deffacts knowledge-base
(goal is type.animal)
(legalanswers are da nu)
(rule (if backbone is da)
(then superphylum is backbone))
(rule (if backbone is nu)
(then superphylum is jellyback))
(question backbone is "Animalul are sira spinarii?")
(rule (if superphylum is backbone and
warm.blooded is da)
(then phylum is warm))
(rule (if superphylum is backbone and
warm.blooded is nu)
(then phylum is cold))
(question warm.blooded is "Animalul are singe cald?")
(rule (if superphylum is jellyback and
live.prime.in.soil is da)
(then phylum is soil))
(rule (if superphylum is jellyback and
live.prime.in.soil is nu)
(then phylum is elsewhere))
(question live.prime.in.soil is "Animalul traieste in pamint?")
(rule (if phylum is warm and
has.breasts is da)
(then class is breasts))
(rule (if phylum is warm and
has.breasts is nu)
(then type.animal is pasare/pinguin))
(question has.breasts is "Femela alapteaza puiul?")
(rule (if phylum is cold and
always.in.water is da)
(then class is water))
(rule (if phylum is cold and
always.in.water is nu)
(then class is dry))
(question always.in.water is "Animalul traieste permanent in apa?")
(rule (if phylum is soil and
flat.bodied is da)
(then type.animal is vierme_plat))
(rule (if phylum is soil and
flat.bodied is nu)
(then type.animal is vierme/lipitoare))
(question flat.bodied is "Animalul are un corp plat?")
(rule (if phylum is elsewhere and
body.in.segments is da)
(then class is segments))

145
(rule (if phylum is elsewhere and
body.in.segments is nu)
(then class is unified))
(question body.in.segments is "Animalul are corpul format din segmente?")
(rule (if class is breasts and
can.eat.meat is da)
(then order is meat))
(rule (if class is breasts and
can.eat.meat is nu)
(then order is vegy))
(question can.eat.meat is "Animalul este carnivor?")
(rule (if class is water and
boney is da)
(then type.animal is peste))
(rule (if class is water and
boney is nu)
(then type.animal is rechin/calcan))
(question boney is "Animalul are sistem osos?")
(rule (if class is dry and
scally is da)
(then order is scales))
(rule (if class is dry and
scally is nu)
(then order is soft))
(question scally is "Animalul are solzi?")
(rule (if class is segments and
shell is da)
(then order is shell))
(rule (if class is segments and
shell is nu)
(then type.animal is centiped/milliped/insecta))
(question shell is "Animalul are o cochilie?")
(rule (if class is unified and
digest.cells is da)
(then order is cells))
(rule (if class is unified and
digest.cells is nu)
(then order is stomach))
(question digest.cells is "Animalul are mai multe camere in stomac?")
(rule (if order is meat and
fly is da)
(then type.animal is liliac))
(rule (if order is meat and
fly is nu)
(then family is nowings))
(question fly is "Animalul poate sa zboare?")
(rule (if order is vegy and
hooves is da)

146
(then family is hooves))
(rule (if order is vegy and
hooves is nu)
(then family is feet))
(question hooves is "Animalul are copite?")
(rule (if order is scales and
rounded.shell is da)
(then type.animal is broasca_testoasa))
(rule (if order is scales and
rounded.shell is nu)
(then family is noshell))
(question rounded.shell is "Animalul are o cochilie inchisa?")
(rule (if order is soft and
jump is da)
(then type.animal is broasca))
(rule (if order is soft and
jump is nu)
(then type.animal is salamandra))
(question jump is "Animalul executa salturi?")
(rule (if order is shell and
tail is da)
(then type.animal is homar))
(rule (if order is shell and
tail is nu)
(then type.animal is crab))
(question tail is "Animalul are coada?")
(rule (if order is cells and
stationary is da)
(then family is stationary))
(rule (if order is cells and
stationary is nu)
(then type.animal is meduza))
(question stationary is "Animalul este permanent atasat unui obiect?")
(rule (if order is stomach and
multicelled is da)
(then family is multicelled))
(rule (if order is stomach and
multicelled is nu)
(then type.animal is protozor))
(question multicelled is "Animalul este alcatuit din mai multe celule?")
(rule (if family is nowings and
opposing.thumb is da)
(then genus is thumb))
(rule (if family is nowings and
opposing.thumb is nu)
(then genus is nothumb))
(question opposing.thumb is "Animalul are degetul mare opozabil?")
(rule (if family is hooves and

147
two.toes is da)
(then genus is twotoes))
(rule (if family is hooves and
two.toes is nu)
(then genus is onetoe))
(question two.toes is "Animalul are doua copite la picior?")
(rule (if family is feet and
live.in.water is da)
(then genus is water))
(rule (if family is feet and
live.in.water is nu)
(then genus is dry))
(question live.in.water is "Animalul traieste in apa?")
(rule (if family is noshell and
limbs is da)
(then type.animal is crocodil/aligator))
(rule (if family is noshell and
limbs is nu)
(then type.animal is sarpe))
(question limbs is "Animalul are picioare?")
(rule (if family is stationary and
spikes is da)
(then type.animal is anemona))
(rule (if family is stationary and
spikes is nu)
(then type.animal is coral/burete))
(question spikes is "Animalul are tepi?")
(rule (if family is multicelled and
spiral.shell is da)
(then type.animal is melc))
(rule (if family is multicelled and
spiral.shell is nu)
(then genus is noshell))
(question spiral.shell is "Animalul are cochilia in forma de spirala?")
(rule (if genus is thumb and
prehensile.tail is da)
(then type.animal is maimuta))
(rule (if genus is thumb and
prehensile.tail is nu)
(then species is notail))
(question prehensile.tail is "Animalul se poate agata cu coada?")
(rule (if genus is nothumb and
over.400 is da)
(then species is 400))
(rule (if genus is nothumb and
over.400 is nu)
(then species is under400))
(question over.400 is "Animalul la maturitate are peste 180 de kilograme?")

148
(rule (if genus is twotoes and
horns is da)
(then species is horns))
(rule (if genus is twotoes and
horns is nu)
(then species is nohorns))
(question horns is "Animalul are coarne?")
(rule (if genus is onetoe and
plating is da)
(then type.animal is rinocer))
(rule (if genus is onetoe and
plating is nu)
(then type.animal is cal/zebra))
(question plating is "Animalul este acoperit cu folie protectoare?")
(rule (if genus is water and
hunted is da)
(then type.animal is balena))
(rule (if genus is water and
hunted is nu)
(then type.animal is delfin/porc_de_mare))
(question hunted is "Animalul este vinat pentru comercializare?")
(rule (if genus is dry and
front.teeth is da)
(then species is teeth))
(rule (if genus is dry and
front.teeth is nu)
(then species is noteeth))
(question front.teeth is "Animalul are dinti mari in fata?")
(rule (if genus is noshell and
bivalve is da)
(then type.animal is scoica/stridie))
(rule (if genus is noshell and
bivalve is nu)
(then type.animal is calmar/caracatita))
(question bivalve is "Animalul este protejat de cochilie din doua bucati?")
(rule (if species is notail and
nearly.hairless is da)
(then type.animal is om))
(rule (if species is notail and
nearly.hairless is nu)
(then subspecies is hair))
(question nearly.hairless is "Animalul este aproape plesuv?")
(rule (if species is 400 and
land.based is da)
(then type.animal is urs/tigru/leu))
(rule (if species is 400 and
land.based is nu)
(then type.animal is morsa))

149
(question land.based is "Animalul traieste pe uscat?")
(rule (if species is under400 and
thintail is da)
(then type.animal is pisica))
(rule (if species is under400 and
thintail is nu)
(then type.animal is coiot/lup/vulpe/caine))
(question thintail is "Animalul are o coada scurta?")
(rule (if species is horns and
one.horn is da)
(then type.animal is hipopotam))
(rule (if species is horns and
one.horn is nu)
(then subspecies is nohorn))
(question one.horn is "Animalul are un singur corn?")
(rule (if species is nohorns and
lives.in.desert is da)
(then type.animal is camila))
(rule (if species is nohorns and
lives.in.desert is nu)
(then type.animal is girafa))
(question lives.in.desert is "Animalul traieste in desert?")
(rule (if species is teeth and
large.ears is da)
(then type.animal is iepure))
(rule (if species is teeth and
large.ears is nu the type.animal is sobolan/soarece/veverita/castor/porc_spinos))
(question large.ears is "Animalul are urechi mari?")
(rule (if species is noteeth and
pouch is da)
(then type.animal is "cangar/urs coala"))
(rule (if species is noteeth and
pouch is nu)
(then type.animal is cirtita/scorpie/elefant))
(question pouch is "Animalul are o punga?")
(rule (if subspecies is hair and
long.powerful.arms is da)
(then type.animal is urangutan/gorila/cimpanzeu))
(rule (if subspecies is hair and
long.powerful.arms is nu)
(then type.animal is babun))
(question long.powerful.arms is "Animalul are brate lungi si puternice?")
(rule (if subspecies is nohorn and
fleece is da)
(then type.animal is berbec/capra))
(rule (if subspecies is nohorn and
fleece is nu)
(then subsubspecies is nofleece))

150
(question fleece is "Animalul are blana?")
(rule (if subsubspecies is nofleece and
domesticated is da)
(then type.animal is vaca))
(rule (if subsubspecies is nofleece and
domesticated is nu)
(then type.animal is caprioara/elan/antilopa))
(question domesticated is "Animalul este domestic?")
(answer is "Cred ca animalul este un(o) " type.animal))

Referatele de laborator vor conine: explicarea modului de funcionare a
programului, exemple de utilizare. Pe baza acestui model se va realiza un sistem
expert pentru un alt domeniu, de exemplu arhitectura calculatoarelor. Se va
compara funcionarea programului realizat cu programul prezentat la lucrarea de
laborator 4,5,6. Lucrarile de laborator vor conine de asemenea: listingul
programului realizat, explicarea funcionrii acestuia i exemple de utilizare.

151

BIBLIOGRAFIE

1. Aur Dorian, Aur Liviu Modelri neuronale n inteligena artificial, Editura
Grigore Tabacaru, Bcau, 1997
2. Dumitrascu Liviu, s.a. - Elemente de inteligen artificial pentru conducerea
operativ a produciei, Editura Academiei, Bucuresti 1983
3. Hristev Ryurick Marius - Introducere in: Prolog, un limbaj al inteligenei artificiale,
Editura APH, Bucuresti 1992
4. Malita Mihaela, Malita Mircea - Bazele inteligenei artificiale. Logici
propoziionale. Editura Tehnica, Bucuresti, 1987
5. Streinu Ileana - LISP. Limbajul de programare al inteligenei artificiale, Editura
tiinific i enciclopedic, Bucureti 1986
6. Becheanu M., s.a. Logic matemetic i teoria multimilor, Editura Didactic i
pedagogic, Bucureti 1972
7. Dumitra Adriana - Proiectarea reelelor neuronale artificiale, Editura ODEON,
Bucuresti, 1997
8. Dumitrescu D. Costin Hariton Reele neuronale. Teorie i aplicatii. Editura
TEORA, Bucuresti, 1996
9. Flondor Paul, Ionescu Cezar - Introducere n algoritmi genetici, ALL, Bucuresti,
1999
10. Chiorean Ioana - Calculul paralel. Fundamente. Editura Microinformatica, Cluj,
1995
11. H.N. Teodorescu, M. Zbancioc, Oana Voroneanu Sisteme bazate pe cunotinte.
Aplicaii. Editura Performantica, Iasi, ISBN-973-730-014-9, 2004
12. H.N. Teodorescu - Program Design (editia a-II-a), Pro-Copy, Tampa, USA, 2000
13. H.N. Teodorescu - Tehnici de programare avansat, Note de curs, UT Iasi, 2001
14. A.Brezulianu Sisteme Fuzzy si Aplicatii, Ed. Tehnici si Tehnologii, Iasi, 2002
15. D. Cristea Programarea bazata pe reguli (Rule-Based Programming), Romanian
Academy Publishing House, 2002, Bucharest, 216 pg.
16. D. Galea, Mihaela Costin, M. Zbancioc Programarea n CLIPS prin exemple,
Tehnopress Publishing House, 2001, ISBN 973-8048-45-1, pg.146
17. D. Galea, Mihaela Costin, M. Zbancioc Aplicaii de Inteligen Artificial n
CLIPS, Tehnopress Publishing House, 2001, ISBN 973-8048-51-6. pg. 152

Inteligenta Artificiala

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Inteligenta Artificiala

Uploaded by

Copyright:

Available Formats

DAN ROTAR

You might also like