Skripta Nova PDF

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
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
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
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
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
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
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
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
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
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
- 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
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
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
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 4 a 2
b b 1 c
c
1 2 f
f
2
d e d e
4
1
g g
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
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
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
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
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
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
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.
U1
W 1j
ΣW U
aktivacija
Ij
ij i
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
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 ui pridružuje se izlazna funkcija koju

realizuje akson i koja preslikava stanje aktivacije u trenutku t u
izlazni signal oi (t ) . 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" :
f ( x ) = ( x − Θ ) ⋅ h( x − Θ )
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 ( w ji ) koja je nosilac znanja i predstavlja
jačinu veze između čvora u j i ui . 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. Ta težina se može podešavati tokom
vremena. Promena vrednosti težina veza naziva se obučavanje.
25
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 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.
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), net j (t ))
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
step_funkcija
 A + b, x ≥ Θ
h( x , Θ, A, b) = 
− A + b , x < Θ
semi-linearna funkcija
 0; x < −Θ
x + Θ
f (x ) =  ;− Θ < x < Θ
 2⋅Θ
 1; x > Θ
i sigmoidna funkcija
1
f ( x) = .
1 − e−x
Na slici prikazana je semi-linearna aktivaciona funkcija
f(net) 1
0
net
-PRAG_AKTIVACIJE 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.
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
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
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 ( Ai ,
Bi ) ) 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
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 ).
I1
W 11
U1 I2
ULAZ
IZLAZ
U2 I3
U3 I4
W 35
I5
Ulazni sloj
Kompetitivni sloj
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:
Ω = {(ulaz j , izlaz j ) j = 1..m} gde je:
ulazi = (a1 ,...an ) , ai ∈ {0,1}
0; i ≠ j
izlaz j = (o1 , o2 ..om ) oi = 
1; i = j
m - broj uzoraka obučavajućeg skupa i broj neurona u izlaznom
sloju
n - broj neurona u ulaznom sloju neuronske mreže
30
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 ; aij = 1
Wi , j = 
1
 ; aij = 0
 KAZNA j
gde je
n
NAGRADA j = ∑ aij
i =1
n
KAZNA j = ∑ (aij − 1)
i =1
Primer 1. Simulirati sistem prikazan slikom
x1 y1
x2 y2
x3 y3
x4 y4
Slika
Ponašanje sistema opisano je sledećom tabelom:
Ulaz Izlaz
x1 x2 x3 x4 y1 y2 y3 y4
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
1 1 W1,1 1 1
W 2,1
0 2 ,1 2
W3
1
4,
W
1 3 3
0 4 4
Slika
gde je W1,1 = 0.5 , W2,1 = −0.5 , W3,1 = 0.5 , W4 ,1 = 0.5
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.
Ovčije boginje
Jaka prehlada
Male boginje
Veliki kašalj
Meningitis
Rubeole
Zauške
Grip
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
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
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
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
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
Izračunaj uticaj greške u

Postavi ulaz za uzorak Izračunaj izlaz Koriguj težine
slojevima
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:
net j = ∑Wi , j ai , gde je j ∈U s i ∈U s −1 , U s je skup indexa neurona u

i
s-tom sloju, ai je izlaz iz i-tog neurona, Wi, j je vrednost težine veze

između j tog i i tog neurona. a j = f ( net j )
Izračunavanje uticaja greške u j-tom neuronu na kriterijumsku

