OBLIKOVANJE KOMBINACIJSKIH MREŽA UPORABOM … · početna mreža od pet sklopova minimizira na samo jedan sklop, a broj ulaza i izlaza pri tom ostaje konstantan te su mreže po kombinaciji

SVEUČILIŠTE U ZAGREBU

FAKULTET ELEKTROTEHNIKE I RA ČUNARSTVA

ZAVRŠNI RAD br. 951

OBLIKOVANJE KOMBINACIJSKIH MREŽA UPORABOM EVOLUCIJSKIH ALGORITAMA

Iva Brajer

Zagreb, lipanj 2009.

I have called this principle, by which each slight variation, if useful, is

preserved, by the term of Natural Selection.

Charles Darwin

Sadržaj

Uvod ............................................................................................................................ 1

1. Opis problema .......................................................................................................... 2

1.1. Sastavljanje kombinacijskih mreža ............................................................................. 2

1.2. Optimizacija kombinacijskih mreža ............................................................................ 3

1.3. Primjena evolucijskih postupaka nad izradom kombinacijskih mreža ....................... 6

2. Primjena genetskog programiranja na zadani problem .............................................. 7

2.1. Genetsko programiranje i kombinatorna eksplozija .................................................. 7

2.2. Prijedlog rješenja ........................................................................................................ 9

2.2.1. Inicijalno okruženje .............................................................................................. 9

2.2.2. Stablasti genotip .................................................................................................. 9

2.2.3. DigitalCircuit algoritam ...................................................................................... 10

2.2.3.1. DigitalCircuit evaluacijski operator ............................................................. 12

2.2.3.2. Operator minimizacije ................................................................................ 15

2.2.3.2.1. Karnaughove tablice ............................................................................ 15

2.2.3.2.2. Izrada tablica ....................................................................................... 17

2.2.3.2.3. Grupiranje tablica ................................................................................ 20

2.2.3.2.4. Sastavljanje logičkog izraza ................................................................. 27

2.2.3.2.5. Stvaranje novog podstabla .................................................................. 28

2.2.3.3. Operator zamjene ....................................................................................... 32

2.2.3.3.1. Zamjenski oblici čvorova ..................................................................... 32

2.2.3.3.2. Traženje čvorova za zamjenu .............................................................. 33

2.2.3.3.3. Usporedba podstabala ........................................................................ 37

2.2.3.3.4. Provedba zamjene čvorova ................................................................. 40

2.2.4. Konfiguracijska datoteka ................................................................................... 42

3. Analiza rezultata ..................................................................................................... 46

3.1. Ispitivanje .................................................................................................................. 46

3.2. Ispitni primjerci ......................................................................................................... 50

3.3. Rezultati ispitivanja ................................................................................................... 52

3.3.1. Ispitni primjerak 1 .............................................................................................. 52

3.3.1.1. Bez operatora minimizacije i zamjene........................................................ 53

3.3.1.2. Uz parametar by_indvididual ..................................................................... 57

3.3.1.3. Uz parametar by_generation ..................................................................... 60

3.3.1.4. Uz parametar by_algorithm ....................................................................... 63

3.3.1.5. Analiza dobivenih rezultata ........................................................................ 67




Zaključak .................................................................................................................... 82

Dodatak ..................................................................................................................... 84

Literatura ................................................................................................................... 85

Sažetak ...................................................................................................................... 89

1

Uvod

„Priroda je sve što nas okružuje“ - najjednostavnija moguća definicija s kojom se upoznaje

pri prvom kontaktu s definicijom prirode otkriva mnogo više nego što se možda na prvi

pogled doima.

Priroda je glavna pretpostavka života, naša svakodnevica, naša inspiracija. Sve što priroda

stvara djeluje možda iznimno slučajno i trivijalno, a opet toliko čudesno i neshvatljivo.

Stoga ne treba čuditi činjenica da se inspiracija prirodnim pojavama pojavljuje i u

području računarske znanosti, odnosno grani umjetne inteligencije, jer ono što je oduvijek

predstavljalo problem u računarstvu jest pronalazak rješenja u konačnom vremenu.

Algoritmi koji pronalaze rješenje u konačnom vremenu i baziraju se na inspiraciji iz

prirode, rade na temelju prirodnih slučajnih procesa koji bez obzira na svoju trivijalnost,

polučuju fascinantno kvalitetne rezultate.

U ovom završnom radu, nastoji se riješiti problem automatskog oblikovanja

kombinacijskih mreža uz pomoć evolucijskih algoritama, točnije genetskog programiranja.

Uz sve pogodnosti koje genetsko programiranje pruža, pri formiranju rješenja upotrijebile

bi se i dodatne funkcionalnosti za optimizaciju mreža te se omogućilo postavljanje raznih

parametara koji ovisno o načinu vrednovanja mreže, lakše usmjeravaju algoritam prema

traženom rješenju.

U prvom poglavlju opisana je problematika pri oblikovanju kombinacijskih mreža te zašto

je genetsko programiranje prigodno za rješavanje tog problema. Drugo poglavlje

posvećeno je prijedlogu rješenja implementacije sustava za automatsko oblikovanje

kombinacijskih mreža te su izložene neke dodatne funkcionalnosti ugrađene u taj sustav.

U trećem poglavlju osvrnulo se na analizu rezultata nad pojedinim ispitnim primjercima

čije je mreže sustav morao oblikovati te su obrađena statistika i izvedeni zaključci dani na

uvid.

2

1. Opis problema

1.1. Sastavljanje kombinacijskih mreža

Digitalne mreže su skupovi međusobno povezanih logičkih vrata (sklopova) koji za neke

ulazne vrijednosti daju jednu ili više izlaznih vrijednosti, a mogu se podijeliti na

kombinacijske i sekvencijske mreže. Kombinacijske mreže se razlikuju od sekvencijskih u

tome što ne sadrže memorijske elemente unutar svojeg skupa logičkih vrata [1].

Zbog jednostavnosti korištenja te nedostatku potrebe za memorijskih elementima, u

ovom će radu biti riječ o kombinacijskim mrežama, a zbog jednostavnosti, upotrebljavat

će se termin mreže koji onda, naravno, podrazumijeva isključivo kombinacijske mreže.

Prilikom konstrukcije kombinacijskih mreža, konstruira se zapravo niz logičkih izraza

(Booleovih formula), ovisno o broju izlaza, koji daju točno određeni izlaz za određenu

grupaciju ulaza. Ponekad podudaranje neke kombinacije ulaza sa željenim izlazom zna

predstavljati problem pri konstrukciji ispravne mreže, pogotovo ako je broj ulaza i izlaza

vrlo velik (ili čak samo ulaza).

Ukoliko je konstrukcija kombinacijske mreže prepuštena nekom inženjeru ili nekom timu

inženjera i broj sklopova se u jednom trenutku počinje gomilati, nastaju problemi u

međuovisnosti ulaza i odabrane strukture mreže koja daje neke izlaze. Postavlja se pitanje

hoće li ti izlazi uvijek biti ispravni, odnosno hoće li se kao rezultat neke ulazne kombinacije

uvijek dobiti željeni izlaz, točnije, nameće se važnost verifikacije strukture kombinacijske

mreže.

Upravo iz tih razloga razvijaju se alati koji osim što sami oblikuju kombinacijsku mrežu,

ujedno i verificiraju njenu strukturu dajući na uvid statističku analizu mreže iz koje je

vidljiva i korisnost same mreže. Ti alati uvelike olakšavaju i ubrzavaju posao inženjerima,

uz uvjet da odabir alata uvelike utječe i na samu kvalitetu rezultata.

3

1.2. Optimizacija kombinacijskih mreža

Generiranjem strukture kombinacijske mreže i verifikacijom te iste mreže, može se biti

uvjeren u ispravnost njezinog rada. Međutim, postoje još neki faktori na koje bi se trebala

naročito obratiti pozornost pri konstrukciji strukture mreže. Tih faktora je mnogo, tako da

će biti izdvojena dva najvažnija, minimizirani oblik mreže te maksimalno vrijeme kašnjenja

logičkih vrata.

Neka se pretpostavi da postoji skup sklopova u mreži koji za određene ulaze daje

određene izlaze te su svi sklopovi u skupu povezani na proizvoljan način. Tada se može

slobodno tvrditi da to sigurno nije jedinstven način prikaza te mreže. Odnosno, to znači da

se za istu kombinaciju ulaza može konstruirati mnogo različitih mreža koje daju iste izlaze

kao i početna mreža. Prema tome, može se zaključiti da postoje mreže koje su

ekvivalentne početnoj mreži te čiji je skup sklopova manji te analogno tome, one čiji je

skup sklopova veći od onog iz početne mreže.

Neka se promotre sada ekvivalenti početne mreže koji imaju manji broj sklopova za

razliku od početne. Ako se zna da su početna mreža i neki od tih ekvivalenata istovjetni,

postavlja se pitanje može li se nekako, gledano iz početne mreže, doći do strukture tog

ekvivalenta. Odgovor je potvrdan i vodi k novom pojmu minimiziranog oblika mreže.

Minimizirani oblik mreže predstavlja pojam koji označava metodu kojom se iz trenutne

strukture mreže može dobiti istovjetna mreža s puno manjim brojem sklopova [2].

Postoje razne metode koje mogu minimizirati mrežu, na primjer primjenom osnovnih

Booleovih aksioma i teorema [2], Quine-McCluskeyeva metoda [2], Karnaughove tablice

[2], Espresso algoritam [3], On Chip logička minimizacija [4] i slične metode. U ovome

radu pozornost će biti usmjerena na minimizaciju mreže Karnaughovim tablicama koja je

dobro poznata i uvriježena metoda minimizacije mreža.

Minimizacija je važna iz više razloga, osim što smanjujući broj sklopova daje veću

preglednost same mreže, ujedno i ostavlja veći manevarski prostor na integriranoj pločici

na kojoj je ta mreža implementirana.

4

Primjer jedne takve minimizacije nalazi se na niže prikazanoj slici (vidi: Slika 1.) gdje se

početna mreža od pet sklopova minimizira na samo jedan sklop, a broj ulaza i izlaza pri

tom ostaje konstantan te su mreže po kombinaciji ulaza i izlaza istovjetne.

Slika 1. Usporedba početne i optimizirane mreže [5]

Drugi faktor kojeg vrijedi spomenuti je maksimalno vrijeme kašnjenja logičkih vrata,

odnosno sklopova. Neka se jedan sklop zamisli kao apstraktna logička vrata koja imaju

predodređeno vrijeme obrade svojih ulaza i puštanje rezultata obrade na svoje izlaze. Ako

se sada tu definiciju primjeni na čitavu mrežu, uvidjet će se da svi sklopovi međusobno

doprinose zajedničkom kašnjenju krajnjih izlaza mreže. Za izlaz koji zadnji primi digitalni

signal koji predstavlja njegovu krajnju vrijednost se može gledati vrijeme proteklo kako bi

taj signal do njega stigao. Tada se to vrijeme naziva maksimalno vrijeme kašnjenja logičkih

vrata za tu mrežu.

Najčešće je cilj da se maksimalno vrijeme kašnjenja svede na najmanju moguću mjeru jer

se time ubrzava rad same mreže, a i drugih mreža koje možda ovise o njoj te se stoga

uvode razne tehnike kojima se to uspijeva reducirati. S jedne strane, vrijeme kašnjenja se

može reducirati već i samim postupkom minimizacije, međutim to ne mora uvijek vrijediti

5

jer se kod kašnjenja ne govori o količini sklopova u nekoj mreži nego o broju razina neke

mreže.

Razina u mreži je niz sklopova koji u istom vremenskom trenutku primaju sve ulaze i

odašilju izlaz koji se propagira dalje kroz mrežu. Točnije gledano, važnije je da su to

sklopovi koji u istom vremenskom trenutku daju izlazne vrijednosti [2].

Na ranije prikazanoj slici (vidi: Slika 1.) početna mreža ima tri razine koje su već na samoj

slici grupirane i jasno vidljive, a optimizirana mreža ima samo jednu razinu. Očigledno je

da se nad ovim primjerom osim minimizacije broja sklopova postiže i redukcija

vremenskog kašnjenja, odnosno jednom riječju, optimizacija mreže.

U nastavku rada, redukcija maksimalnog mogućeg kašnjenja logičkih vrata, odnosno

sklopova, će se podrazumijevati pod pojmom redukcije broja razina mreže.

Važno je da se ta dva pojma dobro shvate i usvoje kako bi se mogla lakše pratiti

programska implementacija sustava za optimizaciju mreža koja je predložena u ovom

radu.

6

1.3. Primjena evolucijskih postupaka nad

izradom kombinacijskih mreža

Evolucijski postupci su često korišteni kao alat za otkrivanje novih načina oblikovanja

digitalnih mreža. Takvi alati imaju vrlo često i potpuno drugačiju logiku rada od ljudskog

pristupa koji najčešće gradi mrežu pristupom odozgo prema dolje1 (eng. top-down

approach). U zadnje vrijeme, spominje se čak i hipoteza o tome kako bih se intenzivnim

proučavanjem oblikovanja digitalnih mreža uz pomoć evolucijskih postupaka, moglo

postići nove, efikasnije i generalizirane principe oblikovanja mreža [6].

Od evolucijskih postupaka, neki su voljni izrađivati digitalne mreže uz pomoćnih genetskih

algoritama uz binarnu reprezentaciju genotipa (eng. binary genotype) te time postižu vrlo

dobre rezultate [7] [8] [9] [10].

Međutim, u ovom radu je umjesto genetskim algoritmima, pozornost posvećena

genetskom programiranju, koje je, pogotovo za kompleksnije mreže, ponekad čak i

prikladnije koristiti nego genetske algoritme [11] [12].

Problem sastavljanja digitalne mreže se može promatrati i kao problem simboličke

regresije2. Kod simboličke regresije, obzirom da postoje točke i spojnice između njih,

povoljno je izabrati reprezentaciju genotipa koja će to vjerno prikazivati. Stoga se za

reprezentanta često uzima stablasti genotip (eng. tree genotype) [12].

Prikladnost uporabe stablastog genotipa i simboličke regresije logičkih izraza koji

predstavljaju kombinacijsku mrežu postat će jasna na konkretnom primjeru u drugom

poglavlju gdje se raspravlja o implementaciji samog rješenja. Detaljnije o pogodnostima

uporabe genetskog programiranja za oblikovanje digitalnih mreža može se pronaći u [12].

1 Pristup odozgo prema dolje je način izrade nekog sustava tako da se on prvo razmatra kao cjelina, bez

uvođenja detalja, te se nakon toga postupno dijeli na podsustave koji se naknadno detaljno sagledavaju [34]. 2 Simbolička regresija je proces određivanja simboličkog izraza na temelju unaprijed određenih točaka i

spojnica među njima [31].

7

2. Primjena genetskog programiranja na

zadani problem

2.1. Genetsko programiranje i kombinatorna

eksplozija

Ljepota uporabe evolucijskih postupaka, pa tako i genetskog programiranja, je u tome što

ne postoji jedinstveno rješenje problema nego njih može biti mnogo, bilo istovjetnih, ali

prikazanih na više različitih načina, bilo neistovjetnih, a međusobno dovoljno bliskih po

količini podudaranja sa željenim rezultatima.

Ukoliko je tome uistinu tako, postavlja se pitanje koje onda rješenje odabrati kao konačno

kako bi ga se upotrijebilo u daljnjim procesima izgradnje integriranih sklopova. Odgovor

na to pitanje uvelike ovisi o potraživanjima onih koji tu mrežu žele koristiti. Na primjer,

nekome možda neće smetati malo veći broj sklopova ako su sklopovi grupirani tako da na

svakoj razini obitavaju samo istovjetni sklopovi iz razloga jer im to ubrzava proces

izgradnje integriranih pločica. S druge strane, nekome će biti itekako važno da je taj broj

sklopova što manji zbog ograničenosti mjesta na integriranoj pločici jer su ostala mjesta

predodređena za implementacije drugih komponenata kao što mogu biti na primjer, razni

utori, rashladne komponente ili mini-napajanja.

Broj mogućih rješenja eksponencijalno raste ukoliko je genetskom programu dano kao

mogućnost korištenje i podešavanje raznih parametara. Ponekad je čak teško odlučiti se s

kojim parametrima uporabiti određeni genetski program koji bi trebao izbaciti kao

rješenje strukturu neke mreže jer neki parametri mogu biti podjednako važni. Čak ako se

treba odrediti postotak važnosti nekog parametra, to zna biti vrlo težak zadatak jer ljudi

su više navikli određivati je li neki parametar važniji od drugoga, a ne na izražavanje

važnosti u postotcima s obzirom na ukupna očekivanja od samog rješenja.

8

Postoje metode koje olakšavaju odabir tako da se uzmu svi važeći parametri u obzir.

Pritom se pri izvršavanju genetskog programa gleda na vrijednosti svih parametara

podjednako ili kako već korisnik odredi, a ne na vrijednost jednog u određenom postotku

pa drugog u određenom postotku i tako dalje. Jedna od takvih metoda je korištenje

višekriterijskog genetskog programiranja (eng. multi-objective GP) [13], ali o takvim

metodama u ovom radu neće biti riječ, već su takve metode ostavljene za buduće

nadogradnje trenutno implementiranog sustava.

Upravo iz tih razloga (višestrukost rješenja i teškoće pri odabiru parametara),

preporučljivo je raditi statističke analize nad svim rezultatima koje je genetski program

izbacio kod proizvoljnog broja pokretanja. Bez obzira što je genetski program radio s

parametrima koji su prilagođeni zahtjevima oko krajnjeg izgleda mreže, i nad samim

rezultatima se mogu primijeniti ti isti zahtjevi kako bi se izlučilo ne možda najbolje, nego

najpovoljnije rješenje s obzirom na trenutne okolnosti [14].

Statistička analiza se iz gore navedenih razloga provodi i u ovom radu nad nekolicinom

odabranih primjera mreže (treće poglavlje).

9

2.2. Prijedlog rješenja

2.2.1. Inicijalno okruženje

Rješenje je implementirano na već postojećem programskom okviru (eng. framework) koji

služi kao podloga za izgradnju programski implementiranih evolucijskih postupaka. Na

njemu je razvijena zasebna grana programskog okvira koja se bavi isključivo oblikovanjem

kombinacijskih mreža i njihovom optimizacijom [15], ali koristi se na isti način kao i

prvotna verzija programskog okvira, o čemu se nešto više može naći u [16].

Prije odvajanja na posebnu granu razvoja, u programskom okviru su bili implementirani

svi važniji dijelovi tako da je bilo potrebno samo dodati novi algoritam za oblikovanje

kombinacijskih mreža i novi evaluacijski operator kojeg taj algoritam koristi. Dodana su i

dva operatora koji se koriste za optimizaciju mreže i naposljetku su nad već ranije

ugrađenim stablastim genotipom napravljene manje izmjene kako bi se programski okvir

pripremio za rad s Booleovim (logičkim) vrijednostima.

