UNIVERSITATEA DIN BACU FACULTATEA DE INGINERIE

DAN ROTAR

INTELIGEN ARTIFICIAL
Note de curs Caiet de seminar Indrumar de laborator

EDITURA ALMA MATER BACU 2007

CUPRINS
Pag. Capitolul 1 DOMENIILE INTELIGENEI ARTIFICIALE 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 Capitolul 3 SISTEME EXPERT Sisteme expert generaliti Structura general a unui sistem expert Funcionarea unui sistem expert 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 5 7 7 7 9 10 13 14 16 16 17 18 19 19 20 20 22 24 24 25 25

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.

3.1. 3.2. 3.3.

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.

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 Capitolul 5 REELE NEURALE Modelul general al unei reele neuronale Ecuaia de evoluie a reelei Paradigme ale instruirii Topologia multistrat a reelelor neurale Capitolul 6 MULIMI NUANATE Noiunea de mulime nuanat Sisteme expert bazate pe mulimi nuanate Capitolul 7 ALGORITMI GENETICI Generaliti Algoritmul genetic canonic SEMINAR Seminar 1 Seminar 2 Seminar 3 Seminar 4 Seminar 5 Seminar 6 Seminar 7 Laborator Laborator 1,2,3 Laborator 4,5,6 Laborator 7,8,9 Laborator 10,11,12,13,14 BIBLIOGRAFIE

43 44 45 45 46 47 48 48 50 51 51 53 53 55 56 57 58 58 60 62 62 62 66 66 68 70 71 72 72 74 77 90 123 134 151

5.1. 5.2. 5.3. 5.4.

6.1. 6.2.

7.1. 7.2.

CAPITOLUL 1 DOMENIILE INTELIGENEI ARTIFICIALE

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

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

nelegerea limbajelor naturale ofer cel mai mare potenial de utilizare din cauz c acestea vor permite oamenilor s interacioneze cu calculatoarelor fr a fi 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. Logica clasic a propoziiilor
2.1.1. Simboluri, formule Obiectul logicii este identificarea i folosirea legilor raionamentului uman. Logica simbolic utilizeaz simboluri pentru unitile de gndire i pentru operaiile asupra lor. Considerm propoziiile: p Ion citete. q Ion scrie. Notaia de mai sus arat c propoziia Ion citete va fi reprezentat prin simbolul p. Propoziia trebuie s fie adevrat sau fals fr a putea fi adevrat i fals n acelai timp. Pentru propoziia neadevrat se folosete negaia: ~ p Nu este adevrat c Ion citete (Ion nu citete). Ct timp nu admitem dect cele dou valori de adevr (fals, adevrat) suntem n cadrul logicii clasice sau a logicii bivalente. n logica de tip propoziional, propoziiile sunt uniti nedecompozabile. Orice consideraie asupra structurii lor interne este irelevant. Propoziiile simple sau atomi p, q, r, ... sunt compozabile. Ele se pot combina dnd natere la noi propoziii, la rndul lor adevrate sau false. Simbolurile numite conectori indic operaiile de asociere sau combinare, care sunt cele mai frecvente n vorbire sau raionament: ^ pentru i : p ^ q Ion citete i Ion scrie v pentru sau : p v q Ion citete sau Ion scrie pentru dac p atunci q : p q Dac Ion citete atunci Ion scrie pentru p dac i numai dac q: p q

Propoziiile p ^ q, p v q, p q sunt formule propoziionale. Formulele vor fi notate cu majuscule: P, Q, R, ... . De exemplu: P : (p ^ q) r, unde: r Ion este mulumit. Interpretarea formulei P este: dac Ion citete i Ion scrie, atunci Ion este mulumit. Formula P este format din trei atomi. Ea poate fi privit drept o funcie de atomii p, q, r, care, din acest motiv, se numesc variabile propoziionale. n logica propoziional unitatea principal de lucru este formula. Totalitatea simbolurilor logicii propoziiilor constituie un alfabet. n cele ce urmeaz simbolurile logice vor fi urmtoarele: p, q, r, ..., ~, ^, v, , , (, ) cu alte cuvinte, simbolurile pentru mulimea finit sau infinit de atomi: p, q, r, ... sau p1, p2, p3, ..., pn, ...; simbolurile pentru conectorii logici, ce vor fi definii mai jos; parantezele, stng, (, i dreapt, ). Simbolurile ce nu sunt cuprinse n alfabet sunt simboluri metalogice. Aceast restricie surprinde de la nceput: simbolurile P, Q, R, ... sau P1, P2, P3, ... utilizate n formule care nu figureaz n alfabet. Alfabetul mpreun cu formulele formeaz limbajul. Proprietile, legile, regulile pot fi enunate pentru atomi i atunci avem nevoie de o regul suplimentar de trecere de la atomi la formule (regula substituiei) sau pot fi enunate direct pentru formule, caz n care poart denumirea de scheme. Exemplu: p^(pq)q este o formul ntotdeauna adevrat (tautologie), oricare ar fi atomii p, q. Iar: P^(PQ)Q unde P, Q sunt formule, este i ea totdeauna adevrat, oricare ar fi P, Q, de exemplu: P=(p q) i: Q=(pvq) ^ (p v ~ q) Legea tautologic enunat pentru atomi poate fi generalizat prin regula substituiei. Este convenabil s o enunm ca o schem n forma general pentru formule, fr a mai meniona substituia. 8

O formul P se obine din atomii p, q, r, ... prin operaiile efectuate de conectori. Definiia recursiv a formulei este: 1) un atom este o formul; 2) dac P este o formul, (~P) este o formul; 3) dac P i Q sunt formule, atunci (P^Q), (PvQ), (PQ), (PQ) sunt formule; 4) toate formulele se obin prin aplicarea regulilor 1) 3). 2.1.2. Evaluare, funcie de adevr Introducem pe mulimea atomilor o funcie, numit de evaluare, care aplic fiecare atom pe mulimea (adevrat, fals): v(p)=1 (adevrat) sau v(p)=0 (fals) Prima problem a calculului propoziiilor const n determinarea valorii de adevr a unei formule n funcie de valoarea de adevr a atomilor. Notm valoarea de adevr a unei formule P cu Pv [0,1], sau cu notaia echivalent v(P). Stabilim prin recuren urmtoarele reguli pentru evaluarea formulelor: dac P este un atom, Pv = v(P); dac P= ~ Q, atunci Pv = 1 dac Q = 0 sau Pv = 0 dac Q = 1; (P ^ Q)v = 1 dac Pv = Qv = 1 sau (P ^ Q)v = 0 n celelalte cazuri; (P v Q)v = 0 dac Pv = Qv = 0 sau (P ^ Q)v = 1 n celelalte cazuri; (P Q)v = 0 dac Pv =1 i Qv = 0 sau (P Q)v = 1 n celelalte cazuri (implicaie, se citete: P implic Q); 6) (P Q)v = 1 dac Pv = Qv sau (P Q)v = 0 n celelalte cazuri (dubla implicaie, se citete: dac P, atunci i numai atunci Q); 1) 2) 3) 4) 5) 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

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

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

Formula P este satisfcut de interpretarea {~p, ~q} care constituie un model a lui P. Interpretarea {p, q} falsific pe P. 2.1.3. Tautologie, validitate, consisten O formul este valid, dac i numai dac este adevrat n toate interpretrile. Altfel (dac i numai dac nu este valid) este nevalid. O formul este inconsistent dac i numai dac este fals n toate interpretrile. O formul este consistent dac i numai dac nu este inconsistent. Denumirea clasic a formulei valide din punct de vedere semantic este tautologie, iar a celei inconsistente este contradicie.

10

Exemple: 1) Formula P: p v ~ p este o tautologie (formul valid), ntruct funcia sa de adevr ia n toate interpretrile valoarea 1. 2) Formula P: p ^ ~ p este o contradicie (formul nevalid) pentru c funcia sa de adevr ia n toate interpretrile valoarea 0. Propoziii. 1) O formul este valid dac i numai dac negaia ei este valid. 2) O formul este inconsistent dac i numai dac negaia ei este valid. 3) O formul este nevalid dac i numai dac exist o interpretare n care este fals. 4) O formul este consistent dac i numai dac exist o interpretare n care este adevrat. 5) O formul valid este consistent. 6) O formul consistent nu este neaprat valid. 7) O formul inconsistent este nevalid. 8) O formul nevalid nu este neaprat inconsistent. ntruct folosirea terminologiei de mai nainte depete necesitile ce se ivesc n demonstrarea automat a teoremelor, sunt folosite cu precdere urmtoarele expresii: O formul consistent se numete realizabil. O formul este nerealizabil (inconsistent) dac i numai dac nu este realizabil. Definiiile proprietilor de validitate (tautologii), consisten (realizabile), inconsisten (contradicii, nerealizabile) i nevaliditate a formulelor sunt reprezentate n schema urmtoare:
CONSISTEN=REALIZABIL Pv = 1 uneori VALID=TAUTOLOGIE Pv = 1 ntotdeauna NEVALID Pv = 0 uneori CONTRADICIE=NEREALIZABIL Pv = 0 ntotdeauna

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

dintr-o singur formul, se spune c aceasta este realizabil, dac S este realizabil, i nerealizabil, dac S este nerealizabil. n limbajul evalurilor o tautologie este o formul T pentru care 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

Sunt frecvente i urmtoarele legi: T13 T14 T15 T16 T17 T18 T19 T20 T21 T22 T23 T24 T25 T26 T27 T28 (P ^ (P Q)) Q (~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) (~P ^ ~Q) ~ (P v Q) ~(P ^ Q) (~ P v ~ Q) (~ P v ~ Q) ~(P ^ Q) 12 modus ponendo ponens sau modus ponens sau regula detarii modus tollendo tollens modus tollendo ponens absurditate negare (contradicie) simplificare schimbarea premiselor legea lui Frege

T25 T28: legile lui De Morgan

T29 T30 T31 T32 T33