funkciju:
∑ ∑ (t j − a j )
1 2
E=
2 uzorci j∈U n
za neurone u izlaznom sloju:
δ j = f ' (net j ) ⋅ (t j − a j ) ,
gde je t j željeni izlaz, a j je stvarni izlaz
36
za neurone u skrivenim slojevima:
δ i = f ' (neti ) ⋅ ∑δ W
i∈U s +1
j i, j
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:
∆ p W i , j = ηδ ( p)
j a i( p ) + β ∆ q W i , j gde su p i q indexi uzoraka, η
brzina obučavanja, δ (j p ) je uticaj greške u j-tom neuronu, β uticaj
prethodnih promjena, ∆ qWi , j prethodna promjena.
pragovi aktivacija (bias) računa se po formuli
∆ pθ u = ηδ (j p ) + β∆ pθ u
Wi , j = Wi , j + ∆ pWi , j i θ u = θ u + ∆ pθ 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
{Tip u kojem se opisuje jedan sloj}
TSloj = record
n:integer; {Stvaran broj neurona u sloju.}
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}
end;
38
{ 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 s:=2 to slojeviN do
slojevi[s].bias[u] := random;
end;
{ 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:real;
begin
for s:=2 to slojeviN do
for v:=1 to slojevi[s].n do
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:integer;
begin
for u:=1 to slojevi[1].n do
slojevi[1].izlaz[u] := obucavajuciSkup[uzorak, 1, u];
end;
{ Funkcija izracunava vrednost gresaka u svim slojevima pocevsi
od poslednjeg, prema prvom. Greska u poslednjem cvoru racuna
39
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];
greska := greska+sqr(slojevi[slojeviN].sigma[v]);
end;
{Greska u svim ostalim slojevima}
for s:=slojeviN-1 downto 1 do
begin
sigmaa := 0;
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;
izracunajGreske := greska;
end;
{ Procedura na osnovu postavljenih vrednosi gresaka u slojevima

koriguje matrice tezina i pragove aktivacije.}
procedure korigujTezine;
var
s, u, v:integer;
net:real;
begin
for s:=1 to slojeviN-1 do
begin
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
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;
greska :real;
begin
pokusaj:=1;
Inicijalizacija; {Inicijalizacija obucavajuceg skupa.}
repeat
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;
readln;
end.
41
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
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.
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.
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.
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
ulazno i prepoznato izlazno slovo. Ulazne podatke učitavati iz
odgovarajuće datoteke.
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
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
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.
Stepen pripadnosti
100%
0%
130 cm 185 cm Visina
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
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
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
0 1 0 0  0 
 x&   − ( I + ml 2 )b m 2 gl 2   x  I + ml 2 
 &x& 0 0  &  
x 2
 = I ( M + m) + Mml 2 I ( M + m) + Mml 2  ⋅   +  I ( M + m) + Mml u
θ&  0 0 0 1 θ   0 
 &&  − mlb mgl ( M + m)   &  ml 
θ  0 I ( M + m) + Mml 2 I ( M + m) + Mml 2
0 θ 
  I ( M + m) + Mml 2 

Slika 1 a
 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.
M = 0.5 kg masa vozila
m = 0.2 kg masa štapa
N
b = 0 .1 koeficient trenja vozila
m/s
I = 0.006 kg ⋅ m 2 koeficient inercije štapa
l = 0 .3 m dužina štapa
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
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.
Matematički model .
θ
u .
x = Ax + Bu θ
Fazi kontroler
θF Fazifikacija
Defazifikacija u F θFM
uFM Zaključivanje
. .
Fazifikacija
θF θFM
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 Zaključivanje Defazifikacija

θF
N Z P N Z P N Z P
N P P Z
.
θF Z P Z N
P Z N N
pripadnost[Z,1] pripadnost[Z,2] pripadnost[Z,3] 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
∑ θ [i] ⋅ θ&
F F
koji predstavlja upravljačku veličinu. u [ k ] =
F
[ j ] , gde je
i, j
k ∈{N , Z , P} , 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
k ∈{N , Z , P} , a u FM [k ,2] centar k-tog elementa fazi skupa.
50
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
{ Procedura na osnovu zadate vrednosti i funkcija pripadnosti
odredjuje fazi skup koji opisuje datu vrednost }
PROCEDURE fazifikacija(vrednost : real;
pripadnost : faziPripadnost;
VAR skup : faziSkup);
BEGIN
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
skup[P]:=1;
END;
{ 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
uF[pravila[i,j]]:=uF[pravila[i,j]]+thetaF[i]*dthetaF[j];
END;
{ Na osnovu fazi skupa i funkcija pripadnosti izracunava se vrednost }

FUNCTION defazifikacija(skup : faziSkup;
pripadnost: faziPripadnost) : real;
{ Metoda centra tezista }
BEGIN
52
defazifikacija:=skup[N]*pripadnost[N,2]+
skup[Z]*pripadnost[Z,2]+
skup[P]*pripadnost[P,2];
END;
{ 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;
ddtheta:=(-mK*l*b*dx+mK*g*l*(MV+mK)*theta+mK*l*u)/imenilac;
END;
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
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;
UNTIL (c IN ['n','N']);
END.
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
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
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
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
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
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 = "";
retVal += newLine;
if((i==markY)&&(j==markX)) {
retVal += " ";
} else {
if(elements[i][j]<10)
retVal += " "+elements[i][j]+" ";
else
retVal += elements[i][j]+" ";
}
}
newLine="\n";
}
60
return retVal;
}
public String toHash() {

String retVal = "";
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
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);
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
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 static State searchBreadthFirst(State state) {
Vector nodes = new Vector();
boolean solved = false;
nodes.add(state);
String hashCode = state.toHash();
while(solved==false||nodes.size()>0) {
State s = (State)nodes.get(0);
63
counter++;
if(s.isFinished()==true) {
return s;
} else {
Vector v = s.possibleActions();
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:
counter = 0;
State solution = searchBreadthFirst(s);
} else {
}
}
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
(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 static State searchIterativeDeepFirst(State state){
for(int i=1; i<200; i++) {
State solution = state.findSolution(1, states, i);
if(solution!=null)
return solution;
}
return null;
}
.....
65
}
Tada glavni program može da izgleda:

counter = 0;
State solution = searchIterativeDeepFirst(s);
} else {
}
}
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
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 static State searchBiDirectional(State state) {
State finalState = finalState();
Hashtable statesA = new Hashtable();
Hashtable statesB = new Hashtable();
Vector nodesA = new Vector();
Vector nodesB = new Vector();
67
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 {
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 {
if(statesB.get(nextHashCode)==null) {
statesB.put(nextHashCode, next);
nodesB.add(next);
}
}
nodesB.remove(s);
}
}
68
return null;
}
....
}
Glavni program može da izgleda:
counter = 0;
State solution = searchIterativeDeepFirst(s);
} else {
}
}
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
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 int heuristicFunction() {
int retVal = 0;
70
if(elements[i][j] == (i*dimension+j+1) ) {
retVal++;
}
}
}
return retVal;
}
public static State searchAStar(State state) {
Vector nodes = new Vector();
nodes.add(state);
String hashCode = state.toHash();
Comparator c = new StateComparator();
while(solved==false||nodes.size()>0) {
State s = (State)nodes.get(0);
counter++;
if(s.isFinished()==true) {
return s;
} else {
if(states.get(nextHashCode)==null) {
states.put(nextHashCode, "");
nodes.add(next);
}
}
nodes.remove(s);
Collections.sort(nodes, c);
}
}
return null;
}
.....
}
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
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:

