copiutzagigantica

8/19/2019 copiutzaGigantica

1/3

Cautarea BF

-----------

Strategia de cautare de tip BF extinde mai intai nodulradacina, apoi se extind toate nodurile generate de nodulradacina, apoi succesorii lor, si asa mai departe. Nodurileaflate la adancimea d in arbore sunt extinse inainteanodurilor aflate la adancimea d+1.Cautarea BF este un tip de cautare neinformata, adica nuse cunosc pasii sau costul drumului de la astarea curentala starea scop.In aceasta cautare se iau in considerare toate drumurile.Daca exista o solutie, este sigur ca va fi gasita, iar dacaexista mai multe, se va gasi intotdeauna solutia cea maiputin adanca.Pentru a programa in Prolog aceasta strategie estenevoie de o multime de noduri candidate, care vor formao multime de drumuri candidate. Aceasta multime va fireprezentata ca o lista de drmuri, iar in fiecare drum va fio lista de noduri inversa. Capul listei fiind nodul cel mairecent generat, iar ultimul element este nodul de unde s-a inceput cautarea.

Strategia BF este:-daca primul drum contine un nod-scop pe post de cap,atunci aceasta este o solutie a problemei.-altfel, inlatura primul drum din multimea de candidati, sigenereaza toate extensiile de un pas ale acestui drum,care se adauga la sfarsitul multimii pe care se va facecautarea BF.

Cautarea in adancime este o strategie in care sunt tratatetoate limitele de adancime posibile, adica adancimea l,apoi 1 etc.

Avantaje:-este optima si completa-consuma putina memorie

Anumite noduri sunt extinse de mai multe ore, insanumarul total de noduri extinse nu este mult mai maredecat cel dintr-o cautare BF.Complexitatea de timp O(b^d)Complexitatea de spatiu(b*d)

Implementare prolog:membru(H, [H|T]).

membru(X, [H|T]):- membru(X, T).cale(Nod, Nod, [Nod]).ca le (PrimNod, Ult imNod, [Ult imulNod|Drum]): -cale(PrimNod, PenultimNod, Drum), s(PenultimNod,UltimNod), \+(membru(UltimNod, Drum)).dfid(Nod_sol):-cale(Nod, NodScop, Sol), scop(NodScop),!.

Predicatul cale este adevarat daca Drum reprezinta ocale aciclica intre nodurile Nod1 si Nod2 in spatiulstarilor. De la nodul de start sunt generate toatedrumurile aciclice prosibile de lungime care creste cucate o unitate, pana cand este ferit Nod-scop. Solutia vafi in ordinea inversa a parcurgerii drumului.

Dezavantaj: recalcularea unor drumuri, care sunt extinsela o noua adancime.

Codul in prolog:rezolva_b(Start, Sol):- breathFirst([[Start]], Sol).breadthfirst([[Nod|Drum]|_], [Nod|Drum]):-scop(Nod).breadthfirst([Drum|Drumuri], Sol):- extinde(Drum,DrumuriNoi), concat(Drumuri, DrumuriNoi, Drumuri1),breadthfirst(Drumuri1, Sol).extinde([Nod|Drum], DrumuriNoi):-bagof([NodNou, Nod|Drum], s(Nod, NodNou), +\(membru(NodNou, [Nod|Drum])), DrumuriNoi), !.extinde(_,[]).concat([], L, L).concat([H|T], L, [H|T1]):-concat(T, L, T1).

membru(H, [H|T]).membru(X, [H|T]):- membru(X,T).

Predicatul rezolva)b este adevarat daca SOl este undrum de la nodul initial la o stare-scop, in oridine inversa,drum obtinut prin BF.Predicatul breadthfirst este adevarat daca un drum dinmultimea de drumuri candidate Drumuri poate fi extins lao stare scop, devenind Sol.Predicatul extinde este adevarat daca prin extindereamultimii de noduri Drum, obtinem multimea numitaDrumuriNoi, el generand multimea tuturor extensiiloracestui drum.Predicatul concat este adevarat daca atunci candconcatenam lista de noduri Drumuri cu lista de noduriDrumuriNoi se obtine Drumuri1.Predicatul membru este adevarat dca nodul numitNodNou apartine listei de noduri [Nod|Drum].Faptul scop(Nod) arata ca Nod este Nod-scop.