Sve kasnije nadogradnje inicijalnog programskog okvira opisane su u nastavku teksta.

2.2.2. Stablasti genotip

Stablasti genotip (eng. tree genotype) je nešto što vrijedi spomenuti prije prelaska na opis

nadograđenih elemenata kako bi se njegova struktura i primjena dobro usvojila.

Takva vrsta genotipa je uobičajena za genetsko programiranje i svodi se na prikaz jedinke

uz pomoć stabla. Svaki čvor u tom stablu naziva se primitiv, a primitivi se dijele na

funkcije, terminale i konstante. Funkcijski čvorovi su oni čvorovi koji predstavljaju neku

operaciju (npr. sinus, kosinus, zbrajanje, oduzimanje), a terminalski čvorovi su zapravo

varijable kojima se pri evaluaciji jedinke pridaju neke vrijednosti (npr. x, y, A, B).

Konstante su čvorovi kojima je vrijednost već unaprijed definirana (npr. 1, 2, Ana, Mario)

10

iz također unaprijed definirane domene konstantnih vrijednosti iz koje se dodjeljuju

vrijednosti i terminalima pri evaluaciji [12].

Svaki čvor u stablu osim svog tipa (funkcija, terminal, konstanta) pamti i broj argumenata

koje će primiti kao svoju djecu, svoj naziv i još manje važne atribute. Stablo je pak

indeksirano tako da se zna točno pozicija svakog čvora u stablu, a indeksiranje se provodi

tzv. indeksiranjem s prvenstvom prethodnika (eng. pre-order) [17] (vidi: Slika 2.).

Za oblikovanje mreža, predviđene su samo logičke operacije nad ulaznim podacima tako

da su imena funkcijskih čvorova definirane kao NOT, AND, OR, XOR, XNOR, NAND i NOR.

Konstante mogu biti samo 1 i 0, a terminali, odnosno varijable su proizvoljni nazivi, jedino

što ne bi smjeli biti istovjetni nazivima funkcija ili konstanti.

Slika 2. Primjer indeksiranog pre-order stabla [18]

2.2.3. DigitalCircuit algoritam

Ovaj algoritam je zamišljen tako da pokrije većinu jednostavnih primjera mreža koji se

mogu naći navedeni u raznim literaturama. Za sam postupak implementacije algoritma ne

postoji nikakva službena literatura nego je u potpunosti osmišljen od samih temelja,

počevši od same ideje implementacije, pseudokoda i konačno, sve do programske

11

implementacije. Iz upravo tog razloga, algoritmu će biti posvećeno malo više pažnje u

daljnjem tekstu.

Postupak izvođenja algoritma može se opisati kratkim pseudokodom:

initialize(); run() {

for i in num_of_individuals evaluate (population.deme[i]);

for i in num_of_generations

advance_generation(population.deme); }

Na početku, algoritam se mora inicijalizirati pri čemu on sam inicijalizira objekte koji su

mu potrebni kao što su selekcijski operatori3 (oni se stvaraju pri stvaranju samog objekta

algoritma). Osim toga, stvara objekte koji su mu potrebni ukoliko su definirani u

konfiguracijskoj datoteci (o njoj će biti riječ i kasnije) kao što su operator minimizacije i

operator zamjene.

Prilikom pokretanja algoritma, prvo se evaluiraju sve jedinke u populaciji određenim

evaluacijskim operatorom4 (koji je objašnjen nešto kasnije). Nako toga se ovisno o broju

unaprijed zadanih iteracija, odnosno broja generacija kroz koje će populacija jedinki

evoluirati, provodi sama srž algoritma koja je sadržana u ovom isječku pseudokoda:

advance_generation(deme) { for i in deme.num_of_individuals

individual1 = get_best_individual(deme); individual2 = get_random_individual(deme); individual3 = get_worst_individual(deme);

//križanje prve dvije jedinke, dijete ide na mjesto treće crossover.mate(individual1, individual2, individual3); mutation.mutate(individual3);

evaluate(individual3); }

3 Selekcijski operator na temelju nekog svojstva pretražuje populaciju i pronalazi jedinku koja najbolje

odgovara tom svojstvu [13]. 4 Evaluacijski operator za neku jedinku radi procjenu o njenoj dobroti (eng. fitness) na temelju nekih

unaprijed definiranih značajki koje su karakteristične za cijelu populaciju jedinki [13].

12

Prolazeći kroz svaku generaciju zasebno, u svakoj iteraciji se prenosi čitava podpopulacija

(eng. deme) te se iteriranjem kroz podpopulaciju odabiru tri jedinke. Prva jedinka koja je

po svojoj dobroti najbolja, druga se odabire sasvim slučajno i treća koja je po svojoj

dobroti najgora. Zatim se nad prve dvije izvršava operacija križanja te nastaje jedno dijete

koje zamjenjuje onu najgoru jedinku nakon čega se to dijete prenosi na operator mutacije

i nakon završetka mutacije se ponovno evaluira.

Algoritam bez nekakvih dodatnih funkcionalnosti radi poprilično jednostavno i

zadovoljava najbitnije kriterije, ali ne i malo manje važne kriterije (što će se pokazati

statističkom analizom u trećem poglavlju). Pod dodatnim funkcionalnostima misli se na

njegova dva operatora, operator minimizacije i operator zamjene. Oni osim što smanjuju

broj sklopova i razina same mreže, pojednostavljuju mrežu izbacujući redundantne

sklopove te određene dijelove mreže zamjenjuju s njihovim puno manjim ekvivalentima.

Riječ je zapravo o pojednostavljenju temeljenom na pravilima (eng. rule based

simplification) [19] ili se to još može u raznim literaturama pronaći pod pojmom

uređivanja (eng. editing) [12]. Kako i gdje se točno pokreću ta dva operatora u samom

algoritmu, bit će objašnjeno u potpoglavlju o konfiguracijskoj datoteci.

2.2.3.1. DigitalCircuit evaluacijski operator

Već je otprije poznato da je evaluacija zapravo procjena dobrote (eng. fitness) neke

jedinke u odnosu na neke zajedničke karakteristike cijele populacije jedinki (vidi: Fusnota

4). Međutim, procjena dobrote neke jedinke nije jednaka za sve probleme koji se

pokušavaju rješavati genetskim programiranjem pa tako je i problem optimizacije mreža

specifičan i za njega se treba osmisliti poseban način vrednovanja jedinki.

Za potrebe osmišljanja evaluacijskog operatora za ovaj problem, bilo je potrebno

sagledati što zapravo predstavlja jedna jedinka u populaciji, a to je jedan način

konstrukcije mreže. To bi značilo da je čitavo stablo5 jedna mreža, a njegovi čvorovi su

5 Podsjetnik da se koristi stablasti genotip (eng. tree genotype) koji je uobičajen za genetsko programiranje

[12].

13

pojedinačni sklopovi, osim listova koji su zapravo spojnice ulaza, a digitalni signal se

propagira od listova prema korijenu stabla. Drugim riječima, korijen stabla je izlazni sklop

koji daje konačnu izlaznu vrijednost, a listovi stabala su spojnice ulaza koje primaju ulazne

vrijednosti.

Pretpostavka je da je za rješenje problema potrebno kao obavezne parametre predati

programu sve kombinacije ulaznih vrijednosti koje se mogu pojaviti u paru s njihovim

izlaznim vrijednostima. Prema tome, dobrota jedinke se može definirati na vrlo

jednostavan način kao broj pogodaka, odnosno brojem evaluacija korijenskog čvora

(odnosno, cijelog stabla) kojima se za različite ulazne vrijednosti dobiva točna izlazna

vrijednost.

Za dobrotu se mogu uzeti, osim broja pogodaka, i broj sklopova od kojeg se mreža sastoji

(odnosno, zbog jednostavnosti, neka to bude broj čvorova u stablu) ili broj razina te

mreže (odnosno, opet zbog jednostavnosti, maksimalna dubina stabla6).

Kako bi se udovoljilo svim trima zahtjevima (broj pogodaka, broj sklopova i razina),

osmišljena je procjena dobrote koja se može izraziti sljedećom formulom:

Jednadžba 1. Procjena dobrote neke jedinke za primjer oblikovanja mreža

Pritom i označava neku proizvoljnu jedinku iz populacije P, num_hits broj pogodaka za tu

jedinku, num_gates ukupan broj sklopova u toj jedinci, num_levels ukupan broj razina

jedinke te naposljetku, fitness kao njena konačna vrijednost dobrote. Varijacije korištenja

procjene dobrote u samom programu se mogu odabrati kao parametri, ali o tome više u

potpoglavlju o konfiguracijskoj datoteci.

Razlog iz kojeg je dobrota ovako definirana je taj da je najbitniji faktor pri vrednovanju

jedinki zasigurno broj pogodaka obzirom da je na prvome mjestu ispravnost rada mreže.

6 Zapravo je pravi broj razina maksimalna dubina stabla umanjena za jedan zbog listova na najvećoj dubini

koji zapravo nisu sklopovi, kao što je već rečeno.

14

Ostala dva faktora (broj sklopova i razina) su malo manje bitna od broja pogodaka, ali

opet međusobno podjednako bitna.

Broj pogodaka se želi očuvati u cijelosti tako da je najbolje taj broj ostaviti u obliku u

kakvom jest, bez množenja s nekim faktorom, te njemu pribrojiti dodatne faktore.

Dodatni faktor broja sklopova se dobiva tako da se uzme recipročna vrijednost, a isti

postupak se provodi i s brojem razina. Razlog tome je da nam je cilj imati što manji broj

sklopova i što manji broj razina, tako da će bolje jedinke koje udovoljavaju tim zahtjevima

upravo zbog te recipročnosti imati veća ta dva člana u formuli za izračun dobrote (vidi:

Jednadžba 1.) od ostalih jedinki.

Ako se malo bolje promotri formula za izračun dobrote (vidi: Jednadžba 1.), primjetit će se

da najveći utjecaj na konačnu vrijednost ima broj pogodaka. Razlog tome je da se žele

grupirati sve jedinke s istim brojem pogodaka te se ovisno o broju sklopova i broju razina

koje su sadržane u svakoj od njih, provodi jedna blaža klasifikacija u toj grupi. Ta blaža

klasifikacija određena je drugim pribrojnikom u formuli gdje se gleda umnožak recipročnih

vrijednosti broja pogodaka i razina. Taj član može maksimalno biti približno jednak jedan,

a minimalno približno jednak nuli, što bi značilo da se sve jedinke s istim brojem pogodaka

mogu klasificirati u rasponu vrijednosti od .

Taj raspon vrijednosti se mogao definirati i na drugi način, tako da bude između ostaloga i

puno veći te pruža bolju klasifikaciju, ali za trenutne potrebe ovakav raspon bit će

dovoljan.

Sam načina izvođenja evaluacije jedinke može se u pojednostavljenom obliku opisati

sljedećim pseudokodom:

evaluate(individual)

{ tree = individual.genotype(); for i in inputs

//postavljanje vrijednosti terminala u stablu for j in inputs[i] terminal = terminals[j];

input = inputs[i][j]; tree.set_terminal_value(terminal, input);

15

//evaluacija stabla kojom se dobiva izlaz result = tree.calculate(); output = outputs[i];

if [ result == output ] ++num_hits; num_gates = tree.size();

num_levels = tree.get_maxdepth(); //fitness se računa po zadanoj formuli fitness.value = get_fitness(num_hits, num_gates, num_levels);

return fitness; }

Iz samog pseudokoda je poprilično jasno kako radi: prolazi se kroz sve ulazne vrijednosti

(njih može biti više za jednu kombinaciju) i one se postavljaju u stablu u terminalima

(varijablama). Stablo se evaluira te se tako dobiva izlazna vrijednost koja se uspoređuje s

traženim izlazom kako bi se odredilo je li to pogodak ili nije. Izračunava se broj sklopova i

broj razina te se na kraju dobrota računa po prethodno danoj formuli (vidi: Jednadžba 1.).

Evaluacijski operator se naravno na početku rada programa inicijalizira pri čemu se osim

stvaranja samog objekta, iz konfiguracijske datoteke čitaju kombinacije ulaznih i izlaznih

vrijednosti.

2.2.3.2. Operator minimizacije

2.2.3.2.1. Karnaughove tablice

Operator minimizacije služi kao dodatna funkcionalnost samog algoritma za oblikovanje

mreža i radi na principu Karnaughovih tablica.

Premda je princip minimizacije Karnaughovim tablicama (ili jednostavnije rečeno, K-

tablicama) već dobro poznat i detaljnije o njemu se može naći u [2], njegove najbitnije

karakteristike će biti izložene u kratkim crtama radi lakšeg praćenja algoritma.

16

Slika 3. Usporedba tablice istinitosti i Karnaughove tablice za F = A + B [20]

K-tablica je zapravo drugačiji zapis tablice istinitosti neke logičke formule (vidi: Slika 3.)

koja se slaže po točno određenom principu tako da Hammingova udaljenost7 susjednih

ćelija8 bude točno jednaka jedinici (vidi: Slika 4.). Ukratko, za potrebe ponavljanja gradiva

o slaganju K-tablice se može pronaći u [21].

Slika 4. Povezanost smještaja ćelija u K-tablici i Hammingove udaljenosti [21]

Minimizacija K-tablicama se provodi tako da se grupiraju susjedne ćelije i to točno

određeni broj susjednih ćelija, točnije 2n ćelija gdje n predstavlja Hammingovu udaljenost

između tih ćelija. Grupiranje se apstraktno shvaća kao „zaokruživanje“ koje se radi kada

se minimizacija K-tablicama provodi ručno na papiru (vidi: Slika 5.)

7 Hammingova udaljenost je broj pozicija u kojima se dva niza jednake duljine razlikuju [32].

8 Ćelija u K-tablici je naziv koji se koristi za jedno polje u K-tablici koje predstavlja neku kombinaciju logičkih

vrijednosti [2].

17

Slika 5. Grupiranje (zaokruživanje) susjednih ćelija u K-tablici [22]

Nakon grupiranja, ispisuje se rezultat kao suma minterma9, konkretno na gornjoj slici

(vidi: Slika 5.), imali bismo četiri takve grupe, odnosno četiri minterma koja se izražavaju

tako da se operacija logičkog presjeka provede nad varijablama u grupi u kojima se grupa

ne razlikuje. Na primjer, za grupu označenu ljubičastom bojom to bi bio minterm , a

za grupu označenu zelenom bojom (onu veću od četiri člana) to bi bio minterm .

Kakako bismo tako izdvojili sve minterme, konačan rezultat bi se dobio kao njihova suma,

odnosno logička unija, .

2.2.3.2.2. Izrada tablica

Algoritam za operator minimizacije je u potpunosti izveden kao programska

implementacija prethodno opisanog postupka. Njegov rad se može u jednostavnom

obliku opisati sljedećim pseudokodom:

minimize(tree) {

//pronalaze se čvorovi djece za svaki indeks roditelja u stablu parent2child = find_parent2child_index(tree); lastIndex = find_last_index(tree);

make_table_for_node(lastIndex); //osvježavaju se atributi stabla (veličina, dubina i sl.) tree.update();

9 Minterm služi za kanonski zapis logičke formule, prikazan je kao logička operacija i (presjek) između

logičkih varijabli, a suma minterma je zapravo unija svih minterma (uzastopne logičke operacije ili) [33].

18

}

Kako bi se u stablu uočila povezanost između roditeljskih čvorova i čvorova djece,

sastavlja se tablica raspršenog adresiranja (eng. hash table) u kojoj se dohvatom indeksa

čvora roditelja mogu dohvatiti indeksi čvorova sve njegove djece (parent2child).

Nadalje, pronalazi se zadnji indeks u stablu od kojeg će se krenuti s izradom K-tablica.

Zadnji indeks u stablu je zapravo veličina tog stabla umanjena za jedan jer se indeksi

indeksiraju od vrijednosti nula.

K-tablica je u kodu predstavljena ponovno kao još jedna tablica raspršenog adresiranja u

kojoj se pomoću indeksa nekog čvora dohvaćaju sve vrijednosti ulaznih kombinacija

varijabli10 (terminala) u kojima dotični čvor daje kao izlaz logičku istinu.

make_table_for_node(index) { //pamti se ime čvora

name = tree.index.primitive.get_designation(); for i in functions.size() if [ name eq functions[i] ]

//stvaranje K-tablice ovisno o operaciji is_operation(name, index); group_table(index);

for i in terminals.size() if [ name eq terminals[i] ] make_table_for_terminal(index);

if [ index != 0 ] make_table_for_node(index - 1); }

Krećući se po stablu od zadnjeg prema nultom čvoru (korijenskom čvoru), grade se K-

tablice za svaki od čvorova, s time da se prvo provjeri koji točno naziv nosi taj čvor te

ovisno o tome je li to naziv neke funkcije ili terminala, izvršava se odgovarajući poziv

metoda. Ukoliko je riječ o terminalu, potrebno je popuniti K-tablicu tog čvora

10

Ponekad će se u tekstu koristiti naziv terminal, a ponekad varijabla, ovisno o tome kako je prikladnije premda se pritom misli na isti pojam.

19

vrijednostima u kojima je varijabla koju predstavlja taj terminal postavljena na vrijednost

logičke istine.

Pri izgradnji K-tablice potrebno je napomenuti još nešto, a to je da se pojedina

kombinacija slaže redoslijedom kojim su terminali nabrojani u konfiguracijskoj datoteci.

Tako da, ako je redoslijed terminala u konfiguracijskoj datoteci dan kao x y z, a dohvaćen

je čvor koji predstavlja terminal s nazivom x, generirat će se K-tablica oblika 100, 101, 110,

111.

Kada se gradi K-tablica za funkcijske čvorove, potrebno je imati na raspolaganju K-tablice

sve njezine djece što će sigurno biti zbog načina obilaska stabla (pogledati poglavlje o

stablastom genotipu), a indeksi djece pojedinog čvora se mogu dohvatiti iz tablice

raspršenog adresiranja koja se sastavila još na početku. Ovisno o nazivu funkcijskog čvora,

provodi se izgradnja K-tablice za taj čvor, tako da se na primjer, ukoliko je riječ o AND

čvoru, traže sve kombinacije koje se pojavljuju u K-tablicama svih čvorova djece tog

funkcijskog čvora (vidi: Tablica 1.).

Ime

funkcijskog

čvora

Broj

djece Izgradnja K-tablice

NOT 1 Sve kombinacije koje ne postoje u K-tablici djeteta

AND 2* Svaka kombinacija koja se pojavljuje u K-tablicama oba djeteta

OR 2* Sve kombinacije koje se pojavljuju u K-tablicama oba djeteta

XOR 2 Svaka kombinacija koja se pojavljuje u K-tablici samo jednog djeteta

XNOR 2 Svaka kombinacija koja se pojavljuje u K-tablicama oba djeteta te sve

kombinacije koje se ne nalaze ni u jednoj od K-tablica djece

NAND 2* Izvodi se kao negacija AND čvora