counter = 0;
State solution = searchAStar(s);
} else {
72
}
}
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
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
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. ∀X se javlja samo u jednom paru iz S
ii. 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
S 2 = { X=brat(ana), Y=otac(ana) }
A * S 2 : drug(brat(ana), otac(ana)).
Supstitucija S2 a = { X=pera, X=mika } nije dobra zato što se

promenljiva X pojavljuje dva para. Takođe supstitucija
S 2b = {X=marko, Y=X } nije dobra zato što se promenljiva X nalazi i sa
leve i sa desne strane znaka =.
Instanca: Term A je instanca terma B ako postoji takva supstitucija
S tako da važi A = B * S .
Primer:
B : p(X):-q(X), r(X,Y). S3 = { X=a, Y=b }
A = B * S3
A: p(a):-q(a), r(a,b).
Ujedinjivost: Dva terma su ujedinjiva ako imaju zajedničku instancu

C = A* S = B * S
Primer:
A: p(a, Y).
B: p(X, b).
C = A * S3 = B * S 3 ;
C: p(a, b).
Ujedinitelj: Supstitucija S naziva se ujedinitelj.

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).
S 4 = { X=Z, Y=voli(pera, vino) }
76
S5 = { X=3, Z=3, Y=voli(pera, 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.
Primer:
p(X):-q(X), r(X).
P(Y):-q(Y), r(Y).
p(K):-q(K), r(K).
S6 = { X=Y }
S7 = { 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 A1 i A2 konstante onda su ujedinjivi samo ako

su identični.
3. Ako je term A1 promenljiv a A2 proizvoljan term onda

ujedinjavanje uspeva ako se promenljiva A1 ne pojavljuje u
termu A2 . Pri ujedinjavanju A1 sa A2 promenljiva A1
poprima vrednost terma A2 . Ako je obrnuto isto važi.
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
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:
(k1) p(X, Y):-q(X), r(X, Y).
(k2) p(d, 4).
(k3) q(a).
(k4) q(b).
(k5) q(c).
(k6) r(a, 1).
(k7) r(a, 2).
(k8) r(c, 3).
Proces redukovanja cilja ?-p(X, Y) grafički je prikazan na slici 2.XX.
78
Slika 2.XX Grafički prikazan proces redukovanja cilja

Stablo pretraživanja:
1. Koren stabla je polazni cilj C.
2. Neka je cilja oblika ?-C1, C2, ..., Cn. čvor stabla
pretraživanja i neka je C1 pozitivan pod cilj tada taj čvor ima
po jednog potomka za svaku klauzulu oblika G:-T1,...,Tq. za
koju su strukture C1 i G ujedinjive. Tada potomak cilja ?-C1,
C2, ..., Cn. izgleda
?-( T1,...,Tq, C2, ..., Cn)*S
Gde je S najopštiji ujedinitelj struktura C1 i G.

Ujedinjive klauzule traže se odozgo prema dolja i s leva na
desno.
3. Neka je cilj ?-C1, C2, ..., Cn. č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
potomaka. Međutim, ako C1* ima konačno stablo pretraživanja
ali bez grane uspeha onda je potomak cilj ?-C2, ..., Cn
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:
(k1) p(X, Y):-q(X), r(X, Y).
(k2) p(d, 4).
(k3) q(a).
(k4) q(b).
(k5) q(c).
(k6) r(a, 1).
(k7) r(a, 2).
(k8) r(c, 3).
Ako je zadata cilj ?-P(X, Y) onda je odgovarajuće stablo

pretraživanja prikazano na slici 2.X1.
80
(1) ?-p(X, Y).
(k1) (k2)
S7={X=d, Y=4}
(2) ?-q(X),r(X, Y). (9) []

Odgovor:
(k3) (k4) (k5) X=d, Y=4
S1={X=a} S3={X=b} S5={X=c}
(3) ?-r(a, Y) (6) ?-r(b, Y) (7) ?-r(c, Y)

(k6) Čvor (k8)
(k7)
S2={Y=1} neuspeha! S6={Y=3}
S4={Y=2}
(4) [] (5) [] (8) []
Odgovor: Odgovor:
Odgovor: X=c, Y=3
X=1, Y=1 X=a, Y=2
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:
(k1) r(ivan, toma).
(k2) r(mara, toma).
(k3) r(toma, petar).
(k4,1) p(X, Y):-r(X,Y).
(k5,1) p(X, Y):-r(X,Z), P(Z, Y).
Za cilj ?-predak(ivan, X). generiše se sledeće stablo pretraživanja:
81
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 k4 i k5-
(k1) r(ivan, toma).
(k2) r(mara, toma).
(k4,2) p(X, Y):-r(X,Z), P(Z, Y).
(k5,2) p(X, Y):-r(X,Y).
Sad za isti upit dobijamo drugačije stablo pretraživanja:
82
(1) ?-p(ivan, X).
k4,2*S1: p(X1,Y1):-r(X1, Y1).
S1={X=X1, Y=Y1} k5,2*S1: p(X1,Y1):-r(X1, Z),p(Z,Y1).
S2={X1=X} (k5,2*S1)*S2 (k4,2*S1)*S2
(2) ?-r(ivan, Z), p(Z, X). (10) ?-r(ivan, X).

S3={Z=toma} S6={X=toma}
(k1) (k1)
(3) ?-p(toma, X). (11) ?-[].

Odgovor:
(k5,2*S1)*S2 (k4,2*S1)*S2 X=toma
(4) ?-r(toma, Z),p(Z, X). (8) ?-r(toma, X).

S4={X=petar}
S5={Z=petar}
(k3)
(k3)
(5) ?-p(petar, X). (9) ?-[].

Odgovor:
X=petar
(k5,2*S1)*S2 (k4,2*S1)*S2
(6) ?-r(petar, Z),p(Z, X). (7) ?-r(petar, X).

Čvor Čvor
neuspeha! 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. Ako se pažljivo pogleda drugo stablo pretraživanja
je «u ogledalu» preslikano prvo stablo.
Rešenje 3:
(k1) r(ivan, toma).
(k2) r(mara, toma).
(k5,3) p(X, Y):-r(X,Y).
(k4,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
(1) ?-p(ivan, X).
S1={X=X1, Y=Y1} S2={X1=X}
k5,3*S1: p(X1,Y1):-r(X1, Z),p(Z,Y1).
k4,3*S1: p(X1,Y1):-r(X1, Y1).
(k5,3*S1)*S2
(k4,3*S1)*S2
(2) ?-r(ivan, X). (4) ?-p(Z, X),r(ivan,Z).
S3={X=toma} (k5,3*S1)*S2
(k4,3)
(k1)
(3) ?-[]. (5) ?-r(Z, X),r(ivan,Z). (10) ?-p(Z1, X),r(Z, Z1),r(ivan, Z).
Odgovor: S6={Z=toma, X=petar}

S4={Z=ivan, X=toma}
X=toma
(k1) (k3)
(k4,3)
(6) ?-r(ivan, ivan). (8) ?-r(ivan, toma). (11) ?-r(Z1, X),r(Z,Z1),r(ivan, Z). .....
(k1)
Čvor
neuspeha! S5={Z=mara, X=toma}
(9) ?-[].
(k2) S9={Z1=toma, X=petar}
Odgovor:
(7) ?-r(ivan, mara). X=petar S7={Z1=ivan, X=toma}
(k1) (k3)
S8={Z1=mara, X=toma}
Čvor (12) ?-r(Z,ivan),r(ivan, Z).
(13) ?-r(Z,toma),r(ivan, Z).
neuspeha! (k2)
Čvor Čvor
neuspeha! neuspeha!
(12) ?-r(Z,mara),r(ivan, Z).
Čvor
neuspeha!
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 k4,3 i
k4,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
90
_Robot BulletMissedEv ent WinEv ent RobotDeathEv ent HitWallEv ent
Robot
+bullet
Bullet +hitBullet BulletHitBulletEv ent

+bullet SkippedTurnEv ent
Inteligentni agenti
+bullet
Ev ent
+bullet HitRobotEv ent
_Adv ancedRobot HitByBulletEv ent
Robocode BulletHitEv ent DeathEv ent
ScannedRobotEv ent
_Adv ancedRadiansRobot MessageEv ent

CustomEv ent
GunTurnCompleteCondition
+condition
Condition
+robot Mov eCompleteCondition
Adv ancedRobot +robot
+robot
+robot
Slika 4.3 Dijagram klasa Robocode API-ja

RadarTurnCompleteCondition
«interface» RobocodeFileWriter
TeamRobot
Droid RobocodeFileOutputStream
TurnCompleteCondition
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 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
getY()
X
getX()
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 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

Skripta Nova PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Skripta Nova PDF

Uploaded by

Copyright:

Available Formats

Univerzitet u Novom Sadu

Fakultet tehničkih nauka

Zora Konjović, Đorđe Obradović

Zbirka zadataka iz predmeta

Novi Sad, mart 2003

2.1.1. Teorijska osnova

2.1.2. Softwerske tehnike

Slika 2.1 Primer rodbinskih veza

Program 2.1 Roditeljske veze

Gde predikat predstavlja ime relacije koja povezuje objekte Arg1,

Program 2.2. Primer korišćenja promenljivih

Program 2.3 Primer definisanja pravila

Program 2.4 Primer pravila

Program 2.5 Kombinacija više činjenica u jednom pravilu

Program 2.6 Logički operator I

Program 2.7 Rekurzivna pravila

Recimo pitanje «Ко је Markov otac?» u PROLOG-u bismo napisali:

ili pitanje «Da li je Toma Markov otac?» napisali bismo ovako:

Odgovor No u PROLOG-u se interpretira kao nemogućnost donošenja

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

Slika 2.2 Podela osnovnih elemenata PROLOG-a

b) Predikat kojim se proverava da li se neki element nalazi u listi.

c) Spajanje dve liste

obrni1(L, OL):-obrni(L, [], OL).

е) Brisanje elemenata iz liste. (Prvog u listi.)

f) Dodavanje elementa u listu

