Documente Academic
Documente Profesional
Documente Cultură
Inteligenta Artificiala PDF
Inteligenta Artificiala PDF
DAAN
N ROT AR
OTAR
NTELIGENŢĂ
IINTELIGENŢĂ
AR TIFICIAL
RTIFICIA Ă
LĂ
CUPRINS
Pag.
Capitolul 1
DOMENIILE INTELIGENŢEI ARTIFICIALE 5
Capitolul 2
BAZELE INTELIGENŢEI ARTIFICIALE 7
2.1. Logica clasică a propoziţiilor 7
2.1.1. Simboluri, formule 7
2.1.2. Evaluare, funcţie de adevăr 9
2.1.3. Tautologie, validitate, consistenţă 10
2.1.4. Metoda lui Quine 13
2.1.5. Metoda reducerii 14
2.1.6. Echivalenţe 16
2.1.7. Reguli de manipulare şi substituţie 16
2.1.8. Dualitate 17
2.1.9. Conectori adecvaţi 18
2.1.10. Consecinţe logice 19
2.1.11. Forme normale 19
2.2. Sistemul deductiv al calculului propoziţiilor 20
2.2.1. Demonstraţie şi deducţie 20
2.3. Limbajul calculului cu predicate de ordinul întâi 22
Capitolul 3
SISTEME EXPERT 24
3.1. Sisteme expert – generalităţi 24
3.2. Structura generală a unui sistem expert 25
3.3. Funcţionarea unui sistem expert 25
Capitolul 4
REALIZAREA UNUI PROGRAM ÎN MEDIUL DE
PROGRAMARE CLIPS 28
4.1. Introducere 28
4.2. Execuţia unui program în mediul de programare CLIPS
4.3. Structura programului CLIPS 32
4.3.1. Constructorii 32
4.3.2. Faptele 32
4.3.3. Constructorul deftemplate 33
4.3.4. Constructorul deffacts 34
4.3.5. Fapte ordonate 35
4.3.6. Adăugarea şi ştergerea faptelor 36
4.3.7. Modificarea şi duplicarea faptelor 39
4.3.8. Comanda watch 40
4.3.9. Definirea regulilor 41
3
Bazele inteligenţei artificiale
Capitolul 5
REŢELE NEURALE 53
5.1. Modelul general al unei reţele neuronale 53
5.2. Ecuaţia de evoluţie a reţelei 55
5.3. Paradigme ale instruirii 56
5.4. Topologia multistrat a reţelelor neurale 57
Capitolul 6
MULŢIMI NUANŢATE 58
6.1. Noţiunea de mulţime nuanţată 58
6.2. Sisteme expert bazate pe mulţimi nuanţate 60
Capitolul 7
ALGORITMI GENETICI 62
7.1. Generalităţi 62
7.2. Algoritmul genetic canonic 62
SEMINAR 66
Seminar 1 66
Seminar 2 68
Seminar 3 70
Seminar 4 71
Seminar 5 72
Seminar 6 72
Seminar 7 74
Laborator
Laborator 1,2,3 77
Laborator 4,5,6 90
Laborator 7,8,9 123
Laborator 10,11,12,13,14 134
BIBLIOGRAFIE 151
4
Bazele inteligenţei artificiale
CAPITOLUL 1
DOMENIILE INTELIGENŢEI ARTIFICIALE
Inteligenţa artificială este o ramură a ştinţei calculatoarelor care se ocupă cu
studiul posibilităţii calculatoarelor de a avea o comportare asemănătoare cu cea
omenească. Termenul a fost introdus în 1956 de către John McCarthy de la
Massachusetts Institute of Technology. Inteligenţa artificială cuprinde:
5
Bazele inteligenţei artificiale
Înţelegerea limbajelor naturale oferă cel mai mare potenţial de utilizare din
cauză că acestea vor permite oamenilor să interacţioneze cu calculatoarelor fără a fi
necasare cunoştiinţe de specialitate. Din păcate sarcina de a programa calculatorul să
înţeleagă limbajele naturale s-a dovedit mult mai dificilă decât s-a crezut la început.
Există câteva sisteme care reusesc să facă traducerea automată dintr-un limbaj în altul
dar ele sunt departe de a fi la fel de bune ca traducătorii umani. Sunt de asemenea
sisteme de recunoaştere a vocii care pot converti sunetele pronunţate în cuvinte scrise
dar acestea nu înţeleg ceea ce scriu; aceste sisteme sunt destinate numai dictării. 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
inteligenţei artificiale şi ale calculatoarelor în general. Până acum însă aceste sisteme n-
au răspuns aşteptărilor. Multe sisteme expert ajută experţii umani în diferite domenii
cum ar fi medicina sau ingineria dar aceste sisteme sunt foarte scumpe şi sunt de folos
doar în situaţii speciale.
Astăzi cel mai fierbinte domeniu al inteligenţei artificiale este cel al reţelelor
neurale care sunt folosite cu succes în anumite domenii cum ar fi recunoaşterea vocii şi
procesarea limbajelor naturale.
Există limbaje de programare care sunt cunoscute drept limbajele inteligenţei
artificiale deoarece acestea sut folosite aproape exclusiv pentru aplicaţii ale inteligenţei
artificiale. Limbajele de programare mai cunoscute utilizate în acest scop sunt LISP şi
Prolog.
Inteligenţa artificială se împarte în două clase: inteligenţă artificială tare (strong
artificial intelligence) şi inteligenţă artificială slabă (weak artificial intelligence).
Inteligenţa artificială tare se referă la domeniul în care calculatoarele pot gândi
(cel puţin) la fel ca oamenii. Inteligenţa artificială slabă se referă doar la elemente de
gândire (raţionamente) adăugate calculatoarelor în scopul de a le face cât mai
folositoare şi acest lucru este deja realizat prin sisteme expert martor, comanda şi
conducerea automobilelor şi programele de recunoaştere a vorbirii.
Ce înseamnă a “gândi” şi a “gândi ca” este (încă) un domeniu pentru dezbateri
aprinse de acum încolo.
6
Bazele inteligenţei artificiale
CAPITOLUL 2
BAZELE INTELIGENŢEI ARTIFICIALE
2.1. Logica clasică a propoziţiilor
p ∆ Ion citeste.
q ∆ Ion scrie.
Cât timp nu admitem decât cele două valori de adevăr (fals, adevărat) suntem în
cadrul logicii clasice sau a logicii bivalente.
În logica de tip propoziţional, propoziţiile sunt unităţi nedecompozabile. Orice
consideraţie asupra structurii lor interne este irelevantă.
Propoziţiile simple sau atomi p, q, r, ... sunt compozabile. Ele se pot combina
dând naştere la noi propoziţii, la rândul lor adevărate sau false. Simbolurile numite
conectori indică operaţiile de asociere sau combinare, care sunt cele mai frecvente în
vorbire sau raţionament:
7
Bazele inteligenţei artificiale
P : (p ^ q) → r,
unde:
r ∆ Ion este mulţumit.
Interpretarea formulei P este: dacă “Ion citeşte” şi “Ion scrie”, atunci “Ion este
mulţumit”. Formula P este formată din trei atomi. Ea poate fi privită drept o funcţie de
atomii p, q, r, care, din acest motiv, se numesc variabile propoziţionale.
În logica propoziţională unitatea principală de lucru este formula.
Totalitatea simbolurilor logicii propoziţiilor constituie un alfabet.
În cele ce urmează simbolurile logice vor fi următoarele:
p, q, r, ..., ~, ^, v, →, ↔, (, )
cu alte cuvinte, simbolurile pentru mulţimea finită sau infinită de atomi: p, q, r, ... sau
p1, p2, p3, ..., pn, ...; simbolurile pentru conectorii logici, ce vor fi definiţi mai jos;
parantezele, stângă, (, şi dreaptă, ).
Simbolurile ce nu sunt cuprinse în alfabet sunt simboluri metalogice. Această
restricţie 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. Proprietăţile, legile, regulile
pot fi enunţate pentru atomi şi atunci avem nevoie de o regulă suplimentară de trecere
de la atomi la formule (regula substituţiei) sau pot fi enunţate direct pentru formule, caz
în care poartă denumirea de scheme.
Exemplu:
p^(p→q)→q
P^(P→Q)→Q
P=(p ↔ q)
şi:
Q=(pvq) ^ (p v ~ q)
8
Bazele inteligenţei artificiale
Un tablou care arată valoarea de adevăr a unei formule pentru toate valorile
posibile ale atomilor din formulă se numeşte tabelă de adevăr. Un exemplu de tabel de
adevăr este:
9
Bazele inteligenţei artificiale
n
Există 2 2 funcţii de adevăr 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 adevăr
cu 2n linii. În cazul n=2 al formulelor cu 2 atomi există 16 formule de adevăr. Se pot
astfel defini 16 conectori binari, din care în această prezentare au fost selectaţi doar
patru.
Numărul formulelor care pot fi construite cu n variabile propoziţionale este
infinit. Rezultă că diferite formule corespund uneia şi aceleiaşi funcţii de adevăr (tabele
de adevăr).
Fie o formulă P având atomii p1, ... , pn. O interpretare a lui P este o evaluare (o
atribuire de valori) a atomilor, fiecare primind valoarea de adevăr “0” sau “1”. Formula
P este adevărată într-o interpretare, dacă este evaluată ca “1”; altfel este falsă ca
interpretare. O formulă cu n atomi va avea 2n interpretări diferite. Liniile unei tabele de
adevăr reprezintă astfel de interpretări.
O interpretare I se reprezintă prin mulţimea 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 adevărată în interpretarea I, se spune că I satisface pe P sau P este
satisfăcut 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 numeşte model a lui P.
Exemplu:
Fie formula P:
~(p v q) v ~ (q v p),
cu tabela de adevăr:
O formulă este validă, dacă şi numai dacă este adevărată în toate interpretările.
Altfel (dacă şi numai dacă nu este validă) este nevalidă.
O formulă este inconsistentă dacă şi numai dacă este falsă în toate interpretările.
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 contradicţie.
10
Bazele inteligenţei artificiale
Exemple:
Propoziţii.
CONSISTENŢĂ=REALIZABILĂ NEVALIDĂ
Pv = 1 uneori Pv = 0 uneori
VALIDĂ=TAUTOLOGIE CONTRADICŢIE=NEREALIZABILĂ
Pv = 1 întotdeauna Pv = 0 întotdeauna
11
Bazele inteligenţei artificiale
dintr-o singură formulă, se spune că aceasta este realizabilă, dacă S este realizabilă, şi
nerealizabilă, dacă S este nerealizabilă.
În limbajul evaluărilor o tautologie este o formulă T pentru care Tv=1, oricare ar
fi valoarea v.
Tautologii fundamentale.
T0 P→P
T1 (P→Q) →((Q→R) →(P→R)) legea silogismului
T2 P→(P v Q)
T3 Q→(P v Q)
T4 (P→Q) →((Q→R) →((P v Q)→R))
T5 P ^ Q →P
T6 P ^ Q →Q
T7 (R→P) →((R→Q) →(R →(P ^ Q)))
T8 (P→(Q→R)) →((P ^ Q) →R) legea importării
T9 ((P ^ Q) → R) → (P →(Q→R)) legea exportării
T10 (P ^ ~P) → Q
T11 (P→(P ^ ~P)) → ~P
T12 P ^ ~P legea terţului exclus sau
tertium non datur
12
Bazele inteligenţei artificiale
1) Atomul care intervine cel mai frecvent este înlocuit o dată cu “V”
(adevăr) şi a doua oară cu “F” (fals), obţinându-se două formule.
2) În fiecare din ele se aplică următoarele reguli:
p q p→q
1 1 1
1 0 0
0 1 1
0 0 1
13
Bazele inteligenţei artificiale
Exemplu:
V↔r V V q↔F
r q
V F F V
1
P→Q
0
Dar implicaţia P → Q este falsă numai când P este fals şi Q este adevărat. Vom
scrie deci sub conectorul principal din P valoarea “1”, sub conectorul principal din Q
valoarea “0” şi deasupra ambilor conectori numărul pasului (2). Continuăm în acelaşi
fel până când:
14
Bazele inteligenţei artificiale
1
P ∧Q
0
din atribuirea valorii “0” nu rezultă în mod unic că P este adevărat sau fals, de aceea
trebuie să considerăm toate cazurile:
Exemple:
63 5 23 1 8947 2 4
((p → q) ^ r) → ((~ r v p) → q)
0 1 0 11 0 1010 0 0
Observăm că la pasul 3 din faptul că valoarea conjuncţiei din membrul întâi este “1”,
rezultă că v(p → q) =1 şi v(r)=1. Întrucât v(q)=0 (rezultă din membrul 2 la pasul 4),
v(p)=0 (altfel v(p→q)=0). Dar dacă introducem v(p)=0 (din membrul întâi, pasul 6) în
membrul doi (pasul 7), obţinem 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.
3 2 3 1 2
a) ((~r v p) → q) → ((p → q) ^ r)
1 1 1 0 0
15
Bazele inteligenţei artificiale
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
((~ r v p) → q) → ((p → q) ^ r)
1 01 1 1 1 0 1 0 0 0 0
2.1.6. Echivalenţe
Echivalenţe fundamentale.
1. Absorbţia P ^ (P v Q) ⇔ P şi P v (P ^ Q) ⇔ P
2. Idempotenţa P ^ P ⇔ P şi P v P ⇔ P
3. Comutativitatea P ^ Q ⇔ Q ^ P şi P v Q ⇔ Q v P
4. Asociativitatea P ^ (Q ^ R) ⇔ (P ^ Q) ^ R
P v (Q v R) ⇔ (P v Q) v R
5. Distributivitatea P ^ (Q v R) ⇔ (P ^ Q) v (P ^ R)
P v (Q ^ R) ⇔ (P v Q) ^ (P v R)
6. Dubla negaţie ~ (~ P) ⇔ P
7. Legile lui De Morgan ~ (P ^ Q) ⇔ ~ P v ~ Q, ~ (P v Q) ⇔ ~ P ^ ~ Q
8. Transpunerea P→Q⇔~Q→~P
9. Negaţia implicaţiei ~ (P → Q) ⇔ P ^ ~ Q
10. Formula bicondiţională P ↔ Q ⇔ (P ^ Q) v (~P ^ ~Q)
16
Bazele inteligenţei artificiale
Fie F o formulă în care apar atomii p1, p2, ..., pn. Fie P1, ... , Pn formule oarecare.
Dacă F este o tautologie, atunci obţinută prin substituirea peste tot în F a fiecărei
apariţii a lui pi prin Pi (1 ≤ i ≤ n) este de asemenea o tautologie.
Exemple:
~ (p ^ q) ↔ ~ p v ~ q (De Morgan)
~ (P ^ Q) ↔ ~ P v ~ Q
P ^ (Q ^ R) ↔ (P ^ Q) ^ R
va fi o tautologie.
Exemplu:
2.1.8. Dualitate
“1”, ^ şi v. Noţiunile definite în termenii acestor simboluri trebuie traduse prin dualele
lor. Astfel dualul termenului “tautologie” este “nerealizabil” pentru că cele două
enunţuri duale sunt:
{~, ^, v}, {~, ^}, {~, v} şi {~, →} sunt mulţimi adecvate de conectori.
1) ↓ - rejecţie sau conectorul lui Nicod – se citeşte “nici ..., nici ...” = NOR
(tehnic)
tabelul de adevăr:
p q p↓q
-------------------------
1 1 0
1 0 0
0 1 0
0 0 1
~p = p ↓ p şi p ^ q = (p ↓ p) ↓ (q ↓ q)
p|q = ~p v ~q
tabelul de adevăr:
p q p|q
-----------------------
1 1 0
1 0 1
0 1 1
0 0 1
18
Bazele inteligenţei artificiale
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 consecinţa logiă folosim notaţia P1, P2, ..., Pn |= P. Simbolul |= în faţa
unei formule denotă că este o tautologie: |= P (citim P este o tautologie).
Cu alte cuvinte, orice model al conjuncţiei 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 număr redus de variabile propoziţionale se poate recusge la
tabela de adevăr a acestei formule).
∨ ∧l
i≤m j≤n
ij
∧∨ l
i≤n j≤m
ij
19
Bazele inteligenţei artificiale
1) un alfabet de simboluri,
2) o mulţime de formule bine formale,
3) o mulţime de axiome,
4) reguli de deducţie.
a) variabilele individuale;
b) conectivele logice: conjuncţie, negaţie;
∀ xF ⇔ ~(∃)~F
d) simbolurile relaţionale;
e) simbolurile funcţionale;
f) câte o constantă individuală.
20
Bazele inteligenţei artificiale
Prima noţiune care este introdusă în cadrul unui sistem formal este aceea de
demonstraţie.
Definiţie. Se numeşte demonstraţie secvenţa de formule A1, A2, ..., An astfel că:
Exemplu:
Fie: A1=p1→(p2→p3),
A2=(p1→(p2→p3)) →((p1→p2) →(p1→p1)),
A3=(p1→p2) →(p1→p1)
L1 p1 → (p2 → p1),
L2 (p1 → (p2 → p1)) → ((p1 → p2) → (p1 → p1)).
Aplicăm 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ă:
Definiţie. Fie o mulţime de formule Γ∈L. Se numeşte deducţie din Γ o secvenţă A1, A2,
..., An, astfel că:
Γ |- An.
L
21
Bazele inteligenţei artificiale
inferenţă
Premise Concluzie
Un lanţ inferenţial exprimat în limbaj obiect, ale cărui premise sunt axiome se
numeşte demonstraţie iar concluzia se numeşte teoremă.
Se consideră că limbajele obiect cel mai larg utilizate în inteligenţă artificială
sunt limbajul calculului propoziţional şi limbajul calculului cu predicate de ordinul
întâi.
Orice predicat este P(x) joacă rolul de funcţie propoziţională deoarece pentru
orice valoare a argumentului independent x, acesta ia ca valoare o propoziţie, cu
valoarea de adevărat sau fals. Numărul de obiecte individuale ce compun argumentul
reprezintă aritatea predicatului. Astfel pentru:
Orice predicat este de ordinul întâi 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 puţin una din variabilele sale individuale predicate de ordinul
întâi se spune că este un predicat de ordinul doi. Se poate spune în general că un
predicat este de ordin n dacă cel puţin una din variabilele sale este un predicat de
ordinul n-1. Pentru calculul cu predicate de ordinul întâi formulele se formează după
regulile limbajului calculului propoziţional, în care variabilele propoziţionale sunt
înlocuite cu predicate. În relaţia folosită pentru predicate, variabilele au semnificaţie nu
prin simbolurile folosite, ci prin poziţia şi rolul pe care îl joacă în definirea predicatului
respectiv. Variabilele folosite în aceste notaţii sunt denumite variabile formale, iar
notaţia definitorie pentru predicate este denumită expresie predicativă sau ion.
Se spune că P(x,y) şi P(u,v) sunt diferite ataşări de variabile formale pentru
aceeaşi 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
Bazele inteligenţei artificiale
|= ∀ xA(x) → A(r)
|= A(r) → ∃ xA(x)
în care:
x este orice variabilă
A(x) este o formulă
r reprezintă orice variabilă nu neapărat distinctă de x
A(r) este rezultatul substituţiei libere cu r a oricărei apariţii libere a variabilei x
în A(x).
23
Bazele inteligenţei artificiale
CAPITOLUL 3
SISTEME EXPERT
3.1. Sisteme expert – generalităţi
24
Bazele inteligenţei artificiale
cunoştinţe de inferenţă
utilizator
Interfaţa
Utilizator
Inginer de
Baza de Modul de
cunoştinţe
fapte explicare
Un loc aparte îl ocupă regulile deductive (sau inferenţe) care sunt de tipul:
Reprezentarea cunoştiinţelor.
Cunoştiinţele care sunt reprezentate în baza de fapte sunt cunoştiinţe afirmative.
25
Bazele inteligenţei artificiale
Motorul inferential.
La un sistem expert este necesar să fie dată o stare a bazei de fapte în care să
poată fi recunoscute regulile aplicabile. Acestă operaţie se numeşte filtrare. Preselecţia
regulilor înaintea filtrării se numeşte restrictionare.
După ce s-a facut preselecţia şi filtrarea trebuie aleasă o strategie de control
(operatie de selectare).
Restricţia nulă
26
Bazele inteligenţei artificiale
27
Bazele inteligenţei artificiale
CAPITOLUL 4
REALIZAREA UNUI PROGRAM ÎN MEDIUL DE
PROGRAMARE CLIPS
4.1. Introducere
CLIPS este un limbaj destinat dezvoltării 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, asemănător 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 înlăturarea acestor lipsuri.
Partea orientată obiect numită şi COOL (CLIPS Object-Oriented Language) este
o combinaţie între trăsăturile găsite şi la alte limbaje orientate obiect ,cum ar fi CLOS
(Common Lisp Object System) şi SmalTalk, la care s-au adus şi idei noi. Partea
procedurală a CLIPS-ului este asemănătoare 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 interfeţele Macintosh.
Datorită integrării totale cu alte limbaje asemănătoare cu C şi Ada, CLIPS-ul
poate fi apelat de un alt limbaj procedural şi după execuţia funcţiilor acesta returnează
controlul înapoi programului ce a realizat apelul. De asemenea codul procedural poate
defini şi funcţii externe, care după ce vor fi apelate de CLIPS şi îşi vor termina execuţia
vor returna controlul înapoi CLIPS-ului.
28
Bazele inteligenţei artificiale
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 ieşire din CLIPS este comanda:
(exit)
dar mai există uneori şi alte posibilităţi (de exemplu sub Windows se poate închide
fereastra sau se poate folosi scurtătura CTRL-Q, corespunzătoare comenzii Quit
CLIPS din meniul File).
Diferenţa între (exit) cu paranteze şi exit fără paranteze este ca nucleul CLIPS-
ului îl va identifica pe primul ca fiind o comandă şi îl va asocia pe al doilea cu un
simbol.
Încărcarea în mediul CLIPS-ului a construcţiilor aflate într-un fişier se
realizează cu ajutorul comenzii load. Sintaxa comenzii load este următoarea :
( load <file-name> )
Fişierul al cărui 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 fişier pentru stocarea construcţiilor se observă în momentul în
care CLIPS-ul verifică sintaxa construcţiilor sau când se lansează în execuţie
programul. Dacă s-ar realiza introducerea construcţiilor direct de la prompter în
momentul în care ar fi fost semnalată o eroare, ar fi trebuit să reintroducem construcţia
respectivă.
Presupunând că avem într-un fişier exemplu.clp aflat pe discul C: construcţii de
tipul deffacts, deftemplate, defrule, atunci încărcarea acestora se va face cu:
(load “C:exemplu.clp” )
Dacă fişierul respectiv se află într-un director şi trebuie să specificăm 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 căii se face astfel:
( load “C : \ \ temp \ \ programe \ \ exemplu.clp” )
Comanda load returnează simbolul TRUE atunci când nu sunt erori în fişierul
încărcat, respectiv simbolul FALSE în caz contrar. Dacă este activată watch
compilations atunci va fi afişat un mesaj informaţional (incluzând numele şi tipul
construcţiei) pentru fiecare construcţie încărcată. Dacă nu este activată atunci pentru
fiecare construcţie va fi afişat 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
construcţiilor într-un singur fişier, dar în cazul folosirii mai multor fişiere trebuiesc
încărcate toate fişierele pentru o bună execuţie a programului. Dacă se folosesc
construcţii 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
Bazele inteligenţei artificiale
30
Bazele inteligenţei artificiale
Figura 1
Selectând din meniul principal Windows, opţiunea Facts Window se afişează
fereastra din figura 2.
Figura 2.
31
Bazele inteligenţei artificiale
4.3.1. Constructorii
Mai mulţi constructori de definiţie apar în CLIPS: defmodule, defrule, deffacts,
deftemplate, defglobal, deffunction, defclass, definstances, defmessagehandler,
defgeneric şi defmethod. Toate construcţiile în CLIPS sunt cuprinse între paranteze,
începând cu o paranteză deschisă ‘ ( ‘ şi terminându-se cu o paranteză închisă ‘ ) ‘.
Aceşti constructori se folosesc pentru a adauga o informaţie la baza de cunoaştere a
CLIPS-ului.
Faţă de funcţiile apelate aceştia nu returnează niciodată o valoare. Se oferă
posibilitatea adăugării unui comentariu la numele construcţiei (excepţie face doar
defglobal). Comentariile pot fi amplasate în CLIPS utilizând punctul şi virgula ‘ ; ’
(semicolon), iar CLIPS-ul va ignora tot ce va găsi 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 execuţie a unui program CLIPS-ul va încerca
toate construcţiile ignorând comentariile.
4.3.2. Faptele
În CLIPS sunt trei forme principale de reprezentare a informaţiei : fapte (facts),
obiecte şi variabilele globale. Faptele sunt forma principală de reprezentare a
informaţiei în sistemul CLIPS. Fiecare fapt reprezintă un element de informaţie 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 relaţie urmat de zero sau mai multe sloturi
(câmpuri simbolice cărora li se pot asocia valori). Forma generală a unui fapt va fi
următoarea :
fact => ( nume_relaţie [ (slot)* ] [ (multislot)* ] )
Parantezele pătrate indica faptul ca existenţa sloturilor este opţională, iar semnul * arată
faptul că putem avea zero sau mai multe sloturi. Se observă faptul că în CLIPS trebuie
să cuprindem între paranteze atât numele de relaţie cât şi sloturile. Un slot este la rândul
său format dintr-un nume de slot, căruia 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ă existenţei în CLIPS a multicâmpului (multifield) care
este de fapt o secvenţă de zero sau mai multe câmpuri. Afişarea în CLIPS a unei valori
multicâmp se va realiza prin închiderea acestuia între paranteze. Trebuie reţinut faptul
că o valoare multifield (a) nu este unul şi acelaşi lucru cu o valoare câmp (single field)
(a) .
slot => ( nume_slot valoare )
ultislot => ( nume_slot [ valoare ]* )
Un slot trebuie să aibă obligatoriu asociată o valoare, pe când la un multislot
asocierea unei valori nu e obligatorie. Valorea pe care o asociem unui slot poate lua
forma unui tip de dată primitivă (integer, float, symbol, string) .
Exemple de fapte ar putea fi :
(start)
(adresa (nume-strada “Alexandru cel Bun”)
(numar-strada 47)
32
Bazele inteligenţei artificiale
(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 relaţie adresa are mai multe sloturi şi anume : nume-strada, numar-strada, bloc,
scara, apartament. Se observă faptul că putem asocia unui slot valori de diferite tipuri.
Astfel valoarea slotului nume-strada este un şir de caractere, valorile sloturilor numar-
strada şi apartament sunt întregi, iar valorile sloturilor bloc şi scara sunt simboluri. În
ultimul caz, pentru faptul persoana, atât slotul nume, cât şi slotul culoare-par sunt
multisloturi (au asociate două şi respectiv zero valori).
Trebuie reţinut faptul că în CLIPS nu are nici o importanţă ordinea apariţiei
sloturilor şi de aceea următoarele două fapte sunt văzute ca fiind identice deşi 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)) .
33
Bazele inteligenţei artificiale
34
Bazele inteligenţei artificiale
35
Bazele inteligenţei artificiale
obţinea acelaşi fapt, în schimb la ordered fact schimbând ordinea câmpurilor se obţine
un alt fapt. Din acest motiv următoarele fapte sunt văzute 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 semnificaţia fiecărui câmp. De aceea de cele mai
multe ori este recomandată folosirea unui deftemplate, deoarece numele sloturilor fac un
fapt mai uşor de înţeles ş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 conţine 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)
36
Bazele inteligenţei artificiale
37
Bazele inteligenţei artificiale
În CLIPS mai există şi comanda (clear) al cărei efect este acela de ştergere a
tuturor faptelor din listă, indexul de fapt începând 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 rămas
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ă deşi 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
acelaşi index din momentul asertării sale în listă, până în momentul ştergerii sale. Se
mai observă de asemenea că la asertarea faptului (e) spaţiile sunt ignorate şi că efectul
comenzii (retract 5 1) este acela de a ne atenţiona că faptul cu indexul 5 nu există, fără
însă a se opri de la ştergerea faptului cu indexul 1. Efectul comenzii (retract *) este
asemănător cu cel al comenzii (clear) , singura excepţie fiind indexul de fapte care nu
este resetat pe valoarea 0, ci îşi continuă incrementarea de la valoarea rămasă. La
asertarea faptului numar CLIPS-ul va realiza automat operaţia de adunare astfel încât
atunci când 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
Bazele inteligenţei artificiale
39
Bazele inteligenţei artificiale
De asemenea nu putem duplica decât un singur fapt, iar în cadrul acestuia putem
modifica valorile câmpurilor unui slot sau a mai multor sloturi. Funcţia returnează ca şi
funcţia 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 urmărit realizarea unor greşeli similare cu cele făcute la
funcţia modify , dar după cum era de aşteptat nu s-a mai pierdut informaţie, deoarece
funcţia duplicate nu retractează faptul ce se doreşte a fi duplicat.
40
Bazele inteligenţei artificiale
<Fact-3>
CLIPS> (retract 3 1)
<== f-3 (copil (nume Oana) (tata Vasile) (mama Ana))
<== f-1 (b)
Secvenţa de caractere ==> ne arată că faptul a fost asertat, intrând în lista de
fapte; pe când secvenţa 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 foloseşte comanda unwatch. Sintaxa
comenzii unwatch este următoarea:
(unwatch <watch-item>)
Evident că pentru a dezactiva urmărirea faptelor trebuie să dăm comanda
(unwatch facts).
După constructorii deftemplate şi deffacts în programul prezentat ca exemplu
(d1.clp) urmează definirea regulilor.
41
Bazele inteligenţei artificiale
=>
<action>* ) ; Right-Hand Side (RHS)
Redefinirea unei reguli deja existente, face ca regula anterioară cu acelaşi 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 opţional care
trebuie cuprins între ghilimele (comentariile pot fi introduse şi după punct şi virgula ’;‘)
urmează zero sau mai multe condiţii (pattern-uri) şi apoi zero sau mai multe acţiuni.
Practic o regulă este formată din două părţi LHS şi RHS separate de secvenţa de
caractere ( => ) pe care o putem numi şi săgeată, formată dintr-un semn ‘egal’ şi un
semn ‘mai mare decât’ . În comparaţia regulii cu un IF-THEN săgeata marchează
începutul părţii THEN. Partea stângă LHS este formată din zero sau mai multe elemente
condiţionale ( CE ) , care sunt legate între ele de un and implicit. RHS-ul este format
dintr-o listă de acţiuni care sunt executate dacă şi numai dacă toate elementele
condiţionale (pattern-urile) sunt satisfăcute. Nu există nici o limită pentru numărul de
condiţii sau de reguli dintr-o regulă, singura limitare o constituie memoria actuală
valabilă. CLIPS-ul aşteaptă îndeplinirea pattern-urilor unei reguli verificând faptele din
lista de fapte. Atunci când toate pattern-urile se potrivesc cu faptele, regula este activată
şi este pusă în agenda. Agenda reprezintă în CLIPS o colecţie de reguli activate. În
agendă pot fi zero sau mai multe fapte, retractarea unui fapt din lista de fapte putând
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 hotărăşte 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 condiţie în LHS, atunci CLIPS-ul va adăuga automat
pattern-ul special initial-fact. Orice regulă care nu are condiţii 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 întâmpla de asemenea ca o regulă să nu aibă nici o
acţiune în RHS. Acest lucru nu este prea util, dar e bine de ştiut că este posibilă
realizarea unei astfel de reguli.
Lansarea în execuţie în CLIPS a unui program se face cu ajutorul comenzii run a
cărei sintaxa este următoarea :
( run [ <limit> ] )
unde argumentul opţional <limit> este un număr întreg, ce specifică numărul maxim de
reguli ce vor fi aprinse. Dacă acest argument nu apare, atunci el are implicit valoarea –1
şi toate regulile vor fi aprinse până ce nu va mai rămâne nici una în agendă. În caz
contrar execuţia regulilor va înceta după ce un număr de <limit> reguli au fost aprinse.
Următoarea comanda run va continua execuţia din locul de unde s-a oprit, astfel încât
comanda (run 1) ar fi echivalentul unei rulări pas cu pas a programului.
Trebuie reţinut faptul că o regulă o dată aprinsă, nu mai poate fi activată de
obicei din nou. Este necesară ori ‘reîmprospătarea’ ei cu ajutorul comenzii refresh, ori
apelarea comenzii reset, care şterge toate faptele şi reintroduce baza iniţială de fapte din
construcţiile deffacts de la care s-a plecat. Odată refăcută baza iniţială de cunoaştere se
poate da din nou comanda run .
Alte exemple de reguli ar putea fi:
(defrule bariera_coborita
tren_apropiat da)
=>
actiune “Coboara bariera.”)
42
Bazele inteligenţei artificiale
(defrule bariera_ridicata
tren_apropiat nu)
=>
actiune “Ridica bariera.”)
43
Bazele inteligenţei artificiale
Comanda refresh pune înapoi în agendă toate activările regulii, ce au fost deja aprinse
(singura restricţie 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 intenţionat 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.
44
Bazele inteligenţei artificiale
(ppdefrule <defrule-name>)
(ppdeftemplate <deftemplate-name>)
(ppdeffacts <deffacts-name>)
45
Bazele inteligenţei artificiale
46
Bazele inteligenţei artificiale
47
Bazele inteligenţei artificiale
Comanda printout trimite spre un dispozitiv ataşat unui nume logic un şir de
caractere. Numele logic trebuie specificat pentru ca dispozitivul spre care se trimite să
fie pregătit (de exemplu un fişier trebuie deschis mai întâi). Pentru a avea ieşirea spre
stdout (ieşirea standard-în general monitorul) se foloseşte numele logic t. Sintaxa
comenzii printout este următoarea :
( printout <logical-name> <expresion>* )
Această comandă îşi dovedeşte utilitatea atunci când este amplasată în RHS-ul regulilor
cu scopul de a se afişa mesaje. Orice număr de expresii poate fi amplasat într-o
comandă printout pentru a fi afişate. Fiecare expresie este evaluată în vederea eliminării
spaţiilor adiţionale aflate între expresiile ce se doresc a fi printate. Simbolul crlf utilizat
ca o <expresie> poate fi amplasat oriunde în lista de expresii, el forţând carriage return /
new line (salt la început de linie nouă). Funcţia printout îşi marchează şirurile pe care le
afişează încadrându-le între ghilimele. Pot fi printate de asemenea şi adresele de fapt,
adresele de instanţă şi adresele externe. Această funcţie nu returnează nici o valoare.
Dispozitivul spre care se trimite poate fi redefinit, astfel încât se pot transmite informaţii
spre un modem sau o imprimantă.
Următoarea regulă demonstrează utilitatea comenzii printout :
(defrule cartela_telefonica
(card yes)
=>
(printout t “Puteti forma numărul de telefon…” crlf) )
În aceasta regulă prezenţa comenzii printout în RHS-ul regulii duce la afişarea
spre terminal (standard output device) a unui şir de caractere. Singurul argument al
funcţiei este şirul:
“Puteti forma numărul de telefon…”
care va fi afişat pe ecran fără ghilimele. Dacă s-ar fi dorit trimiterea şirului spre un
fişier, ar fi trebuit mai întâi deschis fişierul cu funcţia open .
Să vedem acum câteva din elementele programelor CLIPS.
În CLIPS avem trei elemente primare de scriere a programelor : tipuri primitive
de date, funcţii pentru manipularea datelor şi constructori pentru adăugarea datelor la
baza de cunoaştere.
48
Bazele inteligenţei artificiale
49
Bazele inteligenţei artificiale
4.3.18. Funcţiile
O funcţie în CLIPS este un element format din cod executabil cu un nume
specific, care returnează o valoare utilă sau are un anumit efect asupra informaţiei.
Există două tipuri de funcţii : 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. Funcţiile definite de sistem sunt acele funcţii ce
au fost definite intern de mediul CLIPS-ului, iar funcţiile definite de utilizator sunt
funcţii care au fost definite extern mediului CLIPS-ului.
Constructorul deffunction ajută utilizatorii să definească noi funcţii direct în
mediul CLIPS-ului utilizând sintaxa acestuia. Pot fi definite şi funcţii generice cu
ajutorul constructorilor defgeneric şi defmethod. Funcţiile apelate în CLIPS folosesc o
50
Bazele inteligenţei artificiale
notaţie prefix, argumentele unei funcţii apar întotdeauna după numele funcţiei. Funcţia
apelată începe cu o paranteză deschisă ‘ ( ‘ , urmată de numele funcţiei, de argumentele
acesteia (fiecare argument separat de unul sau mai multe spaţii) şi se termină cu o
paranteză închisă ‘ ) ‘ . Argumentele pot fi tipuri primitive de date, variabile sau chiar
alte funcţii apelate de aceasta. De exemplu funcţiile 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ă funcţiile + şi *. Amplasarea
greşită a parantezelor duce la modificarea numărului de argumente şi de aici la
obţinerea unui rezultat greşit.
4.3.19. Constructorii
Mai mulţi constructori de definiţie apar în CLIPS: defmodule, defrule, deffacts,
deftemplate, defglobal, deffunction, defclass, definstances, defmessagehandler,
defgeneric şi defmethod. Toate construcţiile în CLIPS sunt cuprinse între paranteze,
începând cu o paranteză deschisă ‘ ( ‘ şi terminându-se cu o paranteză închisă ‘ ) ‘.
Aceşti constructori se folosesc pentru a adauga o informaţie la baza de cunoaştere a
CLIPS-ului.
Faţă de funcţiile apelate aceştia nu returnează niciodată o valoare. Se oferă
posibilitatea adăugării unui comentariu la numele construcţiei (excepţie face doar
defglobal). Comentariile pot fi amplasate în CLIPS utilizând punctul şi virgula ‘ ; ’
(semicolon), iar CLIPS-ul va ignora tot ce va găsi 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 execuţie a unui program CLIPS-ul va încerca
toate construcţiile ignorând comentariile.
4.3.20. Faptele
În CLIPS sunt trei forme principale de reprezentare a informaţiei : fapte (facts),
obiecte şi variabilele globale. Faptele sunt forma principală de reprezentare a
informaţiei în sistemul CLIPS. Fiecare fapt reprezintă un element de informaţie 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 relaţie urmat de zero sau mai multe sloturi
(câmpuri simbolice cărora li se pot asocia valori). Forma generală a unui fapt va fi
următoarea :
fact => ( nume_relaţie [ (slot)* ] [ (multislot)* ] )
Parantezele pătrate indica faptul ca existenţa sloturilor este opţională, iar semnul
* arată faptul că putem avea zero sau mai multe sloturi. Se observă faptul că în CLIPS
trebuie să cuprindem între paranteze atât numele de relaţie cât şi sloturile. Un slot este la
rândul său format dintr-un nume de slot, căruia 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ă existenţei în CLIPS a multicâmpului (multifield) care
este de fapt o secvenţă de zero sau mai multe câmpuri. Afişarea în CLIPS a unei valori
multicâmp se va realiza prin închiderea acestuia între paranteze. Trebuie reţinut faptul
că o valoare multifield (a) nu este unul şi acelaşi lucru cu o valoare câmp (single field)
(a) .
slot => ( nume_slot valoare )
51
Bazele inteligenţei artificiale
52
Bazele inteligenţei artificiale
CAPITOLUL 5
REŢELE NEURALE
5.1. Modelul general al unei reţele neuronale
x1 t
w1
x2 w2 s = ∑ w jx j
j
y
wn y=f(s)
xn
acest neuron are i ponderi sinaptice, câte una pentru fiecare intrare.
Ponderile sunt notate:
53
Bazele inteligenţei artificiale
n
s = ∑ wj x j
j =1
1 daca x ≥ 0
f ( x) =
0 daca x < 0
Ieşirea se scrie:
n
y = f ∑ w j x j + t
j =1
xn+1=1
wn+1=t
n +1
s' = ∑ wj x j
j =1
y=f(s’)
1 daca x ≥ 0
f ( x) =
0 daca x < 0
54
Bazele inteligenţei artificiale
2. Funcţia signum
1 daca x ≥ 0
f ( x) =
− 1 daca x < 0
1
f ( x) = k >0
1 + e − kx
e kx − e − kx
f ( x) = kx k >0
e + e − kx
wi ,1
wi , 2
V =
i
...
w
i , n
55
Bazele inteligenţei artificiale
i=1, 2, ..., n
S = ViTX
Dacă se notează:
V 1
2
V
W =
...
V n
S=WX
xk1 yk
1
I1 O1
yk
xk2 2
I2 O2
x kn yk
m
In On
56
Bazele inteligenţei artificiale
Liste de asociere.
Considerăm vectorii:
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 mulţime de instruire o mulţime LA de
p asocieri:
57
Bazele inteligenţei artificiale
CAPITOLUL 6
MULŢIMI NUANŢATE
6.1. Noţiunea de mulţime nuanţată
A:X → [0, 1]
Exemplul 1.
58
Bazele inteligenţei artificiale
şi o mulţime nuanţată A peste X, ale cărei grade de apartenenţă sunt date de formula:
1
A(x i ) = , i = 1, 2, 3
i+2
Exemplul 2.
Fie universul:
Gradele de apartenenţă ale mulţimii nuanţate A sunt indicate prin valorile numerice:
Exemplul 3.
Fie:
X=R
A(t)
5 10 15 t (oC)
A = B ⇔ A(x) = B(x), ∀ x ∈ X
59
Bazele inteligenţei artificiale
A(x) ⊆ B(x), ∀ x ∈ X
A’ = 1 – A(x), ∀ x ∈ X
Mulţimea vidă:
Φ(x) = 0, ∀ x ∈ X
X(x) =1
X este A* Premiză
Dacă x este A atunci y este B Implicaţie
----------------------------------------------------------
Y este B* Concluzie
Dacă IN1 este ... şi IN2 este ... atunci OUT1 este ...
unde IN1 şi IN2 sunt elemente ale universului mulţimilor nuanţate de intrare iar OUT1
este un element al universului mulţimii nuanţate de ieşire.
Obţinerea mărimii de ieşire a sistemului expert se face prin denuanţarea mulţimii
nuanţate de ieşire. Metoda clasică de denuanţare este metoda centrului de greutate sau a
centroidei:
60
Bazele inteligenţei artificiale
∑ ( A( x) ⋅ x )
toti x
centroida =
∑ A( x)
toti x
Funcţiile de Nuanţare
apartenenţă a (fuzificare)
mărimilor de - universul
intrare mulţimii nuanţate-
intrări
fuzzy
Reguli
Evaluarea regulilor
ieşiri
fuzzy
Funcţiile de
apartenenţă a Denuanţare
mărimilor de ieşire (defuzificare)
Ieşiri
Figura 6.1. Sistem expert realizat cu ajutorul mulţimilor nuanţate
61
Bazele inteligenţei artificiale
CAPITOLUL 7
ALGORITMI GENETICI
7.1. Generalităţi
fi
f
unde:
62
Bazele inteligenţei artificiale
Selecţie Recombinare
(duplicare) (crossover)
Sir 1 Sir 1 Descendent A (1x2)
Sir 2 Sir 2 Descendent B (1x2)
Sir 3 Sir 3 Descendent A (2x4)
... ... Descendent D (2x4)
.............
63
Bazele inteligenţei artificiale
fi
- se calculează fitness-ul şi pentru >1 partea întreagă indică numărul de
f
şiruri identice plasate în populaţia intermediară;
f
- partea fracţionară 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 generaţia
intermediară şi se mai poate plasa una cu probabilitatea 0,36.
1101\/011011
yxxy/\xxxxyy
1101xxxxyy
şi
yxxy011011
64
Bazele inteligenţei artificiale
65
Bazele inteligenţei artificiale
SEMINAR
Seminar 1
Problema 1.1.
Să se construiască tabelele de adevăr pentru conectorii ~, v, ^, →, ↔ (negare,
sau, şi, implicare şi respectiv, echivalenţă).
Rezolvare
Tabelul 1.1.
a b ~a ~b avb a^b a→b a↔b
a negat b negat a ŞI b a SAU b a IMPLICĂ b a ECHIVALENT b
0 0 1 1 0 0 1 1
0 1 1 0 1 0 1 0
1 0 0 1 1 0 0 0
1 1 0 0 1 1 1 1
Problema 1.2.
Se consideră egalitatea: p v q = ~ (~p ^ ~ q) să se demonstreze cu ajutorul
tabelelor de adevăr că această egalitate este adevărată.
Rezolvare
Tabelul 1.2.
p q ~p ~q ~p ^ ~q p v q ~ (~p ^ ~ q)
0 0 1 1 1 0 0
0 1 1 0 0 1 1
1 0 0 1 0 1 1
1 1 0 0 0 1 1
Pentru ca formula să fie adevărată, ultimile două coloane ale tabelului de adevăr
1.2. trebuie să fie identice. Cu alte cuvinte, toate interpretările din ultimile două coloane
trebuie să aibă valoarea corespunzătoare, egală.
Problema 1.3.
Să se arate, cu ajutorul tabelelor de adevăr că formula P: p v q → ~ (~p ^ ~ q)
este o tautologie.
66
Bazele inteligenţei artificiale
Rezolvare
Dacă luăm în considerare ultimile două coloane din tabelul 1.2. obţinem:
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
Problema 1.4.
Să se arate cu ajutorul tabelelor de adevăr că egalitatea: p ^ (q v r) =(p ^ q) v (p
^ r) – distributivitate – este adevărată.
Rezolvare
Tabelul 1.4.
p q r qvr p^q p^r p ^ (q v r) (p ^ q) v (p ^ r)
0 0 0 0 0 0 0 0
0 0 1 1 0 0 0 0
0 1 0 1 0 0 0 0
0 1 1 1 0 0 0 0
1 0 0 0 0 0 0 0
1 0 1 1 0 1 1 1
1 1 0 1 1 0 1 1
1 1 1 1 1 1 1 1
Aşa cum s+a arătat şi la problema 1.2. ultimile două coloane ale tabelului de
adevăr 1.4. trebuie să fie egale pentru ca egalitatea să fie adevărată.
Problema 1.5
Se consideră formula P: p ^ (q v r). Să se răspundă la următoarele întrebări:
Problema 1.6.
Se consideră formula: P: p ^ (q v r) să se răspundă la următoarele întrebări
referitoare la interpretarea {p, ~q, r}. Să se răspundă la următoarele întrebări:
67
Bazele inteligenţei artificiale
Problema 1.7.
Să se scrie toate modelele formulei: P: p ^ (q v r).
Rezolvare
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 întâi cu V
(adevărat) şi apoi cu F (fals).
Dacă înlocuim atomul r cu adevărat (V) obţinem:
1.a. ((p ^ q ^ ~V) ^ (p v V)) → ((p v V) ^ (q v V))
din care se obţine:
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 obţinem:
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 întâi cu adevărat şi apoi cu fals. Acesta este atomul p:
68
Bazele inteligenţei artificiale
((p ^ q) ^ p) → (p ^ q)
((V ^ q) ^ V) → (V ^ q) ((F ^ q) ^ F) → (F ^ q)
ceea ce duce la:
(q ^ V) → q (F ^ F) → F
şi deci:
q→q F→F
în final:
V→V F→F V
V V
Rezultat obţinut prin înlocuirea atomului q cu adevărat şi apoi fals.
S-a obţinut astfel o interpretare în care formula este falsă (punctul 6.a.) iar restul
în care formula este adevărată. 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: (p→q)
→((q→r) →((p v q)→r)) este o tautologie.
Rezolvare
a. q = V
1.a. (p→V) →((V→r) →((p v V)→r))
2.a. V →(r →(V→r)
3.a. V →(r →r)
4.a. V →(r →r)
În acestă situaţie se înlocuieşte atomul r, mai întâi cu adevărat şi apoi cu fals. Se obţine:
4.a.1. V →(V →V) rezultă: V → V şi ceea ce în final duce la V (adevărat);
4.a.2. V →(F →F) rezultă: V → V şi ceea ce în final duce la V (adevărat);
b. q = F
1.b. (p→F) →((F→r) →((p v F)→r))
2.b. ~p →(V →(p→r))
Se înlocuieşte acum atomul care apare cel mai frecvent, p, mai întâi cu adevărat şi apoi
cu fals.
2.b.1. ~V →(V →(V→r)), rezultă: F →(V →r) şi deci: F → r care este V
(adevărat);
2.b.2. ~F →(F →(F→r)), rezultă: V →(F →V) deci: V →V care dă rezultatul V
(adevărat).
S-a obţinut în toate cazurile rezultatul „adevărat” şi deci formula este o
tautologie”.
69
Bazele inteligenţei artificiale
Seminar 3.
Problema 3.1.
Să se demonstreze prin metoda reducerii că formula de la problema 2.2. este o
tautologie.
Rezolvare
70
Bazele inteligenţei artificiale
Seminar 4.
71
Bazele inteligenţei artificiale
Seminar 5.
Seminar 6.
Problema 6.1.
Folosind universul de discurs, mulţimea oamenilor, să se definească mulţimea
TÂNĂR care răspunde la întrebarea: „care este gradul de tinereţe al unei persoane”
Rezolvare.
Noţiunea de TÂNAR este o noţiune imprecisă. Putem considera persoanele cu
vârsta mai mică de 20 de ani ca fiind tinere. Vârsta unei persoane o notam cu v(x).
Un exemplu de definire este:
1, v( x) ≤ 20
30 − v( x)
ATANAR ( x) = , 20 < v( x) ≤ 30
10
0, v( x) > 30
72
Bazele inteligenţei artificiale
Problema 6.2.
Să se definească mulţimea oamenilor înalţi pe universul de discurs mulţimea
oamenilor.
Rezolvare.
Caracteristica unei persoane de a fi înaltă este de asemenea o noţiune imprecisă.
Pentru a specifica un model fuzzy, notăm h(x) înălţimea în centimetrii a unei persoane
şi considerăm că oamenii cu înălţimea sub 150 cm sunt scunzi (nu sunt înalţi) iar cei cu
înălţimea peste 200 cm sunt înalţi. Funcţia de apartenenţă la clasa oamenilor înalţi se
defineşte atunci prin:
0, h( x) < 150
h( x) − 150
AINALT ( x) = , 150 ≤ h( x) ≤ 200
200
1, h( x) > 200
Problema 6.3.
Să se definească mulţimea fuzzy a numerelor reale foarte apropiate de numărul
zero.
Rezolvare.
Dacă X este mulţimea fuzzy dorită, atunci un model pentru funcţia de
apartenenţă A(x) poate fi:
1
A( x) =
1+ x2
ceea cene conduce la: A(1) = 0,5; A(0) = 1; A(2) = 0,2; A(-2) = 0,2; A(3) = 0,1; A(-3) =
0,1.
Un alt model ar putea fi:
2
1
A( x) = 2
1+ x
ceea cene conduce la: A(1) = 0,25; A(0) = 1; A(2) = 0,04; A(-2) = 0,04; A(3) = 0,01;
A(-3) = 0,01.
Similar, putem defini mulţimea fuzzy a numerelor apropiate de numărul real a,
cu ajutorul funcţiei de apartenenţă:
1
A( x) =
1 + (x − a )
2
Problema 6.4.
Se consideră universul de discurs mulţimea numerelor reale. Să se definească
funcţia de apartenenţă pentru numerele reale care îndeplinesc condiţia a < b.
Rezolvare.
În acest caz se foloseşte o mulţime interval. Modelul interval este:
1, x ∈ [a, b]
A( x) = 1[a ,b ] ( x) =
0, altfel
Se spune că funcţia de apartenenţă furnizează o reprezentare pe verticală a unei
mulţimi fuzzy.
73
Bazele inteligenţei artificiale
Seminar 7.
11. Alegeti varianta cea mai corectă din cele prezentate mai jos. Problemele tratate
cu succes de un sistem expert sunt:
A. Probleme de optimizare.
B. Probleme de conducere.
C. Probleme pentru care nu există o soluţie algoritmică clară.
Răspuns: C
12. Alegeţi răspunsul corect, în funcţie de modul în care definiţia următoare este
corectă (ADEVĂRAT) sau incorectă (FALS). O reţea neurală constă dintr-o
mulţime de elemente de prelucrare (neuroni, elemente cognitive sau noduri ale
reţelei) înalt interconectate.
A. ADEVĂRAT B. FALS
Răspuns: A
13. Alegeţi răspunsul corect, în funcţie de modul în care definiţia următoare este
corectă (ADEVĂRAT) sau incorectă (FALS). Funcţia de ieşire a neuronului
reprezintă funcţia de activare.
A. ADEVĂRAT B. FALS
Răspuns: A
14. Alegeţi răspunsul corect, în funcţie de modul în care definiţia următoare este
corectă (ADEVĂRAT) sau incorectă (FALS). O reţea neurală multistrat poate
conţine cel mult un strat ascuns.
A. ADEVĂRAT B. FALS
Răspuns: B
15. Alegeţi răspunsul corect, în funcţie de modul în care definiţia următoare este
corectă (ADEVĂRAT) sau incorectă (FALS). Algoritmul de instruire a
perceptronului se bazează pe modificarea ponderilor şi a valorii de prag.
A. ADEVĂRAT B. FALS
Răspuns: A
16. Alegeţi răspunsul corect, în funcţie de modul în care definiţia următoare este
corectă (ADEVĂRAT) sau incorectă (FALS). O mulţime nuanţată nu poate
avea complementară.
A. ADEVĂRAT B. FALS
Răspuns: B
17. Alegeţi răspunsul corect, în funcţie de modul în care definiţia următoare este
corectă (ADEVĂRAT) sau incorectă (FALS). Populaţia iniţială a unui algoritm
genetic este stabilită de funcţia de evaluare.
A. ADEVĂRAT B. FALS
Răspuns: B
18. Alegeţi răspunsul corect, în funcţie de modul în care definiţia următoare este
corectă (ADEVĂRAT) sau incorectă (FALS). Un sistem expert conţine o bază
de cunoştiinţe şi un mecanism de interferenţă.
A. ADEVĂRAT B. FALS
Răspuns: B
74
Bazele inteligenţei artificiale
19. Alegeţi răspunsul corect, în funcţie de modul în care definiţia următoare este
corectă (ADEVĂRAT) sau incorectă (FALS). Ponderile sinaptice sunt asociate
ieşirilor neuronului.
B. ADEVĂRAT B. FALS
Răspuns: B
20. Alegeti varianta corectă din cele prezentate mai jos. În activitatea de instruire a
unei reţele neurale sunt folosite:
A. Listele cu ponderile aşteptate.
B. Listele de conexiuni cunoscute.
C. Listele de asociere.
Răspuns: C
21. Alegeti varianta incorectă din cele prezentate mai jos. Perceptronul reprezintă:
A. Cea mai simplă reţea neurală.
B. O reţea neurală cu un singur strat.
C. Perceptronul nu poate avea decât două intrări.
Răspuns: C
22. Alegeti varianta incorectă din cele prezentate mai jos. O mulţime nuanţată este
caracterizată de:
A. Universul mulţimii nuanţate.
B. Tabelul de adevăr.
C. Funcţia de apartenenţă.
Răspuns: B
23. Alegeţi răspunsul corect, în funcţie de modul în care definiţia următoare este
corectă (ADEVĂRAT) sau incorectă (FALS). În cazul unui algoritm genetic
fiecare şir component al unei generaţii se numeşte cromozom sau genotip.
A. ADEVĂRAT B. FALS
Răspuns: A
24. Alegeţi răspunsul corect, în funcţie de modul în care definiţia următoare este
corectă (ADEVĂRAT) sau incorectă (FALS). Într-un algoritm genetic trecerea
de la generaţia curentă la generaţia următoare se face prin selecţie,
recombinare şi mutaţie.
A. ADEVĂRAT B. FALS
Răspuns: A
25. Alegeţi răspunsul corect, în funcţie de modul în care definiţia următoare este
corectă (ADEVĂRAT) sau incorectă (FALS). Pentru un perceptron ponderile
sinaptice pot fi inhibitoare sau excitatoare.
A. ADEVĂRAT B. FALS
Răspuns: A
26. Alegeţi varianta incorectă din cele prezentate mai jos. Funcţiile unui sistem
expert sunt:
A. Funcţia de învăţare.
B. Funcţia de evaluare a cunoştiinţelor pe baza raţionamentelor.
C. Funcţia de elaborare a unor algoritmi simplii.
Răspuns: C
27. Alegeţi varianta corectă din cele prezentate mai jos. Listele de asociere în cazul
reţelelor nurale reprezintă:
A. Asocierea intrărilor cu ponderile sinaptice..
B. Asocierea intrărilor cu funcţiile de excitaţie.
75
Bazele inteligenţei artificiale
76
Bazele inteligenţei artificiale
LABORATOR
Laborator 1, 2, 3.
Indicaţie:
Ne vom baza pe metoda tabelelor de adevăr în care trebuie să demonstrăm că formula
este adevărată în toate interpretările ei.
Pentru aceasta se vor construi funcţii (proceduri) pentru conectorii: ~ (negare), v (sau), ^
(şi), → (implicare). Cu ajutorul acestora vor fi evaluate formulele pentru toate valorile
posibile pentru variabilele P,Q, R.
PROGRAMUL binar1.cpp
#include <stdio.h>
#include <conio.h>
77
Bazele inteligenţei artificiale
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);
}
}
78
Bazele inteligenţei artificiale
}
şi ECHIVALENŢĂ funcţia echiv:
Dacă ne uităm la tabela de adevăr prezentată mai sus este uşor să înţelegem cum
au fost realizate aceste funcţii:
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
Bazele inteligenţei artificiale
gama(echivalenta)= 0
alfa= 1
beta= 1
gama(si)= 1
gama(sau)= 1
gama(nu beta)= 0
gama(implicare)= 1
gama(echivalenta)= 1
Acest exemplu a fost ales mult mai complex decât formulele 1) … 34) în aşa fel încât să
se înţeleagă modul de lucru pentru toate cazurile.
PROGRAMUL binar2.ccp
80
Bazele inteligenţei artificiale
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
Bazele inteligenţei artificiale
fprintf(fisier,"\n c: %d",c);
fprintf(fisier,"\n Valoare iesire (a SI b) IMPLICA c: %d",A[contor]);
contor++;
scanf("%c",pas);
}
82
Bazele inteligenţei artificiale
Pentru început vom construi tabelul de adevăr pentru această formulă. Prima
observaţie care se poate face este că prima parte a formulei: ((a ^ b) → c) depinde de
variabilele a, b şi c care nu apar în partea a doua a formulei. În acest fel vom construi
tabelul de adevar din două tabele.
Primul tabel:
Pentru a evalua formula se construieste acum cel de-al doilea tabel pentru
formula:
A ^ (d ^ e) → (d v e)
83
Bazele inteligenţei artificiale
este :
A d e (d ^ e) (d v e) A^B D → C care este de fapt formula
notat B notat C notat D ((a ^ b) → c) ^ (d ^ e) → (d v e)
0 0 0 0 0 0 1
0 0 1 0 1 0 1
0 1 0 0 1 0 1
0 1 1 1 1 0 1
1 0 0 0 0 0 1
1 0 1 0 1 0 1
1 1 0 0 1 0 1
1 1 1 1 1 1 1
Acelasi lucru a fost realizat şi cu ajutorul programului Binar2. Reyultatele acestuia sunt:
Se calculeaza (a SI b)
a: 0
b: 0
Valoare iesire a SI b: 0
a: 0
b: 1
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
Bazele inteligenţei artificiale
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
85
Bazele inteligenţei artificiale
86
Bazele inteligenţei artificiale
PROGRAMUL flogic.ccp
PROGRAMUL binar3.ccp
// programul Binar3 de verificare a formulei (p SI q) IMPLICA q
#include <stdio.h>
include<conio.h>
#include<flogic.h>
87
Bazele inteligenţei artificiale
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);
}
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
PROGRAMUL binar4.cpp
88
Bazele inteligenţei artificiale
#include <stdio.h>
#include<conio.h>
#include<flogic.h>
p= 0
q= 0
89
Bazele inteligenţei artificiale
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
Laborator 4, 5, 6.
Sistem expert
Programul DIAG2.PAS este un program demonstrativ pentru utilizarea
sistemelor expert. Acest program este destinat in principal pentru învăţarea modului de
definire a termenilor introduşi în baza de date. Rezultatele obţinute sunt în general
modeste datorită faptului că maşina de inferenţă utilizată este extrem de simplă. Chiar şi
aşa se poate vedea modul de funcţionare al unui sistem expert şi faptul că definirea
corectă a informaţiei duce la rezultate bune.
De asemenea este prezentat şi listingul complet al programului în aşa fel încât să
se poată urmări modul de realizare al diverselor funcţii program. Deşi pentru sisteme
90
Bazele inteligenţei artificiale
expert există limbaje consacrate s-a preferat scrierea programului în PASCAL pentru
veleităţile didactice ale acestuia.
După lansarea programului este afişat următorul meniu:
Introduceti:
I -> invatare
A -> actualizare
M -> modificare
C -> consultare
D -> analiza
E -> estimare
S -> stergere baza de date
Q -> parasire program
Introduceti optiunea: _
• Estimare. Permite aflarea unei noţiuni (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
Bazele inteligenţei artificiale
diag2.dat. Dacă datele din baza de date vor fi utilizate mai târziu atunci este
necesar ca, înainte de ştergerea bazei de date, să se copie baza de date
curentă într-un fişier cu un alt nume.
Dacă este prima rulare a programului sau se doreşte crearea unei baze de date
noi se alege opţiunea “S – Ştergere bază de date” pentru iniţilalizarea respectiv ştergerea
bazei de date. După aceasta se vor introduce datele în baza de date prin selectarea
opţiunii “I - Învăţare”. După selectarea acestei opţiuni este afişat pe ecranul
monitorului:
Introduceti notiunea:
|-----------------------|
_
fapt ce permite introducerea numelui unei noţiuni. Din cauză că numărul de caractere
pentru o noţiune este limitat, pe ecran este afişată şi dimensiunea acesteia (cu linie
punctată) în aşa fel încât denumirea noţiunii să fie introdusă corect.
După introducerea noţiunii vor fi introduse atributele acesteia. Dacă au fost
definite atribute anterior (pentru alte noţiuni), atunci se va cere utilizatorului să
definească valoarea de adevăr a acestor atribute, pentru noţiunea nou introdusă. Valorile
de adevăr pot fi: adevărat – dacă atributul respectiv reprezintă o caracteristică (în
general definitorie) pentru noţiunea respectivă, fals – dacă atributul respectiv este o
caracteristică a noţiunii respective dar precizează diferenţa (neîndeplinirea unei
caracteristici) faţă de alte noţiuni şi nedefinit – dacă atributul în discuţie nu este
definitoriu pentru noţiunea respectivă. După definirea atributelor existente în baza de
date sau atunci când se introduce prima noţiune se va cere introducerea atributelor noi.
Atributele noi vor fi definite aici pentru noţiunea în lucru şi vor fi automat nedefinite
pentru celelalte noţiuni din baza de date. Pentru actualizarea valorilor de adevăr a
atributelor cu valoarea de adevăr “nedefinit” pentru toate noţiunile din baza de date se
utilizează opţiunea “A – Actualizare” după terminarea fazei de învăţare. Revenind la
faza de învăţare, introducerea atributelor noi, pentru început se vor introduce atributele
care reprezintă afirmaţii legate de noţiunea respectivă. Ecranul afişat este:
92
Bazele inteligenţei artificiale
93
Bazele inteligenţei artificiale
a putea face distincţia între interfeţe, periferice şi celelalte elemente s-au mai introdus
atributele: transfer blocuri date, comunică cu perifericele şi comunică cu interfeţele.
Atributele cu valoarea de adevăr fals pentru noţiunea microprocesor vor fi:
Pentru această noţiune au fost stabilite numai două atribute specifice ceea ce în
general ar trebui să fie suficient dacă aceste atribute sunt proprii numai noţiunii
respective. De asemenea, fiind definite atribute specifice cu valoarea de adevăr adevărat
la noţiunea de microprocesor acestea vor avea de regulă valoarea de adevăr fals pentru
noţiunea de memorie şi pentru toate noţiunile care vor fi introduse după aceasta. Trebuie
notat faptul că nu este o regulă generală ca un atribut specific unei noţiuni să fie
obligatoriu fals pentru toate celelalte existând şi situaţii când un atribut specific este
adevărat pentru mai multe noţiuni (a nu se confunda cu atributele de departajare care
sunt destinate departajării claselor de noţiuni) Atributele cu valoarea de adevăr fals sunt:
94
Bazele inteligenţei artificiale
După introducerea celei de-a doua noţiuni se poate observa faptul că nu se poate
stabili uşor 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 noţiunilor
care sunt caracterizate de acelaşi atribut, cu opţiunea “C – consultare” şi clasificarea
noţiunilor cu ajutorul opţiunii “D – analiză”.
În tabelul următor sunt prezentate următoarele noţiuni introduse şi valorile de
adevăr pentru atributele acestora.
Noţiune
Interfaţă Modul DMA Tastură Imprimantă
Atribut
Face calcul aritmetic Fals Fals Fals Fals
Face calcul logic Fals Fals Fals Fals
Executa program Fals Fals Fals Adevărat
Generează adrese Fals Adevărat Fals Fals
Achita intreruperi Fals Fals Fals Fals
Modul master Fals Adevărat Fals Fals
Modul slave Adevărat Fals Nedefinit Nedefinit
Memoreaza date Nedefinit Fals Fals Nedefinit
Memoreaza programe Fals Fals Fals Adevărat
Definit de capacitate Fals Fals Fals Fals
Comunică cu periferice Adevărat Nedefinit Fals Fals
Dispozitiv programabil Adevărat Adevărat Fals Adevărat
Generează întreruperi Adevărat Adevărat Nedefinit Nedefinit
Noţiune Interfaţă Modul DMA Tastură Imprimantă
Atribut
Transfer blocuri date Adevărat Adevărat Fals Adevărat
Introducere de date Adevărat Adevărat Adevărat Fals
Circuit integrat Adevărat Adevărat Fals Fals
Pe placa de bază Adevărat Adevărat Fals Fals
Transfer rapid date Fals Adevărat Fals Fals
Este periferic Fals Fals Adevărat Adevărat
Comunica cu interfetele Fals Adevărat Adevărat Adevărat
Dispozitiv extern Fals Fals Adevărat Adevărat
Electro-mecanica Fals Fals Adevărat Adevărat
Consola sistem Fals Fals Adevărat Fals
95
Bazele inteligenţei artificiale
96
Bazele inteligenţei artificiale
memorie
interfata
tastatura
imprimanta
microprocesor
modul DMA
97
Bazele inteligenţei artificiale
Apasati ENTER
_
98
Bazele inteligenţei artificiale
în continuare este prezentată lista atributelor pentru care se solicită stabilirea unei valori
de adevăr şi un exemplu de valori de adevăr stabilite. Trebuie observat faptul că
utilizatorul nu a stabilit corect toate valorile de adevăr (prin comparare cu cele stabilita
la crearea bazei de cunoştiinţe prezentate în tabelul de mai sus) iar pentru caracteristicile
la care nu a ştiut să răspundă a ales valoarea de adevăr nedefinit.
Lista atributelor şi a valorilor de adevăr este:
99
Bazele inteligenţei artificiale
care arată că noţiunea cu cea mai mare probabilitate (88,89%), care are trăsăturile
specificate de utilizator, este cea de imprimantă, ceea ce este corect. Sunt afişate toate
noţiunile din baza de cunoştiinţe cu probabilitatea asociată în aşa fel încât utilizatorul să
poată alege noţiunea ce răspunde cel mai bine situaţiei date (în cazul probabilităţilor
apropiate).
Vom considera acum că se evaluează o noţiune care nu există în baza de
cunoţtiinţe, cea de monitor. Valorile de adevăr stabilite pentru această noţiune vor fi:
100
Bazele inteligenţei artificiale
101
Bazele inteligenţei artificiale
Apasati ENTER
Program Diagnostic;
{
Programul Diagnostic este un program demonstrativ pentru sisteme expert. Acest
program are mai multe regimuri:
102
Bazele inteligenţei artificiale
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
Bazele inteligenţei artificiale
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
Bazele inteligenţei artificiale
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
Bazele inteligenţei artificiale
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
Bazele inteligenţei artificiale
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
Bazele inteligenţei artificiale
===============================')
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
Bazele inteligenţei artificiale
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
Bazele inteligenţei artificiale
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
Bazele inteligenţei artificiale
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
Bazele inteligenţei artificiale
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;
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
Bazele inteligenţei artificiale
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
Bazele inteligenţei artificiale
114
Bazele inteligenţei artificiale
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
Bazele inteligenţei artificiale
write(notiuni[contor1],
'-',notiuni[contor2]);
inc(pozitie3);
{S-a depasit un ecran de afisare}
if pozitie3>PozitieFinala then
begin
pozitie3:=PozitieInitiala;
writeln('Apasati ENTER.');
readln;
StergeEcran;
end;
end;
end;
end;
end;
gotoxy(1,23);
writeln('Apasati ENTER');
readln;
end;
end;
procedure AfisareNotiuni;
{
Procedura permite afisarea tuturor notiunilor din baza de date.
}
var
contor1:byte;
begin
with BazaDeDate do
begin
for contor1:=1 to ContorNotiuni-1 do
begin
writeln(contor1,'. ',notiuni[contor1]);
if contor1 mod 20 = 0 then
begin
writeln;
write('Apasati ENTER pentru continuare');
readln;
StergeEcran;
end;
end;
end;
writeln;
write('Apasati ENTER pentru continuare');
readln;
StergeEcran;
end;
116
Bazele inteligenţei artificiale
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
Bazele inteligenţei artificiale
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
Bazele inteligenţei artificiale
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
Bazele inteligenţei artificiale
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
Bazele inteligenţei artificiale
121
Bazele inteligenţei artificiale
{
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
Bazele inteligenţei artificiale
CitescOptiune;
case optiune of
'I': Invatare;
'A': Actualizare;
'M': Modificare;
'C': Consultare;
'D': Analiza;
'E': Estimare;
'S': StergereBazaDeDate;
end;
until optiune='Q';
end.
Laborator 7, 8, 9.
Perceptronul
Perceptronul cu un singur strat este cea mai simplă reţea neurală. Modelul
perceptronului este sâmburele din care s-au dezvoltat toate celelalte reţele 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 intrări. Pentru exemplificare se utilizeaza perceptronul cu două intrări instruit
să separe punctele dintr-un plan. Programul este destinat învăţării modului de
funcţionare a perceptronului, modul de instruire a acestuia şi limitele acestuia. De
asemenea este prezentată lista codului programului scris în limbaj de programare
PASCAL pentru înţelegerea modului de implementare a perceptronului, a tehnicii de
instruire şi utilizarea perceptronului.
Perceptronul cu un singur strat cu două intrări este prezentat în figura următoare:
123
Bazele inteligenţei artificiale
w1
t
x1
y=w1x1+
+w2x2 f
w2
x2 f=y(t)
y = w1 x1 + w2 x2
0 daca y < −t
f =
1 daca y > −t
124
Bazele inteligenţei artificiale
Î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 situaţie, învăţarea perceptronului reprezinta de fapt
determinarea unei drepte care sa separe planul în două părţi, fiecare parte a planului
trebuind să conţină numai punctele de acelaşi fel. In acest fel relaţia:
y = w1 x1 + w2 x2
w1 x + w2 y − t = 0
w = w + dw
t = t + dt
125
Bazele inteligenţei artificiale
dW = I x (T - O)T
dt = ∑ (T − O)
126
Bazele inteligenţei artificiale
Din această reprezentare grafică se observă modul în care este separat planul în
cele două regiuni. După instruire perceptronul este capabil să clasifice puntele din plan.
Se propune ca exerciţiu să se completeze programul în aşa fel încât utilizatorul, după
faza de instruire, să poată introduce valorile punctelor de intrare şi să primesacă ca
răspuns evaluarea acestora de către perceptronul cu un strat.
Program perceptron1;
{
Programul implementeaza in Pascal perceptronul cu doua intrari.
127
Bazele inteligenţei artificiale
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:
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:
128
Bazele inteligenţei artificiale
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
Bazele inteligenţei artificiale
130
Bazele inteligenţei artificiale
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
Bazele inteligenţei artificiale
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
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
Bazele inteligenţei artificiale
+ 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
Bazele inteligenţei artificiale
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.
Activitatea 1.
Să se realizeze un program în CLIPS care să găsească toate aranjamentele
posibile a patru culori (rosu, albastru, galben, verde) luate câte 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
Bazele inteligenţei artificiale
Din acest motiv sintaxa acestuia permite definirea foarte succintă a unor căutări 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.
Conţinutul fişierului 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 afişează:
Defining deffacts: obiecte
Defining defrule: aranjamente +j+j+j
TRUE
Ceea ce semnifică faptul că programul s-a încărcat cu succes.
Lansarea în execuţie se face astfel:
CLIPS> (reset)
CLIPS> (run)
Programul afişează rezultatul execuţiei, aranjamentele posibile a patru culori în grupe de
câte trei, ca în figura de mai jos:
135
Bazele inteligenţei artificiale
Activitatea 2.
Să se iniţializeze o bază de cunoştinţe cu numele şi prenumele unor persoane,
apoi să se afişeze 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 defineşte structura (template-ul) pentru persoană:
(deftemplate persoana
(slot nume)
(slot prenume)
)
Se iniţializează baza de cunoştinţe (se introduc datele iniţiale ale problemei):
(deffacts init
(persoana (nume Popescu) (prenume Ion))
(persoana (nume Ionescu) (prenume Vasile))
(persoana (nume Pop) (prenume Carmen))
Se defineşte regula pentru afişarea persoanelor cu numele dorit:
(defrule Popescu
(persoana (nume Popescu) (prenume ?p))
=>
(printout t ?p " Popescu " crlf)
)
Se salvează fişierul cu numele ex2.clp în directorul C\CLIPS\PROG.
Comenzile pentru încărcarea şi execuţia programului:
CLIPS> (clear)
se şterg eventualele fapte din execuţiile anterioare
CLIPS> (load “c:\\clips\\prog\\ex2.clp”)
se încarcă programul
CLIPS> (reset)
se activează faptele iniţiale şi regulile corespunzătoare pentru începerea execuţiei
CLIPS> (run)
se lansează în execuţie.
Activitatea 3.
Să se realizeze o stivă cu operaţiile elementare cunoscute (push = depunere în
stivă, pop = extragere din stiva, top = afişarea vârfului stivei).
Rezolvare
Listingul programului este:
(deffacts init
(push 5)
(pop)
136
Bazele inteligenţei artificiale
(push abc)
(push 12)
(top)
(pop)
(top)
)
(defrule stack_init
; nu avem nicio conditie LHS (Left-Hand Side); regula se executa la inceputul
;programului
=>
; se initializeaza stiva cu un fapt vid
; celelalte reguli nu se vor aprinde decit daca exista un fapt stack
(assert (stack))
)
(defrule stack_push
?f1 <- (push ?element)
?f2 <- (stack $?stacklist)
=>
; o regula se aplica o singura data pentru aceeasi conditie
; in acest caz se sterge f1 pentru ca se schimba f2 si deci se schimba LHS ca intreg
(retract ?f1 ?f2)
; se introduce elementul in stiva
(assert (stack ?element $?stacklist))
(printout t "Push: " ?element crlf)
)
(defrule stack_pop
?f1 <- (pop)
?f2 <- (stack ?element $?stacklist)
=>
(retract ?f1 ?f2)
(defrule stack_top
(top)
(stack ?element $?stacklist)
=>
(printout t "Top: " ?element crlf)
; aici nu avem nevoie sa stergem fapte, LHS ramine neschimbata
)
Notă: deşi faptele sunt definite într-o anumită ordine: push, pop, push, top, pop, top),
execuţia programului nu ţine seama de aceasta ordine:
Push: 5
Push: abc
137
Bazele inteligenţei artificiale
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.
Activitatea 4.
Să se realizeze un program CLIPS care să permită identificarea unei cărţi într-o
bibliotecă.
Rezolvare
Indicaţie:
Se va folosi o structură de tipul:
(deftemplate carte
(multislot prenume_autor)
(slot nume_autor)
(multislot titlu)
)
(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
Bazele inteligenţei artificiale
(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
Bazele inteligenţei artificiale
(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
Bazele inteligenţei artificiale
(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)
)
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
Bazele inteligenţei artificiale
;;;======================================================
;;; 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 *
;;;**************************
142
Bazele inteligenţei artificiale
;;;***************************
;;;* DEFFACTS KNOWLEDGE BASE *
143
Bazele inteligenţei artificiale
;;;***************************
(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
Bazele inteligenţei artificiale
145
Bazele inteligenţei artificiale
146
Bazele inteligenţei artificiale
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
Bazele inteligenţei artificiale
148
Bazele inteligenţei artificiale
149
Bazele inteligenţei artificiale
150
Bazele inteligenţei artificiale
BIBLIOGRAFIE
1. Aur Dorian, Aur Liviu – Modelări neuronale în inteligenţa artificială, Editura
Grigore Tabacaru, Băcau, 1997
2. Dumitrascu Liviu, s.a. - Elemente de inteligenţă artificială pentru conducerea
operativă a producţiei, Editura Academiei, Bucuresti 1983
3. Hristev Ryurick Marius - Introducere in: Prolog, un limbaj al inteligenţei artificiale,
Editura APH, Bucuresti 1992
4. Malita Mihaela, Malita Mircea - Bazele inteligenţei artificiale. Logici
propoziţionale. Editura Tehnica, Bucuresti, 1987
5. Streinu Ileana - LISP. Limbajul de programare al inteligenţei artificiale, Editura
Ştiinţifică şi enciclopedică, Bucureşti 1986
6. Becheanu M., s.a. – Logică matemetică şi teoria multimilor, Editura Didactică şi
pedagogică, Bucureşti 1972
7. Dumitraş Adriana - Proiectarea reţelelor neuronale artificiale, Editura ODEON,
Bucuresti, 1997
8. Dumitrescu D. Costin Hariton – Reţele neuronale. Teorie şi aplicatii. Editura
TEORA, Bucuresti, 1996
9. Flondor Paul, Ionescu Cezar - Introducere în algoritmi genetici, ALL, Bucuresti,
1999
10. Chiorean Ioana - Calculul paralel. Fundamente. Editura Microinformatica, Cluj,
1995
11. H.N. Teodorescu, M. Zbancioc, Oana Voroneanu – „Sisteme bazate pe cunoştinte.
Aplicaţii”. Editura Performantica, Iasi, ISBN-973-730-014-9, 2004
12. H.N. Teodorescu - Program Design (editia a-II-a), Pro-Copy, Tampa, USA, 2000
13. H.N. Teodorescu - Tehnici de programare avansată, Note de curs, UT Iasi, 2001
14. A.Brezulianu – Sisteme Fuzzy si Aplicatii, Ed. Tehnici si Tehnologii, Iasi, 2002
15. D. Cristea – Programarea bazata pe reguli (Rule-Based Programming), Romanian
Academy Publishing House, 2002, Bucharest, 216 pg.
16. D. Galea, Mihaela Costin, M. Zbancioc „Programarea în CLIPS prin exemple”,
Tehnopress Publishing House, 2001, ISBN 973-8048-45-1, pg.146
17. D. Galea, Mihaela Costin, M. Zbancioc „Aplicaţii de Inteligenţă Artificială în
CLIPS”, Tehnopress Publishing House, 2001, ISBN 973-8048-51-6. pg. 152
151