Prin s(Nod, NodNou) se realizeaza funcia de succesiunesi desemneaza faptul ca NodNou este nodul succesor allui Nod.In fiecare stare poate fi extinsa pentru a genera b starinoi. Factorul de ramificare este b. Numarul maxim deextensie inaintea gasirii solutiei:1+b+b^2+...+b^d unde d este lungimea drumului pana lastarea scop.=>complexitate de timp: O(b^d)=>complexitate spatiu: este aceeasi cu complexitatea

timpului.

Cautarea de tip DF

------------------

Strategia de cautare de tip DF extinde intotdeauna unuldintre nodurile alfate la nivelul cel mai adanc din arbore.Cautarea si extinderea altor noduri se face numai dacase zareste un nod care nu mai poate fi extins si nu estenod scop.Este necesar sa se mentioneze un singur drum de laradacina la un nod-drunza, impreuna cu nodurile-frateneextinseComplexitatea in spatiu este b*m cu factor de ramificareb si adancime maxima m.Complexitatea de timp este o(b^m), si este acelasi sipentru cazul cel mai nefavorabil. Aceasta cautare estemai rapida decat BF deoarece sunt sanse mai mari sa fiegasita o solutie dupa ce exploreaza numai o micaportiune a arborelui.Dezavantajele sunt:-poate intra intr-un ciclu infinit fara a returna vreodata osolutie.-poate gasi un drum reprezentand o solutie, dar nu esteoptim.

Avantajele sunt:-consumul redus de momorie.-posibilitatea gasirii unei solutii fara a traversa o mareparte din arbore.Strategia DF este:-daca N este un nod-scop atunci sol=[N] sau-daca exista un nod succesor, N1 al lui N, astfel incat saexiste un drum, Sol1, de la N1 la un nod-scop, atuncisol-[N/Sol1].

Forma drumurilor este cea fireasca, de la nodul de startla nodul scop.Varianta imbunatatita a acestui algoritm este adaugareade detectare a ciclurilor. Se va folosi argumentul Drumpentr a impiedica algoritmul sa ia in considerare aceisuccesori ai lui Nod care au fost deja intalniti, adica sadetecteze cicluri.

Implementare Prolog a DF imbunatatit:rezolva1_d(N, Sol):- depthfisrt([], N, Sol).depthfirst(Drum, Nol, [Nod|Drum]):- scop(Nod).depthfirst(Drum, Nod, Sol):- s(Nod, Nod1), +\ (membru(Nod1, Drum)).

membru(H, [H|T]).membru(X, [H|T]):- membru(X, T).

In predicatul depthfirst, Nod este starea de pornire, Drumo lista de noduri, intre nodul start si Nod, iar solutie esteDrum extins prin Nod. Acest predicat este adevaratdaca, extinzand calea Drum via Nod, se ajunge la unnod-scop.Predicatul +\membru() verifica daca anumite noduri au,fost deja vizitate, pentru a nu se realiza cicluri.Predicatul rezolva1_d(N, Sol) este adevarat daca Sol esteun drum de la nodul de start N la nodul scop, in ordineinversa, obtinut prin DF.

Cautarea in adancime iterativa

prezentare generala si implementare in PrologCautarea in adancime iterativa este o strategie care evitachestiunea stabilirii unei adancimi optime la care trebuiecautata solutia, prin testarea tuturor limitelor deadancime posibile- mai intai adancimea 0, apoi 1, apoi 2samd. Acest tip de cautare combina beneficiile cautariiBF si DF, dupa cum urmeaza-este optima si completa ca si cautarea BF-consuma numai cantitatea mica de memorie necesaracautarii DFOrdinea extinderii starilor este similara cu cea de lacautarea de timp BF, numai ca anumite stari sunt extinsede mai multe ori.

Aceasta strategie garanteaza gasirea nodului scop de laadancimea minima, daca un scop poate fi gasit.Desi anumite noduri sunt extinse de mai multe ori, nr.total de noduri extinse nu este mult mai mare decat celdintr-o cautare de tip BF.Pentru a calcula numarul nodurilor extinse de cautarea inadancime iterativa, avem nevoie de nr. nodurilor extinsede o cautare de tip DF completa pana la nivelul j, este:Ndf = b^(j+1)-1/b-1

