Univerzitet u Novom Sadu

Fakultet tehničkih nauka
Odsek za elektrotehniku i računarstvo
Institut za računarstvo i automatiku









Zora Konjović, Đorđe Obradović

Zbirka zadataka iz predmeta
Računarska inteligencija










Novi Sad, mart 2003


Sadržaj
1. UVOD................................................................................................................3
2. REPREZENTACIJA ZNANJA......................................................................5
2.1. PREDIKATSKA LOGIKA...............................................................................5
2.1.1. Teorijska osnova...............................................................................5
2.1.2. Softwerske tehnike ............................................................................5
2.1.3. Primeri i zadaci za vežbu ...............................................................12
2.2. NEURONSKE MREŽE .................................................................................23
2.2.1. Opšti model neuralnih mreža .........................................................23
2.2.2. Klasifikacija neuronskih mreža ......................................................28
2.2.3. Algoritmi za obučavanje neuronskih mreža ...................................29
2.3. FUZZY LOGIKA.........................................................................................45
2.3.1. Fuzzy skupovi .................................................................................45
2.3.2. Reprezentacija znanja primenom fuzzy skupova ............................47
2.3.3. Zaključivanje u fuzzy logici ............................................................47
2.3.4. Rešavanje problema primenom fuzzy logike...................................48
3. TEHNIKE RASUĐIVANJA.........................................................................55
3.1. PRETRAŽIVANJE.......................................................................................55
3.1.1. Enumerativni algoritmi i optimizacioni algoritmi ..........................57
3.1.2. Genetski algoritmi ..........................................................................75
3.2. DEDUKCIJA ..............................................................................................75
3.2.1. Izračunavanje odgovora u predikatskoj logici ...............................75
4. INTELIGENTNI AGENTI ...........................................................................85
4.1. ROBOCODE...............................................................................................87
4.1.1. Osnovni delovi ROBOCODE okruženja.........................................87
4.1.2. Robocode API.................................................................................89
5. LITERATURA...............................................................................................97



Predgovor



I
Uvod
1. Uvod
Redosled:
(22) Predikatska logika
uvod
sintaksa
lista
stablo
graf
majmun i banana
izračunavanje odgovora u Predikatskoj logici
(stablo pretraživanja)
(12) Pretrage
uvod
prvi u dubinu, prvi u širinu
iterativni prvi u širinu, bidirekciona pretraga
A*
primeri:
slagalica, lavirint, skakač, majmun i banana
(6) Genetski algoritmi
uvod
primer:
određivanja minimuma funkcije
određivanje maksimuma funkcije
(10) Neuronske mreže
uvod
najprostiji oblik (pseudo kompetitivno obučavanje)
generalisano delta pravilo
primeri: prepoznavanje slova, 7 segmentni displej,
funkcija, crna kutija, automat prelaza stanja
(6) Fuzzy logika
uvod
inverzno klatno
fuzzy pretraživanje


3

Reprezentacija znanja
2. Reprezentacija znanja
2.1. Predikatska logika
2.1.1. Teorijska osnova

2.1.2. Softwerske tehnike
PROLOG (PROgraming in LOGic) je programski jezik kojim je moguće
opisati i rešiti određen problem na način opisan predikatskom
logikom.
Baza znanja je osnova za izvođenje zaključaka i sastoji se od
činjenica i pravila koji predstavljaju strukturu u kojoj figurišu
relacije. Na primer baza znanja o porodičnim vezama grafički
predstavljena na slici 2.1.

Slika 2.1 Primer rodbinskih veza
programski se opisuje na sledeći način:
otac(ivan, toma).
otac(toma, petar).
otac(petar, marko).
otac(petar, jasna).
5

Reprezentacija znanja
majka(mara, toma).
majka(nina, marko).
majka(nina, jasna).
Program 2.1 Roditeljske veze
Prethodno opisan primer predstavlja reprezentaciju znanja u obliku
skupa činjenica. Činjenice su gradivni elementi svake baze znanja i
uvek predstavljaju tačan iskaz, opisuju se na sledeći način:
predikat(Arg1, Arg2, Arg3, ...)
Gde predikat predstavlja ime relacije koja povezuje objekte Arg1,
Arg2, Arg3, .... Predikat može da ima proizvoljno mnogo
argumenata.
U programu 2.1 veza između objekata ivan i tome je otac i čita se:
«Ivan je otac Tomi». Pored konstanti a to su u ovom primeru ivan i
toma moguće je koristiti i promenljive. Na primer,
stariji(adam, X).
voli(X, X).
Program 2.2. Primer korišćenja promenljivih
U ovom primeru prvom činjenicom rečeno je da je adam stariji od
bilo koga a drugom da svako voli samog sebe.
Znači korišćenjem činjenica u mogućnosti smo da na jednostavan
način predstavimo znanje o posmatranom problemu. Naravno cilj
ovakve reprezentacije je da pored opisa posmatranog sistema
budemo u mogućnosti da izvodimo određene zaključke. Na primer,
«Ko je tomin otac?» ili «Od koga je stariji adam?».
Čovek pored skupa činjenica u zaključivanju barata i određenim
skupom pravila. Na primer, ako je ivan tomin otac, onda je toma
ivanovo dete, odnosno iz relacije otac može se «izvesti» relacija «dete»:
dete(X, Y):-otac(Y, X).
dete(X, Y):-majka(Y, X).
Program 2.3 Primer definisanja pravila
Drugim rečima pravilo predstavlja specijalnu relaciju koja povezuje
zaključak i pretpostavku. Na primer:
pravilo(zaključak, pretpostavka).
U PROLOG-u se zbog preglednijeg pisanja umesto uobičajenog
načina pisanja (kao relacija), pravila definišu na specijalan način:
6
Reprezentacija znanja
zaključak :- pretpostavka.
Pravila se interpretiraju tako što se proveri tačnost pretpostavke a
potom na osnovu nje izvodi se zaključak ili može da se kaže da ako je
tačna pretpostavka onda je tačan i zaključak.
U PROLOG-u se na ravnopravan način mogu koristi dva načina
zapisa infiksan i postfiksan.
Kod infiksnog načina zapisa (a) relacija se navodi između objekata.
Samim tim infiksan način moguće je koristiti samo u relacijama
između dva objekta. Postfiksnim načinom zapisa (b) prvo navodimo
relaciju pa potom objekte.
a) ivan otac toma.
b) otac(ivan, toma).
Infiksne relacije moraju se posebno navesti kako bi ih PROLOG
prevodilac mogao interpretirati.
Primerom 2.4definisano je pravilo roditelj koji kaže «X je Y-u roditelj
ako je X Y-u majka» pored ovoga takođe važi pravilo «X je Y-u roditelj
ako je X Y-u otac».
roditelj(X, Y):- majka(X, Y).
roditelj(X, Y):- otac(X, Y).
Program 2.4 Primer pravila
Drugim rečima ova dva pravila mogu da se opišu jednim koji kaže «X
je Y-u roditelj ako je X Y-u majka ili je X Y-u otac». U PROLOG-u se
to opisuje na sledeći način:
roditelj(X, Y):- majka(X, Y); otac(X, Y).
Program 2.5 Kombinacija više činjenica u jednom pravilu
U ovom iskazu ; predstavlja logički operator ILI. U slučaju da pravilo
u delu pretpostavke sadrži dve činjenice koje istovremeno moraju da
budu zadovoljene one se razdvajaju znakom , koji predstavlja logički
operator I. Na primer,
deda(X, Y) :- otac(X, Z), roditelj(Z, Y).
sestra(X, Y):- roditelj(O, X), majka(O, Y), pol(Y, z),
različiti(X, Y).
predak(X, Y):- roditelj(X, Y).
predak(X, Y):- roditelj(X, Z), roditelj(Z, Y).
7

Reprezentacija znanja
predak(X, Y):- roditelj(X,Z),roditelj(Z,W), roditelj(W,X).
Program 2.6 Logički operator I
U prethodnim primerima pokazana je situacija u kojoj definišemo
pravilo kombinacijom više drugih pravila. Takođe je moguće
definisati pravilo i rekurzivno:
predak(X, Y):-roditelj(X, Y).
predak(X, Y):-roditelj(X, Z), predak(Z, Y).
Program 2.7 Rekurzivna pravila
Ciljevi ili upiti su pored činjenica i pravila veoma važan deo
programskoj jezika PROLOG. Sam mehanizam za izračunavanje
odgovora biće obrađen u posebnom poglavlju. Postoje dve vrste upita:
upiti koji kao odgovor imaju «Ko?» ili «Šta?» i upiti koji odgovaraju na
pitanje «Da li?».
Ciljevi ili upiti postavljaju se u posebnom prozoru i to na sledeći
način:
?-elementi_upita.
Recimo pitanje «Ко је Markov otac?» u PROLOG-u bismo napisali:
?-otac(X, marko).
X=toma
ili pitanje «Da li je Toma Markov otac?» napisali bismo ovako:
?-otac(toma, marko).
Yes
Odgovor No u PROLOG-u se interpretira kao nemogućnost donošenja
pozitivnog zaključka. Odnosno, pomoću trenutne baze znanja
interpreter nije u mogućnosti da izvede pozitivan zaključak.
Kao odgovor na postavljano pitanje moguće je dobiti i više odgovora,
recimo na pitanje:
?-otac(X, _).
Dobićemo odgovor:
X=ivan ->;
X=toma ->;
X=petar ->;
No
Gde No znači «Nema više pozitivnih odgovora!».
8
Reprezentacija znanja
Sintaksa programskog jezika PROLOG
Na slici 2.2 prikazana je podela svih elemenata programskog jezika
PROLOG.

Slika 2.2 Podela osnovnih elemenata PROLOG-a
Atom je svaki niz simbola, cifara i «_» koji počinje malim slovom, ili je
to niz posebnih znakova ili je to bilo koji niz znakova koji se nalazi
unutar navodnika.
Brojevi su niz cifara koji počinje predznakom i ne razlikuju se
posebno celi brojevi od realnih.
promenljive su neke veličine koje se tokom izvršavanja menjaju. One
se imenuju nizom znakova koji počinje velikim slovom ili specijalnim
znakom _. Specijalan slučaj je _ promenljiva koja predstavlja
takozvanu anonimnu promenljivu, odnosno vrednost ove promenljive
nam nije od interesa.
Struktura je složen term koji se formira vezivanjem nekoliko
jednostavnijih termova. Funktor je atom koji objedinjuje strukturu u
jedinstvenu celinu. Strukture se razlikuju po imenu i broju
argumenata.
Specijalan slučaj strukture je lista koja se zbog čestog korišćenja i
opisuje na poseban način. Pored listi veoma korisna struktura je
binarno stablo.
Liste
Lista je struktura koja je ili prazna ili se sastoji od glave i repa.
Prazna lista opisuje se na sledeći način: []. Glava i rep se u listi
odvajaju simbolom | ([g|[]]). U nastavku je dato nekoliko predikata
kojim se opisuju osnovne operacije sa listama. Vrlo često se lista
9

Reprezentacija znanja
prikazuje kao [a, b, 1, 2, c, d], gde je a glava liste, a lista [b, 1,
2, c, d] je rep liste.
a) Predikat kojim se proverava da li je neka struktura lista.
lista([]).
lista(G|R):-lista(R).
b) Predikat kojim se proverava da li se neki element nalazi u listi.
element(X, [X|_]).
element(X, [Y|R]):-element(X, R).

c) Spajanje dve liste
pripoji([], X, X).
pripoji([X|R], Y, [X|Z]):-pripoji(R, Y, Z).

d) Obrtanje liste
obrni([], []).
obrni([X|Xr], Y):-obrni(Xr, Yr), pripoji(Yr, [X], Y).

obrni1(L, OL):-obrni(L, [], OL).
obrni([], OL, OL).
obrni([G|R], S, OL):-obrni(R, [G|S], OL).

е) Brisanje elemenata iz liste. (Prvog u listi.)
brisi(X, [X|R], R).
brisi(X, [Y|R], [Y|R1]):-brisi(X, R, R1).
f) Dodavanje elementa u listu
ubaci(X, L, VL):-brisi(X, VL, L).
g) Permutacija elemenata liste i sortiranje
permutacija([], []).
permutacija([X|L], P):-permutacija(L, L1), ubaci(X, L1, P).

uredjena([X]).
uredjena([X, Y|R]):-X=<Y, uredjena([Y|R]).

sortiraj(L, SL):-permutacija(L, SL), uredjena(SL).
h) Podlista
10
Reprezentacija znanja
podlista(S, L):-pripoji(L1, S, L2), pripoji(L2, L3, L).

Binarno stablo
Binarno stablo je struktura koja je ili prazna ili ima glavu i dva
podstabla: levo i desno.
Binarno stablo prikazano na slici 2.4

Slika 2.5 Binarno stablo
u PROLOG-u se predstavlja na sledeći način:
st(a, st(b, st(d, p, p), st(e, p, p)), st(c, st(f, p, p), p)).
Sledi nekoliko najvažnijih predikata koji opisuju binarno stablo i
operacije nad njim.
a) Predikat kojim se proverava da li je struktura binarno stablo.
b_stablo(p).
b_stablo(st(X, L, D)):-b_stablo(L), b_stablo(D).
b) Predikat kojim se proverava da li se element nalazi u binarnom
stablu.
element(X, st(X, L, D)).
element(X, st(S, L, D)):-element(X, L); element(X, D).
Specijalan slučaj binarnog stabla je uređeno binarno stablo u kojem
su elementi u levom podstablu manji od glave a elementi u desnom
pod stablu su veći od glave.
c) Predikat kojim se proverava da li se element nalazi u uređenom
binarnom stablu.
11

Reprezentacija znanja
element(X, st(X, L, D)).
element(X, st(G, L, D)):-X<G, element(X, L).
element(X, st(G, L, D)):-X=>G, element(X, D).
d) Predikat kojim se dodaje element u uređeno binarno stablo
dodaj(X, p, st(X, p, p)).
dodaj(X, st(G, L, D), st(G, L1, D)):-X<G, dodaj(X, L, L1).
dodaj(X, st(G, L, D), st(G, L, D1)):-X=>G, dodaj(X, D, D1).
e) Predikat kojim se briše element iz binarnog stabla.
brisi(X, st(X, p, D), D).
brisi(X, st(X, L, D), st(Ym, L1, D)):-najveci(L, Ym, L1).
brisi(X, st(Y, L, D), st(Y, L1, D)):-X<Y, brisi(X, L, L1).
brisi(X, st(Y, L, D), st(Y, L, D1)):-X>Y, brisi(X, D, D1).

najveci(st(Ym, L, p), Ym, L).
najveci(st(Y, L, D), Ym, st(Y, L, D1)):-najveci(D, Ym, D1).
f) Predikat za konverziju liste u uređeno binarno stablo
lista_stablo([], p).
lista_stablo([G|R], S):-lista_stablo(R, S1), dodaj(G, S1, S).
g) Predikat za konverziju binarnog stabla u listu.
stablo_lista(p, []).
stablo_lista(st(G, L, D), Rez)):-stablo_lista(L, L1),
stablo_lista(D, D1),
pripoji(L1, [G|D1], Rez).
h) Sortiranje liste
sortiraj(L, SL):-lista_stablo(L, S), stablo_lista(S, Sl).
2.1.3. Primeri i zadaci za vežbu
Zadatak 1.
Kako bi se u predikatskoj logici prikazao sledeći niz rečenica?
Jasna je stara 15 godina. Ona stanuje u kući. Njezine prijateljice su
Milena i Marija. Jasnin otac zove se Marko a majka Katarina.
starost(jasna, 15).
stanuje(jasna, kuca).
prijateljica(jasna, milena).
prijateljica(jasna, marija).
otac(marko, jasna).
12
Reprezentacija znanja
majka(katarina, jasna).
Zadatak 2.
Napisati niz činjenica i pravila koji opisuju sledeću situaciju.
Radnik Marko rođen je 28.3.1970. godine i po zanimanju je stolar.
Milan je takođe radnik rođen 19.4.1945. godine i po zanimanju je
vozač. Pera je pobedio Miku u tenisu, a Milana u fudbalu. Marko je
izgubio od Gorana u pikadu. Pobednik je osoba koja je bilo koga
pobedila u bilo kojoj disciplini.
radnik(marko, rodjen(28, 3, 1970), stolar).
radnik(milan, rodjen(19, 4, 1945), vozač).
pobedio(pera, mika, tenis).
pobedio(pera, milan, fudbal).
izgubio(marko, goran, pikado).
pobedio(X, Y, Z):-izgubio(Y, X, Z).
pobednik(X):-pobedio(X, _, _).
Zadatak 3.
U programskom jeziku PROLOG definisati faktorijel.
faktorijel(0,1).
faktorijel(N, F):-N1 is N-1,
faktorijel(N1, F1),
F is N*F1.


Vežba 1. Upoznavanje sa SWI PROLOG interpreterom
1. SWI PROLOG interpreter se pokreće kao standardna windows
aplikacija.
2. Nakon pokretanja (plwin.exe) programa pred vama se pojavljuje
glavni prozor PROLOG interpretera.
13

Reprezentacija znanja

Neposredno iza znaka '?-' postavljaju se upiti.
3. Da bi se PROLOG program preveo u internu
formu i smestio u radnu bazu znanja, potrebno je
konsultovati sadržaj datoteke u kojoj se program
nalazi. Ova operacija se obavlja pozivanjem akcije
‘File->Consult...’. Nakon čega je neophodno pronaći
datoteku na način standardan Windows okruženju.

4. Novi program pišemo
tako što prvo izabiramo
opciju 'File->New...', i
nakon toga u internom
editoru unosimo činjenice
i pravila. Pored ovog
načina moguće je
program naisati i snimiti
bilo kojim standardnim
editorom tekstualnih
datoteka, u tom slučaju
datoteka se otvara
pozivanjem akcije ‘File-
>Edit...’. Interni editor pored standardnih operacija sa tekstualnim
datotekama omogućava:
- automatsku proveru sintaksne ispravnosti
- prikaz ključnih izraza u različitim bojama
14
Reprezentacija znanja
- osvežavanje interne memorije PROLOG interpretera (Ctrl+c Ctrl+b)
5. U slučaju da se program učitan u internoj memoriji menja bilo
internim editorom bilo klasičnim editorima neophodno je ponovno ga
učitati u radnu memoriju interpretera 'File Reload modified files'
6. Prvi program koji se unosi je model porodičnog
stabla.prikazan na slici 2.4.

Slika 2.4 Model porodičnog stabla
Po unošenju činjenica, snimite datoteku u svoj direktorijum,
ekstenzija datoteke bi trebala da bude .pl i osvežite internu
memoriju PROLOG interpretera (File->Consult.. ili ako ste koristili
interni editor Ctrl+c Ctrl+b).
7. Ako je sve u redu (program sintaksno ispravan i nalazi se u
internoj memoriji) u glavnom prozoru možete da počnete sa
unošenjem upita. Za probu, upitajte 'Ko je kome otac?' i 'Ko je kome
majka?'
8. Vratite se u editorski prozor otkucajte predikate za roditelje i
sestru. Snimite program i osvežite radnu memoriju interpretera.
Isprobajte kako rade predikati roditelj i sestra. Po ugledu na predikat
sestra napišite predikat koji proverava da li je osoba X brat osobi Y.
9. Napišite predikat predak1:
predak1(X, Y):- roditelj(X, Y).
predak1(X, Y):- roditelj(X, Z), predak1(Y, Y).
Na osnovu ovog predikata napišite predikate predak2 (u kojem je
zamenjen redosled prve i druge klauzule), predak3 (u kojem je
izmenjen redosled ciljeva u drugoj klauzuli) i predak4 (u kojem je
15

Reprezentacija znanja
izmenjen redosled i ciljeva i klauzula). Isprobajte ove predikate. Kako
se ponašaju?
11. Proširite porodično stablo tako da dobijete veze ujak, tetka,
brat od ujaka i sestra od strica. Dopunite pravila pravilima koji će
proveravati pomenute veze.
12. Snimite program!

Vežba 2. Rad sa listama
1. Napišite predikat koji proverava da li je data struktura lista.
2. Napišite predikat koji proverava da li se dati element nalazi u listi.
3. Napišite predikat koji spaja dve liste.
4. Proverite predikate koje ste napisali npr.
?- lista([a, s, d, f, g, h]).
ili
?-element(s, [a, s, d, f, g]).
5. Napišite predikate koji obrću listu i brišu element iz liste. Brisanje
elementa iz liste uraditi na oba načina, pomoću predikata pripoji i
bez njega.
6. Proverite korektnost napisanih predikata postavljanjem
odgovarajućih upita u glavnom prozoru.
7. Snimite program!
8. Napišite program za sortiranje brojeva pomoću permutacije i
sortiranje Quick sort algoritmom.
9. Proverite napisane programe.
10. Snimite program!