NOR 2* Izvodi se kao negacija OR čvora

20

* Zasad je broj djece AND i OR čvorova te njihovih komplemenata NAND i NOR čvorova,

postavljen na dva, ali se u budućnosti to može proširiti na veći broj obzirom da se u shemama

takvi sklopovi često prikazuju sa više od dva ulaza pri čemu se, naravno, podrazumijeva serijska

kaskada standardnih dvoulaznih sklopova.

Tablica 1. Načini izgradnje K-tablica funkcijskih čvorova

2.2.3.2.3. Grupiranje tablica

Nakon što je K-tablica za neki funkcijski čvor izgrađena, provodi se grupacija tablice,

drugim riječima započinje proces minimizacije K-tablice, koji se može opisati sljedećim

pseudokodom:

group_table(index) { cells = k_table[index];

if [ cells.size() == 0 ] //čitavo podstablo na mjestu index je konstanta '0' generate_new_constant_node(index, '0');

if [ cells.size() == terminals.size() ^ 2 ] //čitavo podstablo na mjestu index je konstanta '1' generate_new_constant_node(index, '1');

for i in cells.size() combination = cells[i]; //ako se combination ne nalazi u vektoru matches

if [ ! combination_in_matches(combination) ] matches.push(combination); for j in cells.size()

compare = cells[j]; if [ ! combination_in_matches(compare) ] //nađu se mjesta pozicija u kojima je razlika

pos = different_positions(combination, compare); if [ pos.size() == k ] matches.push(compare);

if [ matches.size() > 2 ^ k ] k++; i--; group = matches; else if [ matches.size() = 2 ^ k ]

reorder_group_if_equal(k, matches); k = 1; else

k--; if [ matches.size() == 1 ] groups.push(matches);

reorder_group_if_less(k, group); k = 1; reduce_groups(groups);

21

make_boolean_expression(groups); }

Na početku, pamti se K-tablica trenutnog čvora (cells) te u slučaju da je ona prazna,

sastavlja se čvor koji predstavlja konstantu logičke nule, a u slučaju da se u njoj nalaze sve

moguće kombinacije koje se mogu dobiti obzirom na broj terminala, sastavlja se čvor koji

predstavlja konstantu logičke jedinice.

Ukoliko ništa od prethodnog nije slučaj, ulazi se u petlju u kojoj se bira jedna od

kombinacija iz K-tablice (combination). Prolazeći kroz sve kombinacije u istoj K-tablici

(compare), one koje se razlikuju od odabrane u točno k pozicija (k je na početku

inicijaliziran na jedinicu), odvajaju se u poseban skup (matches) te se pritom svaki puta

vrši provjera da se ne bi neka kombinacija stavila u taj skup, a već se nalazi u istome

(combination_in_matches).

Nakon što se završi s popunjavanjem skupa matches, provjerava se koliko se kombinacija

nalazi u tom skupu u odnosu na k kao broj pozicija razlike. Ukoliko je matches veći od 2k

može se pretpostaviti da se možda može pronaći neka veća grupa (k + 1) za trenutno

odabranu kombinaciju, te se vrijednosti iz matches privremeno pohranjuju u group za

slučaj da se ispostavi da je pretpostavka bila kriva. Vrijednost indeksa i se umanjuje za

jedan kako bi se ostalo pri provjeri za istu početnu kombinaciju obzirom da popunjavanje

skupa matches još nije gotovo.

Ako je matches točno jednak 2k, može se pretpostaviti da je upravo pronađena grupa za

odabranu kombinaciju, međutim kako bi se ustanovilo da se nije možda slučajno dogodilo

da se ta brojka poklopila s 2k, a ipak je riječ o manjoj grupi, provodi se provjera

(reorder_group_if_equal).

Neispunjenjem prethodna dva uvjeta, skup matches je očigledno manji od 2k. U ovaj uvjet

se može ući iz dva razloga, prvi je zato jer je pretpostavka o postojanju veće grupe iz

prvog uvjeta (veće od 2k) bila pogrešna, a drugi zato jer se grupa sastoji samo od jednog

člana (odabrane početne kombinacije). Ukoliko se radi o drugome razlogu, u skup grupa

za trenutnu K-tablicu (groups) se stavlja samo ta jedna kombinacija. Ako se radi o prvome

22

razlogu, k se umanjuje za jedan zbog pogrešnosti pretpostavke i poziva se provjera koja će

podesiti ispravnu veličinu grupe i izbaciti one kombinacije koje ne odgovaraju

(reorder_group_if_less).

Svaki puta kada se matches popuni i okida bilo koji osim prvoga uvjeta, k se ponovno

postavlja na vrijednost jedan i pokreće se novo punjenje skupa matches za iduću

kombinaciju iz K-tablice sve dok se ne prođu sve kombinacije.

U trenutku kada se prođe cijela K-tablica i skup groups bude popunjen, potrebno ga je

reducirati obzirom da se popunjavanje tog skupa odvijalo za svaku odabranu kombinaciju

(reduce_groups) te se na kraju iz dobivenih grupa formira logički izraz kao suma minterma

(make_boolean_expression).

Kao vjerni pratioci grupiranja K-tablica, postoje provjere reorder_group_if_equal i

reorder_group_if_less koje su temeljene na eksperimentalnim razmatranjima iz kojih su

utvrđena neka svojstva pogodna za odvajanje grupa, odnosno za utvrđivanje kombinacija

koje ne pripadaju u svoju trenutnu grupu s obzirom na ostale kombinacije koje se u njoj

nalaze.

Provjera reorder_group_if_equal utvrđuje je li grupa koja je podešena na veličinu od

točno 2k članova uistinu ispravno sastavljena za dani k i kombinacije u trenutnoj grupi jer

kao što je već rečeno, to se može slučajno pogoditi te se time dobivaju pogrešni rezultati

(vidi: Slika 6.).

23

Slika 6. a) Nepravilno složena grupa od osam članova; b) Pravilno složena grupa od osam članova (članovi grupe su

označeni crvenom podvlakom) [23]

Način na koji se utvrđuje je li grupa dobro ili pogrešno sastavljena prikazano je

pseudokodom:

reorder_group_if_equal(k, group)

{ for i in group.size() for j in group.size()

pos = different_positions(group[i], group[j]); //bitan je samo broj pozicija razlike difference.push(pos.size());

for j in difference.size() //razlika s nekom kombinacijom u jednoj poziciji if [ difference[j] == 1 ]

wasOne++; if [ wasOne < k ] reorder_group_for_less(k – 1, group);

return -1; wasOne = 0; difference.clear(); groups.push(group);

return 1; }

Uzima se jedna kombinacija iz grupe te se uspoređuje sa svima ostalima iz grupe, a broj

pozicija u kojima se razlikuju se sprema u difference. Ukoliko je broj pozicija u kojima se

razlikuju jednak jedan u nekim slučajevima i ako je taj broj za odabranu kombinaciju manji

24

od k, tada je tu grupu potrebno smanjiti jer nije ispravno sastavljena i poziva se provjera

reorder_group_if_less s parametrom k koji je umanjen za jedan.

Razlog iz kojeg se traži da upravo razlike za točno jednu poziciju između svih članova

grupe budu manje od k je eksperimentalno utvrđen i može se vidjeti ako se promotri

jednostavan primjer s gornje slike (vidi: Slika 6.a.). Kombinacija se razlikuje za

jednu poziciju samo od člana iz svoje grupe, a to je manje od k = 3, te se tako mogu

naći još dvije kombinacije koje se razlikuju od dvije prethodno nađene kombinacije za

manje od k = 3. To je sve samo zato zbog tako raspršenog pozicioniranja članova u K-

tablici jer ako se podsjeti koje sve susjedne ćelije se od neke odabrane razlikuju za jedan

(vidi: Slika 4.a.), lako se zaključi da će postavljeni uvjet uvijek biti ispunjen jedino ako su

elementi gusto grupirani u K-tablici (vidi: Slika 6.b.).

Ukoliko je uvjet ispunjen, provjereno je da je grupa ispravno sastavljena te se stavlja u

groups, odnosno u grupe trenutno promatrane K-tablice.

Provjera reorder_group_if_less je nešto kompliciranija, a radi tako da izbacuje članove

grupe koji se razlikuju od ostalih za najviše pozicija. Na primjer, uspoređujući tri člana od

kojih se prvi razlikuje od ostala dva za {1, 1}, drugi se razlikuje za {2, 2}, a treći za {1, 2}, bit

će izbačen drugi član (poredak usporedbi u uglatim zagradama nije toliko bitan), a

provjera je opisana donjim pseudokodom:

reorder_group_if_less(k, group)

{ for i in group.size() for j in group.size()

pos = different_positions(group[i], group[j]); //sprema se ukupan broj pozicija razlike difference.push(pos.size());

for j in difference.size() //razlikuje se od neke kombinacije za jednu poziciju if [ difference[j] == 1 ]

wasOne++; if [ wasOne < k ] group.erase(i);

i = -1; if [ group.size() == 2 ^ k ] break;

25

wasOne = 0; difference.clear(); for i in k

helpGroup.push(group[i]); for i in k group.erase(i);

while [ helpGroup.size() != 2 ^ k ] difference.clear(); for j in group.size()

for a in helpGroup.size() p = different_positions(group[j], helpGroup[a]); difference.push(p.size());

sort(difference); if [ lessDifference.empty() ] less = group[j]; lessIndex = j;

lessDifference = difference; else

//usporedba je li lessDifference > difference

if [ compare(lessDifference, difference) ] less = group[j]; lessIndex = j; lessDifference = difference;

helpGroup.push(less); group.erase(lessIndex); reorder_group_if_equal(k, helpGroup);

}

Provjera reorder_group_if_less se može podijeliti u dva dijela. U prvome dijelu radi se

slična provjera kao i u reorder_group_if_equal, gdje se grupa pokušava urediti

izbacivanjem svih onih kombinacija koji se razlikuju od ostalih u jednoj poziciji manje od k

puta. Ponekad se može dogoditi da se već samim time može podesiti ispravna veličina

grupe, tako da se drugi dio može u potpunosti preskočiti.

Međutim, u većem broju slučajeva to nije tako te je potrebno upogoniti i drugi dio

provjere. Prvo se u jednu pomoćnu grupu (helpGroup) sprema točno k kombinacija, a

spremaju se prvih k kombinacija u grupi iz razloga što se zbog načina spremanja pri

traženju grupe (misli se na metodu group_table), uvijek na prvih nekoliko mjesta stavljaju

kombinacije koje se međusobno razlikuju u najmanjem mogućem broju pozicija. Potom se

iz početne grupe (group) te kombinacije brišu, tako da se u daljnjem postupku u pomoćnu

grupu spremaju samo one kombinacije koje zaista pripadaju istoj grupi.

Pomoćna grupa se potom polako puni, sve do trenutka u kojem ima točno 2k članova u

sebi. Tada se uzima jedna kombinacija iz početne grupe i uspoređuje se broj pozicija u

26

kojima se razlikuje sa svim kombinacijama iz pomoćne grupe te se svi ti brojevi spremaju

u vektor difference koji se potom sortira radi lakše usporedbe.

Postoji vektor (lessDifference) u koji se spremaju brojevi pozicija koji su dobiveni

usporedbom neke kombinacije iz početne grupe s pomoćnom grupom te trenutno

predstavljaju najmanji takav niz u usporedbi s ostalim članovima grupe. Ukoliko je taj

vektor prazan, popunjava ga se s trenutnim vrijednostima iz vektora difference te se uz

njega, pamte i kombinacija za koju je dobiven taj vektor (less) i njezin indeks u group

(lessIndex). Ukoliko on nije prazan, uspoređuje se niz kojeg on predstavlja s nizom kojeg

predstavlja vektor difference i ukoliko vektor difference predstavlja manji niz, on postaje

novi lessDifference sa svim pratećim atributima.

Ovo se radi toliko dugo dok se ne prođe kroz cijelu početnu grupu i izdvoji konačan

lessDifference, odnosno, kombinacija less koja se najmanje razlikuje od članova iz

pomoćne grupe. Ta kombinacija se ubacuje u pomoćnu grupu helpGroup i briše se njena

postojanost iz grupe group čime se ponovno dolazi do uvjeta za veličinu grupe od točno 2k

članova. Ako on nije ispunjen, ponavlja se prethodno opisani postupak.

Razlog iz kojega se traži kombinacija koja se najmanje razlikuje od podgrupe izdvojene iz

početne grupe je također eksperimentalno utvrđen, a isto tako se jasno može vidjeti iz

konkretnoga primjera (vidi: Slika 6.a.). Ukoliko se pretpostavi da grupa stvorena za

kombinaciju i ako se sagleda jedna kombinacija koja se razlikuje od odabrane za

jedan (misli se na Hammingovu udaljenost), na primjer , vidljivo je da jedine dvije

kombinacije koje se najmanje razlikuju od stvorene grupe su i jer su ostale

preudaljene od njih. Dakle, također se zahtjeva čvrsta grupacija kako udaljenosti ne bi bile

prevelike i kako bi se moglo ustvrditi da je grupa dobro sastavljena.

Nakon svega, formiranjem grupe veličine 2k, još jednom se poziva provjera

reorder_group_if_equal koja provjerava je li grupa uistinu dobro sastavljena ili je treba još

više reducirati.

27

2.2.3.2.4. Sastavljanje logičkog izraza

Ovime završava proces grupiranja K-tablice jednog čvora i započinje slaganje logičkog

izraza na temelju dobivenih grupa, opisan sljedećim pseudokodom:

make_boolean_expression(groups) { for i in groups.size()

subGroup = groups[i]; k = log_base_2(subGroup.size()); for j in subGroup

//pozicije u kojima se razlikuju dvije kombinacije pos = different_positions(subGroup[0], subGroup[j]); if [ pos.size() == k ]

break; if [ subGroup.size() == 1 ] k = 0;

for j in subGroup[0].size() //pronalazi postojanje pozicije u pos diff = find_equal(subGroup[0][j], pos);

if [ ! diff ] variable = terminals[j]; if [ subGroup[0][j] eq '0' ]

expression.push('NOT'); expression.push(variable); if [ numAnd != subGroup.size() – k – 1 && !diff ]

expression.push('AND'); ++numAnd; if [ numOr == groups.size() – 1 ] expression.push('OR'); ++numOr; numAnd = 0;

if [ need_to_minimize(index, expression) ] generate_new_subtree(index, expression); }

Sastavljanje logičkog izraza odvija se tako da se iz svake grupe generira minterm kao

logički presjek varijabli u kojima se dotična grupa ne razlikuje u svojim kombinacijama. Za

svaku pojedinu grupu, ovisno o njenoj veličini, pamti se k kao broj pozicija u kojima se

kombinacije u toj grupi razlikuju, nakon čega se te pozicije pronalaze i pamte u zasebnom

vektoru (pos).

Kada su pozicije razlike pronađene, minterm je dovoljno generirati tako da se uzme bilo

koji član grupe (ovdje je uzet prvi) i iz njega se za sve varijable čije pozicije ne odgovaraju

onima u kojima postoji razlika, sastavi negirana ili afirmirana vrijednost te varijable,

ovisno o tome je li varijabla postavljena kao logička nula ili jedinica. Varijable se povezuju

28

logičkim presjecima, odnosno AND vrijednostima svaki put kada se postavi nova varijabla i

dokle god je broj sastavljenih logičkih presjeka manji od veličine grupe umanjene za

(k - 1)11. Prije prelaska na novu grupu, nadodaje se logička unija, odnosno OR vrijednost,

ukoliko ona nije veća od broja svih grupa umanjenih za jedan12.

Nakon što se prođe kroz sve grupe i izraz bude sastavljen, provjerava se je li uistinu

potrebna minimizacija (need_to_minimize) na način da se usporedi veličina trenutnog

podstabla dotičnog čvora i veličina podstabla koja bi se dobila da se generira iz dobivenog

logičkog izraza. Naravno, ukoliko je veličina dobivena iz logičkog izraza manja od veličine

trenutnog podstabla, provodi se minimizacija, odnosno gradi se novo minimizirano

podstablo za dotični čvor (generate_new_subtree).

2.2.3.2.5. Stvaranje novog podstabla

Pretpostavimo da je tome istina i da se ispostavi da je dobiveni logički izraz manji od

trenutnog podstabla te se ulazi u izgradnju novog podstabla minimiziranog sadržaja; cijeli

taj postupak se može opisati sljedećim pseudokodom:

generate_new_subtree(index, expression)

{ for i in expression.size() if [ expression[i] eq 'NOT' ]

//stvori novi čvor ovisno o imenu newNotNode = create_new_node('NOT'); //dodaj NOT čvor na kraj novog podstabla

newSubtree.append_node(newNotNode); lastNotIndex = newIndex; newIndex++; else if [ expression[i] eq 'AND' ]

newAndNode = create_new_node('AND'); //pojavljuje se prvi AND u stablu, OR se još nije if [ !wasAnd && !wasOr ]

andIndex = 0; wasAnd = true; //postoje već neki AND čvorovi u stablu, OR-a nema else if [ wasAnd && !wasOr ]

if [ newIndex == lastNotIndex + 2 ] andIndex = lastNotIndex; else

andIndex = newIndex – 1; //zadnji se pojavio OR, prva pojava AND-a nakon toga

11

Razlog tome je taj da ako se neka kombinacija iz grupe sastoji od n varijabli i definiran je k, broj varijabli koje je potrebno povezati je n – k, a povezuju se međusobno sa n – k – 1 logičkih presjeka. 12

Razlog tome je također jednostavan, jedna grupa je jedan minterm, a ako tih minterma ima točno n, suma tih minterma se dobiva umetanjem n – 1 logičkih unija između njih.

29

else if [ !wasAnd && wasOr ] if [ newIndex == lastNotIndex + 2 ] andIndex = lastNotIndex;

else

andIndex = newIndex – 1; lastAndIndex = andIndex;

wasOr = false; wasAnd = true; else

return false;

//umetni novi AND čvor na mjesto andIndex newSubtree.insert(newAndNode, andIndex); if [ andIndex <= lastNotIndex ]

lastNotIndex++; newIndex++; else if [ expression[i] eq 'OR' ]

newOrNode = create_new_node('OR'); //pojavio se prvi OR, AND još nije if [ !wasOr && !wasAnd ]

orIndex = 0; wasOr = true; //zadnji se pojavio AND, prva pojava OR-a nakon toga else if [ !wasOr && wasAnd ]

orIndex = lastAndIndex; wasOr = true; wasAnd = false; //pojavio se već neki OR, ali AND još nijednom

else if [ wasOr && !wasAnd ] if [ newIndex == lastNotIndex + 2 ] orIndex = lastNotIndex;

else

orIndex = newIndex – 1; else

return false; newSubtree.insert(newOrNode, orIndex); if [ andIndex <= lastNotIndex ]

lastNotIndex++; newIndex++; else

newTerminalNode = create_new_node(expression[i]); newSubtree.append_node(newTerminalNode); newIndex++;

//umetanje novog podstabla umjesto starog u glavno stablo mainTree.insertSubtree(index, newSubtree); return true;

}