(P Q) (~Q ~P) (P ~Q) (Q ~P) (~P Q) (~Q P) (~P ~Q) (Q P) ((P Q) P) P

T29 T32: legile transpunerii

legea lui Pierce

Demonstraia caracterului tautologic al formulelor T0 T33 se face prin scrierea tabelei de adevr a fiecrei formule, a crei ultim coloan va fi compus din 1. 2.1.4. Metoda lui Quine Un procedeu de a decide asupra realizabilitii unei formule (sau a caracterului de tautologie sau de contradicie) care nu recurge la tabela de adevr a fost dat de Quine. Procedeul const din urmtorii pai: 1) Atomul care intervine cel mai frecvent este nlocuit o dat cu V (adevr) i a doua oar cu F (fals), obinndu-se dou formule. 2) n fiecare din ele se aplic urmtoarele reguli: a) b) c) d) e) f) se suprim V ca element al conjunciei; se suprim F ca element al disjunciei; o conjuncie cu F se nlocuiete cu F; o disjuncie cu V se nlocuiete cu V; o implicaie coninnd pe V se nlocuiete cu consecventul; o implicaie coninnd pe F se nlocuiete cu negaia antecedentului g) se suprim V ca membru al unei duble negaii; h) se nlocuiete dubla negaie, care conine F ca membru, cu cellalt membru al ei. 3) Se aplic regula 1) la urmtorul atom cu frecvena cea mai mare i se trece la regula 2), apoi la regula 3), pn la epuizarea atomilor. Toate regulile se bazeaz pe tabele de adevr ce definesc conectorii. Astfel regula b), F v q =q, exprim faptul c dac p este fals, p v q ia valoarea de adevr a lui q. Regula d), V v q = V, se reduce la faptul c o disjuncie este adevrat dac un element este adevrat. Regula f), cu privire la F q, sau p F, se deduce din: p 1 1 0 0 13 q 1 0 1 0 pq 1 0 1 1

n primul caz F q nseamn c p q este adevrat, deci putem s-o nlocuim cu negaia antecedentului (V). n al doilea caz, p F, evalurile (1,0) i (0,0), rezult din tablou c are ntotdeauna valoarea lui ~p. Exemplu: Fie formula (p ^ q) v (~p ^ ~r) (q r). Este o tautologie sau o contradicie? Aplicm metoda lui Quine: ((p ^ q) v (~p ^ ~r)) (q r) ((V ^ q) v (F ^ ~r)) (q r), ((F ^ q) v (V ^ ~r)) (q r) (q v (F ^ ~r) (q r) (F v (V ^ ~r) (q r) (q v F) (q r) (V ^ ~r) (q r) q (q r) ~r) (q r) V (Vr) Vr r V F F F (Fr) V F (qV) V (qF) V qF q V

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

Dar implicaia P Q este fals numai cnd P este fals i Q este adevrat. Vom scrie deci sub conectorul principal din P valoarea 1, sub conectorul principal din Q valoarea 0 i deasupra ambilor conectori numrul pasului (2). Continum n acelai fel pn cnd: (a) obinem o evaluare consistent (necontradictorie) pentru toate variabilele propoziionale sau 14

(b) nu gsim o asemenea evaluare. n primul caz, ipoteza iniial este corect i formula este fals; n al doilea caz falsificarea nu a reuit i deci formula este valid. Cnd formula este de forma: 1 P Q 0

din atribuirea valorii 0 nu rezult n mod unic c P este adevrat sau fals, de aceea trebuie s considerm toate cazurile: 212 p^Q 100 212 P^Q 001 212 P^Q 000

unde valorile i indicii se pun i deasupra conectorilor principali din formulele P i Q. Dac fiecare din cele trei cazuri conduc la contradicii, formula iniial este valid. n caz c cel puin unul din ele permite gsirea unei evaluri necontradictorii, formula a putut fi falsificat i este inconsistent. Evalurile pentru care se obine o contradicie sunt subliniate. Exemple: 1) Fie formula ((p q) ^ r) ((~r v p) q). Aplicnd metoda reducerii, se obine o contradicie prin faptul c la pasul 3: v(r)=1, iar la pasul 9: v(r)=0 63 5 23 1 8947 2 4 ((p q) ^ r) ((~ r v p) q) 0 1 0 11 0 1010 0 0 Observm c la pasul 3 din faptul c valoarea conjunciei din membrul nti este 1, rezult c v(p q) =1 i v(r)=1. ntruct v(q)=0 (rezult din membrul 2 la pasul 4), v(p)=0 (altfel v(pq)=0). Dar dac introducem v(p)=0 (din membrul nti, pasul 6) n membrul doi (pasul 7), obinem v(~r)=1 i v(r)=0, ceea ce contrazice valoarea care i s-a atribuit lui r la pasul 3. Formula este o tautologie. 2) Fie formula ((~r v p) q) ((p q) ^ r). ntruct la pasul 3 valoarea lui ~r v p nu rezult n mod unic, trebuie s considerm urmtoarele trei cazuri: 3 2 3 1 2 a) ((~r v p) q) ((p q) ^ r) 1 1 1 0 0

15

3 2 3 1 2 b) ((~r v p) q) ((p q) ^ r) 0 1 1 0 0 3 2 3 1 2 c) ((~r v p) q) ((p q) ^ r) 0 1 0 0 0 Cazul b) i cazul c) duc la contradicii, dar cazul a) permite o evaluare consistent: ((~ r v p) q) ((p q) ^ r) 1 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 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)

5. Distributivitatea 6. Dubla negaie 7. Legile lui De Morgan 8. Transpunerea 9. Negaia implicaiei 10. Formula bicondiional

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

16

Fie F o formul n care apar atomii 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 P

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

Astfel dualul enunului dac P este o tautologie, P v Q este o tautologie este dac P este nerealizabil, P ^ Q este nerealizabil. 2.1.9. Conectori adecvai O mulime de conectori se numete mulime adecvat, dac fiecare formul poate fi exprimat cu ajutorul conectorilor acestei mulimi. {~, ^, v}, {~, ^}, {~, v} i {~, } sunt mulimi adecvate de conectori. Mulimi adecvate formate dintr-un singur conector: 1) - rejecie sau conectorul lui Nicod se citete nici ..., nici ... = NOR (tehnic) tabelul de adevr: p q pq ------------------------1 1 0 1 0 0 0 1 0 0 0 1 Relaiile care leag acest conector de negaie i conjuncie sunt: ~p = p p i p ^ q = (p p) (q q)

2) | - incompatibilitate sau conectorul lui Sheffer NAND p|q = ~p v ~q tabelul de adevr: p q p|q ----------------------1 1 0 1 0 1 0 1 1 0 0 1 Relaiile care leag acest conector de negaie i conjuncie sunt: 18

~ p = p|p i p ^ q = (p|p) | (q|q). Avantajul de a micora numrul de conectori este pltit prin lungimea scrierii formulelor. 2.1.10. Consecine logice Fie n formule P1, P2, ..., Pn. Formula P este o consecin logic (tautologic) a premiselor P1, P2, ..., Pn dac pentru fiecare evaluare v pentru care P1v = P2v = ... = Pnv = 1 avem Pv = 1. Pentru consecina logic folosim notaia P1, P2, ..., Pn |= P. Simbolul |= n faa unei formule denot c este o tautologie: |= P (citim P este o tautologie). Cu alte cuvinte, orice model al conjunciei premiselor P1, P2, ..., Pn este i model al concluziei. Fie formulele P1, P2, ..., Pn. Formula P este o consecin logic a premiselor Pi, dac i numai dac P1^ P2^ ...^ Pn^ ~P este nerealizabil. Problema stabilirii dac o formul este consecin logic (numit i interferen tautologic) revine astfel la stabilirea faptului dac o alt formul este tautologie sau nerealizabil (pentru un numr redus de variabile propoziionale se poate recurge la tabela de adevr a acestei formule). 2.1.11. Forme normale 1. Orice formul care nu este o contradicie este logic echivalent cu o formul restrns normal disjunctiv:

im jn

ij

unde lij sunt literale. 2. Orice formul care nu este o tautologie este logic echivalent cu o formul de form normal conjunctiv:

l
in jm

ij

unde lij sunt literale. Conjunciile i disjunciile care au proprietatea de a lua valoarea formulei n cte o interpretare a ei se numesc minitermeni sau clauze conjunctive, respectiv maxitermeni sau clauze disjunctive.

19

2.2.

Sistemul deductiv al calculului propoziiilor

2.2.1. Demonstraie i deducie Abordarea sintactic este susceptibil de un grad nalt de formalizare. Simbolurile sunt iniial neinterpretate i servesc la construirea unui sistem deductiv abstract. Prin interpretarea ca propoziii se obin consecine noi despre logica acestora. Un sistem formal este definit de: 1) 2) 3) 4) un alfabet de simboluri, o mulime de formule bine formale, o mulime de axiome, reguli de deducie.

Sistemul formal L este definit astfel: 1) alfabetul simbolurilor este infinit, ~, , (, ), p1, p2, ...; 2) o formul bine format (pe scurt fbf) este definit recursiv: a) pi este o formul fbf; b) dac A i B sunt formule fbf, (~A) i (~B) sunt formule fbf; c) mulimea formulelor fbf este generat numai prin regulile a) i b); 3) oricare ar fi formulele fbf A, B, C, urmtoarele formule fbf sunt axiomele lui L: L1 (A (B A)), L2 ((A (B C)) (( A B) (A C))), L3 ((( ~ A) (~ B)) (B A)). 4) regula de inferen este MP (modus ponens): oricare ar fi formulele fbf A, B, din A i (A B) rezult B. Din categoria simbolurilor primitive fac parte: a) variabilele individuale; b) conectivele logice: conjuncie, negaie; ntruct reducerea numrului conectivelor logice duce la pierderea semnificaiei naturale a proceselor infereniale, pentru raiuni practice se accept drept primitive toate conectivele logice uzuale ale calculului propoziional: c) cuantificatorul existenial . Cuantificatorul universal poate fi exprimat cu ajutorul cuantificatorului existenial prin transcrierea: xF ~()~F d) simbolurile relaionale; e) simbolurile funcionale; f) cte o constant individual. 20