Pentru implementarea in prolog a cautarii in adancimeiterative vom folosi predicatul care, de forma:cale(Nod1,Nod2, Drum). care este adevarat daca Drum repr o caleaciclica intre nodurile Nod1 si Nod2 in spatiul starilor.

Aceasta cale va fi reprezentata ca o lista de noduri datein ordine inversa. Corespunzator nodului de start dat,predicatul cale, genereaza toate drumurile aciclicepesobile de lungime care creste cu cate o unitate.Drumurile sunt generate pana cand se genereaza o calecare se termina cu un nod-scop.

cale(Nod,Nod,[Nod]).cale(PrimNod, UltimNod, [UltimNod|Drum]):-cale(PrimNod, PenultimNod, Drum), s(PenultimNod,UltimNod), \+(membru(UltimNod, Drum)).depth_first_iterative_deepeing(Nod, Sol):- cale(Nod,NodScop, Sol), scop(NodScop), !.

Algoritmul A*

1.Creeaza un graf de cautare G, constand numai dinnodul initial n(indice)0 .Plaseaza n0 intr-o lista numitaOPEN.2.Creeaza o lista numita CLOSED,care initial este vida.3.Daca lista OPEN este vida, EXIT cu esec.4.Selecteaa primul nod din lista OPEN, inlatura-l dinOPEN siplaseaza-l in lista CLOSED,Numeste acest nodn.5.Daca n este un nod-scop,opreste executia cu succes.Returneaza solutia obtinuta urmand un drum de-a lungulpointerilor de la n la n0 in G.(Pointerii definesc un arborede cautare si sunt stabiliti la pasul 7).6.Extinde nodul n,generand o multime, M, de succesoriai lui care nu sunt deja stramosi ai lui n in G.Instaleazaacesti membrii ai lui M ca succesori ai lui n in G.7.Stabileste un pointer catre n de la fiecare dintremembrii lui M care nu se gaseau deja in G (adica nu seaflau deja nici in OPEN, nici in CLOSED). Adauga acestimembrii ai lui M listei OPEN.Pentru fiecare membru, m, ai lui M, care se afla deja inOPEN sau in CLOSED, redirectioneaza pointerul saucatre n, daca cel mai bun drum la m gasit pana in acelmoment trece prin n.Pentru fiecare membru al lui M carese afla deja in lista CLOSED,redirectioneaza pointerii fiecaruia dintre descendentii saiin G astfel incat acestia sa tinteasca inapoi dea lungulcelor mai bune drumuri pana la acesti descendenti,gasite pana in acel moment.8.Reordoneaza lista OPEN in ordinea valorilorcrescatoare ale functiei f-caciula(f cu ^deasupra).Eventualele legaturi intre valori minimale ale luif-caciula sunt rezolvate in favoarea nodului din arborelede cautare aflat la cea mai mare adancime.9.Mergi la pasul 3.

Admisibilitatea Algoritmu lui A*

Exista anumite conditii asupra grafului si a lui h-caciulacare garanteaza ca algoritmul A*, aplica acestor grafuri,

gaseste intotdeauna drumuri de cost minim.Conditiileasupra grafului sunt:1.Orice nod al grafului, daca admite succesori, are unnumar finit de succesori.2.Toate arcele din graf au costuri mai mari decat ocantitate pozitiva Epsilon

Conditia asupra lui h-caciula este:3.Pentru toate nodurile n din graful de cautare,h-caciula(n)f*# Presupunem ca A* selecteaza din

coada,pentru extindere, pe G2.Intrucat G2 este o stare-scop,aceasta alegere ar incheia cautarea cu o solutiesuboptimala.Vom arata ca acest lucru nu este posibil.# Fie un nod n,care este, la pasulcurent, un nod frunza pe un drum optim la G.(unasemenea nod trebuia sa existe, in cazul in care drumul afost complet extins, caz in care algoritmul ar fi returnatG).Pentru acest nod n, intrucat h este admisibila,trebuiesa avem# #

# f*>=f(n) (1)# Mai mult, daca n nu este ales pentruextindere in favoarea lui G2,trebuie sa avem:# #

# f(n)>=f(G2) (2)# Combinand (1) cu (2) obtinem:# #

# f*>=f(G2) (3)# Dar, deoarece G2 este o stare-scop,avem h(G2)=0.Prin urmare,# #

# f(G2)=g(G2) (4)# Cu presupunerile facute,conform (3)si (4) am aratat ca# #