Iz logičkog izraza sastavlja se stablo prateći dvije zastavice (wasOr i wasAnd) koje

indiciraju pojavljivanje AND i OR operatora u logičkom izrazu te pamćenjem nekoliko

indeksa. lastNotIndex je indeks posljednjeg pojavljenog NOT operatora (važan je ukoliko

se pojavi AND ili OR operator jer oni remete redoslijed stabla), lastAndIndex je indeks

30

posljednjeg pojavljenog AND operatora (važan je ako se pojavi OR operator nakon AND

operatora), te newIndex kao sljedeći dostupni indeks dodavanjem čvora u stablo.

Značenja skupa zastavica su:

• !wasAnd & !wasOr – zasad se nije pojavio niti jedan OR ili AND operator u stablu

• wasAnd & !wasOr – pojavio se već barem jedan AND operator, ali niti jedan OR

operator ili se zadnji pojavio AND operator i bio je umetnut nakon OR operatora

• !wasAnd & wasOr – pojavio se već barem jedan OR operator, ali niti jedan AND

operator ili se zadnji pojavio OR operator i bio je umetnut nakon AND operatora

• wasAnd & wasOr – nemoguća situacija

Slaganjem stabla prolazi se kroz čitav logički izraz slijeva nadesno i čita se operator po

operator (ili varijabla, ovisno što se dohvati) te ukoliko se prepozna NOT operator, on se

dodaje na kraj novog podstabla, pamti se indeks posljednjeg dodanog NOT operatora

(lastNotIndex) i uvećava newIndex (on je zapravo jednak veličini trenutnog podstabla).

Ako se pak umjesto NOT operatora prepozna AND operator, mora se ovisno o

zastavicama provjeriti što se dosad zbilo prilikom generiranja stabla. Ukoliko se niti OR niti

AND operator još nisu uopće pojavili, trenutni AND će se dodati kao korijenski čvor. Ako

se već pojavio neki AND, a OR još nije, taj AND se dodaje na mjesto zadnjeg dodanog

terminala, odnosno na mjesto zadnjeg dodanog NOT čvora ukoliko je taj terminal bio

njime negiran. Idući slučaj je da se zbila pojava OR operatora, a AND se još nije pojavio i u

tom slučaju se AND stavlja na isto mjesto kao i u prethodnom slučaju, ali se pritom pamti

indeks tog dodanog AND čvora (lastAndIndex) kako bi se pojavom idućeg OR operatora,

on dodao na njegovo mjesto.

Prolaskom kroz sva tri slučaja, u novo podstablo se umeće AND čvor na odgovarajuće

mjesto, ovisno o slučaju koji se zbio. Još se samo provjerava je li se AND umetnuo na

mjesto nekog NOT čvora te se time osvježava lastNotIndex i uvećava se newIndex kao

standardni korak.

31

Iduća moguća pojava je pojava OR operatora i ta pojava prolazi kroz sličan postupak kao i

pojava AND operatora. Prvi mogući slučaj je da se još nisu pojavili niti AND niti OR

operator te se stoga OR operator dodaje kao korijenski čvor. Drugi slučaj je pak da se OR

operator još nije nijednom pojavio, ali barem jedan AND operator se već nalazi u

podstablu te se time OR dodaje na mjesto koje smo upamtili kao lastAndIndex. Zadnji

slučaj je da se pojavio barem već jedan OR čvor, ali niti jedan AND čvor i time se OR

postavlja na mjesto zadnje dodanog terminala ili NOT čvora koji stoji ispred njega ukoliko

je taj terminal negiran. U novo podstablo se na odgovarajuće mjesto, ovisno o izvršenom

slučaju, umeće OR čvor i osvježavaju standardni indeksi.

Zadnja moguća pojava u logičkom izrazu je pojava varijabli koje se dodaju uvijek na kraj

postojećeg podstabla kao terminalski čvorovi.

Primjer jednog takvog generiranja stabla13 iz logičkog izraza može se vidjeti sa donje slike

(vidi: Slika 7.).

Slika 7. Primjer generiranja stabla iz logičkog izraza (NOT x AND NOT z AND NOT c) OR (NOT y AND NOT z AND NOT c)

OR (NOT z)

13

Podsjetnik da se stablo generira na takav način jer je poredak čvorova u stablastom genotipu određen kao pre-order (pogledati poglavlje o stablastom genotipu).

32

Završetak generiranja podstabla jest prolazak kroz čitav logički izraz i time se u glavno

stablo (koje se čitavo vrijeme uporno pokušava minimizirati) dodaje umjesto starog

podstabla na indeksu čvora čije se podstablo minimizira (index) to novo podstablo

dobiveno iz logičkog izraza. Time završava postupak minimizacije i povratkom iz njega,

prelazi se na idući čvor (jedan indeks više) za kojeg se zbivaju iste dugotrajne provjere i

generiranje novog minimiziranog podstabla, ukoliko je to potrebno.

Podsjetnik da trenutak u kojem stvaranje novog podstabla neće biti potrebno je kada se

nakon sastavljanja logičkog izraza utvrdi da bi stablo dobiveno tim logičkim izrazom bilo

veće (ili jednako) od trenutnog.

Premda se možda čini da je ovaj postupak (od izrade tablice za jedan čvor, grupiranja

tablice, sastavljanja logičkog izraza te ako je potrebno sastavljanja novog podstabla)

dugotrajan, ubrzanje postupka se dobiva iz razloga što se minimizacija kreće provoditi od

listova. Točnije, kreće se od zadnjeg indeksa stabla (to je čvor koji je sigurno list) prema

nultom (korijenu).

To znači da će neko podstablo u glavnom stablu, ukoliko se sastoji od nekoliko manjih

podstabala, već imati ta podstabla minimizirana te će proces grupiranja i slaganja logičkog

izraza za to podstablo biti znatno ubrzan. S druge strane, ukoliko je potrebno i sastavljanje

novog podstabla što je memorijski najzahtjevniji dio postupka zbog stvaranja novih

čvorova, ponekad to neće biti potrebno ako se minimizacijom manjih podstabala već

dobio minimalni oblik podstabla.

2.2.3.3. Operator zamjene

2.2.3.3.1. Zamjenski oblici čvorova

Osim operatora minimizacije, postoji i operator zamjene koji ispravlja glavni nedostatak

operatora minimizacije, a to je rad s naprednim logičkim vratima (sklopovima) kao što su

XOR, XNOR, NAND ili NOR logička vrata.

Minimizacijom se dobivaju podstabla koja se sastoje samo od AND, OR i NOT funkcijskih

čvorova jer se minimizacija, kao što je već rečeno, provodi K-tablicama i kao izlaz daje

33

sumu minterma. Ukoliko bi se pri oblikovanju mreže htjelo koristiti naprednija sklopovlja,

izgubila bi se apsolutna moć minimizacije pomoću K-tablica kada se može biti siguran da

je stablo (mreža) optimalno minimizirano.

Iz gore navedenog razloga, operator zamjene služi kako bi popunio tu prazninu tako da

pretvara određeni skup čvorova u XOR, XNOR, NAND ili NOR sklop ukoliko se za tim ukaže

potreba. Izgled skupa čvorova koji se može transformirati u napredni sklop je već otprije

poznat obzirom da za te napredne sklopove postoje njihovi ekvivalenti izraženi samo

osnovnim sklopovima14, NAND i NOR se izražavaju kao AND, odnosno OR sklop kojemu

prethodi NOT sklop, a ekvivalenti za XOR i XNOR sklopove su također poznati i vidljivi s

donje slike (vidi: Slika 8.).

Slika 8. Lijeva slika prikazuje ekvivalent XOR sklopa, a desna slika ekvivalent XNOR sklopa koji su izraženi isključivo

osnovnim sklopovima [24]

Poznavajući strukturu ekvivalenata naprednih sklopova, oni se mogu na taj način uočiti u

stablu i tada se može izvršiti zamjena za napredni sklop kojeg taj ekvivalent predstavlja.

2.2.3.3.2. Traženje čvorova za zamjenu

Na upravo toj ideji počiva i operator zamjene koji se može prikazati jednostavnim

pseudokodom:

swapping(tree)

{ //pronalaze se indeksi čvorova djece za svaki indeks roditelja parent2child = find_parent2child_index(tree);

//iterira se od zadnjeg indeksa u stablu prema nultom for i in reverse(tree) //naziv čvora na indeksu i je 'OR'

if [ tree[i].primitive.get_designation() eq 'OR' ]

14

Osnovni sklopovi su AND, OR i NOT i pomoću njih se može izgraditi bilo kakva mreža, a svi napredni sklopovi su izvedenice osnovnih [2].

34

check_if_need_swap(i); for i in reverse(tree) if [ tree[i].primitive.get_designation() eq 'NOT' ]

check_if_need_swap(i); //osvježavaju se atributi stabla (veličina, dubina itd.) tree.update();

}

Povezanost, točnije rečeno hijerarhija čvorova u stablu pamti se u tablici raspršenog

adresiranja (eng. hash table), koja se može pronaći i kod operatora minimizacije, gdje se

za indeks roditeljskog čvora pamte svi indeksi koji predstavljaju čvorove njegove djece.

Dalje, nastavlja se i iteriranjem po stablu, krećući se od posljednjeg indeksa stabla do

nultog indeksa stabla (korijena) i pritom se za svaki čvor provjerava njegov naziv te

ukoliko je on jednak 'OR', provjerava se je li potrebna zamjena za napredni čvor za

podstablo s korijenom na mjestu i u stablu.

Zamjena koja se može postići provjerom za podstablo s OR čvorom kao korijenom je

zamjena XOR ili XNOR čvorom, a kako se takvom zamjenom stablo umanjuje za najveći

broj razina, traganje za OR čvorovima se odvija u prvom prolazu kroz stablo. U drugom

prolazu kroz stablo traga za NOT čvorovima jer se takvim zamjenama postiže skraćivanje

za samo jednu razinu. Dakle, prioritet je napraviti zamjene s XOR ili XNOR čvorovima

ukoliko se nađu njihovi ekvivalenti, a tek kasnije zamjene s negiranim čvorovima (npr.

NOT XNOR daje XOR, NOT OR daje NOR itd.).

Jedino što provjera za potrebe zamjene podstabla radi je provjeravanje već unaprijed

definirane strukture koja je potrebna kako bi se određena zamjena obavila, što je opisano

sljedećim pseudokodom:

check_if_need_swap(index) { //dohvati se indeks lijevog dijeteta trenutnog čvora

leftChild = parent2child[index][0]; if [ parent2child[index].size() != 1 ] //dohvati se indeks desnog dijeteta trenutnog čvora

rightChild = parent2child[index][1]; //dohvaćaju se imena lijevog i desnog dijeteta leftName = tree[leftChild].primitive.get_designation();

35

rightName = tree[rightChild].primitive.get_designation(); if [ leftName eq 'AND' && rightName eq 'AND' ] find_index_to_compare(index, leftChild, rightChild);

else

name = tree[leftChild].primitive.get_designation(); //u functions su: AND, OR, NAND, NOR, XOR i XNOR (bez NOT)

for i in functions if [ name eq functions[i] ] swap_not(index, name);

}

Ukoliko se dohvatio OR ili NOT čvor, odlazi se u istu provjeru gdje se dohvaća lijevo dijete

za NOT, odnosno lijevo i desno dijete za OR. Ukoliko su dohvaćena dva djeteta, riječ je o

OR čvoru te jedino što treba provjeriti jest da su oba djeteta AND čvorovi, nakon čega se

šalju i njihovi indeksi na provjeru (odnosno, njihova djeca)15. Ukoliko je dohvaćeno samo

jedno dijete i ako je ono jedno od funkcijskih čvorova (osim NOT), odmah se provodi

zamjena.

Pronalazak indeksa čvorova za usporedbu (odnosno, cijelih podstabala) koja bi se

zamjenom dobila kao djeca naprednog čvora opisuje se sljedećim pseudokodom:

find_index_to_compare(index, leftAnd, rightAnd) {

//obzirom na dva AND djeteta, provjerava se struktura //njihove djece i u slučaju da odgovara strukturi ekvivalenta //XOR čvora, vraćaju se indeksi podstabala koja bi mogla biti

//djeca od XOR čvora if [ indexes = check_for_xor(leftAnd, rightAnd) ] //treba se uvjeriti da su primljena podstabla uistinu ista

if [ compare_subtrees(indexes[0], indexes[1]) ] //podstabla su ista, OR čvor se mijenja za XOR i //kao djecu dobiva nađena podstabla

swap_or(index, indexes[0], indexes[1], 'XOR'); if [ indexes = check_for_xnor(leftAnd, rightAnd) ] if [ compare_subtrees(indexes[0], indexes[1]) ]

swap_or(index, indexes[0], indexes[1], 'XNOR'); }

15

Pretpostavka je da se u stablu nalaze OR čvorovi sa samo dva ulaza, u budućim implementacijama gdje bi se možda mogli naći višeulazni OR sklopovi, ovdje je potrebno provesti još neke provjere.

36

Gornji pseudokod maksimalno reducira izgled stvarnog koda u kojemu postoji mnogo

raznih provjera. Metode check_for_xor i check_for_xnor su u stvarnom kodu zamijenjene

raznim uvjetnim izrazima, a ovdje u pseudokodu označavaju slučajeve u kojima se prema

strukturi podstabla s OR čvorom kao korijenom može pretpostaviti kako bi to podstablo

moglo biti ekvivalent XOR podstablu.

Postoje tri slučaja kada će check_for_xor vratiti indekse, odnosno kada će se taj dio uvjeta

evaluirati u istinu (za lakše praćenje preko primjera vidi: Slika 9.):

• Slučaj 1: ako je jedno dijete16 lijevog AND čvora NOT čvor i ako je jedno dijete

desnog AND čvora NOT čvor (najjednostavniji slučaj)

• Slučaj 2: ako su oba djeteta oba AND čvora sva redom NOT čvorovi, posloženi tako

da ako bi se išlo propagirati kroz podstabla sve djece i brojati od koliko se NOT

čvorova u nizu sastoje njihova podstabla i ako bi se zanemarivanjem određenog

broja NOT čvorova dobila ista struktura kao u prvom slučaju

• Slučaj 3: ako su oba djeteta jednog AND čvora NOT čvorovi, a drugi AND čvor ima

samo jedno NOT dijete, struktura XOR čvora može izgledati tako da se jednom

zanemari prvo NOT dijete, a jednom drugo NOT dijete kod AND čvora koji ima kao

oba djeteta NOT čvorove

Također, postoje tri slučaja i za vraćanje indeksa metode check_for_xnor, odnosno kada

će se taj dio uvjeta evaluirati u istinu (za lakše praćenje preko primjera vidi: Slika 10.):

• Slučaj 1: ako se jedan AND čvor sastoji od dva NOT čvora, a drugi nema kao djecu

nijedan NOT čvor (najjednostavniji slučaj)

• Slučaj 2: sličan je drugom slučaju za traženje XOR čvora, kada su sva djeca oba AND

čvora NOT čvorovi, jedino što se ovdje zahtjeva struktura XNOR čvora

• Slučaj 3: sličan je trećem slučaju za traženje XOR čvora, gdje od sveukupne djece

svih AND čvorova samo jedno nije NOT čvor, ali ovdje se zanemaruju oba NOT

čvora kod onog AND čvora koji kao djecu ima dva NOT čvora

16

Važno jest istaknuti da djeca AND čvorova uopće ne moraju biti listovi, nego čitava manja podstabla.

37

Slika 9. Primjeri stvaranja XOR čvora za a) prvi slučaj; b) drugi slučaj; c) treći slučaj (sub_x i sub_y su proizvoljna

podstabla)

Slika 10. Primjeri stvaranja XNOR čvora za a) prvi slučaj; b) drugi slučaj; c) treći slučaj (sub_x i sub_y su proizvoljna

podstabla)

2.2.3.3.3. Usporedba podstabala

Nakon što se uvjerilo da je struktura za ekvivalent XOR, odnosno XNOR sklopa ispunjena,

iduće na redu jest opisati postupak usporedbe dvaju podstabala za koja se pretpostavlja

da mogu činiti djecu XOR, odnosno XNOR čvoru. Promotrimo sljedeći pseudokod:

compare_subtrees(firstIndex, secondIndex) {

//kopira se podstablo iz glavnog stabla s korijenom u firstIndex firstSubtree = copy_subtree(firstIndex);

38

secondSubtree = copy_subtree(secondIndex); if [ firstSubtree.size() != secondSubtree.size() ] return false;

//generira se hash tablica oblika parent2child za podstablo p2cFirst = find_parent2child_index(firstSubtree); p2cSecond = find_parent2child_index(secondSubtree);

//vraća se rezultat usporedbe podstabala return compare(0, firstSubtree, 0, secondSubtree); }

Podstabla koja će se uspoređivati se kopiraju iz glavnog podstabla te se uspoređuje

njihova veličina (ukoliko im veličine nisu jednake, sigurno nisu podjednaka), a nakon toga

se stvaraju dvije nove tablice raspršenog adresiranja oblika tablice parent2child kakva se

stvara na početku za glavno stablo i u kojoj se pamte indeksi djece pojedinih čvorova.

Rezultat se vraća nakon što završi poziv metode compare koja izvršava usporedbu

podstabala čvor po čvor.

Važno je napomenuti da ukoliko se u prvom podstablu naiđe na isti čvor kao i u drugom

podstablu te ako oni imaju isti broj djece, ali na drugačiji način razmještene, to ne utječe

na jednakost stabala. Jedino što je bitno je da se sva djeca koja se nalaze kod čvora u

prvom stablu istovremeno nalaze i kod njegovog ekvivalenta u drugom stablu, ali ne i

njihov redoslijed, odnosno razmještaj u podstablima (vidi: Slika 11.).

Slika 11. Primjer dva ekvivalenta stabla neovisno o razmještaju čvorova

39

Način na koji se uspoređuju dva podstabla može se opisati sljedećim pseudokodom:

compare(fIndex, fSubtree, sIndex, sSubtree) { //dohvaćaju se djeca trenutnih čvorova

fChild = p2cFirst[fIndex]; sChild = p2cSecond[sIndex]; //ukoliko trenutni čvorovi nemaju jednak broj djece, niti

//podstabla im sigurno nisu jednaka if [ fChild.size() != sChild.size() ] return false;

for i in fChild.size() f = fSubtree[fChild[i]].primitive.get_designation(); for j in sChild.size()

s = sSubtree[sChild[j]].primitive.get_designation(); //imena dvoje djece promatranih čvorova se poklapaju if [ f eq s ]

found = true; k = sChild [j]; //dijete se briše da ga se više ne bi dohvaćalo

secondChild.erase(j); break; if [ found ]

//rekurzivni pozivi za djecu od njihove djece compared = compare(fChild[i], fSubtree, k, sSubtree); if [ !compared ]

return false; else

return false;

return true; }

Za čvorove na odabranim indeksima (fIndex i sIndex) provodi se usporedba njihove djece

tako da se djeca dohvate iz tablica p2cFirst i p2cSecond, uspoređuje se imaju li isti broj

djece (ako ne, tada podstabla sigurno nisu jednaka). Ako imaju, iterira se po djeci prvog

čvora i traži se u djeci drugog čvora ekvivalent trenutno dohvaćenog čvora djeteta prvog

čvora. Ukoliko se takav ekvivalent nađe, pamti se njegov indeks i briše ga se iz skupa djece

drugog čvora jer se iteriranje po djeci drugog čvora vrši sigurno nekoliko puta pa kako se

ne bi u idućim provjerama pronašao ekvivalent koji je već zapravo pronađen za jedno

drugo dijete prvog čvora.

Pronalaskom ekvivalenta, poziva se još jednom metoda compare, ali ovaj puta s

indeksima djece za koju je utvrđena ekvivalencija kako bi se provjerilo vrijedi li ta ista

ekvivalencija i za svu njihovu djecu. Ukoliko se malo bolje promotri pseudokod, uočit će se

40

da je riječ zapravo o nizu rekurzivnih poziva koji se počinju vraćaju nazad u svoje

pozivatelje tek nakon što se dođe do listova podstabala (koji nemaju djece), ako je prošlo

sve u redu, a ako ne, vraća se indikacija greške.

2.2.3.3.4. Provedba zamjene čvorova

Ako je provjera strukture i podudarnosti podstabala dala pozitivan rezultat, provodi se

operacija zamjene. Postoje dvije operacije zamjene, jedna se provodi ukoliko se zamjena

želi provesti za OR čvor, a jedna ukoliko se zamjena želi provesti za NOT čvor. Zamjena

provedena za OR čvor prikazana pseudokodom izgleda otprilike ovako:

swap_or(index, firstChild, secondChild, name)

{ //djeca budućeg XOR ili XNOR čvora firstSubtree = copy_subtree(firstChild);

secondSubtree = copy_subtree(secondChild); //stvara se novi čvor, XOR ili XNOR, ovisno o imenu

newNode = create_new_node(name);

//dodaje se u novo podstablo kao korijen newSubtree.append(newNode); //u novo podstablo stavlja se prvo dijete odmah iza korijena

newSubtree.append_subtree(firstSubtree); //u novo podstablo stavlja se drugo dijete na kraj newSubtree.append_subtree(secondSubtree);

//brisanje starog podstabla s OR čvorom na mjestu index mainTree.delete_subtree(index); //dodavanje novog podstabla s XOR ili XNOR čvorom na mjesto index

mainTree.insert_subtree(index, newSubtree); }

Iz samog pseudokoda je uglavnom sve jasno, kopiraju se podstabla iz glavnog stabla koja

će predstavljati djecu novog XOR ili XNOR čvora, stvara se taj novi XOR ili XNOR čvor te se

dodaje u privremeno novo podstablo kao korijenski čvor i do njega se „nalijepe“ njegova

djeca. Tada se iz glavnog stabla nad kojim se vrši zamjena izbriše staro podstablo gdje je

prije kao korijen stajao OR čvor i zamjenjuje se sa novim podstablom tako da tu sada stoji

XOR, odnosno XNOR čvor kao novi korijen.

Druga zamjena koja se provodi za NOT čvor nije puno drugačija od prve, što je vidljivo iz

samog pseudokoda:

swap_not(index, name)

41

{ //pamte se indeksi djece čvora na mjestu index children = parent2child[index];

//dohvaćaju se sva podstabla čije korijene čine ta djeca for i in children.size() subtrees.push(copy_subtree(children[i]));

//novi čvor se stvara ovisno o negaciji imena trenutnog newNode = create_new_node(negation(name)); //dodavanje tog čvora u novo podstablo

newSubtree.append(newNode); //dodavanje sve njegove djece u novo podstablo for i in subtrees.size()

newSubtree.append_subtree(subtrees[i]); //brisanje starog podstabla iz glavnog stabla mainTree.delete_subtree(index);

//dodavanje novog podstabla u glavno stablo mainTree.insert_subtree(index, newSubtree); }

Ovdje stoji pretpostavka da postoji više od dvoje čvorova djece17, ali ostatak postupka

ostaje isti kao i za slučaj kada se zamjena obavlja za OR čvor.

Ovime završava operacija zamjene nad trenutnim čvorom i isti postupak se nastavlja za

idući čvor u nizu u petlji koja se iterira na samom početku rada operatora zamjene.

17

Da se omogući prostor za daljnja proširenja koda, kada budu uvedeni višeulazni AND i OR sklopovi te njihove negacije (NAND i NOR).

42

2.2.4. Konfiguracijska datoteka

Svi parametri rada programa se podešavaju preko konfiguracijske datoteke koja je

posložena kao XML dokument pa ju je jednostavno oblikovati. Postoje neki elementi u

konfiguracijskoj datoteci koje je poželjno mijenjati, a ostali mogu ostati kako su

postavljeni na početku.

U odjeljku koji označava DigitalCircuit algoritam nalaze se sljedeći elementi:

• broj generacija – cijeli broj koji označava koliko dugo će populacija evoluirati

• korištenje operatora minimizacije – yes/no (ili prazno)

• korištenje operatora zamjene – yes/no (ili prazno)

• pozicija u kodu gdje se mogu koristiti operatori –

by_individual/by_generation/by_algorithm

Posebno zanimljiv element je određivanje pozicije u kodu gdje se koriste operatori.

Ukoliko se koristi by_individual, operatori se provode svaki puta kada se u algoritmu

dohvate nove tri jedinke selekcijskim operatorima. Ako se koristi by_generation, operatori

se provode nad cijelom populacijom na kraju svake generacije. Može se koristiti i

by_algorithm, gdje se operatori provode nad cijelom populacijom tek na kraju rada

algoritma (završetkom evolucije). Korisnost ovog elementa bit će vidljiva u idućem

poglavlju o testiranju.

Nadalje, u elementu koji označava stablasti algoritam nalaze se sljedeći korisni elementi:

• funkcijski čvorovi – { NOT, AND, OR, XOR, XNOR, NAND, NOR }

• terminalski čvorovi – proizvoljni nazivi18

• konstante – uvijek moraju biti navedene 0 i 1

18

Bitno je samo da se ne poklapaju s niti jednim nazivom funkcijskog čvora ili konstante.

43

Od funkcijskih čvorova navodi se bilo koji broj njih iz navedene grupe, od terminalskih se

navode nazivi po izboru, ovisno o broju traženih ulaza, dok su konstante već unaprijed

određene i ne mogu se mijenjati.

Na posljetku, postoji još element registra koji određuje način bilježenja važnijih pojava

prilikom rada algoritma (bilježenje, ispis čitave populacije nakon određenog broja

generacija) te svaku dodatnu funkcionalnost algoritma. Za ovaj algoritam ovdje su dodana

još tri elementa (ostali se ne moraju mijenjati):

• kombinacije ulaznih vrijednosti – generiraju se ovisno o broju i poretku terminala,

treba paziti da budu sve moguće kombinacije navedene kako bi algoritam davao

ispravne rezultate

• kombinacije izlaznih vrijednosti – zasad je to samo jedna izlazna vrijednost, izlazne

vrijednosti se slažu redoslijedom kojim su posložene ulazne vrijednosti tako da se

mogu lakše odvojiti u parove u kodu

• način procjene dobrote – hits/hits+size/hits+level/all

U ovome dijelu, izdvaja se element koji označava način procjene dobrote pri čemu se kao

okosnica uzima formula koja se koristi za izračun dobrote (vidi: Jednadžba 1.). Ukoliko se

u taj element postavi vrijednost hits, u jednadžbi ostaje samo pribrojnik s brojem

pogodaka. Ako se postavi vrijednost hits+size, ostaju pribrojnik s brojem pogodaka i

pribrojnik s faktorom gdje se pak gleda samo veličina stabla. Za hits+level ostaju pribrojnik

s brojem pogodaka i pribrojnik s faktorom gdje se gleda samo dubina stabla. Ako se pak

postavi vrijednost all, uzimaju se svi pribrojnici u obzir, odnosno cijela formula. Korištenje

ovog elementa će također doći do izražaja u idućem poglavlju o ispitivanju.

Primjer slaganja konfiguracijske datoteke (npr. za potpuno zbrajalo) nalazi se u nastavku

teksta:

<ECF> <Algorithm>

<DigitalCircuit>  <Entry key="ngen">100</Entry>

 <Entry key="usemin">yes</Entry>

44

 <Entry key="useswap">yes</Entry> 

<Entry key="usefeat">by_individual</Entry> </DigitalCircuit> </Algorithm>

<Genotype> <Tree>

 <Entry key="maxdepth">8</Entry> 

<Entry key="mindepth">4</Entry>  <Entry key="functionset">AND OR NOT XOR XNOR</Entry>

 <Entry key="terminalset">x y c</Entry> 

<Entry key="constantset">0 1</Entry> </Tree> </Genotype>

<Registry> 

<Entry key="randomizer.seed">0</Entry>  <Entry key="population.size">30</Entry>

 <Entry key="mutation.indprob">0.3</Entry> 

<Entry key="term.maxgen">10</Entry>  <Entry key="log.level">3</Entry>

 <Entry key="log.filename">log.txt</Entry>  <Entry key="milestone.filename">out.txt</Entry>  <Entry key="milestone.interval">0</Entry> 

<Entry key="varset">000 010 100 110 001 011 101 111</Entry>  <Entry key="cellvalue">0 1 1 0 1 0 0 1</Entry>

 <Entry key="fitnessuse">all</Entry> </Registry>

</ECF>

45

Prema trenutnom podešenju konfiguracijske datoteke rezultati izvođenja programa

spremaju se u log.txt i out.txt, tekstualne datoteke koje su također XML oblikovani

dokumenti.

U log.txt se mogu pronaći statistički podaci o pojedinoj generaciji (maksimalna i

minimalna vrijednost dobrote, prosječna vrijednost i standardna devijacija) te ispis

najbolje jedinke na kraju algoritma. Bilježenje takvih podataka ovisi i o postavljenoj razini

logiranja, zasad je dovoljna samo treća razina.

U out.txt se nalazi ispis čitave populacije na kraju izvođenja algoritma, odnosno ispis svake

jedinke tako da se prikaže veličina te jedinke (odnosno, broj genotipova), ispis genotipa

(u ovom slučaju, stabla) te uz njega ispis veličine te dubine genotipa i dobrote genotipa te

jedinke.

46

3. Analiza rezultata

3.1. Ispitivanje

Nakon što je implementiran sustav za oblikovanje mreža i utvrđena je ispravnost njegovog

rada, ostalo je još ispitati korisnost cijele implementacije, odnosno pokazati koliko

„dobra“ rješenja se dobivaju u odnosu na očekivanja i u odnosu na neke korisnički

definirane parametre (o kojima je bilo riječ u poglavlju o konfiguracijskoj datoteci).

Ispitivanje se provodi na osobnom prijenosnom računalu19 unutar Eclipse platforme

verzije 3.4.1. [25] tako da se nakon pokretanja prate dvije izlazne datoteke koje se

generiraju nakon završetka rada programa (opisane su u prethodnom poglavlju o

konfiguracijskoj datoteci) ili pak ispis na standardni izlaz.

Osim toga, kako bi se moglo pratiti i ukupno vrijeme izvođenja algoritma uključeno je

zaglavlje koje pruža tu funkcionalnost i mjeri vrijeme izvođenja nekog dijela koda. Ovdje je

bilo potrebno mjeriti samo vrijeme izvođenja algoritma, tako da se na kraju programa

dobiva uvid u vrijeme proteklo za izvođenje algoritma pri jednom pokretanju. Uključeno

zaglavlje je besplatan alat koji se može skinuti sa službenih stranica njegovog autora i

koristiti u svome kodu, više o tome pogledati na [26].

Pri ispitivanju, na kraju svakog pokretanja, gleda se samo najbolja jedinka i njezine

karakteristike (vrijednost dobrote, veličina stabla i dubina stabla), s time da se veličina

stabla i dubina stabla nazivaju kao vrijednosti karakteristične za mrežu (broj sklopova, broj

razina).

Za odabrani parametar koji određuje gdje će se u kodu koristiti operatori, rezultati

ispitivanja bit će prikazani u tablicama: u prvoj tablici nalazit će se ispitivanja za

kombinaciju različitih funkcija dobrote, a u drugoj tablici bit će prikazana ispitivanja za

broj pogođenih kombinacija ulaza s izlazima, broj sklopova i broj razina za najbolje

19

Lenovo R60e, Intel Centrino Duo T5500 @ 1.66GHz, 1GB RAM, OS: WinXP Proffesional

47

rješenje (izdvojeno opet ovisno o odabiru funkcije dobrote tako da će zapravo ovakvih

tablica biti četiri).

Formirat će se još dvije tablice u kojima će biti pokazana usporedba utjecaja upotrebe

operatora na rezultate s naglaskom na poboljšanje, odnosno pogoršanje u odnosu na

ostale varijante, bilo pri dobivanju dobrote najbolje jedinke bilo pri vremenu izvođenja

algoritma.

Nakon toga će se izabrati jedna funkcija dobrote (npr. ona za koju najveći broj varijacija

dobiva najbolja rješenja, premda će uvijek ispasti da je za sve četiri varijacije riječ o istoj) i

na temelju nje će se izgraditi treća tablica, a četvrta će se izgraditi na osnovu vremena

izvođenja obzirom na odabranu funkciju dobrote.

Završetkom izgradnji tablica, grafički se prikazuje prosječno kretanje cijele populacije kroz

veći broj pokretanja programa, tako da se pokazuje rast ili pad dobrote, broja pogodaka,

broja sklopova i broja razina uspoređujući najbolje vrijednosti i prosječne vrijednosti u

cijeloj populaciji u nekoj generaciji.

Određeno je da će broj ispitivanja za svaku tablicu (misli se na prvu i drugu) biti ukupno

deset, a sve tablice i grafovi će se generirati nad ispitnim primjercima o kojim je riječ u

idućem poglavlju.

Za vrijednosti koje su upisane u tablicu, računat će se srednja vrijednost, maksimalna

apsolutna pogreška, relativna pogreška20 i odmak od idealnog slučaja. Prva tri pojma su

već odavna poznata kao standardan alat koji služi za objektivan prikaz statistike, a pojam

idealnog slučaja se koristi kako bi se prikazalo subjektivno zadovoljstvo s dobivenim

rezultatima. Uz njih, prikazuje se i još najbolja dobivena vrijednost prilikom ispitivanja.

Idealni slučaj je zamišljen kao model koji označava izgled kombinacijske mreže kakav

zamišlja osoba koja implementira tu mrežu (idealan broj sklopova, broj razina te idealne

vrijednosti ostalih parametara). Računanje odmaka od idealnog slučaja za pojedini

parametar je zapravo razlika između idealne vrijednosti i dobivene vrijednosti.

20

Kao podsjetnik na način računanja tih vrijednosti, može se pogledati dodatak na kraju.

48

Cilj je da taj odmak bude što bliži nuli, ali pozitivan, ukoliko je za neki parametar poželjna

što veća vrijednost (npr. dobrota). Ukoliko je za neki parametar poželjna što manja

vrijednost (npr. broj sklopova), tada je cilj također da se približava nuli, ali da je taj odmak

negativan. Pretpostavka je da su sve vrijednosti (i idealne i dobivene) pozitivne.

Kod određivanja idealnog slučaja se mora paziti da se on zadaje realno, odnosno da osoba

koja ga definira ne podcjenjuje niti ne precjenjuje idealni slučaj u usporedbi s onim što se

može dobiti kao rješenje. Npr. bilo bi pogrešno zadati da je za ispitni primjerak potpunog

zbrajala od tri ulaza idealni slučaj za broj sklopova jednak desetak sklopova, ako se zna da

se standardna izvedba potpunog zbrajala sastoji od pet sklopova (pretpostvka je da se

koriste XOR sklopovi) [2]. Također bi bilo pogrešno zadati da je za isti ispitni primjerak

idealni slučaj uz samo jedan sklop jer se zna da ne postoji niti jedan logički operator (kojeg

implementira određeni osnovni ili napredni sklop) koji je ternarni, odnosno koji radi s tri

ulazne vrijednosti istovremeno.

Kako zamijetiti da je idealni slučaj pogrešno postavljen je zapravo prilično dobro vidljivo iz

dobivene statistike kad se na mjestu gdje se očekuje pozitivna vrijednost približno

jednaku nuli, dobije negativna i obrnuto.

Odmak od idealnog slučaja u tablicama se za potrebe statističkih mjerenja u ovom radu

računa kao idealna vrijednost umanjena za dobivenu srednju vrijednost, a kao idealne

vrijednosti uzimaju se za broj idealnih pogodaka te idealni broj sklopova i razina.

Još je jednom potrebno napomenuti da korištenje izraza „broj sklopova“ i „broj razina“ pri

mjerenju i nije baš u potpunosti podudarno s onime što bi se dobilo kakako bi se

pogledalo na slikovni prikaz mreže. Broj sklopova zapravo označava broj čvorova u stablu

koji predstavljaju jednu mrežu, što zapravo znači da se pod pojmom „sklop“

podrazumijevaju i čvorovi koji su terminali i konstante, odnosno ono što je na mreži

prikazano kao ulazna spojnica. Prema tome, ako su terminali i konstante također

„sklopovi“ to bi dalo veći broj razina nego što u stvarnosti postoji. To je jasno vidljivo sa

recimo slike koja prikazuje prvi ispitni primjerak potpunog zbrajala (vidi: Slika 12.) gdje

postoji jedna razina više nego što je to na slikovnom prikazu mreže i tri „sklopa“ više nego

što je to na istom slikovnom prikazu. Ovo treba uzeti i obzir i dobro shvatiti jer se na tome

49

temelje rezultati mjerenja jer je mreža, kao što je već napomenuto nekoliko puta u tekstu,

prikazana kao stablo.

50

3.2. Ispitni primjerci

Izdvojena su četiri primjera mreža s definiranim ulaznim i izlaznim vrijednostima koji će,

između ostalog, poslužiti i kao ispitni primjerci u procesu ispitivanja:

1. Potpuno zbrajalo (eng. full adder) – tri ulazne vrijednosti (bit prvog broja, bit

drugog broja i bit prijenosa iz prethodne operacije) i jedna izlazna vrijednost (gleda

se samo rezultat, ali ne i izlazni prijenos) [2]

2. Generator parnog pariteta – izlaz je paritetni bit koji se dodaje kao zadnji bit u nizu

od četiri ulazne vrijednosti [27] [28]

3. Indikator kružnog posmaka udesno – izlaz je desno posmaknut bit u (virtualni)

registar, gledano za četiri ulazna bita [2]

4. Generator četvrtog zaštitnog bita Hammingovog kodera – izlaz je četvrti zaštitni bit

koji se umeće u ulaznu riječ od četiri bita (izgled konačne kodne riječi:

z1z2b3z4b5b6b7 gdje su z zaštitni, a b informacijski bitovi) [29] [28]

Uzeti su najjednostavniji primjeri mreža koji se mogu naći u raznim literaturama, gdje je

broj ulaza maksimalno do četiri bita21, a broj izlaza je uvijek samo jedan.

Od funkcijskih čvorova, za sve ispitne primjerke uključeni su svi dostupni (NOT, AND, OR,

XOR, XNOR, NAND, NOR), a terminalski čvorovi se biraju po želji, premda su za potrebe

ispitivanja oni složeni od stražnjih slova engleske abecede (x, y, z, w). Ostali parametri su

podešeni na isti način kao što stoji u primjeru konfiguracijske datoteke iz prethodnog

poglavlja.

Opisani način slaganja tablica iz prethodnog poglavlja provodit će se zasebno nad svakim

ispitnim primjerkom, međutim rezultati će biti u potpunosti prikazani i prokomentirani

samo za prvi ispitni primjerak. Za ostale ispitne primjerke bit će navedena samo tablica

koja se za neku kombinaciju varijacije postavljanja operatora i funkcije dobrote ispostavi

21

Razlog tome je i minimizacija pomoću K-tablica, za koju nije preporučljivo uzimati više od pet ulaznih vrijednosti [2].

51

najprikladnijom (s obzirom na ispitivanje prvog ispitnog primjerka), ostavljena čitatelju za

detaljnije proučavanje.

52

3.3. Rezultati ispitivanja

3.3.1. Ispitni primjerak 1

Za prvi ispitni primjerak, odnosno potpuno zbrajalo, izdvojene su ulazne i izlazne

vrijednost u konfiguracijskoj datoteci22:

<Entry key="varset">000 010 100 110 001 011 101 111</Entry> <Entry key="cellvalue">0 1 1 0 1 0 0 1</Entry>

Ovaj ispitni primjerak je odabran jer je, prema slobodnoj procjeni, najteži za

implementaciju te će se nad njim napraviti detaljna statistika kako bi se dobila takva

kombinacija parametara i funkcija dobrote koja daje najbolja rješenja.

Slika 12. Izvedba potpunog zbrajala za tri ulazne i jednu izlaznu vrijednost koja je malo izmjenjena u odnosu na onu iz

[2] gdje se promatraju dva izlaza iz potpunog zbrajala (lijeva slika) i njezin ekvivalent prikazan kao stablo (desna slika)

Funkcije dobrote dobivaju se uvrštenjem različitih parametara te zanemarivanjem nekih

od njih u funkciju dobrote koja je definirana na početku (vidi: Jednadžba 1.), odnosno

izgled svih uvrštenih parametara za primjer potpunog zbrajala sa slike (vidi: Slika 12.) bio

22

Napomena: Nakon provedbe testiranja prvog primjerka, uočena je greška u kodu koji definira funkciju dobrote takvu da se za idealni slučaj (jedan sklop, jedna razina) dobije manja dobrota nego za neke slabije varijante. Međutim, kako se pri testiranju prvog testnog primjerka nije pojavio niti jedan takav idealni slučaj, dobivena statistika je valjana.

53

bi , gdje je prvi pribrojnik broj pogodaka, a idući je faktor između obrnuto

proporcionalne vrijednosti broja sklopova pomnožene s obrnuto proporcionalnom

vrijednošću broja razina 23.

3.3.1.1. Bez operatora minimizacije i zamjene

Ispitivanjem uz nenavedeni parametar mjesta korištenja operatora (odnosno, u tom

slučaju se podrazumijeva da se operatori ne koriste), dobiva se sljedeća tablica za različite

varijante funkcije dobrote (vidi: Tablica 2.):

Ispitni primjerak 1

Dobrota s različitim kriterijima (bez utjecaja operatora)

Statističke vrijednosti

dobrota (broj pogodaka)

dobrota (broj pogodaka + broj

sklopova)


razina)

dobrota (broj pogodaka + broj sklopova + broj

razina)

Najbolja vrijednost

8,00000 8,25000 8,12500 8,02273

Srednja vrijednost

7,80000 7,21884 7,52680 7,71582

Maksimalna apsolutna pogreška

0,80000 1,14741 2,40180 1,66820

Relativna pogreška

5,40560 13,45952 14,29680 8,59768

Idealni slučaj 8,00000 8,25000 8,50000 8,75000

Odmak od idealnog slučaja

0,20000 1,03116 0,97321 1,03418

Tablica 2. Rezultati dobiveni biranjem različitih varijanti funkcije dobrote za slučaj bez korištenja operatora

minimizacije i zamjene

23

Kao što je već napomenuto, broj sklopova je zapravo pet, a broj razina tri, ali ovdje se zbog kasnije uočene pogreške u definiranju dobrote u kodu uzimaju vrijednosti za jedan manje. U idućim testnim primjercima se uzimaju prave vrijednosti broja sklopova i broja razina i uvrštavaju u tom obliku u funkcije dobrote.

54

Ukoliko se izdvoji funkcija dobrote koja za parametar uzima samo broj pogodaka,

odnosno ispravno pogođenih kombinacija ulaza i izlaza, dobiva se sljedeća tablica (vidi:

Tablica 3.):

Ispitni primjerak 1

Različiti parametri za zadnju generaciju i vrijeme trajanja izvođenja algoritma (dobrota = broj pogodaka)


Broj pogodaka Broj sklopova Broj razina Brzina izvođenja algoritma [ms]

Najbolja vrijednost

8 45 9 96,6

Srednja vrijednost

7,80000 194,00000 9,00000 252,76000


0,80000 167,00000 0,00000 187,24000

Relativna pogreška

5,40560 55,43894 0,00000 47,06276

Idealni slučaj

8 4 2


0,20000 -190,00000 -7,00000

Tablica 3. Dobiveni parametri uz funkciju dobrote koja prati samo broj pogodaka za slučaj u kojem se ne koriste

operatori minimizacije i zamjene

Treba primijetiti da se u tablicama gdje se popunjavaju različiti parametri uz neku

odabranu funkciju dobrote, ne popunjava idealni slučaj i odmak od idealnog slučaja za

vrijeme izvođenja algoritma. Razlog tome je činjenica da je takvo nešto dosta teško

procijeniti zbog različitih vanjskih utjecaja na brzinu izvođenja programa pa se

jednostavno izostavlja.

Slične tablice dobivaju se i za ostale tri varijante funkcije dobrote (vidi: Tablica 4.; Tablica

5.; Tablica 6.).

55

Ispitni primjerak 1

Različiti parametri za zadnju generaciju i vrijeme trajanja izvođenja algoritma (dobrota = broj pogodaka + broj sklopova)



Najbolja vrijednost

8 5 3 65,6

Srednja vrijednost

7,10000 19,80000 5,80000 93,98000


1,10000 41,20000 3,20000 61,02000

Relativna pogreška

14,00604 100,18745 42,07587 29,96963

Idealni slučaj

8 4 2


0,90000 -15,80000 -3,80000

Tablica 4. Dobiveni parametri uz funkciju dobrote koja prati broj pogodaka i broj sklopova za slučaj u kojem se ne

koriste operatori minimizacije i zamjene

Ispitni primjerak 1

Različiti parametri za zadnju generaciju i vrijeme trajanja izvođenja algoritma (dobrota = broj pogodaka + broj razina)



Najbolja vrijednost

8 35 8 113,0

Srednja vrijednost

7,40000 257,60000 8,90000 330,70000


2,40000 222,60000 0,90000 217,70000

Relativna pogreška

14,52659 56,93088 3,55312 48,24681

Idealni slučaj

8 4 2


0,60000 -253,60000 -6,90000

Tablica 5. Dobiveni parametri uz funkciju dobrote koja prati broj pogodaka i broj razina za slučaj u kojem se ne

koriste operatori minimizacije i zamjene

56

Ispitni primjerak 1

Različiti parametri za zadnju generaciju i vrijeme trajanja izvođenja algoritma (dobrota = broj pogodaka + broj sklopova + broj razina)



Najbolja vrijednost

8 8 4 83,7

Srednja vrijednost

7,70000 27,80000 6,40000 127,82000


1,70000 49,20000 2,60000 63,18000

Relativna pogreška

8,76557 89,35549 27,75607 35,75839

Idealni slučaj

8 4 2


0,30000 -23,80000 -4,40000

Tablica 6. Dobiveni parametri uz funkciju dobrote koja prati broj pogodaka, broj sklopova i broj razina za slučaj u

kojem se ne koriste operatori minimizacije i zamjene

Najzanimljivija statistička komponenta je zasigurno odmak od idealnog slučaja. Ako se

promotre dobiveni odmaci za različite varijante funkcija dobrote (vidi: Tablica 2.), najbolja

je dobrota koja mjeri samo broj pogodaka, iza nje odmah slijedi dobrota s brojem

pogodaka i razina pa dobrota s brojem pogodaka i sklopova te na kraju, dobrota koja

uzima sva tri parametra u obzir. Kako razlike između tih odmaka nisu prevelike (malena je

gradacija), u obzir se moraju uzeti i ostale tablice.

Ako se promotre preostale tablice i odmaci od idealnog slučaja za broj pogodaka, broj

sklopova i broj razina i to za svaku pojedinu varijantu funkcije dobrote (vidi: Tablica 3.;

Tablica 4.; Tablica 5.; Tablica 6.), statistika pokazuje drugačije.

Funkcija dobrote koja mjeri samo broj pogodaka i ona koja mjeri broj razina i broj

pogodaka imaju velik odmak od idealnog slučaja za broj sklopova, dok preostale dvije

imaju puno manji. Osim toga, funkcija dobrote koja mjeri broj pogodaka i sklopova ima

nešto manji odmak od idealnog slučaja za broj sklopova i pogodaka od funkcije dobrote

koja mjeri sve parametre.

57

Prema tome, ukoliko se ne koriste operatori minimizacije i zamjene, najbolje je koristiti

(bar za ovaj ispitni primjerak) funkciju dobrote koja promatra broj pogodaka i broj

sklopova.

3.3.1.2. Uz parametar by_indvididual

Parametar by_individual se uključuje ako se želi koristiti operator minimizacije i zamjene

svaki puta kada algoritam dohvati nove tri jedinke (selekcijskim operatorima) nad kojima

će provoditi križanje, mutaciju i na koncu, evaluaciju nove jedinke. Slijede tablice koje

opisuju ispitivanje tog parametra uz sve četiri varijante funkcije dobrote (vidi: Tablica 7.;

Tablica 8.; Tablica 9.; Tablica 10.; Tablica 11.)

Ispitni primjerak 1

Dobrota s različitim kriterijima (by_individual)




sklopova)