Prima noiune care este introdus n cadrul unui sistem formal este aceea de demonstraie. Definiie. Se numete demonstraie secvena de formule 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. L. Ultima formul An este o teorem n L, iar secvena este demonstraia lui An n

Exemplu: Fie: A1=p1(p2p3), A2=(p1(p2p3)) ((p1p2) (p1p1)), A3=(p1p2) (p1p1)

Deci, A3 este o teorem n L iar A1, A2, A3 demonstraia lui A3 n L. ntr-adevr, ntruct axiomele sunt scrise pentru A, B, C din L, este suficient s punem A = p1, B = p2, C = p1, i se obin: L1 L2 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)

Noiunea de demonstraie este lrgit de cea de deducie. Definiie. Fie o mulime de formule L. Se numete deducie din o secven A1, A2, ..., An, astfel c: 1) Ai este o axiom (1 i n) sau 2) Ai este un membru a lui sau 3) Ai urmeaz din MP din doi membri antecedeni ai irului Aj, Ak (j <i, k<i). scriem: Spunem c ultimul termen An este deductibil din sau consecin a lui i |- An.
L

21

Structura unei inferene. Premise 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: predicatul ce specific semnificaia funcional a propoziiei; argumentul predicatului specific semnificaia suportului funcional al propoziiei.

Orice predicat este P(x) joac rolul de funcie propoziional deoarece pentru orice valoare a argumentului independent x, acesta ia ca valoare o propoziie, cu valoarea de adevrat sau fals. Numrul de obiecte individuale ce compun argumentul reprezint aritatea predicatului. Astfel pentru: n=0 predicatul este o propoziie; n=1 predicatul specific o proprietate a argumentului; n=2 predicatul specific o proprietate binar; n=3 relaie n-ar. Orice predicat este de ordinul nti dac variabilele sale nu sunt predicate (se poate spune despre astfel de variabile c pot fi considerate predicate de ordinul zero). Un predicat care are cel puin una din variabilele sale individuale predicate de ordinul nti se spune c este un predicat de ordinul doi. Se poate spune n general c un predicat este de ordin n dac cel puin una din variabilele sale este un predicat de ordinul n-1. Pentru calculul cu predicate de ordinul nti formulele se formeaz dup regulile limbajului calculului propoziional, n care variabilele propoziionale sunt nlocuite cu predicate. n relaia folosit pentru predicate, variabilele au semnificaie nu prin simbolurile folosite, ci prin poziia i rolul pe care l joac n definirea predicatului respectiv. Variabilele folosite n aceste notaii sunt denumite variabile formale, iar notaia definitorie pentru predicate este denumit expresie predicativ sau ion. Se spune c P(x,y) i P(u,v) sunt diferite atari de variabile formale pentru aceeai expresie predicativ primar P(_1, _2) iar P(a, b) este o instan a acestei expresii predicative n care a i b au fost asignate primului i respectiv celui de-al doilea 22

argument al predicatului. Pentru aprecierea valorii de adevr n raport cu domeniul n care iau valori variabilele individuale ale predicatelor componente, se introduc o serie de operatori unari denumii i cuantificatori ce acioneaz asupra variabilelor. cuantificatorul universal indic faptul c formula prefixat este valid pentru toate valorile posibile n domeniul variabilei x; cuantificatorul existenial indic faptul c formula prefixat este valid pentru cel puin o valoare din domeniul variabilei x. Teoria demonstraiei la calculul cu predicate de ordinul nti folosete pe lng axiomele i regulile de inferen ale limbajului calculului propoziional i urmtoarele axiome: |= xA(x) A(r) |= A(r) xA(x) n care: x este orice variabil A(x) este o formul r reprezint orice variabil nu neaprat distinct de x A(r) este rezultatul substituiei libere cu r a oricrei apariii libere a variabilei x n A(x).

23

CAPITOLUL 3 SISTEME EXPERT

3.1. Sisteme expert generaliti
Sistemele expert bazate pe 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

3.2. Structura general a unui sistem expert

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

Interfaa utilizator

Expert uman Inginer de cunotine

Modul de achiziie a cunotinelor

Baza de cunotine

Mecanism de inferen

Utilizator

Baza de fapte

Modul de explicare

Achiziia de cunotine

Reprezentarea cunotinelor

Tratarea cunotinelor

Utilizarea cunotinelor

3.3. Funcionarea unui sistem expert

Un sistem expert presupune existena unor reguli de forma: Dac situaie Atunci aciune. Un loc aparte l ocup regulile deductive (sau inferene) care sunt de tipul: Dac premisa este adevrat atunci concluzia este adevrat. Reprezentarea cunotinelor. Cunotinele care sunt reprezentate n baza de fapte sunt cunotine afirmative.

25

Cunotinele coninute n reguli se numesc cunotine operatorii. Ele indic modul cum sunt folosite faptele. Din acestea se obin raionamente sau moduri de aciune. Mulimea de reguli i de fapte formeaz baza de cunotine. Cunotinele sistemului de control se numesc strategii de control. Motorul inferenial. La un sistem expert este necesar s fie dat o stare a bazei de fapte n care s poat fi recunoscute regulile aplicabile. Aceast operaie se numete filtrare. Preselecia regulilor naintea filtrrii se numete restricionare. Dup ce s-a fcut preselecia i filtrarea trebuie aleas o strategie de control (operaie de selectare). Strategiile de control la sistemele expert. Fie o mulime de reguli coninute n baza de cunotine sau o submulime din aceste reguli. Filtrarea const n a gsi printre aceste reguli pe acelea a cror precondiie este satisfcut. Trebuie deci, comparat precondiia cu informaiile care exist n baza de fapte. De regul se aplic o regul deductiv de tipul celei artate mai sus. n cazul n care asupra acestei operaii nu se aplic restricii atunci activitatea decurge conform schemei logice prezentate n continuare.

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

Funcionarea unui sistem cu restricie

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.

4.2. Execuia unui program n mediul de programare CLIPS

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

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

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

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

Figura 1 Selectnd din meniul principal Windows, opiunea Facts Window se afieaz fereastra din figura 2.

Figura 2. 31

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

4.3. Structura programului CLIPS

4.3.1. Constructorii Mai muli constructori de definiie apar n CLIPS: defmodule, defrule, deffacts, deftemplate, defglobal, deffunction, defclass, definstances, defmessagehandler, defgeneric i defmethod. Toate construciile n CLIPS sunt cuprinse ntre paranteze, ncepnd cu o parantez deschis ( i terminndu-se cu o parantez nchis ) . Aceti constructori se folosesc pentru a 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.2. Faptele n CLIPS sunt trei forme principale de reprezentare a informaiei : fapte (facts), obiecte i variabilele globale. Faptele sunt forma principal de reprezentare a informaiei n sistemul CLIPS. Fiecare fapt reprezint un element de informaie care va fi plasat n lista de fapte numit factlist. Faptul este forma fundamental de date folosit de reguli i const ntr-un nume de relaie urmat de zero sau mai multe sloturi (cmpuri simbolice crora li se pot asocia valori). Forma general a unui fapt va fi urmtoarea : fact => ( nume_relaie [ (slot)* ] [ (multislot)* ] ) Parantezele ptrate indica faptul ca existena sloturilor este opional, iar semnul * arat faptul c putem avea zero sau mai multe sloturi. Se observ faptul c n CLIPS trebuie s cuprindem ntre paranteze att numele de relaie ct i sloturile. Un slot este la rndul su format dintr-un nume de slot, cruia i se poate asocia o valoare. Exist ns i posibilitatea asocierii de mai multe valori i n acest caz spunem ca avem un multislot. Acest lucru este posibil datorit existenei n CLIPS a multicmpului (multifield) care este de fapt o secven de zero sau mai multe cmpuri. Afiarea n CLIPS a unei valori multicmp se va realiza prin nchiderea acestuia ntre paranteze. Trebuie reinut faptul c o valoare multifield (a) nu este unul i acelai lucru cu o valoare cmp (single field) (a) . slot => ( nume_slot valoare ) ultislot => ( nume_slot [ valoare ]* ) Un slot trebuie s aib obligatoriu asociat o valoare, pe cnd la un multislot asocierea unei valori nu e obligatorie. 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) 32