# f*>=g(G2) Aceasta concluzie contrazice faptul ca G2 estesuboptimal,Ea arata ca A* nu selecteaza niciodata pentruextindere un scop suboptimal. A* intoarce o solutienumai dupa ce a selectat-o pentru extindere, de aici

rezultand faptul ca A* este un algoritm optim.


2/3

Implementarea in Prolog a cautarii de tip best-first

Predicatul bestfirst(Nod_initial, solutie) este adevaratdaca solutie este drum (obtinur folosind strategia best-first) de la nodul Nod_initial la o stare_scop.

bestfirst(Nod_initial, solutie) :-expandeaza([],l(Nod_initial, 0/0), 9999999, _, da, solutie)

.expandeaza(Drum, l(N,_), _, _, da, [N|Drum]) :- scop(N) .

Caz 1: daca N este nod_scop, atunci construimcale_solutie-----------------------------------------------------------

expandeaza(Drum,l(N,F/G), Limita, Arb1, Rez, Sol) :-F =< Limita,(bagof (M/C, (s(N, M, C), \+(membru(M, Drum))),

Succ), !, listasucc(G,Succ, As), cea_mai_buna_f(As, F1),expandeaza(Drum, t(N, F1/G,As) Limita, Arb1, Rez, Sol);Rez=imposibil) .

Caz 2: daca N este nod_frunza a carui f-valoare este maimica decat Limita, atunci ii generez succesori si iiexpandez in limita Limita.----------------------------------------------------------------------------------------------------------------------------------------

expandeaza(Drum, t(N,F/G,[A/As])Limita, Arb1, Rez,Sol) :-F=< Limita, cea_mai_buna_f(As, BF), min(Limita, Bf,

Limita1), expandeaza([N|Drum], A, Limita1, A1, Rez1,Sol), continua(Drum, t(N,F/G, [A1/As]), Limita, Arb1,Rez1, Rez, Sol) .

Caz 3: Daca arborele de radacina N are subarbori nevizisi f^ - valoarea este mai mica decat Limita, atunciexpandam cel mai "promitator" subarbore sau, in functiede rezultatul obtinut, Rez, vom decide cum vom continuacautarea cu ajutorul predicatului continua:------expandeaza(_, t(_, _, []), _, _, imposibil, _) :- ! .

Caz 4: nu se obtin solutii------

expandeaza(_, Arb, Limita, Arb, nu, _) :- f(Arb, F), F >Limita .

Caz 5: In cazul unot f^ -valori ami mari dcatt Bound, Arborele nu mai poate fi extins

continua(_, _, _, _, da, da, Sol) .continua(P, t(F/G, [A1|As]), Limita, Arb1, nu, Rez, Sol) :-insereaza(A1, As, NAs), cea_mai_buna_f(NAs, F1),expandeaza(P, t(N, F1/F, NAs), Limita, Arb1, Rez, Sol) .continua(P, t(N, F/G,[_|As]), Limita, Arb1, imposibil, Rez,Sol) :- cea_mai_buna_f(As, F1),expandeaza(P, t(N,F1/G, As), Limita, Arb1, Rez, Sol) .listasucc(_, [], []) .listasucc(GO, [N/C[Ncs],Ts]) :-G is Go+c,h(N, H),F is G+H,listasucc(G0, Ncs, Ts1) .inserea(l, (N, F/G), Ts1, Ts) .

Algoritmul MinMax.

Textul algoritmului:1. Genereaza intregul arbore de joc, pana la starileterminale.2. Aplica functia de utilitate fiecarei stari terminale pentrua obtine valoarea corespunzatoare.3. Deplaseaza-te inapoi in arbore, de la nodurile frunzaspre nodurile starii radacina, determinand corespunzatorfiecarui nivel al arborelui valorile care reprezinta utilitateanodurilor afltae la acel nivel. Propagarea acestor valori laniveluri anterioare se face prin intermediul nodurilorparinte succesive, conform urmatoarelor reguli:$ daca starea-parinte este un nod de tip MAX, atribuim

maximul dinte valorile avute de fii sai$ daca starea-parinte este un nod de tip MIN, atribuim

minimul dintre valorile avute de fii sai4. dicizia minmax

Ajuns in nodul-radacina, alege petru MAX acea mutarecare conduce la valoarea maxima.