razina)


razina)

Najbolja vrijednost

8,00000 8,03846 8,33333 8,03333

Srednja vrijednost

6,70000 7,21452 7,45595 7,04191


1,70000 1,13760 1,20595 0,99142

Relativna pogreška

14,15945 11,95695 10,90376 11,13067

Idealni slučaj

8,00000 8,25000 8,50000 8,75000


1,30000 1,03548 1,04405 1,70809

Tablica 7. Rezultati dobiveni biranjem različitih varijanti funkcije dobrote za slučaj korištenja parametra by_individual

58

Ispitni primjerak 1



Broj pogodaka Broj sklopova Broj razina Brzina izvođenja

algoritma [s]

Najbolja vrijednost

8 9 4 2,34

Srednja vrijednost

6,70000 19,50000 6,10000 4,45000


1,70000 10,50000 2,10000 2,16000

Relativna pogreška

14,15945 36,36247 22,46427 26,90088

Idealni slučaj

8 4 2


1,30000 -15,50000 -4,10000

Tablica 8. Dobiveni parametri uz funkciju dobrote koja prati broj pogodaka za slučaj u kojem se koristi parametar

by_individual

Ispitni primjerak 1




algoritma [s]

Najbolja vrijednost

8 5 3 2,71

Srednja vrijednost

7,10000 11,80000 4,70000 4,01000


1,10000 15,20000 2,30000 3,11000

Relativna pogreška

12,33232 50,02473 22,53936 30,89833

Idealni slučaj

8 4 2


0,90000 -7,80000 -2,70000

Tablica 9. Dobiveni parametri uz funkciju dobrote koja prati broj pogodaka i broj sklopova za slučaj u kojem se koristi

parametar by_individual

59

Ispitni primjerak 1




algoritma [s]

Najbolja vrijednost

8 9 4 3,15

Srednja vrijednost

7,20000 15,00000 5,10000 4,53300


1,20000 11,00000 2,90000 2,46700

Relativna pogreška

10,95570 42,86067 26,86903 25,81922

Idealni slučaj

8 4 2


0,80000 -11,00000 -3,10000

Tablica 10. Dobiveni parametri uz funkciju dobrote koja prati broj pogodaka i broj razina za slučaj u kojem se koristi

parametar by_individual

Ispitni primjerak 1




algoritma [s]

Najbolja vrijednost

8 5 3 2,60

Srednja vrijednost

7,00000 15,20000 5,20000 4,61400


1,00000 10,20000 2,20000 3,64600

Relativna pogreška

11,66424 56,23621 31,14092 40,44087

Idealni slučaj

8 4 2


1,00000 -11,20000 -3,20000


kojem se koristi parametar by_individual

60

Slično kao i u prethodno potpoglavlju, zanimljivo je promatrati odmak od idealnog slučaja

(vidi: Tablica 7.) za različite varijante korištenja funkcija dobrote uz korištenje parametra

by_individual. Usporedbom tih vrijednosti dobiva se da je najbolja funkcija dobrote ona

koja mjeri broj pogodaka i razina, zatim ona koja mjeri broj pogodaka i sklopova, slijedi

ona koja gleda samo broj pogodaka i zadnja je ona koja uzima sve parametre u obzir.

Gradacija tih vrijednosti je također malena, međutim, za razliku od rezultata iz

prethodnog potpoglavlja, ako se promotre ostale tablice (vidi: Tablica 8.; Tablica 9.;

Tablica 10.; Tablica 11.) i idealni slučajevi za broj pogodaka, sklopova i razina, sve funkcije

dobrote su uglavnom ujednačene. Možda bi se eventualno mogla izdvojiti ponovno

funkcija dobrote koja gleda broj pogodaka i sklopova jer ima najmanji odmak u broju

sklopova i razina za razliku od ostalih.

3.3.1.3. Uz parametar by_generation

Parametrom by_generation operatori minimizacije i zamjene se koriste na kraju svake

generacije i to nad cijelom populacijom. Tablice koje opisuju rezultate ispitivanje za taj

parametar uz različite varijacije funkcije dobrote se nalaze u nastavku (vidi: Tablica 12.;

Tablica 13.; Tablica 14.; Tablica 15.; Tablica 16.).

Ispitni primjerak 1

Dobrota s različitim kriterijima (by_generation)




sklopova)


razina)


razina)

Najbolja vrijednost

8,00000 8,05882 8,12500 8,00556

Srednja vrijednost

7,50000 7,37267 7,92500 7,70439


1,50000 1,28176 0,80000 0,69864

Relativna pogreška

9,42809 10,48412 5,32034 6,24662

Idealni slučaj

8,00000 8,25000 8,50000 8,75000

61


0,50000 0,87733 0,57500 1,04561

Tablica 12. Rezultati dobiveni biranjem različitih varijanti funkcije dobrote za slučaj korištenja parametra

by_generation

Ispitni primjerak 1




Najbolja vrijednost

8 63 9 112,00

Srednja vrijednost

7,50000 199,10000 9,00000 258,60000


1,50000 136,10000 0,00000 156,40000

Relativna pogreška

9,42809 54,49951 0,00000 42,29748

Idealni slučaj

8 4 2


0,50000 -195,10000 -7,00000


by_generation

Ispitni primjerak 1




Najbolja vrijednost

8 5 3 67,60

Srednja vrijednost

7,30000 23,70000 6,30000 106,08000


1,30000 36,30000 3,30000 109,92000

Relativna 11,27771 65,76055 25,97447 41,55687

62

pogreška

Idealni slučaj

8 4 2


0,70000 -19,70000 -4,30000

Tablica 14. Dobiveni parametri uz funkciju dobrote koja prati broj pogodaka i broj sklopova za slučaj u kojem se

koristi parametar by_generation

Ispitni primjerak 1




Najbolja vrijednost

8 57 9 106,00

Srednja vrijednost

7,80000 203,40000 9,00000 268,40000


0,80000 153,60000 0,00000 184,60000

Relativna pogreška

5,40560 56,05496 0,00000 46,63440

Idealni slučaj

8 4 2


0,20000 -199,40000 -7,00000


parametar by_generation

Ispitni primjerak 1




Najbolja vrijednost

8 22 7 105,00

63

Srednja vrijednost

7,70000 47,20000 7,90000 181,50000


0,70000 70,80000 1,10000 97,50000

Relativna pogreška

6,27332 62,45749 12,87710 30,91870

Idealni slučaj

8 4 2


0,30000 -43,20000 -5,90000


kojem se koristi parametar by_generation

Promatranjem odmaka od idealnog slučaja za različite varijante funkcija dobrote uz

korištenje parametra by_generation (vidi: Tablica 12.) dobiva se slična gradacija kao i u

slučaju kada se ne koriste operatori minimizacije i zamjene. To znači da je najbolja

funkcija dobrote ona koja mjeri samo broj pogodaka, pa ona koja mjeri broj pogodaka i

razina, zatim ona koja mjeri broj pogodaka i sklopova i na kraju ona koja mjeri sve

parametre.

Zanimljivo je primijetiti da se promatranjem odmaka od idealnog slučaja u ostalim

tablicama (vidi: Tablica 13.; Tablica 14.; Tablica 15.; Tablica 16.) dobivaju također slični

rezultati kao i slučaju bez korištenja operatora. Odnosno, funkcija dobrote koja koristi

samo broj pogodaka i ona koja koristi broj pogodaka i razina imaju povelik odmak od

idealnog slučaja za broj sklopova za razliku od ostale dvije funkcije dobrote.

Usporedbom preostale dvije funkcije dobrote, dobrota koja mjeri broj pogodaka i

sklopova ima nešto manji odmak od idealnog slučaja za broj sklopova i razina od funkcije

dobrote koja u obzir uzima sve parametre pa prema tome, ta funkcija dobrote je i u ovom

slučaju najbolji izbor.

3.3.1.4. Uz parametar by_algorithm

Zadnji parametar koji se može koristiti, by_algorithm, koristi se kada se operacije

minimizacije i zamjene žele provesti nad cijelom populacijom tek pri kraju rada algoritma

64

(prolaskom kroz sve generacije), a tablice dobivene za taj parametar su navedene ispod

teksta (vidi: Tablica 17.; Tablica 18.; Tablica 19.; Tablica 20.; Tablica 21.).

Ispitni primjerak 1

Dobrota s različitim kriterijima (by_algorithm)




sklopova)


razina)


razina)

Najbolja vrijednost