Vežba 3. Rad sa binarnim stablom
Pored osnovne složenije strukture podataka, liste, postoji i složenija
struktura binarno stablo. U nastavku je dat pregled osnovnih
operacija nad ovakvom strukturom.
1. Binarno stablo se (podsećanja radi) definiše ovako:
16
Reprezentacija znanja
a. Prazno binarno stablo je atom p
b. Binarno stablo je struktura koja se sastoji od:
Elementa, levog i desnog podstabla.
2. Na osnovu ove definicije napišite predikat (b_stablo(X)) koji
proverava da li promenljiva X ima strukturu binarnog stabla.
Koristite rekurziju.
3. X je element binarnog stabla ako je:
a. X isto što i Element u strukturi ili
b. X je element levog podstabla ili
c. X je element desnog podstabla
4. Napišite predikat (element_s(X, S) ) koji proverava da li je X
element binarnog stabla S.
5. Implementirajte predikate (uvrsti_s(X, S, D)) za dodavanje
elementa u binarno stablo koje je uređeno tako da se u levom
podstablu nalaze elementi koji su strogo manji od Element-a.
X je element koji se dodaje, S je stablo u koje se dodaje a D je
stablo koje se dobije kao rezultat.
6. Implementirajte predikate (brisi_s(X, S, D)) za brisanje
elementa X iz binarnog stabla S a da posle brisanja dobijeno
stablo D ostane uređeno.
7. Implementirajte predikat ( sortiraj(Lista, Rez) koji za
sortiranje koristi konverziju liste u uređeno binarno stablo i
konverziju iz stabla u listu.
8. Napišite predikat (listovi_s(X, S)) koji pronalazi elemente X
binarnog stabla S koji su listovi (nemaju ni desno ni levo
podstablo)
9. Napišite predikat (spoji_s(X, Y, Z)) koji spaja dva binarna
stabla X i Y tako da rezultujuće binarno stablo Z bude
uređeno.
10. Razmislite i pokušajte da opišete stablo sa proizvoljnim
brojem neposrednih potomaka. Kod binarnog stabla postoje
dva. Recimo, struktura direktorijuma kod file sistema
organizovana je kao neuređeno (ne postoji matematička
formula po kojoj raspoređujemo elemente u
17

Reprezentacija znanja
poddirektorijume(podstabla)). Ako vam je jasno kako bi
izgledala takva struktura pokušaje da napišete predikate za
proveravanje da li je data struktura stablo, proveravanje da li
se zadati element nalazi u stablu, dodavanje elementa u
odgovarajuće podstablo, brisanje elementa i brisanje čitavog
podstabla.

Vežba 6. Rad sa grafovima
Zadatak: Zadat je neorijentisan graf. Smestiti relevantne podatke o
grafu u bazu znanja PROLOG-a. Napisati predikat koji pronalazi i
ispisuje put između dve zadate tačke u grafu. Modifikovati podatke
za slučaj da prelazak iz jedne u drugu tačku u grafu ima neku cenu.
Za ovakve podatke, promeniti program tako da, uz pronalaženje
puta, sračunava i cenu puta između dve tačke.

a
b
c
d
f
g
e

a
b
c
d
f
g
e
4
1
2
2
1
1
2
4

Slika 2.5

Diskusija: Podatke o grafu smestiti u bazu podataka tako da
rešavanje sledećeg zadatka bude olakšano. Za zapisivanje podataka
možemo odabrati više različitih strategija. Možemo pohraniti podatke
o tačkama, granama ili oba podatka. Pošto kasniji zadatak zahteva
od nas da pronađemo put između dve tačke na grafu, mudro je da
zapišemo podatke o vezama između tačaka. Ova odluka nam
olakšava i kasniju modifikaciju – ubacivanje cena. Podatke, dakle,
možemo zapisati ovako:
veza(a,b).
što znači da postoji veza između tačaka a i b. Sledeći problem koji
treba razmotriti je činjenica da je graf neorijentisan, što znači da ako
18
Reprezentacija znanja
možemo da dođemo od tačke a do b, onda možemo i od tačke b do
tače a. Ovaj problem možemo rešiti tako što ćemo ubaciti dodatne
činjenice tipa:
veza(b,a).
Međutim elegantnije rešenje je da napišemo dodatni predikat koji
glasi ovako:
povezani(X, Y):-veza(X,Y);veza(Y,X).
predji1(Cilj, Cilj, Put, Put).
predji1(Start, Cilj, Put, Predjeno):-povezani(Start, X),
predji1(X, Cilj, Put, [X|Predjeno]).
Predikat koji poziva predji1 i omogućuje prikazivanje rezultata
izgleda ovako:
put(Start, Cilj, Put):-predji1(Start, Cilj, Put, [Start]).
Ako probate ovaj program na nekoliko primera, možete utvrditi da
program povremeno upada u beskonačnu petlju. Ova neugodnost se
može rešiti tako što ćemo, pre rekurzivnog poziva, proveriti da li smo
već prošli kroz tačkukoju smo pronašli predikatom povezani. Taj
podcilj glasi (predikat element napišite sami):
not element(X, Predjeno).
Na ovaj način možemo da pređemo sve puteve između dve zadate
tačke. Međutim, putevi koje pronalazi ovakav program obrnuti su u
odnosu na zadate tačke (tačke su poređane od ciljne do početne
tačke). Da bi se dobio put koji nije obrnut, moguće su dva rešenja.
Jedno podrazumeva ubacivanjepredikata obrni (koji obrće zatatu
listu) na pogodno mesto, a drugi je elegantnije i pokušajte da ga
pronađete. Ovako smo rešili prvi deo zadatka.

Drugi deo zadatka zahteva da proširite podatke o grafu cenama. To je
moguće postići ovakvim klauzulama:
veza(a,b,4).
Na osnovu ovog primera, modifikujte predikat povezani, i predikate
koji traže put između tačaka. Vodite računa o tome da je potrebno
zadati i novu promenjljivu ukojoj će biti smeštena cena puta između
dve tačke.
19

Reprezentacija znanja

Vežba 5 Diferenciranje matematičkih izraza
ZADATAK: Napisati predikate u programskom jeziku PROLOG, koji,
- Nalaze prvi izvod funkcije f(x)
- Nalaze diferencijal funkcije koja zavisi od jedne ili više
promenljivih po zadatoj promenljivoj.
DISKUSIJA: Diferenciranje matematičkih izraza je problem koji se
izuzetno lako rešava korišcenjem PROLOG-a, najviše zahvaljujuci
jakoj podršci simboličkoj obradi.
Prvi izvodi elementarnih matematičkih izraza lako se nalaze
korišcenjem tabele (to su tzv. tablični izvodi). U PROLOG-u ovakvu
tabelu možemo vrlo jednostavno implementirati . Na primer, izvod od
sin(g(x)) je g'(x)cos(g(x)). U PROLOGu se ova relacija može napisati
ovako:
izvod(sin(U), Du*cos(U)):-izvod (U, Du).
Vidimo da se radi o rekurzivnoj relaciji koja kao prvi argument prima
funkciju koju treba diferencirati, a kao drugi argument vraća prvi
izvod te funkcije. Kao što možete da primetite, odmah smo primenili
kombinaciju tabličnog izvoda i formule za nalaženje prvog izvoda
složene funkcie, i tako smo obezbedili da nam predikat automatski
radi sa složenim funkcijama. Takođe, valja primetiti da je klauzula
koju smo gore naveli tipičan primer leve rekurzije. Zato je potrebno
definisati i terminalni uslov. Postoje dva slučaja u kojima se direktno
nalazi prvi izvod. To su izvod od promenljive x na prvi stepen, koji je
1, i izvod konstante, koji je 0. Ekvivalenti ovih iskaza u PROLOGu
glase:
izvod(x, 1).
izvod(N, 0):-integer(N).
Da bi mogli da tražimo izvode polinoma potrebno je na odgovarajući
način definisati operaciju stepenovanja. Za operator stepenovanja
odabiramo simbol ^.
:-op(200, yfx, ^).
Izvod stepenovane promenljive tada izgleda ovako :
izvod(U^N, N*U^N1*Du):-integer(N), not N=0,
N1 is N-1, izvod(U, Du).
20
Reprezentacija znanja
Postoje još i formule za računanje izvoda zbira, razlike, proizvoda i
količnika funkcija. Klauzula za izvod zbira izgleda ovako:
izvod(U+V, Du+Dv):-izvod(U, Du), izvod(V, Dv).
Sami napišite klauzule koje nedostaju. Obratite pažnju na izvod
funkcije sa negativnim predznakom.
Sada napišite predikat koji, pored funkcije koju treba diferencirati i
promenljive u koju se smešta prvi izvod, prima i promenljivu po kojoj
treba diferencirati funkciju. dif(F, Fprim, Prom). Ovaj predikat
treba da funkciju više promenljivih izdiferencira po zadatoj
promenljivoj. Isprobajte predikat.
Sigurno ste primetili da je rezultat rada ovih predikata funkcija koja
jeste prvi izvod, ali data u obliku koji nije pogodan za ljudsko
korišcenje .
Vežba 6. 'Majmun i banana'
ZADATAK: Napisati program kojim se rešava problem 'Majmun i
banana'. Majmun treba da u prostoriji pronađe način kako da se
dočepa banane koja se nalazi okačena na
U prostoriji postoje stri mesta na kojima nesto moye da se nalazi:
vrata, sredina, prozor.
REŠENJE:Predikat treba da ima nekoliko logičkih celina u okviru
istog predikata.
Prva logička celina su klauzule koje opisuju terminalni uslov za
rekurziju. Ove klauzule treba da reaguju na sledeće situacije: pojavu
atoma u izrazu, pojavu računske operacije množenja nulom i
stepenovanja izraza nulom i na pojavu dva broja između kojih stoji
operator. Ovi slučajevi predstavljaju kraj jednog ciklusa
uprošcavanja. Primeri.
sr(A, A):-atomic(A), !. % Atomska vrednost
sr(A*0, 0):-!.
sr(A+B, C):-integer(A), integer(B), C is A+B, !.
Obratite pažnju na činjenicu da matematičke operacije koje su
komutativne, ne moraju biti komutativne kada uz pomoć PROLOGa
analizirate izraz.
Sledeća celina su klauzule koje deluju kada naiđemo na deo izraza u
kome postoji mogućnost uprošćavanja, ali je potrebno i dalje
21

Reprezentacija znanja
eventualno uprošćavanje. Neke od ovih situacija su množenje
jedinicom, sabiranje sa nulom, kao i stepenovanje jedinicom,
sabiranje sa nulom, kao i stepenovanje jedinicom.
sr(A+0, A1):-sr(A, A1).
sr(0-A, -A1):-sr(A, A1).
Treća grupa klauzula je tu da omogući dalju analizu i uprošćavanje
izraza. Ove klauzule deluju na delove izraza između kojih su
operatori. Primeri:
sr(A*B, A1*B1):-sr(A, A1), sr(B, B1).
sr(A+B, A1+B1):-sr(A, A1), sr(B, B1).
Program sastavljen po ovim uputstvima bi trebalo da bude u stanju
da uprosti neke specijalne slučajeve izraza. Međutim, posle nekoliko
testova, utvrdićete da program ne reaguje na neke prilično očigledne
situacije. Ovakvo ponašanje je uslovljeno načinom na koji PROLOG
formira stablo pretraživanja. Zato je potrebno ponoviti uprošćavanje
nekoliko puta. Ovu ideju možemo da realizujemo fiksnim brojem
poziva predikata sr. Drugi način je rekurzivno pozivanje predikata sr
sve dok ne dobijemo dva puta isti rezultat.
sredi(X, Y):-sr(X, Y1), X \=Y1, sredi(Y1, Y), !.
sredi(X, X):-sr(X, X), !.
Primetićete da ni ovako napisan program nije u stanju da uprosti sve
moguće izraze. Međutim, ovaj program se može iskoristiti kao osnova
za razvijanje komplikovanijih algoritama za uprošćavanje izraza.
22
Reprezentacija znanja
2.2. Neuronske mreže
2.2.1. Opšti model neuralnih mreža
Na slici XX prikazana je građa motornog neurona iz prednjeg roga
kičmene moždine. Neuron je osnovna strukturna i funkcionalna
jedinica živčanog tkiva. Pod pojmom veštačka neuronska mreža
podrazumevamo matematički, fizički ili računarski model strukture i
aktivnosti živčanih tkiva, odnosno mozga.
Neuronske mreže koriste se za istraživanje i reprodukovanje ljudskih
nervnih aktivnosti kao što su prepoznavanje i obrada govora i slike,
motorne aktivnosti, učenje, pamćenje itd.
Širok je spektar problema koji se rešavaju korišćenjem neuronskih
mreža (na primer, kombinatorna optimizacija, prepoznavanje oblika,
asocijativne memorije itd.).

Slika XXX Građa motornog neurona
Postoji velik broj klasa neuronskih mreža od kojih svaka ima svoje
specifičnosti. Pored velike različitosti postoje i osobine koje su
zajedničke za sve tipove neuronskih mreža.


23

Reprezentacija znanja
Svaku neuronsku mrežu karakteriše osam glavnih parametara:
1. Skup procesnih elemenata (čvorovi).
2. Stanje aktivacije.
3. Izlazna funkcija za svaki čvor.
4. Struktura povezanosti između čvorova.
5. Pravilo propagacije signala kroz mrežu.
6. Aktivaciona funkcija.
7. Algoritam obučavanja.
8. Okolina u kojoj sistem treba funkcioniše.
Skup procesnih elemenata
Da bismo formirali model neuronske mreže prvi korak je da
definišemo skup čvorova i šta oni predstavljaju. Postoje dva pristupa.
U prvom (jedan čvor jedan koncept) čvor predstavlja neki objekat kao
što je slovo, reč ili koncept. U drugom (distribuirani pristup) čvor
predstavlja samo jedno obeležje nekog objekta a kompletan objekata
predstavljen je celinom mreže. Distribuirani pristup se češće koristi.
U neuronskoj mreži nema supervizora koji nadgleda i kontroliše rad
celine, postoje samo relativno jednostavni procesni elementi koji
obavljaju jednostavne zadatke. Celokupan zadatak čvora je da primi
signale sa ulaza (težinski izlazi susednih čvorova) i da na osnovu njih
generišu izlazni signal. Na slici prikazan je model neurona kao
procesnog elementa.
W
1j
Σ
W
ij
U
i
a
k
t
i
v
a
c
i
j
a
U1
I
j

Slika Model neurona kao procesnog elementa
Tipičan model neuronskih mreža sadrži tri tipa čvorova: ulazne,
izlazne i skrivene. Funkcije pojedinih čvorova odgovaraju njihovom
nazivu. Tako ulazni čvorovi služe da prime signale iz okoline i
distribuiraju ih u unutrašnjost mreže. Skriveni čvorovi te signale
preuzimaju, procesiraju ih i prenose do izlaznih čvorova koji ih
konačno predaju okolini (izlaz). Skriveni čvorovi nemaju vezu s
24
Reprezentacija znanja
okolinom, sem indirektno preko ulaznih i zlaznih čvorova. Procesni
elementi biće označeni sa ui, i=1, N, N- broj procesnih elemenata
mreže.
Stanje aktivacije
Stanje aktivacije ai(t) predstavlja stanje i-tog procesnog elementa u
trenutku t i odgovara stanju jezgra neurona. Stanje čvora može da
poprimi vrednost iz definisanog skupa (npr. skup pozitivnih realnih
brojeva).
Izlazna funkcija
Svakom procesnom elementu u pridružuje se izlazna funkcija koju
realizuje akson i koja preslikava stanje aktivacije u trenutku t u
izlazni signal . U većini modela neuralnih mreža ta funkcija je
f(x)=x. Izlazna funkcija koristi se za modeliranje nekih ograničenja
recimo negativne vrednosti da stavi na 0 a vrednosti veće od
maksimalne da postavi na maksimum. Takve funkcije zovu se
"rampa funkcije" :
i
) (t o
i
( ) ( ) ( ) Θ − ⋅ Θ − = x h x x f
gde je:
Θ − prag aktivacije
h − Hevisajdova funkcija.
Struktura povezanosti
Čvorovi kod svih tipova neuralnih mreža međusobno su povezani
brojnim vezama koje odgovaraju sinapsama. Broj i struktura veza
jedan su od najznačajnijih elemenata neuralne mreže. Topologije
raznih neuralnih mreža određene su baš ovom osobinom. Svaka veza
sadrži određenu težinu ( ) koja je nosilac znanja i predstavlja
jačinu veze između čvora u i . Kad signal prelazi iz jednog čvora u
drugi obično se množi težinom grane (veze ) i tako utiče na stanje
aktivacije odredišnog čvora. Ta težina se može podešavati tokom
vremena. Promena vrednosti težina veza naziva se obučavanje.
ji
w
j i
u
ji
w
25

Reprezentacija znanja
Obučavanje mora da se obavlja tako da mreža nakon modifikacije
daje bolje rezultate od neobučene mreže.
Mogući su razni načini opisa veza. Jedan od načina je da se
informacije o vezama organizuju u matricu n x n gde je n ukupan
broj čvorova. Ako je vrednost težine veća od nula tada se takva veza
naziva excitirajuća. Takve veze povećavaju nivo aktivacije čvoru u koji
ulaze. U protivnom, ako je vrednost manja od nula tada se veza
naziva inhibirajuća i smanjuje nivo aktivacije odredišnog čvora.
Postoje neuralne mreže (npr. Hopfield-ova) kod kojih je ta matrica
simetrična ili je trougaona (najčešći slučaj).
Pravilo propagacije signala kroz mrežu
Pravilo propagacije signala kroz mrežu predstavlja način kojim se
vrši kombinacija izlaznih vrednosti čvorova i tako generiše ulaz u
čvor. Kod neurona ga realizuju dendriti. Pravilo propagacije je
najčešće jednostavno
net w o
i ji
j
j i
= +

Θ
gde je
vrednost ulaza u i-ti čvor
i
net
bias i-tog čvora i koristi se kod obučavanja
i
Θ
Postoje i komplikovanija pravila propagacije i ona zavise od tipa i
zadatka koji se rešava uz pomoć neuralne mreže.

Aktivaciona funkcija
Funkcija aktivacije predstavlja zakon po kojem se menja vrednost
stanja aktivacije j-tog čvora i ima sledeći oblik:
( )) ), 1 ( ( ) ( t net t a F t a
j j j j
− =
Funkcija perikaryon-a može da se posmatra kao funkcija aktivacije.
U opštem slučaju to je funkcija koja zavisi od prethodnog stanja
aktivacije kao i od trenutnog ulaza u čvor. Funkcija je najčešće
deterministička iako može da bude i stohastička. Tri najčešća tipa
aktivacionih funkcija su:
26
Reprezentacija znanja
step_funkcija
( ) h x A b
A b x
A b x
, , ,
,
,
Θ
Θ
Θ
=
+ ≥
− + <
¦
´
¹

semi-linearna funkcija
( )
¦
¹
¦
´
¦
Θ >
Θ < < Θ −
Θ ⋅
Θ +
Θ − <
=
x
x
x
x
x f
; 1
;
2
; 0

i sigmoidna funkcija
( ) f x
e
x
=


1
1
.
Na slici prikazana je semi-linearna aktivaciona funkcija
-PRAG_AKTIVACIJE PRAG_AKTIVACIJE
1
net
f(net)
0

Slika Semi-linearna aktivaciona funkcija
Algoritmi obučavanja
Algoritam obučavanja je specificirano pravilo koje opisuje način
promene težina veza između čvorova tokom vremena kako bi se
dobilo željeno ponašanje mreže.
Okolina
Svaki sistem pa i neuralna mreža prima signale iz okoline. Prema
tome potrebno je imati model te okoline. Rezultate obrade ulaznih
podataka mreža treba da distribuira u okolinu.
27

Reprezentacija znanja
2.2.2. Klasifikacija neuronskih mreža
Klasifikacija neuralnih mreža vrši se u odnosu na sledeće tri važne
karakteristike ili osobine mreža.
1. Topološke karakteristike.
2. Način reprezentacije znanja.
3. Način obučavanja.
Klasifikacija u odnosu na topološke karakteristike
Razne arhitekture (topologije) neuralnih mreža nastaju organizacijom
čvorova u slojeve (polja) i povezivanjem čvorova unutar polja kao i
čvorova između polja na razne načine. Karakterizacija topologija vrši
se u odnosu na tri parametra:
• vrste veza
• šeme veza
• konfiguracija polja
Veze mogu biti excitirajuće (povećavaju nivo aktivacije) ili
inhibitirajuće (smanjuju nivo aktivacije). Postoje dve osnovne šeme
veza: veze unutar polja i veze između polja. Takođe, postoje i dve
vrste toka informacija: feedforward (tok signala samo u jednom
smeru) i feedback (dozvoljen tok signala u oba smera).
Konfiguracije polja formiraju koherentnu arhitekturu
kombinovanjem slojeva procesnih elemenata, toka informacija i šema
povezivanja.
Klasifikacija u odnosu na način reprezentacije znanja
Neuralne mreže mogu se posmatrati kao memorije sa znanjem
distribuiranim u vezama (sinapsama). Kao memorije neuralne mreže
mogu čuvati dve vrste uzoraka: prostorne (vremenski nepromenljive )
i prostorno-vremenske uzorke (vremenski nestacionarni).
Neuralne mreže mogu se posmatrati i kao asocijativne memorije.
Suština je u načinu adresiranja kojim se jednoj adresi (ključu)
asocira skup memorisanih objekata sa zadanim nivoom tačnosti.
Situacija u kojoj se koristi asocijativna memorija je kad znamo samo
deo ključa, a potreban nam je ceo objekt.
28
Reprezentacija znanja
Postoje dva osnovna principa smještanja informacija u neuralnoj
mreži kao asocijativnoj memoriji: autoasocijativni i heteroasocijativni.

Klasifikacija u odnosu na način obučavanja
Obučavanje je proces promene vrednosti veza između procesnih
elemenata. Ta promena veza mora biti u odnosu na zadati cilj. Sve
metode generalno mogu se podeliti u dve osnovne grupe: obučavanje
sa ili bez učitelja (samo obučavanje).
Kod obučavanja sa učiteljem cilj koji treba da se zadovolji je
minimizacija greške kad poznajemo način na koji su ulazni i izlazni
podaci klasifikovani. Obučavanje sa učiteljem možemo podeliti u dve
kategorije: strukturalno obučavanje (kodiraju se parovi uzoraka ( A
i
,
B
i
) ) i temporalno obučavanje kojim se kodira sekvenca uzoraka koja
je potrebna da se dostigne. Primeri obučavanja sa učiteljem su:
obučavanje sa korekcijom greške , obučavanje sa međusobnim
pojačanjem, stohastičko obučavanje itd.
Samo obučavanje predstavlja proces obučavanja kod kojeg nema
spoljašnjeg učitelja i koji zavisi samo od informacije sadržane u
uzorcima koji dolaze na mrežu.

2.2.3. Algoritmi za obučavanje neuronskih mreža
Jedan od najvećih problema koji se javlja kod modeliranja
neuronskih mreža je pronalaženje efikasnog sistema (postupka) za
obučavanje. Trenutno ne postoji generalno rešenje koje bi na
zadovoljavajući način bilo primenljivo u svim situacijama. U
nastavku će biti opisana dva postupka: pseudo-kompetitivno
obučavanje i obučavanje generalisanim delta pravilom.
Prvi postupak jedan je od najjednostavnijih algoritama za obučavanje
i ovde je opisan da bi se na ilustrativnom a jednostavnom primeru
prikazale mogućnosti a i problemi na koje treba obratiti pažnju.
Generalisano delta pravilo jedan je od najpoznatijih i najčešće
korišćenih algoritama za obučavanje neuronskih mreža.
29

Reprezentacija znanja
Pseudo kompetitivno obučavanje
Neuronske mreže koje su pogodne za obučavanje ovim načinom su
dvoslojne neuronske mreže i semi-linearnom aktivacionom funkcijom
u neuronima izlaznog sloja (Slika ).
U1
U2
U3
I1
I2
I3
I4
I5
W
11
W
35
Ulazni sloj
Kompetitivni sloj
I
Z
L
A
Z
U
L
A
Z

Slika Dvoslojna feedforward neuronska mreža
Algoritmom se vrši modifikacija težinskih faktora veza između
ulaznih i izlaznih neurona. U izlaznom (kompetitivnom) sloju samo
jedan neuron može da bude aktivan dok su ostali neuroni neaktivni
(nepobuđeni), odnosno za određenu kombinaciju pobuđenih neurona
na ulazu pobuđen je samo jedan neuron na izlazu. Ovim se dobija
vrlo jednostavan a efikasan klasifikator.
Algoritam: Ako je obučavajući skup Ω oblika:
} .. 1 ) , {( m j izlaz ulaz
j j
= = Ω gde je:
) ,... (
1 n i
a a ulaz = , } 1 , 0 { ∈
i
a
) .. , (
2 1 m j
o o o izlaz =
¹
´
¦
=

=
j i
j i
o
i
; 1
; 0

m - broj uzoraka obučavajućeg skupa i broj neurona u izlaznom
sloju
n - broj neurona u ulaznom sloju neuronske mreže
30
Reprezentacija znanja
Tada se vrednost težina veza između ulaznih neurona i pobuđenog
izlaznog neurona računa na sledeći način:
¦
¹
¦
´
¦
=
=
=
0 ;
1
1 ;
1
,
j
i j
j
i j
j i
a
KAZNA
a
NAGRADA
W
gde je

=
=
n
i
j
i
j
a NAGRADA
1


=
− =
n
i
j
i
j
a KAZNA
1
) 1 (
Primer 1. Simulirati sistem prikazan slikom
x
1
x
2
x
3
x
4
y
1
y
2
y
3
y
4

Slika
Ponašanje sistema opisano je sledećom tabelom:

Ulaz Izlaz
x
1
x
2
x
3
x
4
y
1
y
2
y
3
y
4

1 0 1 0 1 0 0 0
1 1 1 1 0 1 0 0
0 0 0 1 0 0 1 0
1 1 0 0 0 0 0 1
Rešenje:
Neuronska mreža treba da ima 4 ulaza i 4 izlaza. Za prvi uzorak iz
obučavajućeg skupa neuronska mreža prikazana je na slici
31

Reprezentacija znanja
1
2
3
4
1
2
3
4
W
1,1
W2
,1
W
3
,1
W
4
,
1
1
1
0
1
0

Slika
gde je 5 . 0
1 , 1
= W , 5 . 0
1 , 2
− = W , 5 . 0
1 , 3
= W , 5 . 0
1 , 4
= W

Primer 2. Sistem za dijagnostiku dečijih bolesti
Dizajnirati i implementirati ekspertni sistem za dijagnostiku dečijih
bolesti. Sistem treba da obezbedi postavljanje dijagnoze na osnovu
uočenih simptoma. Ekspert (lekar) treba unapred da opiše poznate
bolesti preko određenog broja simptoma.


M
a
l
e

b
o
g
i
n
j
e

R
u
b
e
o
l
e

Z
a
u
š
k
e

G
r
i
p

O
v
č
i
j
e

b
o
g
i
n
j
e

V
e
l
i
k
i

k
a
š
a
l
j

J
a
k
a

p
r
e
h
l
a
d
a

M
e
n
i
n
g
i
t
i
s

Groznica
Da Da Da Da
Osip
Da Da Da Da
Glavobolja
Da Da
Curenje nosa
Da Da Da Da Da
Konjuktivitis
Da Da
Kašalj
Da Da Da Da
Jak bol u telu
Da
Osetljivost na svetlost
Da
Bol u grlu
Da Da Da
Kijavica
Da Da Da
Otekle pljuvačne žlezde
Da
Krvave oči
Da
Ukrućeni zglobovi
Da
Povećane limfne žlezde iza uha
Da
Otpor na sisanje kiselog
Da
32
Reprezentacija znanja
Nenormalna pljuvačka Da
Otekli krajnici Da
Suva usta Da
Slabost u telu Da
Trovanje Da Da
Dijareja Da
Svrab Da
Gubitak apetita Da
U tabeli pregledno je dat opis bolesti preko simptoma matricom u
kojoj na preseku kolone (bolest) i vrste (simptomi) piše da ako je
simptom prisutan u bolesti odnosno ništa ako se simptom ne
pojavljuje u posmatranoj bolesti.
Rešenje
Na ulaz neuronske mreže dovode se informacije o simptomima a na
izlazu svaki neuron odgovara jednoj bolesti. Za obučavanje koristi se
obučavajući skup definisan u tabeli.
Na REFERENCA_NA_SAJT je dato rešenje u programskom jeziku....

Primer 3. Sistem za prepoznavanje slova
Implementirati sistem za prepoznavanje slova na osnovu slike 5x7
pixela.

33

Reprezentacija znanja
Rešenje
Neuronska mreža treba da ima 35 ulaza, svaki ulaz odgovara jednom
pixelu matrice 5x7, vrednost 1 predstavlja crnu boju dok 0 belu.
Izlazni sloj neuronske mreže treba da ima onoliko neurona koliko
ima slova. Svakom neuronu tog sloja se pridružuje jedno slovo tako
da u toku eksploatacije neuron koji je najjače pobuđen u stvari
predstavlja prepoznato slovo.
U nastavku su izdvojeni delovi karakteristični za rešenje a kompletno
rešenje nalazi se u REFERENCA_NA_SAJT
void PseudoKompetitivno::obucavanje() {
int i = 0;
for(int i=0; i<broj_izlaza; i++){
double nagrada = 0.0;
double kazna = 0.0;
for(int j = 0;j<broj_ulaza; j++){
if(alphabet[j][i] == 1)
nagrada++;
else
kazna++;
}
if(nagrada != 0)
nagrada = 1.0/nagrada;
if(kazna != 0)
kazna = -1.0/kazna;
for(int j = 0;j<broj_ulaza; j++){
if(alphabet[j][i] == 1)
W[j][i] = nagrada;
else
W[j][i] = kazna;
}
}
}

void PseudoKompetitivno::dijagnostika(double ad[],
double ad1[]) {
for(int i=0; i<broj_izlaza; i++){
double net = 0.0;
for(int j=0; j<broj_ulaza; j++){
net += W[j][i] * ad[j];
}
ad1[i] = aktivacija(net);
}
}
U dodatku je data implementacija u C++ i Java programskim
jezicima.
34
Reprezentacija znanja

UKLJUČITI C++
Na sličan način moguće je i u programskom jeziku Java imple-
mentirati prethodno opisan algoritam. Neuronska mreža u ovom
primeru treba da obezbedi prepoznavanje slova opisanih sličicom 5x7
pixela.

Slika Sistem za prepoznavanje slova
Na slici su prikazana tri slučaja u kojima je dobro prepoznato
orginalno slovo. Aplikacija sadrži pet elemenata: 1. originalno slovo,
2 zamućeno slovo, 3 propoznato slovo, 4 klizač za definisanje stepena
zamućenja i 5 dugme za izbor novog slova.

Slika Elementi aplikacije za prepoznavanje slova


Generalisano delta pravilo
Algoritam generalisano delta pravilo poznato je i kao back-
propagation algoritam.
Višeslojne neuronske mreže sa sigmoidnim aktivacionim funkcija
pogodne su za obučavanje ovim algoritmom. Za razliku od
prethodnog algoritma na izlazu može više neurona da bude
pobuđeno. Zbog ove osobine back-propagation je moguće koristiti u
35

Reprezentacija znanja
rešavanju većeg skupa problema. Nedostatak ovog algoritma je u
tome što aktivaciona funcija mora da bude diferencijabilna, a
prilikom obučavanja dobijeno stanje ne mora i da bude najbolje.
Back-propagation algoritam
iteracija
uzorak
Postavi ulaz za uzorak Izračunaj izlaz
Izračunaj uticaj greške u
slojevima
Koriguj težine
Slika 2.
Algoritam: Na slici 2. dat je strukturni dijagram algoritma. Četri
operacije se ponavljaju u svakoj iteraciji i za svaki uzorak. Operacije
su redom: postavljanje ulaza, izračunavanje izlaza, izračunavanje
greške i korekcija težina.
Izračunavanje izlaza obavlja se po formulama:
i
i
j i j
a W net

=
,
, gde je
s
U j ∈
1 −

s
U i
(
j
net f
,U je skup indexa neurona u
s-tom sloju, je izlaz iz i-tog neurona, W je vrednost težine veze
između j tog i i tog neurona. a
s
)
j
i
a
j i,
=
Izračunavanje uticaja greške u j-tom neuronu na kriterijumsku
funkciju:
( )
∑ ∑

− =
uzorci U j
j j
n
a t E
2
2
1

za neurone u izlaznom sloju:
) ( ) ( '
j j j j
a t net f − ⋅ = δ ,
gde je željeni izlaz, je stvarni izlaz
j
t
j
a
36
Reprezentacija znanja
za neurone u skrivenim slojevima:

+

⋅ =
1
,
) ( '
s
U i
j i j i i
W net f δ δ
Uticaj greške računa se od izlaznog sloja prema ulaznom sloju.
Korekcija težina računa se od ulaznog prema izlaznom sloju po
sledećoj formuli:
j i q
p
i
p
j j i p
W a W
,
) ( ) (
,
∆ + = ∆ β ηδ gde su p i q indexi uzoraka, η
brzina obučavanja, je uticaj greške u j-tom neuronu,
) ( p
j
δ β uticaj
prethodnih promjena, prethodna promjena.
j i q
W
,

pragovi aktivacija (bias) računa se po formuli
u p
p
j u p
θ β ηδ θ ∆ + = ∆
) (

j i p j i j i
W W W
, , ,
∆ + = i
u p u u
θ θ θ ∆ + =
Primer 1: XOR funkcija
program bp;

{ Generalisano delta pravilo.
Primer obucavanja viseslojne neuralne mreze algoritmom
backpropagation. Primenjen algoritam je detaljno opisan
u knjizi D.Nauck, F. Klawonn, R. Kruse
Foundations of neuro-fuzzy systems
John Wiley & sons 1997. godine
Autori programa: Damir Solajic & Djordje Obradovic}

const

slojeviN = 3; { Ukupan broj slojeva.}
MAXN = 2; { Maximalan broj neurona po slojevima.}
{ Konstante potrebne za obucavanje. }
uzorciN = 4; { Ukupan broj uzoraka.}
MAXITERACIJA = 10000; { Maximalan broj iteracija za obucavanje}
MAXGRESKA = 0.001; { Zadata vrednost maximalne greske.}
ni = 0.05; {Parametri obucavanja.}
beta = 0.9;


BROJPOKUSAJA = 5;
type

37

Reprezentacija znanja
{Tip u kojem se opisuje jedan sloj}
TSloj = record
n:inte {Stvaran broj neurona u sloju.} ger;
izlaz:array[1..MAXN] of real;
sigma array[1..MAXN] of real; { Greska u posmatranom cvoru} :
bias:array[1..MAXN] of real; { Prag aktivacije}
biasp:array[1..MAXN] of real; { Promena praga aktivacije}
end;

TW = array[1..MAXN, 1..MAXN] of real; { Matrica za opis tezina.}
TSlojevi = array[1..slojeviN] of TSloj; { Niz slojeva.}
TWi = array[1..(slojeviN-1)] of TW; {Niz matrica tezina}

var

slojevi:TSlojevi; { Svi slojevi u mrezi.}
tezine:TWi; { Sve matrice tezina.}
tezineP:TWi; { Matrice promena odgovarajucih tezina}
{ ulaz=1 izlaz =2}

obucavajuciSkup:array[1..uzorciN, 1..2, 1..MAXN] of real;
{ Obucavajuci skup: prvi index UZORAK, drugi index je jedan ako se
posmatra ulaz a dva ako se posmatra izlaz,
treci index redni broj neurona }


{ Procedura sluzi za inicijalizaciju neuronske mreze i obucavajuceg
skupa}
procedure Inicijalizacija;
begin

{Inicijalizacija mreze. Odredjivanje stvarnog broja neurona po
sloju.}
slojevi[1].n := 2;
slojevi[2].n := 2;
slojevi[3].n := 1;

{Inicijalizacija obucavajuceg skupa za XOR problem}
obucavajuciSkup[1,1,1] := 0;
obucavajuciSkup[1,1,2] := 0; { uzorak 1}
obucavajuciSkup[1,2,1] := 0;

obucavajuciSkup[2,1,1] := 0;
obucavajuciSkup[2,1,2] := 1; { uzorak 2}
obucavajuciSkup[2,2,1] := 1;

obucavajuciSkup[3,1,1] := 1;
obucavajuciSkup[3,1,2] := 0; { uzorak 3}
obucavajuciSkup[3,2,1] := 1;

obucavajuciSkup[4,1,1] := 1;
obucavajuciSkup[4,1,2] := 1; { uzorak 4}
obu
end;
cavajuciSkup[4,2,1] := 0;

38
Reprezentacija znanja


{ Procedura sluzi za inicijalizaciju matrice tezina i pragova
aktivacije.}
procedure InicijalizacijaTezina;
var
s, u, v:integer;
begin
{Inicijalizacija matrice tezina
po preporuci W je element [-0.1, 0.1]}
randomize;
for s:=1 to slojeviN-1 do
begin
for u:=1 to slojevi[s].n do
for v:=1 to slojevi[s+1].n do
tezine[s][u,v] := (random-0.5)/5;
end;
{Inicijalizacija pragova aktivacije. [0,1]}
for :=2 to lojeviN do s s
for u:=1 to slojevi[s].n do

end;
slojevi[s].bias[u] := random;
{ Sigmoidna funkcija aktivacije.}
function sigmoid(net:real):real;
begin
sigmoid := 1/(1+exp(-net));
end;
{ Procedura na osnovu postavljenog ulaza izracunava vrednost izlaza.}
procedure izracunajIzlaz;
var
s, u, v:integer;
net:
begin
real;
for :=2 to lojeviN do s s
for =1 to slojevi[s].n do v:
begin
net := slojevi[s].bias[v];
for u:= 1 to slojevi[s-1].n do
net := net+slojevi[s-1].izlaz[u]*tezine[s-1][u, v];
slojevi[s].izlaz[v] := sigmoid(net);
end;
end;
{ Procedura na ulaz postavlja vrednost uzorka indeksiranog
parametrom uzorak}
procedure postaviUlaz(uzorak:integer);
var
u:in
begin
teger;
for u:=1 to slojevi[1].n do
s
end;
lojevi[1].izlaz[u] := obucavajuciSkup[uzorak, 1, u];
{ Funkcija izracunava vrednost gresaka u svim slojevima pocevsi
od poslednjeg, prema prvom. Greska u poslednjem cvoru racuna
39

Reprezentacija znanja
se u odnosu na uzorak indeksiran parametrom uzorak.
Ukupna greska uzorka racuna se kao suma kvadrata gresaka na
svim izlazima.}
function izracunajGreske(uzorak:integer):real;
var
s,u,v:integer;
sigmaa:real;
f:real;
greska:real;
begin
{Greska u poslednjem sloju}
greska:= 0;
for v:=1 to slojevi[slojeviN].n do
begin
slojevi[slojeviN].sigma[v] := obucavajuciSkup[uzorak, 2, v] -
slojevi[slojeviN].izlaz[v];
gre
end;
ska := greska+sqr(slojevi[slojeviN].sigma[v]);
{Greska u svim ostalim slojevima}
for :=sloj iN-1 downto 1 do s ev
for =1 to slojevi[s].n do u:
begin
sigmaa := 0;
for v:=1 to slojevi[s+1].n do
sigmaa := sigmaa + slojevi[s+1].sigma[v]*tezine[s][u,v];
f := slojevi[s].izlaz[u];
slojevi[s].sigma[u] := f*(1-f)*sigmaa; {ovo vazi samo za
sigmoidnu aktivaciju}
end;
izr
end;
acunajGreske := greska;

{ Procedura na osnovu postavljenih vrednosi gresaka u slojevima
koriguje matrice tezina i pragove aktivacije.}
procedure korigujTezine;
var
s, u, v:integer;
net:
begin
real;
for s:=1 to slojeviN-1 do
for v:=1 to slojevi[s+1].n do
begin
for u:=1 to slojevi[s].n do
begin
tezineP[s][u,v] :=
ni*slojevi[s+1].sigma[v]*slojevi[s].izlaz[u]+beta*tezineP[s][u,v];
tezine[s][u,v] := tezine[s][u,v] + tezineP[s][u,v];
end;
{Korekcija pragova aktivacije}
slojevi[s+1].biasp[v] := ni*slojevi[s+1].sigma[v] + beta*
slojevi[s+1].biasp[v];
slojevi[s+1].bias[v] := slojevi[s+1].bias[v] +
slojevi[s+1].biasp[v];
{Izracunavanje korigovane vrednosti izlaza u sloju.}
net := slojevi[s+1].bias[v];
40
Reprezentacija znanja
for u:=1 to slojevi[s].n do
net := net+slojevi[s].izlaz[u]*tezine[s][u,v];
slojevi[s+1].izlaz[v] := sigmoid(net);
end;
end;

{ Funkcija kao povratnu vrednost vraca ukupnu gresku u
poslednjoj iteraciji.}
function obucavanje:real;
var
iteracija, uzorak, i, j:integer;
greska:real;
begin
iteracija := 1;
repeat
greska := 0;
for uzorak:=1 to uzorciN do
begin
postaviUlaz(uzorak);
izracunajIzlaz;
greska := greska + 0.5*izracunajGreske(uzorak);
korigujTezine;
end;{uzorak}
Inc(iteracija);
until (iteracija>=MAXITERACIJA) or (greska<MAXGRESKA);
{Kontrola!}
writeln('Iteracija: ', iteracija, ' Greska: ', greska);
obucavanje := greska;
end;

{ Glavni program.}
var
i, pokusaj:integer;
gres
begin
ka :real;
pokusaj:=1;
Inicija
repeat
lizacija; {Inicijalizacija obucavajuceg skupa.}
InicijalizacijaTezina; {Postavljanje matrice tezina i pragova
aktivacija.}
greska := obucavanje;
Inc(pokusaj);
until (pokusaj>BROJPOKUSAJA) or (greska <MAXGRESKA);
{ Ispis rezultata. }
for i:=1 to uzorciN do
begin
postaviUlaz(i);
IzracunajIzlaz;
writeln(i, ' ', slojevi[slojeviN].izlaz[1]);
end;
rea
end.
dln;
41

Reprezentacija znanja
Zadaci za vežbu
1. Dizajnirati i implementirati ekspertni sistem za
dijagnosticiranje kvara na automobilu na osnovu dvoslojne neuralne
mreže i kompetitivnog algoritma za obučavanje. Sistem treba da
obezbedi postavljanje dijagnoze na osnovu uočenih simptoma kvara.
Postaviti tabelu sa 10 simptoma i kvarova, omogućiti jednostavno
dodavanje novih simptoma i kvarova, jednostavan i pristupačan
korisnički interfejs i čuvanje rezultata rada.
2. Pomoću neuralne mreže simulirati rad sistema čije je
ponašanje opisano sledećim formulama: y1=x1+x2+x3, y2=x4+x5+x6.
x1 ,x2, x3, x4, x5 i x6 su ulazi u sistem, a y1 i y2 su izlazi iz sistema.
Koristiti troslojnu feed-forward neuralnu mrežu i back-
propagation algoritam obučavanja.
3. Dizajnirati i implementirati ekspertni sistem za
dijagnosticiranje kvara na automobilu na osnovu troslojne feed-
forward neuralne mreže i back-propagation algoritma za obučavanje.
Sistem treba da obezbedi postavljanje dijagnoze na osnovu uočenih
simptoma kvara. Izlaze kodirati NBCD kodom. Postaviti tabelu sa 10
simptoma i kvarova, omogućiti jednostavno dodavanje novih
simptoma i kvarova, jednostavan i pristupačan korisnički interfejs i
čuvanje rezultata rada.
4. Pomoću neuralne mreže simulirati rad sistema koji
predstavlja konvertor iz NBCD u Grejov kod. Ulaz je cifra kodirana
NBCD kodom, a izlaz ista cifra kodirana Grejovim kodom. Koristiti
troslojnu feed-forward neuralnu mrežu i back-propagation
algoritam obučavanja.
5. Dizajnirati i implementirati ekspertni sistem za dijagnostiku
dečijih bolesti na osnovu troslojne feed-forward neuralne mreže i
back-propagation algoritma za obučavanje. Sistem treba da obezbedi
postavljanje dijagnoze na osnovu uočenih simptoma bolesti. Postaviti
tabelu sa 10 simptoma i bolesti, omogućiti jednostavno dodavanje
novih simptoma i bolesti, jednostavan i pristupačan korisnički
interfejs i čuvanje rezultata rada.
6. Dizajnirati i implementirati ekspertni sistem za dijagnostiku
dečijih bolesti na osnovu troslojne feed-forward neuralne mreže i
back-propagation algoritma za obučavanje. Sistem treba da obezbedi
postavljanje dijagnoze na osnovu uočenih simptoma bolesti. Izlaze
kodirati NBCD kodom. Postaviti tabelu sa 10 simptoma i bolesti,
omoguciti jednostavno dodavanje novih simptoma i bolesti,
42
Reprezentacija znanja
jednostavan i pristupačan korisnicki interfejs i čuvanje rezultata
rada.
7. Dizajnirati i implementirati sistem za prepoznavanje slova na
osnovu dvoslojne neuralne mreže i kompetitivnog algoritma za
obučavanje. Ulaz u sistem predstavljaju slova srpske abecede
(latinica) predstavljena matricom 5x7. Izlaz iz sistema je verovatnoća
da je dato slovo na ulazu. Posle obučavanja, tačno slovo na ulazu
zamutiti za željeni procenat. Dizajnirati pristupačan korisnički
interfejs koji će omogućiti jednostavno zadavanje ulaznog slova,
koeficijenta zamućenja i prikazati tačno ulazno, zamućeno ulazno i
prepoznato izlazno slovo. Ulazne podatke učitavati iz odgovarajuće
datoteke.
8. Dizajnirati i implementirati sistem za prepoznavanje slova na
osnovu dvoslojne neuralne mreže i kompetitivnog algoritma za
obučavanje. Ulaz u sistem predstavljaju slova srpske azbuke (ćirilica)
predstavljena matricom 5x7. Izlaz iz sistema je verovatnoca da je
dato slovo na ulazu. Posle obučavanja, tačno slovo na ulazu zamutiti
za željeni procenat. Dizajnirati pristupačan korisnički interfejs koji će
omogućiti jednostavno zadavanje ulaznog slova, koeficijenta
zamućenja i prikazati tačno ulazno, zamućeno ulazno i prepoznato
izlazno slovo. Ulazne podatke učitavati iz odgovarajuce datoteke.
9. Dizajnirati i implementirati sistem za prepoznavanje slova na
osnovu troslojne feed-forward neuralne mreže i back-propagation
algoritma za obučavanje. Ulaz u sistem predstavljaju slova srpske
abecede (latinica) predstavljena matricom 5x7. Izlaz iz sistema je
verovatnoća da je dato slovo na ulazu. Posle obučavanja, tačno slovo
na ulazu zamutiti za željeni procenat. Dizajnirati pristupačan
korisnički interfejs koji će omogućiti jednostavno zadavanje ulaznog
slova, koeficijenta zamućenja i prikazati tačno ulazno, zamućeno
ulazno i prepoznato izlazno slovo. Ulazne podatke učitavati iz
odgovarajuće datoteke.
10. Dizajnirati i implementirati sistem za prepoznavanje slova na
osnovu troslojne feed-forward neuralne mreže i back-propagation
algoritma za obučavanje. Ulaz u sistem predstavljaju slova srpske
azbuke (ćirilica) predstavljena matricom 5x7. Izlaz iz sistema je
verovatnoca da je dato slovo na ulazu. Posle obučavanja, tačno slovo
na ulazu zamutiti za željeni procenat. Dizajnirati pristupačan
korisnički interfejs koji će omogućiti jednostavno zadavanje ulaznog
slova, koeficijenta zamućenja i prikazati tačno ulazno, zamućeno
43

Reprezentacija znanja
ulazno i prepoznato izlazno slovo. Ulazne podatke učitavati iz
odgovarajuće datoteke.
1. Dizajnirati i implementirati sistem za prepoznavanje slova na
osnovu troslojne feed-forward neuralne mreže i back-propagation
algoritma za obučavanje. Ulaz u sistem predstavljaju slova srpske
abecede (latinica) predstavljena matricom 5x7. Izlaz iz sistema je
verovatnoća da je dato slovo na ulazu. Slova na izlazu kodirati NBCD
kodom. Posle obučavanja, tačno slovo na ulazu zamutiti za željeni
procenat. Dizajnirati pristupačan korisnički interfejs koji će
omogućiti jednostavno zadavanje ulaznog slova, koeficijenta
zamućenja i prikazati tačno ulazno, zamućeno ulazno i prepoznato
izlazno slovo. Ulazne podatke učitavati iz odgovarajuće datoteke.
44
Reprezentacija znanja
2.3. Fuzzy logika
Fuzzy logika kao koncept je puno prirodniji nego što se to na prvi
momenat misli. Naime, postoje situacije u kojima nije moguće znanje
o sistemu reprezentovati na apsolutno precizan način. Čak je više
situacija u kojima moramo da koristimo neprecizne konstatacije. Na
primer, «Marko je visok čovek.», «Onaj automobil se približava jako
velikom brzinom.» su neprecizne rečenice a ipak ih svakodnevno
koristimo.
Da bismo bili u stanju reprezentovati znanje o ovakvim sistemima (a
ima ih jako puno) moramo da se odreknemo klasične (binarne) logike
u kojoj je nešto ili tačno ili netačno (crno ili belo) i da koristimo fuzzy
logiku (sve je nijansa sive boje).
Neki će reći ako nepreciznim iskazima reprezentujemo znanje, kako
možemo da očekujemo korektno izvođenje zaključaka. U ovom
poglavlju pokušaćemo da na jednom primeru pokažemo da je to
moguće, čak i jednostavnije nego da koristimo klasične metode.
2.3.1. Fuzzy skupovi
Fuzzy skupovi su osnovni elementi kojima opisujemo nepreciznost.
Naime, diskretan skup (klasičan) sadrži elemente sa istim svojstvima
(skup jabuka, skup krušaka, skup celih brojeva itd.) dok fuzzy
skupovi sadrže elemente sa sličnim svojstvima (skup visokih ljudi,
skup niskih ljudi, skup brzih automobila itd.).
U diskretnim skupovima element ili pripada ili ne pripada određenom
skupu, ako to predstavimo matematički kažemo da je stepen
pripadnosti skupu 1 (ako pripada) ili 0 (ako ne pripada). Sa druge
strane elementi u fuzzy skupovima mogu delimično da pripadaju,
matematički to možemo da predstavimo na sledeći način 1 (100%
pripada), 0 (uopšte ne pripada skupu), 0.7 (70% pripada skupu).
Ovim pristupom možemo preciznije da reprezentujemo neprecizne
iskaze.
Na primer, ako kažemo da su ljudi višlji od 185 cm visoki, kako da
opišemo čoveka visokog 184.5 cm? Da li on pripada skupu visokih ili
niskih ljudi? Iz iskustva bismo ovakvog čoveka svrstali u grupu
visokih ljudi, međutim kako da to predstavimo na sistematičan način
(kako bi ono što mi radimo iskustveno radio i računar)? Jednostavno
45

Reprezentacija znanja
kazaćemo da čovek visok 184.5 pripada skupu visokih ljudi sa
stepenom 0.95.
Na ovaj način uvodimo nov koncept a to je funkcija pripadnosti. Tako
na primer skupu visokih ljudi pridružena je funkcija pripadnosti koja
opisuje stepen pripadnosti svakog elmenta tom skupu.
Na slici prikazana je funkcija pripadnosti skupu visokih ljudi.
130 cm
185 cm
Stepen pripadnosti
Visina
100%
0%

Slika
Osnovne osobine fazi skupa su:
• normalnost
Maksimalna vrednost funkcije pripadnosti je 1.
• konveksnost

a) konveksan b) nekonveksan
• broj elemenata
Broj elemenata skupa računa sa kao zbir vrednosti
funkcije pripadnosti svakog elementa.
Kao i kod diskretnih skupova i ovde se definišu osnovne operacije
(unija, presek, negacija i komplement).
46
Reprezentacija znanja
2.3.2. Reprezentacija znanja primenom fuzzy skupova
Znanje u predikatskoj (diskretnoj) logici sadržano je u relacijama
između objekata (skup činjenica i pravila). Na isti način se znanje
reprezentuje u fuzzy logici ali pomoću fuzzy relacija.
Na primer ako imamo dva skupa A={1, 3, 4} i B={3, 1, 5} tada se u
diskretnoj logici relacija veći ili jednak definiše na sledeći način.