(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

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

(initial-fact date-initiale salariu_maxim) CLIPS> (reset) <== f-0 (a) ==> f-0 (initial-fact) ==> f-1 (angajat (nume Cozma George) (salariu 1500000) ) ==> f-2 (angajat (nume Miron Liliana) (salariu 1650000) ) ==> f-3 (angajat (nume Mazilu Razvan) (salariu 1580000) ) ==> f-4 (data (zi 31) (luna 9) (an 1991) ) CLIPS> Se observ existena nc de la startarea CLIPS-ului a construciei deffacts initial-fact. Funcia get-deffacts-list ne informeaz de existena celor trei construcii deffacts, dar abia dup ce se d comanda reset n lista de fapte vor fi introduse faptele acestora. Ultima construcie deffacts salariu_minim nu are nici un fapt, existena ei fiind oarecum inutil. 4.3.5. Fapte ordonate Un fapt ordonat (ordered fact) const ntr-un nume de relaie urmat de zero sau mai multe cmpuri separate de spaii. Ar putea fi comparat cu un slot de tip multifeld n care se pun toate valorile ce urmeaz dup numele de relaie. Lipsa sloturilor nu face necesar existena unei construcii deftemplate care s le expliciteze. Din acest motiv faptele care corespund unei construcii deftemplate se mai numesc i deftemplate facts sau non-ordered facts. Faptele ordonate sunt create automat de un deftemplate implicit al CLIPS-ului (fa de celelalte fapte care necesit existena unui deftemplate explicit). n acest mod se poate implementa foarte uor o stiv sau o coad, sau se pot reprezenta iruri de elemente. De exemplu: (numere_pare 2 4 6 8 10) (numere_prime 2 3 5 7 11) Aceste fapte se pot realiza n mod echivalent, folosind o construcie deftemplate: (deftemplate numere_pare (multislot valori)) n acest caz faptul echivalent va arta astfel: (numere_pare (valori 2 4 6 8 10)) Cmpurile ntr-un fapt ordonat pot fi, orice tip de dat primitiv (cu excepia primului cmp care reprezint numele de relaie i trebuie s fie de tip simbol), i nu exist restricii privitoare la ordinea acestora. Totui urmtoarele simboluri sunt rezervate i nu pot fi primul cmp dintr-un fapt (numele de relaie) : test, and, or, not, declare, logical, object, exists, i forall. Aceste simboluri rezervate pot fi folosite la numele unui slot, dar oricum acest lucru nu este recomandat. n urmtoarele exemple de fapte : (test de inteligenta artificiala) (Test de inteligenta artificiala) n primul caz CLIPS-ul ne va informa c nu putem folosi ca nume de relaie simbolul test, dar n al doilea caz acesta va accepta ca nume de relaie simbolul Test, deoarece dup cum s-a mai spus CLIPS-ul este case-sensitive i vede cele dou cmpuri ca fiind total diferite. n al doilea fapt lista de elemente este format din trei cmpuri: de , inteligenta, artificial. CLIPS-ul face deosebirea ntre un ordered fact i un deftemplate fact extrgnd primul cmp din fapt (numele de relaie) i comparnd-ul apoi cu numele fiecrui deftemplate. Dac la un deftemplate fact schimbnd ordinea sloturilor se 35

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

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

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

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

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

Se observ c faptul watch activations nu afieaz nici un mesaj atunci cnd o regul este aprins (executat) dup ce a fost dat comanda run ,dei aceasta a fost tears din agend n momentul aprinderii sale. Dac se urmresc regulile atunci se va afia un mesaj de fiecare dat cnd o regul este aprins. CLIPS> (reset) CLIPS> (watch rules) CLIPS> (run) FIRE 1 actiunea_zilei: f-4 FIRE 2 find_person: f-1 CLIPS>(unwatch rules) CLIPS> Numrul aflat dup simbolul FIRE indic ct de multe reguli s-au aprins dup ce a fost dat comanda run. Dac se urmresc statisticile vor fi afiate pe ecran o serie de mesaje informaionale dup cum se va vedea: CLIPS> (reset) CLIPS> (watch statistics) CLIPS> (run) 2 rules fired Run time is 0.054 seconds. 36.4 rules per second. 6 mean number of facts (7 maximum) 1 mean number of instances (1 maximum) 2 mean number of activations (2 maximum) CLIPS> (unwatch statistics) CLIPS> 4.3.12. Afiarea listei membrilor unei construcii specificate Pentru afiarea listei regulilor aflate la un moment dat n CLIPS se utilizeaz comanda list-defrules. De asemenea comenzile list-deftemplates i list-deffacts sunt utilizate pentru afiarea construciilor deftemplate, respectiv a construciilor deffacts. Sintaxa acestor comenzi este urmtoarea: (list-defrules) (list-deftemplates) (list-deffacts) CLIPS> (list-deffacts) initial-fact date-initiale For a total of 2 deffacts. 4.3.13. Afiarea textului membrilor unei construcii specificate Ca i mai sus avem la dispoziie trei comenzi ppdefrule (pretty print defrule), ppdeftemplate i ppdeffacts utilizate la afiarea textului (coninutului) unei construcii defrule, deftemplate sau deffacts. Sintaxa acestor comenzi este urmtoarea: (ppdefrule <defrule-name>) (ppdeftemplate <deftemplate-name>) (ppdeffacts <deffacts-name>) 45

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

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

47

4.3.16. Comanda printout Comanda printout trimite spre un dispozitiv ataat unui nume logic un ir de caractere. Numele logic trebuie specificat pentru ca dispozitivul spre care se trimite s fie pregtit (de exemplu un fiier trebuie deschis mai nti). Pentru a avea ieirea spre stdout (ieirea standard-n general monitorul) se folosete numele logic t. Sintaxa comenzii printout este urmtoarea : ( printout <logical-name> <expresion>* ) Aceast comand i dovedete utilitatea atunci cnd este amplasat n RHS-ul regulilor cu scopul de a se afia mesaje. Orice numr de expresii poate fi amplasat ntr-o comand printout pentru a fi afiate. Fiecare expresie este evaluat n vederea eliminrii spaiilor adiionale aflate ntre expresiile ce se doresc a fi printate. Simbolul crlf utilizat ca o <expresie> poate fi amplasat oriunde n lista de expresii, el fornd carriage return / new line (salt la nceput de linie nou). Funcia printout i marcheaz irurile pe care le afieaz ncadrndu-le ntre ghilimele. Pot fi printate de asemenea i adresele de fapt, adresele de instan i adresele externe. Aceast funcie nu returneaz nici o valoare. Dispozitivul spre care se trimite poate fi redefinit, astfel nct se pot transmite informaii spre un modem sau o imprimant. Urmtoarea regul demonstreaz utilitatea comenzii printout : (defrule cartela_telefonica (card yes) => (printout t Puteti forma numrul de telefon crlf) ) n aceasta regul prezena comenzii printout n RHS-ul regulii duce la afiarea spre terminal (standard output device) a unui ir de caractere. Singurul argument al funciei este irul: Puteti forma numrul de telefon care va fi afiat pe ecran fr ghilimele. Dac s-ar fi dorit trimiterea irului spre un fiier, ar fi trebuit mai nti deschis fiierul cu funcia open . S vedem acum cteva din elementele programelor CLIPS. n CLIPS avem trei elemente primare de scriere a programelor : tipuri primitive de date, funcii pentru manipularea datelor i constructori pentru adugarea datelor la baza de cunoatere. 4.3.17. Tipuri de date n CLIPS exist opt tipuri de date primitive i acestea sunt : float , integer , symbol , string , external address , fact address , instance name i instance address. Informaiile de tip numeric pot fi reprezentate evident de float i integer, iar informaiile de tip simbolic pot fi reprezentate de symbol i string. Primele dou tipuri de cmpuri float i integer sunt numite cmpuri numerice sau numere. Un cmp numeric este alctuit din trei pri : semnul, valoarea, i exponentul. Semnul este opional i poate fi + sau -. Valoarea conine una sau mai multe cifre (0-9), un punct opional (.) i din nou una sau mai multe cifre. Exponentul este i el opional i const n litera e sau E urmata de un + sau opional i de una sau mai multe cifre. Orice numr format doar din semnul opional i din cifre este considerat a fi de tip ntreg. Toate celelalte numere sunt de tip float. Exemple de ntregi : 1 +7 -2 79 Exemple de float: 1.3 3.0 8e-1 6.5E+3 48

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

Pentru introducerea ntr-un ir a ghilimelelor este necesar folosirea caracterului backslash \ . De exemplu : \ un_cmp \ este interpretat de CLIPS ca fiind cmpul: un_cmp . De aceast dat a fost creat un singur cmp deoarece folosirea caracterului backslash mpiedica interpretarea ghilimelelor ca fiind delimitatori. Introducerea unui caracter backslash ntr-un ir presupune folosirea a dou astfel de caractere succesiv. De exemplu : \\ un_cmp \\ va fi interpretat de CLIPS ca fiind cmpul: \ un_cmp \ . Celelalte patru tipuri de cmpuri external address , fact address , instance name i instance address prezint un interes mai mic pentru utilizatorul obinuit. External address reprezint adresa unei structuri de date externe returnat de un userdefined function (funcie definit de utilizator scris ntr-un limbaj ca C sau Ada i legat cu CLIPS-ul pentru a adauga o funcionalitate adiional). Dar valoarea unei adrese externe nu poate fi specificat ca fiind o secven de caractere ce formeaz un tokens i nu este posibil crearea unui astfel de cmp de ctre utilizator ntr-o variant nemodificat a CLIPS-ului. Reprezentarea unei astfel de adrese externe este: <pointer-XXXXXX> , unde XXXXXX este external address. Un fapt este o list de valori atomice i este referit poziional (fapte ordonate - ordered facts) sau dup nume (fapte neordonate sau ablon non-ordered or template facts). Referirea unui fapt se face cu ajutorul unui index sau adres. Formatul pentru fact address este: <Fact-XXX> , unde XXX este indexul de fapt. Instance name i instance address sunt cmpuri utilizate n conjuncie cu COOL. Obiectele n CLIPS sunt definite a fi floats, integers, symbols, strings, multifield values (valori multicmp), external addresses, fact addresses sau o instan a unei user-defined class. O clas definit de utilizator este realizat, folosind un constructor defclass. O instan a unei clase definite de utilizator este creat cu funcia makeinstance i poate fi referit n mod unic cu ajutorul adresei acesteia. Cteva exemple de instance name sunt: [pump-1] [foo] [+++] [123-890] Parantezele ptrate nu sunt parte component din instan, ele indicnd faptul c simbolul nchis ntre acestea este o instance-name. O adres de instan poate fi obinut prin asocierea unei variabile, valorii returnate de funcia instance-address. Reprezentarea unei instance address este: <instance-XXX> ,unde XXX este numele instanei. 4.3.18. Funciile O funcie n CLIPS este un element format din cod executabil cu un nume specific, care returneaz o valoare util sau are un anumit efect asupra informaiei. Exist dou tipuri de funcii : user defined functions i system defined functions, acestea fiind elemente de cod scrise n limbaje externe (cum ar fi C, FORTRAN sau ADA) i linkeditate cu mediul CLIPS. Funciile definite de sistem sunt acele funcii ce au fost definite intern de mediul CLIPS-ului, iar funciile definite de utilizator sunt funcii care au fost definite extern mediului CLIPS-ului. Constructorul deffunction ajut utilizatorii s defineasc noi funcii direct n mediul CLIPS-ului utiliznd sintaxa acestuia. Pot fi definite i funcii generice cu ajutorul constructorilor defgeneric i defmethod. Funciile apelate n CLIPS folosesc o 50

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

x1 x2 xn
Intrrile sunt notate: x1i, x2i, ..., xni

t w1 w2 wn s = w jx j
j

y y=f(s)

acest neuron are i ponderi sinaptice, cte una pentru fiecare intrare. Ponderile sunt notate: w1i, w2i, ..., wni dac wji > 0 avem o pondere sinaptic excitatoare dac wji < 0 avem o pondere sinaptic inhibitoare 53

Pentru simplitate se suprim indicele i. Starea intern sau activarea (excitaia) neuronului se exprim cu relaia:
s = wj x j
j =1 n

n modelul McCulloch-Pitts fiecare neuron este caracterizat de un prag de excitare t. Ieirea y este unu dac s t. Definim funcia rspuns f:R R
1 daca x 0 f ( x) = 0 daca x < 0

Ieirea se scrie:
n y= f w x t + j j j = 1

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

xn+1=1 wn+1=t

rezult activitatea total a neuronului:

s' = wj x j
j =1 n +1

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

y=f(s)

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

54

2. Funcia signum
1 daca x 0 f ( x) = 1 daca x < 0

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

4. Funcia sigmoidal (var 1)

f ( x) = 1 1 + e kx k >0

5. Funcia sigmoidal (var 2)

f ( x) = e kx e kx e kx + e kx k >0

5.2.

Ecuaia de evoluie a reelei

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

s = wij x j
j =1

n +1

Considerm toi neuronii reelei conectai ntre ei:

wi ,1 w 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

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

S=WX

Pentru studiul dinamicii reelei introducem parametrul timp. Ecuaia de evoluie va fi:
X(t+1) = F(W X(t))

5.3.

Paradigme ale instruirii

Considerm modelul de reea neural prezentat n figura urmtoare: xk1 xk2
yk 1

I1 I2

O1
yk

O2

xkn

In

On

yk

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

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

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

unde toate formele cheie au aceeai dimensiune:

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

Se admite c i toate formele asociate au aceeai dimensiune:

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

5.4.

Topologia multistrat a reelelor neurale

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

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

X = {x1, x2, x3} i o mulime nuanat A peste X, ale crei grade de apartenen sunt date de formula:

A( x i ) =
Exemplul 2.

1 , i = 1, 2, 3 i+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

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

10

15

t (oC)

Continum prezentarea elementelor de baz ale teoriei mulimilor nuanate. Fie A o mulime nuanat peste X. Suportul mulimii nuanate A, notat supp A, este mulimea clasic definit prin:
Supp A = { x X | A(x) > 0}

Egalitatea mulimilor nuanate: A = B A(x) = B(x), x X

59

Mulimea nuanat A este inclus n mulimea nuanat B i notm A B dac i numai dac:
A(x) B(x), x X

Complementara A a unei mulimi nuanate este:

A = 1 A(x), x X

Mulimea vid: (x) = 0, x X Complementara mulimii vide :

X(x) =1

Principiul Modus-Ponens generalizat:

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

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

6.2. Sisteme expert bazate pe mulimi nuanate

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

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

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

Baza de cunotine a sistemului expert Funciile de apartenen a mrimilor de intrare

Maina de inferen nuanat Intrri Nuanare (fuzificare) - universul mulimii nuanateintrri fuzzy

Reguli

Evaluarea regulilor ieiri fuzzy

Funciile de apartenen a mrimilor de ieire

Denuanare (defuzificare) Ieiri

Figura 6.1. Sistem expert realizat cu ajutorul mulimilor nuanate

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).