8,00000 8,20000 8,14286 8,05556

Srednja vrijednost

7,60000 7,70527 7,53429 7,81649


1,60000 1,56241 1,40929 0,80112

Relativna pogreška

9,20008 10,51643 11,03088 5,39855

Idealni slučaj

8,00000 8,25000 8,50000 8,75000


0,40000 0,54473 0,96571 0,93351

Tablica 17. Rezultati dobiveni biranjem različitih varijanti funkcije dobrote za slučaj korištenja parametra

by_algorithm

Ispitni primjerak 1




Najbolja vrijednost

8 49 9 118,00

Srednja vrijednost

7,60000 196,10000 9,00000 253,80000


1,60000 205,90000 0,00000 213,20000

Relativna pogreška

9,20008 59,64258 0,00000 45,85140

Idealni 8 4 2

65

slučaj


0,40000 -192,10000 -7,00000


by_algorithm

Ispitni primjerak 1




Najbolja vrijednost

8 6 4 74,70

Srednja vrijednost

7,60000 16,70000 5,90000 91,46000


1,60000 34,30000 3,10000 43,54000

Relativna pogreška

11,09571 82,49335 34,31942 20,21361

Idealni slučaj

8 4 2


0,40000 -12,70000 -3,90000

Tablica 19. Dobiveni parametri uz funkciju dobrote koja prati broj pogodaka i broj sklopova za slučaj u kojem se

koristi parametar by_algorithm

Ispitni primjerak 1




Najbolja vrijednost

8 19 6 81,70

Srednja vrijednost

7,40000 234,70000 8,60000 314,17000


1,40000 215,70000 2,60000 232,47000

Relativna pogreška

11,39559 72,55895 11,23363 58,88092

66

Idealni slučaj

8 4 2


0,60000 -230,70000 -6,60000


parametar by_algorithm

Ispitni primjerak 1




Najbolja vrijednost

8 7 4 79,70

Srednja vrijednost

7,80000 34,20000 6,80000 134,53000


0,80000 61,80000 2,80000 151,47000

Relativna pogreška

5,40560 94,60519 32,36779 50,40588

Idealni slučaj

8 4 2


0,20000 -30,20000 -4,80000


kojem se koristi parametar by_algorithm

Ponovno, promatranjem odmaka od idealnog slučaja za slučaj gdje se koristi parametar

by_algorithm (vidi: Tablica 17.), dobiva se da je najbolji odmak od idealnog slučaja imala

funkcija dobrote koja promatra samo broj pogodaka, zatim ona koja mjeri broj pogodaka i

sklopova, ona koja uzima u obzir sve parametre, i konačno, ona koja mjeri broj pogodaka i

razina.

Slično kao i kod slučaja bez uporabe operatora minimizacije i zamjene, promatranjem

odmaka od idealnog slučaja za broj pogodaka, sklopova i razina u ostalim tablicama (vidi:

Tablica 18.; Tablica 19.; Tablica 20.; Tablica 21.), vidljivo je da funkcija dobrote koja u obzir

67

uzima broj pogodaka i ona koja promatra broj pogodaka i razina imaju velik odmak od

idealnog slučaja za broj sklopova za razliku od ostale dvije.

Usporedbom ostalih dviju funkcija dobrote, ispada da je ona koja promatra broj pogodaka

i sklopova nešto bolja po odmaku od idealnog slučaja za broj sklopova i razina od one koja

promatra sve parametre. Drugim riječima, i za četvrti slučaj se dobiva funkcija dobrote

koja koristi broj pogodaka i sklopova kao najbolji odabir.

3.3.1.5. Analiza dobivenih rezultata

Promatranjem dobivenih tablica za različite varijacije parametara (bez korištenja

operatora, by_invididual, by_generation, by_algorithm), potrebno je izabrati funkciju

dobrote koja za sve četiri varijacije daje najbolje rezultate.

Ukoliko bi se taj odabir provodio tako da se uspoređuje odmak od idealnog slučaja za

neku varijaciju te se funkcije dobrote, ovisno o iznosu rezultata, poredaju u silaznom

poretku (od najbolje prema najgoroj), dobile bi se ove gradacije za svaku pojedinu

varijaciju parametara24:

• bez korištenja operatora: broj pogodaka >> broj pogodaka + broj razina >> broj

pogodaka + broj sklopova >> broj pogodaka + broj sklopova + broj razina

• by_individual: broj pogodaka + broj razina >> broj pogodaka + sklopova >> broj

pogodaka >> broj pogodaka + broj sklopova + broj razina

• by_generation: broj pogodaka >> broj pogodaka + broj razina >> broj pogodaka

+ broj sklopova >> broj pogodaka + broj sklopova + broj razina

• by_algorithm: broj pogodaka >> broj pogodaka + broj sklopova >> broj

pogodaka + broj sklopova + broj razina >> broj pogodaka + broj razina

24

Promatraju se tablice: Tablica 2., Tablica 7., Tablica 12., Tablica 17. ; Do istih zaključaka se došlo i na kraju svakog od prethodna četiri potpoglavlja.

68

Slika 13. Vrijednosti odmaka od idealnog slučaja za različite funkcije dobrote korištenjem različitih parametara (što

manje je bolje)

Usporedbom sve četiri varijacije parametara, najbolje vidljivo na temelju gornje slike (vidi:

Slika 24.), dobiva se gradacija funkcije dobrote (od bolje prema goroj):

broj pogodaka >> broj pogodaka + broj sklopova >> broj pogodaka + broj razina >> broj

pogodaka + broj sklopova + broj razina25

Trenutno dobiveni rezultat pokazuje da je najbolje koristiti funkciju dobrote koja u obzir

uzima samo broj pogodaka, međutim, usporede li se tablice koje pokazuju odmak od

idealnog slučaja za parametre kao što su broj dobivenih pogodaka, sklopova i razina, izbor

se ne pokazuje možda najboljim. Ovisno o odabiru funkcije dobrote za neku varijaciju26,

primjećuje se da funkcija dobrote koja koristi broj pogodaka i funkcija dobrote koja koristi

broj pogodaka uz broj razina imaju ogromno odstupanje u broju sklopova od idealnog

slučaja za razliku od funkcije dobrote koje gleda broj pogodaka i broj sklopova i funkcije

25

Dobrota s brojem pogodaka i razina te dobrota s brojem pogodaka i sklopova su zapravo manje više podjednake. 26

Promatraju se tablice: Tablica 3., Tablica 4., Tablica 5., Tablica 6., Tablica 8., Tablica 9., Tablica 10., Tablica 11., Tablica 13., Tablica 14., Tablica 15., Tablica 16., Tablica 18., Tablica 19., Tablica 20., Tablica 21.

69

dobrote koja gleda sve parametre, a osim toga, i odstupanje u broju razina od idealnog

slučaja je upola veće nego kod zadnje dvije funkcije dobrote u gornje navedenoj gradaciji.

Obzirom da je bila riječ o blagoj gradaciji, mogu se kao bolje funkcije dobrote izdvojiti

funkcija koja uzima u obzir broj pogodaka i broj sklopova i funkcija koja uzima u obzir sve

parametre. Funkcija koja uzima u obzir broj pogodaka i broj sklopova, osim što je bolja i u

samoj gradaciji, bolja je i po tome što koristi upola manje sklopova od funkcije koja uzima

u obzir sve parametre, a za broj razina i broj pogodaka su te dvije funkcije podjednake.

Prema tome, nameće se zaključak da je najpovoljnije koristiti funkciju dobrote koja uzima

u obzir broj pogodaka i broj sklopova27, a sada da se još promotri koju varijaciju

parametara uzeti kao najbolju s obzir na odabranu funkciju dobrote.

Za odabir najbolje moguće varijacije parametara, uzima se srednja vrijednost odabrane

funkcije dobrote (broj pogodaka i broj sklopova) za svaku od varijacija i tada se one

stavljaju u međusobnu usporedbu što je vidljivo s donje tablice (vidi: Tablica 22.). Tablica

je sastavljena tako da se srednja vrijednost dobrote retka oduzme od srednje vrijednosti

dobrote stupca gdje redak i stupac označavaju varijaciju parametra. Iz tablice se vidi da

najbolje rezultate daje parametar by_algorithm obzirom da se za njega dobivaju sve

pozitivne vrijednosti što znači da je po srednjoj vrijednosti funkcije dobrote bolji od

ostalih varijacija.

Ispitni primjerak 1

Postotna poboljšanja/pogoršanja u odnosu na razne varijante te utjecaj operatora na srednju dobrotu jedinki

bez minimizacije i zamjene

by_individual by_generation by_algorithm

bez minimizacije i

zamjene 0,00000 0,00432 -0,15383 -0,48643

by_individual -0,00432 0,00000 -0,15815 -0,49075

by_generation 0,15383 0,15815 0,00000 -0,33260

27

Do istih zaključaka došlo se i na kraju svaka od prethodna četiri potpoglavlja gdje je svaki puta kao najbolja varijanta ispalo korištenje upravo dobivene funkcije dobrote.

70

by_algorithm 0,48643 0,49075 0,33260 0,00000

Tablica 22. Međusobna usporedba varijacije parametara s obzirom na srednju vrijednost funkcije dobrote koja uzima

u obzir broj pogodaka i broj sklopova

Osim po srednjoj vrijednosti funkcije dobrote, usporedba se može odvijati tako da se

uspoređuje prosječno vrijeme izvođenja algoritma uz uvjet da se izvodilo uz odabranu

funkciju dobrote koja je izabrana kao najbolja (broj pogodaka i broj sklopova). Ponovno je

vidljivo da se najbolji rezultati dobivaju za parametar by_algorithm, ali ovdje pak iz

razloga jer su sve dobivene vrijednosti za tu varijaciju negativne, što bi značilo da je on po

prosječnoj duljini izvođenja bolji od ostalih varijacija (vidi: Tablica 23.). Tablica se sastavlja

na sličan način kao i prethodna, od prosječnog vremena izvođenja retka se oduzima

prosječno vrijeme izvođenja stupca, s time da retci i stupci predstavljaju različite varijacije

parametara.

Ispitni primjerak 1

Postotna poboljšanja/pogoršanja u odnosu na razne varijante te vrijeme izvođenja algoritma

bez minimizacije i zamjene

by_individual by_generation by_algorithm

bez minimizacije i

zamjene 0,00000 -3916,02000 -12,10000 2,52000

by_individual 3916,02000 0,00000 3903,92000 3918,54000

by_generation 12,10000 -3903,92000 0,00000 14,62000

by_algorithm -2,52000 -3918,54000 -14,62000 0,00000

Tablica 23. Međusobna usporedba varijacije parametara s obzirom na srednju vrijednost vremena izvođenja

algoritma, pri čemu se uzima u obzir funkcija dobrote koja gleda broj pogodaka i broj sklopova

Iz dobivenih rezultata zaključuje se da je najbolja varijacija parametara koja se može

koristiti za dani primjer korištenje parametra by_algorithm, a najbolja funkcija dobrote

koja se može uz nju koristiti je ona koja kombinira kao svoje parametre broj pogodaka i

broj sklopova.

71

Osim toga, mogu se grafički prikazati i prosječna kretanja populacije kroz veći broj

pokretanja algoritma tako da se prikaže kretanje s obzirom na vrijednost funkcije dobrote,

broj pogodaka, broj sklopova i broj razina. Za funkciju dobrote uzima se ona koja

promatra broj pogodaka i broj sklopova (dakle, ona koja je određena kao najbolja), a za

parametar by_algorithm (također pokazan kao najbolji).

Kretanje populacije se promatra kao kretanje najbolje i prosječne vrijednosti nekog

odabranog parametra kroz veći broj pokretanja programa (za potrebe prikaza sljedećih

grafičkih rezultata, odabrana su tri pokretanja). Umjesto prikaza vrijednosti najbolje i

prosječne vrijednosti parametra kroz svih stotinu generacija, odabrani su generacijski

miljokazi koji ukazuju na otprilike svaku desetu generaciju tokom izvođenja programa.

Slika 14. Kretanje populacije kroz generacijske miljokaze za vrijednosti funkcije dobrote

Na gornjoj slici vidljivo je jedno takvo kretanje za funkciju dobrote (vidi: Slika 14.) i to za

onu koja prati broj pogodaka i sklopova. Vidljiv je rast vrijednosti dobrote kretanjem kroz

generacije, kako i najbolje, tako i prosječne vrijednosti dobrote. Također, uočljivo je kada

72

bi se nastavilo iterirati kroz generacije, udaljenost između prosječne i najbolje vrijednosti

postajala bi sve manja.

Slika 15. Kretanje populacije kroz generacijske miljokaze za vrijednosti broja pogodaka

Idući parametar kojeg vrijedi promotriti jest onaj koji promatra broj pogodaka što je

vidljivo s gornje slike (vidi: Slika 15.). Vidi se kako vrijednosti broja pogodaka rastu i za

prosječnu i za najbolju vrijednost, a osim toga, uočljivo je i približavanje tih dviju

vrijednosti.

Nakon broja pogodaka, zanimljivo je pogledati što se događa s brojem sklopova i razina.

Ovdje je jedino potrebno napomenuti da se pod najboljom vrijednošću broja sklopova i

razina ne podrazumijevaju vrijednosti tih dvaju parametara sadržane u najboljoj jedinci u

nekoj generaciji, nego vrijednosti tih parametara neovisnih o funkciji dobrote.

Tako promatranjem donje slike (vidi: Slika 16.) za broj sklopova, uočit će se kako broj

sklopova prolaskom kroz sve veći broj generacija naglo opada, a prosječna vrijednost

također prati najbolju vrijednost i s vremenom je odmak između njih sve manji.

73

Slika 16. Kretanje populacije kroz generacijske miljokaze za vrijednosti broja sklopova

Zadnji parametar za kojeg vrijedi pogledati kretanje populacije jest broj razina. Kretanje

populacije za broj razina prikazano je na donjoj slici (vidi: Slika 17.) gdje je vidljivo kako

broj razina s vremenom opada, s time da za najbolju vrijednost opada brže nego za

prosječnu pa se prosječna ne stiže toliko brzo približiti najboljoj.

74

Slika 17. Kretanje populacije kroz generacijske miljokaze za vrijednosti broja razina

Iz cijele statistike za primjer potpunog zbrajala može se zaključiti da program ne radi

toliko loše jer daje ispravna rješenja, međutim broj sklopova i razina nije baš

zadovoljavajući. Drugim riječima, možda se uspjelo postići ispravnost rada mreže,

odnosno poklopiti sve ulazne kombinacije s izlaznima (što je ujedno bio i najvažniji

zahtjev), ali se nije uspjelo doći do idealnog slučaja s minimalnim brojem sklopova i razina.

Kako bi se to popravilo, mogao bi se postaviti veći broj inicijalne populacije pa se tako sa

broja trideset za probu taj broj postavio na 300 jedinki. Nakon prvih nekoliko pokretanja,

došlo se do dva rješenja koja su vrlo bliska idealnom slučaju, a već nakon šestog

pokretanja pojavio se i idealni slučaj.

Umjesto izrade tablice, zanimljivije bi bilo taj slučaj promotriti ponovno na grafovima koji

opisuju kretanje populacije (koja je sad puno veća nego prije).

75

Slika 18. Kretanje populacije od 300 jedinki kroz generacijske miljokaze za vrijednosti funkcije dobrote

Slika 19. Kretanje populacije od 300 jedinki kroz generacijske miljokaze za vrijednosti broja pogodaka

76

Slika 20. Kretanje populacije od 300 jedinki kroz generacijske miljokaze za vrijednosti broja sklopova

Slika 21. Kretanje populacije od 300 jedinki kroz generacijske miljokaze za vrijednosti broja razina

77

Gornji grafovi (vidi: Slika 18.; Slika 19.; Slika 20.; Slika 21.) izrađeni su s vrijednostima koje

je dao sustav kada je dobio idealni slučaj (dakle, nakon šestog pokretanja). Vidljivo je kako

se kretanjem kroz generacijske miljokaze (još uvijek je riječ o 100 generacija) već u

četvrtom miljokazu uočavaju idealne vrijednosti za sve parametre. Moguće je da je već

tada nastao idealan slučaj koji se zatim generacijski samo prenosio do kraja algoritma i

time utjecao na vrijednosti ostalih jedinki čija su se prosječna kretanja, kako je vidljivo s

grafova, približavala idealnom slučaju.


Idući ispitni primjerak je generator parnog pariteta čije su ulazne i izlazne vrijednosti u

sljedećem obliku unesene u konfiguracijsku datoteku:

<Entry key="varset">0000 0001 0010 0011 0100 0101 0110 0111 1000 1001

1010 1011 1100 1101 1110 1111</Entry> <Entry key="cellvalue">0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0</Entry>

S obzirom na donju sliku (vidi: Slika 22.), u funkcije dobrote za dobivanje idealnog slučaja

uvrštava se vrijednost sedam za broj sklopova te vrijednost tri za broj razina, i naravno,

vrijednost šesnaest za broj pogodaka, odnosno, za odabranu funkciju dobrote koja gleda

samo broj pogodaka i broj sklopova to je izraženo formulom (vidi: Jednadžba 1.).

78

Slika 22. Izgled mreže za generator parnog pariteta [27] (lijeva slika) te njegov ekvivalent prikazan kao stablo (desna

slika)

Tablica koja se dobiva ispitivanjem tog ispitnog primjerka je prikazana niže (vidi: Tablica

24.).

Ispitni primjerak 2

Različiti parametri za zadnju generaciju i vrijeme trajanja izvođenja algoritma (dobrota - broj pogodaka + broj sklopova) uz uključen parametar by_algorithm