Algoritmul minmax este conceput pentru a determinastrategia optima corespunzatoare lui MAX si in acest felpentru a decide care este cea mai buna miscare.Vom considera cazul general al uni joc cu doi jucatori, pecare ii vom numii MAX si MIN. MAX va face primamutare, dupa care jucatorii for efectua mutari pe randpana cand jocul ia sfarsit. La finalul jocurlui vor fiacordate puncte jucatorului castigator (sau vor fiacordate anumite penalizari ceui care a pierdut)

Exemplu de arbore cu valori minime:4 mutarea lui max

/ \ 4 2 mutarea lui min

/\ / \ 4 7 2 1 mutarea lui max

/\ /\ /\ /\ 2 4 5 7 2 1 1 1 valori statice

Max trebuie sa gaseasca intotdeauna o strategie care saduca la o stare finala cstigatare indiferent de actiunea luimin

Aceasta strategie include mutarea curenta a lui Maxcorespunzatoare fiecarei mutari posibile a lui Min

Algoritmul reprezinta o cautare de tip deapth-first

Implementarea in Prolog:Un program Prolog care calculeaza val minmax a unuinod intern dat va avea relatie principala peminmax(Poz,SuccBun,Val) unde:$ Val - este valoarea minmax a unei pozitii Poz$ SuccBun - este cea mai buna pozitie succesor a lui

Poz

minmax(Poz,SuccBun,Val) :-%mutarile legate de la Poz produc ListaPozmutari(Poz,ListaPoz), !,celmaibun(ListaPoz,SuccBun,Val);%poz nu are succesor si este evaluat in mod staticstaticval(Poz,Val) .

celmaibun([Poz],Poz,Val) :-minmax(Poz, -, Val), !.

celmaibun([Poz1|ListaPoz], Pozun, ValBuna) :-minmax(Poz1, -, Val1),celmaibun(ListaPoz,Poz2, Val2),maibine(Poz1, Val1, Poz2, Val2, PozBun, ValBuna) .

%Poz0 mai buna decat Poz1maibine(Poz0, Val0, Poza1, Val1, Poz0, Val0) :-%Min face o mutare pe Poz0%Max prefera valoarea maximamutare_min(Poz0),

val0 > val1,!;%Max face o mutare la Poz0%Min prefera valoarea mai mica

mutare_max(Poz0),val0 < val1, !.%Astfel Poz1 este mai buna decat Poz1maibine(Poz0, Val0, Poz1, Val1, Poz1, Val1) .

Alpha-Beta

Aceasta tehnica aplicata algoritmului Minmax, vaintoarce aceleasi rezultare, dar intr-un timp mult maiscurt, deoarece acesta taie anumite ramuri care nu potinfluenta decizia finala.

Algoritmul consta in a considera un nod oarecare n,astfel incat jucatorul poate ajunge sa faca o mutare lael.Daca un jucator poate face o alegere mai buna,m, fiela nivelul lui n fie in orice alt punct in arbore aflat mai sus,nodul n nu va fi atins niciodata si va fi inlaturat.Deasemenea, se folosesc doua limite:alpha si beta.

Alpha este valoarea minima pe care este deja garantat cao va obtine Max, iar beta este valoarea maxima pe careMax poate spera sa o atinga.Pentru Min,beta estevaloarea nefavorabila.Deci, valoarea efectiva va fi intrealpha si beta.Alpha este scorul pe care il poate obtineMax, presupunand ca Min joaca perfect.Cautarea se opreste atunci cand: dedesubtul oricaruinod de tip Min care are o valoare beta mai mica sauegala cu valoarea alpha a oricarui dintre stramosii sai detip Max sau cand dedesubtul oricarui nod de tip Maxcare are o valoare alpha mai mare sau egala cu valoareabeta a oricaruia dintre stramosii sai de tip Min.#

Exemplu: vezi Poza_1.png#

Alpha-Beta Implementare Prolog

Predicatul principal:alphabeta(Poz,Alpha,Beta,PozBuna,Val)

unde PozBuna reprezinta un succesor "suficient de bun"al lui Poz,astfel incat valoarea sa, Val, satisface cerintele:# Val=V(Poz,Alpha,Beta)