7.2. Algoritmul genetic canonic

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

fi f unde:
62

fi reprezint evaluarea asociat cu irul i; f - evaluarea medie a tuturor irurilor populaiei. Este util ca execuia unui algoritm genetic s fie considerat ca un proces n dou etape: 1. prima etap const n aplicarea unei selecii populaiei curente rezultnd o populaie intermediar; 2. a doua etap const n aplicarea recombinrilor i mutaiilor populaiei intermediare pentru a crea o populaie urmtoare.

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

Sir 1 Sir 2 Sir 3 ...

Descendent A (1x2) Descendent B (1x2) Descendent A (2x4) Descendent D (2x4) .............

Generaie curent t

Generaia intermediar t

Generaia urmtoare t+1

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

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

Prin recombinare se nelege aplicarea cu o probabilitate pc operatorul crossover perechilor de iruri aleator formate. Funcionarea operatorului de crossover va fi explicat prin urmtorul exemplu. Presupunem dou iruri binare din generaia intermediar. Pentru a putea urmri modul de funcionare a operatorului cel de-al doilea ir a fost reprezentat cu simbolurile x i y n loc de 1 i 0. Cele dou iruri sunt: primul ir: 1101011011 al doilea ir: yxxyxxxxyy Folosind un punct de recombinare aleator ales, un crossover simplu (1-point crossover) apare ca: 1101\/011011 yxxy/\xxxxyy n urma aplicrii operatorului de recombinare obinem descendenii: 1101xxxxyy i yxxy011011 Dup recombinare se poate aplica operatorul de mutaie. Fiecare bit din populaie se va schimba cu o mic probabilitate pm (n general rata mutaiei este sub 1%). Dup ce procesele de selecie, recombinare i mutaie au luat sfrit, populaia urmtoare poate fi evaluat. Evaluarea, selecia, recombinarea i mutaia formeaz o generaie n executarea unui algoritm genetic. Generaia urmtoare devine generaie curent i algoritmul este reluat pn se atinge obiectivul propus definit de funcia obiectiv. Teoria algoritmilor genetici presupune o mare varietate de metode i tehnici utilizate, ncepnd de la modul de reprezentare a variabilelor funciei de optimizat i terminnd cu metodele de calcul. Rezultatele foarte bune obinute n unele domenii ale inteligenei artificiale au impus aceast metod pe lng reelele neurale i mulimile nuanate ca instrumente foarte puternice de lucru. n concluzie putem spune c un lucru izbitor la algoritmii genetici i modelele paralele este bogia acestor forme de calcul. Ceea ce pare o mic schimbare n algoritm duce adeseori la comportri surprinztoare. 64

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

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. Formula P este realizabil? Formula P este o tautologie? Formula P este nevalid? Formula P este o contradicie? Rspuns: DA Rspuns: NU Rspuns: DA Rspuns: NU

Not: rspunsurile se obin avnd n vedere tabelul de adevr 1.4. i diagrama de la pagina 11 din curs. Problema 1.6. Se consider formula: P: p ^ (q v r) s se rspund la urmtoarele ntrebri referitoare la interpretarea {p, ~q, r}. S se rspund la urmtoarele ntrebri: 67

1. Interpretarea satisface pe P? 2. Interpretarea falsific pe P?

Rspuns: DA Rspuns: NU

Not: rspunsurile se obin avnd n vedere tabelul de adevr 1.4. i explicaiile de la pagina 10 din curs. Problema 1.7. S se scrie toate modelele formulei: P: p ^ (q v r). Rezolvare Un model reprezint o interpretare care satisface formula P (o interpretare pentru care formula P este adevrat). Folosindu-ne de tabelul 1.4, obinem modelele formulei P: {p, ~q, r}, {p, q, ~r} i {p, q, r} Seminar 2 Problema 2.1. Cu ajutorul metodei lui Quine, prezentat n curs la pagina 13, s se determine caracterul formulei: P: ((p ^ q ^ ~r) ^ (p v r)) ((p v r) ^ (q v r)). Rezolvare Atomul care apare cel mai frecvent este atomul r. l nlocuim mai nti cu V (adevrat) i apoi cu F (fals). Dac nlocuim atomul r cu adevrat (V) obinem: 1.a. ((p ^ q ^ ~V) ^ (p v V)) ((p v V) ^ (q v V)) din care se obine: 2.a. ((p ^ q ^ F) ^ V)) (V ^ V) apoi: 3.a. ((p ^ F) ^ V)) V dup care: 4.a. (F ^ V) V ceea ce duce la: 5.a. F V i n final: 6.a. F nlocuim acum atomul r cu fals (F) i obinem: 1.b. ((p ^ q ^ ~F) ^ (p v F)) ((p v F) ^ (q v F)) rezult: 2.b. ((p ^ q ^ V) ^ p) (p ^ q) deci: 3.b. ((p ^ q) ^ p) (p ^ q) n acest moment atomul r este eliminat. Vom nlocui n continuare atomul care apare cel mai des nti cu adevrat i apoi cu fals. Acesta este atomul p: 68