1 3 4
3 1 1 0
1 1 0 0
5 1 1 1
Ovde je stepen sigurnosti (stepen pripadnosti) uvek ili 0 ili 1.
Kod fuzzy relacija ovo izgleda malo drugačije. Na primer imamo skup
A={marko, nikola, steva} tada relacija dobar_drug može da bude
definisana na sledeći način:

dobar_drug marko nikola steva
marko 0.5 0.8 0.2
nikola 0.8 0.5 0.3
steva 0.2 0.3 0.5
Ovde je stepen sigurnosti između 0 i 1.
Kao i u diskretnim logikama i ovde je moguća kompozicija relacija.
2.3.3. Zaključivanje u fuzzy logici
Ovo verovatno treba prebaciti kod tehnika rasuđivanja.

47

Reprezentacija znanja
2.3.4. Rešavanje problema primenom fuzzy logike
U ovom poglavlju opisan je jedan primer primene fuzzy logike u
rešavanju problema automatskog upravljanja realnim sistemom.
Primer 1. Projektovati sistem za upravljanje kočenjem automobila
koji na osnovu brzine automobila i rastojanju do susednog vozila
određuje potrebno kočenje kako bi se izbegao sudar.
• Prvi korak u rešavanju problema je podela skupa mogućih
vrednosti stanja u nekoliko kategorija.
Na primer brzinu automobila (0 do 200 km/h) delimo u
dve kategorije ili dva skupa mala_brzina i velika_brzina i
rastojanje do susednog vozila (0.5m do 200m) delimo u
veliko i malo rastojanje.
Ovim su definisane ulazne fuzzy veličine.
• Drugi korak je podela skupa mogućih akcija u nekoliko
skupova ili kategorija.
Silu kočenja (0 do 1000 N) delimo u tri fuzzy skupa:
slabo, srednje i veliko kočenje.
Ovim se definišu izlazne fuzzy veličine.
• Na osnovu iskustva napisati fuzzy pravila ili fuzzy relacije na
osnovu kojih će se izvoditi zaključak.
Fuzzy pravila bi u ovom slučaju mogla da izgledaju ovako:
Ako je mala_brzina i veliko_rastojanje kočenje treba da
bude slabo. Ako je velika_brzina i malo_rastojanje koristiti
veliko kočenje.
• Na kraju definisati funkcije pripadnosti koje opisuju fuzzy
skupove (posebno za svaku od veličine).
Primer 2.
Izvršiti dizajn i implementaciju sistema za upravljanje položajem
inverznog klatna. Mehanički model problema prikazan je na slici 1, a
matematički model dat je sistemom diferencijalnih jednačina u
prostoru stanja:
48
Reprezentacija znanja
u
Mml m M I
ml
Mml m M I
ml I
θ
θ
x
x
Mml m M I
m M mgl
Mml m M I
mlb
Mml m M I
gl m
Mml m M I
)b ml I
θ
θ
x
x
(
(
(
(
(
(
¸
(

¸

+ +
+ +
+
+
(
(
(
(
¸
(

¸


(
(
(
(
(
(
¸
(

¸

+ +
+
+ +

+ + + +
+ −
=
(
(
(
(
¸
(

¸

2
2
2
2 2
2
2 2
2
2
) (
0
) (
0
0
) (
) (
) (
0
1 0 0 0
0
) ( ) (
(
0
0 0 1 0
&
&
& &
&
& &
&

Slika 1 a
u
θ
θ
x
x
y
(
¸
(

¸

+
(
(
(
(
¸
(

¸

(
¸
(

¸

=
0
0
1 0 0 0
0 1 0 0
&
&

Slika 1 b
Na slici 2 prikazana je slika realnog sistema kojim se upravlja kao i
osnovne veličine koje ga opisuju.



5 . 0 = M masa vozila kg
2 . 0 = m masa štapa kg
1 . 0 = b
s m
N
/
koeficient trenja vozila
006 . 0 = I koeficient inercije štapa
2
m kg ⋅
3 . 0 = l dužina štapa m
F upravljačka sila
x pozicija vozila
θ ugao između štapa i
vertikale

Slika 2
Ulazi u fazi kontroler su ugao i ugaona brzina klatna. Izlaz iz fazi
kontrolera je upravljačka sila. Na slici 3. prikazan je šematski prikaz
upravljačkog modela.
Sistem je podeljen na dve celine. Prva celina predstavlja objekat
upravljanja (inverzno klatno), opisan matematičkim modelom. Druga
49

Reprezentacija znanja
celina je fazi kontroler koji treba da obezbedi željenu vrednost
upravljane veličine. Fazi upravljanje se sastoji od tri etape. Prva je
fazifikacija ulaznih veličina. Nakon fazifikacije sledi zaključivanje na
osnovu fazi pravila. Na kraju se vrednost upravljačke sile određuje u
modulu za defazifikaciju.
Fazifikacija
θ
FM
Fazifikacija
θ
FM
Zaključivanje
Defazifikacija
u
FM
Fazi kontroler
θ
θ
F
u
F
u
Matematički model
x = Ax + Bu
.
.
θ
θ
F
.
.

Slika 3
Na slici 4. prikazan je izgled modula za fazifikaciju ulaznih veličina.
Fazifikacija je proces određivanja stepena pripadnosti elementima
fazi skupa. Funkcije pripadnosti fazi skupovima su trougaone
funkcije opisane sa tri veličine.
Fazifikacija
N Z P
pripadnost[Z,1] pripadnost[Z,2] pripadnost[Z,3]
Zaključivanje
N
Z P
Z
Z
P
P
N N
P
P
Z
Z
N
N
θ
F
θ
F
.
Defazifikacija
N Z P
Izlaz

Slika 4 Slika 5 Slika 6
U procesu zaključivanja prikazanom na slici 5. na osnovu fazi
skupova koji opisuju ulazne veličine i fazi pravila određuje fazi skup
koji predstavlja upravljačku veličinu. , gde je
, a i,j su indeksi matrice pravila gde je element jednak
k. U ovom primeru za defazifikaciju (slika 6) izabran je metod težišta
, a centar k-tog elementa fazi skupa.
] [ ] [ ] [
θ
θ
,
j i k u
F
j i
F
F
& ⋅ =

} , , { P Z N k ∈
} , , { P Z N k ∈ ] 2 , [k u
FM
50
Reprezentacija znanja
U nastavku je dato rešenja na programskom jeziku Pascal. Potrebno
je proširiti fazi skupove tako da se u svakom od njih umesto tri
nalazi pet vrednosti (dodati negativno jako i pozitivno jako) i za tako
definisane skupove napisati nova pravila. Potrebno je iscrtati
kretanje klatna i grafik promene položaja, ugaone brzine i
upravljačke sile u vremenu.
PROGRAM fazi_logika;
{ Program za upravljanje polozajem inverznog klatna
primenom fazi logike.
Datum: 21. mart 2000.
Autori: Djordje Obradovic E5427
Damir Solajic E5882
}
USES
Crt;
CONST

MV = 0.5; { Masa vozila }
mK = 0.2; { Masa stapa }
b = 0.1; { Koeficijent trenja vozila }
I = 0.006; { Koeficijent inercije stapa }
l = 0.3; { Duzina stapa }
g = 9.81; { Gravitaciono ubrzanje }
dt = 0.001; { Vremenski prirastaj }
N = 1; { Indeks za negativne vrednosti }
Z = 2; { Indeks za nulte vrednosti }
P = 3; { Indeks za pozitivne vrednosti }
brojFaziVrednosti = 3;

TYPE

faziSkup = ARRAY[1..brojFaziVrednosti] OF real;
faziPripadnost = ARRAY[1..brojFaziVrednosti, 1..3] OF real;
faziPravila = ARRAY[1..brojFaziVrednosti, 1..brojFaziVrednosti] OF
integer;

VAR

t : real; { Vreme }
theta, dtheta, ddtheta : real; { Ugao stapa u odnosu na vertikalu }
x, dx, ddx : real; { Horizontalna koordinata }
u : real; { Upravljacka sila }

thetaF : faziSkup;
thetaFM : faziPripadnost;
dthetaF : faziSkup;
dthetaFM : faziPripadnost;
uF : faziSkup;
uFM : faziPripadnost;

pravila : faziPravila;

51

Reprezentacija znanja
{ Procedura na osnovu zadate vrednosti i funkcija pripadnosti
odredjuje fazi skup koji opisuje datu vrednost }
PROCEDURE fazifikacija(vrednost : real;
pripadnost : faziPripadnost;

BEGIN
VAR skup : faziSkup);
IF (vrednost <= pripadnost[N,2]) THEN
skup[N]:=1
ELSE IF (vrednost > pripadnost[N,2])
AND (vrednost < pripadnost[N,3]) THEN
skup[N]:=(pripadnost[N,3]-vrednost)/
(pripadnost[N,3]-pripadnost[N,2])
ELSE
skup[N]:=0;
IF (vrednost <= pripadnost[Z,1]) OR
(vrednost >= pripadnost[Z,3]) THEN
skup[Z]:=0
ELSE IF (vrednost > pripadnost[Z,1]) AND
(vrednost <= pripadnost[Z,2]) THEN
skup[Z]:=(vrednost-pripadnost[Z,1])/
(pripadnost[Z,2]-pripadnost[Z,1])
ELSE IF (vrednost > pripadnost[Z,2]) AND
(vrednost < pripadnost[Z,3]) THEN
skup[Z]:=(pripadnost[Z,3]-vrednost)/
(pripadnost[Z,3]-pripadnost[Z,2]);
IF (vrednost <= pripadnost[P,1]) THEN
skup[P]:=0
ELSE IF (vrednost > pripadnost[P,1]) AND
(vrednost < pripadnost[P,2]) THEN
skup[P]:=(vrednost-pripadnost[P,1])/
(pripadnost[P,2]-pripadnost[P,1])
ELSE

END;
skup[P]:=1;
{ Na osnovu dva fazi skupa i fazi pravila odredjuje se fazi skup
koji opisuje upravljanje }
PROCEDURE zakljucivanje(thetaF, dthetaF : faziSkup;
pravila : faziPravila;
VAR uF : faziSkup);
VAR
i, j : integer;
BEGIN
uF[N]:=0;
uF[Z]:=0;
uF[P]:=0;
FOR i:=1 TO brojFaziVrednosti DO
FOR j:=1 TO brojFaziVrednosti DO

END;
uF[pravila[i,j]]:=uF[pravila[i,j]]+thetaF[i]*dthetaF[j];

{ Na osnovu fazi skupa i funkcija pripadnosti izracunava se vrednost }
FUNCTION defazifikacija(skup : faziSkup;
pripadnost: faziPripadnost) : real;
{ Metoda centra tezista }
BEGIN
52
Reprezentacija znanja
defazifikacija:=skup[N]*pripadnost[N,2]+
skup[Z]*pripadnost[Z,2]+

END;
skup[P]*pripadnost[P,2];

{ Proracun matematickog modela }
PROCEDURE matematickiModel(x, dx, theta, dtheta, u : real;
VAR ddx : real; VAR ddtheta : real);
VAR
imenilac : real;
BEGIN
imenilac:=I*(MV+mK)+MV*mK*sqr(l);
ddx:=(-(I+mK*sqr(l))*b*dx+g*sqr(mK*l)*theta+(I+mK*sqr(l))*u)/
imenilac;
d
END;
dtheta:=(-mK*l*b*dx+mK*g*l*(MV+mK)*theta+mK*l*u)/imenilac;

PROCEDURE inicijalizacijaKontrolera;
BEGIN
thetaFM[N,1]:=-50*Pi/180;
thetaFM[N,2]:=-10*Pi/180;
thetaFM[N,3]:=0;

thetaFM[Z,1]:=-10*Pi/180;
thetaFM[Z,2]:=0;
thetaFM[Z,3]:=10*Pi/180;

thetaFM[P,1]:=0;
thetaFM[P,2]:=10*Pi/180;
thetaFM[P,3]:=50*Pi/180;

dthetaFM[N,1]:=-1.5;
dthetaFM[N,2]:=-0.75;
dthetaFM[N,3]:=0;

dthetaFM[Z,1]:=-0.75;
dthetaFM[Z,2]:=0;
dthetaFM[Z,3]:=0.75;

dthetaFM[P,1]:=0;
dthetaFM[P,2]:=0.75;
dthetaFM[P,3]:=1.5;

uFM[N,1]:=-30;
uFM[N,2]:=-25;
uFM[N,3]:=0;

uFM[Z,1]:=-25;
uFM[Z,2]:=0;
uFM[Z,3]:=25;

uFM[P,1]:=0;
uFM[P,2]:=25;
53

Reprezentacija znanja
uFM[P,3]:=30;

pravila[N,N]:=P;
pravila[N,Z]:=P;
pravila[N,P]:=Z;
pravila[Z,N]:=P;
pravila[Z,Z]:=Z;
pravila[Z,P]:=N;
pravila[P,N]:=Z;
pravila[P,Z]:=N;
pravila[P,P]:=N;
END;

{ Na osnovu dve vrednosti (ugla i ugaone brzine)
odredjuje se upravljacka sila }
FUNCTION faziKontroler(theta, dtheta : real) : real;
BEGIN
fazifikacija(theta, thetaFM, thetaF);
fazifikacija(dtheta, dthetaFM, dthetaF);

zakljucivanje(thetaF, dthetaF, pravila, uF);

faziKontroler:=defazifikacija(uF, uFM);
END;

{ Glavni program }
VAR
c : char;

BEGIN
inicijalizacijaKontrolera;
REPEAT
clrscr;
writeln('Izracunavanje upravljanja polozajem inverznog klatna');
write('Unesite inicijalni polozaj stapa = ');
readln(theta);
theta:=theta*Pi/180;
dtheta:=0;
x:=0;
dx:=0;
u:=0;

t:=0;
WHILE (t <= 1) DO
BEGIN
writeln(' u = ', u:4:2,' theta = ',(theta*180/Pi):4:2,
' dtheta = ',dtheta:4:2);
u:=faziKontroler(theta,dtheta);
matematickiModel(x,dx,theta,dtheta,u,ddx,ddtheta);
x:=x+dx*dt;
dx:=dx+ddx*dt;
theta:=theta+dtheta*dt;
dtheta:=dtheta+ddtheta*dt;
t:=t+dt;
END;
54
Tehnike rasuđivanja
write('Da li zelite jos jednom (d/n) ? ');
c:=readkey;

END.
UNTIL (c IN ['n','N']);
Zadaci za vežbu
1. Dizajnirati i implementirati sistem za upravljanje položajem
inverznog klatna čiji je matematički model dat u prethodnom
primeru. Fazi skupove organizovati tako da u svakom ima 5
vrednosti. Na ulazu zadati početno odstupanje položaja i
ugaone brzine klatna, kao i željeni krajnji položaj klatna (ugao
pod kojim će se klatno zaustaviti). Funkcije pripadnosti fazi
skupu modelirati kao trapezoidne funkcije opisane sa 4
veličine. Prikazati kretanje klatna i grafike promene položaja i
ugaone brzine klatna i upravljačke sile u vremenu.

3. Tehnike rasuđivanja
3.1. Pretraživanje
Brzina i kvalitet rešenja zavise od primenjenog algoritma za traženje
rešenja odnosno algoritma za pretraživanje. U ovom poglavlju biće
opisani najznačajniji algoritmi za pretragu u prostoru problema.
Naime, sam problem predstavlja stanje u «nekakvom» prostoru. Iz
jednog stanja moguće je preći u konačno mnogo i to uvek u
zavisnosti od nekog pravila. Recimo u šahu se figure pomeraju u
odnosu na pravila a položaji figura pre i posle pomeranja
predstavljaju dva moguća stanja.
Prvi zadatak svih pretraga je pronaći niz akcija ili koraka koje treba
obaviti da bi se iz početnog stanja stiglo do željenog stanja. U
principu moguće je naći više takvih nizova. Vrlo često se zahteva da
se prilikom rešavanja ovakvih problema vodi računa o nekoliko
stvari: broj koraka koji je doveo do cilja, ukupan broj koraka, broj
ponovljenih stanja itd.
Prema tome, pretrage predstavljaju kompleksne postupke koji u sebi
obuhvataju više različitih mehanizama.
U složenim problemima broj stanja kao i mogućih akcija u pravilu je
velik pa je veoma važno odabrati algoritam koji može da pronađe
rešenje i pri tom zadovolji postavljene uslove.
55

Tehnike rasuđivanja
Lavirint je jedan jednostavan primer u kome je stanje u stvari
pozicija opisana koordinatama x i y a raspored zidova određuje
pravila po kojima je moguće iz jedne pozicije preći u drugu. Na slici
XXX prikazan je lavirint u kojem je potrebno naći put između tačaka
P i K.

Slika XXX Lavirint
Iz stanja P u stanje b moguće je preći samo akcijom 3 (napred).
Pozicija stanja g je x=4, y=5, iz stanje f moguće je levo (1) u stanje e,
gore (3) u stanje g i dole (4) u stanje h.
Jedno rešenje ovog problema opisano je nizom akcija:
2, 2, 2, 2, 2, 4, 2, 2, 2, 3, 2, 2, 4, 4, 4, 4, 2, 2, 2, 2, 2
Razmislite o tome na koji način bi ste vi na osnovu sopstvenog
iskustva rešili ovakav zadatak. Nakon toga pokušajte da opišete
zašto ste problem rešili baš tako, i na kraju probajte problem da
opišete algoritamski ili da napišete program.
U nastavku će biti opisano nekoliko različitih postupaka za rešavanje
ovakvih problema.
56
Tehnike rasuđivanja
3.1.1. Enumerativni algoritmi i optimizacioni algoritmi
Pretraživanje «Prvi u dubinu»
Ako se postupak pretrage predstavi stablom, tad se postupak prvi u
dubinu može se ilustrativno predstaviti slikom:

Slika XXX Pretraživanje prvi u dubinu
Strategija pretraživanja prvi u dubinu
• Trenutna hipoteza ili stanje razrađuje se (u dubinu) pre
razmatranja ostalih stanja.
• U slučaju da stanje nema dece odnosno trenutna hipoteza ne
može da se razrađuje, prelazi se na obradu prethodne
hipoteze u drugom pravcu.
• Pošto su vrlo često problemi takvi da razvijanje stabla u
dubinu rezultuje stablima vrlo velike dubine, iz tehničkih
razloga dubina se ograničava na neku prihvatljivu veličinu.
Stanja odnosno hipoteze ispod te dubine se ne obrađuju.
U nastavku je prikazana ilustracija algoritma na primeru rešavanja
slagalice 3x3.
57

Tehnike rasuđivanja

Slika XXX Rešavanje slagalice 3x3
Programsko rešenje prikazano je u programskom jeziku Java, sastoji
se iz dve klase: State i Action. Klasa State opisuje jedan položaj
slagalice i sadrži statičke metode u kojima su opisani različiti
algoritmi za pretraživanje. Klasa Action opisuje pomeranje koje
povezuje dva stanja.
Action.java
public class Action {
public int startX;
public int startY;
public int endX;
public int endY;

public Action(int aStartX, int aStartY, int aEndX, int aEndY) {
startX = aStartX;
startY = aStartY;
endX = aEndX;
endY = aEndY;
}

public String toString() {
return "("+startX+", "+startY+") -> ("+endX+", "+endY+")";
}
}
58
Tehnike rasuđivanja

Atributi startX i startY opisuju položaj prazne pozicije pre a endX i
endY nakon izvršavanja akcije.
State.java

import java.util.*;
import java.util.Comparator;
import java.util.Collections;

public class State {

public int dimension = 0;
public int elements[][]=null;
public int markX = 0;
public int markY = 0;
public State parent = null;
public Action action = null;

public static int counter = 0;

public State(int aDimension) {
dimension = aDimension;
elements = new int[dimension][dimension];
}

public State(State st) {
dimension = st.dimension;
elements = new int[dimension][dimension];
for(int i=0; i<dimension; i++) {
for(int j=0; j<dimension; j++) {
elements[i][j] = st.elements[i][j];
}
}
markX = st.markX;
markY = st.markY;
}

public Vector possibleActions() {
Vector retVal = new Vector();
if(markX>0) {
Action act = new Action(markX-1, markY, markX, markY);
retVal.add(act);
}
if(markX+1<dimension) {
Action act = new Action(markX+1, markY, markX, markY);
retVal.add(act);
}
if(markY>0) {
Action act = new Action(markX, markY-1, markX, markY);
retVal.add(act);
}
59

Tehnike rasuđivanja
if(markY+1<dimension) {
Action act = new Action(markX, markY+1, markX, markY);
retVal.add(act);
}
return retVal;
}

public State nextState(Action act) {
State retVal = new State(this);
retVal.parent = this;
retVal.action = act;
// pomeranje
retVal.elements[act.endY][act.endX]=
elements[act.startY][act.startX];
retVal.elements[act.startY][act.startX]=
elements[act.endY][act.endX];
retVal.markX=act.startX;
retVal.markY=act.startY;
return retVal;
}

public void showPath(){
if(parent!=null)
parent.showPath();
if(action!=null)
System.out.println(""+action);
System.out.println(""+this);
}

public boolean isFinished() {
String curr = toHash();
String finished = finalState().toHash();
if(curr.equals(finished))
return true;
else
return false;
}

public String toString() {
String retVal = "";
String newLine = "";
for(int i=0; i<dimension; i++) {
retVal += newLine;
for(int j=0; j<dimension; j++) {
if((i==markY)&&(j==markX)) {
retVal += " ";
} else {
if(elements[i][j]<10)
retVal += " "+elements[i][j]+" ";
else
retVal += elements[i][j]+" ";
}
}
newLine="\n";
}
60
Tehnike rasuđivanja
return retVal;
}

public String toHash() {
String retVal = "";
for(int i=0; i<dimension; i++) {
for(int j=0; j<dimension; j++) {
retVal += elements[i][j]+"";
}
}
return retVal;
}

public State findSolution(int level, Hashtable states,
int maxLevel)
{
counter++;
if(level>maxLevel)
return null;
String hashCode = toHash();
states.put(hashCode, "");
if(isFinished()==true) {
return this;
}else{
Vector v = possibleActions();
for(int i=0; i<v.size(); i++) {
Action act = (Action)v.get(i);
State next = nextState(act);
if(states.get(next.toHash())==null) {
State solution = next.findSolution(level+1,
states, maxLevel);
if(solution!=null) {
return solution;
}
}
}
}
return null;
}

public static State searchDeepFirst(State state) {
Hashtable states = new Hashtable();
return state.findSolution(1, states, 200);
}

public static State initialState() {
State s = new State(3);
s.elements[0][0]=1;
s.elements[0][1]=9;
s.elements[0][2]=3;
s.elements[1][0]=5;
s.elements[1][1]=2;
s.elements[1][2]=6;
61

Tehnike rasuđivanja
s.elements[2][0]=4;
s.elements[2][1]=7;
s.elements[2][2]=8;
s.markY = 0;
s.markX = 1;
return s;
}

public static State finalState() {
State s = new State(3);
s.elements[0][0]=1;
s.elements[0][1]=2;
s.elements[0][2]=3;
s.elements[1][0]=4;
s.elements[1][1]=5;
s.elements[1][2]=6;
s.elements[2][0]=7;
s.elements[2][1]=9;
s.elements[2][2]=8;
s.markY = 2;
s.markX = 2;
return s;
}

public static void main(String args[]) {
State s = initialState();
System.out.println(s);
counter = 0;
State solution = searchDeepFirst(s);
if(solution!=null) {
System.out.println("---- Solution ----");
System.out.println("counter:"+counter);
solution.showPath();
} else {
System.out.println("---- ***** ----");
}
}

}
Rezultat izvršavanja
1 3
5 2 6
4 7 8
---- SOLVED----
counter:84477
1 3
5 2 6
4 7 8
(0, 0) -> (1, 0)
1 3
5 2 6
4 7 8
(0, 1) -> (0, 0)
5 1 3
2 6
62
Tehnike rasuđivanja
4 7 8
.........
(2, 2) -> (2, 1)
1 2 3
4 5 6
7 8

Pretraživanje «Prvi u širinu»

Strategija pretraživanja «Prvi u širinu»
• Razvijaju se uvek stanja ili hipoteze na istom nivou.
• Kad se završi pretraživanje u jednom nivou prelazi se na
sledeći i tako dok se ne dođe do rešenja ili dok hipoteze mogu
da se razvijaju bez ponavljanja
• Putanja od korana stabla do rešenja je u ovom slučaju
minimalna.
Programsko rešenje:
Implementacija ovog algoritma se nadovezuje na prethodni program.
Klasa State proširena je metodom

public class State {
....
public static State searchBreadthFirst(State state) {
Hashtable states = new Hashtable();
Vector nodes = new Vector();
boolean solved = false;
nodes.add(state);
String hashCode = state.toHash();
states.put(hashCode, "");
while(solved==false||nodes.size()>0) {
State s = (State)nodes.get(0);
63

Tehnike rasuđivanja
counter++;
if(s.isFinished()==true) {
return s;
} else {
Vector v = s.possibleActions();
for(int i=0; i<v.size(); i++) {
Action act = (Action)v.get(i);
State next = s.nextState(act);
String nextHashCode = next.toHash();
if(states.get(nextHashCode)==null) {
states.put(nextHashCode, "");
nodes.add(next);
}
}
nodes.remove(s);
}
}
return null;
}
....
}
A metoda main se sad menja u:

public static void main(String args[]) {
State s = initialState();
System.out.println(s);
counter = 0;
State solution = searchBreadthFirst(s);
if(solution!=null) {
System.out.println("---- Solution ----");
System.out.println("counter:"+counter);
solution.showPath();
} else {
System.out.println("---- ***** ----");
}
}
Rezultat izvršavanja
1 3
5 2 6
4 7 8
---- SOLVED----
counter:52
1 3
5 2 6
4 7 8
(1, 1) -> (1, 0)
1 2 3
5 6
4 7 8
(0, 1) -> (1, 1)
1 2 3
5 6
4 7 8
64
Tehnike rasuđivanja
(0, 2) -> (0, 1)
1 2 3
4 5 6
7 8
(1, 2) -> (0, 2)
1 2 3
4 5 6
7 8
(2, 2) -> (1, 2)
1 2 3
4 5 6
7 8
Iterativno pretraživanje «Prvi u dubinu»
Iterativno pretraživanje «prvi u dubinu» je pretraživanje u kojem se
koriste dobre osobine pretrage prvi u dubinu i dobre osobine
pretrage prvi u širinu.
Strategija:
• Izršiti pretragu «Prvi u dubinu» sa zadatom dubinom.
• Ako traženo rešenje nije pronađeno ponoviti postupak sa
povećanom dubinom.
• Uvećavati dubinu pretrage «prvi u dubinu» sve dok se ne nađe
rešenje ili se ne dođe do maksimalne dubine.
• Potrebni resursi su isti kao za pretragu prvi u dubinu.
• Putanja do rešenja je minimalna.
Programsko rešenje:
Implementacija algoritma opisana je metodom koja se nadovezuje na
ostale metode definisane u klasi State.

public class State {
....
public static State searchIterativeDeepFirst(State state){
for(int i=1; i<200; i++) {
Hashtable states = new Hashtable();
State solution = state.findSolution(1, states, i);
if(solution!=null)
return solution;
}
return null;
}
.....
65

Tehnike rasuđivanja
}
Tada glavni program može da izgleda:

public static void main(String args[]) {
State s = initialState();
System.out.println(s);
counter = 0;
State solution = searchIterativeDeepFirst(s);
if(solution!=null) {
System.out.println("---- Solution ----");
System.out.println("counter:"+counter);
solution.showPath();
} else {
System.out.println("---- ***** ----");
}
}

Rezultat izvršavanja:

1 3
5 2 6
4 7 8
---- SOLVED----
counter:192
1 3
5 2 6
4 7 8
(1, 1) -> (1, 0)
1 2 3
5 6
4 7 8
(0, 1) -> (1, 1)
1 2 3
5 6
4 7 8
(0, 2) -> (0, 1)
1 2 3
4 5 6
7 8
(1, 2) -> (0, 2)
1 2 3
4 5 6
7 8
(2, 2) -> (1, 2)
1 2 3
4 5 6
7 8
66
Tehnike rasuđivanja
Bidirekciona pretraga
Strategija:
• Krenuti sa rešavanjem zadatka algoritmom prvi u širinu ili
iterativni prvi u dubinu.
• Istovremeno razvijati rešenje korišćenjem pretrage prvi u
širinu ili iterativni prvi u dubinu.
• Ako se jedan od listova iz jednog stabla poklopi sa jednim od
listova drugog traženo rešenje je putanja od zadatka do
zajedničkog stanja ili hipoteze i putanja od tog stanja do
rešenja.

Ova vrsta pretrage grafički je prikazana na slici

Slika Bidirekciona pretraga
Programsko rešenje implementirano je na primeru slagalice 3x3
odnosno kao proširenje klase State:

public class State {
....
public static State searchBiDirectional(State state) {
State finalState = finalState();
Hashtable statesA = new Hashtable();
Hashtable statesB = new Hashtable();
boolean solved = false;
Vector nodesA = new Vector();
Vector nodesB = new Vector();
67

Tehnike rasuđivanja
nodesA.add(state);
nodesB.add(finalState);
String hashCodeA = state.toHash();
statesA.put(hashCodeA, state);
String hashCodeB = finalState.toHash();
statesB.put(hashCodeB, finalState);
while((counter<10000)||(solved==false)) {
counter++;
// from start
State s = (State)nodesA.get(0);
String hc = s.toHash();
State inter = (State)statesB.get(hc);
if(inter!=null) {
System.out.println("------SOLVED-------");
s.showPath();
System.out.println("-------------------");
inter.showPath();
return inter;
} else {
Vector v = s.possibleActions();
for(int i=0; i<v.size(); i++) {
Action act = (Action)v.get(i);
State next = s.nextState(act);
String nextHashCode = next.toHash();
if(statesA.get(nextHashCode)==null) {
statesA.put(nextHashCode, next);
nodesA.add(next);
}
}
nodesA.remove(s);
}
// from end
s = (State)nodesB.get(0);
hc = s.toHash();
inter = (State)statesA.get(hc);
if(inter!=null) {
System.out.println("------SOLVED-------");
s.showPath();
System.out.println("-------------------");
inter.showPath();
return inter;
} else {
Vector v = s.possibleActions();
for(int i=0; i<v.size(); i++) {
Action act = (Action)v.get(i);
State next = s.nextState(act);
String nextHashCode = next.toHash();
if(statesB.get(nextHashCode)==null) {
statesB.put(nextHashCode, next);
nodesB.add(next);
}
}
nodesB.remove(s);
}
}
68
Tehnike rasuđivanja
return null;
}
....
}
Glavni program može da izgleda:

public static void main(String args[]) {
State s = initialState();
System.out.println(s);
counter = 0;
State solution = searchIterativeDeepFirst(s);
if(solution!=null) {
System.out.println("---- Solution ----");
System.out.println("counter:"+counter);
solution.showPath();
} else {
System.out.println("---- ***** ----");
}
}
Rezultat izvršavanja:
1 3
5 2 6
4 7 8
------SOLVED-------
1 3
5 2 6
4 7 8
(1, 1) -> (1, 0)
1 2 3
5 6
4 7 8
(0, 1) -> (1, 1)
1 2 3
5 6
4 7 8
-------------------
1 2 3
4 5 6
7 8
(1, 2) -> (2, 2)
1 2 3
4 5 6
7 8
(0, 2) -> (1, 2)
1 2 3
4 5 6
7 8
(0, 1) -> (0, 2)
1 2 3
69

Tehnike rasuđivanja
5 6
4 7 8
---- SOLVED----
counter:7
1 2 3
4 5 6
7 8
(1, 2) -> (2, 2)
1 2 3
4 5 6
7 8
(0, 2) -> (1, 2)
1 2 3
4 5 6
7 8
(0, 1) -> (0, 2)
1 2 3
5 6
4 7 8
Optimizacioni algoritmi (A*)
U slučaju da želimo izvršiti pretragu u što je moguće manje koraka
moramo u prostor uvesti metriku. Odnosno, svako stanje bi u tom
slučaju bilo opisano vrednošću definisane heurističke funkcije. Ta
vrednost bi na primer govorila koliko je tranutno stanje «daleko» od
rešenja.
Na ovaj način u pretrazi se prioritet daje stanjima koja su bliže
traženom rešenju a time se značajno smanjuje broj operacija
potrebnih za nalaženje rešenja.
Vrlo često heurističke funkcije predstavljaju samo predviđanje a ne i
stvarno stanje, tako da izbor i kvalitet heurističke funkcije vrlo često
određuje i kvalitet i brzinu pronalaženja rešenja.
Strategija A* algoritma je da se uvek ispituje hipoteza koja ima
minimalnu vrednost definisane heurističke funkcije. Putanja od
zadatka do rešenja je i u ovom slučaju minimalna ali je broj koraka
kojim je dobijeno rešenje manji nego kod pretraživanja prvi u širinu.
Programsko rešenje je implementirano na primeru slagalice 3x3 kao i
u prethodnim slučajevima. Klasa State proširena je heurističkom
funkcijom koja vraća broj pločica koji se nalazi na svojem mestu.

public class State {
.....
public int heuristicFunction() {
int retVal = 0;
70
Tehnike rasuđivanja
for(int i=0; i<dimension; i++) {
for(int j=0; j<dimension; j++) {
if(elements[i][j] == (i*dimension+j+1) ) {
retVal++;
}
}
}
return retVal;
}
public static State searchAStar(State state) {
Hashtable states = new Hashtable();
Vector nodes = new Vector();
boolean solved = false;
nodes.add(state);
String hashCode = state.toHash();
states.put(hashCode, "");
Comparator c = new StateComparator();
while(solved==false||nodes.size()>0) {
State s = (State)nodes.get(0);
counter++;
if(s.isFinished()==true) {
return s;
} else {
Vector v = s.possibleActions();
for(int i=0; i<v.size(); i++) {
Action act = (Action)v.get(i);
State next = s.nextState(act);
String nextHashCode = next.toHash();
if(states.get(nextHashCode)==null) {
states.put(nextHashCode, "");
nodes.add(next);
}
}
nodes.remove(s);
Collections.sort(nodes, c);
}
}
return null;
}
.....
}
Rezultat izvršavanja:
1 3
5 2 6
4 7 8
---- SOLVED----
counter:6
1 3
5 2 6
4 7 8
(1, 1) -> (1, 0)
1 2 3
71

Tehnike rasuđivanja
5 6
4 7 8
(0, 1) -> (1, 1)
1 2 3
5 6
4 7 8
(0, 2) -> (0, 1)
1 2 3
4 5 6
7 8
(1, 2) -> (0, 2)
1 2 3
4 5 6
7 8
(2, 2) -> (1, 2)
1 2 3
4 5 6
7 8
Za potrebe sortiranja implementirana je klasa StateComparator:

import java.util.*;
import java.util.Comparator;
import java.lang.Comparable;

public class StateComparator implements Comparator {

public int compare(Object a, Object b) {
int retVal = 0;
State stateA = (State)a;
State stateB = (State)b;
int fA = stateA.heuristicFunction();
int fB = stateB.heuristicFunction();
if(fA<fB) {
retVal=1;
} else if(fA>fB) {
retVal=-1;
}
return retVal;
}
}

A glavni program u ovom slučaju je:
public static void main(String args[]) {
State s = initialState();
System.out.println(s);
counter = 0;
State solution = searchAStar(s);
if(solution!=null) {
System.out.println("---- Solution ----");
System.out.println("counter:"+counter);
solution.showPath();
} else {
System.out.println("---- ***** ----");
72
Tehnike rasuđivanja
}
}

Zadaci za vežbu
1. Napisati program kojim se određuje postupak za rešavanje
slagalice 4x4. Programski implementirati algoritme prvi u
dubinu, prvi u širinu, iterativni prvi u dubinu, bidirekcioni i
A*. U rešenju treba da se nalazi početno stanje, krajnje
stanje, sve akcije koje od početnog vode ka krajnjem stanju i
broj koraka koji su obavljeni da bi se dobilo rešenje.
2. Ako je lavirint opisan slikom XXXX. Napisati program kojim
se pronalazi najkraći put između ulaza i izlaza.
3. Napisati program koji pronalazi položaje N dama na
šahovskoj tabli dimenzije NxN, takve da se bilo koja dama ne
nalazi na putanji ostalih dama.
4. Ako su gradovi povezani putnom mrežom prikazanom na slici
XXXXY odrediti
a. Listu gradova koji se nalaze na najkraćoj putanji
između grada A i grada Z.
b. Putanju kojom bi se trabalo kretati da se obiđu svi
gradovi i pređe najkraći put.
73

Tehnike rasuđivanja
4
1

Slika XXXs
5. Napisati program kojim se određuju potezi koje šahista treba
da obavi da bi skakač sa pozicije B2 prešao na poziciju F2.

Slika
74
Tehnike rasuđivanja





3.1.2. Genetski algoritmi

3.2. Dedukcija
3.2.1. Izračunavanje odgovora u predikatskoj logici
Izračunavanje odgovora u predikatskoj logici izvodi se korišćenjem
dva mehanizma:
1. Ujedinjavanje
2. Rezolucija
Ovim mehanizmima kreira se stablo pretraživanja.
Ujedinjavanje je proces menjanja dva terma sa ciljem da se ti termovi
učine identični.
Supstitucija: Supstituciom ili zamenom nazivamo konačan skup
parova oblika za koje važi sledeće: S t X =
i. X ∀ se javlja samo u jednom paru iz S
ii. Promenjljive X nema sa desne strane znaka =
S A*
S
je term koji se dobije tako što se u termu izvrši supstitucija
.
A
Primer:
Ako je term drug(X, Y). a supstitucija : A =
1
S { X=pera, Y=mika }
tada je drug(pera, mika). : *
1
S A
75

Tehnike rasuđivanja
=
2
S { X=brat(ana), Y=otac(ana) }
: *
2
S A drug(brat(ana), otac(ana)).
Supstitucija =
a
S
2
{ X=pera, X=mika } nije dobra zato što se
promenljiva X pojavljuje dva para. Takođe supstitucija
{X=marko, Y=X } nije dobra zato što se promenljiva X nalazi i sa
leve i sa desne strane znaka =.
=
b
S
2
Instanca: Term je instanca terma A B ako postoji takva supstitucija
tako da važi S S B* A = .
Primer:
: B p(X):-q(X), r(X,Y). =
3
S { X=a, Y=b }
3
* S B A =
: A p(a):-q(a), r(a,b).
Ujedinjivost: Dva terma su ujedinjiva ako imaju zajedničku instancu
S B S A C * * = =
Primer:
: A p(a, Y).
: B p(X, b).
3 3
* * S B S A C = = ;
: C p(a, b).
Ujedinitelj: Supstitucija naziva se ujedinitelj. S
Najopštiji ujedinitelj: Supstitucija koja ta dva terma ujedinjuje tako
da u njima ostane najveći mogući broj promenljivih.
Primer:
: A p(X, Y, a).
: B p(Z, voli(pera, vino), a).
=
4
S { X=Z, Y=voli(pera, vino) }
76
Tehnike rasuđivanja
=
5
S { X=3, Z=3, Y=voli(pera, vino) }
4
S je opštiji od
5
S
Varijanta: Varijanta nekog terma A je instanca te strukture koja je
dobijena primenom supstitucije koja sadrži samo promenljive.
Primer:
p(X):-q(X), r(X).
P(Y):-q(Y), r(Y).
p(K):-q(K), r(K).
=
6
S { X=Y }
=
7
S { X=K }
Proces ujedinjavanja dva terma:
1. Dve strukture su ujedinjive ako imaju iste funktore i ako su
svi argumenti jedne ujedinjive sa argumentima druge.
2. Ako su termovi i konstante onda su ujedinjivi samo ako
su identični.
1
A
2
A
3. Ako je term promenljiv a proizvoljan term onda
ujedinjavanje uspeva ako se promenljiva ne pojavljuje u
termu . Pri ujedinjavanju sa promenljiva
poprima vrednost terma . Ako je obrnuto isto važi.
1
A
2
A
1
1
A
2
A
2
A A
1
A
2
A
Primeri:
drug(a, b).
drugar(a, b).
Dve strukture nisu ujedinjive zato što nemaju uste funktore.
drug(a, b).
drug(a, b, c).
Dve strukture nisu ujedinjive zato što nemaju isti broj argumenata.
brz(X).
brz(pas(X)).
77

Tehnike rasuđivanja
Ove dve nisu ujedinjive zato što argumenti X i pas(X) nisu ujedinjivi.
Međutim, ujedinjavanje je moguće izvršiti između prve klauzule i
varijante druge (preimenovanje promenljivih).
brz(X).
brz(pas(Y)).


Mehanizam redukovanja cilja (resolucija)
Procedura rezolviranja se svodi na pojednostavljivanje zadatog cilja
korišćenjem ujedinjavanja sve dok ne dobijemo prazan cilj.
Primer:
(k
1
) p(X, Y):-q(X), r(X, Y).
(k
2
) p(d, 4).
(k
3
) q(a).
(k
4
) q(b).
(k
5
) q(c).
(k
6
) r(a, 1).
(k
7
) r(a, 2).
(k
8
) r(c, 3).
Proces redukovanja cilja ?-p(X, Y) grafički je prikazan na slici 2.XX.
78
Tehnike rasuđivanja

Slika 2.XX Grafički prikazan proces redukovanja cilja
Stablo pretraživanja:
1. Koren stabla je polazni cilj C.
2. Neka je cilja oblika ?-C
1
, C
2
, ..., C
n
. čvor stabla
pretraživanja i neka je C
1
pozitivan pod cilj tada taj čvor ima
po jednog potomka za svaku klauzulu oblika G:-T
1
,...,T
q
. za
koju su strukture C
1
i G ujedinjive. Tada potomak cilja ?-C
1
,
C
2
, ..., C
n
. izgleda
?-( T
1
,...,T
q
, C
2
, ..., C
n
)*S
Gde je S najopštiji ujedinitelj struktura C
1
i G.
Ujedinjive klauzule traže se odozgo prema dolja i s leva na
desno.
3. Neka je cilj ?-C
1
, C
2
, ..., C
n
. čvor stabla pretraživanja ali je
C
1
oblika C
1
=not( C
1
*
). Ako cilj ima C
1
*
konačno stablo
pretraživanja sa granom uspeha tada celi čvor nema
79

Tehnike rasuđivanja
potomaka. Međutim, ako C
1
*
ima konačno stablo pretraživanja
ali bez grane uspeha onda je potomak cilj ?-C
2
, ..., C
n

4. Potomak koji nema ni jednog elementa naziva se prazan cilj []
Čvor uspeha je čvor koji sadrži prazan cilj. Grana stabla koje
završavaju na čvoru uspeha nazivaju se grane uspeha. Čvor koji
sadrži ne prazan cilj a nema potomaka naziva se čvor neuspeha.
Grana neuspeha je grana koja završava na čvoru neuspeha.
Primer 1:
(k
1
) p(X, Y):-q(X), r(X, Y).
(k
2
) p(d, 4).
(k
3
) q(a).
(k
4
) q(b).
(k
5
) q(c).
(k
6
) r(a, 1).
(k
7
) r(a, 2).
(k
8
) r(c, 3).
Ako je zadata cilj ?-P(X, Y) onda je odgovarajuće stablo
pretraživanja prikazano na slici 2.X1.
80
Tehnike rasuđivanja
?-p(X, Y).
?-q(X),r(X, Y).
?-r(a, Y) ?-r(b, Y) ?-r(c, Y)
[]
[] [] []
(k
1
)
(k
2
)
(k
3
) (k
4
) (k
5
)
(k
6
)
(k
7
)
(k
8
)
S
1
={X=a}
S
2
={Y=1}
S
3
={X=b}
S
4
={Y=2}
S
5
={X=c}
S
6
={Y=3}
S
7
={X=d, Y=4}
Odgovor:
X=d, Y=4
Odgovor:
X=c, Y=3
Odgovor:
X=a, Y=2
Odgovor:
X=1, Y=1
Čvor
neuspeha!
(1)
(2)
(3)
(4) (5)
(6) (7)
(8)
(9)

Slika 2.X1
Primer 2:
Za prikazano porodično stablo napisati skup činjenica i pravila koji
opisuju vezu roditelj (r) i vezu predak (p). Nakon toga nacrtati stablo
pretraživanja koje se formira kako bi se izračunao odgovor na pitanje
«Kome je ivan preda?».
Rеšenje 1:
(k
1
) r(ivan, toma).
(k
2
) r(mara, toma).
(k
3
) r(toma, petar).
(k
4,1
) p(X, Y):-r(X,Y).
(k
5,1
) p(X, Y):-r(X,Z), P(Z, Y).
Za cilj ?-predak(ivan, X). generiše se sledeće stablo pretraživanja:
81

Tehnike rasuđivanja

Slika 2.X1 Stablo pretraživanja za primer 2 rešenje 1
Dobijeni odgovori redom: X=toma, X=petar, i nakon toga dva čvora
neuspeha.
Rešenje 2:
Razlika između ovog i prethodnog rešenja je u tome što je zamenjen
redosled klauzula k
4
i k
5-
(k
1
) r(ivan, toma).
(k
2
) r(mara, toma).
(k
3
) r(toma, petar).
(k
4,2
) p(X, Y):-r(X,Z), P(Z, Y).
(k
5,2
) p(X, Y):-r(X,Y).
Sad za isti upit dobijamo drugačije stablo pretraživanja:
82
Tehnike rasuđivanja
?-p(ivan, X).
S
1
={X=X
1
, Y=Y
1
}
Odgovor:
X=petar
Odgovor:
X=toma
(1)
k
4,2
*S
1
: p(X
1
,Y
1
):-r(X
1
, Y
1
).
S
2
={X
1
=X}
?-r(ivan, X).
S
6
={X=toma}
?-[].
(k
1
)
?-r(ivan, Z), p(Z, X).
k
5,2
*S
1
: p(X
1
,Y
1
):-r(X
1
, Z),p(Z,Y
1
).
(k
5,2
*S
1
)*S
2
S
3
={Z=toma}
(k
1
)
?-p(toma, X).
(k
4,2
*S
1
)*S
2
?-r(toma, X).
S
4
={X=petar}
?-[].
(k
3
)
?-r(toma, Z),p(Z, X).
S
5
={Z=petar}
?-p(petar, X).
(k
3
)
?-r(petar, X).
Čvor
neuspeha!
?-r(petar, Z),p(Z, X).
Čvor
neuspeha!
(2)
(3)
(4)
(5)
(6) (7)
(8)
(9)
(10)
(11)
(11)
(k
5,2
*S
1
)*S
2
(k
4,2
*S
1
)*S
2
(k
4,2
*S
1
)*S
2
(k
5,2
*S
1
)*S
2

Slika Stablo pretraživanja za rešenje 2
U ovom slučaju prvo se generišu dva čvora neuspeha a potom
X=petar i X=toma. Ako se pažljivo pogleda drugo stablo pretraživanja
je «u ogledalu» preslikano prvo stablo.
Rešenje 3:
(k
1
) r(ivan, toma).
(k
2
) r(mara, toma).
(k
3
) r(toma, petar).
(k
5,3
) p(X, Y):-r(X,Y).
(k
4,3
) p(X, Y):-p(Z,Y), r(X, Y).
Stablo pretraživanja za treći slučaj nam daje dva dobra rešenja,
beskonačno mnogo čvorova neuspeha i jednu beskonačnu granu.
83

Tehnike rasuđivanja
?-p(ivan, X).
(k
4,3
*S
1
)*S
2
S
1
={X=X
1
, Y=Y
1
}
Odgovor:
X=toma
(1)
k
4,3
*S
1
: p(X
1
,Y
1
):-r(X
1
, Y
1
).
S
2
={X
1
=X}
?-r(ivan, X).
S
3
={X=toma}
?-[].
(k
1
)
?-p(Z, X),r(ivan,Z).
k
5,3
*S
1
: p(X
1
,Y
1
):-r(X
1
, Z),p(Z,Y
1
).
(k
5,3
*S
1
)*S
2
(k
4,3
)
?-r(Z, X),r(ivan,Z).
?-r(ivan, ivan).
?-r(ivan, mara).
S
6
={Z=toma, X=petar}
Čvor
neuspeha!
Čvor
neuspeha!
(2)
(3)
(4)
(5)
(6)
(7)
(10)
(12)
S
4
={Z=ivan, X=toma}
(k
1
)
S
5
={Z=mara, X=toma}
(k
2
)
?-r(ivan, toma). (8)
(k
3
)
?-[].
(k
1
)
(9)
?-p(Z
1
, X),r(Z, Z
1
),r(ivan, Z).
Odgovor:
X=petar
(k
5,3
*S
1
)*S
2
?-r(Z
1
, X),r(Z,Z
1
),r(ivan, Z).
(k
4,3
)
(11)
S
7
={Z
1
=ivan, X=toma}
?-r(Z,ivan),r(ivan, Z).
(k
1
)
Čvor
neuspeha!
S
8
={Z
1
=mara, X=toma}
(12) ?-r(Z,mara),r(ivan, Z).
Čvor
neuspeha!
S
9
={Z
1
=toma, X=petar}
(k
3
)
?-r(Z,toma),r(ivan, Z). (13)
Čvor
neuspeha!
(k
2
)
.....

Slika 2.XX Stablo pretraživanja sa beskonačnom granom
Možemo uočiti da je mehanizam rezolviranja prvo došao do tačnih
rešenja pa onda upao u beskonačno proširivanje zadatog cilja a
samim tim i do beskonačne grane. Po analogiji između prvog i drugog
slučaja kad smo zamenom redosleda klauzula dobili stablo
pretraživanja koje je «u ogledalu» preslikano stablo iz prvog slučaja,
lako je zaključiti da bismo u slučaju zamene redosleda klauzula k
4,3
i
k
4,5
odmah upali u beskonačno proširivanje cilja.
Zato je preporuka da se prvo navode klauzule koje predstavljaju
završetak rekurzije i da se prvo rešavaju jednostavniji podciljevi a
potom komplikovaniji. Pošto se potomci čvora grade rešavanjem
podciljeva s leva na desno poželjno je jednostavnije ciljeve smeštati
sa leva a komplikovanije sa desna.

84
Inteligentni agenti
4. Inteligentni agenti
Agent kao koncept definiše se na mnogo načina. Međutim, skoro sve
definicije opisuju agente kao objekte koji mogu da vide okolinu,
objekte i druge agente preko svojih senzora. Mogu da komuniciraju
sa drugim objektima ili agentima u okolini. Poseduju osobinu
pokretljivosti i obavezno imaju cilj koji treba da ispune. Ponekad
nekoliko agenata imaju zajednički zadatak pa je neophodno da
postoji njihova međusobna koordinacija. Takođe, agenti mogu da
budu osposobljeni za rešavanje određenog zadatka ili problema, i
tada oni predstavljaju servis koji ostali agenti mogu da koriste kako
bi rešili svoj zadatak.
Prethodnom definicijom obuhvaćen je veoma velik broj različitih
uređaja i programskih paketa. U daljem radu ograničićemo se na
agente koji pored prethodnih osobina poseduju i određenu
inteligenciju. Naime, agent da bi ispunio zadati cilj mora da donosi
odluke. Agenti koji te odluke donose na način opisan tehnikama
računarske inteligencije nazivaju se inteligentni agenti.
Za potrebe modeliranja i implementacije agenata pojedine celine se
odvajaju u module (modul za kretanje, modul za odlučivanje, modul
za komunikaciju, modul za izvršavanje akcija, senzori itd.). U
programskoj implementaciji inteligentnih agenata koristi se nekoliko
disciplina: objektno orijentisano modeliranje, računarska
inteligencija, modeliranje konkurentnog ponašanja, modeliranje
protokola za komunikaciju itd.

Slika 4.1 Okolina sa dva agenta i jednim objektom
Na slici 4.1 prikazana je jedna okolina (ili prostor) u kojoj se nalaze
dva agenta i jedan objekat. Zadatak agenta 1 može da bude sledeći:
85

Inteligentni agenti
«Pronađi objekat 1 i odnesi ga agentu 2. Agent 2 treba da sačuva
objekat 1 i da ga kasnije na zahtev brzo pronađe.»
Karakteristična struktura inteligentnog agenta prikazana je na slici
4.2.

Slika 4.2 Karakteristična struktura inteligentnog agenta
Kategorizacija agenata u odnosu na bazu znanja:
• Agenti koji imaju ugrađenu bazu znanja i ne mogu da uče-
Odluke se donose samo na osnovu sopstvene baze znanja
koja se definiše po kreiranju agenta i vremenom se ne menja.
• Agenti koji mogu da uče - Baza znanja se stalno proširuje
znanjem koje se preuzima iz okoline.
Kategorizacija agenata u odnosu na svrhu postojanja:
• Agenti koji postoje da bi obavili zadatak.
• Uslužni agenti – postoje kao servisi i čekaju dok neki drugi
agenti ne zatraže njihovu uslugu.
Koncept inteligentnih agenata trenutno je u razvoju. Sam razvoj se
kreće u nekoliko pravaca i sastoji se u implementaciji standarda i
okruženja za podršku agent orijentisanom programiranju i
izvršavanju.
Za koordinaciju razvoja inteligentnih agenata osnovana je
organizacija Foundation for Intelligent Physical Agents skraćeno (FIPA
http://www.fipa.org). Jedan od zadataka ove fondacije je
prikupljanje i objavljivanje specifikacija i standarda iz oblasti
inteligentnih agenata.
86
Inteligentni agenti
FIPA specifikacije su kolekcije standarda kojima se opisuje način
povezivanja i koordinacije raznolikih agentskih struktura.
Paralelno sa definisanjem specifikacija mnoge kompanije razvijaju
sopstvena okruženja za podršku agent orijentisanom programiranju.
Tako je na primer IBM T.J.Watson Research Center istraživački
centar pokrenuo projekat kojim se razvija okruženje ABLE (Agent
Building and Learning Environment), JAF (The Java Agent
Framework) je projekat MAS laboratorije
(http://mas.cs.umass.edu/), kojim je takođe implementirano
okruženje za razvoj inteligentnih agenata. Pored ova dva vrlo ozbilja
projekta IBM alphaWorks je pokrenuo i projekat ROBOCODE
(http://robocode.alphaworks.ibm.com/home/home.html), kojim je
moguće na jednostavan način kreirati agente i pratiti njihovo
ponašanje u okruženju u kojem se nalaze.
U nastavku će biti opisano ROBOCODE okruženje.
4.1. Robocode
Robocode projekat je razvijen u edukativne svrhe i njegova namena je
da se na atraktivnom primeru promoviše razvoj agent orijentisanog
programiranja u programskom jeziku Java.
Samo okruženje je zamišljeno kao virtuelno bojno polje u kojem se
takmiče inteligentni agenti (tenkovi). Takmičenje predstavlja
simulaciju međusobnog ponašanja više implementiranih agenata ili
timova. Osnovne funkcije kao i objekti definisani su u ROBOCODE
API-ju. Samo jezgro moguće je proširivati raznim tehnikama za
odlučivanje.
4.1.1. Osnovni delovi ROBOCODE okruženja
Robocode se distribuira u obliku izvršne .jar datoteke pod nazivom
robocode-setup.jar. Prilikom instalacije neophodno je da na
računaru bude instalirana verzija Java-e 1.3 ili više. Potrebno je da
se odgovori na pitanje gde će biti instaliran Robocode i da li će se
koristi jikes za kompajliranje (IBM-ova verzija Java kompajlera).
Nakon instalacije, okruženje je spremno za pokretanje izvršavanjem
datoteke robocode.bat.
87

Inteligentni agenti

Slika 4.3 Osnovni prozor ROBOCODE okruženja
Crni deo prozora predstavlja bojno polje na kojem se izvršava
simulacija.
Deo aplikacije namenjen kreiranju i modifikaciji agenata naziva se
Robot Editor i prikazan je slikom 4.4.

Slika 4.4 Robot Editor
88
Inteligentni agenti
Pokretanje simulacije obavlja se kreiranjem nove bitke (Battle->New).
Za opis simulacije, odnosno bitke potrebno je izabrati koji sve roboti
učestvuju u takmičenju i koliko rundi će trajati takmičenje.

Slika 4.5 Prozor za opis simulacije
Po pokretanju bitke (Start Battle), roboti se kreiraju na slučajnim
pozicijama. Jedna runda traje sve dok na bojnom polju ne ostane ili
jedan robot ili jedna ekipa. Za vreme izvršavanja, roboti unutar
jednog tima mogu da razmenjuju poruke.
4.1.2. Robocode API
U ovom poglavlju opisan je skup klasa Robocode API-ja. Na slici 4.6
prikazan je dijagram osnovnih klasa.
Da bi se kreirao inteligentni agent potrebno je naslediti klasu Robot
ili klasu AdvancedRobot i redefinisati metodu run. Prilikom pokretanja
simulacije, run metode agenata, koji učestvuju u takmičenju,
izvršavaju se u odvojenim procesima.
Svaki robot ima funkcije kojima upravlja kretanjem, i opremljen je sa
radarom (senzor za osmatranje okoline) i topom.
89

Inteligentni agenti










































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































W
i
n
E
v
e
n
t
_
A
d
v
a
n
c
e
d
R
a
d
i
a
n
s
R
o
b
o
t
_
A
d
v
a
n
c
e
d
R
o
b
o
t
_
R
o
b
o
t
A
d
v
a
n
c
e
d
R
o
b
o
t
B
u
l
l
e
t
B
u
l
l
e
t
H
i
t
B
u
l
l
e
t
E
v
e
n
t
B
u
l
l
e
t
H
i
t
E
v
e
n
t
B
u
l
l
e
t
M
i
s
s
e
d
E
v
e
n
t
C
o
n
d
i
t
i
o
n
C
u
s
t
o
m
E
v
e
n
t
D
e
a
t
h
E
v
e
n
t
«
i
n
t
e
r
f
a
c
e
»
D
r
o
i
d
E
v
e
n
t
G
u
n
T
u
r
n
C
o
m
p
l
e
t
e
C
o
n
d
i
t
i
o
n
H
i
t
B
y
B
u
l
l
e
t
E
v
e
n
t
H
i
t
R
o
b
o
t
E
v
e
n
t
H
i
t
W
a
l
l
E
v
e
n
t
M
e
s
s
a
g
e
E
v
e
n
t
M
o
v
e
C
o
m
p
l
e
t
e
C
o
n
d
i
t
i
o
n
R
a
d
a
r
T
u
r
n
C
o
m
p
l
e
t
e
C
o
n
d
i
t
i
o
n
R
o
b
o
c
o
d
e
R
o
b
o
c
o
d
e
F
i
l
e
O
u
t
p
u
t
S
t
r
e
a
m
R
o
b
o
c
o
d
e
F
i
l
e
W
r
i
t
e
r
R
o
b
o
t
R
o
b
o
t
D
e
a
t
h
E
v
e
n
t
S
c
a
n
n
e
d
R
o
b
o
t
E
v
e
n
t
S
k
i
p
p
e
d
T
u
r
n
E
v
e
n
t
T
e
a
m
R
o
b
o
t
T
u
r
n
C
o
m
p
l
e
t
e
C
o
n
d
i
t
i
o
n
+
r
o
b
o
t
+
r
o
b
o
t
+
r
o
b
o
t
+
r
o
b
o
t
+
b
u
l
l
e
t
+
h
i
t
B
u
l
l
e
t
+
b
u
l
l
e
t
+
b
u
l
l
e
t
+
c
o
n
d
i
t
i
o
n
+
b
u
l
l
e
t
Slika 4.3 Dijagram klasa Robocode API-ja

90
Inteligentni agenti
Vrlo jednostavan robot koji se kreće po ivicama kvadrata stranice 50
(jedinica mere rastojanja u prostoru) opisan je klasom Robot1.java.

package ovi;
import robocode.*;

public class Robot1 extends Robot{
public void run() {
while(true) {
ahead(50);
turnLeft(90);
ahead(50);
turnLeft(90);
ahead(50);
turnLeft(90);
}
}
}
Metoda ahead koristi se za kretanje unapred, ulazni prametar
opisuje dužinu puta koji se prelazi. U slučaju da robot pre završetka
puta naiđe na prepreku metoda se završava i nastavlja se sa
izvršavanjem prve sledeće metode. Metoda turnLeft koristi se za
pomeranje u levo za ugao (u stepenima) koji se prosledi kao ulazni
parametar. Metode back i turnRight koriste se za kreanje unazad i
pomeranje u desno na isti način kao metode ahead i turnLeft.
Robot koji pomera radar i top u desno prikazan je klasom Robot2.
Metoda onScannedRobot poziva se u slučaju da je radar opazio
drugog robota. Metodom fire se puca, ulazni parametar je
intenzitet paljbe.

package ovi;
import robocode.*;
public class Robot2 extends Robot {
public void run() {
while(true) {
turnGunRight(360);
}
}
public void onScannedRobot(ScannedRobotEvent e) {
fire(1);
}
}

91

Inteligentni agenti
Ovo su bila dva jednostavna primera na kojima su ilustrovane
mogućnosti kretanja robota, pomeranja senzora i izvršnih uređaja.
Primer robota koji najkraćim putem ide prema donjem levom uglu
prikazan je klasom Robot5.java

package ovi;
import robocode.*;

public class Robot5 extends Robot {

public void run() {
while(true) {
double heading = getHeading();
double x = getX();
double y = getY();
double l1 = Math.atan(x/y)*180/Math.PI;
turnRight(180-heading+l1);
ahead(10);
}
}
}
U ovom primeru prikazano je i nekoliko veoma važnih veličina koji
opisuju stanje robota:
• getHeading() – ugao kretanja u odnosu na vrh bojnog polja
• getX() i getY() – apsolutna pozicija, donji levi ugao je 0,0

heading
Y
getX()
X
getY()

Slika Osnovne veličine koje opisuju stanje robota
92
Inteligentni agenti
Pored metoda za kretanje i proveru stanja postoje i metode koje se
pozivaju kao rezultat određenog događaja. Jedan od takvih događaja
je i događaj kad radar (senzor) primeti drugog robota
(ScannedRobotEvent). Tom prilikom poziva se metoda onScannedRobot
u kojoj je moguće napisati reakciju na događaj. Na primer, možemo
odrediti apsolutnu poziciju robota. ScannedRobotEvent pored
relativnog ugla između radara i smera kretanja sadrži i informaciju o
udaljenosti, brzini drugog robota itd.

package ovi;
import robocode.*;

public class Robot3 extends Robot {
public void run() {
double heading = getHeading();
turnLeft(heading);
while(true) {
turnGunRight(20);
}
}
public void onScannedRobot(ScannedRobotEvent e) {
double eX = getX()+ e.getDistance()*
Math.sin(getGunHeading()*Math.PI/180);
double eY = getY()+e.getDistance()*
Math.cos((360-getGunHeading())*Math.PI/180);
double eVelocity = e.getVelocity();
double eHeading = e.getHeading();
System.out.println(getTime()+
" scanned robot("+eX+", "+eY+")");
turnRight(e.getBearing());
fire(1);
if(e.getDistance()>140)
ahead(1);
}
}
Vežba 1. Na osnovu prethodno opisanih metoda proširite metodu
onScannedRobot tako da se u njoj procenjuje naredni položaj
skeniranog robota. Nakon toga napišite robota koji oponaša tuđe
kretanje. Pokušajte da koristite neku od tehnika računarske
inteligencije.
Vežba 2. Napišite robota koji prilikom pucanja uzima u obzir i
preticanje, voditi računa o udaljenosti, brzini i smeru kretanja
drugog robota.
93

Inteligentni agenti
Jedan od veoma važnih proces u projektovanju agenata jeste
koordinacija delovanja. Koordinacija se postiže komunikacijom koja
se odvija između pojedinih agenata tima ili istovremeno svih.
U Robocode okruženju klasom TeamRobot opisan je robot koji pored
osobina običnog robota ima i metode slanja i primanja poruka.
Naime poruka može u svakom trenutku da se pošalje bilo kojem
agentu ekipe, metodom sendMessage, dok se primanje poruka
obrađuje kao događaj onMessageReceived. U nastavku je dat primer
dve klase koje pripadaju istom timu.

Robot61.java

package ovi;
import robocode.*;

public class Robot61 extends TeamRobot {

public void run() {
while(true) {
ahead(10);
try {
sendMessage("ovi.Robot62",
"SOS "+getX()+", "+getY());
}catch(Exception ex){}
}
}
}

Robot62.java

package ovi;
import robocode.*;
public class Robot62 extends TeamRobot{
public void run() {
while(true) {
ahead(10);
}
}
public void onMessageReceived(MessageEvent event) {
out.println(event.getSender() +
" poslao poruku: " + event.getMessage());
}
}
Robot Robot61 šalje poruke o svojoj poziciji svim objektima klase
ovi.Robot62. Robot ovi.Robot62 prihvata poruke i ispisuje ih na
standardnom izlazu.
94
Inteligentni agenti
Vežba 3. Implementirajte tim koji se sastoji od tri robota (1, 2 i 3).
Prvi (1) u početku emituje poruke o poziciji sastanka a druga dva (2,
3) po prijemu poruka kreću ka tom mestu. Po stizanju u blizinu
roboti javljaju robotu 1 da su stigli. Po pristizanju svi zajedno se
upućuju na mesto koje definiše agent 1.
Vežba 4. Implementirajte tim koji se sastoji od četiri robota. Dva
služe za osmatranje i ne pomeraju se. Njihovi radari stalno skeniraju
okolinu. Poruke o stanju okoline šalju robotima čiji je zadatak da se
kreću i pucaju prema neprijateljskim robotima. U slučaju uništenja
oba izviđačka robota jedan od preostalih pokretnih preuzima ulogu
izviđača.

95

Literatura
5. Literatura
[1] HTML 4.0 Reference,
http://www.w3.org/TR/REC-html40/
[2] Java Native Interface Specification, JDK 1.1.8 dokumentacija
[3] Java Server Pages, http://java.sun.com/products/jsp/
[4] Eckel, B., Thinking in Java, revision 9, August 1997.
[5] Extensible Markup Language (XML),
http://www.w3.org/TR/REC-xml
[6] Nauck, D., Klawon, F., Kruse, R., Neuro-Fuzzy Systems,
John Wiley& Sons, 1
[7] Russell S.J., Norvig P., Artificial Intelligence A modern
approach, Prentice-Hall Internatinoal, Inc.
97



99

Sadržaj
1. 2. UVOD................................................................................................................3 REPREZENTACIJA ZNANJA......................................................................5 2.1. PREDIKATSKA LOGIKA ...............................................................................5 2.1.1. Teorijska osnova...............................................................................5 2.1.2. Softwerske tehnike ............................................................................5 2.1.3. Primeri i zadaci za vežbu ...............................................................12 2.2. NEURONSKE MREŽE .................................................................................23 2.2.1. Opšti model neuralnih mreža .........................................................23 2.2.2. Klasifikacija neuronskih mreža ......................................................28 2.2.3. Algoritmi za obučavanje neuronskih mreža ...................................29 2.3. FUZZY LOGIKA .........................................................................................45 2.3.1. Fuzzy skupovi .................................................................................45 2.3.2. Reprezentacija znanja primenom fuzzy skupova ............................47 2.3.3. Zaključivanje u fuzzy logici ............................................................47 2.3.4. Rešavanje problema primenom fuzzy logike...................................48 3. TEHNIKE RASUĐIVANJA .........................................................................55 3.1. PRETRAŽIVANJE .......................................................................................55 3.1.1. Enumerativni algoritmi i optimizacioni algoritmi ..........................57 3.1.2. Genetski algoritmi ..........................................................................75 3.2. DEDUKCIJA ..............................................................................................75 3.2.1. Izračunavanje odgovora u predikatskoj logici ...............................75 4. INTELIGENTNI AGENTI ...........................................................................85 4.1. ROBOCODE...............................................................................................87 4.1.1. Osnovni delovi ROBOCODE okruženja.........................................87 4.1.2. Robocode API.................................................................................89 5. LITERATURA...............................................................................................97

.

Predgovor I .

.

automat prelaza stanja (6) Fuzzy logika uvod inverzno klatno fuzzy pretraživanje 3 . lavirint. Uvod Redosled: (22) Predikatska logika uvod sintaksa lista stablo graf majmun i banana izračunavanje odgovora u Predikatskoj logici (stablo pretraživanja) (12) Pretrage uvod prvi u dubinu. bidirekciona pretraga A* primeri: slagalica. crna kutija. funkcija. prvi u širinu iterativni prvi u širinu.Uvod 1. majmun i banana (6) Genetski algoritmi uvod primer: određivanja minimuma funkcije određivanje maksimuma funkcije (10) Neuronske mreže uvod najprostiji oblik (pseudo kompetitivno obučavanje) generalisano delta pravilo primeri: prepoznavanje slova. skakač. 7 segmentni displej.

.

Predikatska logika 2.2. Reprezentacija znanja 2. jasna). otac(petar. Softwerske tehnike PROLOG (PROgraming in LOGic) je programski jezik kojim je moguće opisati i rešiti određen problem na način opisan predikatskom logikom.1.1. Teorijska osnova 2. Na primer baza znanja o porodičnim vezama grafički predstavljena na slici 2. petar).Reprezentacija znanja 2. otac(toma. toma).1 Primer rodbinskih veza programski se opisuje na sledeći način: otac(ivan. Slika 2.1.1. Baza znanja je osnova za izvođenje zaključaka i sastoji se od činjenica i pravila koji predstavljaju strukturu u kojoj figurišu relacije. otac(petar.1. marko). 5 .

U PROLOG-u se zbog preglednijeg pisanja umesto uobičajenog načina pisanja (kao relacija).2. X). Na primer. Arg2. Y):-majka(Y. jasna). Predikat može da ima proizvoljno mnogo argumenata.Reprezentacija znanja majka(mara. Arg2. Y):-otac(Y.1 veza između objekata ivan i tome je otac i čita se: «Ivan je otac Tomi». Arg3.... X).. Program 2. ako je ivan tomin otac. Program 2. «Ko je tomin otac?» ili «Od koga je stariji adam?». pretpostavka). voli(X. Na primer. Program 2. . odnosno iz relacije otac može se «izvesti» relacija «dete»: dete(X.) Gde predikat predstavlja ime relacije koja povezuje objekte Arg1. Na primer: pravilo(zaključak. Primer korišćenja promenljivih bilo koga a drugom da svako voli samog sebe. marko).1 Roditeljske veze Prethodno opisan primer predstavlja reprezentaciju znanja u obliku skupa činjenica. opisuju se na sledeći način: predikat(Arg1. Činjenice su gradivni elementi svake baze znanja i uvek predstavljaju tačan iskaz. Naravno cilj ovakve reprezentacije je da pored opisa posmatranog sistema budemo u mogućnosti da izvodimo određene zaključke. . Čovek pored skupa činjenica u zaključivanju barata i određenim skupom pravila. majka(nina. X).. U programu 2. pravila definišu na specijalan način: 6 . stariji(adam.3 Primer definisanja pravila Drugim rečima pravilo predstavlja specijalnu relaciju koja povezuje zaključak i pretpostavku. dete(X. X). majka(nina. onda je toma ivanovo dete. Arg3. Na primer. Pored konstanti a to su u ovom primeru ivan i toma moguće je koristiti i promenljive. U ovom primeru prvom činjenicom rečeno je da je adam stariji od Znači korišćenjem činjenica u mogućnosti smo da na jednostavan način predstavimo znanje o posmatranom problemu. toma).

Reprezentacija znanja
zaključak :- pretpostavka.

Pravila se interpretiraju tako što se proveri tačnost pretpostavke a potom na osnovu nje izvodi se zaključak ili može da se kaže da ako je tačna pretpostavka onda je tačan i zaključak. U PROLOG-u se na ravnopravan način mogu koristi dva načina zapisa infiksan i postfiksan. Kod infiksnog načina zapisa (a) relacija se navodi između objekata. Samim tim infiksan način moguće je koristiti samo u relacijama između dva objekta. Postfiksnim načinom zapisa (b) prvo navodimo relaciju pa potom objekte. a) ivan otac toma. b) otac(ivan, toma). Infiksne relacije moraju se posebno navesti kako bi ih PROLOG prevodilac mogao interpretirati. Primerom 2.4definisano je pravilo roditelj koji kaže «X je Y-u roditelj ako je X Y-u majka» pored ovoga takođe važi pravilo «X je Y-u roditelj ako je X Y-u otac».
roditelj(X, Y):- majka(X, Y). roditelj(X, Y):- otac(X, Y).

Program 2.4 Primer pravila Drugim rečima ova dva pravila mogu da se opišu jednim koji kaže «X je Y-u roditelj ako je X Y-u majka ili je X Y-u otac». U PROLOG-u se to opisuje na sledeći način:
roditelj(X, Y):- majka(X, Y); otac(X, Y).

Program 2.5 Kombinacija više činjenica u jednom pravilu U ovom iskazu ; predstavlja logički operator ILI. U slučaju da pravilo u delu pretpostavke sadrži dve činjenice koje istovremeno moraju da budu zadovoljene one se razdvajaju znakom , koji predstavlja logički operator I. Na primer,
deda(X, Y) :- otac(X, Z), roditelj(Z, Y). sestra(X, Y):- roditelj(O, X), majka(O, Y), pol(Y, z), različiti(X, Y). predak(X, Y):- roditelj(X, Y). predak(X, Y):- roditelj(X, Z), roditelj(Z, Y).

7

Reprezentacija znanja
predak(X, Y):- roditelj(X,Z),roditelj(Z,W), roditelj(W,X).

Program 2.6 Logički operator I U prethodnim primerima pokazana je situacija u kojoj definišemo pravilo kombinacijom više drugih pravila. Takođe je moguće definisati pravilo i rekurzivno:
predak(X, Y):-roditelj(X, Y). predak(X, Y):-roditelj(X, Z), predak(Z, Y).

Program 2.7 Rekurzivna pravila Ciljevi ili upiti su pored činjenica i pravila veoma važan deo programskoj jezika PROLOG. Sam mehanizam za izračunavanje odgovora biće obrađen u posebnom poglavlju. Postoje dve vrste upita: upiti koji kao odgovor imaju «Ko?» ili «Šta?» i upiti koji odgovaraju na pitanje «Da li?». Ciljevi ili upiti postavljaju se u posebnom prozoru i to na sledeći način:
?-elementi_upita.

Recimo pitanje «Ко је Markov otac?» u PROLOG-u bismo napisali:
?-otac(X, marko). X=toma

ili pitanje «Da li je Toma Markov otac?» napisali bismo ovako:
?-otac(toma, marko). Yes

Odgovor No u PROLOG-u se interpretira kao nemogućnost donošenja pozitivnog zaključka. Odnosno, pomoću trenutne baze znanja interpreter nije u mogućnosti da izvede pozitivan zaključak. Kao odgovor na postavljano pitanje moguće je dobiti i više odgovora, recimo na pitanje: ?-otac(X, _). Dobićemo odgovor:
X=ivan ->; X=toma ->; X=petar ->; No

Gde No znači «Nema više pozitivnih odgovora!». 8

Reprezentacija znanja

Sintaksa programskog jezika PROLOG
Na slici 2.2 prikazana je podela svih elemenata programskog jezika PROLOG.

Slika 2.2 Podela osnovnih elemenata PROLOG-a Atom je svaki niz simbola, cifara i «_» koji počinje malim slovom, ili je to niz posebnih znakova ili je to bilo koji niz znakova koji se nalazi unutar navodnika. Brojevi su niz cifara koji počinje predznakom i ne razlikuju se posebno celi brojevi od realnih. promenljive su neke veličine koje se tokom izvršavanja menjaju. One se imenuju nizom znakova koji počinje velikim slovom ili specijalnim znakom _. Specijalan slučaj je _ promenljiva koja predstavlja takozvanu anonimnu promenljivu, odnosno vrednost ove promenljive nam nije od interesa. Struktura je složen term koji se formira vezivanjem nekoliko jednostavnijih termova. Funktor je atom koji objedinjuje strukturu u jedinstvenu celinu. Strukture se razlikuju po imenu i broju argumenata. Specijalan slučaj strukture je lista koja se zbog čestog korišćenja i opisuje na poseban način. Pored listi veoma korisna struktura je binarno stablo.

Liste
Lista je struktura koja je ili prazna ili se sastoji od glave i repa. Prazna lista opisuje se na sledeći način: []. Glava i rep se u listi odvajaju simbolom | ([g|[]]). U nastavku je dato nekoliko predikata kojim se opisuju osnovne operacije sa listama. Vrlo često se lista 9

element(X. OL). [Y|R]. [Y|R]):-element(X. S. c. OL. f) Dodavanje elementa u listu ubaci(X. d]. 2. X). P):-permutacija(L. gde je a glava liste. [X]. P). Yr). pripoji(Yr. [X|Z]):-pripoji(R. [X|R]. obrni([]. obrni([X|Xr]. d) Obrtanje liste obrni([]. L1. d] je rep liste. c) Spajanje dve liste pripoji([]. uredjena([X]). Y|R]):-X=<Y. 1. Y. 1. 2. (Prvog u listi.) brisi(X. []. []). Y). Y):-obrni(Xr. OL). OL):-obrni(L.Reprezentacija znanja prikazuje kao [a. OL). b. SL):-permutacija(L. obrni([G|R]. R1). obrni1(L. VL. X. a lista [b. R. b) Predikat kojim se proverava da li se neki element nalazi u listi. h) Podlista 10 . element(X. sortiraj(L. lista([]). е) Brisanje elemenata iz liste. OL):-obrni(R. uredjena([Y|R]). ubaci(X. g) Permutacija elemenata liste i sortiranje permutacija([]. [X|_]). pripoji([X|R]. [G|S]. uredjena([X. uredjena(SL). R). a) Predikat kojim se proverava da li je neka struktura lista. SL). lista(G|R):-lista(R). brisi(X. [Y|R1]):-brisi(X. permutacija([X|L]. []). c. VL):-brisi(X. L. L1). Z). L). R). Y.

p). L):-pripoji(L1. D). b_stablo(st(X. st(b. a) Predikat kojim se proverava da li je struktura binarno stablo.4 Slika 2. Binarno stablo prikazano na slici 2. element(X. S. c) Predikat kojim se proverava da li se element nalazi u uređenom binarnom stablu. 11 . pripoji(L2.Reprezentacija znanja podlista(S. D)). st(d. L3. p.5 Binarno stablo u PROLOG-u se predstavlja na sledeći način: st(a. L. L2). L). p). b_stablo(p). L. p. Sledi nekoliko najvažnijih predikata koji opisuju binarno stablo i operacije nad njim. D)):-b_stablo(L). Binarno stablo Binarno stablo je struktura koja je ili prazna ili ima glavu i dva podstabla: levo i desno. st(f. st(S. b_stablo(D). L. p)). element(X. Specijalan slučaj binarnog stabla je uređeno binarno stablo u kojem su elementi u levom podstablu manji od glave a elementi u desnom pod stablu su veći od glave. p. p)). st(e. b) Predikat kojim se proverava da li se element nalazi u binarnom stablu. st(X. L). element(X. D)):-element(X. st(c.

L. Ym. L. st(Y. dodaj(X. L. p. S). st(Y. brisi(X. brisi(X. p). f) Predikat za konverziju liste u uređeno binarno stablo lista_stablo([]. st(X. brisi(X.1. st(G. L. D1)):-X>Y. p. L1. L. 12 . st(G. Kako bi se u predikatskoj logici prikazao sledeći niz rečenica? Jasna je stara 15 godina. S1. element(X. e) Predikat kojim se briše element iz binarnog stabla. L. dodaj(X. p. D). element(X. dodaj(X. L. D)). L1). D1)):-X=>G. stablo_lista(S. st(X. D). D)):-najveci(L. Primeri i zadaci za vežbu Zadatak 1. najveci(st(Y. prijateljica(jasna. stablo_lista(st(G. Ym. L). D). najveci(st(Ym. st(X. Ona stanuje u kući. st(Y. D1). st(Ym. L). Rez)):-stablo_lista(L. st(Y. D)):-X<G. Rez). element(X. prijateljica(jasna. D)):-X<G. S1). D. marija). element(X. D1). st(Y. 2. D). brisi(X. Jasnin otac zove se Marko a majka Katarina. L. D)):-X<Y. jasna). D1). st(G. S):-lista_stablo(R.3. D. g) Predikat za konverziju binarnog stabla u listu. Njezine prijateljice su Milena i Marija. L. st(G. 15). L. D1). st(X. L. L. D). p)). D)):-X=>G. kuca). []). D). L. L1). D1)):-najveci(D. L. stablo_lista(D. L1). starost(jasna. L1). L1. brisi(X. D). SL):-lista_stablo(L. pripoji(L1. stablo_lista(p. st(G. stanuje(jasna. L. otac(marko. lista_stablo([G|R]. Ym. S). L1. brisi(X. milena). L. p). dodaj(G. d) Predikat kojim se dodaje element u uređeno binarno stablo dodaj(X.Reprezentacija znanja element(X. [G|D1]. D). dodaj(X. Ym. D). h) Sortiranje liste sortiraj(L. Sl). D). st(G.

Zadatak 3. rodjen(28. radnik(marko. pobedio(pera. pobedio(X. Radnik Marko rođen je 28. Napisati niz činjenica i pravila koji opisuju sledeću situaciju. faktorijel(N. _. X. radnik(milan. 4. pobedio(pera. F):-N1 is N-1. tenis). _). 2. goran.3. pikado). faktorijel(N1.exe) programa pred vama se pojavljuje glavni prozor PROLOG interpretera. godine i po zanimanju je stolar.4. milan. Zadatak 2. Nakon pokretanja (plwin. 1945). godine i po zanimanju je vozač. SWI PROLOG interpreter se pokreće kao standardna windows aplikacija. stolar). izgubio(marko. jasna). Z). Pera je pobedio Miku u tenisu. a Milana u fudbalu.Reprezentacija znanja majka(katarina. Z):-izgubio(Y. U programskom jeziku PROLOG definisati faktorijel. 1970). vozač). rodjen(19. F is N*F1. faktorijel(0. Pobednik je osoba koja je bilo koga pobedila u bilo kojoj disciplini.1).1945. Milan je takođe radnik rođen 19. Y. F1). pobednik(X):-pobedio(X.1970. 3. fudbal). 13 . Marko je izgubio od Gorana u pikadu. Vežba 1. Upoznavanje sa SWI PROLOG interpreterom 1. mika.

. Da bi se PROLOG program preveo u internu formu i smestio u radnu bazu znanja..’.automatsku proveru sintaksne ispravnosti ..prikaz ključnih izraza u različitim bojama 14 . Pored ovog načina moguće je program naisati i snimiti bilo kojim standardnim editorom tekstualnih datoteka.. Interni editor pored standardnih operacija sa tekstualnim datotekama omogućava: .’.'. 3.Reprezentacija znanja Neposredno iza znaka '?-' postavljaju se upiti. u tom slučaju datoteka se otvara pozivanjem akcije ‘File>Edit. i nakon toga u internom editoru unosimo činjenice i pravila. 4. potrebno je konsultovati sadržaj datoteke u kojoj se program nalazi.. Novi program pišemo tako što prvo izabiramo opciju 'File->New.. Ova operacija se obavlja pozivanjem akcije ‘File->Consult. Nakon čega je neophodno pronaći datoteku na način standardan Windows okruženju.

roditelj(X. predak1(Y.prikazan na slici 2. Vratite se u editorski prozor otkucajte predikate za roditelje i sestru. ekstenzija datoteke bi trebala da bude .osvežavanje interne memorije PROLOG interpretera (Ctrl+c Ctrl+b) 5. Snimite program i osvežite radnu memoriju interpretera. Napišite predikat predak1: predak1(X. predak3 (u kojem je izmenjen redosled ciljeva u drugoj klauzuli) i predak4 (u kojem je 15 . Y):. 9. Na osnovu ovog predikata napišite predikate predak2 (u kojem je zamenjen redosled prve i druge klauzule).roditelj(X. se unosi je model porodičnog Slika 2. Za probu. ili ako ste koristili interni editor Ctrl+c Ctrl+b).4. predak1(X. snimite datoteku u svoj direktorijum.pl i osvežite internu memoriju PROLOG interpretera (File->Consult. Z). Prvi program koji stabla.. U slučaju da se program učitan u internoj memoriji menja bilo internim editorom bilo klasičnim editorima neophodno je ponovno ga učitati u radnu memoriju interpretera 'File Reload modified files' 6. Y). Y):.4 Model porodičnog stabla Po unošenju činjenica. Po ugledu na predikat sestra napišite predikat koji proverava da li je osoba X brat osobi Y.Reprezentacija znanja . 7. Y). Ako je sve u redu (program sintaksno ispravan i nalazi se u internoj memoriji) u glavnom prozoru možete da počnete sa unošenjem upita. upitajte 'Ko je kome otac?' i 'Ko je kome majka?' 8. Isprobajte kako rade predikati roditelj i sestra.

ili ?-element(s. Napišite predikat koji proverava da li je data struktura lista. Isprobajte ove predikate. s. 4. Snimite program! Vežba 2. 5. Proširite porodično stablo tako da dobijete veze ujak.Reprezentacija znanja izmenjen redosled i ciljeva i klauzula). Rad sa listama 1. h]). Proverite napisane programe. g]). Proverite korektnost napisanih odgovarajućih upita u glavnom prozoru. f. U nastavku je dat pregled osnovnih operacija nad ovakvom strukturom. d. liste. 12. Napišite predikat koji proverava da li se dati element nalazi u listi. 6. s. f. 9. g. Kako se ponašaju? 11. Proverite predikate koje ste napisali npr. [a. brat od ujaka i sestra od strica. Dopunite pravila pravilima koji će proveravati pomenute veze. 2. postoji i složenija struktura binarno stablo. Rad sa binarnim stablom Pored osnovne složenije strukture podataka. d. 7. 1. Snimite program! predikata postavljanjem Vežba 3. Napišite predikat koji spaja dve liste. Napišite predikate koji obrću listu i brišu element iz liste. Snimite program! 8.lista([a. tetka. 10. Brisanje elementa iz liste uraditi na oba načina. Napišite program za sortiranje brojeva pomoću permutacije i sortiranje Quick sort algoritmom. ?. 3. Binarno stablo se (podsećanja radi) definiše ovako: 16 . pomoću predikata pripoji i bez njega.

Napišite predikat (element_s(X. S) ) koji proverava da li je X element binarnog stabla S. Y. X je element desnog podstabla 4. S)) koji pronalazi elemente X binarnog stabla S koji su listovi (nemaju ni desno ni levo podstablo) 9. 8. 10. X je element koji se dodaje. Implementirajte predikate (brisi_s(X. Implementirajte predikat ( sortiraj(Lista. levog i desnog podstabla. 7. Prazno binarno stablo je atom p b. 2. S. X isto što i Element u strukturi ili b. X je element binarnog stabla ako je: a. D)) za dodavanje elementa u binarno stablo koje je uređeno tako da se u levom podstablu nalaze elementi koji su strogo manji od Element-a. Implementirajte predikate (uvrsti_s(X. X je element levog podstabla ili c. Razmislite i pokušajte da opišete stablo sa proizvoljnim brojem neposrednih potomaka.Reprezentacija znanja a. 3. Na osnovu ove definicije napišite predikat (b_stablo(X)) koji proverava da li promenljiva X ima strukturu binarnog stabla. D)) za brisanje elementa X iz binarnog stabla S a da posle brisanja dobijeno stablo D ostane uređeno. Koristite rekurziju. Napišite predikat (listovi_s(X. struktura direktorijuma kod file sistema organizovana je kao neuređeno (ne postoji matematička formula po kojoj raspoređujemo elemente u 17 . Z)) koji spaja dva binarna stabla X i Y tako da rezultujuće binarno stablo Z bude uređeno. S. Napišite predikat (spoji_s(X. Recimo. 5. 6. Binarno stablo je struktura koja se sastoji od: Elementa. S je stablo u koje se dodaje a D je stablo koje se dobije kao rezultat. Kod binarnog stabla postoje dva. Rez) koji za sortiranje koristi konverziju liste u uređeno binarno stablo i konverziju iz stabla u listu.

mudro je da zapišemo podatke o vezama između tačaka. 4 c f d e a b a 2 c b 1 2 d 1 f e 2 1 g 4 g Slika 2. Pošto kasniji zadatak zahteva od nas da pronađemo put između dve tačke na grafu.b). proveravanje da li se zadati element nalazi u stablu. sračunava i cenu puta između dve tačke. Za zapisivanje podataka možemo odabrati više različitih strategija. Za ovakve podatke. granama ili oba podatka. što znači da ako 18 . Podatke. Ako vam je jasno kako bi izgledala takva struktura pokušaje da napišete predikate za proveravanje da li je data struktura stablo. možemo zapisati ovako: veza(a. Napisati predikat koji pronalazi i ispisuje put između dve zadate tačke u grafu. Vežba 6. uz pronalaženje puta. Modifikovati podatke za slučaj da prelazak iz jedne u drugu tačku u grafu ima neku cenu.Reprezentacija znanja poddirektorijume(podstabla)). brisanje elementa i brisanje čitavog podstabla. Sledeći problem koji treba razmotriti je činjenica da je graf neorijentisan. Ova odluka nam olakšava i kasniju modifikaciju – ubacivanje cena.5 Diskusija: Podatke o grafu smestiti u bazu podataka tako da rešavanje sledećeg zadatka bude olakšano. Rad sa grafovima Zadatak: Zadat je neorijentisan graf. promeniti program tako da. što znači da postoji veza između tačaka a i b. dodavanje elementa u odgovarajuće podstablo. Možemo pohraniti podatke o tačkama. dakle. Smestiti relevantne podatke o grafu u bazu znanja PROLOG-a.

Y):-veza(X. Cilj. Put.Reprezentacija znanja možemo da dođemo od tačke a do b. Ovaj problem možemo rešiti tako što ćemo ubaciti dodatne činjenice tipa: veza(b. Put). Na ovaj način možemo da pređemo sve puteve između dve zadate tačke.a). Ova neugodnost se može rešiti tako što ćemo. Put):-predji1(Start. možete utvrditi da program povremeno upada u beskonačnu petlju. proveriti da li smo već prošli kroz tačkukoju smo pronašli predikatom povezani. Put. Međutim elegantnije rešenje je da napišemo dodatni predikat koji glasi ovako: povezani(X. Međutim. predji1(Start. X).veza(Y. Cilj. Taj podcilj glasi (predikat element napišite sami): not element(X. Cilj.4). modifikujte predikat povezani. moguće su dva rešenja. [X|Predjeno]). To je moguće postići ovakvim klauzulama: veza(a. putevi koje pronalazi ovakav program obrnuti su u odnosu na zadate tačke (tačke su poređane od ciljne do početne tačke).X). [Start]).Y). 19 . Na osnovu ovog primera. Predjeno):-povezani(Start. pre rekurzivnog poziva. Put. Cilj. a drugi je elegantnije i pokušajte da ga pronađete. onda možemo i od tačke b do tače a. Jedno podrazumeva ubacivanjepredikata obrni (koji obrće zatatu listu) na pogodno mesto. Ovako smo rešili prvi deo zadatka.b. Vodite računa o tome da je potrebno zadati i novu promenjljivu ukojoj će biti smeštena cena puta između dve tačke. Predjeno). predji1(Cilj. Da bi se dobio put koji nije obrnut. i predikate koji traže put između tačaka. Predikat koji poziva predji1 i omogućuje prikazivanje rezultata izgleda ovako: put(Start. Put. Ako probate ovaj program na nekoliko primera. Drugi deo zadatka zahteva da proširite podatke o grafu cenama. Cilj. predji1(X.

yfx. koji. Na primer. tablični izvodi). izvod od sin(g(x)) je g'(x)cos(g(x)). Izvod stepenovane promenljive tada izgleda ovako : izvod(U^N. Du). izvod(U. odmah smo primenili kombinaciju tabličnog izvoda i formule za nalaženje prvog izvoda složene funkcie. Prvi izvodi elementarnih matematičkih izraza lako se nalaze korišcenjem tabele (to su tzv. Zato je potrebno definisati i terminalni uslov. Nalaze prvi izvod funkcije f(x) Nalaze diferencijal funkcije koja zavisi od jedne ili više promenljivih po zadatoj promenljivoj. Kao što možete da primetite. ^). a kao drugi argument vraća prvi izvod te funkcije. Du). DISKUSIJA: Diferenciranje matematičkih izraza je problem koji se izuzetno lako rešava korišcenjem PROLOG-a. U PROLOGu se ova relacija može napisati ovako: izvod(sin(U). 1). U PROLOG-u ovakvu tabelu možemo vrlo jednostavno implementirati . 20 . Du*cos(U)):-izvod (U.Reprezentacija znanja Vežba 5 Diferenciranje matematičkih izraza ZADATAK: Napisati predikate u programskom jeziku PROLOG. Da bi mogli da tražimo izvode polinoma potrebno je na odgovarajući način definisati operaciju stepenovanja. valja primetiti da je klauzula koju smo gore naveli tipičan primer leve rekurzije. Za operator stepenovanja odabiramo simbol ^. Ekvivalenti ovih iskaza u PROLOGu glase: izvod(x. koji je 0. 0):-integer(N). :-op(200. Takođe. i izvod konstante. Postoje dva slučaja u kojima se direktno nalazi prvi izvod. N1 is N-1. not N=0. Vidimo da se radi o rekurzivnoj relaciji koja kao prvi argument prima funkciju koju treba diferencirati. koji je 1. i tako smo obezbedili da nam predikat automatski radi sa složenim funkcijama. N*U^N1*Du):-integer(N). To su izvod od promenljive x na prvi stepen. najviše zahvaljujuci jakoj podršci simboličkoj obradi. izvod(N.

integer(B). Klauzula za izvod zbira izgleda ovako: izvod(U+V. pored funkcije koju treba diferencirati i promenljive u koju se smešta prvi izvod. Ovaj predikat treba da funkciju više promenljivih izdiferencira po zadatoj promenljivoj. 0):-!. Isprobajte predikat. !. !. izvod(V. razlike. Du+Dv):-izvod(U. REŠENJE:Predikat treba da ima nekoliko logičkih celina u okviru istog predikata. sr(A+B. Ove klauzule treba da reaguju na sledeće situacije: pojavu atoma u izrazu. C is A+B. 'Majmun i banana' ZADATAK: Napisati program kojim se rešava problem 'Majmun i banana'. proizvoda i količnika funkcija. ne moraju biti komutativne kada uz pomoć PROLOGa analizirate izraz. Sada napišite predikat koji. Obratite pažnju na izvod funkcije sa negativnim predznakom. % Atomska vrednost sr(A*0. A):-atomic(A). Obratite pažnju na činjenicu da matematičke operacije koje su komutativne. Prva logička celina su klauzule koje opisuju terminalni uslov za rekurziju.Reprezentacija znanja Postoje još i formule za računanje izvoda zbira. ali data u obliku koji nije pogodan za ljudsko korišcenje . Sledeća celina su klauzule koje deluju kada naiđemo na deo izraza u kome postoji mogućnost uprošćavanja. Sigurno ste primetili da je rezultat rada ovih predikata funkcija koja jeste prvi izvod. Primeri. pojavu računske operacije množenja nulom i stepenovanja izraza nulom i na pojavu dva broja između kojih stoji operator. sr(A. C):-integer(A). sredina. Majmun treba da u prostoriji pronađe način kako da se dočepa banane koja se nalazi okačena na U prostoriji postoje stri mesta na kojima nesto moye da se nalazi: vrata. ali je potrebno i dalje 21 . Du). dif(F. Ovi slučajevi predstavljaju kraj jednog ciklusa uprošcavanja. prozor. Vežba 6. Sami napišite klauzule koje nedostaju. Fprim. Prom). prima i promenljivu po kojoj treba diferencirati funkciju. Dv).

X):-sr(X. Neke od ovih situacija su množenje jedinicom. sr(B. X). sr(A+0. A1*B1):-sr(A. Zato je potrebno ponoviti uprošćavanje nekoliko puta. utvrdićete da program ne reaguje na neke prilično očigledne situacije. Međutim. Primetićete da ni ovako napisan program nije u stanju da uprosti sve moguće izraze. Primeri: sr(A*B. B1). sabiranje sa nulom. Y). Međutim. -A1):-sr(A. A1). A1):-sr(A. sabiranje sa nulom. Program sastavljen po ovim uputstvima bi trebalo da bude u stanju da uprosti neke specijalne slučajeve izraza. sredi(Y1. Drugi način je rekurzivno pozivanje predikata sr sve dok ne dobijemo dva puta isti rezultat. Ovu ideju možemo da realizujemo fiksnim brojem poziva predikata sr.Reprezentacija znanja eventualno uprošćavanje. sr(A+B. Y1). Treća grupa klauzula je tu da omogući dalju analizu i uprošćavanje izraza. sr(B. A1). A1+B1):-sr(A. posle nekoliko testova. Ovakvo ponašanje je uslovljeno načinom na koji PROLOG formira stablo pretraživanja. !. sredi(X. Ove klauzule deluju na delove izraza između kojih su operatori. Y):-sr(X. sredi(X. A1). ovaj program se može iskoristiti kao osnova za razvijanje komplikovanijih algoritama za uprošćavanje izraza. 22 . kao i stepenovanje jedinicom. sr(0-A. kao i stepenovanje jedinicom. A1). !. X \=Y1. B1).

1. učenje. Pored velike različitosti postoje i osobine koje su zajedničke za sve tipove neuronskih mreža.). Pod pojmom veštačka neuronska mreža podrazumevamo matematički. Slika XXX Građa motornog neurona Postoji velik broj klasa neuronskih mreža od kojih svaka ima svoje specifičnosti.Reprezentacija znanja 2.2. Neuron je osnovna strukturna i funkcionalna jedinica živčanog tkiva. asocijativne memorije itd. Neuronske mreže 2. Neuronske mreže koriste se za istraživanje i reprodukovanje ljudskih nervnih aktivnosti kao što su prepoznavanje i obrada govora i slike. Širok je spektar problema koji se rešavaju korišćenjem neuronskih mreža (na primer. 23 .2. pamćenje itd. Opšti model neuralnih mreža Na slici XX prikazana je građa motornog neurona iz prednjeg roga kičmene moždine. fizički ili računarski model strukture i aktivnosti živčanih tkiva. odnosno mozga. motorne aktivnosti. kombinatorna optimizacija. prepoznavanje oblika.

Funkcije pojedinih čvorova odgovaraju njihovom nazivu. reč ili koncept. Tako ulazni čvorovi služe da prime signale iz okoline i distribuiraju ih u unutrašnjost mreže. Na slici prikazan je model neurona kao procesnog elementa. Okolina u kojoj sistem treba funkcioniše. 6. postoje samo relativno jednostavni procesni elementi koji obavljaju jednostavne zadatke. Celokupan zadatak čvora je da primi signale sa ulaza (težinski izlazi susednih čvorova) i da na osnovu njih generišu izlazni signal. 7. 3. 4. 8. procesiraju ih i prenose do izlaznih čvorova koji ih konačno predaju okolini (izlaz). Skup procesnih elemenata (čvorovi). Izlazna funkcija za svaki čvor. Pravilo propagacije signala kroz mrežu. Postoje dva pristupa. Algoritam obučavanja. izlazne i skrivene. U neuronskoj mreži nema supervizora koji nadgleda i kontroliše rad celine. Distribuirani pristup se češće koristi.Reprezentacija znanja Svaku neuronsku mrežu karakteriše osam glavnih parametara: 1. Aktivaciona funkcija. Struktura povezanosti između čvorova. 2. U drugom (distribuirani pristup) čvor predstavlja samo jedno obeležje nekog objekta a kompletan objekata predstavljen je celinom mreže. Stanje aktivacije. Skriveni čvorovi te signale preuzimaju. 5. U1 W 1j ΣW U ij aktivacija Ij i Slika Model neurona kao procesnog elementa Tipičan model neuronskih mreža sadrži tri tipa čvorova: ulazne. Skriveni čvorovi nemaju vezu s 24 . Skup procesnih elemenata Da bismo formirali model neuronske mreže prvi korak je da definišemo skup čvorova i šta oni predstavljaju. U prvom (jedan čvor jedan koncept) čvor predstavlja neki objekat kao što je slovo.

U većini modela neuralnih mreža ta funkcija je f(x)=x. Takve funkcije zovu se "rampa funkcije" : f ( x ) = ( x − Θ ) ⋅ h( x − Θ ) gde je: Θ − prag aktivacije h − Hevisajdova funkcija. Stanje čvora može da poprimi vrednost iz definisanog skupa (npr. Broj i struktura veza jedan su od najznačajnijih elemenata neuralne mreže. 25 . Kad signal prelazi iz jednog čvora u drugi obično se množi težinom grane (veze w ji ) i tako utiče na stanje aktivacije odredišnog čvora. Topologije raznih neuralnih mreža određene su baš ovom osobinom. Izlazna funkcija koristi se za modeliranje nekih ograničenja recimo negativne vrednosti da stavi na 0 a vrednosti veće od maksimalne da postavi na maksimum. Procesni elementi biće označeni sa ui. Ta težina se može podešavati tokom vremena.broj procesnih elemenata mreže. i=1. Struktura povezanosti Čvorovi kod svih tipova neuralnih mreža međusobno su povezani brojnim vezama koje odgovaraju sinapsama. N. Promena vrednosti težina veza naziva se obučavanje. sem indirektno preko ulaznih i zlaznih čvorova. Svaka veza sadrži određenu težinu ( w ji ) koja je nosilac znanja i predstavlja jačinu veze između čvora u j i ui .Reprezentacija znanja okolinom. Stanje aktivacije Stanje aktivacije ai(t) predstavlja stanje i-tog procesnog elementa u trenutku t i odgovara stanju jezgra neurona. skup pozitivnih realnih brojeva). Izlazna funkcija Svakom procesnom elementu ui pridružuje se izlazna funkcija koju realizuje akson i koja preslikava stanje aktivacije u trenutku t u izlazni signal oi (t ) . N.

Aktivaciona funkcija Funkcija aktivacije predstavlja zakon po kojem se menja vrednost stanja aktivacije j-tog čvora i ima sledeći oblik: a j (t ) = F j (a j (t − 1). Kod neurona ga realizuju dendriti. Takve veze povećavaju nivo aktivacije čvoru u koji ulaze.Reprezentacija znanja Obučavanje mora da se obavlja tako da mreža nakon modifikacije daje bolje rezultate od neobučene mreže. Jedan od načina je da se informacije o vezama organizuju u matricu n x n gde je n ukupan broj čvorova. Tri najčešća tipa aktivacionih funkcija su: 26 . Postoje neuralne mreže (npr. Pravilo propagacije signala kroz mrežu Pravilo propagacije signala kroz mrežu predstavlja način kojim se vrši kombinacija izlaznih vrednosti čvorova i tako generiše ulaz u čvor. net j (t )) Funkcija perikaryon-a može da se posmatra kao funkcija aktivacije. ako je vrednost manja od nula tada se veza naziva inhibirajuća i smanjuje nivo aktivacije odredišnog čvora. U opštem slučaju to je funkcija koja zavisi od prethodnog stanja aktivacije kao i od trenutnog ulaza u čvor. Mogući su razni načini opisa veza. Funkcija je najčešće deterministička iako može da bude i stohastička. Hopfield-ova) kod kojih je ta matrica simetrična ili je trougaona (najčešći slučaj). U protivnom. Ako je vrednost težine veća od nula tada se takva veza naziva excitirajuća. Pravilo propagacije je najčešće jednostavno net i = ∑ w ji o j + Θ i j gde je neti vrednost ulaza u i-ti čvor Θi bias i-tog čvora i koristi se kod obučavanja Postoje i komplikovanija pravila propagacije i ona zavise od tipa i zadatka koji se rešava uz pomoć neuralne mreže.

Prema tome potrebno je imati model te okoline.− Θ < x < Θ  2⋅Θ 1. 27 . Θ. x ≥ Θ h( x . 1 − e−x 1 Na slici prikazana je semi-linearna aktivaciona funkcija f(net) 0 -PRAG_AKTIVACIJE net PRAG_AKTIVACIJE Slika Semi-linearna aktivaciona funkcija Algoritmi obučavanja Algoritam obučavanja je specificirano pravilo koje opisuje način promene težina veza između čvorova tokom vremena kako bi se dobilo željeno ponašanje mreže.Reprezentacija znanja step_funkcija  A + b. x < Θ semi-linearna funkcija 0. Okolina Svaki sistem pa i neuralna mreža prima signale iz okoline. x > Θ  i sigmoidna funkcija f ( x) = 1 . b) =  − A + b . Rezultate obrade ulaznih podataka mreža treba da distribuira u okolinu. x < −Θ  x + Θ f (x ) =  . A.

a potreban nam je ceo objekt. Kao memorije neuralne mreže mogu čuvati dve vrste uzoraka: prostorne (vremenski nepromenljive ) i prostorno-vremenske uzorke (vremenski nestacionarni).Reprezentacija znanja 2.2. 1. Klasifikacija u odnosu na način reprezentacije znanja Neuralne mreže mogu se posmatrati kao memorije sa znanjem distribuiranim u vezama (sinapsama). Takođe. Karakterizacija topologija vrši se u odnosu na tri parametra: • • • vrste veza šeme veza konfiguracija polja Veze mogu biti excitirajuće (povećavaju nivo aktivacije) ili inhibitirajuće (smanjuju nivo aktivacije). 3. Postoje dve osnovne šeme veza: veze unutar polja i veze između polja. Klasifikacija u odnosu na topološke karakteristike Razne arhitekture (topologije) neuralnih mreža nastaju organizacijom čvorova u slojeve (polja) i povezivanjem čvorova unutar polja kao i čvorova između polja na razne načine. Topološke karakteristike. 28 . Neuralne mreže mogu se posmatrati i kao asocijativne memorije. postoje i dve vrste toka informacija: feedforward (tok signala samo u jednom smeru) i feedback (dozvoljen tok signala u oba smera). Konfiguracije polja formiraju koherentnu arhitekturu kombinovanjem slojeva procesnih elemenata.2. Klasifikacija neuronskih mreža Klasifikacija neuralnih mreža vrši se u odnosu na sledeće tri važne karakteristike ili osobine mreža. 2. Način obučavanja. Suština je u načinu adresiranja kojim se jednoj adresi (ključu) asocira skup memorisanih objekata sa zadanim nivoom tačnosti. Situacija u kojoj se koristi asocijativna memorija je kad znamo samo deo ključa. Način reprezentacije znanja. toka informacija i šema povezivanja.

Reprezentacija znanja Postoje dva osnovna principa smještanja informacija u neuralnoj mreži kao asocijativnoj memoriji: autoasocijativni i heteroasocijativni. obučavanje sa međusobnim pojačanjem. 2. Trenutno ne postoji generalno rešenje koje bi na zadovoljavajući način bilo primenljivo u svim situacijama. 29 . Obučavanje sa učiteljem možemo podeliti u dve kategorije: strukturalno obučavanje (kodiraju se parovi uzoraka ( Ai .3. Bi ) ) i temporalno obučavanje kojim se kodira sekvenca uzoraka koja je potrebna da se dostigne. Generalisano delta pravilo jedan je od najpoznatijih i najčešće korišćenih algoritama za obučavanje neuronskih mreža. Algoritmi za obučavanje neuronskih mreža Jedan od najvećih problema koji se javlja kod modeliranja neuronskih mreža je pronalaženje efikasnog sistema (postupka) za obučavanje.2. Ta promena veza mora biti u odnosu na zadati cilj. stohastičko obučavanje itd. Klasifikacija u odnosu na način obučavanja Obučavanje je proces promene vrednosti veza između procesnih elemenata. Primeri obučavanja sa učiteljem su: obučavanje sa korekcijom greške . U nastavku će biti opisana dva postupka: pseudo-kompetitivno obučavanje i obučavanje generalisanim delta pravilom. Prvi postupak jedan je od najjednostavnijih algoritama za obučavanje i ovde je opisan da bi se na ilustrativnom a jednostavnom primeru prikazale mogućnosti a i problemi na koje treba obratiti pažnju. Kod obučavanja sa učiteljem cilj koji treba da se zadovolji je minimizacija greške kad poznajemo način na koji su ulazni i izlazni podaci klasifikovani. Sve metode generalno mogu se podeliti u dve osnovne grupe: obučavanje sa ili bez učitelja (samo obučavanje). Samo obučavanje predstavlja proces obučavanja kod kojeg nema spoljašnjeg učitelja i koji zavisi samo od informacije sadržane u uzorcima koji dolaze na mrežu.

. o2 .. i ≠ j izlaz j = (o1 . ai ∈ {0. i = j m .an ) .. izlaz j ) j = 1.broj uzoraka obučavajućeg skupa i broj neurona u izlaznom sloju n .1} 0.. I1 W 11 U1 I2 Slika Dvoslojna feedforward neuronska mreža Algoritmom se vrši modifikacija težinskih faktora veza između ulaznih i izlaznih neurona.m} gde je: ulazi = (a1 .. odnosno za određenu kombinaciju pobuđenih neurona na ulazu pobuđen je samo jedan neuron na izlazu. Ovim se dobija vrlo jednostavan a efikasan klasifikator. U izlaznom (kompetitivnom) sloju samo jedan neuron može da bude aktivan dok su ostali neuroni neaktivni (nepobuđeni). Algoritam: Ako je obučavajući skup Ω oblika: Ω = {(ulaz j .broj neurona u ulaznom sloju neuronske mreže 30 ULAZ IZLAZ U2 I3 U3 W 35 I4 I5 Ulazni sloj Kompetitivni sloj .Reprezentacija znanja Pseudo kompetitivno obučavanje Neuronske mreže koje su pogodne za obučavanje ovim načinom su dvoslojne neuronske mreže i semi-linearnom aktivacionom funkcijom u neuronima izlaznog sloja (Slika ).om ) oi =  1.

Simulirati sistem prikazan slikom x1 x2 x3 x4 y1 y2 y3 y4 Slika Ponašanje sistema opisano je sledećom tabelom: Ulaz x2 x3 0 1 1 1 0 0 1 0 Izlaz y2 y3 0 0 1 0 0 1 0 0 x1 1 1 0 1 Rešenje: x4 0 1 1 0 y1 1 0 0 0 y4 0 0 0 1 Neuronska mreža treba da ima 4 ulaza i 4 izlaza.Reprezentacija znanja Tada se vrednost težina veza između ulaznih neurona i pobuđenog izlaznog neurona računa na sledeći način: 1   NAGRADA j Wi . Za prvi uzorak iz obučavajućeg skupa neuronska mreža prikazana je na slici 31 . aij = 1 . j =  1   KAZNA j gde je . aij = 0 NAGRADA j = ∑ aij i =1 n KAZNA j = ∑ (aij − 1) i =1 n Primer 1.

W2.1 = −0. Sistem za dijagnostiku dečijih bolesti Dizajnirati i implementirati ekspertni sistem za dijagnostiku dečijih bolesti.Reprezentacija znanja 1 0 1 0 1 2 3 4 W1. W3.1 W3 W . 1 Groznica Osip Glavobolja Curenje nosa Konjuktivitis Kašalj Jak bol u telu Osetljivost na svetlost Bol u grlu Kijavica Otekle pljuvačne žlezde Krvave oči Ukrućeni zglobovi Povećane limfne žlezde iza uha Otpor na sisanje kiselog Da Da Da Da Da Da Da Da Da Da Da Da Da Da Da Da Da Da Da Da Da Da Da Da Da Da 32 Meningitis Rubeole Zauške Grip . W4 .1 = 0. Ekspert (lekar) treba unapred da opiše poznate bolesti preko određenog broja simptoma. Sistem treba da obezbedi postavljanje dijagnoze na osnovu uočenih simptoma.1 1 2 3 4 1 Slika gde je W1.5 .1 = 0.5 .5 .5 Primer 2.1 = 0.1 W 2. Ovčije boginje Jaka prehlada Da Da Da Da Da Da Da Da Male boginje Veliki kašalj 4.

Na REFERENCA_NA_SAJT je dato rešenje u programskom jeziku. 33 .. Primer 3. Rešenje Na ulaz neuronske mreže dovode se informacije o simptomima a na izlazu svaki neuron odgovara jednoj bolesti. Sistem za prepoznavanje slova Implementirati sistem za prepoznavanje slova na osnovu slike 5x7 pixela..Reprezentacija znanja Nenormalna pljuvačka Otekli krajnici Suva usta Slabost u telu Trovanje Dijareja Svrab Gubitak apetita Da Da Da Da Da Da Da Da Da U tabeli pregledno je dat opis bolesti preko simptoma matricom u kojoj na preseku kolone (bolest) i vrste (simptomi) piše da ako je simptom prisutan u bolesti odnosno ništa ako se simptom ne pojavljuje u posmatranoj bolesti.. Za obučavanje koristi se obučavajući skup definisan u tabeli.

for(int j = 0. 34 .0.0/nagrada. for(int j = 0. } if(nagrada != 0) nagrada = 1. j<broj_ulaza. } } U dodatku je data implementacija u C++ i Java programskim jezicima.Reprezentacija znanja Rešenje Neuronska mreža treba da ima 35 ulaza. Svakom neuronu tog sloja se pridružuje jedno slovo tako da u toku eksploatacije neuron koji je najjače pobuđen u stvari predstavlja prepoznato slovo.0. j++){ if(alphabet[j][i] == 1) W[j][i] = nagrada. for(int j=0. i<broj_izlaza. } ad1[i] = aktivacija(net).j<broj_ulaza. } } } void PseudoKompetitivno::dijagnostika(double ad[]. else W[j][i] = kazna. for(int i=0.j<broj_ulaza. i<broj_izlaza. j++){ if(alphabet[j][i] == 1) nagrada++. else kazna++. Izlazni sloj neuronske mreže treba da ima onoliko neurona koliko ima slova. if(kazna != 0) kazna = -1. j++){ net += W[j][i] * ad[j]. i++){ double nagrada = 0.0/kazna. U nastavku su izdvojeni delovi karakteristični za rešenje a kompletno rešenje nalazi se u REFERENCA_NA_SAJT void PseudoKompetitivno::obucavanje() { int i = 0. vrednost 1 predstavlja crnu boju dok 0 belu. double kazna = 0. i++){ double net = 0. svaki ulaz odgovara jednom pixelu matrice 5x7. double ad1[]) { for(int i=0.0.

2 zamućeno slovo. Za razliku od prethodnog algoritma na izlazu može više neurona da bude pobuđeno.Reprezentacija znanja UKLJUČITI C++ Na sličan način moguće je i u programskom jeziku Java implementirati prethodno opisan algoritam. delta pravilo poznato je i kao back- Višeslojne neuronske mreže sa sigmoidnim aktivacionim funkcija pogodne su za obučavanje ovim algoritmom. Aplikacija sadrži pet elemenata: 1. Slika Sistem za prepoznavanje slova Na slici su prikazana tri slučaja u kojima je dobro prepoznato orginalno slovo. Slika Elementi aplikacije za prepoznavanje slova Generalisano delta pravilo Algoritam generalisano propagation algoritam. Zbog ove osobine back-propagation je moguće koristiti u 35 . 4 klizač za definisanje stepena zamućenja i 5 dugme za izbor novog slova. Neuronska mreža u ovom primeru treba da obezbedi prepoznavanje slova opisanih sličicom 5x7 pixela. 3 propoznato slovo. originalno slovo.

gde je j ∈U s i ∈U s −1 . a j je stvarni izlaz 36 . Wi. Operacije su redom: postavljanje ulaza.Reprezentacija znanja rešavanju većeg skupa problema. ai je izlaz iz i-tog neurona. a j = f ( net j ) Izračunavanje uticaja greške u j-tom neuronu na kriterijumsku funkciju: E= 1 2 ∑ ∑ (t j − a j ) 2 uzorci j∈U n za neurone u izlaznom sloju: δ j = f ' (net j ) ⋅ (t j − a j ) . a prilikom obučavanja dobijeno stanje ne mora i da bude najbolje. izračunavanje greške i korekcija težina. j je vrednost težine veze između j tog i i tog neurona. izračunavanje izlaza. gde je t j željeni izlaz. Četri operacije se ponavljaju u svakoj iteraciji i za svaki uzorak. Back-propagation algoritam iteracija uzorak Postavi ulaz za uzorak Izračunaj izlaz Izračunaj uticaj greške u slojevima Koriguj težine Slika 2. Izračunavanje izlaza obavlja se po formulama: net j = ∑Wi . Nedostatak ovog algoritma je u tome što aktivaciona funcija mora da bude diferencijabilna. U s je skup indexa neurona u i s-tom sloju. j ai . dat je strukturni dijagram algoritma. Algoritam: Na slici 2.

δ (j p ) je uticaj greške u j-tom neuronu. j = Wi . BROJPOKUSAJA = 5. j prethodna promjena.} ni = 0. η brzina obučavanja. β uticaj prethodnih promjena. {Parametri obucavanja.} { Konstante potrebne za obucavanje. F. pragovi aktivacija (bias) računa se po formuli ∆ pθ u = ηδ (j p ) + β∆ pθ u Wi . Primenjen algoritam je detaljno opisan u knjizi D. Klawonn. j = ηδ ( p) j a i( p ) + β ∆ q W i . R. godine Autori programa: Damir Solajic & Djordje Obradovic} const slojeviN = 3. { Ukupan broj slojeva.9. j Uticaj greške računa se od izlaznog sloja prema ulaznom sloju. ∆ qWi . } uzorciN = 4.} beta = 0. j program bp.} MAXN = 2. { Maximalan broj neurona po slojevima. i θ u = θ u + ∆ pθ u Primer 1: XOR funkcija { Generalisano delta pravilo.} MAXITERACIJA = 10000. Korekcija težina računa se od ulaznog prema izlaznom sloju po sledećoj formuli: ∆ p W i . Kruse Foundations of neuro-fuzzy systems John Wiley & sons 1997. type 37 .Nauck. { Maximalan broj iteracija za obucavanje} MAXGRESKA = 0.001. j + ∆ pWi .05. { Ukupan broj uzoraka. j gde su p i q indexi uzoraka. Primer obucavanja viseslojne neuralne mreze algoritmom backpropagation. { Zadata vrednost maximalne greske.Reprezentacija znanja za neurone u skrivenim slojevima: δ i = f ' (neti ) ⋅ i∈U s +1 ∑δ W j i.

. obucavajuciSkup[2.. {Niz matrica tezina} var slojevi:TSlojevi.1] := 0.n := 1.MAXN] of real. tezineP:TWi. { uzorak 2} { uzorak 3} { uzorak 4} 38 .1] := 1.Reprezentacija znanja {Tip u kojem se opisuje jedan sloj} TSloj = record n:integer. drugi index je jedan ako se posmatra ulaz a dva ako se posmatra izlaz. 1.MAXN] of real.1.2. obucavajuciSkup[4.n := 2. { Greska u posmatranom cvoru} bias:array[1. obucavajuciSkup[3.MAXN] of real. tezine:TWi. obucavajuciSkup[2.. { Promena praga aktivacije} end.1..} TWi = array[1.1] := 1.} slojevi[1]. slojevi[3].MAXN.1.n := 2. { Niz slojeva.2] := 0. obucavajuciSkup[4. { uzorak 1} obucavajuciSkup[1.1. { Prag aktivacije} biasp:array[1. {Stvaran broj neurona u sloju.2.2] := 1..1] := 1.MAXN] of real.1] := 1. { Obucavajuci skup: prvi index UZORAK.2] := 1.1. obucavajuciSkup[4. {Inicijalizacija obucavajuceg skupa za XOR problem} obucavajuciSkup[1.} { Sve matrice tezina. slojevi[2]. treci index redni broj neurona } { Procedura sluzi za inicijalizaciju neuronske mreze i obucavajuceg skupa} procedure Inicijalizacija..2] := 0.2.slojeviN] of TSloj.1.1] := 0.} izlaz:array[1.} TSlojevi = array[1. obucavajuciSkup[3... 1.1.uzorciN. end. { Svi slojevi u mrezi. obucavajuciSkup[2.MAXN] of real. Odredjivanje stvarnog broja neurona po sloju.1] := 0. obucavajuciSkup[1. { Matrica za opis tezina.. obucavajuciSkup[3.1] := 0. 1.MAXN] of real. begin {Inicijalizacija mreze. sigma:array[1.2.2.} { Matrice promena odgovarajucih tezina} { ulaz=1 izlaz =2} obucavajuciSkup:array[1..1..(slojeviN-1)] of TW. TW = array[1.

{ Sigmoidna funkcija aktivacije. v:integer.} procedure izracunajIzlaz. v]. end. v:integer. slojevi[s]. Greska u poslednjem cvoru racuna 39 . for s:=1 to slojeviN-1 do begin for u:=1 to slojevi[s]. {Inicijalizacija pragova aktivacije.n do slojevi[s]. u. for u:= 1 to slojevi[s-1].} function sigmoid(net:real):real.Reprezentacija znanja { Procedura sluzi za inicijalizaciju matrice tezina i pragova aktivacije. { Procedura na ulaz postavlja vrednost uzorka indeksiranog parametrom uzorak} procedure postaviUlaz(uzorak:integer).n do for v:=1 to slojevi[s+1]. end.izlaz[u] := obucavajuciSkup[uzorak. end. 1. var s.n do net := net+slojevi[s-1].izlaz[v] := sigmoid(net). var u:integer. { Procedura na osnovu postavljenog ulaza izracunava vrednost izlaza. { Funkcija izracunava vrednost gresaka u svim slojevima pocevsi od poslednjeg. net:real. end. begin for s:=2 to slojeviN do for v:=1 to slojevi[s].bias[v].v] := (random-0. end. [0. prema prvom.bias[u] := random.n do begin net := slojevi[s].izlaz[u]*tezine[s-1][u.n do slojevi[1].5)/5.n do tezine[s][u.1. begin sigmoid := 1/(1+exp(-net)). u]. u.1]} randomize. var s. 0.1]} for s:=2 to slojeviN do for u:=1 to slojevi[s]. end. begin {Inicijalizacija matrice tezina po preporuci W je element [-0. begin for u:=1 to slojevi[1].} procedure InicijalizacijaTezina.

v:integer. var s.v] + tezineP[s][u.} function izracunajGreske(uzorak:integer):real.izlaz[u]+beta*tezineP[s][u. end.sigma[v]). {Greska u svim ostalim slojevima} for s:=slojeviN-1 downto 1 do for u:=1 to slojevi[s].v] := ni*slojevi[s+1].biasp[v]. Ukupna greska uzorka racuna se kao suma kvadrata gresaka na svim izlazima.bias[v] := slojevi[s+1]. end. {ovo vazi samo za sigmoidnu aktivaciju} end.bias[v] + slojevi[s+1]. for v:=1 to slojevi[slojeviN].sigma[v] := obucavajuciSkup[uzorak.biasp[v].n do begin tezineP[s][u.sigma[v] + beta* slojevi[s+1]. greska := greska+sqr(slojevi[slojeviN].sigma[v]*slojevi[s]. {Izracunavanje korigovane vrednosti izlaza u sloju.biasp[v] := ni*slojevi[s+1]. begin for s:=1 to slojeviN-1 do for v:=1 to slojevi[s+1].bias[v]. f := slojevi[s]. v] slojevi[slojeviN]. for v:=1 to slojevi[s+1]. { Procedura na osnovu postavljenih vrednosi gresaka u slojevima koriguje matrice tezina i pragove aktivacije.n do begin sigmaa := 0.v].v:integer.Reprezentacija znanja se u odnosu na uzorak indeksiran parametrom uzorak. net:real.n do begin for u:=1 to slojevi[s].izlaz[v].v] := tezine[s][u.} net := slojevi[s+1].v].v]. begin {Greska u poslednjem sloju} greska:= 0.u. greska:real. slojevi[s]. f:real.n do sigmaa := sigmaa + slojevi[s+1].sigma[v]*tezine[s][u. u.izlaz[u].} procedure korigujTezine. izracunajGreske := greska. slojevi[s+1]. {Korekcija pragova aktivacije} slojevi[s+1]. 40 .n do begin slojevi[slojeviN]. tezine[s][u. end.sigma[u] := f*(1-f)*sigmaa. var s. sigmaa:real. 2.

} for i:=1 to uzorciN do begin postaviUlaz(i).} var i. uzorak.5*izracunajGreske(uzorak).izlaz[v] := sigmoid(net). korigujTezine. begin pokusaj:=1. writeln(i. { Ispis rezultata. for uzorak:=1 to uzorciN do begin postaviUlaz(uzorak).izlaz[1]). { Funkcija kao povratnu vrednost vraca ukupnu gresku u poslednjoj iteraciji.} repeat InicijalizacijaTezina. greska := greska + 0. Inicijalizacija. end. {Inicijalizacija obucavajuceg skupa.v]. end. until (pokusaj>BROJPOKUSAJA) or (greska <MAXGRESKA). readln. iteracija. repeat greska := 0. begin iteracija := 1. end. j:integer. i. until (iteracija>=MAXITERACIJA) or (greska<MAXGRESKA). greska:real. IzracunajIzlaz. end. slojevi[slojeviN]. Inc(pokusaj). 41 . izracunajIzlaz. end. ' '. {Postavljanje matrice tezina i pragova aktivacija. {Kontrola!} writeln('Iteracija: '.n do net := net+slojevi[s].} greska := obucavanje. ' Greska: '. greska :real. obucavanje := greska. { Glavni program. end.Reprezentacija znanja for u:=1 to slojevi[s].} function obucavanje:real. pokusaj:integer.izlaz[u]*tezine[s][u. slojevi[s+1]. greska). var iteracija.{uzorak} Inc(iteracija).

y2=x4+x5+x6. 2. x3. Ulaz je cifra kodirana NBCD kodom. Sistem treba da obezbedi postavljanje dijagnoze na osnovu uočenih simptoma kvara. Izlaze kodirati NBCD kodom. Pomoću neuralne mreže simulirati rad sistema čije je ponašanje opisano sledećim formulama: y1=x1+x2+x3. Izlaze kodirati NBCD kodom. Sistem treba da obezbedi postavljanje dijagnoze na osnovu uočenih simptoma bolesti.Reprezentacija znanja Zadaci za vežbu 1. x5 i x6 su ulazi u sistem. omogućiti jednostavno dodavanje novih simptoma i bolesti. Dizajnirati i implementirati ekspertni sistem za dijagnosticiranje kvara na automobilu na osnovu troslojne feedforward neuralne mreže i back-propagation algoritma za obučavanje. omogućiti jednostavno dodavanje novih simptoma i kvarova.x2. a izlaz ista cifra kodirana Grejovim kodom. x4. Dizajnirati i implementirati ekspertni sistem za dijagnostiku dečijih bolesti na osnovu troslojne feed-forward neuralne mreže i back-propagation algoritma za obučavanje. Postaviti tabelu sa 10 simptoma i bolesti. Sistem treba da obezbedi postavljanje dijagnoze na osnovu uočenih simptoma kvara. jednostavan i pristupačan korisnički interfejs i čuvanje rezultata rada. Postaviti tabelu sa 10 simptoma i bolesti. Pomoću neuralne mreže simulirati rad sistema koji predstavlja konvertor iz NBCD u Grejov kod. jednostavan i pristupačan korisnički interfejs i čuvanje rezultata rada. Koristiti troslojnu feed-forward neuralnu mrežu i backpropagation algoritam obučavanja. Postaviti tabelu sa 10 simptoma i kvarova. omogućiti jednostavno dodavanje novih simptoma i kvarova. Sistem treba da obezbedi postavljanje dijagnoze na osnovu uočenih simptoma bolesti. Koristiti troslojnu feed-forward neuralnu mrežu i back-propagation algoritam obučavanja. 3. x1 . 6. Postaviti tabelu sa 10 simptoma i kvarova. 5. omoguciti jednostavno dodavanje novih simptoma i bolesti. 4. Dizajnirati i implementirati ekspertni sistem za dijagnostiku dečijih bolesti na osnovu troslojne feed-forward neuralne mreže i back-propagation algoritma za obučavanje. 42 . Dizajnirati i implementirati ekspertni sistem za dijagnosticiranje kvara na automobilu na osnovu dvoslojne neuralne mreže i kompetitivnog algoritma za obučavanje. a y1 i y2 su izlazi iz sistema. jednostavan i pristupačan korisnički interfejs i čuvanje rezultata rada.

Ulazne podatke učitavati iz odgovarajuće datoteke. zamućeno 43 . Ulaz u sistem predstavljaju slova srpske azbuke (ćirilica) predstavljena matricom 5x7. Izlaz iz sistema je verovatnoća da je dato slovo na ulazu. Dizajnirati pristupačan korisnički interfejs koji će omogućiti jednostavno zadavanje ulaznog slova. Posle obučavanja. zamućeno ulazno i prepoznato izlazno slovo. Dizajnirati i implementirati sistem za prepoznavanje slova na osnovu troslojne feed-forward neuralne mreže i back-propagation algoritma za obučavanje.Reprezentacija znanja jednostavan i pristupačan korisnicki interfejs i čuvanje rezultata rada. tačno slovo na ulazu zamutiti za željeni procenat. Dizajnirati i implementirati sistem za prepoznavanje slova na osnovu dvoslojne neuralne mreže i kompetitivnog algoritma za obučavanje. Dizajnirati i implementirati sistem za prepoznavanje slova na osnovu dvoslojne neuralne mreže i kompetitivnog algoritma za obučavanje. tačno slovo na ulazu zamutiti za željeni procenat. koeficijenta zamućenja i prikazati tačno ulazno. koeficijenta zamućenja i prikazati tačno ulazno. Ulaz u sistem predstavljaju slova srpske abecede (latinica) predstavljena matricom 5x7. 8. Dizajnirati i implementirati sistem za prepoznavanje slova na osnovu troslojne feed-forward neuralne mreže i back-propagation algoritma za obučavanje. Dizajnirati pristupačan korisnički interfejs koji će omogućiti jednostavno zadavanje ulaznog slova. zamućeno ulazno i prepoznato izlazno slovo. tačno slovo na ulazu zamutiti za željeni procenat. 9. 10. Ulaz u sistem predstavljaju slova srpske abecede (latinica) predstavljena matricom 5x7. Izlaz iz sistema je verovatnoca da je dato slovo na ulazu. 7. Posle obučavanja. Dizajnirati pristupačan korisnički interfejs koji će omogućiti jednostavno zadavanje ulaznog slova. Ulazne podatke učitavati iz odgovarajuće datoteke. Posle obučavanja. koeficijenta zamućenja i prikazati tačno ulazno. zamućeno ulazno i prepoznato izlazno slovo. Izlaz iz sistema je verovatnoća da je dato slovo na ulazu. Izlaz iz sistema je verovatnoca da je dato slovo na ulazu. koeficijenta zamućenja i prikazati tačno ulazno. Posle obučavanja. Ulazne podatke učitavati iz odgovarajuce datoteke. tačno slovo na ulazu zamutiti za željeni procenat. Dizajnirati pristupačan korisnički interfejs koji će omogućiti jednostavno zadavanje ulaznog slova. Ulaz u sistem predstavljaju slova srpske azbuke (ćirilica) predstavljena matricom 5x7.

Ulazne podatke učitavati iz odgovarajuće datoteke. Slova na izlazu kodirati NBCD kodom. Ulazne podatke učitavati iz odgovarajuće datoteke. Dizajnirati i implementirati sistem za prepoznavanje slova na osnovu troslojne feed-forward neuralne mreže i back-propagation algoritma za obučavanje. zamućeno ulazno i prepoznato izlazno slovo.Reprezentacija znanja ulazno i prepoznato izlazno slovo. tačno slovo na ulazu zamutiti za željeni procenat. Posle obučavanja. Dizajnirati pristupačan korisnički interfejs koji će omogućiti jednostavno zadavanje ulaznog slova. Izlaz iz sistema je verovatnoća da je dato slovo na ulazu. koeficijenta zamućenja i prikazati tačno ulazno. 44 . 1. Ulaz u sistem predstavljaju slova srpske abecede (latinica) predstavljena matricom 5x7.

Na primer. «Marko je visok čovek. matematički to možemo da predstavimo na sledeći način 1 (100% pripada). diskretan skup (klasičan) sadrži elemente sa istim svojstvima (skup jabuka. kako možemo da očekujemo korektno izvođenje zaključaka. Da bismo bili u stanju reprezentovati znanje o ovakvim sistemima (a ima ih jako puno) moramo da se odreknemo klasične (binarne) logike u kojoj je nešto ili tačno ili netačno (crno ili belo) i da koristimo fuzzy logiku (sve je nijansa sive boje).». Naime. U ovom poglavlju pokušaćemo da na jednom primeru pokažemo da je to moguće. skup niskih ljudi. U diskretnim skupovima element ili pripada ili ne pripada određenom skupu.7 (70% pripada skupu). ako kažemo da su ljudi višlji od 185 cm visoki. međutim kako da to predstavimo na sistematičan način (kako bi ono što mi radimo iskustveno radio i računar)? Jednostavno 45 . Sa druge strane elementi u fuzzy skupovima mogu delimično da pripadaju.3. skup krušaka. 0 (uopšte ne pripada skupu).) dok fuzzy skupovi sadrže elemente sa sličnim svojstvima (skup visokih ljudi. Čak je više situacija u kojima moramo da koristimo neprecizne konstatacije.). skup brzih automobila itd. Neki će reći ako nepreciznim iskazima reprezentujemo znanje. Fuzzy skupovi Fuzzy skupovi su osnovni elementi kojima opisujemo nepreciznost.3. čak i jednostavnije nego da koristimo klasične metode. postoje situacije u kojima nije moguće znanje o sistemu reprezentovati na apsolutno precizan način. Naime.5 cm? Da li on pripada skupu visokih ili niskih ljudi? Iz iskustva bismo ovakvog čoveka svrstali u grupu visokih ljudi. 0. kako da opišemo čoveka visokog 184. Fuzzy logika Fuzzy logika kao koncept je puno prirodniji nego što se to na prvi momenat misli. Ovim pristupom možemo preciznije da reprezentujemo neprecizne iskaze.» su neprecizne rečenice a ipak ih svakodnevno koristimo. 2. «Onaj automobil se približava jako velikom brzinom.Reprezentacija znanja 2. skup celih brojeva itd.1. Na primer. ako to predstavimo matematički kažemo da je stepen pripadnosti skupu 1 (ako pripada) ili 0 (ako ne pripada).

konveksnost a) konveksan • broj elemenata b) nekonveksan Broj elemenata skupa računa sa kao zbir vrednosti funkcije pripadnosti svakog elementa. Stepen pripadnosti 100% 0% 130 cm 185 cm Visina Slika Osnovne osobine fazi skupa su: • • normalnost Maksimalna vrednost funkcije pripadnosti je 1.Reprezentacija znanja kazaćemo da čovek visok 184. Tako na primer skupu visokih ljudi pridružena je funkcija pripadnosti koja opisuje stepen pripadnosti svakog elmenta tom skupu.5 pripada skupu visokih ljudi sa stepenom 0. negacija i komplement). Kao i kod diskretnih skupova i ovde se definišu osnovne operacije (unija. Na ovaj način uvodimo nov koncept a to je funkcija pripadnosti. 46 . presek.95. Na slici prikazana je funkcija pripadnosti skupu visokih ljudi.

1. Kao i u diskretnim logikama i ovde je moguća kompozicija relacija.3 0. nikola. 47 . Na primer ako imamo dva skupa A={1. 5} tada se u diskretnoj logici relacija veći ili jednak definiše na sledeći način. Reprezentacija znanja primenom fuzzy skupova Znanje u predikatskoj (diskretnoj) logici sadržano je u relacijama između objekata (skup činjenica i pravila). ≥ 3 1 5 1 1 1 1 3 1 0 1 4 0 0 1 Ovde je stepen sigurnosti (stepen pripadnosti) uvek ili 0 ili 1.3 steva 0. Kod fuzzy relacija ovo izgleda malo drugačije. Na isti način se znanje reprezentuje u fuzzy logici ali pomoću fuzzy relacija.8 0. 4} i B={3.8 0.5 Ovde je stepen sigurnosti između 0 i 1.3.3. 3.3.2. Na primer imamo skup A={marko.Reprezentacija znanja 2. Zaključivanje u fuzzy logici Ovo verovatno treba prebaciti kod tehnika rasuđivanja.2 0.5 0. 2. steva} tada relacija dobar_drug može da bude definisana na sledeći način: dobar_drug marko nikola steva marko 0.5 0.2 nikola 0.

Na primer brzinu automobila (0 do 200 km/h) delimo u dve kategorije ili dva skupa mala_brzina i velika_brzina i rastojanje do susednog vozila (0. Mehanički model problema prikazan je na slici 1. Primer 2. Rešavanje problema primenom fuzzy logike U ovom poglavlju opisan je jedan primer primene fuzzy logike u rešavanju problema automatskog upravljanja realnim sistemom. Ovim su definisane ulazne fuzzy veličine. Projektovati sistem za upravljanje kočenjem automobila koji na osnovu brzine automobila i rastojanju do susednog vozila određuje potrebno kočenje kako bi se izbegao sudar.5m do 200m) delimo u veliko i malo rastojanje. Ako je velika_brzina i malo_rastojanje koristiti veliko kočenje. a matematički model dat je sistemom diferencijalnih jednačina u prostoru stanja: 48 .3. • Na osnovu iskustva napisati fuzzy pravila ili fuzzy relacije na osnovu kojih će se izvoditi zaključak. Fuzzy pravila bi u ovom slučaju mogla da izgledaju ovako: Ako je mala_brzina i veliko_rastojanje kočenje treba da bude slabo.4. srednje i veliko kočenje. Silu kočenja (0 do 1000 N) delimo u tri fuzzy skupa: slabo. • Drugi korak je podela skupa mogućih akcija u nekoliko skupova ili kategorija. • Na kraju definisati funkcije pripadnosti koje opisuju fuzzy skupove (posebno za svaku od veličine).Reprezentacija znanja 2. Primer 1. • Prvi korak u rešavanju problema je podela skupa mogućih vrednosti stanja u nekoliko kategorija. Ovim se definišu izlazne fuzzy veličine. Izvršiti dizajn i implementaciju sistema za upravljanje položajem inverznog klatna.

006 kg ⋅ m 2 l = 0 .3 m F masa vozila masa štapa koeficient trenja vozila koeficient inercije štapa dužina štapa upravljačka sila pozicija vozila ugao između štapa i vertikale x θ Slika 2 Ulazi u fazi kontroler su ugao i ugaona brzina klatna. M = 0. Sistem je podeljen na dve celine. Prva celina predstavlja objekat upravljanja (inverzno klatno). prikazan je šematski prikaz upravljačkog modela. Druga 49 .1 m/s I = 0. Na slici 3.5 kg m = 0.Reprezentacija znanja 0 &  x   && 0  x =  & θ  0  &&  θ  0  1 − ( I + ml 2 )b I ( M + m) + Mml 2 0 − mlb I ( M + m) + Mml 2 0 m 2 gl 2 I ( M + m) + Mml 2 0 mgl ( M + m) I ( M + m) + Mml 2 Slika 1 a 0 0     x   I + ml 2 0  &   x  I ( M + m) + Mml 2  ⋅ +  u 1 θ   0  ml  θ    & 0     I ( M + m) + Mml 2      x  & 0 0 1 0   x  0  y= +  u  0 0 0 1 θ  0  & θ  Slika 1 b Na slici 2 prikazana je slika realnog sistema kojim se upravlja kao i osnovne veličine koje ga opisuju. opisan matematičkim modelom.2 kg N b = 0 . Izlaz iz fazi kontrolera je upravljačka sila.

j su indeksi matrice pravila gde je element jednak k.2] pripadnost[Z. x = Ax + Bu Fazi kontroler θF . 50 . gde je k ∈{N .Reprezentacija znanja celina je fazi kontroler koji treba da obezbedi željenu vrednost upravljane veličine. Z .2] centar k-tog elementa fazi skupa. a u FM [k . Prva je fazifikacija ulaznih veličina.1] pripadnost[Z. Fazi upravljanje se sastoji od tri etape. P} . Nakon fazifikacije sledi zaključivanje na osnovu fazi pravila. Fazifikacija N Z P . u [ k ] = F & ∑ θ [i] ⋅ θ F i. θF pripadnost[Z. a i. Defazifikacija uFM u F Zaključivanje Fazifikacija θFM Fazifikacija . Funkcije pripadnosti fazi skupovima su trougaone funkcije opisane sa tri veličine.3] Zaključivanje θF N Z P N Z P Defazifikacija N Z P P P Z P Z N Z N N Izlaz Slika 4 Slika 5 Slika 6 U procesu zaključivanja prikazanom na slici 5. j F [ j ] . Slika 3 Na slici 4. U ovom primeru za defazifikaciju (slika 6) izabran je metod težišta k ∈{N . na osnovu fazi skupova koji opisuju ulazne veličine i fazi pravila određuje fazi skup koji predstavlja upravljačku veličinu. Fazifikacija je proces određivanja stepena pripadnosti elementima fazi skupa. Matematički model u θ θ . P} . θFM θF . Z . Na kraju se vrednost upravljačke sile određuje u modulu za defazifikaciju. prikazan je izgled modula za fazifikaciju ulaznih veličina.

dx. dthetaF : faziSkup. Datum: 21.1. { Program za upravljanje polozajem inverznog klatna primenom fazi logike.5. { Masa stapa } b = 0. { Vreme } theta.001. OF 51 . { Koeficijent inercije stapa } l = 0.81. { Upravljacka sila } thetaF : faziSkup.brojFaziVrednosti] integer.. uF : faziSkup. { Indeks za negativne vrednosti } Z = 2. dtheta. { Indeks za pozitivne vrednosti } brojFaziVrednosti = 3. CONST MV = 0. 1. { Vremenski prirastaj } N = 1. pravila : faziPravila.3.Reprezentacija znanja U nastavku je dato rešenja na programskom jeziku Pascal. ddtheta : real. uFM : faziPripadnost. faziPripadnost = ARRAY[1. ugaone brzine i upravljačke sile u vremenu... { Duzina stapa } g = 9. { Gravitaciono ubrzanje } dt = 0. 1. VAR t : real. faziPravila = ARRAY[1. dthetaFM : faziPripadnost.3] OF real.brojFaziVrednosti.. { Koeficijent trenja vozila } I = 0.brojFaziVrednosti. Potrebno je proširiti fazi skupove tako da se u svakom od njih umesto tri nalazi pet vrednosti (dodati negativno jako i pozitivno jako) i za tako definisane skupove napisati nova pravila. Potrebno je iscrtati kretanje klatna i grafik promene položaja. { Indeks za nulte vrednosti } P = 3.2.006. PROGRAM fazi_logika. { Ugao stapa u odnosu na vertikalu } x. Autori: Djordje Obradovic E5427 Damir Solajic E5882 } USES Crt. { Masa vozila } mK = 0.brojFaziVrednosti] OF real. { Horizontalna koordinata } u : real. ddx : real. mart 2000. TYPE faziSkup = ARRAY[1.. thetaFM : faziPripadnost.

{ Na osnovu dva fazi skupa i fazi pravila odredjuje se fazi skup koji opisuje upravljanje } PROCEDURE zakljucivanje(thetaF.1])/ (pripadnost[Z. uF[Z]:=0. pripadnost : faziPripadnost.3]-pripadnost[Z. pripadnost: faziPripadnost) : real. VAR skup : faziSkup).1]) AND (vrednost < pripadnost[P. IF (vrednost <= pripadnost[P.1])/ (pripadnost[P. END.2]) THEN skup[Z]:=(vrednost-pripadnost[Z.j]]+thetaF[i]*dthetaF[j].1]) ELSE skup[P]:=1.3]) THEN skup[N]:=(pripadnost[N. BEGIN uF[N]:=0.3]-vrednost)/ (pripadnost[N.2]) THEN skup[N]:=1 ELSE IF (vrednost > pripadnost[N. IF (vrednost <= pripadnost[Z. uF[P]:=0.2]) ELSE skup[N]:=0.1]) THEN skup[P]:=0 ELSE IF (vrednost > pripadnost[P.1]) OR (vrednost >= pripadnost[Z. dthetaF : faziSkup. pravila : faziPravila.j]]:=uF[pravila[i.3]) THEN skup[Z]:=0 ELSE IF (vrednost > pripadnost[Z. { Metoda centra tezista } BEGIN 52 . BEGIN IF (vrednost <= pripadnost[N.3]-pripadnost[N. j : integer.1]) AND (vrednost <= pripadnost[Z.2]-pripadnost[P.Reprezentacija znanja { Procedura na osnovu zadate vrednosti i funkcija pripadnosti odredjuje fazi skup koji opisuje datu vrednost } PROCEDURE fazifikacija(vrednost : real.2]).2]) AND (vrednost < pripadnost[Z. { Na osnovu fazi skupa i funkcija pripadnosti izracunava se vrednost } FUNCTION defazifikacija(skup : faziSkup.3]-vrednost)/ (pripadnost[Z.1]) ELSE IF (vrednost > pripadnost[Z. END. VAR i.3]) THEN skup[Z]:=(pripadnost[Z. FOR i:=1 TO brojFaziVrednosti DO FOR j:=1 TO brojFaziVrednosti DO uF[pravila[i.2]) THEN skup[P]:=(vrednost-pripadnost[P. VAR uF : faziSkup).2]) AND (vrednost < pripadnost[N.2]-pripadnost[Z.

3]:=0.3]:=50*Pi/180.75.2]:=-10*Pi/180. thetaFM[Z. thetaFM[Z.2]:=-25. dthetaFM[Z. uFM[N. PROCEDURE inicijalizacijaKontrolera.2]:=25.1]:=-10*Pi/180.1]:=-1. dthetaFM[N. uFM[N. theta. thetaFM[N. BEGIN thetaFM[N.75. dthetaFM[P.3]:=25. uFM[P.2].2]:=0. dthetaFM[Z.1]:=0. uFM[Z. thetaFM[N.2]+ skup[Z]*pripadnost[Z.2]:=0. thetaFM[P. ddtheta:=(-mK*l*b*dx+mK*g*l*(MV+mK)*theta+mK*l*u)/imenilac. uFM[P. dthetaFM[N. END.1]:=0. thetaFM[P.1]:=-30. uFM[Z.1]:=-25. thetaFM[Z.Reprezentacija znanja defazifikacija:=skup[N]*pripadnost[N.1]:=-0. { Proracun matematickog modela } PROCEDURE matematickiModel(x. dtheta. dthetaFM[P. u : real.2]:=10*Pi/180.2]:=-0.5.2]:=0.1]:=-50*Pi/180. BEGIN imenilac:=I*(MV+mK)+MV*mK*sqr(l). 53 .3]:=10*Pi/180.75. VAR ddtheta : real). VAR ddx : real.5. dx.1]:=0. ddx:=(-(I+mK*sqr(l))*b*dx+g*sqr(mK*l)*theta+(I+mK*sqr(l))*u)/ imenilac. dthetaFM[P.3]:=0.2]+ skup[P]*pripadnost[P. uFM[N. VAR imenilac : real. dthetaFM[Z.3]:=0.75. uFM[Z. dthetaFM[N.3]:=1. thetaFM[P.3]:=0.2]:=0. END.

dthetaF). pravila[N. pravila[P. writeln('Izracunavanje upravljanja polozajem inverznog klatna'). t:=t+dt.N]:=P. pravila[P. { Glavni program } VAR c : char.Z]:=Z.dtheta:4:2).' theta = '.P]:=Z.Z]:=N. x:=0.P]:=N.dtheta.ddx. dtheta:=0. pravila[Z.3]:=30.(theta*180/Pi):4:2. x:=x+dx*dt.u.Z]:=P. END. theta:=theta*Pi/180. dtheta:=dtheta+ddtheta*dt. u:4:2. fazifikacija(dtheta. pravila[Z. pravila[N. pravila. zakljucivanje(thetaF. dx:=dx+ddx*dt. pravila[Z. dthetaF. END. pravila[N.dtheta).P]:=N. matematickiModel(x. write('Unesite inicijalni polozaj stapa = '). u:=faziKontroler(theta. uFM). thetaF). readln(theta). thetaFM. END. BEGIN inicijalizacijaKontrolera. uF).N]:=P. WHILE (t <= 1) DO BEGIN writeln(' u = '. dx:=0. BEGIN fazifikacija(theta.N]:=Z. dthetaFM. REPEAT clrscr. dtheta : real) : real. faziKontroler:=defazifikacija(uF. pravila[P. ' dtheta = '. 54 .ddtheta). t:=0. theta:=theta+dtheta*dt.Reprezentacija znanja uFM[P. u:=0. { Na osnovu dve vrednosti (ugla i ugaone brzine) odredjuje se upravljacka sila } FUNCTION faziKontroler(theta.theta.dx.

1. U složenim problemima broj stanja kao i mogućih akcija u pravilu je velik pa je veoma važno odabrati algoritam koji može da pronađe rešenje i pri tom zadovolji postavljene uslove. Zadaci za vežbu 1. U ovom poglavlju biće opisani najznačajniji algoritmi za pretragu u prostoru problema. pretrage predstavljaju kompleksne postupke koji u sebi obuhvataju više različitih mehanizama. Tehnike rasuđivanja 3. Recimo u šahu se figure pomeraju u odnosu na pravila a položaji figura pre i posle pomeranja predstavljaju dva moguća stanja. kao i željeni krajnji položaj klatna (ugao pod kojim će se klatno zaustaviti).'N']). END. ukupan broj koraka. Dizajnirati i implementirati sistem za upravljanje položajem inverznog klatna čiji je matematički model dat u prethodnom primeru.Tehnike rasuđivanja write('Da li zelite jos jednom (d/n) ? '). Na ulazu zadati početno odstupanje položaja i ugaone brzine klatna. sam problem predstavlja stanje u «nekakvom» prostoru. Prikazati kretanje klatna i grafike promene položaja i ugaone brzine klatna i upravljačke sile u vremenu. Fazi skupove organizovati tako da u svakom ima 5 vrednosti. Prema tome. 55 . Vrlo često se zahteva da se prilikom rešavanja ovakvih problema vodi računa o nekoliko stvari: broj koraka koji je doveo do cilja. Iz jednog stanja moguće je preći u konačno mnogo i to uvek u zavisnosti od nekog pravila. Funkcije pripadnosti fazi skupu modelirati kao trapezoidne funkcije opisane sa 4 veličine. Pretraživanje Brzina i kvalitet rešenja zavise od primenjenog algoritma za traženje rešenja odnosno algoritma za pretraživanje. U principu moguće je naći više takvih nizova. 3. UNTIL (c IN ['n'. Prvi zadatak svih pretraga je pronaći niz akcija ili koraka koje treba obaviti da bi se iz početnog stanja stiglo do željenog stanja. broj ponovljenih stanja itd. c:=readkey. Naime.

2. 2. 2. 4. 2. 2 Razmislite o tome na koji način bi ste vi na osnovu sopstvenog iskustva rešili ovakav zadatak. U nastavku će biti opisano nekoliko različitih postupaka za rešavanje ovakvih problema. Pozicija stanja g je x=4. 4. 2. 2. i na kraju probajte problem da opišete algoritamski ili da napišete program. 2. Jedno rešenje ovog problema opisano je nizom akcija: 2. 3. iz stanje f moguće je levo (1) u stanje e. Slika XXX Lavirint Iz stanja P u stanje b moguće je preći samo akcijom 3 (napred). y=5. 2. gore (3) u stanje g i dole (4) u stanje h. 2. 2. 2. 2. 2. Na slici XXX prikazan je lavirint u kojem je potrebno naći put između tačaka P i K. 4. 4. 56 .Tehnike rasuđivanja Lavirint je jedan jednostavan primer u kome je stanje u stvari pozicija opisana koordinatama x i y a raspored zidova određuje pravila po kojima je moguće iz jedne pozicije preći u drugu. Nakon toga pokušajte da opišete zašto ste problem rešili baš tako. 4.

1. U slučaju da stanje nema dece odnosno trenutna hipoteza ne može da se razrađuje. Stanja odnosno hipoteze ispod te dubine se ne obrađuju.1.Tehnike rasuđivanja 3. prelazi se na obradu prethodne hipoteze u drugom pravcu. 57 . Enumerativni algoritmi i optimizacioni algoritmi Pretraživanje «Prvi u dubinu» Ako se postupak pretrage predstavi stablom. iz tehničkih razloga dubina se ograničava na neku prihvatljivu veličinu. Pošto su vrlo često problemi takvi da razvijanje stabla u dubinu rezultuje stablima vrlo velike dubine. • U nastavku je prikazana ilustracija algoritma na primeru rešavanja slagalice 3x3. tad se postupak prvi u dubinu može se ilustrativno predstaviti slikom: Slika XXX Pretraživanje prvi u dubinu Strategija pretraživanja prvi u dubinu • • Trenutna hipoteza ili stanje razrađuje se (u dubinu) pre razmatranja ostalih stanja.

sastoji se iz dve klase: State i Action. endX = aEndX.java public class Action { public int startX. startY = aStartY. public Action(int aStartX.Tehnike rasuđivanja Slika XXX Rešavanje slagalice 3x3 Programsko rešenje prikazano je u programskom jeziku Java. public int endX. public int startY. } public String toString() { return "("+startX+". endY = aEndY. } } 58 . public int endY. Action. "+endY+")". "+startY+") -> ("+endX+". int aStartY. int aEndY) { startX = aStartX. Klasa State opisuje jedan položaj slagalice i sadrži statičke metode u kojima su opisani različiti algoritmi za pretraživanje. int aEndX. Klasa Action opisuje pomeranje koje povezuje dva stanja.

markY). import java.util. public class State { public public public public public public int dimension = 0. markY. elements = new int[dimension][dimension].util. public static int counter = 0.Tehnike rasuđivanja Atributi startX i startY opisuju položaj prazne pozicije pre a endX i endY nakon izvršavanja akcije. retVal. i<dimension. } public State(State st) { dimension = st. markX. int markX = 0. State. int markY = 0. j<dimension. markY).Comparator. } if(markY>0) { Action act = new Action(markX.add(act).Collections. markY-1. } 59 . markY). markY. markX. int elements[][]=null.markY.dimension.markX. Action action = null.*. } } markX = st. public State(int aDimension) { dimension = aDimension. markY = st.util. markX. for(int i=0. retVal.add(act). retVal.elements[i][j]. j++) { elements[i][j] = st. } public Vector possibleActions() { Vector retVal = new Vector(). if(markX>0) { Action act = new Action(markX-1. } if(markX+1<dimension) { Action act = new Action(markX+1. i++) { for(int j=0.add(act). import java.java import java. elements = new int[dimension][dimension]. State parent = null.

i<dimension.println(""+this).showPath(). String newLine = "". } public String toString() { String retVal = "".startX]= elements[act. retVal. i++) { retVal += newLine. else return false. retVal.out. if(action!=null) System. } return retVal. } public State nextState(Action act) { State retVal = new State(this).equals(finished)) return true.println(""+action). } else { if(elements[i][j]<10) retVal += " "+elements[i][j]+" ". retVal.endX]= elements[act.markX=act. markY+1. retVal. } } newLine="\n".add(act).startX]. for(int j=0. String finished = finalState(). for(int i=0. retVal. return retVal. else retVal += elements[i][j]+" ".startY][act.markY=act.parent = this.startY.Tehnike rasuđivanja if(markY+1<dimension) { Action act = new Action(markX. // pomeranje retVal.elements[act.action = act. retVal. j++) { if((i==markY)&&(j==markX)) { retVal += " ". System. } public void showPath(){ if(parent!=null) parent.endY][act. j<dimension.endY][act. } public boolean isFinished() { String curr = toHash().toHash().endX].out. if(curr. markX.startY][act.startX. markY). } 60 .elements[act.

}else{ Vector v = possibleActions().toHash())==null) { State solution = next. states.put(hashCode. } public String toHash() { String retVal = "". return state. s. } public static State searchDeepFirst(State state) { Hashtable states = new Hashtable().findSolution(1.elements[0][2]=3. } } } } return null. i++) { Action act = (Action)v. maxLevel). if(isFinished()==true) { return this. int maxLevel) { counter++. if(level>maxLevel) return null. 61 . ""). s. j<dimension. s.findSolution(level+1.elements[1][0]=5. 200).get(i).Tehnike rasuđivanja return retVal.elements[1][2]=6. } public static State initialState() { State s = new State(3). State next = nextState(act). for(int i=0. i++) { for(int j=0.elements[0][1]=9. j++) { retVal += elements[i][j]+"".elements[0][0]=1.get(next. for(int i=0.elements[1][1]=2. if(solution!=null) { return solution. s. i<v. String hashCode = toHash(). } public State findSolution(int level.size(). s. s. i<dimension. } } return retVal. if(states. states. Hashtable states. states.

s.out. if(solution!=null) { System.elements[2][2]=8. s. 0) 1 3 5 2 6 4 7 8 (0.elements[1][0]=4. s. s. System. s.***** ----"). s.elements[2][1]=9. s.elements[1][2]=6. solution.markY = 2. s.Tehnike rasuđivanja s.elements[2][0]=7.elements[2][0]=4.showPath(). State solution = searchDeepFirst(s).elements[0][2]=3. 0) 5 1 3 2 6 62 . s.elements[0][1]=2.elements[2][2]=8.SOLVED---counter:84477 1 3 5 2 6 4 7 8 (0. 1) -> (0.println("counter:"+counter).println("---.Solution ----"). s.elements[2][1]=7. s. s. s.markY = 0.out.out. 0) -> (1. } else { System. return s.markX = 2. } public static void main(String args[]) { State s = initialState(). return s. counter = 0.elements[0][0]=1. s.elements[1][1]=5. s.println("---. } public static State finalState() { State s = new State(3). System. } } } Rezultat izvršavanja 1 3 5 2 6 4 7 8 ---.out.markX = 1.println(s).

Vector nodes = new Vector()... states..Tehnike rasuđivanja 4 7 8 ... (2. 1) 1 2 3 4 5 6 7 8 Pretraživanje «Prvi u širinu» Strategija pretraživanja «Prvi u širinu» • • Razvijaju se uvek stanja ili hipoteze na istom nivou.. ""). boolean solved = false.. nodes. Kad se završi pretraživanje u jednom nivou prelazi se na sledeći i tako dok se ne dođe do rešenja ili dok hipoteze mogu da se razvijaju bez ponavljanja Putanja od korana stabla do rešenja je u ovom slučaju minimalna. • Programsko rešenje: Implementacija ovog algoritma se nadovezuje na prethodni program.size()>0) { State s = (State)nodes. String hashCode = state.. Klasa State proširena je metodom public class State { .put(hashCode.get(0). public static State searchBreadthFirst(State state) { Hashtable states = new Hashtable().. 63 ..toHash().add(state).. while(solved==false||nodes. 2) -> (2.

out.. State solution = searchBreadthFirst(s). } } . String nextHashCode = next. } } return null.possibleActions().remove(s).Tehnike rasuđivanja counter++.showPath().. 0) 1 2 3 5 6 4 7 8 (0.out. } else { System. } } Rezultat izvršavanja 1 3 5 2 6 4 7 8 ---.put(nextHashCode. if(s. nodes.. "").get(i). if(solution!=null) { System. System.get(nextHashCode)==null) { states.println(s).***** ----"). A metoda main se sad menja u: public static void main(String args[]) { State s = initialState(). counter = 0. 1) -> (1. solution.println("counter:"+counter).nextState(act).println("---. 1) -> (1. } } nodes. if(states. } else { Vector v = s. 1) 1 2 3 5 6 4 7 8 64 .out.out.println("---.Solution ----"). System.size(). for(int i=0.isFinished()==true) { return s.toHash().add(next). i++) { Action act = (Action)v.SOLVED---counter:52 1 3 5 2 6 4 7 8 (1. State next = s. i<v.

public static State searchIterativeDeepFirst(State state){ for(int i=1.. if(solution!=null) return solution. Strategija: • • • • • Izršiti pretragu «Prvi u dubinu» sa zadatom dubinom. i<200.. Ako traženo rešenje nije pronađeno ponoviti postupak sa povećanom dubinom. 2) -> (0. 2) 1 2 3 4 5 6 7 8 (2.Tehnike rasuđivanja (0.. 65 . states.. 1) 1 2 3 4 5 6 7 8 (1.findSolution(1. i++) { Hashtable states = new Hashtable(). Putanja do rešenja je minimalna. 2) 1 2 3 4 5 6 7 8 Iterativno pretraživanje «Prvi u dubinu» Iterativno pretraživanje «prvi u dubinu» je pretraživanje u kojem se koriste dobre osobine pretrage prvi u dubinu i dobre osobine pretrage prvi u širinu.. State solution = state. Programsko rešenje: Implementacija algoritma opisana je metodom koja se nadovezuje na ostale metode definisane u klasi State. Uvećavati dubinu pretrage «prvi u dubinu» sve dok se ne nađe rešenje ili se ne dođe do maksimalne dubine. Potrebni resursi su isti kao za pretragu prvi u dubinu. 2) -> (0. i). 2) -> (1. } . } return null... public class State { .

out. } } Rezultat izvršavanja: 1 3 5 2 6 4 7 8 ---.println("---.out. } else { System.out. System.SOLVED---counter:192 1 3 5 2 6 4 7 8 (1.println("counter:"+counter).println("---. State solution = searchIterativeDeepFirst(s).***** ----"). 2) 1 2 3 4 5 6 7 8 66 . 1) 1 2 3 4 5 6 7 8 (1. counter = 0. 1) -> (1. 2) 1 2 3 4 5 6 7 8 (2. 2) -> (0. solution.Tehnike rasuđivanja } Tada glavni program može da izgleda: public static void main(String args[]) { State s = initialState().Solution ----"). if(solution!=null) { System. 0) 1 2 3 5 6 4 7 8 (0. System. 1) 1 2 3 5 6 4 7 8 (0. 2) -> (0.out.showPath(). 1) -> (1. 2) -> (1.println(s).

Tehnike rasuđivanja Bidirekciona pretraga Strategija: • • • Krenuti sa rešavanjem zadatka algoritmom prvi u širinu ili iterativni prvi u dubinu. Ova vrsta pretrage grafički je prikazana na slici Slika Bidirekciona pretraga Programsko rešenje implementirano je na primeru slagalice 3x3 odnosno kao proširenje klase State: public class State { . Istovremeno razvijati rešenje korišćenjem pretrage prvi u širinu ili iterativni prvi u dubinu. 67 . boolean solved = false. Vector nodesA = new Vector(). public static State searchBiDirectional(State state) { State finalState = finalState(). Vector nodesB = new Vector().. Hashtable statesA = new Hashtable()... Ako se jedan od listova iz jednog stabla poklopi sa jednim od listova drugog traženo rešenje je putanja od zadatka do zajedničkog stanja ili hipoteze i putanja od tog stanja do rešenja. Hashtable statesB = new Hashtable().

possibleActions(). // from start State s = (State)nodesA.get(hc).put(hashCodeA.showPath(). inter.showPath(). } else { Vector v = s.showPath().toHash().toHash(). if(statesB. } else { Vector v = s. if(statesA. s. next).showPath(). statesA. for(int i=0. state). } } 68 . String hc = s.out.toHash(). hc = s.nextState(act).remove(s).toHash().get(nextHashCode)==null) { statesB. System.add(next). System. nodesA.get(0).println("------SOLVED-------").get(hc).nextState(act).possibleActions(). next). return inter. } } nodesA.get(i).println("------SOLVED-------"). inter = (State)statesA. State next = s.println("-------------------").println("-------------------").get(0). String hashCodeB = finalState. if(inter!=null) { System. while((counter<10000)||(solved==false)) { counter++.add(next).size(). return inter. nodesB. String nextHashCode = next.Tehnike rasuđivanja nodesA. State next = s.add(state). inter. i<v.out.add(finalState). i++) { Action act = (Action)v. if(inter!=null) { System. i++) { Action act = (Action)v. } } nodesB.put(nextHashCode.get(i).size().remove(s). finalState). s.out. statesB. State inter = (State)statesB. i<v. String hashCodeA = state. nodesB.put(hashCodeB.put(nextHashCode.get(nextHashCode)==null) { statesA. String nextHashCode = next. } // from end s = (State)nodesB.toHash().toHash(). for(int i=0.out.

} Glavni program može da izgleda: public static void main(String args[]) { State s = initialState(). solution.showPath(). State solution = searchIterativeDeepFirst(s). 2) -> (1.Solution ----"). if(solution!=null) { System. 0) 1 2 3 5 6 4 7 8 (0.println("counter:"+counter). 2) 1 2 3 4 5 6 7 8 (0. System.println("---. 1) 1 2 3 5 6 4 7 8 ------------------1 2 3 4 5 6 7 8 (1.. 2) 1 2 3 4 5 6 7 8 (0. System.. } } Rezultat izvršavanja: 1 3 5 2 6 4 7 8 ------SOLVED------1 3 5 2 6 4 7 8 (1.. 1) -> (0. 2) -> (2.out. } .out. 1) -> (1.println(s).***** ----").Tehnike rasuđivanja return null.out. counter = 0. 1) -> (1.out. 2) 1 2 3 69 . } else { System.println("---.

70 .SOLVED---counter:7 1 2 3 4 5 6 7 8 (1. Klasa State proširena je heurističkom funkcijom koja vraća broj pločica koji se nalazi na svojem mestu.. Vrlo često heurističke funkcije predstavljaju samo predviđanje a ne i stvarno stanje. public int heuristicFunction() { int retVal = 0. Ta vrednost bi na primer govorila koliko je tranutno stanje «daleko» od rešenja.Tehnike rasuđivanja 5 6 4 7 8 ---. 2) 1 2 3 5 6 4 7 8 Optimizacioni algoritmi (A*) U slučaju da želimo izvršiti pretragu u što je moguće manje koraka moramo u prostor uvesti metriku. Odnosno. 2) 1 2 3 4 5 6 7 8 (0.. tako da izbor i kvalitet heurističke funkcije vrlo često određuje i kvalitet i brzinu pronalaženja rešenja. 2) 1 2 3 4 5 6 7 8 (0. Programsko rešenje je implementirano na primeru slagalice 3x3 kao i u prethodnim slučajevima. Strategija A* algoritma je da se uvek ispituje hipoteza koja ima minimalnu vrednost definisane heurističke funkcije. 2) -> (2.. 2) -> (1. public class State { . svako stanje bi u tom slučaju bilo opisano vrednošću definisane heurističke funkcije.. 1) -> (0. Na ovaj način u pretrazi se prioritet daje stanjima koja su bliže traženom rešenju a time se značajno smanjuje broj operacija potrebnih za nalaženje rešenja. Putanja od zadatka do rešenja je i u ovom slučaju minimalna ali je broj koraka kojim je dobijeno rešenje manji nego kod pretraživanja prvi u širinu.

"").SOLVED---counter:6 1 3 5 2 6 4 7 8 (1.Tehnike rasuđivanja for(int i=0. "").add(next). nodes.toHash(). } } return null. j++) { if(elements[i][j] == (i*dimension+j+1) ) { retVal++. while(solved==false||nodes. c). String hashCode = state.. } Rezultat izvršavanja: 1 3 5 2 6 4 7 8 ---. i<dimension.get(0).remove(s).possibleActions().. 0) 1 2 3 71 . if(s.put(hashCode. for(int i=0.add(state).get(nextHashCode)==null) { states.put(nextHashCode. states.. } public static State searchAStar(State state) { Hashtable states = new Hashtable().sort(nodes. } else { Vector v = s.size(). nodes. if(states.size()>0) { State s = (State)nodes. i++) { for(int j=0. i++) { Action act = (Action)v. Comparator c = new StateComparator()..nextState(act).get(i). i<v. 1) -> (1. counter++. boolean solved = false. } } nodes. } } } return retVal. } .toHash(). Collections. Vector nodes = new Vector(). String nextHashCode = next. j<dimension.isFinished()==true) { return s. State next = s.

Tehnike rasuđivanja 5 4 7 (0. System.Comparable. State stateB = (State)b.lang.Solution ----"). int fB = stateB.println(s). State stateA = (State)a. 1) (0. } return retVal.util. if(solution!=null) { System. 1) 1 2 5 4 7 (0. public class StateComparator implements Comparator { public int compare(Object a. 72 . int fA = stateA.out.println("counter:"+counter).***** ----"). import java. System. 2) Za potrebe sortiranja implementirana je klasa StateComparator: import java.println("---.heuristicFunction(). if(fA<fB) { retVal=1.showPath().util. Object b) { int retVal = 0. import java.out.println("---.Comparator.out. 2) (1. } else { System. } } A glavni program u ovom slučaju je: public static void main(String args[]) { State s = initialState(). } else if(fA>fB) { retVal=-1.*.out. counter = 0. 2) 1 2 4 5 7 (1. 2) 1 2 4 5 7 (2. State solution = searchAStar(s). 2) 1 2 4 5 7 8 6 8 -> 3 6 8 -> 3 6 8 -> 3 6 8 -> 3 6 (1. 1) (0. solution.heuristicFunction().

Tehnike rasuđivanja
} }

Zadaci za vežbu
1. Napisati program kojim se određuje postupak za rešavanje slagalice 4x4. Programski implementirati algoritme prvi u dubinu, prvi u širinu, iterativni prvi u dubinu, bidirekcioni i A*. U rešenju treba da se nalazi početno stanje, krajnje stanje, sve akcije koje od početnog vode ka krajnjem stanju i broj koraka koji su obavljeni da bi se dobilo rešenje. 2. Ako je lavirint opisan slikom XXXX. Napisati program kojim se pronalazi najkraći put između ulaza i izlaza. 3. Napisati program koji pronalazi položaje N dama na šahovskoj tabli dimenzije NxN, takve da se bilo koja dama ne nalazi na putanji ostalih dama. 4. Ako su gradovi povezani putnom mrežom prikazanom na slici XXXXY odrediti a. Listu gradova koji se nalaze na najkraćoj putanji između grada A i grada Z. b. Putanju kojom bi se trabalo kretati da se obiđu svi gradovi i pređe najkraći put.

73

Tehnike rasuđivanja

4

1

Slika XXXs 5. Napisati program kojim se određuju potezi koje šahista treba da obavi da bi skakač sa pozicije B2 prešao na poziciju F2.

Slika 74

Tehnike rasuđivanja

3.1.2.

Genetski algoritmi

3.2. Dedukcija
3.2.1. Izračunavanje odgovora u predikatskoj logici

Izračunavanje odgovora u predikatskoj logici izvodi se korišćenjem dva mehanizma: 1. Ujedinjavanje 2. Rezolucija Ovim mehanizmima kreira se stablo pretraživanja. Ujedinjavanje je proces menjanja dva terma sa ciljem da se ti termovi učine identični. Supstitucija: Supstituciom ili zamenom nazivamo konačan skup S parova oblika X = t za koje važi sledeće: i. ii.

∀X se javlja samo u jednom paru iz S
Promenjljive

X nema sa desne strane znaka =

A * S je term koji se dobije tako što se u termu A izvrši supstitucija S.
Primer: Ako je term A : drug(X, Y). a supstitucija S1 = { X=pera, Y=mika } tada je A * S1 : drug(pera, mika). 75

Takođe supstitucija S 2b = {X=marko. Y). Supstitucija S2 a = { X=pera. S3 = { X=a. } nije dobra zato što se promenljiva X pojavljuje dva para. Instanca: Term A je instanca terma B ako postoji takva supstitucija S tako da važi A = B * S . r(X. vino). C = A * S3 = B * S 3 . vino) } B: S 4 = { X=Z. Primer: B : p(X):-q(X).Y). Y=otac(ana) } otac(ana)). Y=X } nije dobra zato što se promenljiva X nalazi i sa leve i sa desne strane znaka =. voli(pera.b). b). p(Z. p(X. X=mika A * S 2 : drug(brat(ana). Ujedinitelj: Supstitucija S naziva se ujedinitelj. r(a. a). b). Y=voli(pera. 76 . Najopštiji ujedinitelj: Supstitucija koja ta dva terma ujedinjuje tako da u njima ostane najveći mogući broj promenljivih. Primer: A: p(X. a). Ujedinjivost: Dva terma su ujedinjiva ako imaju zajedničku instancu C = A* S = B * S Primer: A: B: p(a. Y=b } A = B * S3 A: p(a):-q(a). Y. C: p(a.Tehnike rasuđivanja S 2 = { X=brat(ana).

Ako je obrnuto isto važi. brz(X). r(K). P(Y):-q(Y). Z=3. 2. Y=voli(pera. b. vino) } S 4 je opštiji od S5 Varijanta: Varijanta nekog terma A je instanca te strukture koja je dobijena primenom supstitucije koja sadrži samo promenljive.Tehnike rasuđivanja S5 = { X=3. Ako je term A1 promenljiv a A2 proizvoljan term onda ujedinjavanje uspeva ako se promenljiva A1 ne pojavljuje u termu A2 . b). drugar(a. b). 3. Ako su termovi A1 i A2 konstante onda su ujedinjivi samo ako su identični. Dve strukture nisu ujedinjive zato što nemaju uste funktore. Primer: p(X):-q(X). drug(a. c). S6 = { X=Y } S7 = { X=K } Proces ujedinjavanja dva terma: 1. Primeri: drug(a. r(Y). 77 . b). Dve strukture su ujedinjive ako imaju iste funktore i ako su svi argumenti jedne ujedinjive sa argumentima druge. p(K):-q(K). brz(pas(X)). r(X). drug(a. Dve strukture nisu ujedinjive zato što nemaju isti broj argumenata. Pri ujedinjavanju A1 sa A2 promenljiva A1 poprima vrednost terma A2 .

Mehanizam redukovanja cilja (resolucija) Procedura rezolviranja se svodi na pojednostavljivanje zadatog cilja korišćenjem ujedinjavanja sve dok ne dobijemo prazan cilj. ujedinjavanje je moguće izvršiti između prve klauzule i varijante druge (preimenovanje promenljivih). (k3) q(a). 78 . brz(X). Primer: (k1) p(X. (k5) q(c). brz(pas(Y)). 3). 2). Međutim. Y):-q(X). Proces redukovanja cilja ?-p(X. (k7) r(a. (k6) r(a. Y) grafički je prikazan na slici 2. (k4) q(b). 4). (k8) r(c. Y). r(X.Tehnike rasuđivanja Ove dve nisu ujedinjive zato što argumenti X i pas(X) nisu ujedinjivi. (k2) p(d.XX. 1).

3. Cn. Cn. Tada potomak cilja ?-C1. C2. C2. Neka je cilj ?-C1..XX Grafički prikazan proces redukovanja cilja Stablo pretraživanja: 1...... čvor stabla pretraživanja i neka je C1 pozitivan pod cilj tada taj čvor ima po jednog potomka za svaku klauzulu oblika G:-T1. . ... čvor stabla pretraživanja ali je C1 oblika C1=not( C1* ). . .... Ako cilj ima C1* konačno stablo pretraživanja sa granom uspeha tada celi čvor nema 79 .. Cn.Tehnike rasuđivanja Slika 2.. Ujedinjive klauzule traže se odozgo prema dolja i s leva na desno. 2..Tq. Neka je cilja oblika ?-C1.. Koren stabla je polazni cilj C.Tq. Cn)*S Gde je S najopštiji ujedinitelj struktura C1 i G... izgleda ?-( T1. C2... C2.. za koju su strukture C1 i G ujedinjive.

3). Y):-q(X). (k8) r(c. r(X. 2). 4). Grana neuspeha je grana koja završava na čvoru neuspeha. Primer 1: (k1) p(X. Ako je zadata cilj ?-P(X.X1. Međutim. Y).Tehnike rasuđivanja potomaka. Y) onda pretraživanja prikazano na slici 2. (k5) q(c). (k4) q(b). Cn 4. je odgovarajuće stablo 80 . ako C1* ima konačno stablo pretraživanja ali bez grane uspeha onda je potomak cilj ?-C2. Grana stabla koje završavaju na čvoru uspeha nazivaju se grane uspeha. (k2) p(d. Potomak koji nema ni jednog elementa naziva se prazan cilj [] Čvor uspeha je čvor koji sadrži prazan cilj. (k6) r(a. Čvor koji sadrži ne prazan cilj a nema potomaka naziva se čvor neuspeha.. (k3) q(a). 1).. .. (k7) r(a.

generiše se sledeće stablo pretraživanja: 81 .1) p(X.1) p(X. Y=2 [] Odgovor: X=c. Y). Y) (k8) S6={Y=3} (8) [] Odgovor: X=1. P(Z. Y=4} (2) ?-q(X). Nakon toga nacrtati stablo pretraživanja koje se formira kako bi se izračunao odgovor na pitanje «Kome je ivan preda?». (k2) r(mara. Y):-r(X. (k5. Y) Čvor neuspeha! (7) ?-r(c. (k1) (k2) S7={X=d.Z).X1 Primer 2: Za prikazano porodično stablo napisati skup činjenica i pravila koji opisuju vezu roditelj (r) i vezu predak (p). (k3) r(toma. Y) (k7) S4={Y=2} (5) (6) ?-r(b. Y).Y). Y=3 Slika 2. Y=4 S1={X=a} S5={X=c} (3) (k6) S2={Y=1} (4) ?-r(a. Y). (k3) (k4) S3={X=b} (k5) (9) [] Odgovor: X=d.r(X. petar). toma). Za cilj ?-predak(ivan. toma). Y=1 [] Odgovor: X=a.Tehnike rasuđivanja (1) ?-p(X. Y):-r(X. Rеšenje 1: (k1) r(ivan. (k4. X).

2) p(X. Y):-r(X. Rešenje 2: Razlika između ovog i prethodnog rešenja je u tome što je zamenjen redosled klauzula k4 i k5(k1) r(ivan. toma). Y):-r(X.2) p(X.Z). Y).X1 Stablo pretraživanja za primer 2 rešenje 1 Dobijeni odgovori redom: X=toma. petar). i nakon toga dva čvora neuspeha. (k3) r(toma. (k5. Sad za isti upit dobijamo drugačije stablo pretraživanja: 82 . P(Z. toma).Y).Tehnike rasuđivanja Slika 2. (k2) r(mara. (k4. X=petar.

Z). Odgovor: X=petar (k5.Y). Z). (k2) r(mara. X).Y). S4={X=petar} (k3) (8) ?-r(toma. k4.2*S1: p(X1. X).p(Z. toma). Y1). Y). (k5.2*S1)*S2 ?-p(ivan.Y1). S3={Z=toma} (k1) ?-r(ivan. Y=Y1} S2={X1=X} (2) k5.2*S1)*S2 (11) ?-[]. (k4. Stablo pretraživanja za treći slučaj nam daje dva dobra rešenja. (9) ?-[]. Rešenje 3: (k1) r(ivan.p(Z. Z). Y):-r(X.2*S1)*S2 ?-p(toma. S5={Z=petar} (k3) (5) ?-p(petar. X). Čvor neuspeha! (7) ?-r(petar. p(Z. X). Čvor neuspeha! (11) Slika Stablo pretraživanja za rešenje 2 U ovom slučaju prvo se generišu dva čvora neuspeha a potom X=petar i X=toma. X). X).p(Z.2*S1)*S2 (k4. Z). petar). X). toma). (k4.3) p(X.Y1):-r(X1. X).2*S1)*S2 (6) ?-r(petar. (k5. beskonačno mnogo čvorova neuspeha i jednu beskonačnu granu. Odgovor: X=toma (4) ?-r(toma.Tehnike rasuđivanja (1) S1={X=X1. 83 . r(X. S6={X=toma} (k1) (3) (k5. (k4.3) p(X.Y1):-r(X1. (k3) r(toma. Ako se pažljivo pogleda drugo stablo pretraživanja je «u ogledalu» preslikano prvo stablo. Y):-p(Z. X).2*S1)*S2 (10) ?-r(ivan.2*S1: p(X1.

(k4. Y1).r(Z. (k1) ?-r(Z1. X=toma} (k1) (k4.toma). X). Čvor neuspeha! Slika 2. X).3*S1: p(X1.XX Stablo pretraživanja sa beskonačnom granom Možemo uočiti da je mehanizam rezolviranja prvo došao do tačnih rešenja pa onda upao u beskonačno proširivanje zadatog cilja a samim tim i do beskonačne grane. X=petar} (k3) (8) (10) ?-p(Z1.Y1):-r(X1. k5. Z). X=petar} S7={Z1=ivan. ivan).r(ivan. lako je zaključiti da bismo u slučaju zamene redosleda klauzula k4. Pošto se potomci čvora grade rešavanjem podciljeva s leva na desno poželjno je jednostavnije ciljeve smeštati sa leva a komplikovanije sa desna. Z).3*S1)*S2 (4) S1={X=X1. X=toma} (k2) (12) (13) (k3) (7) ?-r(ivan.Z). X). Odgovor: X=petar S9={Z1=toma. Čvor neuspeha! ?-r(ivan. Z1).. (k4.r(ivan.r(ivan.3 i k4. S6={Z=toma. Po analogiji između prvog i drugog slučaja kad smo zamenom redosleda klauzula dobili stablo pretraživanja koje je «u ogledalu» preslikano stablo iz prvog slučaja. (k5. Čvor neuspeha! (12) ?-r(Z.r(ivan.Y1):-r(X1.3) (k5. X). 84 .r(ivan. (k1) ?-p(Z. Z).3*S1: p(X1. . Y=Y1} S2={X1=X} k4.Z1).p(Z.Y1).mara). mara).3*S1)*S2 (2) ?-r(ivan. Čvor neuspeha! ?-r(Z. X=toma} (k2) (9) ?-[].3*S1)*S2 S3={X=toma} (3) ?-[]..3) (11) (6) ?-r(ivan.ivan). X). Zato je preporuka da se prvo navode klauzule koje predstavljaju završetak rekurzije i da se prvo rešavaju jednostavniji podciljevi a potom komplikovaniji. S5={Z=mara. Z). Odgovor: X=toma (5) ?-r(Z. X=toma} (k1) S8={Z1=mara. Čvor neuspeha! ?-r(Z. X).Z).Tehnike rasuđivanja (1) ?-p(ivan. Z). Z).r(Z.r(ivan... toma). S4={Z=ivan.r(ivan.5 odmah upali u beskonačno proširivanje cilja.

1 Okolina sa dva agenta i jednim objektom Na slici 4. Poseduju osobinu pokretljivosti i obavezno imaju cilj koji treba da ispune. modul za izvršavanje akcija. računarska inteligencija. i tada oni predstavljaju servis koji ostali agenti mogu da koriste kako bi rešili svoj zadatak. Slika 4. agenti mogu da budu osposobljeni za rešavanje određenog zadatka ili problema. modeliranje konkurentnog ponašanja. senzori itd.Inteligentni agenti 4. U programskoj implementaciji inteligentnih agenata koristi se nekoliko disciplina: objektno orijentisano modeliranje. Ponekad nekoliko agenata imaju zajednički zadatak pa je neophodno da postoji njihova međusobna koordinacija. skoro sve definicije opisuju agente kao objekte koji mogu da vide okolinu.1 prikazana je jedna okolina (ili prostor) u kojoj se nalaze dva agenta i jedan objekat. modul za komunikaciju. U daljem radu ograničićemo se na agente koji pored prethodnih osobina poseduju i određenu inteligenciju. modeliranje protokola za komunikaciju itd. modul za odlučivanje. Agenti koji te odluke donose na način opisan tehnikama računarske inteligencije nazivaju se inteligentni agenti. Prethodnom definicijom obuhvaćen je veoma velik broj različitih uređaja i programskih paketa. Naime. Za potrebe modeliranja i implementacije agenata pojedine celine se odvajaju u module (modul za kretanje. Takođe. Međutim. Mogu da komuniciraju sa drugim objektima ili agentima u okolini.). agent da bi ispunio zadati cilj mora da donosi odluke. Inteligentni agenti Agent kao koncept definiše se na mnogo načina. objekte i druge agente preko svojih senzora. Zadatak agenta 1 može da bude sledeći: 85 .

Slika 4. 86 . Uslužni agenti – postoje kao servisi i čekaju dok neki drugi agenti ne zatraže njihovu uslugu.Inteligentni agenti «Pronađi objekat 1 i odnesi ga agentu 2. prikupljanje i objavljivanje specifikacija i standarda iz oblasti inteligentnih agenata. Za koordinaciju razvoja inteligentnih agenata osnovana je organizacija Foundation for Intelligent Physical Agents skraćeno (FIPA Jedan od zadataka ove fondacije je http://www.» Karakteristična struktura inteligentnog agenta prikazana je na slici 4. • Kategorizacija agenata u odnosu na svrhu postojanja: • • Koncept inteligentnih agenata trenutno je u razvoju. Agent 2 treba da sačuva objekat 1 i da ga kasnije na zahtev brzo pronađe. Sam razvoj se kreće u nekoliko pravaca i sastoji se u implementaciji standarda i okruženja za podršku agent orijentisanom programiranju i izvršavanju.fipa. Agenti koji mogu da uče .2. Agenti koji postoje da bi obavili zadatak.org).2 Karakteristična struktura inteligentnog agenta Kategorizacija agenata u odnosu na bazu znanja: • Agenti koji imaju ugrađenu bazu znanja i ne mogu da učeOdluke se donose samo na osnovu sopstvene baze znanja koja se definiše po kreiranju agenta i vremenom se ne menja.Baza znanja se stalno proširuje znanjem koje se preuzima iz okoline.

Pored ova dva vrlo ozbilja projekta IBM alphaWorks je pokrenuo i projekat ROBOCODE (http://robocode.edu/). Osnovni delovi ROBOCODE okruženja Robocode se distribuira u obliku izvršne .jar datoteke pod nazivom robocode-setup. Samo jezgro moguće je proširivati raznim tehnikama za odlučivanje. Nakon instalacije. 4.ibm.Inteligentni agenti FIPA specifikacije su kolekcije standarda kojima se opisuje način povezivanja i koordinacije raznolikih agentskih struktura.J.alphaworks.1.Watson Research Center istraživački centar pokrenuo projekat kojim se razvija okruženje ABLE (Agent Building and Learning Environment). Samo okruženje je zamišljeno kao virtuelno bojno polje u kojem se takmiče inteligentni agenti (tenkovi).umass. kojim je moguće na jednostavan način kreirati agente i pratiti njihovo ponašanje u okruženju u kojem se nalaze. JAF (The Java Agent Framework) je projekat MAS laboratorije (http://mas.html). Prilikom instalacije neophodno je da na računaru bude instalirana verzija Java-e 1. Robocode Robocode projekat je razvijen u edukativne svrhe i njegova namena je da se na atraktivnom primeru promoviše razvoj agent orijentisanog programiranja u programskom jeziku Java.cs. 4. Osnovne funkcije kao i objekti definisani su u ROBOCODE API-ju.3 ili više. Paralelno sa definisanjem specifikacija mnoge kompanije razvijaju sopstvena okruženja za podršku agent orijentisanom programiranju.com/home/home.1. Takmičenje predstavlja simulaciju međusobnog ponašanja više implementiranih agenata ili timova.bat.jar. Potrebno je da se odgovori na pitanje gde će biti instaliran Robocode i da li će se koristi jikes za kompajliranje (IBM-ova verzija Java kompajlera). Tako je na primer IBM T. kojim je takođe implementirano okruženje za razvoj inteligentnih agenata. U nastavku će biti opisano ROBOCODE okruženje. okruženje je spremno za pokretanje izvršavanjem datoteke robocode.1. 87 .

Inteligentni agenti Slika 4. Slika 4. Deo aplikacije namenjen kreiranju i modifikaciji agenata naziva se Robot Editor i prikazan je slikom 4.4 Robot Editor 88 .3 Osnovni prozor ROBOCODE okruženja Crni deo prozora predstavlja bojno polje na kojem se izvršava simulacija.4.

Za vreme izvršavanja. 89 . koji učestvuju u takmičenju. i opremljen je sa radarom (senzor za osmatranje okoline) i topom. Na slici 4. roboti se kreiraju na slučajnim pozicijama. run metode agenata. Da bi se kreirao inteligentni agent potrebno je naslediti klasu Robot ili klasu AdvancedRobot i redefinisati metodu run. 4.2.1.Inteligentni agenti Pokretanje simulacije obavlja se kreiranjem nove bitke (Battle->New). Jedna runda traje sve dok na bojnom polju ne ostane ili jedan robot ili jedna ekipa. roboti unutar jednog tima mogu da razmenjuju poruke. Prilikom pokretanja simulacije. odnosno bitke potrebno je izabrati koji sve roboti učestvuju u takmičenju i koliko rundi će trajati takmičenje.5 Prozor za opis simulacije Po pokretanju bitke (Start Battle). Svaki robot ima funkcije kojima upravlja kretanjem. Slika 4. Robocode API U ovom poglavlju opisan je skup klasa Robocode API-ja.6 prikazan je dijagram osnovnih klasa. izvršavaju se u odvojenim procesima. Za opis simulacije.

90 Robot _Robot WinEv ent BulletMissedEv ent +bullet Bullet +bullet +hitBullet BulletHitBulletEv ent +bullet +bullet _Adv ancedRobot HitByBulletEv ent Robocode BulletHitEv ent ScannedRobotEv ent _Adv ancedRadiansRobot GunTurnCompleteCondition Adv ancedRobot +robot +robot +robot +robot RadarTurnCompleteCondition RobotDeathEv ent HitWallEv ent Inteligentni agenti SkippedTurnEv ent Ev ent HitRobotEv ent DeathEv ent MessageEv ent CustomEv ent +condition Mov eCompleteCondition Condition Slika 4.3 Dijagram klasa Robocode API-ja TeamRobot «interface» Droid TurnCompleteCondition RobocodeFileWriter RobocodeFileOutputStream .

turnLeft(90). import robocode. } } public void onScannedRobot(ScannedRobotEvent e) { fire(1). } } } Metoda ahead koristi se za kretanje unapred. ahead(50). Robot koji pomera radar i top u desno prikazan je klasom Robot2. import robocode. Metoda turnLeft koristi se za pomeranje u levo za ugao (u stepenima) koji se prosledi kao ulazni parametar. U slučaju da robot pre završetka puta naiđe na prepreku metoda se završava i nastavlja se sa izvršavanjem prve sledeće metode.Inteligentni agenti Vrlo jednostavan robot koji se kreće po ivicama kvadrata stranice 50 (jedinica mere rastojanja u prostoru) opisan je klasom Robot1. Metoda onScannedRobot poziva se u slučaju da je radar opazio fire se puca. public class Robot1 extends Robot{ public void run() { while(true) { ahead(50). package ovi. public class Robot2 extends Robot { public void run() { while(true) { turnGunRight(360).java. turnLeft(90). package ovi. Metode back i turnRight koriste se za kreanje unazad i pomeranje u desno na isti način kao metode ahead i turnLeft. Metodom intenzitet paljbe. turnLeft(90).*.*. ulazni parametar je drugog robota. ahead(50). } } 91 . ulazni prametar opisuje dužinu puta koji se prelazi.

import robocode. pomeranja senzora i izvršnih uređaja. double x = getX(). Primer robota koji najkraćim putem ide prema donjem levom uglu prikazan je klasom Robot5.0 Y heading getY() getX() X Slika Osnovne veličine koje opisuju stanje robota 92 .PI.atan(x/y)*180/Math. double y = getY().Inteligentni agenti Ovo su bila dva jednostavna primera na kojima su ilustrovane mogućnosti kretanja robota.*. donji levi ugao je 0. turnRight(180-heading+l1). ahead(10).java package ovi. public class Robot5 extends Robot { public void run() { while(true) { double heading = getHeading(). } } } U ovom primeru prikazano je i nekoliko veoma važnih veličina koji opisuju stanje robota: • getHeading() – ugao kretanja u odnosu na vrh bojnog polja • getX() i getY() – apsolutna pozicija. double l1 = Math.

Na primer. double eHeading = e.sin(getGunHeading()*Math.getDistance()* Math. fire(1). Na osnovu prethodno opisanih metoda proširite metodu onScannedRobot tako da se u njoj procenjuje naredni položaj skeniranog robota. while(true) { turnGunRight(20). Nakon toga napišite robota koji oponaša tuđe kretanje.getDistance()>140) ahead(1). package ovi.println(getTime()+ " scanned robot("+eX+".Inteligentni agenti Pored metoda za kretanje i proveru stanja postoje i metode koje se pozivaju kao rezultat određenog događaja.cos((360-getGunHeading())*Math. Pokušajte da koristite neku od tehnika računarske inteligencije. brzini i smeru kretanja drugog robota. turnRight(e. turnLeft(heading). Napišite robota koji prilikom pucanja uzima u obzir i preticanje. double eY = getY()+e.out. double eVelocity = e.getHeading(). Vežba 2.getVelocity().*. } } Vežba 1. ScannedRobotEvent pored relativnog ugla između radara i smera kretanja sadrži i informaciju o udaljenosti.PI/180). if(e.PI/180). voditi računa o udaljenosti. System. Jedan od takvih događaja je i događaj kad radar (senzor) primeti drugog robota (ScannedRobotEvent).getBearing()). import robocode. brzini drugog robota itd. } } public void onScannedRobot(ScannedRobotEvent e) { double eX = getX()+ e. 93 . public class Robot3 extends Robot { public void run() { double heading = getHeading(). Tom prilikom poziva se metoda onScannedRobot u kojoj je moguće napisati reakciju na događaj. "+eY+")"). možemo odrediti apsolutnu poziciju robota.getDistance()* Math.

Robot ovi. }catch(Exception ex){} } } } Robot62.Robot62". "+getY()).getMessage()). import robocode. Robot61. "SOS "+getX()+".*. U nastavku je dat primer dve klase koje pripadaju istom timu. Naime poruka može u svakom trenutku da se pošalje bilo kojem agentu ekipe. public class Robot62 extends TeamRobot{ public void run() { while(true) { ahead(10).*. public class Robot61 extends TeamRobot { public void run() { while(true) { ahead(10).java package ovi. import robocode. } } Robot Robot61 šalje poruke o svojoj poziciji svim objektima klase ovi. } } public void onMessageReceived(MessageEvent event) { out. metodom sendMessage.Robot62.Robot62 prihvata poruke i ispisuje ih na standardnom izlazu. Koordinacija se postiže komunikacijom koja se odvija između pojedinih agenata tima ili istovremeno svih. dok se primanje poruka obrađuje kao događaj onMessageReceived. 94 .getSender() + " poslao poruku: " + event. try { sendMessage("ovi.println(event. U Robocode okruženju klasom TeamRobot opisan je robot koji pored osobina običnog robota ima i metode slanja i primanja poruka.Inteligentni agenti Jedan od veoma važnih proces u projektovanju agenata jeste koordinacija delovanja.java package ovi.

Vežba 4. 3) po prijemu poruka kreću ka tom mestu. Po stizanju u blizinu roboti javljaju robotu 1 da su stigli. Poruke o stanju okoline šalju robotima čiji je zadatak da se kreću i pucaju prema neprijateljskim robotima.Inteligentni agenti Vežba 3. Dva služe za osmatranje i ne pomeraju se. Njihovi radari stalno skeniraju okolinu. Po pristizanju svi zajedno se upućuju na mesto koje definiše agent 1. 95 . U slučaju uništenja oba izviđačka robota jedan od preostalih pokretnih preuzima ulogu izviđača. Prvi (1) u početku emituje poruke o poziciji sastanka a druga dva (2. 2 i 3). Implementirajte tim koji se sastoji od četiri robota. Implementirajte tim koji se sastoji od tri robota (1.

.

Thinking in Java..0 Reference. Neuro-Fuzzy Systems. B. August 1997.1.J. Artificial Intelligence A modern approach. 1 Language (XML). http://www.w3. Kruse. F. Extensible Markup http://www. Literatura [1] [2] [3] [4] [5] [6] [7] HTML 4.. JDK 1..com/products/jsp/ Eckel.org/TR/REC-html40/ Java Native Interface Specification. R. Norvig P. John Wiley& Sons..sun.. http://java. Klawon. 97 .org/TR/REC-xml Nauck.w3.. Prentice-Hall Internatinoal.8 dokumentacija Java Server Pages.Literatura 5. Russell S. revision 9. D. Inc.

.

99 .

Sign up to vote on this title
UsefulNot useful