Proceduralimitarebuna(ListaPoz,Alpha,Beta,PozBuna,Val)gaseste in lista ListaPoz, o pozitie suficient de buna,PozBuna, astfel incat valoarea de tip minmax, Val, a luiPozBuna,reprezinta o aproximatie suficient de bunarelativ la Alpha si Beta.# Intervalul alpha-beta se poateingusta (dar niciodata largi) in timpul apelarilorrecursive,de la o mai mare adancime, ale procedurii.#

Relatia limitenoi(Alpha,Beta,Poz,Val,AlphaNou,BetaNou)defineste noul interval [AlphaNou,BetaNou].Acesta esteintotdeauna mai ingust sau cel mult egal cu vechiulinterval [Alpha,Beta].Ingustarea intervalului conduce laoperatii suplimentare de retezare a arborelui.

Algoritmul Alpha-Beta:

alphabeta(Poz,Alpha,Beta,PozBuna,Val):-# mutari(Poz,ListaPoz),!,#

limitarebuna(ListaPoz,Alpha,Beta,PozBuna,Val);# %valoare statica a lui Poz# staticval(Poz,Val).

limitarebuna([Poz|ListaPoz],Alpha,Beta,PozBuna,ValBuna):-# alphabeta(Poz,Alpha,Beta,_,Val),#

destuldebun(ListaPoz,Alpha,Beta,Poz,Val,PozBuna,ValBuna).%nu exista alt candidatdestuldebun([],_,_,Poz,Val,Poz,Val):-!.destuldebun(_,Alpha,Beta,Poz,Val,Poz,Val):-# %atingere limita superioara# mutare_min(Poz),Val>Beta,!;# %atingere limita inferioara# mutare_max(Poz),Val Alpha,!.limitenoi(Alpha,Beta,Poz,Val,Alpha,Val):-# %descrestere limita superioara# mutare_max(Poz),Val < Beta,!.%altfel,limitele nu se schimbalimitenoi(Alpha,Beta,_,_,Alpha,Beta).

%Poz mai buna ca Poz1maibine(Poz,Val,Poz1,Val1,Poz,Val):-# mutare_min(Poz),Val > Val1,!;# mutare_max(Poz),Val < Val1,!.%altfel,Poz1 mai buna

Reprezentatrea cunostintelor cu reguli if-then.

Interpretor pt reguli in cazul inlantuirii

inainte( implementarea in Prolog)

Regulile de tip if-then, numite si reguli de productie,constituie o forma naturala de exprimare a cunostintelorsi au urmatoarele caracteristici suplimentare :-MODULARITATE, fiecare regula defineste o cantitate decunostinte relativ mica si independenta de celelalte.-INCREMENTABILITATE, noi reguli pot fi adaugate bazeide cunostinte in mod relativ independent de celelaltereguli.-MODIFICABILITATE(ca o consecinta a modularitatii)regulile vechi pot fi modificate relativ independent decelelalte reguli.-sustin TRANSPARENTA sistemului.

Regulile de tip if-then adesea definesc relatii logice intreconceptele apartinand domeniului problemei. Relatiilepur logice pot fi caracterizate ca apartinand cunostintelorcategorice.if conditie A then concluzie B cu certitudinea Fex: if hol ud si bucatarie uscat then scurgere in baie.

Inlantuirea inainte ("forward chaining")- nu incepe cu o ipoteza; face un rationament de lapartea cu if la partea cu then ( in directia opusa)reguli: if Conditie then Concluzie

Implementare Prolog :

inainte:-fapta_noua_dedusa(P), % o noua fapta!,write(Dedus:),write(P),nl,assert(fapta (P)),inainte %continua;write(Nu mai exista fapte). %Toate faptele au fostdeduse

fapta_noua_dedusa(Concl):-if Cond then Concl, %o regulanot fapta(Concl), %Concluzia regulii nu este inca o faptafapta_compusa(Cond). %Conditia este adevarata?

fapta_compusa(Cond):- %fapta simplafapta(Cond).fapta_compusa(Cond1 and Cond2):-fapta_compusa(Cond1), fapta_compusa(Cond2).%Ambii conjunctisunt adevarati

fapta_compusa(Cond1 or Cond2):-fapta_compusa(Cond1);fapta_compusa(Cond2).

Inlantuirea inainte presupune cautare de la date insprescopuri, fiind orientata catre date.


3/3

Reprezentatrea cunostintelor cu reguli if-then.

Interpretor pt reguli in cazul inlantuirii