((p ^ q) ^ p) (p ^ q) ((V ^ q) ^ V) (V ^ q) ceea ce duce la: (q ^ V) q i deci: qq n final: VV FF V V V Rezultat obinut prin nlocuirea atomului q cu adevrat i apoi fals. S-a obinut astfel o interpretare n care formula este fals (punctul 6.a.) iar restul n care formula este adevrat. Putem spune c formula este consistent dar nu este o tautologie. Problema 2.2. S se demonstreze cu ajutorul metodei lui Quine c formula: P: (pq) ((qr) ((p v q)r)) este o tautologie. Rezolvare Ca n exemplul precedent, se va nlocui atomul care apare cel mai frecvent, q, mai nti cu adevrat (V) i apoi cu fals (F). a. q = V 1.a. (pV) ((Vr) ((p v V)r)) 2.a. V (r (Vr) 3.a. V (r r) 4.a. V (r r) n 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 FF (F ^ F) F ((F ^ q) ^ F) (F ^ q)

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

combinaia v(p) = 0 i v(q) = 1, impune v (q) = 1, v(r) = 1 ceea ce intr iari n contradicie cu valoarea lui r stabilit la pasul 3 iar combinaia v(p) = 1 i v(q) = 1, impune v (q) = 1, v(r) = 1 ceea ce intr n contradicie cu valoarea lui r stabilit la pasul 3. Dup cum s-a putut vedea nu mai este necesar studierea combinaiilor posibile pentru conectorul SAU deoarece nu se poate gsi o combinaie convenabil pentru atomii p,q,r din analiza celorlali conectori. Rezult c n toate interpretrile formula nu poate fi falsificat i deci ea este o tautologie. Not: Seminarul se va completa cu exemplele din curs. Seminar 4. ntrebri pentru testul gril. 1. Alegei rspunsul corect, n funcie de modul n care definiia urmtoare este corect (ADEVRAT) sau incorect (FALS). O formul este valid dac i numai dac este adevrat n toate interpretrile. A. ADEVRAT B. FALS Rspuns: A 2. Alegei varianta cea mai corect din cele prezentate mai jos. Metoda lui Quine reprezint: A. O metod de reprezentare a funciilor logice. B. O metod de determinare a realizabilitii unei formule. C. Un operator logic. Rspuns: B 3. Alegei rspunsul corect, n funcie de modul n care definiia urmtoare este corect (ADEVRAT) sau incorect (FALS). Dou formule sunt logic echivalente dac au aceeai tabel de adevr. A. ADEVRAT B. FALS Rspuns: A 4. Alegei rspunsul corect, n funcie de modul n care definiia urmtoare este corect (ADEVRAT) sau incorect (FALS). O formul nerealizabil este adevrat n toate interpretrile ei deci admite model. A. ADEVRAT B. FALS Rspuns: B 5. Alegei varianta cea mai corect din cele prezentate mai jos. Metoda reducerii se bazeaz pe: A. ncercarea de falsificare a formulei date. B. ncercarea de validare a formulei date. C. nlocuirea termenilor negai cu cei nenegai. Rspuns: A 6. Alegei rspunsul corect, n funcie de modul n care definiia urmtoare este corect (ADEVRAT) sau incorect (FALS). Un lan inferenial exprimat n limbaj obiect, ale crui premise sunt axiome se numete demonstraie iar concluzia se numete teorem. A. ADEVRAT B. FALS Rspuns: A 71

7. Alegei rspunsul corect, n funcie de modul n care definiia urmtoare este corect (ADEVRAT) sau incorect (FALS). n cazul logicii propoziiilor: o formul valid poate fi i inconsistent. A. ADEVRAT B. FALS Rspuns: B 8. Alegei rspunsul corect, n funcie de modul n care definiia urmtoare este corect (ADEVRAT) sau incorect (FALS). Metoda lui Quine permite determinarea caracterului de tautologie al unei formule. A. ADEVRAT B. FALS Rspuns: A 9. Alegei rspunsul corect, n funcie de modul n care definiia urmtoare este corect (ADEVRAT) sau incorect (FALS). n cazul logicii propoziiilor: o tautologie reprezint o formul valid. A. ADEVRAT B. FALS Rspuns: A 10. Alegei varianta incorect din cele prezentate mai jos. A. O formul valid este consistent. B. O formul este nevalid dac i numai dac exist o interpretare n care este fals. C. O formul este valid dac i numai dac negaia ei este inconsistent. Rspuns: C Seminar 5. S se deseneze schema bloc a unui sistem expert. Se vor explica urmtoarele blocuri: Modul de achiziie a cunotinelor, Baza de cunotine, Baza de fapte, Mecanismul de inferen, Modulul de explicare, Interfaa utilizator (curs pagina 25). Se va desena i se va explica schema bloc a strategiei de control cu restricie nul (curs pagina 26). Se vor discuta i explica principalele elemente ale limbajului CLIPS (curs de la pagina 27). Seminar 6. Problema 6.1. Folosind universul de discurs, mulimea oamenilor, s se defineasc mulimea TNR care rspunde la ntrebarea: care este gradul de tineree al unei persoane Rezolvare. Noiunea de TNR este o noiune imprecis. Putem considera persoanele cu vrsta mai mic de 20 de ani ca fiind tinere. Vrsta unei persoane o notm cu v(x). Un exemplu de definire este: 1, v( x) 20 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:

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

C. Perechi de valori intrare-ieire furnizate reelei neurale n procesul de instruire. Rspuns: C 28. Alegei rspunsul corect, n funcie de modul n care definiia urmtoare este corect (ADEVRAT) sau incorect (FALS). Universul unei mulimi nuanate poate fi continuu sau discret. A. ADEVRAT B. FALS Rspuns: A

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 b 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

Un exemplu de realizare a unui program de verificare a tautologiilor, n C++ va fi prezentat n continuare. Pentru nceput vor fi realizate funciile logice de baza de care avem nevoie. n C++ funciile logice I (&&) i SAU (||) sunt definite, deci trebuie realizate doar funciile implicare i echivalen. Realizarea acestor funcii este fcut in programul binar1.cpp: PROGRAMUL binar1.cpp /* testare operatiilor logice */ #include <stdio.h> #include <conio.h> 77

char impl (char a,char b) { char c; if (a==0) c=1; if ((a==1) && (b==0)) c=0; if ((a==1) && (b==1)) c=1; return c; } char echiv (char a,char b) { char c; if (a==b) c=1; if (a != b) c=0; return c; } void main(void) { unsigned char alfa, beta, gama,pas; clrscr(); for (alfa=0; alfa<=1; alfa++) for (beta=0; beta<=1; beta++) { printf("\n alfa= %d", alfa); printf("\n beta= %d", beta); gama=alfa && beta; printf("\n gama(si)= %d", gama); gama=alfa || beta; printf("\n gama(sau)= %d", gama); printf("\n gama(nu)= %d", !gama); gama=impl(alfa,beta); printf("\n gama(implicare)= %d", gama); gama=echiv(alfa,beta); printf("\n gama(echivalenta)= %d", gama); scanf("%c",pas); } } La nceputul programului sunt definite cele dou funcii logice necesare: IMPLICARE funcia impl: 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; 78

} 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

fprintf(fisier,"\n (d SI e): %d",B[contor]); fprintf(fisier,"\n Valoare iesire (A SI B): %d",D[contor]); scanf("%c",pas); } // se calculeaza formula ((a SI b) IMPLICA c) SI (d SI e) IMPLICA (d SAU e) // care, cu notatiile facute se poate scrie D IMPLICA C // iar rezultatul se va pune in vectorul E. printf("\n Se calculeaza formula ((a SI b) IMPLICA c) SI (d SI e) IMPLICA (d SAU e)"); fprintf(fisier,"\n Se calculeaza formula ((a SI b) IMPLICA c) SI (d SI e) IMPLICA (d SAU e)"); for (contor=0; contor<=7; contor++) { E[contor]=impl(D[contor],C[contor]); printf("\n ((a SI b) IMPLICA )c SI (d SI e): %d",D[contor]); printf("\n (d SAU e): %d",C[contor]); printf("\n Valoare iesire D IMPLICA C: %d",E[contor]); fprintf(fisier, "\n ((a SI b) IMPLICA )c SI (d SI e): %d",D[contor]); fprintf(fisier, "\n (d SAU e): %d",C[contor]); fprintf(fisier, "\n Valoare iesire D IMPLICA C: %d",E[contor]); scanf("%c",pas); } printf("\n Verificarea s-a terminat!"); scanf("%c",pas); fclose(fisier); } Pentru nceput vom construi tabelul de adevr pentru aceast formul. Prima observaie care se poate face este c prima parte a formulei: ((a ^ b) c) depinde de variabilele a, b i c care nu apar n partea a doua a formulei. n acest fel vom construi tabelul de adevr din dou tabele. Primul tabel: c 0 0 0 0 1 1 1 1 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 (a ^ b) c notat mai departe cu A 1 1 1 0 1 1 1 1

Formula (a ^ b) c nu este valid (este nevalid) i deci nu este o tautologie. Pentru a evalua formula se construiete acum cel de-al doilea tabel pentru formula: A ^ (d ^ e) (d v e) 83

este : A 0 0 0 0 1 1 1 1 d 0 0 1 1 0 0 1 1 e 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 D C care este de fapt formula ((a ^ b) c) ^ (d ^ e) (d v e) 1 1 1 1 1 1 1 1

Formula este egala cu unu in toate interpretrile ei i deci este o tautologie. Acelai lucru a fost realizat i cu ajutorul programului Binar2. Rezultatele acestuia sunt: Se calculeaza (a SI b) a: 0 b: 0 Valoare iesire a SI b: 0 a: 0 b: 1 Valoare iesire a SI b: 0 a: 1 b: 0 Valoare iesire a SI b: 0 a: 1 b: 1 Valoare iesire a SI b: 1 Se calculeaza (a SI b) IMPLICA c (a si b): 0 c: 0 Valoare iesire (a SI b) IMPLICA c: 1 (a si b): 0 c: 0 Valoare iesire (a SI b) IMPLICA c: 1 (a si b): 0 c: 0 Valoare iesire (a SI b) IMPLICA c: 1 (a si b): 1 c: 0 Valoare iesire (a SI b) IMPLICA c: 0 (a si b): 0 c: 1 Valoare iesire (a SI b) IMPLICA c: 1 (a si b): 0 84

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

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

