Symulator zachowań osobników – teoria doboru naturalnego w

Rok akademicki 2012/2013
Politechnika Warszawska
Wydział Elektroniki i Technik Informacyjnych
Instytut Informatyki
PRACA DYPLOMOWA INŻYNIERSKA
Krzysztof Burliński
Symulator zachowań osobników – teoria doboru
naturalnego w wirtualnym środowisku
Opiekun pracy
mgr inż. Krzysztof Gracki
Ocena: .....................................................
.................................................................
Podpis Przewodniczącego
Komisji Egzaminu Dyplomowego
Kierunek:
Informatyka
Specjalność:
Inżynieria Systemów Informatycznych
Data urodzenia:
1989.01.03
Data rozpoczęcia studiów:
2010.02.22
Życiorys
Urodziłem się 3 stycznia 1989 roku w Bydgoszczy. Mój ojciec jest inżynierem
geodetą, a matka pracuje jako nauczycielka w liceum. Mam starszego brata, Piotra.
Edukację rozpocząłem od sportowej Szkoły Podstawowej nr 39 w Bydgoszczy, którą
ukończyłem z wyróżnieniem. Kolejnym etapem mojej edukacji było Gimnazjum nr 50,
należące do Zespołu Szkół Ogólnokształcących, gdzie później kontynowałem edukację w
liceum. W szkole średniej brałem udział w wielu konkursach, między innymi w Olimpiadzie
Informatycznej, w której doszedłem do etapu regionalnego, oraz w Olimpiadzie
Ekonomicznej, gdzie uzyskałem tytuł finalisty. Po zdaniu matury w roku 2008 rozpocząłem
studia na wydziale Mechatroniki Politechniki Warszawskiej, jednakże wskutek zmiany
zainteresowań przeszedłem od lutego 2010 na wydział Elektroniki i Technik Informacyjnych
na kierunku Informatyka i specjalności Inżynieria Systemów Informatycznych.
W wolnych chwilach zajmuję się swoimi zainteresowaniami, do których należą
terrarystyka i literatura fantastyczna. Tworzę również gry na platformy mobilne.
.......................................................
Podpis studenta
EGZAMIN DYPLOMOWY
Złożył egzamin dyplomowy w dniu ..................................................................................2013 r
z wynikiem ...................................................................................................................................
Ogólny wynik studiów: ................................................................................................................
Dodatkowe wnioski i uwagi Komisji: ..........................................................................................
.......................................................................................................................................................
.......................................................................................................................................................
STRESZCZENIE
„Symulator zachowań osobników – teoria doboru naturalnego w wirtualnym
środowisku” jest projektem z pogranicza informatyki i biologii. Praca opisuje stworzenie
systemu służącego do obserwacji zmian dążących do wzrostu przystosowania populacji
osobników. Projekt ten obejmował stworzenie wirtualnego środowiska, w którym
panowałyby prawa fizyczne podobne do rzeczywistych, a które byłoby zamieszkanie przez
jednostki o prostej budowie i zachowaniu, mogące podlegać zmianom genetycznym.
Osobniki są zbudowane z okrągłych modułów, z których każdy może czujnikiem lub
silnikiem. W ramach systemu stworzyłem trzy moduły. Pierwszym jest biblioteka,
udostępniająca metody tworzenia środowiska wirtualnego oraz symulująca życie osobników.
Kolejnym jest program implementujący algorytm ewolucyjny, który za funkcję celu
przyjmuje skuteczność jednoski w wirtualnym świecie. Ostatnim jest program prezentujący
osobniki na ekranie w sposób graficzny, pozwalający na podglądanie wyników badań oraz
testowanie jednostek. W ramach projektu wykonałem dwa badania, pierwsze z nich,
„Szukanie jedzenia” polegało na zapełneniu świata jedzeniem, które, zbierane przez osobniki,
służyło jako funkcja celu algorytmu. Drugi eksperyment, „Ruch liniowy” polegał na użyciu
algorytmu ewolucyjnego do stworzenia osobnika, który będzie najskuteczniejszy w
pokonywaniu długich dystansów. System ten można by w przyszłości usprawnić, poprzez
zaimplementowanie nowych sposobów kodowania genów oraz usprawnienie języka
skryptowego zarządzającego jednostkami.
Słowa kluczowe: symulacja, algorytm ewolucyjny, dobór naturalny, wirtualny świat
Simulating the behavior of beings – theory of natural selection in virtual
environment
The thesis is about creating a project bordering on computer science and biology. It
describes creating a system to follow changes in population, which lead to increased
adaptation of beings. Main part of the project was designing a virtual environment habited
with beings of simple build. Such virtual beings are built from simple round modules of
various type, which could be detectors or engines, and are conducted using simple script. The
system consists of three main modules. First of them is library, serving methods and
structures needed to create and operate beings on virtual world. Next one is an
implementation of evolutionary algorithm, which uses the virtual environment to calculate its
fitness function. Last module is a program used to visualize beings and observe their
behavior. To test the system, I performed two experiments. First of them, “Finding food”,
tests the ability of units to collect pieces of food, which are randomly distributed in the
environment. Second of them, “Linear motion” evolves units to make them able to cover the
longest distance. Created system can be further developed, by implementing new genomes
implementations or improving the units steering algorithm.
Keywords: simulation, evolutionary algorithm, natural selection, virtual world
Spis treści
1. Wprowadzenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2. Przeglad
˛ wiedzy . . . . . . . . . . . . . . . . . .
2.1. Darwinowska zasada doboru naturalnego
2.2. Gra w życie . . . . . . . . . . . . . . . . . .
2.3. Symulacje w nauce . . . . . . . . . . . . .
2.4. Model fizyczny środowiska . . . . . . . . .
2.5. Algorytmy ewolucyjne . . . . . . . . . . . .
2.5.1. Operator selekcji . . . . . . . . . .
2.5.2. Operator krzyżowania . . . . . . . .
2.5.3. Operator mutacji . . . . . . . . . .
.
.
.
.
.
.
.
.
.
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4
4
5
6
7
10
11
12
12
3. Projekt systemu symulacji doboru naturalnego
3.1. Wymagania i założenia . . . . . . . . . . . . .
3.2. Zastosowane technologie . . . . . . . . . . . .
3.3. Podział na moduły . . . . . . . . . . . . . . . .
3.3.1. Środowisko symulacyjne . . . . . . . .
3.3.2. Program ewoluujacy
˛
. . . . . . . . . .
3.3.3. Program prezentujacy
˛
. . . . . . . . .
3.4. Osobniki . . . . . . . . . . . . . . . . . . . . .
3.4.1. Budowa jednostek . . . . . . . . . . . .
3.4.2. Zachowanie . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
14
14
15
16
17
18
19
19
19
20
4. Implementacja . . . . . . . . . . . . . . . . . .
4.1. Używane struktury . . . . . . . . . . . . .
4.2. Opis i działanie wirtualnego świata . . . .
4.3. Tworzenie przykładowego osobnika . . . .
4.4. Algorytm ewolucyjny . . . . . . . . . . . .
4.5. Przechowywanie wyników algorytmu . . .
4.6. Prezentowanie wyników . . . . . . . . . .
4.7. Wykorzystane narzedzia
˛
programistyczne
4.8. Szacowanie złożoności obliczeniowej . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
22
22
23
24
25
27
28
29
30
5. Eksperymenty . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.1. Szukanie jedzenia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2. Ruch liniowy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
32
32
35
6. Podsumowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
38
Bibliografia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
39
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1. Wprowadzenie
Teoria ewolucji, choć jest dziedzina˛ nauki nie ważniejsza˛ od wielu innych, zdaje
si˛e wywoływać nadzwyczajne emocje zarówno w kregach
˛
naukowych jak i w opinii
publicznej. Spowodowane jest to zapewne tym, że dotyka ona pochodzenia wszystkich stworzeń na ziemi, w tym człowieka. Ponadto, mimo że wiele trudu zostało
już włożone w zbadanie historii gatunków, ciagle
˛
poszukuje sie˛ tzw. brakujacych
˛
ogniw, a wiedza jest wcia˛ż niepełna. Na szczeście,
˛
biologii z pomoca˛ w rozszyfrowaniu pozostałych problemów i braków w wiedzy o ewolucji przychodza˛ inne nauki:
genetyka, archeologia, geologia, a ostatnio nawet informatyka.
Podstawa˛ teorii ewolucji jest zasada doboru naturalnego zaproponowana przez
Darwina [3]. Powoduje ona zmiany w genomie osobników, zmierzajace
˛ do zwiek˛
szenia przystosowania całej populacji danego stworzenia. Nowy gatunek powstaje
w momencie, gdy pewna grupa osobników oddziela sie˛ od swoich kuzynów na tyle,
że nie sa˛ w stanie sie˛ już krzyżować. Niestety, proces taki trwa zazwyczaj tysiace,
˛
a nawet miliony lat, i o ile jesteśmy w stanie zaobserwować efekty działania zasady
doboru naturalnego, to powstawanie gatunków jest procesem zbyt długotrwałym.
Tutaj z pomoca˛ przychodzi informatyka, a szczególnie symulacje komputerowe.
Współpraca biologii i informatyki nie jest jednak jednostronna. Wiekszość
˛
nauk
inspirowanych jest natura,
˛ nie omineło
˛ to wiec
˛ nawet tak sztucznych tworów, jakimi sa˛ komputery. Badacze zaczeli
˛ słusznie zauważać, że skoro ewolucja potrafi
z prostych czastek
˛
stworzyć tak skomplikowane stworzenie jak człowiek, to zapewne może pomóc w rozwiazywaniu
˛
rozbudowanych problemów algorytmicznych.
Z tego podejścia wywiodła sie˛ cała dziedzina, jaka˛ sa˛ algorytmy ewolucyjne. Mimo,
że poszukujac
˛ lepszej wydajności odchodzi sie˛ w nich powoli od inspiracji z natury,
to do dzisiaj obowiazuj
˛ a˛ w nich pojecia
˛
takie jak genom, fenotyp lub krzyżowanie,
znane raczej z biologii niż informatyki [2].
Problemem, który wydaje sie˛ szczególnie nadawać do rozwiazywania
˛
za pomoca˛
algorytmów ewolucyjnych jest modelowanie. Roboty, tak jak żywe stworzenia, składaja˛ sie˛ z prostych elementów, tworzacych
˛
wieksz
˛
a˛ całość. Mimo, że stopień skomplikowania nawet najbardziej złożonych robotów nie jest wcia˛ż porównywalny do
najprostszych form życia, projektanci napotykaja˛ problemy wynikajace
˛ z niemożności opanowania umysłem całej koncepcji przez jedna˛ osobe.
˛ Organizmy żywe
ewoluuja˛ poprzez da˛żenie do coraz lepszych form, tym samym samomodyfikuja˛ sie.
˛
1. Wprowadzenie
2
Brak konieczności sprawowania nadzoru nad tym procesem zacheca
˛ do prób wykorzystywania algorytmów ewolucyjnych również w dziedzinie modelowania, i sa˛ one
podejmowane z coraz wie˛ kszymi sukcesami.
Tematyka˛ ewolucji interesowałem sie˛ jeszcze przed pójściem na studia, toteż
naturalnym krokiem było dla mnie wybranie tematu z nia˛ zwiazanego.
˛
Pierwsze
środowisko, w którym można było obserwować działanie zasady doboru naturalnego stworzyłem jeszcze w liceum. Był to bardzo prosty system, pokazujacy
˛ kropki
na ekranie i modyfikujacy
˛ jedynie kilka współczynników dla każdego gatunku, jednakże, przy użyciu wyobraźni można było zobaczyć bezlitosna˛ walke˛ o przetrwanie. Poczatkowo
˛
działał jak gra w życie, lecz, chcac
˛ obserwować nowe zachowania,
rozbudowywałem go o dodatkowe funkcjonalności. W trakcie studiów informatycznych znacznie rozwinałem
˛
swoje umiejetności
˛
z zakresu inżynierii oprogramowania
co pozwoliło na stworzenie znacznie bardziej zaawansowanego systemu.
Zainspirowany historia˛ zmian w budowie stworzeń zamieszkujacych
˛
ziemie,
˛ postanowiłem zasymulować organizmy sie˛ różniace
˛ cechami fizycznymi, majacymi
˛
realny wpływ na ich przystosowanie. Wiele koncepcji obserwowanych w organizmach
ze świata rzeczywistego, takich jak symetria i minimalizm, powinno wystepować
˛
również w symulacji przy doborze odpowiednich założeń. W mojej pracy postanowiłem również zawrzeć możliwość ewoluowania zachowania osobników, dzieki
˛
czemu system powinien pozwalać na powstawanie zupełnie nowych wzorców i typów jednostek. Na rysunku 1.1 przedstawiono artystyczne wyobrażenie kolejnych
etapów ewolucji człowieka.
Rysunek 1.1. M. Garde. Schemat ewolucji człowieka
Oprócz obserwowania efektów ewolucji osobników, celem pracy było stworzenie środowiska, które pomagałoby mi w późniejszych eksperymentach nad algorytmami genetycznymi i modelowaniem wirtualnych istot. Planowany system mógłbym, przy odpowiedniej rozbudowie, wykorzystać do badań prowadzonych na studiach magisterskich, dlatego istotne było jego zaprojektowanie tak, aby dało sie˛
go rozbudowywać o dodatkowe funkcjonalności. Ważnym aspektem było również
stworzenie odpowiedniej dokumentacji biblioteki, aby inne osoby, chcace
˛ ewentualnie skorzystać z mojego systemu, były w stanie sie˛ w nim orientować. Niniejsza
1. Wprowadzenie
3
praca opisuje wykonany program, w sposób chronologiczny traktujac
˛ najpierw o
wiedzy, jaka˛ musiałem zdobyć do utworzenia tego systemu, przez projekt i implementacje˛ , aż po przeprowadzone eksperymenty. Jest ona podstawowym dokumentem, z którego powinny skorzystać osoby chcace
˛ użyć napisanej przeze mnie
biblioteki.
2. Przeglad
˛ wiedzy
Symulowanie doboru naturalnego w wirtualnym środowisku zainspirowane jest
natura,
˛ jednakże wymaga sporej wiedzy z zakresu algorytmiki, robotyki oraz symulacji. Rozdział ten poświeciłem
˛
przegladowi
˛
wiedzy potrzebnej do wykonania
projektu oraz przeprowadzenia eksperymentów. Przeprowadziłem również próbe˛
przedstawienia różnych podejść do rozwiazywania
˛
problemów tej klasy, aby upewnić sie˛ , że wybrałem właściwe podejście. Ponadto, zawarłem w nim wyjaśnienia
poj˛eć naukowych użytych w tej pracy. Zaczałem
˛
od informacji na temat doboru
naturalnego, gdyż stanowi od sedno mojej pracy. Nastepnie
˛
poruszyłem tematyke˛
projektowania wirtualnego świata, który, odwzorowujac
˛ rzeczywistość, jest moim
zdaniem najważniejszym elementem tej pracy. Na koniec umieściłem przeglad
˛ wiedzy o algorytmach ewolucyjnych, które bed
˛ a˛ sterowały programem.
2.1. Darwinowska zasada doboru naturalnego
Zasada doboru naturalnego leży u podstaw teorii ewolucji, czyli nauki o pochodzeniu gatunków. Została zaproponowana przez Karola Darwina w roku 1859
w przełomowym dziele ”O powstawaniu gatunków” [3], zawierajacym
˛
spostrzeżenia
i dowody zebrane przez badacza w czasie jego podróży morskich. Dobór naturalny
polega na zmianach w populacji, które zwiekszaj
˛
a˛ jej przecietne
˛
przystosowanie, w
efekcie da˛żac
˛ do powstawania nowych gatunków. Modyfikacje moga˛ być rozmaite,
poczawszy
˛
od lepszej odporności na warunki atmosferyczne, poprzez sprawniejsze
unikanie wrogich organizmów, aż do efektywniejszego szukania partnerów do rozmnażania. Zasadzie doboru naturalnego podlegaja˛ wszystkie stworzenia, zarówno
zwierze˛ ta jak i rośliny.
Teoria ta, pomimo utrudnień w prowadzeniu eksperymentów spowodowanych
wolnym tempem przemian, doczekała sie˛ dowodów praktycznych. Jednym z pierwszych poważnych badań była obserwacja ćmy z gatunku krepak
˛
nabrzozak na
terenach industrialnych przeprowadzona przez brytyjskiego naukowca Bernarda
Kettlewella. Eksperyment ten wprowadził pojecie
˛
melanizmu przemysłowego, czyli
przybieranie przez osobniki ciemniejszych barw, w celu lepszego maskowania sie˛
na terenach o wysokim poziomie industrializacji [4]. Skażenie powietrza powodowało wymieranie porostów nadajacych
˛
jaśniejszy kolor drzewom na których rosły,
i w efekcie wie˛ ksza˛ umieralność jaśniejszych osobników tej ćmy. Dobór naturalny
2.2. Gra w życie
5
spowodował, że ciemniejsze owady, majac
˛ wieksze
˛
szanse na ukrycie przed drapieżnikami, wyparły na terenie przemysłowej Anglii jaśniejsze odmiany tego gatunku.
Obecnie, w skutek zwie˛ kszonego nacisku na ochrone˛ środowiska i deindustrializacj˛e, notuje sie˛ odwrotny trend. Obie odmiany zaprezentowano na rysunku 2.1
Rysunek 2.1. Krepak
˛
nabrzozak - ciemna i jasna odmiana
Eksperymenty na ćmie gatunku krepak
˛
nabrzozak udowodniły, że organizmy
potrafia˛ zmieniać gen odpowiedzialny za kolor w przeciagu
˛
kilku lat, jeśli jest to
uzasadnione przez dobór naturalny. Należy pamietać,
˛
że długość życia ćmy, wliczajac
˛ okres larwalny, może wynosić jedynie kilka miesiecy,
˛
czyli znacznie krócej
niż wie˛ kszość ssaków. Stworzeniami o jeszcze krótszym życiu sa˛ bakterie, które
przez to stanowia˛ dobry obiekt do badań nad doborem naturalnym. W fabrycznych
ściekach zaobserwowano tworzenie zupełnie nowego genu przez bakterie z rodzaju
Flavobacter i Pseudomonas, dzieki
˛ któremu nauczyły sie˛ one tworzyć enzym rozkładajacy
˛ nylon, zwiazek
˛
nie wystepuje
˛
w naturze [10]. Choć mechanizmy ewolucji sa˛
dobrze opisane i potwierdzone doświadczalnie, niestety, zaobserwowanie powstawania nowego gatunku, jest, ze wzgledu
˛
na długotrwałość tego procesu, niemożliwe do zaobserwowania w naturze. Dzieki
˛ rozwojowi takich nauk jak archeologia
czy genetyka można jednak prześledzić proces ewolucji dla niektórych gatunków,
szczególnie tych, które dobrze zachowuja˛ sie˛ w warstwach geologicznych.
Zasada doboru naturalnego nierozłacznie
˛
wia˛że sie˛ z środowiskiem naturalnym.
Dla odmiany, hodowla psów rasowych, jako sterowana przez arbitralne kryteria
wybierane przez człowieka, jest definiowana jako dobór sztuczny. Symulowanie
doboru naturalnego wymaga stworzenia środowiska udajacego
˛
prawdziwy świat,
co jest niemożliwe ze wzgle˛ du na stopień złożoności przekraczajacy
˛
możliwości
dzisiejszych komputerów. Należy wiec
˛ tak długo upraszczać model aż bedzie
˛
to
możliwe lub wyodre˛ bnić pożadane
˛
kryteria, nie rozpatrujac
˛ pozostałych dziedzin,
tworzac
˛ jednocześnie dobór sztuczny. Zasady i sposoby przeprowadzania symulacji
opisałem w naste˛ pnych podrozdziałach.
2.2. Gra w życie
Wymieniona we wste˛ pie gra w życie jest jednym z pierwszych terminów które
przychodza˛ na myśl gdy łaczy
˛
sie˛ biologie˛ z informatyka.
˛ Pojecie
˛
to wymyślił John
2.3. Symulacje w nauce
6
Horton Conway w latach sześćdziesiatych
˛
i poczatkowo
˛
oznaczało symulowanie populacji bakterii na kwadratowej planszy według konkretnych reguł [6]. Zasady były
bardzo proste, mianowicie polegaja˛ one na zliczaniu liczby sasiadów
˛
dla każdego
osobnika. Gdy bakteria ma mniej niż dwóch sasiadów
˛
umiera z samotności, gdy
jest ich czterech lub wie˛ cej nastepuje
˛
zgon z "przeludnienia". Gdy pole bez żadnego
osobnika ma dokładnie trzech towarzyszy, na nim również ożywa bakteria. Na
rysunku 2.2 zaprezentowano dwie stabilne kombinacje.
Rysunek 2.2. Stabilne konfiguracje bakterii w grze w życie
Gra w życie pokazała, jak z bardzo prostych reguł moga˛ tworzyć sie˛ skomplikowane wzory i układy, również takie, które bardzo cie˛ żko jest zaprojektować recznie.
˛
Taka sama zasada leży u podstaw teorii ewolucji i doboru naturalnego. Jest to
szczególnie widoczne w symulacjach komputerowych, gdzie zbiór zasad panujacych
˛
w wirtualnym świecie, choć zazwyczaj znacznie bardziej skomplikowany niż dla
standardowej gry w życie, wcia˛ż jest znacznie prostszy niż osiagane
˛
dzieki
˛ niemu
efekty.
2.3. Symulacje w nauce
Symulacja jest ważnym narzedziem
˛
w nauce, szczególnie rozwinietym
˛
dzieki
˛
stosowaniu komputerów i algorytmiki. Polega ona na imitowaniu procesów zachodzacych
˛
w rzeczywistym świecie lub modelu teoretycznym tak, aby można było
obserwować ich zmiany w czasie. Podstawa˛ każdej symulacji jest przechowywanie
stanu obiektów i obliczanie ich oddziaływań miedzy
˛
soba˛ zgodnie z przyjetymi
˛
założeniami. Wie˛ kszość obecnie rozwijanych nauk korzysta z symulacji, poczawszy
˛
od
fizyki i astronomii, aż po biologie˛ i socjologie.
˛
Istotna˛ cze˛ ścia˛ dobrze przeprowadzonej symulacji jest poprawne przełożenie symulowanego układu na model matematyczny. W przypadku symulowania wyimaginowanego modelu matematycznego jest to zazwyczaj możliwe, a jedyna˛ przeszkoda˛
może być wydajność komputerów i użytych algorytmów. Niestety, podczas symulowania procesów zachodzacych
˛
w rzeczywistym świecie nie jest to możliwe, gdyż nie
2.4. Model fizyczny środowiska
7
sa˛ znane wszystkie zasady fizyki panujace
˛ we wszechświecie. Kolejnym problemem
jest złożoność obliczeniowa, która wielokrotnie przekracza możliwości dzisiejszych
jednostek obliczeniowych. Z tego powodu, przy symulowaniu świata rzeczywistego
lub jego wycinka zawsze stosowany jest pewien model upraszczajacy.
˛
Przykładem
może być pominie˛ cie niektórych oddziaływań fizycznych, takich jak elektryczności,
grawitacji, siły Coriolisa oraz ograniczanie złożoności świata, takie jak przyjecie,
˛
że
najmniejsza˛ jednostka˛ na jaka˛ można podzielić materie˛ jest milimetr sześcienny.
Czasami uzasadnione jest przełożenie na mniejsza˛ liczbe˛ wymiarów, co skutkuje
znacznym zmniejszeniem skomplikowania modelu.
Według przedmiotu modele matematyczne cechuja˛ sie˛ trzema właściwościami [6].
Pierwsza z nich, jednoznaczność, wystepuje
˛
gdy dla danego zbioru
danych wejściowych uzyskuje sie˛ zawsze ta˛ sama˛ odpowiedź. Poprawny program
komputerowy, który nie używa funkcji losowych, powinien z definicji zachowywać
t˛e ceche˛ . Niestety, cze˛ ste błedy,
˛
w rodzaju wyścigów krytycznych lub niezdefiniowanego zachowania, nieprzewidzianego przez kompilator, sprawiaja,
˛ że dla tych
samych danych można otrzymywać różne wyniki. Druga˛ cecha˛ jest spójność, która
oznacza, że elementy modelu nie zaprzeczaja˛ sobie nawzajem. Ostatnia˛ właściwościa˛ jest stabilność, która jest zachowana gdy drobne zmiany w modelu powoduja˛
niewielkie zmiany w stanie końcowym. Jest to szczególnie istotne przy symulowaniu wykorzystywanym przez algorytmy heurystyczne. Niestety, czesto
˛
jest to trudne
do osiagni
˛ e˛ cia przez tzw. efekt motyla, czyli kumulujace
˛ sie˛ efekty, wywołane mała˛
zmiana˛ w stanie poczatkowym.
˛
2.4. Model fizyczny środowiska
Istotna˛ cze˛ ścia˛ projektowanego systemu jest model fizyczny, niezbedny
˛
do symulacji życia osobników. W przypadku doboru naturalnego środowisko jest jedynym czynnikiem majacym
˛
wpływ na efekty ewolucji, jednakże w przypadku symulacji komputerowej, z wyjaśnionych w poprzednim podrozdziale przyczyn należy
użyć uproszczonego modelu, co ma ogromny wpływ na osiagni
˛ ete
˛ wyniki. W tej
cz˛eści opisałem różne podejścia do wyboru modelu oraz uzasadniłem podjet
˛ a˛ przez
siebie decyzje˛ .
Podczas projektowania modelu fizycznego należy podjać
˛ wiele decyzji, majacych
˛
wpływ na wzajemnie wykluczajace
˛ sie˛ czynniki. Główna˛ osia˛ konfliktu jest dokładność odwzorowania środowiska naturalnego, a wydajność symulacji. Zbyt dużo
detali powoduje wzrost na zapotrzebowanie obliczeniowe, co może znacznie zwiek˛
szyć koszta projektu, a nawet go uniemożliwić. Należy wiec,
˛ przy tworzeniu modelu,
przykładać duża˛ uwage˛ do złożoności czasowej, przewidujac,
˛ jaka˛ cena˛ należy zapłacić za dokładniejsze odwzorowanie.
2.4. Model fizyczny środowiska
8
Przy szacowaniu zapotrzebowania algorytmu na zasoby zaczyna sie˛ od ustalenia
klasy złożoności. Terminem tym określa sie˛ zbiór problemów o podobnej złożoności
obliczeniowej. Według Christos’a H. Papadimitriou klase˛ złożoności cechuje kilka
parametrów. Pierwszym z nich jest bazowy model obliczeniowy, za który zazwyczaj
przyjmuje sie˛ maszyne˛ Turinga. Kolejnym parametrem jest tryb obliczeń, dwoma
najcze˛ ściej spotykanymi jest deterministyczny i niedeterministyczny, stanowia˛ one
o sposobie podejmowania decyzji przez model. Ostatnia˛ cecha˛ klasy złożoności jest
ograniczenie, czyli funkcja określajaca
˛ maksymalne zużycie zasobów dla podanego
wejścia. Przy projektowaniu modelu najlepiej jest zapewnić, żeby problem należał
do klasy wielomianowej, żeby uniknać
˛ wykładniczego wzrostu potrzebnych zasobów [11].
Przy symulacjach ewolucyjnych, inspirowanych natura,
˛ naukowcy stosuja˛
różne podejścia. Jednym z najbardziej zaawansowanych systemów jest projekt
Golem [8]. Jest to system ewolucyjnego tworzenia robotów, zrealizowany przez
profesorów z uniwersytetu Brandeis, Hod’a Lipson’a i Jordan’a B. Pollack’a. Projekt ten za pomoca˛ algorytmu ewolucyjnego projektuje proste roboty, a nast˛epnie
z użyciem drukarki 3d uruchamia je w rzeczywistym świecie. Model fizyczny zasugerowany w tym eksperymencie składa sie˛ z trójwymiarowego świata, w którym
osobniki stworzone z prostych kształtów geometrycznych poruszaja˛ sie,
˛ da˛żac
˛ do
pokonania jak najwie˛ kszej odległości w określonym czasie, co jest funkcja˛ celu w
algorytmie ewolucyjnym. Ponieważ dla każdej jednostki jest tworzony osobny świat,
w którym naste˛ puje symulacja, osobniki nie oddziałuja˛ miedzy
˛
soba.
˛ Jednostki
podlegaja˛ prawu grawitacji i napedzane
˛
sa˛ silnikami posuwowymi. Każdy osobnik
jest sterowany za pomoca˛ sieci neuronowej, która również podlega ewolucji.
Podejściem wprost przeciwnym do projektu Golem jest gra w ewolucje˛ [7] autorstwa Heather’a Larkin’a, zaprezentowana na rysunku 2.3. Najważniejsza˛ cecha˛ jest
dwuwymiarowy świat, na którym osobniki konkuruja˛ ze soba˛ o pożywienie. Nie ma
tutaj standardowego algorytmu ewolucyjnego, który decydowałby, która jednostka
może sie˛ rozmnożyć, osobniki rozmnażaja˛ sie˛ same, jeśli maja˛ wystarczajaco
˛ pożywienia. Świat jest ograniczony ścianami i panuja˛ w nim proste prawa fizyki,
takie jak tarcie i inercja. Model ten charakteryzuje sie˛ również prostym, stałym
skryptem zarzadzaj
˛
acym
˛
osobnikami, który steruje napedem
˛
i pozwala na poszukiwanie pożywienia. Przyje˛ te jest także, że zasieg
˛ wzroku jednostek jest niczym nie
ograniczony, a osobniki nie moga˛ ze soba˛ kolidować.
Aby dokonać dobrego wyboru modelu należy podjać
˛ wiele decyzji, majacych
˛
decydujacy
˛ wpływ na powodzenie projektu. Najbardziej podstawowe to liczba wymiarów wirtualnego świata oraz wybór, które z rzeczywistych praw fizyki w nim
wyst˛epuja˛ lub na ile poprawnie sa˛ odwzorowane. Czasami do powodzenia symulacji wystarczy, że świat jest zamieszkiwany przez maksymalnie jednego osobnika,
co zwalnia projektanta z konieczności przewidzenia zasobów na interakcje miedzy
˛
2.4. Model fizyczny środowiska
9
Rysunek 2.3. Heather Larkin. Gra w ewolucje˛
jednostkami. W przeciwnym razie należy dodatkowo zaprojektować system kolizji.
W przypadku symulacji doboru naturalnego pojawiaja˛ sie˛ dodatkowe kwestie, takie
jak sposób prokreacji oraz zmiany wygladu
˛
i zachowania na przestrzeni pokoleń.
Przy odpowiedzi na każde z tych pytań należy pamietać,
˛
że im lepiej przyjety
˛
model odwzorowuje środowisko naturalne, tym bardziej kosztowna obliczeniowo
b˛edzie symulacja. Po rozpatrzeniu wszystkich możliwości zdecydowałem, że w projektowanym przeze mnie systemie świat bedzie
˛
odwzorowany w dwuwymiarowy
kartezjański układ współrze˛ dnych. Jest to najbardziej naturalne dla człowieka
przełożenie otaczajacego
˛
go świata na zależności matematyczne1 . Osobniki bed
˛ a˛
przedstawione na planie jako bryły sztywne, majace
˛ przyporzadkowane
˛
wartości
położenia i szybkości, zarówno w ruchu liniowym, jak i obrotowym. Zmiana szybkości jednostek powodowana jest siłami tarcia, oporu powietrza oraz działaniami
własnymi jednostek. Aby obserwować zmiany w wygladzie
˛
jednostek wymagany jest
model pozwalajacy
˛ nie tylko na modelowanie różnorodnych kształtów, ale również
na interakcje osobników z otoczeniem zależne właśnie od jego kształtu. Jednostki
nie moga˛ być wie˛ c traktowane punktowo, lecz jako bryły sztywne, podlegajace
˛ prawom fizycznym.
Bryła sztywna jest to poje˛ cie używane w fizyce i mechanice, określajace
˛ brył˛e,
która nie może podlegać odkształceniom. Koncepcyjnie, jest to etap pośredni w abstrakcji mie˛ dzy punktem materialnym a obiektem ze świata rzeczywistego. Istotna˛
cecha˛ bryły sztywnej jest możliwość obrotu, wywołana niezerowym momentem siły.
W ogólnym przypadku bryła sztywna posiada sześć stopni swobody, jednakże, w
szczególnym przypadku figur płaskich w dwuwymiarowym układzie współrzednym
˛
1
Z wyjatkiem
˛
trójwymiarowego układu kartezjańskiego, ale ten nie jest brany pod uwage˛ ze
wzgledu
˛
na znaczny wzrost złożoności obliczeniowej
10
2.5. Algorytmy ewolucyjne
liczba stopni swobody jest ograniczona do trzech. Bryłe˛ sztywna˛ pokazałem na rysunku 2.4. Przyłożenie niezerowej siły powoduje ruch liniowy (FX , FY ), a niezerowy
moment siły wprawia ciało w rotacje˛ . Ponieważ dowolna liczba sił działajacych
˛
na
osobnika może być za pomoca˛ zasady superpozycji zamieniona na siłe˛ przyłożona˛
do środka oraz siłe˛ przechodzac
˛ a˛ przez środek masy, w każdej chwili może zmienić
si˛e szybkość liniowa lub katowa.
˛
Rysunek 2.4. Bryła sztywna
Obecnie istnieje kilka gotowych bibliotek, które pozwalaja˛ na symulacje˛ kształtu
jednostek i ich oddziaływań ze środowiskiem. Jednym z najbardziej znanych rozwiaza
˛ ń jest Box2D [1]. Jest to wolne oprogramowanie służace
˛ do symulacji zachowań brył sztywnych na potrzeby gier. Oprócz prostych kształtów, jakie można w
nim dodawać, oferuje on dodatkowe funkcje, takie jak sztywne i luźne połaczenia
˛
i elementy ruchome. Biblioteka ta udostepnia
˛
model fizyczny, który uwzglednia
˛
sił˛e tarcia, spre˛ żystość oraz algorytm kolizji, oferujac
˛ przy tym wyskalowanie do
jednostek SI. Nie zdecydowałem sie˛ na użycie tego silnika z dwóch powodów. Po
pierwsze brakuje w nim siły oporu powietrza, która może mieć duży wpływ na
wydajność ruchu osobników i tym samym na jego kształt. Drugim powodem jest
brak możliwości przyjmowania pewnych założeń, które przyśpieszały by działanie
symulacji, co jest istotne przy długotrwałych eksperymentach.
2.5. Algorytmy ewolucyjne
Algorytmy ewolucyjne sa˛ cześci
˛ a˛ algorytmów heurystycznych i cele przed nimi
stawiane sa˛ generalnie takie same [2, 9]. Służa˛ one do przeszukiwania przestrzeni
alternatywnych rozwiaza
˛ ń w poszukiwaniu najlepszego z nich. Z racji inspiracji genetyka˛ i teoria˛ ewolucji używaja˛ jednak zupełnie nowej terminologii, otóż proponowane rozwiazania
˛
nazywane sa˛ osobnikami, problem nazywany jest środowiskiem,
2.5. Algorytmy ewolucyjne
11
a jakość rozwiazania
˛
przystosowaniem osobnika. Kolejnymi pojeciami
˛
sa˛ genotyp,
czyli zestaw danych potrzebnych do skonstruowania osobnika oraz fenotyp, bed
˛ acy
˛
zestawem cech kodowanym przez genotyp. Genotyp zawsze koduje jeden fenotyp,
lecz jeden fenotyp może pochodzić z różnych zestawów genów. Moga˛ również istnieć
fenotypy nie dajace
˛ sie˛ zakodowywać żadnym kodem z przestrzeni dopuszczalnych
genotypów. Gen jest podstawowym nośnikiem informacji, w naturze kodowany za
pomoca˛ łańcuchów DNA, w algorytmach moga˛ być liczby całkowite, zmiennoprzecinkowe lub binarne.
Generalna idea algorytmu ewolucyjnego zakłada populacje˛ osobników, z której
na podstawie operatorów selekcji, krzyżowania i mutacji sa˛ wyłaniani nowi potomkowie w każdym pokoleniu. Dobry dobór operatorów jest istotny aby otrzymać
odpowiedni balans mie˛ dzy eksploracja˛ a eksploatacja,
˛ czyli pomiedzy
˛
odpornościa˛
na pułapki ewolucji (ekstrema lokalne) a szybkościa˛ osiagania
˛
zbieżności przez algorytm. Każdy problem wymaga odpowiedniego doboru operatorów. Mutacja, czy
drobne, losowe zmiany w genach pomiedzy
˛
pokoleniami zazwyczaj odpowiadaja˛ za
eksploracje˛ , a krzyżowanie, czyli dziedziczenie cech obojga rodziców, wpływa na
zdolność do eksploatacji, jednakże dokładny wpływ operatorów na te współczynniki
jest zależny od implementacji.
2.5.1. Operator selekcji
Operator selekcji decyduje o tym, którzy z osobników dostanie szanse spłodzenia potomstwa. Można go zaimplementować na kilka sposobów, różniacych
˛
sie˛
mi˛edzy soba˛ właściwościami. Pierwsza˛ metoda˛ jaka˛ opisze˛ jest reprodukcja proporcjonalna. Polega ona na stworzeniu wirtualnego koła ruletki i przydzieleniu
osobnikom tym wie˛ kszych wycinków koła im lepiej sa˛ oni przystosowani. Nastep˛
nie dla każdego potomka jakiego chcemy stworzyć losujemy rodzica (lub rodziców)
ze zbioru obecnie żyjacych
˛
osobników. Metoda ta zapewnia zwiekszone
˛
szanse na
prokreacje˛ osobnikom lepiej przystosowanym, nie odbierajac
˛ całkowicie prawa do
posiadania potomstwa osobnikom gorzej przystosowanym.
Kolejna˛ implementacja˛ operatora selekcji jest reprodukcja rangowa, zwana również szrankowa.
˛ Polega ona na posortowaniu osobników wzgledem
˛
funkcji przystosowania i przydzieleniu jednostkom szansy na reprodukcje˛ tym wiekszej,
˛
im lepsza˛
pozycje˛ w rankingu posiada. Metoda ta głównie różni sie˛ tym od reprodukcji proporcjonalnej, że jeśli istnieje osobnik znacznie lepiej przystosowany od pozostałych
to nie zdominuje on kolejnych pokoleń.
Reprodukcja progowa jest modyfikacja˛ reprodukcji rangowej. Różni sie˛ od niej
˛
tym, że po posortowaniu osobników odcina sie˛ wybrana˛ ilość osobników, dajac
tym którzy pozostali ta˛ sama˛ szanse˛ na przeżycie. Metoda ta promuje najlepiej
przystosowanych osobników lecz nie różnicuje ich miedzy
˛
soba,
˛ co w niektórych
sytuacjach wpływa pozytywnie na odporność algorytmu na ekstrema lokalne.
2.5. Algorytmy ewolucyjne
12
2.5.2. Operator krzyżowania
Krzyżowanie nie jest niezbedn
˛ a˛ cześci
˛ a˛ algorytmu ewolucyjnego, jednakże odpowiednio wykorzystane potrafi przynieść dobre efekty w postaci szybszego zbliżania
si˛e do optimum. Polega ono na wymianie genów przez dwóch lub wiecej
˛
rodziców podczas tworzenia potomka. Brak tego operatora sprawia, że cała populacja
musi dojść do poszukiwanego optimum za pomoca˛ mutacji, czyli metoda˛ "małych
kroczków".
Implementacje operatorów krzyżowania, oprócz liczby rodziców bioracych
˛
udział
w prokreacji, różnia˛ sie˛ jeszcze sposobem wyznaczania genotypu potomstwa. Projektant algorytmu musi podjać
˛ decyzje,
˛ czy chce, aby krzyżowanie przypominało
znane z rzeczywistości rozcinanie i łaczenie
˛
łańcuchów, czy może losowe mieszanie. Pierwszy z tych sposobów może polegać na wyznaczeniu losowego punktu2
w genotypie i przydzieleniu potomkowi cześci
˛
z lewej stronie punktu od jednego
rodzica i prawej od drugiego, co zobrazowano na rysunku 2.5.
Rysunek 2.5. Krzyżowanie poprzez rozcinanie genotypów
Losowe mieszanie polega na przypadkowym dla każdego genu wyborze, z którego
rodzica ma być brany. Jeżeli genotyp nie jest binarny należy również sie˛ zastanowić, czy powinniśmy wyznaczyć średnia˛ z dwóch genów, czy może wartość losowa˛
z przedziału wyznaczonego wartościami genów.
2.5.3. Operator mutacji
W każdym algorytmie ewolucyjnym powinien znaleźć sie˛ operator mutacji, gdyż
krzyżowanie nie gwarantuje eksploracji wszystkich rozwiaza
˛ ń3 . Drobne zmiany
w genotypach pozwalaja˛ w krótkim terminie na eksploatacje, czyli poszukiwanie
2
Oczywiście dla wi˛ekszej liczby rodziców należy wyznaczyć wi˛ecej punktów
Jeżeli populacja startowa jest jednorodna, samo krzyżowanie nie doprowadzi do żadnego nowego rozwiazania
˛
3
2.5. Algorytmy ewolucyjne
13
lokalnych ekstremów, jednakże skumulowane w czasie, prowadza˛ do nowych rozwiaza
˛ ń. Mutacje pozwalaja˛ na dojście do dowolnego genotypu, jednakże może być
to bardzo czasochłonne.
Operator mutacji jest zazwyczaj implementowany poprzez losowanie pewnej
liczby genów i ich przypadkowe zmodyfikowanie. Zmiana, w przypadku genotypów binarnych, polega zazwyczaj na odwróceniu wartości danego genu. Dla liczb
zmiennoprzecinkowych problem jest bardziej złożony, gdyż należy nie tylko wybrać
szerokość otoczenia, z jakiego losujemy nowy punkt, ale także rozkład prawdopodobieństwa. Najbardziej oczywisty, rozkład ciagły,
˛
nie zawsze daje odpowiednie
efekty, wie˛ c stosuje sie˛ również rozkład normalny, a także rozkład Cauchy’ego.
Ten ostatni charakteryzuje sie˛ tym, że choć faworyzuje wartości bliskie środkowi
przedziału, nie sprawia, że szansa na wylosowanie wartości odległych od środka
przedziału spada do zera, jak to jest w rozkładzie normalnym; kolokwialnie mówi
si˛e o nim, że ma ”grube ogony”.
3. Projekt systemu symulacji doboru
naturalnego
W rozdziale tym opisałem proces projektowania systemu oraz stawiane przed
nim wymagania. Przed rozpoczeciem
˛
implementacji musiałem podjać
˛ decyzje˛ o zastosowanych technologiach oraz użytych bibliotekach. Aby system mógł być używany w badaniach postanowiłem o podziale na moduły, gdyż dzieki
˛ temu łatwiej
można dostosowywać go do kolejnych eksperymentów. Nastepnie
˛
wybrałem środowisko programistyczne jakiego użyje˛ podczas wdrożenia oraz zdecydowałem o
użyciu techniki wersjonowania kodu.
3.1. Wymagania i założenia
Specyfikowanie wymagań jest poczatkowym
˛
etapem projektowania systemu.
Mimo, że ta cze˛ ść inżynierii oprogramowania wywodzi sie˛ z aplikacji biznesowych,
można a nawet powinno sie˛ ja˛ stosować również projektujac
˛ aplikacje dla celów
naukowych. Dzie˛ ki dobremu określeniu wymagań łatwiej jest opisać system na
etapie projektowania, co skutkuje uniknieciem
˛
późniejszych refaktoryzacji kodu,
gdy na etapie implementacji okaże sie,
˛ że struktura aplikacji nie jest przygotowana
na wszystkie funkcje.
Oto wymagania funkcjonalne, jakie przyjałem
˛
podczas projektowania systemu:
— system musi pozwalać na definiowanie kształtu osobników w przestrzeni dwumiarowej;
— system musi symulować wirtualny świat, w którym żyja˛ osobniki;
— środowisko musi imitować świat rzeczywisty, poprzez bezwładność, opór powietrza itp;
— osobniki musza˛ mieć kontakt z otoczeniem poprzez receptory;
— osobniki musza˛ mieć możliwość poruszania sie;
˛
— aplikacja musi mieć możliwość prezentowania kształtu osobników oraz ich działania;
— aplikacja musi mieć możliwość przechowywania efektów działania na dysku;
— system musi pozwalać na testowanie różnych algorytmów ewolucyjnych;
3.2. Zastosowane technologie
15
Oprócz wymagań funkcjonalnych zazwyczaj przyjmuje sie˛ również wymagania
niefunkcjonalne. Postanowiłem, że projektowany system musi mieć możliwość łatwego wykorzystywania w różnych eksperymentach, co m.in. oznacza możliwość
uruchamiania programu z parametrami, ale również łatwość edycji kodu. Kolejnym
wymaganiem jest przenośność. Program powinien być napisany w jezyku
˛
pozwalajacym
˛
na uruchomienie na różnych systemach operacyjnych i wiekszości
˛
platform.
Wykorzystywane technologie powinny należeć do standardów takich organizacji jak
IEEE oraz ANSI. Ostatnim wymaganiem jest szybkość działania. Jakkolwiek nie
mogłem na etapie projektowania wyznaczyć sztywnych norm czasowych, przyja˛
łem, że system musi zwrócić wyniki w czasie pozwalajacym
˛
na przeprowadzanie
eksperymentów, czyli jego złożoność musi być wielomianowa.
Wykonanie systemu w sposób spełniajacy
˛ wymagania wymaga przyjecia
˛
kliku
założeń. Bez tego złożoność obliczeniowa środowiska symulujacego
˛
byłaby zbyt
wielka, aby otrzymać wyniki w czasie rozsadnym
˛
dla badacza. Oto przyjete
˛ przeze
mnie założenia:
— osobniki składaja˛ sie˛ z kół;
— świat ma ograniczony rozmiar;
— jeżeli na świecie jest wie˛ cej osobników, to nie moga˛ ze soba˛ kolidować1 ;
— zachowanie osobników nie podlega ewolucji;
Budowa z modułów kołowych pozwala na tworzenie praktycznie dowolnych
osobników, bez konieczności implementowania operacji na zbiorach wierzchołków,
które dla bardziej skomplikowanych osobników mogłyby znacznie zwiekszyć
˛
złożoność algorytmiczna.
˛ Ponadto, dzieki
˛ przyjeciu
˛
tego założenia, mogłem wyznaczyć
przybliżone wzory na opór powietrza i moment bezwładności, co, przy dowolnych
kształtach, byłoby znacznie trudniejsze lub nawet niemożliwe.
3.2. Zastosowane technologie
Przy wyborze je˛ zyka programowania musiałem przede wszystkim rozważyć, czy
zastosowana technologia spełni założone wymagania, oraz czy istnieja˛ gotowe rozwiazania,
˛
które mógłbym wykorzystać przy pracy nad systemem. Wymaganiami,
które postawiłem przed moim systemem, a które miały najwiekszy
˛
wpływ na wybór technologii były szybkość działania i przenośność. Uniwersalnymi aspektami
majacymi
˛
wpływ na decyzje˛ były ponadto szybkość programowania, podatność na
bł˛edy oraz przejrzystość kodu, istotna dla innych osób chcacych
˛
zrozumieć kod
programu.
Pierwsza˛ decyzja,
˛ jaka˛ podjałem
˛
jest niestosowanie paradygmatu programowania obiektowego. Uzasadniłem to tym, że najważniejsze jego cechy nie były istotne
1
Silnik kolizji jest kosztowny obliczeniowo
3.3. Podział na moduły
16
w projektowanym przeze mnie systemie. Ponadto, korzyści zazwyczaj osiagane
˛
poprzez enkapsulacje˛ moga˛ łatwo stać sie˛ wadami, gdy badacz chce dla potrzeb
eksperymentu ingerować w atrybuty nie przewidziane wcześniej jako edytowalne.
Aby spełnić wymaganie szybkości działania naturalnym wyborem było stosowanie
j˛ezyka kompilowanego, tworzacego
˛
kod maszynowy, najlepiej z recznym
˛
zarzadza˛
niem pamie˛ cia,
˛ tj bez odśmiecacza (garbage collector).
Ostatecznie wybrałem je˛ zyk C w standardzie C89 [5]. Jest jednym z najbardziej
przenośnych je˛ zyków programowania, co pozwoli na bezproblemowe używanie projektowanego systemu na zdecydowanej wiekszości
˛
systemów operacyjnych. Jezyk
˛
ten ponadto zapewnia duża˛ szybkość działania, co jest niezbedne
˛
podczas kosztownych obliczeń wykonywanych w symulacji. C jest stosunkowo starym narzedziem,
˛
o
ugruntowanej pozycji wśród programistów. Jezyk
˛
ten przez jakiś czas był używany
do wie˛ kszości tworzonych na świecie programów, łacznie
˛
z aplikacjami interaktywnymi oraz grami, później wyparty przez jezyki
˛
paradygmatu obiektowego oraz
wysokopoziomowe. C dalej jest używany do pisania aplikacji systemów wbudowanych, sterowników oraz programów wymagajacych
˛
dużej wydajności i symulacji.
Ponadto, jest zazwyczaj wspierany na systemach zarzadzaj
˛
acych
˛
superkomputerami, co w przypadku wysokopoziomowych jezyków
˛
nie zawsze jest możliwe. Dzieki
˛
jego powszechności doste˛ pnych jest sporo dodatkowych bibliotek, co, choć nie było
niezbe˛ dne w moim projekcie, może być pomocne w wypadku rozbudowywania systemu o dalsze funkcje.
W celu wyświetlania efektów pracy systemu na ekranie użytkownika w postaci
graficznej wybrałem biblioteke˛ FreeGlut. Jest to oprogramowanie o otwartym kodzie, kompatybilne ze standardem GLUT, czyli korzystajace
˛ z silnika OpenGL [12].
GLUT, skrót od OpenGL Utility Toolkit, czyli zestaw narzedzi
˛
użytkowych OpenGL,
jest wieloplatformowym rozwiazaniem
˛
do wyświetlania grafiki 2d oraz 3d. Pomimo
dość dobrej przenośności programów napisanych w FreeGlut, postanowiłem odseparować cze˛ ść wyświetlajac
˛ a˛ od cześci
˛
wykonujacej
˛
algorytmy ewolucyjne, aby inni
użytkownicy mogli, w razie potrzeby, zaimplementować własny program do wyświetlania wyewoluowanych osobników. Było to tym istotniejsze, że FreeGlut nie jest
najwygodniejszym obecnie znanym narzedziem
˛
do rysowania na ekranie, jednakże
jego przenośność oraz prostota były dominujacymi
˛
czynnikami w projektowanym
przeze mnie systemie, gdyż nie chciałem wprowadzać kolejnej warstwy abstrakcji w programie, którego głównym zadaniem nie jest grafika, lecz dobór naturalny
i algorytmy ewolucyjne.
3.3. Podział na moduły
W celu ułatwienia projektowania systemu oraz zwiekszenia
˛
szansy na ponowne
użycie kodu postanowiłem zastosować podział na moduły. W podrozdziale tym
17
3.3. Podział na moduły
opisałem trzy cze˛ ści składowe systemu wydzielone tak, aby badacz próbujacy
˛ dostosować kod do własnych potrzeb mógł bez trudu wprowadzać nowe funkcje lub
nawet zaste˛ pować moduły swoimi. Zdecydowałem, że ważne jest, aby cześć
˛ zajmujaca
˛ sie˛ ewolucja˛ była programem wsadowym, aby można było używać go w konsoli
tekstowej lub poprzez ssh. Funkcjonalność prezentowania, oczywiście, wymagała
użycia środowiska graficznego, pozwalajacego
˛
na swobodne rysowanie po ekranie.
Aby nie powielać kodu postanowiłem stworzyć biblioteke,
˛ która zapewniałaby środowisko symulacyjne, wykorzystywane zarówno przez algorytm ewolucyjny, jak i
program do wyświetlania wyników. Rysunek 3.1 obrazuje podział na moduły projektowanego systemu.
Rysunek 3.1. Podział na moduły
3.3.1. Środowisko symulacyjne
Pierwszym modułem, który zaprojektowałem była biblioteka środowiska symulacyjnego, w kodzie nazywana jako Simulation. Jej zadaniem było umożliwienie
tworzenia wirtualnego świata oraz dodawania do niego osobników. Biblioteka miała
umożliwiać tworzenie wielu światów, oddzielonych od siebie, aby można było zaimplementować choć cze˛ ściowa˛ współbieżność w algorytmie ewolucyjnym. Ponadto
miała ona zapewniać programowi prezentujacemu
˛
możliwość pobierania danych o
kształcie, budowie i obecnym położeniu osobników. Postanowiłem w niej również
zawrzeć definicje˛ genomu oraz metod potrzebnych do jego użycia, takich jak mutacja i krzyżowanie.
3.3. Podział na moduły
18
Oto funkcje, które miała udostepniać
˛
biblioteka Simulation:
— tworzenie i usuwanie świata;
— dodawanie i usuwanie osobników;
— wykonanie kroku symulacji;
— podgladanie
˛
sytuacji w danym świecie;
— operacje na genomach
Simulation zostało tak zaprojektowane, aby interfejs, udostepniaj
˛
acy
˛ te funkcje
był przejrzysty w użyciu, ale nie wykluczał dostepu
˛
do szczegółowych danych.
Podgladanie
˛
sytuacji w wirtualnym świecie oznacza tutaj zarówno komunikacje˛ z
opisanym poniżej modułem prezentujacym,
˛
jak i możliwość odwołania do dowolnej
zmiennej przez programiste˛ .
3.3.2. Program ewoluujacy
˛
Modułem systemu odpowiedzialnym za uruchamianie algorytmu był program
ewoluujacy,
˛
nazywany również Evolution. Jego zadaniem było inicjowanie i sterowanie procesem ewolucji poprzez korzystanie z odpowiednich metod biblioteki.
Postanowiłem zaprojektować go jako program wsadowy, sterowany za pomoca˛ konsoli, zapisujacy
˛ wyniki swojej pracy w podanym pliku, który potem może być zarchiwizowany, przesłany lub otwarty przez program prezentujacy.
˛
Nie zdecydowałem
si˛e na stworzenie środowiska graficznego, gdyż działanie tego modułu przewidywane było jako długotrwałe i pracochłonne, nie wymagajace
˛ żadnej interakcji z
użytkownikiem. Program ewolucyjny miał być w istocie implementacja˛ algorytmu
ewolucyjnego, z możliwościa˛ wybrania parametrów z linii poleceń. Wydzieliłem ten
program jako osobny moduł, gdyż badacz korzystajacy
˛ z systemu, a chcacy
˛ zaproponować nowy, własny algorytm ewolucyjny, jest zachecany
˛
do nadpisania tego
modułu, korzystajac
˛ z biblioteki symulacji.
Z racji, że ważna˛ cze˛ ścia˛ tego modułu miał być algorytm ewolucyjny, postanowiłem przyłożyć duża˛ wage˛ do jego elastyczności. Możliwość przeładowania operatorów krzyżowania i mutacji pozwoliła na elastyczniejsze dokonywanie eksperymentów. Aby ułatwić wielokrotne uruchamianie za pomoca˛ zautomatyzowanych skryptów, postanowiłem zapewnić możliwość uruchamiania programu z parametrami,
takimi jak liczba generacji, długość trwania symulacji czy współczynniki mutacji.
Program ewolucyjny przewidziałem jako główny poligon dla przeprowadzanych
badań. Wie˛ kszość eksperymentów można przeprowadzić edytujac
˛ jego parametry
lub wprowadzajac
˛ nowe funkcje. Niektóre badania moga˛ wymagać zmodyfikowania
programu ewolucyjnego, dlatego istotne jest takie zaimplementowanie tego modułu,
żeby było to jak najłatwiejsze. Oprócz wspomnianej parametryzacji, ważne było,
żeby pliki wynikowe nie nadpisywały sie,
˛ gdy kilka różnych eksperymentów jest
uruchomionych naraz.
19
3.4. Osobniki
3.3.3. Program prezentujacy
˛
Programowi prezentujacemu,
˛
nazywanemu również Prezenter, wyznaczyłem zadanie pokazywania wyewoluowanych osobników, zarówno statycznie, jak i dynamiczne (w trakcie działania). Moduł ten miał również korzystać z biblioteki symulujacej,
˛
aby pokazywać funkcjonowanie istot w wirtualnym świecie, takim samym,
jak świat wykorzystywany do ewolucji. Wybrałem biblioteke˛ FreeGlut do rysowania
na ekranie za pomoca˛ OpenGL. Oczywiście, wymagana była możliwość otwierania
plików z osobnikami wygenerowanymi przez program ewolucyjny, tak, aby mógł on
służyć również do opisywania wyników badań.
Program ten, oprócz oczywistego wyświetlania osobników, miał zapewniać możliwość podgladu
˛
świata symulacji w dowolnym miejscu, pokazujac
˛ również pozostałe
elementy, takie jak pożywienie osobników. Zaprojektowałem go tak, aby pozwalał
również na proste sterowanie symulacja,
˛ wspierajac
˛ takie komendy jak pauzuj i
przyśpiesz.
3.4. Osobniki
Świat symulowany w bibliotece pozwala na dodawanie osobników, które sa˛ najważniejszym elementem projektowanego systemu. Dwoma najważniejszymi aspektami konstrukcji jednostki były budowa oraz zachowanie. Od dobrego dobrania
sposobu tworzenia osobników zależały skuteczność algorytmów ewolucyjnych oraz
możliwości późniejszej rozbudowy symulacji.
3.4.1. Budowa jednostek
Postanowiłem, że jednostki bed
˛ a˛ składały sie˛ z modułów o kształcie koła o
różnych średnicach. Osobniki musza˛ być integralne, to znaczy miedzy
˛
budujacymi
˛
je kółkami nie może być odstepu,
˛
musza˛ one na siebie nachodzić. Aby jednostki
mogły realizować zadane funkcje zapewniłem im receptory oraz silniki. Oto lista
modułów, które moga˛ wchodzić w skład budowy pojedynczych osobników:
— zwykły (bez dodatkowych funkcji)
— receptor liniowy, aktywny, gdy w linii prostej znajduje sie˛ pożywienie
— receptor kołowy, sprawdzajacy,
˛
czy jedzenie znajduje sie˛ w dowolnym kierunku
— silnik, nadajacy
˛ siłe˛ w wybranym kierunku
Detale oraz przykładowe osobniki zawarłem w rozdziale poświeconym
˛
implementacji, gdyż na etapie projektowania cechy wygladu
˛
nie były jeszcze przesadzone.
˛
Kolejnym aspektem był sposób rozmieszczenia modułów w osobniku.
Choć
pierwszym, najbardziej naturalnym pomysłem jest po prostu rozmieszczanie receptorów i silników w dowolnych miejscach, przykładowo za pomoca˛ współrzed˛
nych kartezjańskich układu wycentrowanym na środku projektowanego osobnika,
20
3.4. Osobniki
postanowiłem poszukać lepszego rozwiazania.
˛
Aby uniknać
˛ chaosu zwiazanego
˛
z mnogościa˛ kształtów osobników, z czego wiekszość
˛
byłaby fizycznie nieprawidłowa2 , zdecydowałem, że jednostki miały sie˛ składać z centralnego modułu, otoczonego pewna˛ liczba˛ receptorów i silników. Każdy z nich posiada parametr kata,
˛
jaki tworzy on z środkiem osobnika, oraz odległość od niego, czyli położenie jest
zapisane współrze˛ dnymi biegunowymi, z tym ograniczeniem, że element może być
położony jedynie tak daleko, aby ciagle
˛
zachował kontakt z modułem centralnym.
Program prezentujacy
˛ miał pokazywać moduły tak, aby użytkownik programu
mógł z samego ogladania
˛
podgladu
˛
domyśleć sie˛ działania jednostek. Jako dodatkowe ułatwienie dla użytkownika postanowiłem, że moduł ten powinien też pokazywać, które moduły sa˛ w danej chwili aktywne.
3.4.2. Zachowanie
Osobniki, aby działać, potrzebuja˛ programu sterujacego.
˛
Przy podejmowaniu
decyzji o algorytmie zarzadzaj
˛
acym
˛
jednostkami mogłem zdecydować sie˛ na mniej
lub bardziej elastyczne podejście. Poczatkowo
˛
chciałem zaproponować generyczna˛
funkcje˛ sterujac
˛ a˛ osobnikami, jednakże stwierdziłem, że negatywnie wpłynie to na
możliwości późniejszego wykorzystania algorytmu. Ostatecznie zdecydowałem sie˛
na stworzenie prostego je˛ zyka poleceń, który byłby wykonywany przez jednostki w
każdej turze symulacji. Projektowany skrypt miał być indywidualny dla każdego
osobnika oraz powinien umożliwiać wykonywanie prostych algorytmów sterowania
silnikami w zależności od informacji uzyskanych z receptorów.
Oto przykładowa sekwencja w pseudokodzie kodowana przez skrypt sterujacy
˛
zachowaniem:
1
5
procedure decydowanie {
s i l n i k [ 1 ] = true ;
silnik [2]= false ;
i f ( receptor [ 3 ] ) {
silnik [1]= false ;
s i l n i k [ 2 ] = true ;
} e l s e s i l n i k [ 4 ] = true ;
}
Wydruk 3.1. Przykładowy algorytm
Jak widać, sekwencje wykonywane przez osobniki sa˛ proste, lecz pozwalaja˛
na opisanie zasad kierujacych
˛
zachowaniem istot stworzonych z kilku modułów
w kształcie koła. Dzie˛ ki instrukcjom warunkowym jednostka może reagować na
zmiany w otoczeniu. Postanowiłem, że sekwencje sterujace
˛ nie musza˛ pozwalać na
2
dza.
˛
Osobnik jest nieprawidłowy, gdy jego moduły nie sa˛ połaczone
˛
lub za bardzo na siebie nacho-
3.4. Osobniki
21
definiowanie zmiennych innych niż binarne, gdyż nie sa˛ one niezbedne
˛
w zarza˛
dzaniu tak prostym osobnikiem. Powoduje to uproszczenie interpretatora oraz, co
ważniejsze, zmniejszenie liczby różnych instrukcji, jakie moga˛ być wykonane. Jest
to istotne w eksperymentach ewolucyjnych, w których nie tylko kształt osobników
podlega zmianom, ale również zachowanie.
4. Implementacja
Wdrożenie, pomimo tego, że opiera sie˛ na wykonanej uprzednio dokumentacji,
jest istotna˛ faza˛ każdego projektu. W moim systemie implementacja zajeła
˛ najwi˛eksza˛ cze˛ ść czasu ze wzgle˛ du na trudności z odpowiednim zaprogramowaniem
środowiska symulacyjnego.
W tym rozdziale opisałem najważniejsze struktury
dost˛epne w bibliotece oraz metody służace
˛ do operowania na nich. Przedstawiłem również budowe˛ przykładowego osobnika wraz z wyjaśnieniem jego działania.
Oprócz korzystania ze środowiska symulacyjnego umieściłem także informacje pomocne w używaniu programów do ewolucji i prezentacji wyników, co w przypadku
tego pierwszego jest szczególnie istotne, gdyż jest to narzedzie
˛
wsadowe, bez środowiska graficznego. Nie sa˛ tutaj opisane wszystkie metody z jakich można korzystać,
gdyż wszystko wyjaśniaja˛ komentarze w kodzie, a zachowana została czytelność
niniejszej pracy.
Zrealizowałem wszystkie funkcje opisane w poprzednim rozdziale zgodnie z założeniami. Pierwszym krokiem było zrobienie szkieletu biblioteki i nagłówków funkcji, naste˛ pnie stworzyłem program prezentujacy,
˛
aby można było w trakcie kodowania podgladać
˛
efekty pracy. Prezenter był przydatnym narzedziem
˛
również w testowaniu i szukaniu błe˛ dów środowiska symulacyjnego, a ponadto był niezbedny
˛
do kontrolowania wyników i dobierania odpowiednich parametrów fizycznych wirtualnego świata. Po ukończeniu biblioteki zajałem
˛
sie˛ programowaniem algorytmu
ewolucyjnego. Na koniec dopracowałem interfejsy użytkownika tak, aby osoba nie
uczestniczaca
˛
bezpośrednio w tworzeniu projektu mogła, po przeczytaniu dokumentacji, korzystać ze stworzonego przeze mnie systemu.
4.1. Używane struktury
Biblioteka symulacji przechowuje dane w logicznych strukturach, których nazwy, w wie˛ kszości przypadków, pochodza˛ od bytów, które soba˛ reprezentuja.
˛ Z racji, że każda symulacja wymaga wirtualnego świata oraz żyjacych
˛
w nich osobników
na poczatku
˛
wydzieliłem struktury World oraz Unit. Podstawowym budulcem jednostek zamieszkujacych
˛
świat sa,
˛ tak jak postanowiłem na etapie projektowania,
kółka, wie˛ c wydzieliłem kolejna˛ strukture˛ on nazwie Bubble. Pożywienie którego
szukaja˛ osobniki, przechowywane jest w strukturze Food. Genom jednostek zapisany jest w GenData. Ostatnia˛ potrzebna˛ struktura˛ jest BubData, które jest
4.2. Opis i działanie wirtualnego świata
23
wykorzystywane przez Prezenter do wyświetlania stanu wirtualnego świata. Zaproponowany przeze mnie podział, wraz z zależnościami miedzy
˛
strukturami jest
przedstawiony na rysunku 4.1.
Rysunek 4.1. Zależności miedzy
˛
strukturami
Struktura BubData nie została umieszczona na diagramie, gdyż służy ona wyłacznie
˛
do komunikacji mie˛ dzy programem prezentujacym
˛
a symulacja.
˛ Nie przechowuje ona żadnych danych powiazanych
˛
z modelem świata wirtualnego.
4.2. Opis i działanie wirtualnego świata
Główna˛ funkcja˛ biblioteki symulacji jest umożliwienie tworzenia i usuwania
wirtualnego świata dla osobników podlegajacych
˛
ewolucji. W moim systemie jest
to realizowane przez metode˛ prepareWorld, która pobiera wskaźnik do struktury
World. Jako dodatkowe argumenty przyjmuje rozmiar świata oraz predefiniowane
maksima dla liczby sztuk jedzenia i jednostek mogacych
˛
naraz istnieć w danym
świecie.
1
void createWorld ( World ∗ world , const long sizeX , const long sizeY ,
const unsigned long maxFood, const unsigned long maxUnits ) ;
Wirtualny świat zawiera parametry fizyczne majace
˛ wpływ na zachowanie osobników w symulacji. Metoda prepareWorld ustawia domyślne parametry świata, jednakże osoba chcaca
˛ przystosować system do własnych wymagań może je zmienić.
Oto zaprogramowane przeze mnie parametry fizyczne wirtualnego świata:
— współczynnik tarcia liniowego;
— współczynnik tarcia obrotowego;
— współczynnik oporu powietrza w ruchu liniowym
— współczynnik oporu powietrza w ruchu obrotowym
24
4.3. Tworzenie przykładowego osobnika
Siły tarcia zarówno liniowego jak i w ruchu obrotowym zależa˛ wyłacznie
˛
od masy
osobnika. Opór powietrza, jako że zależa˛ od kształtu jednostek, sa˛ trudniejsze do
oszacowania. Dla oporu powietrza w ruchu liniowym obliczam szerokość osobnika
w kierunku, w jakim akurat sie˛ porusza. Siła oporu jest nastepnie
˛
wprost proporcjonalna do szerokości osobnika i kwadratu jego szybkości. Aby policzyć opór
powietrza ruchu obrotowego obliczam szerokość osobnika oraz jego zbalansowanie. Ten ostatni czynnik szacuje˛ na podstawie odległości środka masy od środka
geometrycznego obiektu.
Biblioteka implementujaca
˛ wirtualny świat pozwala na sterowanie postepem
˛
symulacji. Aby wykonać jeden krok kalkulacji należy wywołać metode˛ performTurn,
która przyjmuje w parametrze wskaźnik do struktury World. Po wykonaniu tury symulacji można pobrać dane opisujace
˛ sytuacje˛ w symulacji na potrzeby programu
prezentujacego.
˛
Pobieranie tych danych w trakcie, np jako skutek wielowatkowo˛
ści, może spowodować niezdefiniowane zachowanie.
1
void performTurn ( World ∗ world ) ;
4.3. Tworzenie przykładowego osobnika
Osobniki zamieszkujace
˛ wirtualny świat sa˛ ważna˛ cześci
˛ a˛ systemu ze wzgledu
˛
na to, że maja˛ podlegać ewolucji. Jednostki sa˛ autonomicznymi bytami, każda z
nich wykonuje własny algorytm sterujacy
˛ i zbudowana jest na podstawie materiału
genetycznego. Osobniki składaja˛ sie˛ z modułów o okragłym
˛
kształcie, z których
każdy może spełniać inna˛ funkcje.
˛ Dzieki
˛ silnikom jednostka może poruszać sie˛
po wirtualnym świecie, a dzieki
˛ receptorom może decydować o kierunku dalszego
ruchu. Aby dodać osobnika na podstawie genomu GenData należy wywołać metode˛
spawnFromGenData.
1
void spawnFromGenData ( World ∗ world , GenData ∗ genData ) ;
Osobnik podlega prawom fizyki zaimplementowanym w świecie wirtualnym. Co
krok symulacji wywoływany jest algorytm sterujacy
˛ oraz uruchamiane sa˛ odpowiednie moduły - silniki, które nadaja˛ ped
˛ osobnikowi. Aby przełożyć otrzymany
wektor siły na przyśpieszenie i ped
˛ należy użyć prostych przekształceń z mechaniki
brył sztywnych, które tutaj pomine.
˛ Warte wymienienia jest twierdzenie Steinera,
którego używam do obliczenia momentu bezwładności osobników.
I = I0 + md
(4.1)
Gdzie:
— I0 to moment bezwładności wzgledem
˛
osi przechodzacej
˛
przez środek masy;
— I to moment bezwładności wzgledem
˛
osi równoległej do pierwszej osi;
4.4. Algorytm ewolucyjny
25
— d to odległość mie˛ dzy osiami;
— m to masa bryły (jednego modułu osobnika)
Dzi˛eki temu obrót nadany przez niezerowy moment siły sprawia wrażenie realizmu.
Jednostki składaja˛ sie˛ z wielu modułów, co wymaga odpowiedniego zobrazowania w programie prezentujacym.
˛
Aby nie zaciemniać obrazu nadmiarem graficznych elementów, głównym sposobem oznaczania różnych modułów sa˛ kolory oraz
kształty. Przykładowy osobnik został przedstawiony na rysunku 4.2. Czerwonym
kolorem zaznaczone sa˛ silniki, żółtym czujniki. Receptor liniowy oraz silniki posiada trójkat
˛ wskazujacy
˛ kierunek jego działania. Gdy moduł jest aktywny trójkat
˛
jest wypełniony kolorem. Czujniki kołowe sa˛ pokolorowane na żółto i oznaczone
żółtym okre˛ giem w środku, który jest wypełniony jeśli receptor ”widzi” coś w swoim
zasi˛egu.
Rysunek 4.2. Wyrenderowany osobnik na domyślnym, czarnym tle
Receptory wykrywaja˛ jedzenie w zasiegu
˛
wzroku, i w zależności od tego, czy coś
widza,
˛ ustawiaja˛ swoja˛ flage˛ . Czujniki osobnika musza˛ być rozmieszczone w efektywny sposób, gdyż inne moduły wchodzace
˛ w jego skład moga˛ przysłaniać im
widok, sprawiajac,
˛ że staja˛ sie˛ one nieefektywne. Na rysunku 4.3 przedstawiłem
przykładowa˛ jednostke˛ i zasie˛ g widzenia jej czujników. Jak widać, receptor liniowy
jest całkowicie zasłonie˛ ty i nie widzi ani jednej sztuki jedzenia, jego bit jest ustawiony na fałsz. Czujnik kołowy tymczasem jest cześciowo
˛
przysłoniety
˛ przez reszta˛
modułów osobnika, nie widzac
˛ pożywienia numer 2 oraz 3, jednakże ma czyste pole
widzenia do jedzenia 1 oraz 4, wiec
˛ jego flaga jest ustawiona pozytywnie.
4.4. Algorytm ewolucyjny
Algorytm ewolucyjny zaimplementowałem w programie Evolution w sposób standardowy, z użyciem symulacji jako funkcji oceny osobników. Z racji, że system miał
zapewniać dowolność, zaprogramowałem możliwość konfiguracji liczby osobników
4.4. Algorytm ewolucyjny
26
Rysunek 4.3. Zasieg
˛ widzenia osobnika
i pokoleń. Oprócz tego wie˛ kszość parametrów operatorów również można zdefiniować za pomoca˛ argumentu linii poleceń, aby można było za pomoca˛ skryptów
uruchamiać program wielokrotnie dla różnych parametrów. Zapis genomu i jego
przełożenie na kształt osobników jest zależne od przeprowadzanych badań, jednak domyślna implementacja przechowuje wartości zmiennoprzecinkowe z zakresu
<0;1> dla położenia, rozmiaru i typu modułów. W zaimplementowanym algorytmie
użyłem trzech operatorów:
— selekcji;
— mutacji;
— krzyżowania;
W programie umieściłem domyślna˛ implementacje,
˛ osoba chcaca
˛ wykorzystać algorytm do własny potrzeb zechce zapewne zmienić ja˛ cześciowo
˛
lub nawet całkowicie.
Domyślnym operatorem selekcji jest metoda rankingowa. W moim programie
kandydaci sa˛ losowani ze zwracaniem ze zbioru wszystkich osobników, a wygrywaja˛
dwa genomy, które potem podlegaja˛ operatorom krzyżowania i mutacji. Przegrani
sa˛ zaste˛ powani potomkami zwyciezców.
˛
Liczba kandydatów stajacych
˛
w szranki
jest wybierana przez użytkownika systemu i podawana z linii poleceń przy wywołaniu programu.
Kolejnym zaimplementowanym przeze mnie operatorem jest operator mutacji.
Przy domyślnym genomie losuje on dla każdego genu nowa˛ wartość z rozkładu cia˛
głego, którego długość jest parametrem definiowanym z linii poleceń. Na potrzeby
testów napisałem również mutacje˛ z użyciem rozkładu Gaussa, która jest dostepna
˛
jako metoda mutateStandard, widoczna w pliku algorithm.h. Osoba korzystajaca
˛ z
4.5. Przechowywanie wyników algorytmu
27
systemu może oczywiście stworzyć własny operator mutacji, co tworzy sie˛ podmieniajac
˛ metode˛ mutate w strukturze Algorithm.
Operator krzyżowania ma na celu wymieszanie genów dwóch osobników. W
moim systemie działa on poprzez wylosowanie nowej wartości dla każdego genu z
przedziału wyznaczonego przez rodziców. Losowanie odbywa sie˛ z rozkładu cia˛
głego. Podobnie jak dla operatora mutacji, można stworzyć własna˛ metode.
˛
4.5. Przechowywanie wyników algorytmu
Aby móc przechowywać osobniki zaproponowane przez algorytm ewolucyjny
potrzebny jest sposób zapisu genomów do pliku. W implementowanym programie
stworzyłem metode˛ zapisujac
˛ a˛ genom do pliku, wraz z danymi pomocniczymi,
takimi jak godzina wygenerowania, numer generacji i wartość przystosowania.
1
void writeGenToFile ( FILE ∗ f i l e , GenData ∗ genDatas ,
double result , int generation )
Wywołanie tej metody spowoduje napisanie do podanego w parametrze pliku
bloku tekstu według stałej reguły. Pierwsza˛ linijka˛ jest data, potem numer generacji i rezultat. Kolejna˛ informacja˛ jest liczba modułów, które wchodza˛ w skład
osobnika. W kolejnych linijkach, dla każdego modułu umieszczone sa˛ dane dotyczace
˛ kolejnych elementów, rozdzielone przecinkami: kat
˛ i promień, czyli położenie
modułu wzgle˛ dem środka jednostki, wyrażone w układzie biegunowym, nastepnie
˛
rozmiar elementu, jego typ oraz kat
˛ obrotu. Listing 4.5 demonstruje zapis przykładowego osobnika, a rysunek 4.4 przedstawia jego wyglad.
˛
Jak widać, każdy
gen jest zapisywany z dokładnościa˛ do czwartej cyfry po przecinku, co jest uzasadnione tym, że wie˛ ksza dokładność nie jest niezbedna
˛
do poprawnego wyświetlenia
osobnika na ekranie, a mogłaby utrudnić reczne
˛
przegladanie
˛
plików z wynikami.
1
5
2013−08−21.17:21:15
generation : 16
r e s u l t : 624.00
4
0.0000 ,0.3333 ,0.2597 ,0.7500 ,0.0000
0.5000 ,0.6746 ,0.7729 ,0.2500 ,0.0000
0.7778 ,0.5368 ,0.5042 ,0.5000 ,0.0000
0.1222 ,0.4940 ,0.7248 ,0.0000 ,0.0000
Odczytem danych z pliku zajmuje sie˛ metoda readGenDataFromFile. Pomija ona
dane pomocnicze zapisane w pliku i wczytuje genomy do tablicy. W przypadku napotkania nieoczekiwanego znaku zaprzestaje pracy, zwracajac
˛ dotychczas wczytane
dane.
1
int readGenDataFromFile ( GenData ∗ genData , int max, char ∗ fileName ) ;
4.6. Prezentowanie wyników
28
Rysunek 4.4. Osobnik generowany z pliku
4.6. Prezentowanie wyników
Program prezentujacy
˛ jest napisany w C z użyciem bibliotek Freeglut. Służy
do przedstawiania wyników algorytmu ewolucyjnego, a dzieki
˛
użyciu biblioteki
środowiska wirtualnego, oprócz wyświetlania osobników, może też pokazywać ich
działanie w czasie. Pomaga również w testowaniu stworzonych jednostek, gdyż
pozwala na re˛ czne sterowanie osobnikami. Program ten jest istotny, gdyż bez niego
ci˛eżko sobie wyobrazić wyglad
˛ oraz zachowanie osobników na podstawie zbioru
liczb.
Uruchomienie programu prezentujacego
˛
wymaga podania pliku z danymi do
wyświetlenia. Aby to zrobić, należy podczas uruchamiania programu podać nazwe˛
pliku:
1
./ Prezenter example_file
Nie podanie pliku spowoduje wyświetlenie komunikatu o błedzie.
˛
Jest to spowodowane tym, że nie ma sensu uruchamiać środowiska graficznego bez żadnych
osobników poddawanych symulacji. Warto dodać, że podaniu pliku z błedem
˛
nie
przerwie działania programu, o ile uda sie˛ skonstruować chociaż jednego poprawnego osobnika.
Program prezentujacy
˛ pozwala na sterowanie symulacja˛ a nawet ingerowanie w
działanie osobników. Wszystkie funkcje sa˛ uruchamiane za pomoca˛ klawiatury.
Celowo nie opisze˛ tutaj wszystkich skrótów klawiszowych, gdyż w programie dost˛epna jest pomoc, wyświetlana klawiszem ’h’. Oto funkcje zaimplementowane w
programie:
— przykładanie sił do osobnika;
— rotowanie osobnika;
— wstrzymywanie symulacji;
— tryb krokowy;
— tryb szybkiej symulacji;
4.7. Wykorzystane narzedzia
˛
programistyczne
29
— przesuwanie ekranu;
Moduł prezentujacy
˛ wykorzystuje biblioteke˛ symulacji, linkowana˛ statycznie.
Pozwala to nie tylko na wyświetlanie osobników, ale również podgladanie
˛
ich w działaniu. Rodzi to jednakże dodatkowe problemy, z których głównym jest zapewnienie
odpowiedniej komunikacji ze struktura˛ World. Postanowiłem nie siegać
˛
bezpośrednio do pamie˛ ci używanej w symulacji, gdyż w przypadku wielowatkowości
˛
może to
powodować problem z unikaniem wyścigów krytycznych. Osiagn
˛ ałem
˛
to poprzez
implementacje˛ dodatkowego bufora pośredniczacego
˛
w wymianie danych potrzebnych do rysowania. Aby zapełnić bufor danymi o położeniu i rodzaju okregów
˛
wchodzacych
˛
w skład osobników, aplikacja powinna wywołać metode˛ piszac
˛ a˛ dane
do bufora.
1
unsigned long getBubbles ( World ∗ world , BubData ∗ buffer , unsigned long max) {
Metoda ta dla danego świata zapełnia bufor danymi o okregach
˛
dopóki nie opisze wszystkich osobników lub nie nastapi
˛ przekroczenie maksymalnej pojemności. Kolejnym zyskiem wynikajacym
˛
z takiego podejścia jest zwolnienie aplikacji
prezentujacej
˛
z obowiazku
˛
przeprowadzania skomplikowanych przekształceń matematycznych, potrzebnych do wyznaczenia kształtu osobników przy danej rotacji.
Program prezentujacy
˛
jest istotna˛ cześci
˛ a˛ systemu, ale całkowicie odzielona˛
od algorygtmu ewolucyjnego. Dzieki
˛
temu osoba chcaca
˛
osiagn
˛ ać
˛ lepsze efekty
graficzne może zaimplementować ten moduł na nowo, uzupełniajac
˛ go o pewne
funkcje. Nie jest również wymagane stworzenie programu prezentujacego
˛
w C, gdyż
wi˛ekszość popularnych je˛ zyków programowania pozwoli na linkowanie biblioteki
symulacji skompilowanej w C. Sprawia to, że możliwe sa˛ różnorodne zastosowania
takie jak np. podgladanie
˛
efektów symulacji na ekranie telefony komórkowego,
gdyż Java pozwala na używanie kodu maszynowego.
4.7. Wykorzystane narzedzia
˛
programistyczne
Do pracy wykorzystywałem głównie środowisko Eclipse z wtyczka˛ CDT, ułatwiajac
˛ a˛ programowanie w C/C++. Platforma ta, stworzona przez IBM, a obecnie udoste˛ pniona na zasadach wolnego oprogramowania, służy dostarczaniu programistom poprzez system wtyczek narzedzi
˛
wspomagajacych
˛
prace.
˛ Dzieki
˛ niej
mogłem korzystać z wielu funkcji ułatwiajacych
˛
wpisywanie i formatowanie kodu.
Kolejna˛ korzyścia˛ płynac
˛ a˛ z korzystania ze środowiska Eclipse + CDT jest automatyczne tworzenie makefilów, dzieki
˛ któremu byłem zwolniony z pisania ich recznie.
˛
Wtyczka CDT posiada ponadto bardzo dobre wsparcie dla debugowania kodu, choć
do problemów z wyciekami i profilowaniem używałem dokładniejszego narzedzia
˛
Valgrind.
4.8. Szacowanie złożoności obliczeniowej
30
Aby ułatwić powracanie do porzednich wersji kodu lub nie utracić wyników
pracy w przypadku awarii postanowiłem użyć systemu wersjonowania Git. Narze˛
dzie to, be˛ dace
˛ wolnym oprogramowaniem, jest szeroko wykorzystywane zarówno
w projektach akademickich, jak i przez firmy zajmujace
˛ sie˛ produkcja˛ oprogramowania na skale˛ przemysłowa.
˛ Git jest systemem rozproszonym, co oznacza, że
każdy programista korzystajacy
˛ z niego może pracować bez połaczenia
˛
z internetem, łacz
˛ ac
˛ efekty swojej pracy, gdy zajdzie taka potrzeba. Jako, że nad projektem
pracowałem sam, najistotniejsza˛ cecha˛ Gita była dla mnie szybkość. Narzedzie
˛
to
posiada wtyczke˛ do środowiska Eclipse, jednakże ja korzystałem z niego za pomoca˛
terminala linii poleceń.
Korzystanie z systemu w przypadku bardziej skomplikowanych symulacji jest
zaj˛eciem bardzo czasochłonnym, toteż do sterowania używałem własnorecznie
˛
napisanych skryptów Bash, czyli powłoki tekstowej linux. Pozwalaja˛ one na zakolejkowanie zadań z różnymi parametrami, dzieki
˛ czemu obecność operatora przy
komputerze nie jest stale wymagana. Tego samego narzedzia
˛
używałem również
do wste˛ pnego opracowywania wyników, szczególnie, gdy było ich zbyt wiele, aby
można było na nich wygodnie operować za pomoca˛ arkusza kalkulacyjnego.
4.8. Szacowanie złożoności obliczeniowej
Choć nie jest to przedmiotem tej pracy, zgrubne szacowanie złożoności obliczeniowej nie powinno być pominiete
˛ przy projektowaniu i implementowaniu systemów informatycznych, ze szczególnym naciskiem na programy, których ważna˛
cz˛eścia˛ algorytmy. Dokładne obliczenie zapotrzebowania na pamieć
˛ i procesor jest
dla rozbudowanych systemów zbyt pracochłonne, jednakże nie przeszkadza to w
przeprowadzeniu pesymistycznego szacowania w notacji asymptotycznej. W moim
systemie postanowiłem skupić sie˛ na na złożoności obliczeniowej, gdyż program nie
jest pamie˛ ciochłonny.
Pierwszym krokiem szacowania złożoności obliczeniowej jest zidentyfikowanie
zmiennych, od których jest zależne zapotrzebowanie [11]. Pierwsza˛ wartościa˛ jaka
przychodzi na myśl jest oczywiście liczba tur symulacji, czyli czas poddany dyskretyzacji. Naste˛ pnie należy przyjrzeć sie˛ pojedynczemu krokowi symulacji, w którym
znajduja˛ sie˛ oddziaływania silnika fizycznego oraz proces podejmowania decyzji
przez każdego z osobników obecnych w symulacji. Obliczenia zwiazane
˛
z symulacja˛
warunków fizycznych, choć skomplikowane, nie sa˛ pracochłonne, w przeciwieństwie do algorytmu decyzyjnego jednostek, który jest zależny od liczby modułów
oraz ilości jedzenia w zasie˛ gu wzroku. Samo sprawdzanie, czy pożywienie jest w zasi˛egu receptora ma złożoność kwadratowa˛ wzgledem
˛
liczby modułów, gdyż należy
sprawdzić, czy linia widzenia nie jest przesłonieta
˛
przez inny element jednostki.
W pesymistycznym przypadku, gdy wszystkie sztuki jedzenia sa˛ w zasiegu
˛
wzroku,
31
4.8. Szacowanie złożoności obliczeniowej
a każdy moduł jest detektorem, złożoność obliczeniowa przedstawia sie˛ nastepu˛
jaco:
˛
O(T JM N 2 )
(4.2)
gdzie:
— T oznacza liczbe˛ tur symulacji;
— J oznacza liczbe˛ sztuk pożywienia;
— M oznacza liczbe˛ jednostek;
— N oznacza liczbe˛ modułów w jednostce.
Jak widać, wyste˛ puje wiele czynników, co sprawia, że wyrażenie jest piatego
˛
stopnia. W algorytmice jest to duża wartość, ale należy pamietać,
˛
że system nie
jest zaplanowany do symulowania osobników złożonych z tysiecy
˛
modułów, a to
jedyny czynnik wyste˛ pujacy
˛
w kwadracie.
W praktyce, jedyne dwa parametry,
o których trzeba pamie˛ tać przy planowaniu eksperymentu, to liczba tur symulacji
oraz ilość jedzenia na mapie. Co wiecej,
˛
planujac
˛ eksperyment, który nie wymaga
od osobników posiadania detektorów, można z góry przyjać,
˛ że czynniki J oraz N sa˛
pomijalne.
5. Eksperymenty
Zwieńczeniem pracy nad systemem sa˛ eksperymenty majace
˛ na celu praktyczne
przetestowanie działania środowiska. Badania sa˛ dobrane tak, aby wypróbować
elastyczność systemu potrzebna˛ do rozwiazywania
˛
różnych problemów. Każdy eksperyment wymagał dobrania odpowiednich parametrów oraz dokonania modyfikacji w programie ewolucyjnym.
5.1. Szukanie jedzenia
Pierwszy, najprostszy z eksperymentów, zatytułowałem ”szukanie jedzenia”. Polega on na symulowaniu jednej z najbardziej naturalnych potrzeb żywych istot, czyli
odżywiania sie˛ . Celem tego eksperymentu było wykazanie wpływu zasady doboru
naturalnego na fenotyp osobników, jednakże miał on również wykazać działanie
całego systemu.
Przyjałem
˛
naste˛ pujace
˛ warunki środowiskowe:
— współczynnik tarcia liniowego: 25;
— współczynnik tarcia obrotowego: 20;
— współczynnik oporu powietrza w ruchu liniowym: 15;
— współczynnik oporu powietrza w ruchu obrotowym czynnik kwadratowy: 10:
— współczynnik oporu powietrza w ruchu obrotowym czynnik liniowy: 10:
Sa˛ to wartości domyślne dla programu, dobrane tak, aby osobniki poruszały sie˛
naturalnie.
Osobniki ewoluowały w kierunku coraz lepszych i skuteczniejszych form, co było
opisane ilościa˛ zjedzonego przez jednostke˛ w określonym czasie. Aby zwiekszyć
˛
szanse˛ na osiagni
˛ e˛ cie oczekiwanych rezultatów postanowiłem wprowadzić kilka
uproszczeń. Przede wszystkim zrezygnowałem z samomodyfikujacego
˛
skryptu sterujacego
˛
osobnikami, wszystkie jednostki korzystaja˛ z tego samego, zaprojektowanego przeze mnie skryptu. Ponadto, postanowiłem, że liczba, rodzaj i położenie
modułów również nie podlegaja˛ ewolucji, jedynie ich rozmiar i jak bardzo wysuni˛ete maja˛ być. Na rysunku 4.2 przedstawiłem przykładowego, losowego osobnika
z populacji poczatkowej:
˛
Jak widać, składa sie˛ on z sześciu modułów. Posiada dwa detektory kołowe po
bokach, detektor liniowy pośrodku, silnik główny na dole oraz dwa silniki pomocnicze, nadajace
˛ osobnikowi niezerowy moment siły. Skrypt sterujacy
˛ jednostka˛
5.1. Szukanie jedzenia
33
Rysunek 5.1. Osobnik z populacji poczatkowej
˛
w każdej turze symulacji sprawdza, czy przedni czujnik jest aktywny (czyli wykrywa jedzenie w linii prostej. Jeśli tak jest, uruchamia silnik główny, powodujac
˛
ruch do przodu. W przeciwnym razie sprawdza, czy detektory boczne coś widza,
˛
uruchamiajac
˛ odpowiedni silnik manewrowy. Jeżeli nic nie widzi, uruchamia silnik główny i jeden z manewrowych, próbujac
˛ poruszać sie˛ w losowym kierunku.
Można przypuszczać, że zaprezentowany na rysunku osobnik z populacji poczatko˛
wej nie be˛ dzie zbyt skuteczny w szukaniu pożywienia, gdyż czujniki sa˛ zasłoniete
˛
przez zdecydowanie zbyt wielkie silniki manewrowe. Ewolucji podlegały tylko rozmiary modułów i odległość od modułu głównego, także w praktyce algorytm ten
jest prosta˛ optymalizacja˛ funkcji 12 zmiennych. Użyto domyślnych operatorów,
czyli selekcja odbywała sie˛ w sposób turniejowy, natomiast mutacja i krzyżowanie
korzystaja˛ z rozkładu ciagłego
˛
podczas doboru zmiennych losowych. Wymieniony
poniżej współczynnik mutacji w tym wypadku przekłada sie˛ na szerokość przedziału, z którego sa˛ losowane wartości.
Algorytm ewolucyjny otrzymał nastepuj
˛
ace
˛ parametry:
— rozmiar populacji: 120;
— rozmiar szranki: 6;
— liczba generacji: 1000;
— liczba tur symulacji: 3000;
— współczynnik mutacji: 0.04;
Wyniki eksperymentu okazały sie˛ być cześciowo
˛
zgodne z przewidywaniami i
zostały przedstawione na rysunku 5.2, uszeregowane od lewej do prawej chronologicznie. Najważniejsze moduły, czyli detektor liniowy znajdujacy
˛ sie˛ w środku
osobnika oraz nape˛ d w każdym z najskuteczniejszych osobników sa˛ duże. Znacznie ciekawsza jest historia silników manewrowych oraz detektorów bocznych. Z
racji, że nie daja˛ one żadnego efektu poza szybszym naprowadzaniem na pożywienie ewolucja postanowiła zmniejszać ich rozmiary na tyle na ile to możliwe. Co
5.1. Szukanie jedzenia
34
ciekawe, lewy detektor i prawy silnik zostały zmniejszone do tego stopnia, że nie
maja˛ prawie żadnego wpływu na organizm. Może być to spowodowane tym, że jednostka preferuje obrót w prawo, jako że kierunek ten jest uprzywilejowany z racji,
że w ta˛ strone˛ obraca sie˛ osobnik którego detektory nic nie widza.
˛ Warto jeszcze
wspomnieć że zachowana została symetria, a środek masy jest w linii z głównym
silnikiem.
Rysunek 5.2. Historia zmian w wygladzie
˛
osobnika
Program ewolucyjny, oprócz zapisywania najlepszych osobników zbierał również dane statystyczne dla każdego pokolenia. Informacje te, czyli przystosowanie
najlepszego osobnika w danym pokoleniu oraz średnie przystosowanie w czasie
sa˛ jedna˛ z najprostszych i najpopularniejszych sposobów oceny algorytmów genetycznych. Pozwalaja˛ one na wyznaczenie liczby generacji potrzebnej do tego, żeby
algorytm uzyskał zbieżność. Dane te, po opracowaniu, umieściłem na wykresie 5.3.
Rysunek 5.3. Wykres dostosowania populacji w czasie
Jak widać, zbieżność nastapiła
˛
po kilkudziesieciu
˛
pokoleniach, co jest spowodowane tym, że zadanie optymalizacyjne było dość proste i w populacji poczatkowej
˛
znalazł sie˛ pewnie dostatecznie dobry osobnik. Wykres średniego dostosowania
jest po osiagni
˛ e˛ ciu zbieżności stabilny, w przeciwieństwie do wykresu najlepszego
35
5.2. Ruch liniowy
przystosowania w danym pokoleniu, którego zmienność spowodowana jest losowym
ułożeniem pożywienia w świecie symulacji. Eksperyment ten dowiódł poprawności
działania systemu oraz przyniósł spodziewane rezultaty, niemniej jednak szybkie
˛ trudne
osiagni
˛ e˛ cie zbieżności każe przypuszczać, że zadanie nie było wystarczajaco
dla algorytmu ewolucyjnego.
5.2. Ruch liniowy
Pierwszy eksperyment miał na celu sprawdzenie działania środowiska w praktyce i, ze wzgle˛ du na ograniczenia, nie pokazywał w pełni możliwości ewolucyjnego
tworzenia osobników. W kolejnym badaniu postanowiłem pozwolić algorytmowi na
pełniejsze sterowanie budowa˛ jednostek. Eksperyment ten, o nazwie ruch liniowy,
zainspirowany praca˛ nad projektem Golem opisanym w drugim rozdziale niniejszej pracy, polega na określeniu funkcji przystosowania jako odległość osobnika od
punktu startowego w linii prostej.
Aby osobniki nie zataczały okregów,
˛
postanowiłem zmienić parametry środowiska, zwie˛ kszajac
˛ tarcie oraz opór powietrza w ruchu obrotowym. Celem tego
zabiegu było uodpornienie populacji na zmiany wynikajace
˛ z przekrecenia
˛
jednego
z silników w poprzek osi ruchu.
Kolejna˛ zmiana˛ w stosunku do poprzedniego
eksperymentu było kompletne wyłaczenie
˛
skryptu sterujacego
˛
jednostkami, jako
że detektory nie sa˛ potrzebne ze wzgledu
˛
na brak jedzenia, a silniki powinny być
zawsze właczone.
˛
Dokonałem tego, ustawiajac
˛ flage˛ w strukturze World:
1
typedef struct {
/∗ other f i e l d s ( . . . ) ∗/
int enginesAlwaysOn ;
} World ;
Poszukujac
˛ lepszych efektów, postanowiłem eksperyment ten przeprowadzić
z innymi operatorami algorytmu ewolucyjnego. Krzyżowanie, zamiast domyślnego,
które losuje wartość z rozkładu ciagłego
˛
ograniczonego wartościami genu obu rodziców, zostało zastapione
˛
losowaniem, który z rodziców przekazuje swój gen. Mutacja korzysta z rozkładu normalnego zamiast ciagłego.
˛
Zmienione zostały również
parametry algorytmu ewolucyjnego:
— rozmiar populacji: 240;
— rozmiar szranki: 6;
— liczba generacji: 3000;
— liczba tur symulacji: 4000;
— współczynnik mutacji: 0.02, przy odchyleniu standardowym wynoszacym
˛
1.
Każdy osobnik z populacji składał sie˛ z maksymalnie siedmiu modułów, z których każdy z wyjatkiem
˛
bazowego był silnikiem.
Ewolucji podlegały wszystkie
˛
parametry elementów tworzacych
˛
jednostke,
˛ czyli odległość modułu od bazy, kat
36
5.2. Ruch liniowy
określajacy
˛ jego położenie, rozmiar oraz kierunek działania silnika. W przypadku,
gdy moduły zachodza˛ na siebie, sa˛ odrzucane w procesie tworzenia osobnika, choć
geny za to odpowiedzialne sa˛ zachowane, i moga˛ być użyte w przyszłym pokoleniu. W ten sposób, algorytm stał sie˛ optymalizacja˛ 28 zmiennych rzeczywistych
z zakresu <0;1>, co w porównaniu z poprzednim eksperymentem, gdzie zmianom
podlegało efektywnie 12 wartości, jest znacznym utrudnieniem. Warto również zauważyć, że o ile w poprzednim eksperymencie dało by sie˛ wyznaczyć zadowalajacy
˛ wynik metoda˛ siłowa,
˛ tak w tym wypadku złożoność obliczeniowa byłaby zbyt
duża. Populacja poczatkowa
˛
ponownie została zainicjowana osobnikami losowymi,
jednakże w tym wypadku szansa na to, że któryś ze startowych osobników jest
bliski optymalnemu jest niska. Kilka jednostek z populacji poczatkowej
˛
zostało
zaprezentowanych na rysunku 5.4, jak widać, ich silniki wskazuja˛ w losowych
kierunkach, powodujac
˛ straty w szybkości i kluczenie. W niektórych przypadkach
brakuje kilku modułów silnika, które nachodza˛ na inne, wiec
˛ zostały odrzucone
przez algorytm tworzacy
˛ osobniki z genomu jako nieprawidłowe. Dodatkowo, jako
utrudnienie dla osobników, każdy zaczyna z modułem centralnym o maksymalnym
rozmiarze, co ma symulować sztuczne obcia˛żenie, spowalniajace
˛ jednostki. Widać
je na rysunkach jako biały okrag,
˛ otoczony czerwonymi silnikami.
Rysunek 5.4. Osobniki z populacji poczatkowej
˛
Wyniki eksperymentu okazały sie˛ zgodne z oczekiwaniami. Najlepsze osobniki
składaja˛ z dwóch silników, równoległych do siebie. Dodatkowe silniki nie były
”doczepiane” od boku, prawdopodobnie w celu unikniecia
˛
wzrostu oporu powietrza,
który w tym eksperymencie miał decydujacy
˛ wpływ. Niektóre osobniki miały jeszcze
małe moduły nape˛ dowe, umieszczone w szczelinach tak, aby nie zwiekszały
˛
oporu
powietrza. Najlepszego osobnika przedstawiłem na rysunku 5.5.
Podobnie jak w poprzednim eksperymencie, zbierałem dane o jakości populacji
w czasie i po obrobieniu umieściłem na wykresie 5.6. W wypadku tego eksperymentu również zbieżność została dość szybko osiagni
˛ eta.
˛
Zauważalnie spadło również falowanie wykresu, co jest spowodowane tym, że usunieta
˛ została losowość w
rozmieszczaniu pożywienia, a dwa takie same osobniki zawsze pokonaja˛ ten sam
dystans.
37
5.2. Ruch liniowy
Rysunek 5.5. Najlepszy osobnik w historii
Rysunek 5.6. Statystuki pokonanego dystansu
Badanie to zakończyło sie˛ sukcesem, choć szybkie osiagni
˛ ecie
˛
zbieżności zach˛eca do stawiania trudniejszych problemów przed algorytmem ewolucyjnym. Kolejne badania mogłyby wprowadzić dodatkowe zasady budowy osobników, aby
można było obserwować tworzenie bardziej skomplikowanych form.
6. Podsumowanie
W ramach projektu udało mi sie˛ wykonać wszystkie planowane moduły systemu. Najwie˛ cej uwagi poświeciłem
˛
bibliotece symulujacej
˛
zachowanie osobników,
gdyż jest ona tym, co odróżnia mój system od zwykłego algorytmu ewolucyjnego.
Moduł prezentujacy
˛ poprawnie wyświetla jednostki, udostepniaj
˛
ac
˛ również ograniczona˛ możliwość kontrolowania symulacji. Program ewoluujacy
˛ jest implementacja˛
algorytmu ewolucyjnego, przystosowana˛ do działania z symulatorem. Pozwala również na łatwa˛ parametryzacje,
˛ dzieki
˛
czemu można go z powodzeniem stosować
podczas badań.
Myśle˛ , że wybór technologii użytych w projekcie był poprawny. Uważam jedynie, że zamiast standardu C89 mogłem użyć C99, co znacznie poprawiłoby przejrzystość kodu, przy zachowaniu podobnej przenośności. Zauważyłem jeszcze, że
˛ a˛ do wyświetlania osobników na ekranie,
choć FreeGlut jest biblioteka˛ wystarczajac
to naste˛ pnym razem poszukałbym jednak narzedzia
˛
pozwalajacego
˛
na łatwiejsze
rysowanie osobników o dodatkowych detalach. Pozostałe zastosowane przeze mnie
technologie nie pozostawiaja˛ żadnych zastrzeżeń.
Po wykonaniu systemu zaplanowałem i wykonałem dwa eksperymenty. Pierwszy z nich, ”Szukanie Jedzenia” przyniósł oczekiwane rezultaty, choć nie pokazał
wszystkich możliwości systemu. Drugi, zatytułowany Ruch Liniowy zakończył sie˛
umiarkowanym sukcesem. System może być w przyszłości użyty do dalszych badań
nad doborem naturalnym wśród osobników, a dzieki
˛ modularnej budowie może łatwo podlegać modyfikacji. Osoba chcaca
˛ kontynuować prace,
˛ powinna skupić sie˛
na dodaniu innych rodzajów genomów oraz na usprawnieniu jezyka
˛
skryptowego
sterujacego
˛
osobnikami. W celu lepszej prezentacji wyników badań należałoby również polepszyć program prezentujacy,
˛
np. poprzez teksturowanie osobników lub
proste efekty 3d.
Podsumowujac,
˛ uważam, że system spełnia postawione przed nim wymagania. Wymaga on jeszcze sporo pracy zanim bedzie
˛
można wykorzystywać go do
poważniejszych badań, niemniej jednak dzieki
˛ odpowiedniej strukturze jest on łatwy w rozbudowie. Stanowi on dobra˛ podstawe˛ do dalszej pracy podczas studiów
magisterskich.
Bibliografia
[1] Box2d, a 2d physics engine for games. http://box2d.org/ dostep
˛ 16.06.2013.
[2] Jarosław Arabas.
Wykłady z algorytmów ewolucyjnych.
Wydawnictwa
Naukowo-Techniczne, Warszawa, 2001.
[3] Charles Darwin. O powstawaniu gatunków droga˛ doboru naturalnego czyli o utrzymaniu sie˛ doskonalszych ras w walce o byt. De Agostini, Warszawa, 2001.
[4] Arjen E. Hof, van’t, Nicola Edmonds, Martina Dalíková, František Marec, Ilik J. Saccheri. Industrial melanism in british peppered moths has a singular and recent mutational origin. Opublikowane w internetowym wydaniu Science w dniu 14.04.2011,
wydanie 332 nr 6032 strony 958-960 DOI: 10.1126/science.1203043.
[5] B.W. Kernighan, D.M. Ritchie. Jezyk
˛
ANSI C. Programowanie. Wydawnictwo Helion,
Gliwice, wydanie drugie, 2010.
[6] Romuald Kotowski, Piotr Tronczyk. Modelowanie i symulacje komputerowe. Wydawnictwo Uniwersytetu Kazimierza Wielkiego, Bydgoszcz, 2009.
[7] Heather Larkin. The game of evolution. http://www.larkinheather.com/evolution/
dostep
˛ 13.06.2013.
[8] Hod Lipson, Jordan B. Pollack. Automatic design and manufacture of robotic lifeforms. http://www.demo.cs.brandeis.edu/golem/ dostep
˛ 12.06.2013.
[9] Zbigniew Michalewicz. Algorytmy genetyczne + struktury danych = programy ewolucyjne. Wydawnictwa Naukowo-Techniczne, Warszawa, 1996.
[10] Susumu Ohno. Birth of unique enzyme from alternative reading frame of the preexisted, internally repetitious coding sentence. Proc Natl Acad Sci U S A. 1984 Kwiecień;
81(8): 2421–2425.
[11] Christos H. Papadimitriou. Złożoność obliczeniowa. Wydawnictwo Helion, Gliwice,
2012.
[12] S. Richard Wright, Benjamin Lipchak. OpenGL Ksiega
˛
eksperta. Wydawnictwo Helion,
Gliwice, 2012.