Documente Academic
Documente Profesional
Documente Cultură
FACULTATEA DE INGINERIE
DAN ROTAR
INTELIGEN ARTIFICIAL
Note de curs
Caiet de seminar
Indrumar de laborator
CUPRINS
Pag.
Capitolul 1
DOMENIILE INTELIGENEI ARTIFICIALE
2.1.
2.1.1.
2.1.2.
2.1.3.
2.1.4.
2.1.5.
2.1.6.
2.1.7.
2.1.8.
2.1.9.
2.1.10.
2.1.11.
2.2.
2.2.1.
2.3.
Capitolul 2
BAZELE INTELIGENEI ARTIFICIALE
Logica clasic a propoziiilor
Simboluri, formule
Evaluare, funcie de adevr
Tautologie, validitate, consisten
Metoda lui Quine
Metoda reducerii
Echivalene
Reguli de manipulare i substituie
Dualitate
Conectori adecvai
Consecine logice
Forme normale
Sistemul deductiv al calculului propoziiilor
Demonstraie i deducie
Limbajul calculului cu predicate de ordinul nti
7
7
7
9
10
13
14
16
16
17
18
19
19
20
20
22
3.1.
3.2.
3.3.
Capitolul 3
SISTEME EXPERT
Sisteme expert generaliti
Structura general a unui sistem expert
Funcionarea unui sistem expert
24
24
25
25
4.1.
4.2.
4.3.
4.3.1.
4.3.2.
4.3.3.
4.3.4.
4.3.5.
4.3.6.
4.3.7.
4.3.8.
4.3.9.
Capitolul 4
REALIZAREA UNUI PROGRAM N MEDIUL DE
PROGRAMARE CLIPS
Introducere
Execuia unui program n mediul de programare CLIPS
Structura programului CLIPS
Constructorii
Faptele
Constructorul deftemplate
Constructorul deffacts
Fapte ordonate
Adugarea i tergerea faptelor
Modificarea i duplicarea faptelor
Comanda watch
Definirea regulilor
3
28
28
28
32
32
32
33
34
35
36
39
40
41
4.3.10.
4.3.11.
4.3.12.
4.3.13.
4.3.14.
4.3.15.
4.3.16.
4.3.17.
4.3.18.
4.3.19.
4.3.20.
Afiarea agendei
Urmrirea activrilor, regulilor i a statisticilor
Afiarea listei membrilor unei construcii specificate
Afiarea textului membrilor unei construcii specificate
tergerea membrilor unei construcii specificate
tergerea tuturor construciilor din mediul CLIPS
Comanda printout
Tipuri de date
Funciile
Constructorii
Faptele
43
44
45
45
46
47
48
48
50
51
51
5.1.
5.2.
5.3.
5.4.
Capitolul 5
REELE NEURALE
Modelul general al unei reele neuronale
Ecuaia de evoluie a reelei
Paradigme ale instruirii
Topologia multistrat a reelelor neurale
53
53
55
56
57
6.1.
6.2.
Capitolul 6
MULIMI NUANATE
Noiunea de mulime nuanat
Sisteme expert bazate pe mulimi nuanate
58
58
60
7.1.
7.2.
Capitolul 7
ALGORITMI GENETICI
Generaliti
Algoritmul genetic canonic
62
62
62
SEMINAR
Seminar 1
Seminar 2
Seminar 3
Seminar 4
Seminar 5
Seminar 6
Seminar 7
66
66
68
70
71
72
72
74
Laborator
Laborator 1,2,3
Laborator 4,5,6
Laborator 7,8,9
Laborator 10,11,12,13,14
77
90
123
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:
nelegerea limbajelor naturale ofer cel mai mare potenial de utilizare din
cauz c acestea vor permite oamenilor s interacioneze cu calculatoarelor fr a fi
necesare cunotine 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 reuesc 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 nau 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 sunt 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.
CAPITOLUL 2
BAZELE INTELIGENEI ARTIFICIALE
2.1.
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:
Pv
1
1
0
0
P
Qv
1
0
1
0
~Pv
0
0
1
1
(P^V)v
1
0
0
0
(PvV)v
1
1
1
0
(P Q)v
1
0
1
1
(P Q)v
1
0
0
1
pvq
~(p v q)
~(p v q)
1
1
0
0
1
0
1
0
1
1
1
0
0
0
0
1
0
0
0
1
~(p v q) v ~ (q v
p)
0
0
0
1
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:
CONSISTEN=REALIZABIL
Pv = 1 uneori
NEVALID
Pv = 0 uneori
VALID=TAUTOLOGIE
Pv = 1 ntotdeauna
CONTRADICIE=NEREALIZABIL
Pv = 0 ntotdeauna
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 Tv=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 tautologii:
T0
T1
T2
T3
T4
T5
T6
T7
T8
T9
T10
T11
T12
PP
(PQ) ((QR) (PR))
P(P v Q)
Q(P v Q)
(PQ) ((QR) ((P v Q)R))
P ^ Q P
P ^ Q Q
(RP) ((RQ) (R (P ^ Q)))
(P(QR)) ((P ^ Q) R)
((P ^ Q) R) (P (QR))
(P ^ ~P) Q
(P(P ^ ~P)) ~P
P ^ ~P
legea silogismului
legea importrii
legea exportrii
legea terului exclus sau
tertium non datur
(P ^ (P Q)) Q
T14
T15
T16
T17
T18
T19
T20
T21
T22
T23
T24
T25
(~Q ^ (P Q)) ~ P
(~P ^ (P v Q)) Q
((P Q) ^ ~ Q) ~ P
~ (P ^ ~ P)
P (Q P)
(P (Q R)) (Q (P R))
(P (Q R)) ((P Q) (P R))
P~~P
~~PP
(P Q) (~P v Q)
(~P v Q) (P Q)
~ (P v Q) (~P ^ ~Q)
T26
T27
T28
(~P ^ ~Q) ~ (P v Q)
~(P ^ Q) (~ P v ~ Q)
(~ P v ~ Q) ~(P ^ Q)
12
T29
(P Q) (~Q ~P)
T30
T31
T32
T33
(P ~Q) (Q ~P)
(~P Q) (~Q P)
(~P ~Q) (Q P)
((P Q) P) P
q
1
0
1
0
13
pq
1
0
1
1
F (Fr)
F (qV) V (qF)
qF
V F
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
din atribuirea valorii 0 nu rezult n mod unic c P este adevrat sau fals, de aceea
trebuie s considerm toate cazurile:
212
p^Q
100
212
P^Q
001
212
P^Q
000
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 01 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 Pv Qv.
Definiie echivalent: dou formule P i Q sunt echivalente dac P Q este o
tautologie.
Echivalene fundamentale.
1.
2.
3.
4.
Absorbia
Idempotena
Comutativitatea
Asociativitatea
5. Distributivitatea
6. Dubla negaie
7. Legile lui De Morgan
8. Transpunerea
9. Negaia implicaiei
10. Formula bicondiional
P ^ (P v Q) P i P v (P ^ Q) P
P ^ P P i P v P P
P ^ Q Q ^ P i P v Q Q v P
P ^ (Q ^ R) (P ^ Q) ^ R
P v (Q v R) (P v Q) v R
P ^ (Q v R) (P ^ Q) v (P ^ R)
P v (Q ^ R) (P v Q) ^ (P v R)
~ (~ P) P
~ (P ^ Q) ~ P v ~ Q, ~ (P v Q) ~ P ^ ~ Q
PQ~Q~P
~ (P Q) P ^ ~ Q
P Q (P ^ Q) v (~P ^ ~Q)
16
Fie F o formul n care apar atomii p1, p2, ..., pn. Fie P1, ... , Pn formule oarecare.
Dac F este o tautologie, atunci obinut prin substituirea peste tot n F a fiecrei
apariii a lui pi prin Pi (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 p1 ^ (p2 ^ p3) (p1 ^ p2) ^ p3 este o tautologie (asociativitatea), oricare ar fi
formulele P, Q, R,
P ^ (Q ^ R) (P ^ Q) ^ R
va fi o tautologie.
ntr-o formul 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 Pv =1 pentru toi v i Qv = 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 ~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
P
p ^ q = (p p) (q q)
im jn
ij
l
in jm
ij
19
2.2.
un alfabet de simboluri,
o mulime de formule bine formale,
o mulime de axiome,
reguli de deducie.
Prima noiune care este introdus n cadrul unui sistem formal este aceea de
demonstraie.
Definiie. Se numete demonstraie secvena de formule A1, A2, ..., An astfel c:
1) Ai (1 i n) este axiom sau
2) Ai urmeaz din Aj, Ak (j <i, k<i) dou formule anterioare ale secvenei prin aplicarea
lui MP.
Ultima formul An este o teorem n L, iar secvena este demonstraia lui An n
L.
Exemplu:
Fie:
A1=p1(p2p3),
A2=(p1(p2p3)) ((p1p2) (p1p1)),
A3=(p1p2) (p1p1)
p1 (p2 p1),
(p1 (p2 p1)) ((p1 p2) (p1 p1)).
Aplicm acum regula MP formulelor A=p1 (p2 p1) i B=(p1 p2) (p1 p1).
Din A afirmat de L1 i A B afirmat de L2, deducem B adic:
(p1 p2) (p1 p1),
MP (L1, L2)
21
inferen
Concluzie
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:
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
23
CAPITOLUL 3
SISTEME EXPERT
3.1. Sisteme expert generaliti
Sistemele expert bazate pe cunotine sau pe scurt sistemele expert utilizeaz
cunotinele omeneti pentru a rezolva probleme care necesit n mod normal inteligena
omeneasc. Aceste sisteme expert reprezint cunotine de expert ca date sau reguli ntrun 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 cunotine s
poat fi utilizate. Programele de calculator convenionale realizeaz sarcini utiliznd
logic de decizie convenional -- coninnd puine cunotine n afara algoritmului de
baz pentru rezolvarea unei probleme specifice i condiiile de grani necesare.
Cunotinele programului sunt adesea parte integrat a codului programului i deci dac
cunotinele se schimb atunci se va schimba i programul i va trebui s fie rescris.
Sistemele bazate pe cunotine colecteaz fragmente mici de cunotine omeneti
eseniale (know-how) ntr-o baz de cunotine, cunotine 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 cunotine 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 cunotinelor 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
Inginer de
cunotine
Achiziia de
cunotine
Mecanism
de inferen
Baza de
cunotine
Baza de
fapte
Modul de
explicare
Reprezentarea
cunotinelor
Tratarea
cunotinelor
Interfaa
utilizator
Expert
uman
Modul de achiziie a
cunotinelor
Utilizator
Utilizarea
cunotinelor
25
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 n figura de mai jos.
26
27
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 SmallTalk, 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.
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 CLIPSului 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
29
Figura 1
Selectnd din meniul principal Windows, opiunea Facts Window se afieaz
fereastra din figura 2.
Figura 2.
31
(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 numarstrada 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.
33
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
36
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)
For a total of 3 facts.
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)
or a total of 2 facts.
LIPS> (retract *)
LIPS> (facts)
LIPS> (assert ( numar (+ 3 5)))
Fact-6>
LIPS> (facts)
-6
(numar 8)
or a total of 1 facts.
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.
38
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-0
(student (nume Husleag Dumitru) (nr_grupa 1406) (an IV))
f-3
(student (nume Husleag Dumitru) (nr_grupa 1207) (an II))
For a total of 2 facts.
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-0
(student (nume Husleag Dumitru) (nr_grupa 1406) (an IV))
f-3
(student (nume Husleag Dumitru) (nr_grupa 1207) (an II))
For a total of 2 facts.
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> (watch facts)
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))
40
<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 c 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 prompterul 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)
41
=>
<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.)
42
(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> (watch facts)
CLIPS> (run 1)
==> f-5
(mesaj Exista un angajat cu acest nume.)
CLIPS>(agenda)
0
actiunea_zilei: f-4
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>)
43
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
actiunea_zilei: f-4
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>
44
47
trei_cmpuri
.
49
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 aduga 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 )
51
multislot
=>
( nume_slot [ valoare ]* )
Un slot trebuie s aib obligatoriu asociat o valoare, pe cnd la un multislot
asocierea unei valori nu e obligatorie. Valoarea 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 numarstrada 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)) .
52
CAPITOLUL 5
REELE NEURALE
5.1.
x1
x2
xn
t
w1
w2
wn
s = w jx j
y=f(s)
s = wj x j
j =1
Ieirea se scrie:
n
y = f w j x j + t
j =1
s' = wj x j
j =1
54
2. Funcia signum
1 daca x 0
f ( x) =
1 daca x < 0
1
1 + e kx
k >0
5.2.
e kx e kx
e kx + e kx
k >0
s = wij x j
j =1
i,2
Vi =
...
w
i,n
55
i=1, 2, ..., n
reprezint vectorul pondere asociat neuronului i i conine toate ponderile spre
neuronul i.
Activarea neuronului se scrie:
S = ViTX
Dac se noteaz:
V 1
2
V
W =
...
V n
5.3.
xkn
yk
I1
O1
I2
O2
In
On
yk
yk
Considerm vectorii:
R = (x1 x2 ... xm)T form (vectorul de intrare n reea)
S = (s1 s2 ... sn)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 = {(R1,S1), ..., (Rp,Sp)} p1
j = 1,2, ..., p
5.4.
j = 1,2, ..., p
57
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:
58
A( x i ) =
1
, i = 1, 2, 3
i+2
Exemplul 2.
Fie universul:
X = {x1, x2, x3}
Gradele de apartenen ale mulimii nuanate A sunt indicate prin valorile numerice:
A(x1)=0,7; A(x2)=0,5; A(x3)=0,9
Exemplul 3.
Fie:
X=R
10
15
t (oC)
Mulimea vid:
(x) = 0, x X
Complementara mulimii vide :
X(x) =1
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:
60
( A( x) x )
centroida =
A( x)
toti x
toti x
Maina de
inferen nuanat Intrri
Baza de cunotine
a sistemului expert
Funciile de
apartenen a
mrimilor de
intrare
Nuanare
(fuzificare)
- universul
mulimii nuanateintrri
fuzzy
Reguli
Evaluarea regulilor
ieiri
fuzzy
Funciile de
apartenen a
mrimilor de ieire
Denuanare
(defuzificare)
Ieiri
61
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(x1, x2, ... xM)
ceea ce nseamn c dorim s minimizm sau s maximizm aceast funcie. n acest
caz variabilele ce desemneaz parametrii sunt reprezentate n general prin iruri binare
(variabilele fiind discretizate apriori).
fi
f
unde:
62
Sir 1
Selecie
(duplicare)
Recombinare
(crossover)
Sir 1
Descendent A (1x2)
Sir 2
Sir 2
Descendent B (1x2)
Sir 3
Sir 3
Descendent A (2x4)
...
...
Descendent D (2x4)
.............
Generaie
curent t
Generaia
intermediar t
Generaia
urmtoare t+1
fi
>1 partea ntreag indic numrul de
f
iruri identice plasate n populaia intermediar;
f
partea fracionar i reprezint ansa de a mai plasa o copie a irului. De
f
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.
se calculeaz fitness-ul i pentru
65
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
0 0
1
0 1
1
1 0
0
1 1
0
~b
b negat
1
0
1
0
avb
a I b
0
1
1
1
a^b
a SAU b
0
0
0
1
ab
a IMPLIC b
1
1
0
1
ab
a ECHIVALENT b
1
0
0
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
0 0 1
1
0 1 1
0
1 0 0
1
1 1 0
0
~p ^ ~q
1
0
0
0
p v q ~ (~p ^ ~ q)
0
0
1
1
1
1
1
1
Pentru ca formula s fie adevrat, ultimele dou coloane ale tabelului de adevr
1.2. trebuie s fie identice. Cu alte cuvinte, toate interpretrile din ultimele 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.
66
Rezolvare
Dac lum n considerare ultimele 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 qvr
0 0 0
0
0 0 1
1
0 1 0
1
0 1 1
1
1 0 0
0
1 0 1
1
1 1 0
1
1 1 1
1
p^q
0
0
0
0
0
0
1
1
p^r
0
0
0
0
0
1
0
1
p ^ (q v r)
0
0
0
0
0
1
1
1
(p ^ q) v (p ^ r)
0
0
0
0
0
1
1
1
Aa cum s+a artat i la problema 1.2. ultimele 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.
2.
3.
4.
Rspuns: DA
Rspuns: NU
Rspuns: DA
Rspuns: NU
1. Interpretarea satisface pe P?
2. Interpretarea falsific pe P?
Rspuns: DA
Rspuns: NU
((p ^ q) ^ p) (p ^ q)
((V ^ q) ^ V) (V ^ q)
((F ^ q) ^ F) (F ^ q)
(F ^ F) F
FF
i deci:
n final:
VV
FF
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 aceast 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.
69
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 23
(pq) ((qr) ((p v q)r))
1
0
1 00
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:
545 2 646 1 737 2 3
(pq) ((qr) ((p v q)r))
10 0 1 100 0 110 00
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 46 2
4
1
3 23
(pq) ((qr) ((p v q)r))
1 00 1
1
0
1 00
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 permite 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 la o
contradicie i, de asemenea, v(p) = 1 i v(q) = 1 care este, evident iari o contradicie.
Din nou nu s-a putut gsi o combinaie v(p), v(q) care sa permit 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 s satisfac ambele implicaii:
4
2
4
1
3 23
(pq) ((qr) ((p v q)r))
1
1
1
0
1 00
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 stabilit la pasul 3,
70
30 v( x)
, 20 < v( x) 30
ATANAR ( x) =
10
0,
v( x) > 30
72
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:
0,
h( x) < 150
h( x) 150
, 150 h( x) 200
AINALT ( x) =
200
1,
h( x) > 200
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:
1
A( x) =
1+ x2
ceea ce ne 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
1
A( x) =
2
1+ x
ceea ce ne 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:
1
A( x) =
2
1 + (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:
1, x [a, b]
A( x) = 1[a ,b ] ( x) =
altfel
0,
Se spune c funcia de apartenen furnizeaz o reprezentare pe vertical a unei
mulimi fuzzy.
73
Seminar 7.
Test gril final.
11. Alegei 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
12. Alegei rspunsul corect, n funcie de modul n care definiia urmtoare este
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
13. Alegei rspunsul corect, n funcie de modul n care definiia urmtoare este
corect (ADEVRAT) sau incorect (FALS). Funcia de ieire a neuronului
reprezint funcia de activare.
A. ADEVRAT
B. FALS
Rspuns: A
14. Alegei rspunsul corect, n funcie de modul n care definiia urmtoare este
corect (ADEVRAT) sau incorect (FALS). O reea neural multistrat poate
conine cel mult un strat ascuns.
A. ADEVRAT
B. FALS
Rspuns: B
15. Alegei rspunsul corect, n funcie de modul n care definiia urmtoare este
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
16. Alegei rspunsul corect, n funcie de modul n care definiia urmtoare este
corect (ADEVRAT) sau incorect (FALS). O mulime nuanat nu poate
avea complementar.
A. ADEVRAT
B. FALS
Rspuns: B
17. Alegei rspunsul corect, n funcie de modul n care definiia urmtoare este
corect (ADEVRAT) sau incorect (FALS). Populaia iniial a unui algoritm
genetic este stabilit de funcia de evaluare.
A. ADEVRAT
B. FALS
Rspuns: B
18. Alegei rspunsul corect, n funcie de modul n care definiia urmtoare este
corect (ADEVRAT) sau incorect (FALS). Un sistem expert conine o baz
de cunotiine i un mecanism de interferen.
A. ADEVRAT
B. FALS
Rspuns: B
74
19. Alegei rspunsul corect, n funcie de modul n care definiia urmtoare este
corect (ADEVRAT) sau incorect (FALS). Ponderile sinaptice sunt asociate
ieirilor neuronului.
B. ADEVRAT
B. FALS
Rspuns: B
20. Alegei 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. Alegei 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. Alegei 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
23. Alegei rspunsul corect, n funcie de modul n care definiia urmtoare este
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
24. Alegei rspunsul corect, n funcie de modul n care definiia urmtoare este
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
25. Alegei rspunsul corect, n funcie de modul n care definiia urmtoare este
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 cunotinelor 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 neurale reprezint:
A. Asocierea intrrilor cu ponderile sinaptice..
B. Asocierea intrrilor cu funciile de excitaie.
75
76
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
0
0
1
1
0
1
0
1
~a
a negat
1
1
0
0
~b
b negat
1
0
1
0
avb
a I b
0
1
1
1
a^b
a SAU b
0
0
0
1
ab
a IMPLIC b
1
1
0
1
ab
a ECHIVALENT b
1
0
0
1
}
i ECHIVALEN funcia echiv:
char echiv (char a,char b)
{
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
instruciune if).
Prin execuia programului se obine urmtorul 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
gama(echivalenta)= 0
alfa= 1
beta= 0
gama(si)= 0
gama(sau)= 1
gama(nu beta)= 1
gama(implicare)= 0
79
gama(echivalenta)= 0
alfa= 1
beta= 1
gama(si)= 1
gama(sau)= 1
gama(nu beta)= 0
gama(implicare)= 1
gama(echivalenta)= 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 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;
80
}
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]);
81
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]);
82
b
0
0
1
1
0
0
1
1
a
0
1
0
1
0
1
0
1
(a ^ b)
0
0
0
1
0
0
0
1
este :
A
0
0
0
0
1
1
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
(d ^ e)
notat B
0
0
0
1
0
0
0
1
(d v e)
notat C
0
1
1
1
0
1
1
1
A^B
notat D
0
0
0
0
0
0
0
1
c: 1
Valoare iesire (a SI b) IMPLICA c: 1
(a si b): 0
c: 1
Valoare iesire (a SI b) IMPLICA c: 1
(a si b): 1
c: 1
Valoare iesire (a SI b) IMPLICA 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
Valoare iesire (d SI e): 0
Valoare iesire (d SAU e): 1
d: 1
e: 0
Valoare iesire (d SI e): 0
Valoare iesire (d SAU e): 1
d: 1
e: 1
Valoare iesire (d SI e): 1
Valoare iesire (d SAU e): 1
d: 0
e: 0
Valoare iesire (d SI e): 0
Valoare iesire (d SAU e): 0
Valorile se repeta
d: 0
e: 1
Valoare iesire (d SI e): 0
Valoare iesire (d SAU e): 1
d: 1
e: 0
Valoare iesire (d SI e): 0
Valoare iesire (d SAU e): 1
d: 1
e: 1
Valoare iesire (d SI e): 1
Valoare iesire (d SAU 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
85
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.
Dup ce au fost create aceste fiiere se creeaz proiectul cu numele binar3.prj.
Acest lucru se realizeaz prin selectarea meniului PROJECT -> OPEN PROJECT i
n fereastra care se deschide 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
Rezultatul pentru (p SI q) IMPLICA q este: 1
p= 1
q= 0
Rezultatul pentru (p SI q) IMPLICA q este: 1
p= 1
q= 1
Rezultatul pentru (p SI q) IMPLICA q este: 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)
88
#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 nti 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 creeaz
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
89
q= 0
Rezultatul pentru (p IMPLICA (q IMPLICA r)) IMPLICA ((p SI Q) IMPLICA r) este: 1
p= 0
q= 0
q= 1
Rezultatul pentru (p IMPLICA (q IMPLICA r)) IMPLICA ((p SI Q) IMPLICA r) este: 1
p= 0
q= 1
q= 0
Rezultatul pentru (p IMPLICA (q IMPLICA r)) IMPLICA ((p SI Q) IMPLICA r) este: 1
p= 0
q= 1
q= 1
Rezultatul pentru (p IMPLICA (q IMPLICA r)) IMPLICA ((p SI Q) IMPLICA r) este: 1
p= 1
q= 0
q= 0
Rezultatul pentru (p IMPLICA (q IMPLICA r)) IMPLICA ((p SI Q) IMPLICA r) este: 1
p= 1
q= 0
q= 1
Rezultatul pentru (p IMPLICA (q IMPLICA r)) IMPLICA ((p SI Q) IMPLICA r) este: 1
p= 1
q= 1
q= 0
Rezultatul pentru (p IMPLICA (q IMPLICA r)) IMPLICA ((p SI Q) IMPLICA r) este: 1
p= 1
q= 1
q= 1
Rezultatul pentru (p IMPLICA (q IMPLICA r)) IMPLICA ((p SI Q) IMPLICA r) este: 1
Lucrrile de laborator vor conine: schema logic sau pseudocodul
programului utilizat, rezultatele obinute n urma verificrii tuturor formulelor
prezentate la nceputul lucrrii, 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
90
expert exist limbaje consacrate s-a preferat scrierea programului n PASCAL pentru
veleitile didactice ale acestuia.
Dup lansarea programului este afiat urmtorul meniu:
Introduceti:
I -> invatare
A -> actualizare
M -> modificare
C -> consultare
D -> analiza
E -> estimare
S -> stergere baza de date
Q -> parasire program
Introduceti optiunea: _
Acest meniu permite realizarea urmtoarelor aciuni:
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:
91
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:
=============== INVATARE ===============
Introduceti notiunea:
|-----------------------|
_
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:
Introduceti ce este ADEVARAT pentru notiunea TEST:
|-----------------------|
_
Urmeaz introducerea atributelor care reprezint negaii legate de noiunea
respectiv. Ecranul afiat este:
92
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
dispozitiv programabil
genereaza intreruperi
transfer rapid date
memoreaza programe
introducere de date
este periferic
definit de capacitate
dispozitiv extern
electro-mecanica
consola sistem
utilizeaza cod ASCII
atribut de departajare
atribut de departajare
atribut de departajare
atribut de departajare
atribut de departajare
atribut de departajare
atribut de departajare
atribut de departajare
atribut de departajare
atribut de departajare
atribut de departajare
atribut de departajare
memoreaza date
memoreaza programe
modul slave
circuit integrat
pe placa de baza
definit de capacitate
atribut specific
atribut specific
atribut de departajare
atribut de departajare
atribut de departajare
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:
atribut specific
atribut specific
atribut specific
atribut specific
atribut de departajare
atribut de departajare
94
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
Interfa
Modul DMA
Atribut
Face calcul aritmetic
Face calcul logic
Executa program
Genereaz adrese
Achita intreruperi
Modul master
Modul slave
Memoreaza date
Memoreaza programe
Definit de capacitate
Comunic cu periferice
Dispozitiv programabil
Genereaz ntreruperi
Noiune
Fals
Fals
Fals
Fals
Fals
Fals
Adevrat
Nedefinit
Fals
Fals
Adevrat
Adevrat
Adevrat
Interfa
Atribut
Transfer blocuri date
Introducere de date
Circuit integrat
Pe placa de baz
Transfer rapid date
Este periferic
Comunica cu interfetele
Dispozitiv extern
Electro-mecanica
Consola sistem
Adevrat
Adevrat
Adevrat
Adevrat
Fals
Fals
Fals
Fals
Fals
Fals
95
Tastur
Imprimant
Fals
Fals
Fals
Adevrat
Fals
Adevrat
Fals
Fals
Fals
Fals
Nedefinit
Adevrat
Adevrat
Modul DMA
Fals
Fals
Fals
Fals
Fals
Fals
Nedefinit
Fals
Fals
Fals
Fals
Fals
Nedefinit
Tastur
Fals
Fals
Adevrat
Fals
Fals
Fals
Nedefinit
Nedefinit
Adevrat
Fals
Fals
Adevrat
Nedefinit
Imprimant
Adevrat
Adevrat
Adevrat
Adevrat
Adevrat
Fals
Adevrat
Fals
Fals
Fals
Fals
Adevrat
Fals
Fals
Fals
Adevrat
Adevrat
Adevrat
Adevrat
Adevrat
Adevrat
Fals
Fals
Fals
Fals
Adevrat
Adevrat
Adevrat
Adevrat
Fals
96
97
Identice
Asemanatoare
Diferite
interfata-modul DMA
microprocesor-modul DMA
memorie-interfata
tastatura-imprimanta
microprocesor-memorie
microprocesor-interfata
microprocesor-imprimanta
memorie-modul DMA
memorie-tastatura
memorie-imprimanta
interfata-tastatura
interfata-imprimanta
modul DMA-tastatura
modul DMA-imprimanta
Apasati ENTER
_
98
_
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:
Asemanatoare
Diferite
interfata-modul DMA
tastatura-monitor
microprocesor-modul DMA
memorie-interfata
tastatura-imprimanda
imprimanda-monitor
microprocesor-memorie
microprocesor-interfata
microprocesor-imprimanda
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
Reprezentare grafic
Reprezentare text
Reprezentare color
Principiu tub catodic
- adevrat
- adevrat
- adevrat
- adevrat
101
Asemanatoare
Diferite
interfata-modul DMA
microprocesor-modul DMA
memorie-interfata
tastatura-imprimanta
tastatura-monitor
imprimanta-monitor
microprocesor-memorie
microprocesor-interfata
microprocesor-tastatura
microprocesor-imprimanta
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
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
104
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;
105
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: ');
106
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}
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]:=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
107
===============================')
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.}
for contor1:=1 to ContorAtribute-1 do
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: ');
108
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('================================= CONSULTARE
===============================');
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('=================================
109
CONSULTARE ===============================');
writeln('==================================
Notiuni ================================');
end;
end;
writeln;
write('Apasati ENTER pentru continuare');
readln;
StergeEcran;
writeln('================================= CONSULTARE
===============================');
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;
for contor1:=1 to ContorAtribute-1 do
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;
for contor1:=1 to ContorAtribute-1 do
if legatura[NumarNotiune,contor1]=0 then
writeln(atribute[contor1]);
writeln;
writeln('Apasati Enter pentru continuare');
readln;
110
end;
end;
'A':
{Consultare dupa atribute.}
begin
StergeEcran;
writeln('================================= CONSULTARE
===============================');
writeln('================================== Atribute
===============================');
for contor1:=1 to ContorAtribute-1 do
begin
writeln(contor1,'. ',atribute[contor1]);
if contor1 mod 20 = 0 then
begin
writeln;
write('Apasati ENTER pentru continuare');
readln;
StergeEcran;
writeln('=================================
CONSULTARE ===============================');
writeln('==================================
Atribute ================================');
end;
end;
writeln;
write('Apasati ENTER pentru continuare');
readln;
StergeEcran;
writeln('================================= CONSULTARE
===============================');
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:');
111
end;
writeln;
for contor1:=1 to ContorNotiuni-1 do
if legatura[contor1,NumarAtribut]=1 then
writeln(notiuni[contor1]);
writeln;
writeln('Apasati Enter pentru continuare');
readln;
StergeEcran;
writeln('=================================
CONSULTARE ===============================');
writeln('==================================
Atribute ================================');
writeln;
writeln(atribute[NumarAtribut],
' NU este valabil pentru:');
writeln;
for contor1:=1 to ContorNotiuni-1 do
if legatura[contor1,NumarAtribut]=0 then
writeln(notiuni[contor1]);
writeln;
writeln('Apasati Enter pentru continuare');
readln;
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;
112
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
for contor2:=1 to ContorNotiuni-1 do
for contor1:=1 to ContorAtribute-1 do
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
{
113
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
pozitie1:=PozitieInitiala;
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);
{S-a depasit un ecran de afisare}
if pozitie2>PozitieFinala then
begin
pozitie2:=PozitieInitiala;
writeln('Apasati ENTER.');
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);
115
write(notiuni[contor1],
'-',notiuni[contor2]);
inc(pozitie3);
{S-a depasit un ecran de afisare}
if pozitie3>PozitieFinala then
begin
pozitie3:=PozitieInitiala;
writeln('Apasati ENTER.');
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
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;
end;
end;
end;
writeln;
write('Apasati ENTER pentru continuare');
readln;
StergeEcran;
end;
116
procedure AfisareAtribute;
{
Procedura afiseaza toate atributele din baza de date.
}
var
contor1:byte;
begin
with BazaDeDate do
begin
StergeEcran;
for contor1:=1 to ContorAtribute-1 do
begin
writeln(contor1,'. ',atribute[contor1]);
if contor1 mod 20 = 0 then
begin
writeln;
write('Apasati ENTER pentru continuare');
readln;
StergeEcran;
end;
end;
writeln;
write('Apasati ENTER pentru continuare');
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;
contor1,contor2:byte;
begin
CitescBazaDeDate;
NumarNotiune:=0;
with BazaDeDate do
begin
StergeEcran;
write('Stergeti notiune? D/N: ');
CitescOptiune;
117
if optiune='D' then
begin
AfisareNotiuni;
write('Introduceti numarul notiunii (0 - abandon): ');
readln(NumarNotiune);
if NumarNotiune<>0 then
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): ');
readln(NumarNotiune);
if NumarNotiune<>0 then
begin
for contor1:=NumarNotiune to ContorAtribute-1 do
atribute[contor1]:=atribute[contor1+1];
for contor2:=1 to ContorNotiuni-1 do
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;
write('Introduceti numarul notiunii (0 - abandon): ');
readln(NumarNotiune);
if NumarNotiune<>0 then
begin
StergeEcran;
writeln('Modificare atributele notiunii: ',
notiuni[NumarNotiune],' :');
for contor1:=1 to ContorAtribute-1 do
begin
118
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;
contor1,contor2: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.');
for contor1:=1 to ContorAtribute-1 do
begin
writeln('Atributul: ',atribute[contor1]);
writeln('Introduceti valoarea de adevar: ');
writeln('D - pentru ADEVARAT');
writeln('N - pentru FALS');
writeln('I - pentru NEDEFINIT');
120
{
Afisare rezultat.
}
StergeEcran;
for contor2:=1 to ContorNotiuni-1 do
begin
Maxim:=0;
Pozitie:=0;
for contor1:=1 to ContorNotiuni-1 do
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;
121
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:
123
x1
x2
w1
w2
y=w1x1+
+w2x2
f=y(t)
124
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 reprezint de fapt
determinarea unei drepte care s separe planul n dou pri, fiecare parte a planului
trebuind s conin numai punctele de acelai fel. In acest fel relaia:
y = w1 x1 + w2 x2
poate fi transformat n:
w1 x + w2 y t = 0
dW = I x (T - O)T
dt = (T O)
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 motiv 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.
126
Din aceast reprezentare grafic se observ modul n care este separat planul n
cele dou regiuni. Dup instruire perceptronul este capabil s clasifice punctele 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.
127
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
}
128
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
for contor1:=1 to 24 do
writeln;
end;
procedure IntroducereDate;
{Procedura IntroducereDate solicita utilizatorului introducerea urmatoarelor date:
129
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;
for contor1:=1 to 2 do
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
contor1,contor2:byte;
begin
for contor1:=1 to NrSeturiDate do
iesire[contor1]:=0;
for contor1:=1 to NrSeturiDate do
for contor2:=1 to 2 do
iesire[contor1]:=iesire[contor1]+intrare[contor2,contor1]*
pondere[contor2];
131
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;
for contor1:=1 to NrSeturiDate do
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
for contor1:=1 to NrSeturiDate do
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)) +
132
+ a12*(tinta(2)-iesire(2)) +
+ a13*(tinta(3)-iesire(3)) + ...
intrarea 2 Pondere(2) = Pondere(2)
+ a21*(tinta(1)-iesire(1)) +
+ a22*(tinta(2)-iesire(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
contor1,contor2:byte;
begin
for contor1:=1 to 2 do
for contor2:=1 to NrSeturiDate do
Pondere[contor1]:=Pondere[contor1]+Intrare[contor1,contor2]*
(Tinta[contor2] - Iesire[contor2]);
for contor1:=1 to NrSeturiDate do
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.');
133
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.
Lucrrile 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.
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).
135
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)
136
(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)
(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 aceast ordine:
Push: 5
Push: abc
137
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.
Lucrrile 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 mbuntire 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 GESTIONARE 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))
)
138
(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
139
(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)
(autor (nume ?n) (prenume ?p) (titlu ?t) )
(test (eq (lowcase ?x) (lowcase ?p)))
=>
(printout t ?n " " ?p " -- " ?t crlf)
)
(defrule cautare_dupa_titlu
(optiune 3)
(titlu ?x)
(autor (nume ?n) (prenume ?p) (titlu ?t) )
(test (str-index (lowcase ?x) (lowcase ?t)))
=>
(printout t ?n " " ?p " -- " ?t crlf)
)
(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)) )
140
(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
(declare (salience -5))
?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
(declare (salience -10))
=>
(close)
)
Referatele de laborator vor conine programul realizat, explicarea
funcionrii acestuia, baza de date, rezultatele obinute, propuneri de mbuntire
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.
141
;;;======================================================
;;; 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 ""
(declare (salience 20))
142
;;;***************************
(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))
144
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?")
147
150
BIBLIOGRAFIE
1. Aur Dorian, Aur Liviu Modelri neuronale n inteligena artificial, Editura
Grigore Tabacaru, Bacu, 1997
2. Dumitracu Liviu, s.a. - Elemente de inteligen artificial pentru conducerea
operativ a produciei, Editura Academiei, Bucureti 1983
3. Hristev Ryurick Marius - Introducere n: Prolog, un limbaj al inteligenei artificiale,
Editura APH, Bucureti 1992
4. Malita Mihaela, Malita Mircea - Bazele inteligenei artificiale. Logici
propoziionale, Editura Tehnic, Bucureti, 1987
5. Streinu Ileana - LISP. Limbajul de programare al inteligenei artificiale, Editura
tiinific i enciclopedic, Bucureti 1986
6. Becheanu M., s.a. Logic matematic i teoria mulimilor, 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 aplicaii. Editura
TEORA, Bucureti, 1996
9. Flondor Paul, Ionescu Cezar - Introducere n algoritmi genetici, ALL, Bucureti,
1999
10. Chiorean Ioana - Calculul paralel. Fundamente. Editura Microinformatica, Cluj,
1995
11. H.N. Teodorescu, M. Zbancioc, Oana Voroneanu Sisteme bazate pe cunotine.
Aplicaii. Editura Performantica, Iai, ISBN-973-730-014-9, 2004
12. H.N. Teodorescu - Program Design (ediia a-II-a), Pro-Copy, Tampa, USA, 2000
13. H.N. Teodorescu - Tehnici de programare avansat, Note de curs, UT Iai, 2001
14. A.Brezulianu Sisteme Fuzzy i Aplicaii, Ed. Tehnici i Tehnologii, Iai, 2002
15. D. Cristea Programarea bazat pe reguli (Rule-Based Programming), Romanian
Academy Publishing House, 2002, Bucharest.
16. D. Galea, Mihaela Costin, M. Zbancioc Programarea n CLIPS prin exemple,
Tehnopress Publishing House, 2001, ISBN 973-8048-45-1, pag.146
17. D. Galea, Mihaela Costin, M. Zbancioc Aplicaii de Inteligen Artificial n
CLIPS, Tehnopress Publishing House, 2001, ISBN 973-8048-51-6. pag. 152
151