Se poate observa faptul c rezultatele sunt identice cu cele din tabele. Vom verifica acum cu ajutorul unui program similar tautologia numarul 7): P ^ Q Q din tabelul de nceput al acestei lucrari. Programul realizat este programul Binar3. Pentru a simplifica lucrurile vom modifica fiierul binar1.ccp i-l vom salva sub numele flogic.ccp, astfel : PROGRAMUL flogic.ccp /* testarea operatiilor logice */ char 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; har echiv (char a,char b) { har c; if (a==b) c=1; if (a != b) c=0; return c; } Dup aceasta, se creeaz fiierul flogic.h cu urmtorul coninut: extern char impl (char a,char b); extern char echiv (char a,char b); putem s realizm acum fiierul binar3.ccp pentru verificarea formulei P ^ Q Q: PROGRAMUL binar3.ccp // programul Binar3 de verificare a formulei (p SI q) IMPLICA q #include <stdio.h> include<conio.h> #include<flogic.h> void main (void) { unsigned char p,q,r,pas; FILE *fisier; isier=fopen("rezultat","w+"); 87

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: nvare. Permite introducerea noiuniilor i a atributelor acestora n baza de date. Atributele trebuie s rspund la ntrebrile: ce este noiunea la care se refer? ce caracterizeaz noiunea? care sunt proprietile noiunii? etc. i ce NU este noiunea la care se refer? ce NU caracterizeaz noiunea? care NU sunt proprietile noiunii? etc. n acest fel, n baza de date, se vor forma trei categorii de propoziii: adevrate, false i nedefinite. Actualizare. Permite definirea atributelor nedefinite. Introducerea unui atribut nou la o noiune, face ca acesta s fie nedefinit la toate noiunile anterioare. Regimul actualizare permite definirea acestor atribute la toate noiunile din baza de date. Modificare. Permite tergerea unei noiuni, tergerea unui atribut, modificarea valorii de adevr a atributelor existente, introducerea atributelor noi pentru o noiune. Consultare. Permite afiarea unei noiuni cu toate atributele asociate acesteia adevrate i false fiind ignorate cele nedefinite. Analiz. Opiunea permite afiarea asocierilor noiunilor pe baza atributelor introduse. Cele trei tipuri de asocieri sunt: identitate, asemnare i diferite. Regimul permite estimarea corectitudinii i suficienei atributelor introduse. Estimare. Permite aflarea unei noiuni (din baza de date) pe baza atributelor acesteia. tergere baz de date. Permite tergerea bazei de date curente i crearea unei baze de date complet goal. Baza de date curent are denumirea standard: 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

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

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

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

Se observ c toate atributele din aceast clas sunt de departajare. n general aici sunt mai greu de stabilit atributele specifice din cauz c este mai uor de spus ce este un obiect dect ce nu este. Dac aceste atribute sunt suficiente pentru caracterizarea corect a noiunii de microprocesor se va vedea mai trziu n faza de analiz i estimare. Urmtoarea noiune definit va fi cea de memorie. Pentru aceast noiune atributele cu valoarea de adevr adevrat vor fi: memoreaza date 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: face calcul aritmetic face calcul logic achita intreruperi executa program genereaza adrese modul master atribut specific atribut specific atribut specific atribut specific atribut de departajare atribut de departajare 94

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

Dup introducerea celei de-a doua noiuni se poate observa faptul c nu se poate stabili uor o grani precis ntre atributele de departajare i cele specifice. Dup o prim faz de stabilire a acestora, se vor face analize prin compararea tuturor noiunilor care sunt caracterizate de acelai atribut, cu opiunea C consultare i clasificarea noiunilor cu ajutorul opiunii D analiz. n tabelul urmtor sunt prezentate urmtoarele noiuni introduse i valorile de adevr pentru atributele acestora. Noiune Interfa 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 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 Fals Fals Fals Fals Fals Fals Adevrat Nedefinit Fals Fals Adevrat Adevrat Adevrat Interfa Adevrat Adevrat Adevrat Adevrat Fals Fals Fals Fals Fals Fals 95 Modul DMA Fals Fals Fals Adevrat Fals Adevrat Fals Fals Fals Fals Nedefinit Adevrat Adevrat Modul DMA Adevrat Adevrat Adevrat Adevrat Adevrat Fals Adevrat Fals Fals Fals Tastur Fals Fals Fals Fals Fals Fals Nedefinit Fals Fals Fals Fals Fals Nedefinit Tastur Fals Adevrat Fals Fals Fals Adevrat Adevrat Adevrat Adevrat Adevrat Imprimant Fals Fals Adevrat Fals Fals Fals Nedefinit Nedefinit Adevrat Fals Fals Adevrat Nedefinit Imprimant Adevrat Fals Fals Fals Fals Adevrat Adevrat Adevrat Adevrat Fals

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

96

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

==================== CONSULTARE ======================= ===================== Atribute ======================== modul master este valabil pentru: microprocesor modul DMA Apasati Enter pentru continuare

Verificarea final a bazei de cunotiine se va face cu opiunea D analiz. Dac asocierile fcute ntre noiuni nu sunt corecte atunci se va reveni cu modificri asupra bazei de cunotiine prin: reevaluarea atributelor cu valoarea de adevr nedefinit; introducerea unor atribute noi.

n final clasificarea noiunilor poate fi conform figurii urmtoare.

97

Identice interfata-modul DMA

Asemanatoare microprocesor-modul DMA memorie-interfata tastatura-imprimanta

Diferite 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 _

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

98

Introduceti valorile de adevar pentru atributele notiunii de estimat. Atributul: face calcul aritmetic Introduceti valoarea de adevar: D - pentru ADEVARAT N - pentru FALS I - pentru NEDEFINIT ENTER pentru a-l lasa nedefinit

_ n continuare este prezentat lista atributelor pentru care se solicit stabilirea unei valori de adevr i un exemplu de valori de adevr stabilite. Trebuie observat faptul c utilizatorul nu a stabilit corect toate valorile de adevr (prin comparare cu cele stabilita la crearea bazei de cunotiine prezentate n tabelul de mai sus) iar pentru caracteristicile la care nu a tiut s rspund a ales valoarea de adevr nedefinit. Lista atributelor i a valorilor de adevr este: Face calcul aritmetic fals Face calcul logic fals Genereaz adrese fals Modul master fals Achit ntreruperi fals Modul slave adevrat Memoreaz date adevrat Execut program adevrat Comunic cu periferic fals Dispozitiv programabil adevrat Genereaz ntreruperi adevrat Transfer rapid de date adevrat Transfer blocuri date nedefinit Memoreaz programe adevrat Introduce date fals Este periferic adevrat Comunic cu interfeele adevrat Circuit integrat nedefinit Pe placa de baz fals Definit de capacitate nedefinit Dispozitiv extern adevrat Electro-mecanic adevrat Consol sistem adevrat Utilizeaz cod ASCII adevrat

Este evident faptul c n stabilirea valorilor de adevr este de preferat n primul rnd ca valorile de adevr nedefinit s fie n numr ct mai mic. n al doilea rnd ntre o valoare de adevr greit stabilit (cu valoarea de adevrat sau fals) i una cu valoarea de adevr nedefinit este de preferat cea din urm. Dup introducerea valorilor de adevr vor fi afiate urmtoarele informaii: 99

Este: imprimanta 88.89 % Este: tastatura 68.42 % Este: memorie 52.63 % Este: interfata 42.11 % Este: modul DMA 33.33 % Este: microprocesor 15.00 % Apasati ENTER _ care arat c noiunea cu cea mai mare probabilitate (88,89%), care are trsturile specificate de utilizator, este cea de imprimant, ceea ce este corect. Sunt afiate toate noiunile din baza de cunotiine cu probabilitatea asociat n aa fel nct utilizatorul s poat alege noiunea ce rspunde cel mai bine situaiei date (n cazul probabilitilor apropiate). Vom considera acum c se evalueaz o noiune care nu exist n baza de cunotiine, cea de monitor. Valorile de adevr stabilite pentru aceast noiune vor fi: Face calcul aritmetic fals Face calcul logic fals Genereaz adrese fals Modul master fals Achit ntreruperi fals Modul slave nedefinit Memoreaz date fals Execut program fals Comunic cu periferice fals Dispozitiv programabil fals Genereaz ntreruperi fals Transfer rapid de date nedefinit Transfer blocuri date fals Memoreaz programe fals Introduce date fals Este periferic adevrat Comunic cu interfeele adevrat Circuit integrat fals Pe placa de baz fals Definit de capacitate fals Dispozitiv extern adevrat Electro-mecanic fals Consol sistem adevrat Utilizeaz cod ASCII fals

De la nceput se observ c sunt puine valori de adevr adevrat ceea ce va impune introducerea unor atribute noi. Rezultatul afiat de program va fi: 100

Este: tastatura 85.71 % Este: imprimanta 65.00 % Este: memorie 55.00 % Este: modul DMA 45.45 % Este: interfata 45.00 % Este: microprocesor 38.10 % Apasati ENTER _ Acest rezultat arat c noiunea estimat este un periferic (tastatura i imprimanta au scorurile cele mai mari) dar evident este greit evaluat pentru c tastatura este un dispozitiv periferic de intrare iar monitorul un dispozitiv periferic de ieire. Vor trebui introduse atribute suplimentare care s asigure diferenierea ntre noiunea de tastatur i cea de monitor. La solicitarea programului de a introduce noiunea vom rspunde afirmativ i se va introduce noiunea de monitor deocamdat fr atribute suplimentare. Dup aceasta selectm opiunea D analiz din meniul principal. Rezultatul afiat va fi:
Identice interfata-modul DMA tastatura-monitor Asemanatoare microprocesor-modul DMA memorie-interfata tastatura-imprimanda imprimanda-monitor Diferite 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

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

101

Dup aceasta se selecteaz din meniul principal opiunea A actualizare i se actualizeaz valoarea de adevr a acestor atribute astfel: pentru noiunile de microprocesor, memorie, interfa, modul DMA i tastatur atributele noi au valoarea de adevr: fals. pentru noiunea de imprimant, atributele: reprezentare grafic, reprezentare text i reprezentare color au valoarea de adevr: adevrat iar atributul principiu tub catodic are valoarea de adevr: fals.

n sfrit, din meniul principal se selecteaz opiunea D analiz care afieaz urmtoarele informaii:
Identice interfata-modul DMA Asemanatoare microprocesor-modul DMA memorie-interfata tastatura-imprimanta tastatura-monitor imprimanta-monitor Diferite 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

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