g) Permutacija elemenata liste i sortiranje

sortiraj(L, SL):-permutacija(L, SL), uredjena(SL).

Slika 2.5 Binarno stablo

Sledi nekoliko najvažnijih predikata koji opisuju binarno stablo i

b) Predikat kojim se proverava da li se element nalazi u binarnom

Specijalan slučaj binarnog stabla je uređeno binarno stablo u kojem

d) Predikat kojim se dodaje element u uređeno binarno stablo

e) Predikat kojim se briše element iz binarnog stabla.

najveci(st(Ym, L, p), Ym, L).

f) Predikat za konverziju liste u uređeno binarno stablo

g) Predikat za konverziju binarnog stabla u listu.

2.1.3. Primeri i zadaci za vežbu

Vežba 1. Upoznavanje sa SWI PROLOG interpreterom

Neposredno iza znaka '?-' postavljaju se upiti.

4. Novi program pišemo

Slika 2.4 Model porodičnog stabla

Na osnovu ovog predikata napišite predikate predak2 (u kojem je

Vežba 2. Rad sa listama

5. Napišite predikate koji obrću listu i brišu element iz liste. Brisanje

Vežba 3. Rad sa binarnim stablom

Vežba 6. Rad sa grafovima

Diskusija: Podatke o grafu smestiti u bazu podataka tako da

što znači da postoji veza između tačaka a i b. Sledeći problem koji

Međutim elegantnije rešenje je da napišemo dodatni predikat koji

Predikat koji poziva predji1 i omogućuje prikazivanje rezultata

Ako probate ovaj program na nekoliko primera, možete utvrditi da

Na ovaj način možemo da pređemo sve puteve između dve zadate

Drugi deo zadatka zahteva da proširite podatke o grafu cenama. To je

Na osnovu ovog primera, modifikujte predikat povezani, i predikate

Vežba 5 Diferenciranje matematičkih izraza

Vidimo da se radi o rekurzivnoj relaciji koja kao prvi argument prima

Da bi mogli da tražimo izvode polinoma potrebno je na odgovarajući

Izvod stepenovane promenljive tada izgleda ovako :

Sami napišite klauzule koje nedostaju. Obratite pažnju na izvod

Obratite pažnju na činjenicu da matematičke operacije koje su

Treća grupa klauzula je tu da omogući dalju analizu i uprošćavanje

Program sastavljen po ovim uputstvima bi trebalo da bude u stanju