inapoi( implementarea in Prolog)

Regulile de tip if-then, numite si reguli de productie,constituie o forma naturala de exprimare a cunostintelorsi au urmatoarele caracteristici suplimentare :-MODULARITATE, fiecare regula defineste o cantitate de

cunostinte relativ mica si independenta de celelalte.-INCREMENTABILITATE, noi reguli pot fi adaugate bazei

de cunostinte in mod relativ independent de celelaltereguli.-MODIFICABILITATE(ca o consecinta a modularitatii)

regulile vechi pot fi modificate relativ independent decelelalte reguli.-sustin TRANSPARENTA sistemului.

Regulile de tip if-then adesea definesc relatii logice intreconceptele apartinand domeniului problemei. Relatiilepur logice pot fi caracterizate ca apartinand cunostintelorcategorice.if conditie A then concluzie B cu certitudinea Fex: if hol ud si bucatarie uscat then scurgere in baie.

Inlantuirea inapoi ("backword chaining")- pleaca de la o ipoteza; parcurge in sensul "inapoi"reteaua de inferenta.


:- op(800,fx,if).:- op(700,xfx,then).:- op(300,xfy,or).:- op(200,xfy,and).

este_adevarat(P):-fapta(P).

este_adevarat(P):-

if Conditie then P,este_adevarat(Conditie).

este_adevarat(P1 and P2):-este_adevarat(P1),este_adevarat(P2).

este_adevarat(P1 or P2):-este_adevarat(P1);este_adevarat(P2).

Se observa ca acest interpretor pentru reguli if-then detip nlantuire napoi continua sa lucreze napoi n manieradepth-first.

Un dezavantaj al acestei implementari este acela ca bazade cunostinte nu se poate distinge de restul programului

Generarea explicatiilor si introducerea incertitudinii in

sistemele expert

Generarea explicatiilor : Una dintre caracteristicileregulilor de productie care fac din acestea o modalitatenaturala de exprimare a cunostintelor in cadrul sistemelorexpert este faptul ca ele sustin transparenta sistemului.Prin transparenta sistemului se intelege abilitateaacestuia de a explica deciziile si solutiile sale. Regulile deproductie faciliteaza generarea raspunsurilor pentruurmatoarele doua tipuri de intrebari: cum? si de ce? Arborele de demonstratii al unei propozitii "cum?" ( Dem1 or Dem2.

Implementare in Prolog :

%este_adevarat(P,Dem) daca Dem constituie o%demonstratie a faptului ca P este adevarat

:-op(800,xfx, c(P2)=c(P1)*c


% certitudine (Propozitie, Certitudine)certutudine(P,Cert):-dat(P,Cert).certitudine(Cond1 and Cond2, Cert):-certitudine(Cond1,Cert1),certitudine(Cond2,Cert2),minimum(Cert1,Cert2,Cert).

certitudine(Cond1 or Cond2, Cert):-certitudine(Cond1,Cert1),certitudine(Cond2,Cert2),maximum(Cert1,Cert2,Cert).

certitudine(P,Cert):-if Cond then P:C1,certitudine(Cond,C2),Cert is C1*C2.

Influenta in retele Bayesiene.

Sarcina principal a oricarui system probabilist de

inferenta este aceea de a calcula probabilitati a

posteriorii de tipul P(Interogare|Dovezi) corespunzator

unei multimi de variabile de interogare coditionat de

valori exacte ale unor variabile dovezi.

Retelele Bayesiene sunt su%cient de flexibile pentru ca

orice nod sa poata servi fie ca o variabila de interogare,

fie ca o variabila dovada. In general, un agent primeste

valori are variabilelor dovezi de la senzorii sai ( sau in

urma altor rationamente) si intreaba despre posibilele

valori ale altor variabile a.i. sa poata decide ce actiune

trebuie intreprinsa.

Exista 4 tipuri de inferenta realizate de retelele

Bayesiene:

- Inferenta de tip diagnostic ( de la efecte la

cauze);

- Inferenta cauzala (de la cauze la efect);

- Inferenta intercauzala ( intre cauze ale unui

efect comun)

- Inferenta mixta (combinatia a doua sau mai

multe dintre inferentele anterioare).

Retelele Bayesiene s-au dovedit extreme de

folositoare in realizarea mai multor tipuri de sarcini.

copiutzagigantica

Documents