Invatare - care permite introducerea notiunilor si a atributelor acestora in baza de date. Atributele trebuie sa raspunda la intrebarile: Ce este notiunea la care se refera? Ce caracterizeaza notiunea? Care sunt proprietatile notiunii? etc. si Ce NU este notiunea la care se refera? Ce NU caracterizeaza notiunea? Care NU sunt proprietatile notiunii? etc. In acest fel in baza de date se vor forma trei categorii de propozitii: adevarate, false si nedefinite. Actualizare care permite definirea atributelor nedefinite. Introducerea unui atribut nou la o notiune face ca acesta sa fie nedefinit la toate notiunile anterioare. Regimul actualizare permite defineirea acestor atribute la toate notiunile din baza de date. Modificare care permite stergerea unei notiuni, stergerea unui atribut, modificarea valorii de adevar a atributelor existente, introducerea atributelor noi pentru o notiune. Consultare care permite afisarea unei notiuni cu toate atributele asociate acesteia adevarate si false fiind ignorate cele nedefinite. Analiza in care sunt prezentate asocierile notiunilor pe baza atributelor introduse. Cele trei tipuri de asocieri sunt: identitate, asemanare si diferite. Regimul permite estimarea corectitudinii si suficientei atributelor introduse. Estimare care permite aflarea unei notiuni (din baza de date) pe baza atributelor acesteia. Stergere baza de date in care baza de date este stearsa si se creaza una noua complet goala. } uses Crt; const { Numarul maxim de notiuni sau atribute ce pot fi introduse in baza de date. Se pot introduce DimensiuneMaximaBazaDeDate notiuni si DimensiuneMaximaBazaDeDate atribute. } DimensiuneMaximaBazaDeDate=100; { Dimensiunea maxima a numelui unei notiuni sau a unui articol. } DimensiuneArticol=25; type { Descrierea bazei de date a sistemului expert. } 103

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

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

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

'-',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

write(notiuni[contor1],

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

write('Atributul: ',atribute[contor1],' este: '); if legatura[NumarNotiune,contor1]=0 then writeln('FALS'); if legatura[NumarNotiune,contor1]=1 then writeln('ADEVARAT'); if legatura[NumarNotiune,contor1]=2 then writeln('NEDEFINIT'); writeln('Introduceti noua valoare de adevar: '); writeln('D - pentru ADEVARAT'); writeln('N - pentru FALS'); writeln('I - pentru NEDEFINIT'); writeln('ENTER pentru a-l lasa neschimbat'); CitescOptiune; if optiune='N' then legatura[NumarNotiune,contor1]:=0; if optiune='D' then legatura[NumarNotiune,contor1]:=1; if optiune='I' then legatura[NumarNotiune,contor1]:=2; end; end; end; StergeEcran; write('Introduceti atribute noi? D/N: '); CitescOptiune; if optiune='D' then begin AfisareNotiuni; write('Introduceti numarul notiunii (0 - abandon): '); readln(NumarNotiune); if NumarNotiune<>0 then begin StergeEcran; NrNotiuneInLucru:=NumarNotiune; IntroducereAtributeNoi; end; end; end; ScriuBazaDeDate; end; procedure Estimare; { Procedura estimeaza o notiune noua (necunoscuta) pe baza atributelor existente in baza de date. La sfarsit daca este o notiune noua ea poate fi introdusa in baza de date cu valorile de adevar pentru atributele existente. Daca se doreste introducerea atributelor noi atunci se apeleaza meniul Modificare. } 119

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

writeln('ENTER pentru a-l lasa nedefinit'); CitescOptiune; if optiune='N' then model[contor1]:=0; if optiune='D' then model[contor1]:=1; if optiune='I' then model[contor1]:=2; end; for contor1:=1 to DimensiuneMaximaBazaDeDate do NumarComparari[contor1]:=0; for contor1:=1 to ContorNotiuni-1 do for contor2:=1 to ContorAtribute-1 do if (legatura[contor1,contor2]<>2) and (model[contor2]<>2) then begin if legatura[contor1,contor2]=model[contor2] then inc(NumarPotriviri[contor1]); inc(NumarComparari[contor1]); end;

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

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

w1

t
y=w1x1+ +w2x2 f=y(t)

x2

w2

Valoarea ieirii perceptronului se calculeaz n felul urmtor. Se calculeaz suma ponderat a intrrilor dup relaia:
y = w1 x1 + w2 x2

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

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

ce reprezint ecuaia dreptei de separaie. Este limpede faptul ca perceptronul nu poate separa dect puncte (n plan sau hiperplan) liniar separabile. n cazul n care configuraia punctelor este mai complicat i acestea nu sunt liniar separabile se vor utiliza reele neuronale cu mai multe straturi. Algoritmul de nvare utilizat pentru perceptron n acest program este urmtorul: 1. se calculeaz un vector de ieire pentru cele patru seturi de date de intrare utilizate la instruire; 2. se compar vectorul de ieire calculat la punctul 1 cu vectorul int; 3. dac cei doi vectori sunt diferii atunci se modific ponderile i pragul astfel: w = w + dw t = t + dt unde dw i dt sunt valori adugate la vechea pondere, respectiv prag. Aceste valori se calculeaz astfel: 125

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.

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

126

=============== REZULTAT =================== Procesul de invatare a reusit. Invatarea s-a facut in 4 pasi. Ponderile obtinute sunt: - ponderea intrarii 1: -2.6161 - ponderea intrarii 2: -0.6922 Pragul obtinut: -0.1680 Apasati tasta ENTER. Reprezentarea grafic a rezultatului obinut este prezentat n figura urmtoare.

Din aceast reprezentare grafic se observ modul n care este separat planul n cele dou regiuni. Dup instruire perceptronul este capabil s clasifice 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

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

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.

Laborator 10, 11, 12, 13, 14. Lucrul cu mediul CLIPS

Activitatea 1. S se realizeze un program n CLIPS care s gseasc toate aranjamentele posibile a patru culori (rosu, albastru, galben, verde) luate cte trei. Rezolvare Rezolvarea acestei probleme cu ajutorul limbajelor procedurale cunoscute (Pascal, C, Java etc.) presupune realizarea unui program relativ complex. Avantajul limbajului CLIPS const n motorul de inferen bazat pe un algoritm foarte performant. 134

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) ; se scoate elementul din stiva (assert (stack $?stacklist)) (printout t "Pop: " ?element crlf)

(defrule stack_top (top) (stack ?element $?stacklist) => (printout t "Top: " ?element crlf) ; aici nu avem nevoie sa stergem fapte, LHS ramine neschimbata ) Not: dei faptele sunt definite ntr-o anumit ordine: push, pop, push, top, pop, top), execuia programului nu ine seama de 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

(assert (nr_carti ?nr_carti))

(defrule meniu-de-optiuni => (printout t t "Optiuni:" crlf) (printout t "1. Cautare carte dupa nume autor" crlf) (printout t "2. Cautare carte dupa prenume autor" crlf) (printout t "3. Cautare carte dupa titlu" crlf) (printout t "4. Introducere carte noua in baza de date" crlf) (printout t "5. Afisare numar de carti din biblioteca" crlf) (printout t "Alegeti una din optiuni (1-5): ") (assert (optiune (read))) ) (defrule optiune_incorecta ?f <- (optiune ?c & ~1 & ~2 & ~3 & ~4 & ~5) => (retract ?f) (printout t "Alegeti una din optiuni (1-5): ") (assert (optiune (read))) ) (defrule introducere_nume (optiune 1 | 4) => (printout t t "Introduceti numele autorului: ") (bind ?n (read)) (while (or (not (symbolp ?n)) (< (str-length (str-cat ?n)) 3)) (printout t "Introduceti numele autorului: ") (bind ?n (read)) ) (assert (nume ?n)) ) (defrule introducere_prenume (optiune 2 | 4) => (printout t "Introduceti prenumele autorului: ") (bind ?p (read)) (while (or (not (symbolp ?p)) (< (str-length (str-cat ?p)) 3)) (printout t "Introduceti prenumele autorului: ") (bind ?p (read)) ) (assert (prenume ?p)) ) (defrule introducere_titlu 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

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

(defrule afisare_numar_carti (optiune 5) (nr_carti ?n) => (printout t t "In aceasta baza de date sunt " ?n " volume." crlf) ) (defrule stergere_date (declare (salience -5)) (or ?f <- (nume ?) ?f <- (prenume ?) ?f <- (titlu ?) ) => (retract ?f) ) (defrule alta_optiune (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

(variable ?variable ?value) ?f <- (rule (if ?variable ? ~?value $?)) => (retract ?f)) (defrule modify-rule-match "" (declare (salience 20)) (variable ?variable ?value) ?f <- (rule (if ?variable ? ?value and $?rest)) => (modify ?f (if ?rest))) (defrule rule-satisfied "" (declare (salience 20)) (variable ?variable ?value) ?f <- (rule (if ?variable ? ?value) (then ?goal ? ?goal-value)) => (retract ?f) (assert (variable ?goal ?goal-value))) (defrule ask-question-no-legalvalues "" (declare (salience 10)) (not (legalanswers $?)) ?f1 <- (goal is ?variable) ?f2 <- (question ?variable ? ?text) => (retract ?f1 ?f2) (format t "%s " ?text) (assert (variable ?variable (read)))) (defrule ask-question-legalvalues "" (declare (salience 10)) (legalanswers ? $?answers) ?f1 <- (goal is ?variable) ?f2 <- (question ?variable ? ?text) => (retract ?f1) (format t "%s " ?text) (printout t ?answers " ") (bind ?reply (read)) (if (member (lowcase ?reply) ?answers) then (assert (variable ?variable ?reply)) (retract ?f2) else (assert (goal is ?variable)))) ;;;*************************** ;;;* DEFFACTS KNOWLEDGE BASE * 143

;;;*************************** (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

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

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

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

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

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

(question fleece is "Animalul are blana?") (rule (if subsubspecies is nofleece and domesticated is da) (then type.animal is vaca)) (rule (if subsubspecies is nofleece and domesticated is nu) (then type.animal is caprioara/elan/antilopa)) (question domesticated is "Animalul este domestic?") (answer is "Cred ca animalul este un(o) " type.animal)) Referatele de laborator vor conine: explicarea modului de funcionare a programului, exemple de utilizare. Pe baza acestui model se va realiza un sistem expert pentru un alt domeniu, de exemplu arhitectura calculatoarelor. Se va compara funcionarea programului realizat cu programul prezentat la lucrarea de laborator 4,5,6. Lucrrile de laborator vor conine de asemenea: listingul programului realizat, explicarea funcionrii acestuia i exemple de utilizare.

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