dobrota (broj pogodaka +

broj sklopova Broj pogodaka Broj sklopova Broj razina

Brzina izvođenja

algoritma [ms]

Najbolja vrijednost

16,1429 16 7 3 123,00

Srednja vrijednost

15,03938 15,00000 65,00000 7,80000 201,70000


3,00488 3,00000 116,00000 4,80000 147,30000

Relativna pogreška

8,41031 8,31479 85,38731 27,56327 38,99275

Idealni slučaj

16,14285 16 7 3


1,10347 1,00000 -58,00000 -4,8

Tablica 24. Dobiveni parametri za drugi ispitni primjerak uz funkciju dobrote koja prati broj pogodaka i broj sklopova

za slučaj u kojem se koristi parametar by_algorithm

Za ovaj ispitni primjerak, idealni slučaj je dobiven tek u zadnjem ispitivanju, a osim toga,

odmak od idealnog slučaja je u potpunosti neodgovarajući i dobiva se mnogo vrijednosti

za funkciju dobrote najbolje jedinke koje ne zadovoljavaju u potpunosti kriterij ispravnosti

rada mreže. U dosta slučajeva dogodilo se da nedostaju jedan ili dva pogotka kako bi

mreža ispravno radila. Razlog tome može biti i taj što je za korištenu funkciju dobrote

odabrana ona koja se ispostavila kao najbolja za prvi testni primjerak (potpuno zbrajalo),

međutim, ta funkcija dobrote ne mora za ovaj primjerak davati isto tako dobre rezultate.

79


Za ispitni primjerak mreže koja opisuje indikaciju posmaknutog bita kružnim posmakom

udesno navedene su sljedeće ulazne i izlazne vrijednosti u konfiguracijskoj datoteci:

<Entry key="varset">0000 0001 0010 0011 0100 0101 0110 0111 1000 1001

1010 1011 1100 1101 1110 1111</Entry> <Entry key="cellvalue">0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1</Entry>

Slika 23. Prikaz indikatora kružnog posmaka udesno u virtualni registar (lijeva slika) svodi se na samo jedan čvor u

stablu (desna slika)

Ako se pogleda gornja slika (vidi: Slika 23.), uočava se da je za broj razina i broj sklopova

dovoljno uzeti vrijednost jedan te se time dobiva kao idealni slučaj za odabranu funkciju

dobrote izraženo formulom (vidi: Jednadžba 1.).

Tablica koja se dobiva ispitivanjem tog ispitnog primjerka prikazana je niže (vidi: Tablica

25.).

Ispitni primjerak 3





Brzina izvođenja

algoritma [ms]

Najbolja vrijednost

17 16 1 1 84,80

Srednja vrijednost

16,71073 15,90000 8,00000 2,20000 155,65000


1,69433 0,90000 53,00000 6,80000 105,35000

Relativna 3,95155 1,98885 236,07026 122,71792 35,66481

80

pogreška

Idealni slučaj

17 16 1 1


0,28927 0,10000 -7,00000 -1,2

Tablica 25. Dobiveni parametri za treći ispitni primjerak uz funkciju dobrote koja prati broj pogodaka i broj sklopova

za slučaj u kojem se koristi parametar by_algorithm

Za ovaj testni primjerak dobiven je idealni slučaj i njemu u potpunosti odgovara

kombinacija korištenja funkcije dobrote koja gleda broj pogodaka i sklopova te parametar

by_algorithm.


Zadnji ispitni primjerak predstavlja generator četvrtog zaštitnog bita Hammingovog

kodera za četverobitnu ulaznu riječ, pri čemu su navedene ulazne i izlazne vrijednosti u

konfiguracijskoj datoteci sljedeće:

<Entry key="varset">0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111</Entry>

<Entry key="cellvalue">0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1</Entry>

Slika 24. Izgled mreže za generator četvrtog zaštitnog bita Hammingovog kodera [29] (lijeva slika) te stablo

generirano iz te mreže (desna slika)

81

Sa gornje slike (vidi: Slika 24.) vidljivo je da će broj razina biti tri, a broj sklopova pet, što bi

značilo da je idealni slučaj za odabranu funkciju dobrote dobiven kao izraženo

formulom (vidi: Jednadžba 1.).

Tablica koja se dobiva ispitivanjem tog ispitnog primjerka dana je u nastavku teksta (vidi:

Tablica 26.).

Ispitni primjerak 4





Brzina izvođenja

algoritma [ms]

Najbolja vrijednost

16,1667 16 6 4 106,00

Srednja vrijednost

15,04596 15,00000 58,10000 7,50000 213,90000


2,01656 2,00000 64,90000 3,50000 109,10000

Relativna pogreška

7,13146 7,02728 78,69198 28,28427 37,98595

Idealni slučaj

16,2 16 5 3


1,15404 1,00000 -53,10000 -4,5

Tablica 26. Dobiveni parametri za četvrti ispitni primjerak uz funkciju dobrote koja prati broj pogodaka i broj

sklopova za slučaj u kojem se koristi parametar by_algorithm

Slično kao i kod drugog testnog primjerka, odmak od idealnog slučaja nije zadovoljavajući

i niti jednom se ne dobije idealni slučaj. Razlog tome također može biti funkcija dobrote

koja gleda samo broj pogodaka i sklopova.

82

Zaključak

Provedbom statističkih mjerenja nad odabranim ispitnim primjercima mreža koje se

trebaju generirati kao izlaz implementiranog sustava za oblikovanje kombinacijskih mreža,

dobiva se pokazatelj korisnosti same programske implementacije.

Obzirom da je pri analizi rezultata bio definiran idealni slučaj, odnosno, u neku ruku

traženo rješenje, usporedbom dobivenih rješenja s traženim dobili su se maleni odmaci

od idealnog slučaja. Upravo to pokazuje kako je korisnost implementiranog sustava velika.

Međutim, uzimajući u obzir da su ispitni primjerci primjeri mreža s relativno malim

brojem ulaza, da je veličina populacije bila postavljena na trideset jedinki, a broj

populacija kroz koje populacija evaluira na 100 iteracija, očekivalo bi se da se idealni slučaj

trebao pojaviti pri ispitivanju barem jednom za svaki od testnih primjeraka. Ali idealni

slučaj se pojavljuje svega jednom i to za ispitni primjerak generatora parnog pariteta, a za

ostale ispitne primjerke uočavaju se samo blaga približavanja idealnom slučaju.

Teško je odrediti što šteti maksimalnoj korisnosti implementiranog sustava i što se može

učiniti kako bi se ona poboljšala, ali se može pretpostaviti da je zbog nedovoljno

„slučajnosti“ unesene u selekciju jedinki za križanje i mutaciju algoritam „patio“ od tzv.

zaglavljivanja u lokalnim optimumima (što se zna dogoditi ako se ne koristi dovoljno

„slučajna“ selekcija). Razlog nedovoljne „slučajnosti“ jest činjenica da se u algoritmu

selekcijom odabire uvijek najbolja jedinka kao jedan roditelj u operaciji križanja te najgora

koja će biti eliminirana nakon što se stvori dijete iz križanja odabranih roditelja.

Ovakav način rada algoritma dugoročno i nije najisplativije rješenje, prema tome, trebalo

bi možda uvesti korištenje dodatnog selekcijskog operatora koji bi omogućio neku vrstu

„slučajnosti“ (mogućnost odabira kao parametra).

Osim toga, problem može predstavljati i definicija funkcije dobrote koja se uz korištenje

parametara koji opisuju utjecaj broja sklopova i broja razina na dobrotu jedinki, proširuje

sa osnovnog parametra (broj pogodaka ulaza s izlazima) samo do maksimalne vrijednosti

uvećane za jedan. Tome bi se moglo doskočiti uvođenjem faktora utjecaja koji bi se mogli

83

množiti ili potencirati s vrijednostima parametara kako bi se raspon vrijednosti funkcije

dobrote proširio i time dao veću gradaciju jedinki ili bi se pak, kao što je već negdje

spomenuto u tekstu, moglo upotrijebiti višekriterijsko optimiranje koje pruža mogućnost

rada s više parametara koji se uzimaju kao ukupna dobrota jedinke.

Postoji mnogo karakteristika sustava koje bi se mogle poboljšati, ali odabrane su samo

dvije možda najuočljivije koje su prethodno objašnjene.

Bez obzira na „nesavršenstvo“ implementiranog sustava, sa rezultatima koje on ostvaruje

za definiranu domenu kombinacijskih mreža (sa maksimalno četiri ulaza i jednim izlazom),

može se biti zadovoljan jer zadovoljava najpotrebniji parametar, a to je broj pogodaka

ulaza s izlazima koji određuje ispravnost rada same mreže.

84

Dodatak

U ovom dodatku su dane formule upotrijebljene za računanje statistike u mjerenjima [30].

Srednja vrijednost:

Maksimalna apsolutna pogreška:

Relativna pogreška:

85

Literatura

[1] Čupić, M. (23. listopad 2008.). Digitalna logika - Uputa za šestu laboratorijsku vježbu.

Preuzeto 29. svibanj 2009. iz www.fer.hr: http://www.fer.hr/_download/repository/DL-

LAB06.pdf

[2] Peruško, U., & Glavinić, V. (2005.). Digitalni sustavi. Zagreb: Školska knjiga.

[3] Espresso heuristic logic minimizer. (20. svibanj 2009.). Preuzeto 29. svibanj 2009. iz

Wikipedia, the free encyclopedia: http://en.wikipedia.org/wiki/Publicad

[4] Lysecky, R., & Vahid, F. (2. lipanj 2003.). On-Chip Logic Minimization. Preuzeto 29.

svibanj 2009. iz www.cs.ucr.edu: http://www.cs.ucr.edu/~vahid/pubs/dac03_oclm.pdf

[5] Green, S. (7. prosinac 2008.). Circuit Minimization. Preuzeto 28. svibanj 2009. iz

Wikimedia Commons: http://commons.wikimedia.org/wiki/File:Circuit-minimization.svg

[6] Miller, J. F., Job, D., & Vassilev, V. K. (6. kolovoz 1999.). Principles in the Evolutionary

Design of Digital Circuits - Part I. Preuzeto 28. svibanj 2009. iz SpringerLink:

http://www.springerlink.com/content/qg444pr7u4611741/fulltext.pdf?page=1

[7] Coello, C. A., Christiansen, A. D., & Hernandez Aquirre, A. (11. lipanj 2005.). Automated

Design of Combinational Logic Circuits using Genetic Algorithms. Preuzeto 28. svibanj

2009. iz delta.cs.cinvestax.mx:

http://delta.cs.cinvestav.mx/~ccoello/conferences/icannga97.pdf.gz

[8] Sarif, B. A. (n.d.). Evolutionary Design of Digital Circuits. Preuzeto 28. svibanj 2009. iz

faculty.kfupm.edu.sa:

http://www.google.hr/url?sa=t&source=web&ct=res&cd=10&url=http%3A%2F%2Ffaculty

.kfupm.edu.sa%2FCOE%2Fbambang%2Ffiles%2Fpresentations%2FEvolutionary%2520Desi

gn%2520of%2520Digital%2520Circuit.ppt&ei=fMEfStmfA5ib_QbM1KSbCQ&usg=AFQjCNF

iCG3bLYPKMjAbDJf07O7g7wjb

86

[9] Noren, K. V., & Ross, J. E. (29. svibanj 2002.). Analog Circuit Design Using Genetic

Algorithms. Preuzeto 28. svibanj 2008. iz www.mrc.uidaho.edu:

http://www.mrc.uidaho.edu/~knoren/GAs/B-159_paper.PDF

[10] Gold, M. (26. prosinac 2006.). Using Genetic Algorithms to Design Logic Circuits in C#.

Preuzeto 28. svibanj 2009. iz C# Corner: http://www.c-

sharpcorner.com/UploadFile/mgold/GAAdderDesign09242005053429AM/GAAdderDesig

n.aspx

[11] Koza, J. R., Bennett, F. H., Lohn, J., Dunlap, F., Keane, M. A., & Andre, D. (9. svibanj

2002.). Automated Synthesis of Computational Circuits Using Genetic Programming.

Preuzeto 29. svibanj 2009. iz ti.arc.nasa.gov:

http://ti.arc.nasa.gov/people/jlohn/Papers/icec1997.pdf

[12] Koza, J. R. (1992.). Genetic Programming: On the Programming of Computers by

Means of Natural Selection. Cambridge, Massachusetts: The MIT Press.

[13] Poli, R., Langdon, W. B., McPhee, N. F., & Koza, J. R. (12. siječanj 2009.). A Field Guide

to Genetic Programming. Preuzeto 28. svibanj 2009. iz www.lulu.com:

http://www.lulu.com/items/volume_63/2167000/2167025/2/print/book.pdf

[14] Howard, D. (6. lipanj 2008.). Multiple Solutions by Means of Genetic Programming: A

Collision Avoidance Example. Preuzeto 29. svibanj 2009. iz SpringerLink:

http://www.springerlink.com/content/91k622t65778n62k/fulltext.pdf?page=1

[15] Brajer, I. (12. veljača 2009.). ECF - DigitalCircuit branch. Preuzeto 29. svibanj 2009. iz

www.zemris.fer.hr: svn://smaug.zemris.fer.hr/ecf/branches/DigitalCircuit

[16] Jakobović, D. (23. svibanj 2009.). ECF - Evolutionary Computation Framework.

Preuzeto 28. svibanj 2009. iz www.fer.hr: http://gp.zemris.fer.hr/ecf/

[17] Tree traversal. (21. svibanj 2009.). Preuzeto 30. svibanj 2009. iz Wikipedia, the free

encyclopedia: http://en.wikipedia.org/wiki/Tree_search

87

[18] Searson, D. (11. svibanj 2007.). Symbolic regression using multiple gene/tree

representations of models in GPTIPS. Preuzeto 30. svibanj 2009. iz ncl.ac.uk:

http://www.staff.ncl.ac.uk/d.p.searson/multigene_regression.htm

[19] Mori, N., McKay, B., Hoai, N. X., Essam, D., & Takeuchi, S. (18. veljača 2009.). A New

Method for Simplifying Algebraic Expressions in Genetic Programming Called Equivalent

Decision Simplification. Preuzeto 30. svibanj 2009. iz www.fujipress.jp:

http://www.google.hr/url?sa=t&source=web&ct=res&cd=1&url=http%3A%2F%2Fwww.fu

jipress.jp%2Ffinder%2Fpreview_download.php%3Fpdf_filename%3DPRE_JACII001300030

010.pdf%26frompage%3Dabst_page%26pid%3D%26lang%3DEnglish&ei=9PEgSqPtOMSOs

Aaxw6y_Bg&usg=AFQjCNGnnHk_N2

[20] Belton, D. (8. prosinac 2005.). Karnaugh Maps. Preuzeto 29. svibanj 2009. iz

www.ee.surrey.ac.uk:

http://www.ee.surrey.ac.uk/Projects/Labview/minimisation/karnaugh.html

[21] Logic simplification with Karnaughs maps. (10. veljača 2009.). Preuzeto 30.. svibanj

2009. iz All About Circuits: http://www.allaboutcircuits.com/vol_4/chpt_8/6.html

[22] Mendes, S. (14. travanj 2004.). Karnaugh4. Preuzeto 31. svibanj 2009. iz

www.smendes.com: http://www.smendes.com/el10b/karnaugh4.gif

[23] CMSC 313 Selected Lecture Notes. (5. rujan 2004.). Preuzeto 31. svibanj 2009. iz

www.cs.umbc.edu: http://www.cs.umbc.edu/~squire/cs313_lect.html

[24] Nave, R. (6. ožujak 2001.). Exclusive OR Gate. Preuzeto 27. svibanj 2009. iz

hyperphysics.phy-astr.gsu.edu: http://hyperphysics.phy-

astr.gsu.edu/HBASE/Electronic/xor.html#c2

[25] Eclipse Foundation, Inc. (30. svibanj 2009.). Eclipse.org Home. Preuzeto 31. svibanj

2009. iz www.eclipse.org: http://www.eclipse.org/

[26] Hoyer, H. (11. listopad 2008.). Harald Hoyer Homepage. Preuzeto 2. lipanj 2009. iz

ourworld.compserve.com: http://ourworld.compuserve.com/homepages/harald_hoyer/

88

[27] Hsu, J. Y. (4. travanj 2009.). Computer Logic: Design Principles and Applications.

Preuzeto 3. lipanj 2009. iz books.google.hr:

http://books.google.hr/books?id=evgrgF1jKdAC&pg=PA102&lpg=PA102&dq=parity+ciruci

t&source=bl&ots=C_56sVm-

Ug&sig=uYn0Qj0US7JVbBp0JCZhHzLqQS4&hl=hr&ei=FComStyuHIiLsAai-

9TXBQ&sa=X&oi=book_result&ct=result&resnum=10#PPA104,M1

[28] Pandžić, I. S., Bažant, A., Ilić, Ž., Vrdoljak, Z., Kos, M., & Sinković, V. (2007.). Uvod u

teoriju informacije i kodiranje. Zagreb: Element.

[29] Stroud, C. E. (21. siječanj 2009.). A Designer's Guide to Built-in Self-Test. Preuzeto 3.

svibanj 2009. iz books.google.hr: http://books.google.hr/books?id=KOrTsg-

wUI0C&pg=PA275&lpg=PA275&dq=hamming+circuit&source=bl&ots=-

Chfijk1p9&sig=c3QOoNyAcbhcSlGlA7RGrrN8KzI&hl=hr&ei=YysmSuGXHoiS_QbFp7TZBw&s

a=X&oi=book_result&ct=result&resnum=4#PPA275,M1

[30] Račun pogrešaka. (11. listopad 2007.). Preuzeto 4. lipanj 2009. iz phy.grf.hr:

http://phy.grf.hr/media/download_gallery/Fizika1_pogre%C5%A1ke_2.pdf

[31] Cameron, S. (19. lipanj 2006.). Symbolic Regression. Preuzeto 29. svibanj 2009. iz

www.alesdar.org: http://www.alesdar.org/oldSite/IS/chap6-2.html

[32] Hamming distance. (4. travanj 2009.). Preuzeto 30. svibanj 2009. iz Wikipedia, the

free encyclopedia: http://en.wikipedia.org/wiki/Hamming_distance

[33] Canonical form (Boolean algebra). (18. svibanj 2009.). Preuzeto 31. svibanj 2009. iz

Wikipedia, the free encyclopedia:

http://en.wikipedia.org/wiki/Canonical_form_(Boolean_algebra)

[34] Top down and bottom up design. (20. svibanj 2009.). Preuzeto 30. svibanj 2009. iz

Wipedia, the free encyclopedia: http://en.wikipedia.org/wiki/Top-down

89

Sažetak

Opisana je problematika oblikovanja kombinacijskih mreža s obzirom na optimizacijska

mjerila vrednovanja kao što su minimiziranost mreže i maksimalno vrijeme kašnjenja.

Ostvaren je programski sustav za automatsko oblikovanje kombinacijskih mreža temeljen

na genetskom programiranju s upotrebom stablastog genotipa. Sustavu je omogućen rad

s različitim parametrima vrednovanja jedinki preko četiri različite definicije funkcije

dobrote te su omogućene dodatne funkcionalnosti kao što je upotreba operatora

minimizacije i operatora zamjene koje se mogu koristiti na tri različita načina pri izvođenju

algoritma. Eksperimentalno je utvrđena učinkovitost implementiranog sustava s obzirom

na četiri različita ispitna primjerka kombinacijskih mreža uz priložena statistička mjerenja i

analizu rezultata.

The main issue described within the bachelors thesis is the automated design of

combinational logic circuits using genetic programming with respect to optimization

evaluation criteria such as network minimization and maximal delay time. A software

system for automated design of combinational networks based on genetic programming

and the usage od tree genotype has been implemented. The system works with various

parameters of unit evaluation throughout four different fitness function definitions and

enables additional functionalities such as the utilization of minimization and swapping

operators which can be used in three different ways in performing algorithms. The

efficiency of the implemented system has been determined experimentally at four

different test specimens, with the statistical measurements and the results analysis

attached.

Documents

OBLIKOVANJE KOMBINACIJSKIH MREŽA UPORABOM … · početna mreža od pet sklopova minimizira na samo jedan sklop, a broj ulaza i izlaza pri tom ostaje konstantan te su mreže po kombinaciji