wydziaŁ elektrotechniki, automatyki i informatyki...

WYDZIAŁ ELEKTROTECHNIKI, AUTOMATYKI I INFORMATYKI

POLITECHNIKA ŚWIĘTOKRZYSKA

INŻYNIERSKA PRACA DYPLOMOWA

Projekt i implementacja aplikacji dla instrukcji ćwiczeniowych do

symulacji w systemie DEVSimPy.

Cezary Sosnowski

Promotor:

Dr inż. Andrzej Kułakowski

Kielce, 2015

Spis treści:

1. Wstęp ....................................................................................................................................... 17

1.1 Modelowanie i symulacja ....................................................................................................... 17

1.2 Cel i zakres pracy ................................................................................................................... 18

1.3 DEVS ..................................................................................................................................... 19

2. Główne cechy środowiska DEVSimPy .................................................................................... 21

2.1 DEVSimPy ............................................................................................................................. 21

2.2 Obsługa komponentów i schematów ....................................................................................... 23

2.3 Usprawnienie procesu symulacji ............................................................................................. 24

3. Projekty aplikacji ćwiczeniowych ........................................................................................... 25

3.1 Instrukcja użytkowa DEVSimPy ............................................................................................. 25

3.1.1 Instalacja ............................................................................................................................ 25

3.1.2 Uruchomienie .................................................................................................................... 26

3.1.3 Podsumowanie rozdziału.................................................................................................... 27

3.2 Opis użytkowy, DEVS ............................................................................................................ 27

3.2.1 Opis użytkowy modeli ....................................................................................................... 27

3.2.2 DEVS ................................................................................................................................ 28


3.3 Biblioteka ............................................................................................................................... 29

3.3.1 Elementy biblioteki ............................................................................................................ 29


3.4 Prosty przykład symulacji ....................................................................................................... 31

3.4.1 Przygotowanie do symulacji............................................................................................... 31


3.5 Symulacja linii produkcyjnej .................................................................................................. 33

3.5.1 Elementy projektu ............................................................................................................... 33

3.5.2 Symulacja.................................................................................................................................34

3.5.3 Podsumowanie rozdziału..................................................................................................... 35

3.6 Symulacja Sztucznej Sieci Neuronowej ................................................................................... 35

3.6.1 Bramka XOR ...................................................................................................................... 35

3.6.2 Problem symulacji układu logicznego ................................................................................ 36

3.6.3 Biblioteka symulacji Sieci Neuronowej ............................................................................... 36

3.6.4 Sieć neuronowa ................................................................................................................... 37

3.6.5 Symulacja ........................................................................................................................... 38

3.6.6 Podsumowanie rozdziału..................................................................................................... 38

4. Implementacja instrukcji ćwiczeniowych ................................................................................ 39

4.1 Instalacja i konfiguracja ........................................................................................................... 39

4.1.1 Instalacja DEVSimPy w wersji 2.8 w systemie WINDOWS XP .......................................... 40

4.2 Pierwsze kroki z DEVSimPy .................................................................................................... 42

4.2.1 Menu główne ...................................................................................................................... 44

4.3 Podstawowy model: model atomowy, budowa, właściwości .................................................... 48

4.3.1 Model atomowy .................................................................................................................. 48

4.3.2Własności atomowego modelu ............................................................................................. 51

4.3.3 Ogólne funkcje .................................................................................................................... 54

4.3.4 Menadżer symulacji ............................................................................................................ 54

4.3.5 Stałe modeli ........................................................................................................................ 54

4.3.6 Opcje zarządzania ............................................................................................................... 55

4.3.7 Biblioteka DEVSimPy......................................................................................................... 57

4.3.8 Import biblioteki ................................................................................................................. 58

4.3.9 Tworzenie biblioteki............................................................................................................ 59

4.4 Przykład symulacji modeli ....................................................................................................... 60

4.4.1 Debugowanie kodu .............................................................................................................. 62

4.5 Symulacja linii produkcyjnej .................................................................................................... 63

4.5.1 Wstępne informacje ............................................................................................................. 63

4.5.2 Symulacja ........................................................................................................................... 68

4.5.3 Podsumowanie symulacji .................................................................................................... 70

4.6 Symulacja sieci neuronowych .................................................................................................. 71

4.6.1 Wstępne informacje ............................................................................................................. 71

4.6.2 Bramka XOR ...................................................................................................................... 73

4.6.3 Biblioteka symulacji Sztucznej Sieci Neuronowej ............................................................... 75

4.6.4 Sieć neuronowa ................................................................................................................... 77

4.6.5 Symulacje ........................................................................................................................... 82

4.6.6 Podsumowanie symulacji .................................................................................................... 86

5. Testowanie .................................................................................................................................. 87

5.1 Przetestowanie projektów aplikacji ćwiczeniowych.................................................................. 87

5.2 Przetestowanie wykonanego oprogramowania w aplikacjach ćwiczeniowych .......................... 88

5.3 Podsumowanie ......................................................................................................................... 89

6. Podsumowanie, wnioski – DEVSimPy ...................................................................................... 90

Spis ilustracji .................................................................................................................................. 91

Spis listingów .................................................................................................................................. 94

Spis tabel ........................................................................................................................................ 94

Bibliografia .................................................................................................................................... 95

17

1. Wstęp

Ludzie wykorzystują do opisywania własnej rzeczywistości modele. Za każdym razem gdy prowadzimy samochód, przechodzimy przez ulicę, spodziewamy się, że może padać deszcz – używamy tych samych modeli predykcyjnych które zbudowaliśmy w oparciu o nasze doświadczenia i błędy z przeszłości [5]. W nauce, jest to szczególnie interesujące do badania zjawisk, w których konfiguracja lub właściwości zmieniają się w czasie np: ruch planet, wzrost roślin, rozprzestrzenianie się chorób itp.

Postęp w rozwiązywaniu metod numerycznych i wzrost wydajności komputera pozwala dziś poprzez symulacje coraz bardziej szczegółowo przewidzieć zachowania złożonych systemów. Symulacje potwierdzone przez eksperymenty wykorzystywane są w dziedzinie przemysłu by skrócić cykl produkcji produktu [2].

1.1 Modelowanie i symulacja

Wykorzystanie metodmodelowania i symulacji (M&S) dla wykonywania konkretnego systemu wymaga poświęcenia dużo czasu.

Aby usprawnić pracę należy [3]: wyznaczyć i wykorzystać elementy wielokrotnego użytku; rozwijać współpracę (M&S).

Należy podkreślić że tradycyjne metody modelowania i symulacji komputerowych są

dość jednowątkowe. Opracowane oprogramowanie koncentruje się głównie na aplikacjach pojedynczych. Symulacja złożonych systemów wymaga wielodyscyplinarnego podejścia, które angażuje większą wydajność komputerów [2]. Zazwyczaj narzędzia do M&S są przygotowane w specjalnych bibliotekach, gdzie opis znacznie ułatwia użycie. Ma to kilka zalet. Po pierwsze, przygotowane biblioteki (składowe) mogą być używane w różnych symulacjach. Po drugie, możliwość wymiany informacji, a zarazem udostępnienie informacji przez wielu użytkowników. Ostatni punkt jest najistotniejszy ponieważ w dzisiejszych czasach praca zespołu jest bardziej efektywna dzięki rozwojowi Internetu [1].

18

1.2 Cel i zakres pracy

Celem niniejszej pracy inżynierskiej jest stworzenie i zaprojektowanie skryptów do instrukcji ćwiczeniowych do symulacji w systemie DEVSimPy. Opracowane zostały zagadnienia dotyczące symulacji zdarzeniowych typu DEVS, a także opracowano charakterystykę systemu symulacyjnego DEVSimPy.

Praca obejmuje także zestaw instrukcji, które zostały stworzone po to, żeby użytkownik podczas ćwiczeń mógł poznać i przetestować program. Przedstawiono cały proces instalacji systemu, opis interfejsu, a także zakres pracy poszczególnych elementów w programie. Przygotowano aplikacje ćwiczeniowe do symulacji różnych dziedzin technicznych w systemie DEVSimPy, przetestowanie ich oraz wyciągnięcie odpowiednich wniosków.

Prace kończą odpowiednio wysunięte wnioski i podsumowania.

Zakres pracy obejmuje następujące zagadnienia:

Wprowadzenie do formalizmu DEVS: - czym jest pojęcie DEVS; - wpływ DEVS na modelowanie i symulacje;

Charakterystykę systemu DEVSimPy: - budowa programu; - najważniejsze elementy i cechy platformy DEVSimPy;

Projekty aplikacji ćwiczeniowych: - wprowadzenie krok po kroku opisujące zasady działania oraz obsługi DEVSimPy;

Implementacje instrukcji ćwiczeniowych: -rozszerzenie aplikacji ćwiczeniowych w postaci opisu modeli, menu oraz wykonanie symulacji. Przedstawiono zakres pracy poszczególnych elementów.

Testowanie: - test obsługi, pracy w programie DEVSimPy;

- test przeprowadzanych symulacji;

Podsumowania i wnioski.

19

1.3 DEVS

Modelowanie i symulacja oparta na DEVS pozwala na określenie zachowania się systemu, a co najważniejsze oddzielenie modelowania od części symulacji [8].

DEVS (System zdarzeń dyskretnych) został wprowadzony w drugiej połowie lat 70 przez profesora Bernarda Zeigler’a. Jest to modułowy i hierarchiczny formalizm do modelowania i analizowania systemów ogólnych. Pozwala na przedstawienie całego układu jako zbiór, zestaw modeli posiadających odpowiednie stany i przejścia [3,8].

Zeigler zaproponował architekturę koncepcyjną dostosowaną do założeń DEVS [8]:

Rys. 1. Struktura modelowania i symulacji w DEVS [5]

Architektura posiada trzy jednostki [3,8]:

System: występuje w określonym środowisku. Pozwala na testowanie i walidację;

Model: opiera się na zestawie definicji, instrukcji i zasad, które są generowane po symulacji. Zdefiniowane i przechowywane w tej jednostce;

Symulator: odpowiedzialny za interpretację modelu. Wykonuje instrukcje by generować odpowiednie reakcje.

20

Nie ma żadnego połączenia pomiędzy podmiotami. Występują tylko relacje. Pozwala to na szereg korzyści jak symulowanie modeli z różnych rodzajów symulatorów i różnych typów środowisk. Drugą zaletą, jest zapewnienie automatycznej symulacji modeli w tego typu strukturze.

Symulator DEVS będzie realizował funkcje przejścia pomiędzy modelami i zarządzał odpowiednią komunikacją.

To wszystko oznacza, że można zaprezentować model danego systemu bez konieczności inicjacji symulacji. Współpraca modelowania i symulacji na oddzielnym polu niesie ze sobą wiele problemów. Po pierwsze, manipulowanie podstawowymi elementami (modele atomowe, połączenia modeli jak i stanowiska kontrolne); po drugie rozwiązanie problemu ze zarządzaniem oprogramowaniem. Głównie użytkownik końcowy musi mieć odniesienie do konstrukcji aplikacji [1,8].

21

2. Główne cechy środowiska DEVSimPy

Rozdział opisuje najistotniejsze cechy tego środowiska. Na jakiej platformie języka bazuje i z jakich bibliotek to oprogramowanie korzysta. Przedstawiono podstawowe rozszerzenia plików, a także atuty procesu symulacji w DEVSimPy.

2.1 DEVSimPy

Środowisko zapewnia przyjazny interfejs dla użytkownika. Rama oprogramowania jest oparta na języku Phyton. Program ten został zainicjowany przez wykładowcę Lawrence Capocchi z Uniwersytetu Korsyki w zespole laboratoryjnym SPE [2].

Pole modelowania w DEVSimpy oparte jest na formalizmie DEVS. Dzięki temu można modelować i symulować systemy dyskretne w hierachiczny sposób.

Najważniejsze cechy [2,3]:

model systemu DEVS można zapisać do biblioteki; edycja modeli DEVS podczas symulacji; import istniejącej biblioteki; automatyczna symulacja; analiza systemu;

DEVSimpy korzysta z biblioteki graficznej wxPhyton, języka Phyton oraz PyDEVS [1] .

Rys. 2. Warstwa DEVSimPy [1]

22

DEVSimPy powstało w wyniku współpracy naukowców podczas modelowania DEVS. Końcowi użytkownicy (odbiorcy) mogą rozwijać elementy rodzajowe biblioteki. Biblioteki mogą być przechowywane na dysku twardym lub w sieci. Dodatkowo niektóre elementy są kompresowane m.in. pliki graficzne modeli co pozwala zachować separację między zachowaniem, a widokiem modeli. Podsumowując tą kwestie DEVSimPy pozwala na wymianę komponentów bibliotek.

Jądro Modelowania i symulacji (M&S) zostało zbudowane w DEVSimPy przez inżynierów aplikacji [1].

Rys. 3. Współpraca w DEVSimPy [1]

Gdy końcowi użytkownicy (rys.3) podczas debugowania swoich modeli wykryją błędy mogą łatwo zaimportować do dwóch Menadżerów błędów. Zaprojektowane przez inżynierów pozwalają korygować modele, bądź też wysyłać e-mail do programistów DEVSimPy. W DEVSimPy biblioteka to określone katalogi zawierające pliki. Mogą one być przechowywane na dysku lokalnym lub na serwerze HTTP. Są więc dwa sposoby udostępniania plików: do odczytu – gdy biblioteka znajduje się na serwerze HTTP oraz odczyt/zapis – dysk lokalny [1].

23

2.2 Obsługa komponentów i schematów

Biblioteka składa się z plików które służą do tworzenia instancji komponentów. Komponenty muszą być łatwe do przenoszenia i łatwe w użyciu w tym środowisku. Dlatego są one wykonane ze skompresowanych plików. W ten sposób łatwo jest oddzielić strukturę od reprezentacji modeli.

DEVSimPy posiada dwa rozszerzenia plików [3]:

.amd model atomowy; plik skompresowany określa zachowanie funkcji przejścia (devs) i pliku graficznego (kolor, kształt);

.cmd dla modeli sprzężonych. Plik ten składa się z pliku definiowania struktury (lista modeli devs) i pliku graficznego;

behawioralne pliki lub pliki strukturalne mają rozszerzenie pliku „.py” a pliki graficzne „.dat”.

Plik o rozszerzeniu „.py” może być nie skompresowany. Dlatego jego reprezentacja w DEVSimPy jest automatyczna. Użytkownik może wyeksportować ten plik do .amd lub .cmd w celu dostosowania.

Aby ułatwić korzystanie z komponentów, DEVSimPy pozwala na automatyczne szablonowanie dokumentacji. System zarządzania może automatycznie generować dokumentację z kodu źródłowego Pythona. DEVSimPy oferuje również uruchamianie modeli przed symulacją z możliwością modyfikacji kodu źródłowego za pomocą wbudowanego edytora kodu.

Gdy użytkownik manipuluje kilkoma elementami tworzy schemat. Ten zestaw powiązanych elementów może być przechowywany w skompresowanym pliku .dsp [1].

24

2.3 Usprawnienie procesu symulacji

Algorytmy symulacyjne w DEVSimPy są generowane automatyczne. Gdy model zostanie zbudowany, symulację można rozpocząć klikając na przycisk – pojawi się okno dialogowe dające dostęp do kilku opcji: jak wybór algorytmu symulacji, wybór profilowania, oraz czas symulacji. Proces symulacji w DEVSimPy jest dość ciekawie rozwiązany [2]. Każda symulacja jest generowana z modelu, a kilka symulacji może być wykonywane jednocześnie. Dzięki czemu użytkownik może symulować kilka zachowań na pojedynczym modelu. Równocześnie można przeprowadzić kilka symulacji z kilku różnych modeli. DEVSimPy pozwala jeszcze na coś więcej. Możliwość zawieszenia symulacji i edytowania kodu modeli w celu modyfikacji ich zachowań. Po zmianach, bez problemów można odtworzyć i uruchomić symulację z nowymi „zachowaniami”. Użytkownik może oddziaływać na zachowanie modeli bez czekania na koniec symulacji [2].

Kolejnym narzędziem symulacji zaproponowanym przez DEVSimPy jest profilowanie. Użytkownik może przeprowadzić symulację z profilowaniem do pomiaru zasobów zużywanych (pamięć, procesor). Każdy taki schemat może być wyprofilowany i zapisany w osobnych plikach. Samo profilowanie musi być używane ostrożnie przez użytkownika [3].

Dwa typy menadżerów do wykrywania błędów zawarte są w DEVSimPy. Pierwszy z nich dotyczy wykrywania błędów pochodzących z jądra kodu DEVSimPy. Drugi menadżer informuje użytkownika, gdzie występuje błąd w kodzie. Sprawdzanie błędów jest możliwe przed symulacją, podczas kodowania modeli i podczas importu bibliotek. Gdy zostanie wykryty błąd zostaje wyświetlone okno z prośbą do użytkownika, czy chce naprawić ten błąd [2,3].

25

3. Projekty aplikacji ćwiczeniowych

Rozdział zawiera projekty aplikacji ćwiczeniowych w systemie DEVSimPy

przygotowane dla użytkownika. Poszczególne rozdziały dotyczą: Instalacji, opisu modeli, podstawowych elementów biblioteki oraz przykładowych symulacji realizowanych w tym środowisku.

3.1 Instrukcja użytkowa DEVSimPy

W instrukcji zawarte są informacje dotyczące instalacji oraz uruchomienia programu DEVSimPy.

3.1.1 Instalacja

DEVSimPy można pobrać pod następującym adresem: https://code.google.com/p/devsimpy/ [4]. Narzędzia potrzebne do uruchomienia DEVSimPy w systemie Windows:

Python, wersja 2.5 + (wymagane);

wxPython wersja 2.6 + (wymagane);

biblioteki Scipy, NumPy (opcjonalnie) do niektórych prac naukowych;

wtyczka Networkx (opcjonalnie).

26

3.1.2 Uruchomienie

Po zainstalowaniu tych bibliotek i dekompresji archiwum DEVSimPy_2.8.zip, w wypakowanym folderze należy znaleźć plik źródłowy devsimpy.py, edytować go w IDLE.

Rys. 4. Uruchomienie pliku DEVSimPy w Pythonie

Następnie, by wykonać, a jednocześnie uruchomić DEVSimPy należy wcisnąć F5:

Rys. 5. Uruchomienie programu DEVSimPy

27

3.1.3 Podsumowanie rozdziału

Użytkownik poznał proces instalacji programu jak i dodatkowych narzędzi współpracujących z głównym narzędziem. Jednocześnie musi dobrać odpowiednie wersje narzędzi do wersji instalowanego DEVSimPy.

3.2 Opis użytkowy modeli, DEVS

Instrukcja opisuje podstawowe modele oraz ich rozszerzenia. Informuje jak stworzyć model, jak edytować i określić podstawowe parametry. Opisane jest także zagadnienie formalizmu DEVS.

3.2.1 Opis użytkowy modeli.

DEVSimpy posiada dwa rozszerzenia plików:

.amd model atomowy; .cmd dla modeli sprzężonych; Behawioralne pliki lub pliki strukturalne mają rozszerzenie pliku „.py” a pliki graficzne

„.dat”.

Stworzenie podstawowego modelu atomowego w DEVSimPy [5] odbywa się za pomocą dwóch sposobów:

za pomocą menadżera tworzenia modelu;

stworzenie i zapisanie pliku kompatybilnego z PyDEVS python i przeniesienie go do okna interfejsu.

28

Rys. 6. Graficzny blok modelu atomu

Po utworzeniu modelu atomu można uzyskać dostęp do właściwości obiektu. Klikając odpowiednio prawym przyciskiem myszki na tle modelu i przechodząc do Properties.

Rys. 7. Własności modelu

Okno jest podzielone na trzy kolumny: Attribute(Atrybuty), Value(Wartość), oraz Information(Informacja danego wiersza).

label (etykieta): nazwa modelu;

pen (pióro): kolor i rozmiar kontur modelu;

image path (ścieżka obrazu);

input (wejście): liczba ścieżek wejściowych;

output (wyjście): liczba ścieżek wyjściowych;

python path (ścieżka pliku Python).

29

3.2.2 DEVS

DEVS jest językiem opisu symulacji. To modularny i hierarchiczny zbiór zasad dla modelowania i analizowania systemów opartych na zdarzeniach dyskretnych (opisanych tabelami stanów przejść) oraz systemów stanów ciągłych (opisanych równaniami różniczkowymi).

DEVS znacznie ułatwia tworzenie symulacji. Jego główna zaleta to skrócenie czasu implementacji - określamy zbiory zdarzeń wejściowych, przejściowych oraz wyjściowych, a także zdarzenia, które wpływają na zmianę stanu układu. DEVS usprawnia także testowanie (modele wysokiej jakości, symulacje 2D, 3D), konserwację systemu, ułatwia eksperymentowanie (prosta zmiana danych wejściowych i parametrów symulacji), automatyzuje uruchamianie równoległe lub czasu rzeczywistego [3]. 3.2.3 Podsumowanie rozdziału

Użytkownik poznał podstawowe rozszerzenia plików w DEVSimPy, tworzenie podstawowego modelu atomowego, a także jego budowę i właściwości. Instrukcja wyjaśniła czym jest pojęcie DEVS, do czego służy i jakie ma znaczenie dla dziedzin nauki.

30

3.3 Biblioteka DEVSimPy

W tej instrukcji użytkownik powinien poznać podstawowe składowe biblioteki DEVSimPy. Informacje dotyczą także prawidłowego zaimportowania biblioteki.

3.3.1 Elementy biblioteki

Biblioteki umożliwiają gromadzenie modeli struktury. DEVSimPy pozwala na tworzenie i zarządzanie bibliotekami za pomocą panelu sterowania. Dane są reprezentowane w postaci drzewa katalogów, które są rozwijane i zwijane. Treść biblioteki składa się z trzech typów wzorów:

pliki Python (klasa PyDEVS): reprezentowane przez logo Python - ;

pliki AMD (modele atomowe): ikona w postaci sześcianu - ;

pliki CMD (modele połączone): reprezentowane przez zbiór kostek - ; Modele można oczywiście przeciągnąć lewym przyciskiem myszki na okno interfejsu.

Rys. 8. Biblioteka w DEVSimPy

Biblioteki są zapisywane domyślnie w katalogu o nazwie „Domain”. Katalog ten znajduje się w katalogu roboczym DEVSimPy. By dostać się do okna importowanych bibliotek należy kliknąć prawym przyciskiem myszki na Panelu kontrolnym i wybrać Import. Lista dostępnych bibliotek w DEVSimPy prezentuje się po przez nazwę, rozmiar oraz ścieżkę dostępu. Biblioteki mogą być przechowywane na dysku twardym lub w sieci. Dodatkowo niektóre elementy biblioteki są kompresowane m.in. pliki graficzne modeli co pozwala zachować separację między zachowaniem, a widokiem modeli. Podsumowując tą kwestię DEVSimPy pozwala na wymianę komponentów bibliotek.

31


Użytkownik poznał możliwości biblioteki w DEVSimPy oraz trzy podstawowe typy wzorów. Dowiedział się jak zaimportować bibliotekę oraz o możliwości przechowywania jej na dwóch płaszczyznach: dysk, sieć.

3.4 Prosty przykład symulacji

Instrukcja dotyczy podstawowej symulacji w programie DEVSimPy. Pokazuje podstawową zależność między elementami biblioteki i ich funkcjonalność.

3.4.1 Przygotowanie do symulacji

Przykład prostej symulacji modeli, które są elementami biblioteki DEVSimPy. Jest to generator zdarzeń (RandomGenerator) połączony z kolektorem wiadomości (MessageCollector). Należy połączyć dwa modele. Klikając lewym przyciskiem na generator wyświetlą się porty. W łatwy sposób można przeciągnąć połączenie od generatora do portu kolektora (rys. 9):

Rys. 9. Połączenie dwóch modeli

Po połączeniu, klikamy w pasku narzędzi Simulation. W oknie symulacji czas trwania ustawiamy przykładowo na wartość 10. Naciskamy Run. Zamykamy okno symulacji. Klikamy podwójnie lewym przyciskiem myszki na MessageCollector. Otwiera się okno, które przedstawia zbiór danych jakie otrzymał model Message Collector.

32

Rys. 10. Wynik symulacji w „MessagesCollector”

Symulacja przebiegła pomyślnie. Model RandomGenearator jak sama nazwa wskazuje wygenerował losowe wiadomości w postaci liczb w czasie 10. MessageCollector odebrał wydarzenia (Event) inkrementowane od wartości 0 do 10. Wiadomość (Message) zawiera wartość randomową od 0 do 10, a także czas odebrania wiadomości. Widać, że wartość odbierana jest cyklicznie co sekundę.


Użytkownik zapoznał się z pierwszą, podstawową symulacją w DEVSimPy. Wszystkie modele symulacji to podstawowe składowe biblioteki.

33

3.5 Symulacja linii produkcyjnej

Symulacja dotyczy urządzeń w linii produkcyjnej w fabryce, która wykonuje operacje mechaniczne podzielone na części. Konkretne urządzenie odbiera dane wejściowe z poprzedniego etapu wytwarzania w linii produkcyjnej ze stałą szybkością. Od czasu do czasu następuje awaria urządzenia, co prowadzi do utraty przetwarzanego materiału. Instrukcja zawiera opis użytych modeli w symulacji oraz opis efektu symulacji.

3.5.1 Elementy projektu

Sam projekt składa się z trzech elementów:

- Generator_produkcyjny;

- Maszyna;

- Urządzenie_odbierające.

Rys. 11. Powiązane ze sobą modele gotowe do symulacji

34

Rys. 12. Własności modelu „Generator_produkcyjny”

3.5.2 Symulacja

By uruchomić symulacje należy w pasku narzędzi kliknąć Simulation. Czas trwania ustawiamy przykładowo na wartość 40. Przycisk Run uruchamia symulację. Gdy symulacja zakończy się, uruchamiamy Urządzenie_Odbierające poprzez podwójne kliknięcie, by zobaczyć jaki wynik linii produkcyjnej otrzymano.

Rys. 13. Wynik Symulacji w „Urządzenie_Odbierające”

Symulacja przebiegła pomyślnie. Pierwszą prace otrzymano w czasie 0,2. Jest to czas jaki musi poświęcić Maszyna by wysłać proces do urządzenia odbierającego. Druga praca została uzyskana w czasie 1.40. Okresowo dodawany jest czas 1.2. Po wykonaniu 5 prac, następuje awaria maszyny. Tryb naprawy trwa 10 sekund. Generator wysyła dalej elementy, ale zostaje zachowane tylko 5 w schowku Maszyny. Reszta elementów przepada. Gdy maszyna zostaje naprawiona, elementy zaczynają przepływać do kolektora. W pierwszej kolejności opróżniany jest schowek z kolejki FIFO. Czas jaki jest na to potrzebny to 0.2. Po opróżnieniu schowka, przesyłane są elementy już bezpośrednio od Generatora.

35


Symulacja „Linia produkcyjna” pokazała użytkownikowi charakterystykę systemu symulacyjnego DEVSimPy. Modyfikacja kodu modeli pozwala na rozszerzenie/rozbudowę symulacji. Symulacje, które były poruszane w tym programie dotyczą problemów aktualnych.

3.6 Symulacja Sztucznej Sieci Neuronowej (SSN)

Celem tej instrukcji jest przeprowadzenie procesu tworzenia sieci neuronowej oraz realizację alternatywy wykluczającej (XOR) w programie DEVSimPy. Użytkownik pozna podstawowy problem związany z bramką logiczną XOR – przedstawienie układu logicznego na płaszczyźnie. Instrukcja zawiera informacje o bibliotece użytej w symulacji, przedstawiony jest schemat zadania oraz jego opis.Ostatnim elementem jest symulacja oraz podsumowanie.

3.6.1 Bramka XOR

Funkcja XOR przyjmuje wartość 1 tylko wtedy, kiedy albo argument A, albo argument B jest równy 1. Gdy oba argumenty są równe jednakowe, funkcja przyjmuje wartość 0. Można to przedstawić w tabeli:

Rys. 14. Tabela XOR

36

3.6.2 Problem symulacji układu logicznego XOR

Można oczywiście przedstawić funkcję XOR jak każdą inną na płaszczyźnie. I tu powstaje problem:

Rys. 15. Zakres danych funkcji XOR

Od razu widać, że nie da się wyznaczyć linii oddzielającej przestrzeń danych na 2 mniejsze, z których jedna odpowiada sygnałowi 1 na wyjściu, a druga 0 na wyjściu. Nie da się tego zrealizować, stosując podział za pomocą jednej prostej.

3.6.3 Biblioteka symulacji Sieci Neuronowej

Biblioteka obejmuje następujące modele:

DeltaOutput_Weight: model odpowiedzialny za obliczenie wymaganej wagi uczenia się (nie wymaga konfiguracji);

ErrorGenerator: model oblicza wartość błędu pomiędzy wartością wychodzącą a oczekiwaną (nie wymaga konfiguracji);

Input: pozwala na instancję warstwy wejściowej (nie wymaga konfiguracji);

Hidden: model odpowiadający za warstwę ukrytą;

Output: odpowiada za instancję warstwy wyjściowej.

37

3.6.4 Sieć neuronowa

Rys. 16. Układ modeli Sztucznej Sieci Neuronowej

Sieć neuronowa uczy się funkcji XOR na podstawie danych w zależności od pliku inputl.dat oraz outputl.dat (odpowiednio zawartych w modelach inputL i outputL). Sprawdzenie poprawności odbywa się w inputv.dat, output.dat (inputlV, outputV). Model Input podłączony jest do Hidden dwoma linami. Model Hidden podłączony jest do modelu Output. Liczba połączeń pomiędzy dwoma modelami odpowiada liczbie neuronów, które chcemy wykorzystać. DeltaOutput_Weight oblicza odpowiednią wagę dla odpowiedniej warstwy i ją przechowuje.

Modele typu Output połączone są z ErrorGenerator by obliczyć różnicę między uzyskanym, a spodziewanym wynikiem (dostarczonym przez outputL i outputV) tj. wartość wyjściową funkcji XOR.

38

3.6.5 Symulacja

By uruchomić symulacje należy w pasku narzędzi kliknąć Simulation. Czas trwania ustawiamy przykładowo na wartość 1000. Przycisk Run uruchamia symulację. Wynikiem symulacji będzie wykres i dlatego też ustawiony czas jest na 1000 iteracji by lepiej zobrazować wynik symulacji. By uruchomić wynik symulacji, klikamy podwójnie lewym przyciskiem myszki na ErrorGenerator.

Doświadczenie pozwala podkreślić wzrost szybkości uczenia się systemu przez modyfikację parametrów:

Rys. 17. Wynik- wykres symulacji


Dzięki symulacji Sztuczne Sieci Neuronowe (SSN) w DEVSimPy użytkownik przekonał się jak złożonebadania można przeprowadzać w tym systemie i jak różne dziedziny nauki mogą one dotknąć.

39

4. Implementacja instrukcji ćwiczeniowych

Implementacja instrukcji ćwiczeniowych zawiera szczegółowe rozwinięcie wszystkich etapów poprzedniego rozdziału. Szczegółowy opis instalacji, opis interfejsu, zakres pracy poszczególnych elementów. Aplikacje ćwiczeniowe, które przygotowano w tym środowisku zostały opisane, przetestowane i wyciągnięto odpowiednio wnioski.

4.1 Instalacja i konfiguracja

DEVSimPy jest projektem typu Open source opracowanym z API w wxPhyton na podstawie licencji GNU GPL v3. Jest w pełni przenośny i nie wymaga wcześniejszej instalacji. DEVSimPy można pobrać pod następującym adresem: https://code.google.com/p/devsimpy/ [4]. W zależności od platformy użytkownika (systemu), DEVSimPy wymaga zainstalowania dodatkowych narzędzi, bibliotek co zostanie omówione poniżej: WINDOWS W systemie Windows są dwa sposoby uruchomienia DEVSimPy: w wersji binarnej lub z pliku źródłowego [4]. W wersji binarnej nie jest wymagane instalowanie dodatkowych narzędzi. Wszystkie pliki są zamieszczone w spakowanym archiwum, po wypakowaniu użytkownik uruchamia plik .exe. Warto zaznaczyć, że starsze wersje (DEVSimPy 2.2) posiadają gotowy plik .exe. Najnowsze wersje (2.7, 2.8, 2.9, 3.0) wymaga uruchomienia z pliku źródłowego.

Potrzebne narzędzia [4]:

Python, wersja 2.5 + (wymagane);

wxPython wersja 2.6 + (wymagane);

biblioteki Scipy, NumPy (opcjonalnie) do niektórych prac naukowych;

wtyczka Networkx (opcjonalnie).

40

LINUX/UNIX

DEVSimPy w systemie Linux wymaga zainstalowanie niektórych pakietów [4]:

Python, wersja 2.5+;

Python – wxversion;

Wxgtk 2.6 lub python – wxgtk 2.8;

Python – scipy, python-matplotlib (opcjonalnie) do niektórych prac naukowych;

python-NetworkX, python-profiler (opcjonalnie) dla niektórych wtyczek.

4.1.1 Instalacja DEVSimPy w wersji 2.8 w systemie Windows XP

- Instalacja Python w wersji 2.7 (rys.18):

Rys. 18. Instalacja Python 2.7

41

- Instalacja biblioteki wxPython 2.8 (rys.19) dla Python w wersji 2.7:

Rys. 19. Instalacja biblioteki wxPython 2.8

Po zainstalowaniu tych bibliotek i dekompresji archiwum DEVSimPy_2.8.zip, w wypakowanym folderze należy znaleźć plik źródłowy devsimpy.py, edytować go w IDLE:

Rys. 20. Uruchomienie pliku DEVSimPy w Pythonie

42

Następnie, by wykonać a jednocześnie uruchomić DEVSimPy (rys.21) należy wcisnąć F5:

Rys. 21. Uruchomienie programu DEVSimPy

4.2 Pierwsze kroki z DEVSimPy

W tym podpunkcie zostanie opisany główny interfejs w DEVSimPy

Rys. 22. Okno dialogowe

43

Okno interfejsu: Obszar służący do budowania, projektowania schematów modeli. Okna są wyświetlane na zasadzie kart, gdzie można dodawać i usuwać. Domyślnie każda „karta” to diagram, przy starcie programu automatycznie tworzy się „Diagram0”;

Panel kontrolny: Zorganizowany jest w formie dwóch zakładek. Pierwsza zarządza bibliotekami, druga zarządza właściwościami wybranych modeli. Biblioteki mogą być organizowane w formie drzewa. W karcie właściwości możliwe jest szybkie edytowanie szablonów wybranych w oknie interfejsu;

Pasek narzędzi: określa najważniejsze skróty takie jak:

- dodawanie diagramu;

- otwarcie istniejących diagramów;

- druk bieżącego diagramu;

- zapisanie diagramu;

- zapisanie diagramu jako;

- przywrócenie poprzednich działań;

- przywrócenie dalszych działań;

- powiększanie/zmniejszenie okna interfejsu;

- symulacja bieżącego modelu;

- wybór typu połączeń pomiędzy modelami.

Pasek stanu: służy do informowania użytkownika o bieżącym działaniu takim jak: Symulacja, kopiuj/wklej, modyfikacja schematu, etc.

44

4.2.1 Menu główne

Niektóre opcje opisane poniżej mają swoje skróty klawiszowe. Menu główne DEVSimPy organizowane jest w następujący sposób:

Rys. 23. Menu „File” w DEVSimPy

File(Plik):

- Open (Otwórz diagram/schemat);

- Recent files (Najnowsze pliki: Otwarcie ostatnich 5 używanych plików);

- Save (Zapisz);

- SaveAs (Zapisz jako);

- Preview/Print/ScreenShot (Podgląd/Druk/Zrzut ekranu);

- Quit (Wyjście).

45

Rys. 24. Menu „Diagram” w DEVSimPy

Diagram-zarządzanie oknem interfejsu:

- New (Nowy diagram);

- Rename (Zmiana nazwy/edycja);

- Detach (Odłączenie/oddzielenie schematu);

- Zoom/UnZoom/AnnuleZoom (zarządzanie diagramem powiększenie / pomniejszenie / powrót do skali pierwotnej);

- Debugger (Kompilacja, wykonywane automatycznie przed symulacją);

- Simulate (Symulacja);

- Add Contsants (Dodawanie stałych do diagramów);

- Priority (Nadanie stanu priorytetu danemu modelowi diagramu);

- Information (Informacje o danym diagramie);

- Clear (Wyczyszczenie zawartości diagramu);

- Close (Zamknięcie diagramu).

46

Rys. 25. Menu „Show” w DEVSimPy

Show (wyświetlenie/ukrycie paneli programu):

- Control (Wyświetlenie panelu biblioteki-domyślnie);

- Console (Wyświetlenie okna dialogu Pythona-przydatne do debuggowania);

- Simulation (Wyświetla symulacje);

-Tools Bar (Wyświetla/ukrywa pasek narzędzi);

Rys. 26. Menu „Perspectives” w DEVSimPy

Perspectives: Służy do zarządzania perspektywą pracy. Możliwość dodawania i usuwania takich obszarów.

Rys. 27. Menu „Options” w DEVSimPy

47

Options: zarządzanie językiem używanego interfejsu. Wejście w zaawansowane opcje DEVSimPy.

Rys. 28. Menu „Help” w DEVSimPy

Help: Uzyskanie pomocy online, bądź możliwość wysłania e-maila do autora, informacje o DEVSimPy.

48

4.3 Podstawowy model: model atomowy, budowa, właściwości

Rozdział zawiera informacje na temat podstawowych modeli w programie. Opisano budowę, właściwości oraz własności poszczególnych elementów.

4.3.1 Model atomowy

Stworzenie podstawowego modelu atomowego w DEVSimPy odbywa się za pomocą dwóch sposobów [5]:

Za pomocą menadżera tworzenia modelu;

Poprzez stworzenie i zapisanie pliku kompatybilnego z PyDEVS python i przeniesienie go do okna interfejsu.

Pierwsza procedura zostanie opisana poniżej.

Menadżer tworzenia modelu:

DEVSimPy Model Generator (rys.29) uruchamia się przez kliknięcie prawym przyciskiem myszki na tle okna interfejsu i wybraniu New. Wybieramy opcję modelu atomowego (ustawienie domyślne) i klikamy Next:

Rys. 29. Okno wyboru modelu

49

W drugim oknie (rys.30) należy określić właściwości grafiki i cechy behawioralne modelu. Odpowiednio:

1. Label (Nazwa) – Atomic_Name (domyślnie);

2. Specific Behavior (Cechy behawioralne) – Default (domyślnie);

3. Inputs (wejścia) – 1 (domyślnie);

4. Outputs (wyjścia) – 1 (domyślnie);

5. Default python file (domyślny plik python) – wyłączona opcja;

6. No plugin file (brak dodatkowych wtyczek) – wyłączona opcja.

Rys. 30. Model Generator

Po przejściu do następnego okna można wybrać nazwę modelu (domyślnie atomic_model.amd) i lokalizację pliku, który będzie przechowywał informację o modelu.

50

Model atomu (rys.31) pojawi się w oknie interfejsu. Mała ikona w kształcie prostokąta, można manipulować wielkością. Posiada wybrane wcześniej porty wejściowe i wyjściowe. W przykładzie [3] odpowiednio in0, out0.

Rys. 31. Graficzny blok modelu atomu

Jak wcześniej wspomniano plik modelu atomu .amd w rzeczywistości zawiera skompresowany plik przejścia i pliku graficznego (w formacie .dat) i plik Python zawierający klasę modelu (plik.py) [3].

Rys. 32. Budowa modelu .amd

51

4.3.2 Własności modelu atomowego

Po utworzeniu modelu atomu można uzyskać dostęp do właściwości obiektu. Klikając odpowiednio prawym myszki na tle modelu i przechodząc do Properties. Okno dialogowe (rys.33) jest pokazane poniżej:

Rys. 33. Własności modelu atomowego

Okno jest podzielone na trzy kolumny: Attribute (Atrybuty), Value (Wartość), oraz Information (Informacja danego wiersza).

- Label (Etykieta): nazwa modelu;

- Pen (Pióro): kolor i rozmiar kontur modelu;

- Image path (Ścieżka obrazu);

- Input (Wejście): liczba ścieżek wejściowych;

- Output (Wyjście): liczba ścieżek wyjściowych;

- Python path (Ścieżka pliku Python);

52

Behawioralne atrybuty są to parametry konstruktora z klasy pyDEVS [3]. Import z tych parametrów jest automatyczny w DEVSimPy. Plik ten jest dostępny tylko do odczytu, w dolnym bloku okna. Użytkownik może poruszać się za pomocą funkcji przejścia przez powyższą listę wyboru (rys. 34). Użytkownik może zmienić wartości pól atrybutów poprzez kliknięcie odpowiedniej komórki. W zależności od rodzaju wartości, atrybut zostanie wywołany.

Rys. 34. Parametry konstruktora z klasy pyDEVS.

Możliwa jest też modyfikacja kodu modelu atomowego [5]. By dostać się do edytora kodu (rys.35) należy na tle modelu kliknąć prawym przyciskiem myszki, przechodząc odpowiednio Edit -> Model. Edytor pokazuje kod Pythona stworzonego modelu. Począwszy od informacji o nazwie pliku, nazwie modelu, autorze, dacie utworzenia i licencji. Następnie import niezbędnych danych do modelu klasy. Klasa posiada konstruktor (__init __ (Self)) o określonym atrybucie self.state do definiowania zmiennych stanu. Przejścia i funkcje są realizowane za pomocą metod intTransition(self) i extTransition (self). Funkcja wyjścia to outputFnc (self). A metoda licząca czas to timeAdvance (self).

53

Rysunek 35 poniżej pokazuje edycję kodu modelu atomowego:

Rys. 35 Edytor kodu z przykładem modelu

54

4.3.3 Ogólne funkcje

Rozdział na temat głównych elementów zarządzania procesem symulacji jak i całym programem DEVSimPy.

4.3.4 Menadżer symulacji

W DEVSimPy menadżer symulacji (rys.36) jest wywoływany poprzez kliknięcie ikonki na pasku narzędzi.

Rys.36. Menadżer symulacji

W górnej części okna wyświetlany jest czas symulacji (domyślnie 10). Dla jednostki predefiniowanej, użytkownik może definiować wartość czasu symulacji w zależności od zachowania modelu. Symulacja rozpoczyna się po kliknięciu przycisku Run. Pasek postępu, który pokazuje postęp symulacji wyświetlany jest w dolnym rogu okna. Przycisk Suspend pozawala na zawieszenie symulacji i edytowanie szablonu. Jest to wielki atut tej platformy. Symulacja ponownie jest wznawiana przyciskiem Run. Przycisk Stop zatrzymuje symulację całkowicie. Za pomocą przyciska Log można wygenerować krótki raport po symulacji [3].

4.3.5 Stałe modeli

W DEVSimPy użytkownik może zdefiniować stałe, które wchodzą w skład modeli. Aby to zrobić, należy kliknąć prawym przyciskiem myszki na tle okna interfejsu i wybrać Add constants (rys.37). Dodawanie i usuwanie wartości odbywa się za pomocą przycisków odpowiednio Add i Remove. Możliwe jest importowanie i eksportowanie plików typu CSV (przyciski Import, Export) [5].

55

Rys. 37. Menadżer wartości stałych

4.3.6 Opcje zarządzania

Menu opcji zarządzania zapewnia w DEVSimPy wybór języka a przede wszystkim wybór określonych preferencji [3]. Okno dialogowe otwiera się po przez kliknięcie na pasku narzędzi Options a następnie Preferences. Preferencje (rys. 38) wymienione są w czterech częściach: General, Simulation, Editor, Plugins. Karta General zarządza opcjami związanymi z interfejsem.

Rys.38. Menadżer ustawień w DEVSimPy

56

Karta Simulation (rys. 39) zarządza opcjami symulacji jak aktywacja dźwięku na koniec symulacji oraz strategie symulacji.

Rys. 39. Karta „Simulation” w DEVSimPy

Karta Editor (rys. 40) obsługuje szablony kodu języka Python.

Rys. 40. Karta „Editor” w DEVSimPy

Karta Plugins (rys. 41) obsługuje konfiguracje zarządzania oraz aktywacji i dezaktywacji wtyczek.

Rys. 41. Karta „Plugins” w DEVSimPy

57

4.3.7 Biblioteka DEVSimPy

Biblioteki (rys.42) umożliwiają gromadzenie modeli struktury. DEVSimPy pozwala na tworzenie i zarządzanie bibliotekami za pomocą panelu sterowania. Dane są reprezentowane w postaci drzewa katalogó, które są rozwijane i zwijane. Treść biblioteki składa się z trzech typów wzorów [3]:

pliki Python (klasa PyDEVS): reprezentowane przez logo Python - ;

pliki AMD (modele atomowe): ikona w postaci sześcianu - ;

pliki CMD (modele połączone): reprezentowane przez zbiór kostek - ;

Modele można oczywiście przeciągnąć lewym przyciskiem myszki na okno interfejsu.

Rys. 42. Biblioteka w DEVSimPy

58

W powyższym przykładzie, DEVSimPy oferuje trzy typy danych bibliotek:

Collector;

Generator;

PowerSystem;

Każda z tych bibliotek posiada zestaw modeli. Biblioteka „Collector” to zbiór modeli atomowych. Składa się z „MessageCollector” do przechowywania wiadomości które zostały przekazane podczas symulacji (ew. błędy). Biblioteka „Generator” posiada tylko modele typu klasy PyDEVS. „PowerSystem” to zbiór modeli połączonych i atomowych [3].

W dolnej części okna możliwie jest przeszukanie biblioteki w celu znalezienia danego modelu. Jeżeli użytkownik chce usunąć bibliotekę może kliknąć prawym przyciskiem myszki na dany zbiór i przejść do Delete. Usuwanie ma tylko wpływ na usunięcie z listy. Źródła są zachowane. Podmenu umożliwia również dostęp do dokumentacji modułu, jeżeli została taka sporządzona.

4.3.8 Import biblioteki

Biblioteki są zapisywane domyślnie w katalogu o nazwie „Domain”. Katalog ten znajduje się w katalogu roboczym DEVSimPy. By dostać się do okna importowanych bibliotek (rys. 43) należy kliknąć prawym przyciskiem myszki na Panelu kontrolnym i wybrać Import. Lista dostępnych bibliotek w DEVSimPy prezentuje się po przez nazwę, rozmiar oraz ścieżkę dostępu.

Rys. 43. Import biblioteki

Jeżeli użytkownik chce importować biblioteki, która nie jest obecna w oknie może przeszukać bibliotekę podając ścieżkę w polu w dolnej części okna, a następnie dodać. Można wstawić w polu także odpowiedni odsyłacz ftp, wtedy DEVSimPy pobierze odpowiednie biblioteki z serwera.

59

4.3.9 Tworzenie biblioteki

Tworzenie biblioteki [3] wymaga zestawieniu plików/podkatalogów przechowywanych w głównym katalogu, który będzie tworzył bibliotekę. Aby ten katalog mógł być dostępny w Panelu sterowania, niektóre warunki muszą być spełnione:

W każdym katalogu musi być zdefiniowany plik python o nazwie „_init_.py”. W pliku powinna być utworzona lista obiektów publicznych które pojawią się w DEVSimPy. Dla przykładu biblioteka Collector:

Rys. 44. Biblioteka „Collector”

Katalog główny musi być umieszczony w katalogu Domain, wtedy automatycznie zostanie wykryty na liście biblioteki, które mogą być importowane do menadżera w DEVSimPy.

60

4.4 Przykład symulacji modeli

Przykład prostej symulacji modelów które są elementami biblioteki DEVSimPy. Jest to generator zdarzeń (RandomGenerator) połączony z kolektorem wiadomości (MessageCollector).

Modele w łatwy sposób mogą zostać umieszczone w oknie interfejsu. Wystarczy metodą przeciągnij i puść (ang. Drag and drop) wstawić bloki odpowiednio (rys. 45):

Rys. 45. Umieszczenie modeli w oknie interfejsu

Następnie należy połączyć dwa modele. Klikając lewym przyciskiem na generator wyświetlą się porty. W łatwy sposób można przeciągnąć połączenie od generatora do portu kolektora (rys. 46):

Rys. 46. Połączenie dwóch modeli

61

Po połączeniu, klikamy w pasku narzędzi Simulation. W oknie symulacji czas trwania ustawiamy przykładowo na wartość 10. Naciskamy Run (rys. 47):

Rys. 47. Uruchomienie przykładowej symulacji

Zamykamy okno symulacji. Klikamy podwójnie lewym przyciskiem myszki na MessageCollector. Otwiera się okno które przedstawia zbiór danych jakie otrzymał model Message Collector (rys. 48):

Rys. 48. Wynik symulacji w „MessagesCollector”

62

Symulacja przebiegła pomyślnie. Model RandomGenearator jak sama nazwa wskazuje wygenerował losowe wiadomości w postaci liczb w czasie 10. Tak jak wspomniano w innym rozdziale, nie ma predefiniowanej jednostki czasowej. Final time (rys. 47) jest interpretowany jako wartość zachowania się modelu jaką chce osiągnąć użytkownik. Czas trwania symulacji jest pokazany w dolnej części okna (rys. 47) w jednostce czasowej sekundy. MessageCollector (rys. 48) odebrał wydarzenia (Event) inkrementowane od wartości 0 do 10. Wiadomość (Message) zawiera wartość randomową od 0 do 10 a także czas odebrania wiadomości. Widać że wartość odbierana jest cyklicznie co sekundę.

4.4.1 Debugowanie kodu

Debugowanie czyli proces systematycznego redukowania liczby błędów w oprogramowaniu jest ważnym zadaniem w procesie wdrażania w DEVSimPy [3]. Po dostaniu się do okna modyfikacji modelu (rozdział 4.2) mamy możliwość zmiany/modyfikacji kodu. Gdy pojawi się błąd w modelu (rys.49), informacje są wyświetlane na pasku. Stan informuje użytkownika o rodzaju błędu i wiersz gdzie występuje składnia (linia 76). To menadżer debugowania zapyta użytkownika czy chce on kierowania do odpowiedniej linii błędu.

Rys. 49. Debugowanie kodu w DEVSimPy

Jest również możliwość debugowania przez użytkownika, gdy rozpoczyna symulację. Ten krok przewiduje wykrycie błędu, gdy model pochodzi z biblioteki czy też nie był modyfikowany.

63

4.5 Symulacja linii produkcyjnej

Rozdział przedstawia pierwszą rozbudowaną symulację linii produkcyjnej. Opisano najważniejsze składowe tego projektu, zasady działania oraz wyciągnięto odpowiednie wnioski.

4.5.1 Wstępne informacje

Symulacja dotyczy urządzeń w linii produkcyjnej w fabryce, która wykonuje operacje mechaniczne podzielone na części. Konkretne urządzenie odbiera dane wejściowe z poprzedniego etapy wytwarzania w linii produkcyjnej ze stałą szybkością. Od czasu do czasu następuje awaria urządzenia, co prowadzi do utraty przetwarzanego materiału. Wymaga to też interwencji technika maszyny. Napływ produkowanych elementów z innych urządzeń jest niezależny. Elementy nie przetworzone przez zepsutą maszynę nie mogą być akceptowane i są tymczasowo przechowywane w specjalnym miejscu. Dostępny schowek ogranicza przechowywanie do 5 części. Reszta części, która się nie zmieściła do schowka zostają po prostu złomowane. Przetwarzanie elementów zostanie wznowione, gdy urządzenie zostanie pomyślnie naprawione. W pierwszej kolejności zostaną przetworzone elementy ze schowka. Technicy odpowiedzialni za naprawę maszyn w fabryce mają również inne obowiązki jak naprawa urządzeń na innych liniach produkcyjnych, czy prace konserwacyjne. Prace konserwacyjne na czas napraw maszyn zostają wstrzymane.

Rys. 50. Powiązane ze sobą modele gotowe do symulacji

64

Sam projekt składa się z trzech elementów:

- „Generator_produkcyjny”: odpowiada za wysyłanie części (zadań) z odpowiednio założonym czasem. Czas dostawy części to: 1,2. Wszystkie zadania obsługiwane przez maszynę wymagają czasu: 0,2 (rys. 51) ;

- „Maszyna”: otrzymuje odpowiednio wysłane części. Posiada schowek w razie awarii maszyny. Zdolność przechowywania części to: 5. Awaria występuje gdy przez maszynę przejdzie 5 części. Czas naprawy to 10 (rys. 52);

- „Urządzenie_odbierające”: Pokazuje gotowy produkt w jakim czasie został odebrany.

Rys. 51. Własności modelu „Generator_produkcyjny”

Rys. 52. Własności modelu „Maszyna”

65

class ProductionLine(DomainBehavior):

""" ProductionLine atomic Model.

"""

def __init__(self, p_periode = 1.2, job_duration=0.2):

"""

@param p_periode : Parts supply timing

@param job_duration = job task duration

"""

DomainBehavior.__init__(self)

### local copy

self.periode = p_periode

self.jd = job_duration

### init state

### production line is active right away (sigma=0)

self.state = {'status':'ACTIVE','sigma':0}

### reset the static variable before new simulation

Job.ID = 0

def intTransition(self):

### production line is passive during p_periode

self.state = {'status':'PASSIVE','sigma':self.periode}

def outputFnc(self):

### production line send message with 0 value on its port 0

self.poke(self.OPorts[0], Message(Job(self.jd), self.timeNext))

###

def timeAdvance(self):

return self.state['sigma']

###

def __str__(self): return "ProductionLine"

Listing. 1. Fragment kodu modelu “Generator_produkcyjny”

66


### if the machine is active, it becomes passive until an external message

if self.state['status'] == 'ACTIVE':

self.state['status'] = 'PASSIVE'

self.state['sigma'] = INFINITY

### if the machine is in the scrapped mode, it goes to the push mode immediately

elif self.state['status'] == 'SCRAPPED':

self.state['status'] = 'PUSH'

self.state['sigma'] = 0

### if the machine is in the push mode, it goes to the push mode until there are jobs to push

elif self.state['status'] == 'PUSH':

### job to push

job = self.state['buffer'].pop()

### if there is no jobs to push, go to passive mode

if len(self.state['buffer']) == 0:

self.state['status'] = 'PASSIVE'

self.state['sigma'] = INFINITY

self.state['f_cpt'] = 0

### if there is a job to push, achieve this one

else:

self.state['status'] = 'PUSH'

self.state['sigma'] = job.duration

### just for output message

self.out_msg = job

Listing. 2. Fragment kodu modelu “Maszyna”

67

Standardowy model MessageCollector pochodzi z biblioteki Collector.

def extTransition(self, *args):

for port in self.IPorts:

### adapted with PyPDEVS

if hasattr(self, 'peek'):

msg = self.peek(port)

np = port.myID

else:

inputs = args[0]

msg = inputs.get(port)

np=port.port_id

if msg:

### filename

fn = "%s%d%s"%(self.fileName, np, self.ext)

with open(fn,'a') as f: f.write("%s\n"%(str(msg)))

del msg

self.state["sigma"] = 0

self.state["status"] = 'ACTIF'

return self.state

###


self.state["status"] = 'IDLE'

self.state["sigma"] = INFINITY

return self.state

###

def timeAdvance(self):return self.state['sigma']

###

def __str__(self):return "MessagesCollector"

Listing. 3. Fragment kodu modelu “Urządzenie_odbierające”

68

4.5.2 Symulacja

By uruchomić symulację należy w pasku narzędzi kliknąć Simulation. Czas trwania ustawiamy przykładowo na wartość 40. Przycisk Run uruchamia symulację. Warto tutaj nadmienić jaką wartość wnoszą odpowiednio ustawione wtyczki w procesie symulacji . Włączona wtyczka Verbose pozwala pokazać jak zachowuje się badany proces w trakcie całej symulacji. O tym w dalszej części rozdziału.

Gdy symulacja zakończy się, uruchamiamy „Urządzenie_Odbierające” po przez podwójne kliknięcie by zobaczyć jaki wynik linii produkcyjnej otrzymano (rys. 53).

Rys. 53. Wynik symulacji w „Urządzenie_Odbierające”

69

Symulacja przebiegła pomyślnie. Pierwszą prace otrzymano w czasie 0,2. Jest to czas jaki musi poświęcić „Maszyna” by wysłać proces do urządzenia odbierającego. Druga praca została uzyskana w czasie 1.40. Okresowo dodawany jest czas 1.2. Po wykonaniu 5 prac, następuje awaria maszyny. Tryb naprawy trwa 10 sekund. Generator wysyła dalej elementy ale zachowane zostają tylko 5 w schowku „Maszyny”. Reszta elementów przepada. Gdy maszyna zostaje naprawiona, elementy zaczynają przepływać do „Kolektora”. W pierwszej kolejności opróżniany jest schowek z kolejki FIFO. Czas jaki jest na to potrzebny to 0.2. Po opróżnieniu schowka, przesyłane są elementy już bezpośrednio od „Generatora”.

By bardziej to zilustrować, posłuży do tego włączona wtyczka Verbose. Po uruchomieniu procesu symulacji pojawia się mini okno o nazwie Blink Logger. Jest to tzw. „Rejestrator zdarzeń” (rys. 54).

Rys. 54. Okno „Blink Logger”

Dane wyświetlane w oknie dotyczą linii produkcyjnej. Całego procesu realizacji i symulacji. Klikając przycisk Dalej wykonujemy następny krok symulacji np. Wysłanie elementu z „Generatora” do „Maszyny” (rys. 55).

Rys. 55. Przesyłane dane z „Generatora” do „Maszyny”

70

Dodatkowo, poszczególne etapy realizacji podczas „ręcznej symulacji” zobrazowane są w postaci zmiany koloru danego modelu (bloku) by bardziej zilustrować sam przebieg symulacji, a co za tym idzie łatwiej zrozumieć i przeanalizować (rys. 56, 57, 58).

Rys. 56. Wizualizacja symulacji etapu I

Rys. 57. Wizualizacja symulacji etapu II

Rys. 58. Wizualizacja symulacji etapu III

4.5.3 Podsumowanie symulacji

Podsumowując, DEVSimPy oferuje dynamiczną symulację. Sam proces symulacji można zawiesić w celu interakcji z innymi modelami. Tworzy to potężną siłę i w dobie dzisiejszych czasów daje możliwość do nieoczekiwanych analiz zachowań.

71

4.6 Symulacja sieci neuronowych

Kolejny Rozdział przedstawia symulację Sztucznych Sieci Neuronowych (SSN).

4.6.1 Wstępne informacje

Celem tej symulacji jest przeprowadzenie procesu tworzenia sieci neuronowej oraz realizację alternatywy wykluczającej (XOR) w programie DEVSimPy [1].

Sieć neuronowa to ogólna nazwa struktur matematycznych i ich programowych lub sprzętowych modeli, realizujących obliczenia lub przetwarzanie sygnałów poprzez rzędy elementów, zwanych sztucznymi neuronami, wykonujących pewną podstawową operację na swoim wejściu [6]. Celem wykonywania tych operacji jest nauczenie zachowania systemu w zależności od elementów na wejściu i wyjściu. Istnieje kilka algorytmów uczenia się systemu [1].

Dość popularnym algorytmem uczenia się jest Algorytm wstecznej propagacji błędu. Nazwa metody oddaje zasadę jej działania, która polega na „przenoszeniu" błędu, jaki popełniła sieć, w kierunku od warstwy wyjściowej do warstwy wejściowej (a więc wstecz w stosunku do kierunku przepływu informacji). Ten błąd pozwoli udoskonalić sieć [1].

Sieć neuronów składa się z warstw technologicznych. Każda warstwa ma odpowiednią liczbę neuronów. Każdy neuron przeprowadza obróbkę, która składa się z sumy wejść ważonych (waga Wi) a następnie zastosowanie funkcji aktywacji (rys. 59).

Rys. 59. Schemat sieci neuronowych [1]

72

Pierwsza warstwa to warstwa wejściowa (rysunek 59– 4 wejścia). Połączona jest z warstwą tzw. ukrytą (lub pośrednią). Warstwa ta ma zmienną liczbę neuronów które muszą zostać wypełnione przez użytkownika podczas kalibracji sieci. Ostatnia warstwa to warstwa wyjściowa. Posiada tyle neuronów ile wyjść (rysunek 59).

Sieć neuronów by przejść etap uczenia musi spełnić kryterium błędu walidacji uczenia. Wraz z upływem czasu błąd uczenia maleje i błąd testowania również. Gdy w ostatniej fazie uczenia się wartość jest zbieżna do zera to jest możliwa faza badań. W czasie badań, gdy wartość błędu testu nie zbiega się do zera to cała sieć neuronowa nie przechodzi fazy treningowej i musi się powtórzyć wszystko od początku.

Parametry kalibracji

Nie ma zasady kalibracji sieci. Ten etap jest rozwiązywany na podstawie doświadczeń użytkownika i wykonanie kilku prób z różnymi parametrami w celu osiągnięcia błędu jak najbardziej zbliżonego do zera.

Aktywacja jest kluczowa. Funkcję aktywacji można zdefiniować wewnątrz neuronu w oparciu o całkowitą ilość wejść. Istnieje kilka sposobów definiowania funkcji aktywacji jak np. funkcja liniowa, funkcja progowa, sigmoidalna funkcja unipolarna (rys. 60) czy też sigmoidalna funkcja bipolarna (tangens hiperboliczny) [6].

Rys. 60. Sigmoidalna funkcja unipolarna [7]

73

Konwergencja sieci (reakcja najbardziej oczekiwana) przy algorytmie wstecznej propagacji jest zasadniczym problemem, ponieważ wymaga wielu powtórzeń. Aby przezwyciężyć ten problem dodawany jest dodatkowy parametr. Ten parametr nazywa się „moment” (często oznaczany M). Moment [6] jest skutecznym sposobem na przyspieszenie nauki. Szybkość uczenia się (N) jest także ważnym parametrem w kalibracji sieci. Innym czynnikiem także ważnym wprowadzanym do kalibracji jest inicjacja wagi. Wagi zawierają całą wiedzę jaką posiada neuron (sieć neuronowa). Często oznacza się literami a,b.

4.6.2 Bramka XOR

Bramka ta realizuje funkcję logiczną zwaną po angielsku exclusive -or. Polska nazwa brzmi ALBO. Funkcję EX-OR zapisuje się za pomocą znaku „⊕” , np.:

C=A⊕B (1)

co odczytuje się: „C równa się A albo B”. Wartość funkcji można określić na podstawie definicji:

A⊕B=ĀB+AB (2)

Funkcja XOR przyjmuje wartość 1 tylko wtedy, kiedy albo argument A, albo argument B jest równy 1. Gdy oba argumenty są równe jednakowe, funkcja przyjmuje wartość 0. Można to przedstawić w tabeli:

Rys. 61. Tabela XOR

74

Problem symulacji układu logicznego XOR

Można oczywiście przedstawić funkcję XOR jak każdą inną na płaszczyźnie. I tu powstaje problem (rys. 62).

Rys. 62. Układ logiczny XOR na płaszczyźnie

Od razu widać, że nie da się wyznaczyć linii oddzielającej przestrzeń danych na 2 mniejsze, z których jedna odpowiada sygnałowi 1 na wyjściu, a druga 0 na wyjściu. Nie da się tego zrealizować, stosując podział za pomocą jednej prostej. Przestrzeń danych funkcji XOR może wyglądać następująco (rys. 63):

Rys. 63. Zakres danych funkcji XOR

Jeżeli chcemy odwzorować funkcję za pomocą sieci neuronowej wejściami dla sieci powinny być wartości logiczne X oraz Y natomiast na wyjściu powinno pojawić się wartość funkcji XOR dla podanych argumentów [7].

75

4.6.3 Biblioteka symulacji Sztucznej Sieci Neuronowej

Poniższy rysunek wyświetla listę dostępnych modeli w bibliotece, która jest użyta w symulacji:

Rys. 64. Biblioteka symulacji Sztucznej Sieci Neuronowej

Biblioteka obejmuje następujące modele:

DeltaOutput_Weight: Model odpowiedzialny za obliczenie wymaganej wagi uczenia się (nie wymaga konfiguracji);

ErrorGenerator: Model oblicza wartość błędu pomiędzy wartością wychodzącą a oczekiwaną (nie wymaga konfiguracji);

Input: Pozwala na instancję warstwy wejściowej (nie wymaga konfiguracji);

Hidden: Model odpowiadający za warstwę ukrytą;

Output: Odpowiada za instancję warstwy wyjściowej.

Konfiguracja dotyczy modeli pośrednich i wyjściowych by prawidłowo zbudować sieć neuronów. Poniżej przedstawiono własności modelu Hidden. Przypisane są tam odpowiednio parametry do prawidłowej kalibracji (rys. 65)

76

Rys.65. Własności modelu „Hidden”

Dodatkowym modelem symulacji będzie FileGenerator (pochodzący z biblioteki DEVSimPy) Pełniący rolę:

Inputl: szkolenie sieci neuronowej;

Inputv: walidacja sieci neuronowej;

Outputl: pożądany wynik szkolenia;

Outputv: pożadany wynik walidacji.

Inputl oraz Inputv są odpowiednio połączone do Input; Outputl i Outputv podane są na wejście do ErrorGenerator. By FileGenerator mógł współpracować z całą siecią potrzebuję pliku w ścieżce dostępu z danymi w formacie .dat; na podstawie tych danych w pliku sieć pracuje (rys. 66).

Rys. 66. Własności modelu „FileGenerator”

77

4.6.4 Sieć neuronowa

Rys. 67. Układ modeli Sztucznej Sieci Neuronowej

Sieć neuronowa uczy się funkcji XOR na podstawie danych w zależności od pliku Inputl.dat oraz Output.dat (odpowiednio zawartych w modelach InputL i OutputL). Sprawdzenie poprawności odbywa się w Inputv.dat, Output.dat (InputlV, OutputV). Model Input podłączony jest do Hidden dwoma linami. Model Hidden podłączony jest do modelu Output. Liczba połączeń pomiędzy dwoma modelami odpowiada liczbie neuronów które chcemy wykorzystać. DeltaOutput_Weight oblicza odpowiednią wagę dla odpowiedniej warstwy i ją przechowuje.

Modele typu Output połączone są z ErrorGenerator by obliczyć różnicę między uzyskanym a spodziewanym wynikiem (dostarczonym przez outputL i outputV) tj. wartość wyjściowa funkcji XOR.

78

Zawartość pliku InputL.dat:

Zawartość pliku OutputL.dat:

Zawartość pliku InputV.dat:

Zawartość pliku OutputV.dat:

def __init__(self): """Constructor """ DomainBehavior.__init__(self) self.state = {'status':'Idle', 'sigma': INFINITY} #self.dt = INFINITY self.current_tpattern = 0 self.current_vpattern = 0 self.t_pattern = [] self.v_pattern = [] def extTransition(self): ### receiving pattern before statring the simulation. for port, msg in self.peek_all(): i = port.myID if i == 0: self.t_pattern.append(map(float,msg.value[0])) self.dt = 1.0/len(self.t_pattern) self.state = {'status':'PASSIVE', 'sigma':self.dt} self.msgListOut = [Message([None,None],0.0) for i in xrange(len(self.OPorts))] else: self.v_pattern.append(map(float,msg.value[0])) ### changing state deleted.

Listing. 4. Fragment kodu modelu „Input”

0.0 0.0 1.0 0.0 0.0 1.0 1.0 1.0

0 1 1 0

0.1 0.1 0.9 0.2 0.1 0.8 0.8 0.9

0 1 1 0

79

def timeAdvance(self): return self.state['sigma'] def transfer(self,sim): for i in sim.wh: s = sum([sim.inputs[j]*sim.wh[i][j] for j in sim.wh[i]]) sim.outputs[i] = self.activation(sim.activation,s) #if sim.val_inputs[i] != None: try: s_val = sum([sim.val_inputs[j]*sim.wh[i][j] for j in sim.wh[i]]) sim.val_outputs[i] = self.activation(sim.activation,s_val) #else: except: sim.val_outputs[i]= None #raise def activation(self,activation,x,k=1.0): """ activation Functions.""" if activation == "tanh": return math.tanh(x) elif activation == "sigmoid": return 1.0/(1.0+math.exp(float(k)*(-float(x)))) else: return x def finish(self, msg): """ optional method to control the the behavior when simulation finished """

Listing. 5. Fragment kodu modelu „Hidden”

### Specific import ------------------------------------------------------------

from Hidden import Hidden

### Model class ----------------------------------------------------------------

class Output(Hidden):

""" Output Layer

"""

def __str__(self):

return 'Output'

Listing. 6. Fragment kodu modelu „Output”

80

def outputFnc(self):

self.poke(self.OPorts[0], Message([self.errors,None,None], self.timeNext))


if self.current_pattern == len(self.output_targets)-1:

try:

self.results['t'].append((self.iteration,self.globalerror))

except:

self.results['t'] = [(self.iteration,self.globalerror)]

self.iteration += 1

self.current_pattern = 0

self.globalerror = 0.0

else:

self.current_pattern += 1

if self.current_validation_pattern == len(self.output_validation_targets)-1:

try:

self.results['v'].append((self.iteration,self.globalerror_validation))

except:

self.results['v'] = [(self.iteration,self.globalerror_validation)]

self.validation_iteration += 1

self.current_validation_pattern = 0

self.globalerror_validation = 0.0

else:

self.current_validation_pattern += 1

self.state = {'status':'Idle', 'sigma':INFINITY}

Listing. 7. Fragment kodu modelu „ErrorGenerator”

81

class DeltaOutput_Weight(DomainBehavior):

def __init__(self):

""" constructor.

"""

DomainBehavior.__init__(self)

self.state = { 'status': 'Idel', 'sigma':INFINITY}

self.layerId = None

self.outError = {}

self.sim = None

self.msgListOut = [Message([None,None,None],0.0),Message([None,None,None],0.0)]

def extTransition(self):

""" receiving Errors and calculates new weights """

for port,msg in self.peek_all():

i = port.myID

msg = self.peek(self.IPorts[i])

if i == 0:

self.sim = msg.value[0]

self.layerId = msg.value[2]

else:

self.sim.errors = msg.value[0]

self.outError = self.run(self.sim)

self.state = {'status': 'ACTIVE', 'sigma':0}

Listing. 8. Fragment kodu modelu „DeltaOutput_Weight”

82

4.6.5 Symulacje

By uruchomić symulację należy w pasku narzędzi kliknąć Simulation. Czas trwania ustawiamy przykładowo na wartość 1000. Przycisk Run uruchamia symulację. Wynikiem symulacji będzie wykres i dlatego też ustawiony czas jest na 1000 iteracji by lepiej zobrazować wynik symulacji. By uruchomić wynik symulacji, klikamy podwójnie lewym przyciskiem myszki na ErrorGenerator.

Tak jak wspomniano wcześniej, trzeba odpowiednio skalibrować parametry modelu pośredniego i wyjściowego (Hidden/Output). W tabeli przedstawiono wartości parametrów skalibrowanych do wykonania czterech symulacji:

Nr. doświadczenia

Parametr N Parametr M Funkcja aktywacji

Liczba neuronów

1 0,9 0,1 Sigmoidalna 3 2 1,5 0,1 Sigmoidalna 3 3 0,9 0,1 Tangens 3 4 0,9 0,1 Sigmoidalna 3

Tabela. 1. Parametry dla symulacji Sztucznej Sieci Neuronowej (SSN)

Pozostałe parametry są stałe:

a = -0,2

b = 0,2

bias = 0,5

83

Pierwsza symulacja:

Eksperyment będzie służył jako stanowisko odniesienia. Symulowane parametry odpowiadają domyślnym parametrom modeli biblioteki sieci. Wyniki przedstawiono na wykresie:

Rys. 68. Wynik- wykres I symulacji

Jak widać na wykresie powyżej (rys. 68), są dwie krzywe: jedna dla uczenia się systemu (kolor czarny) i druga reprezentująca cały proces walidacji. Krzywe oczywiście mogą się od siebie różnić. Tak jak wspomniano jest to symulacja odniesienia, po zmianie ustawień konfiguracyjnych będzie można porównać ją do innych symulacji.

84

Druga symulacja:

Doświadczenie drugie pozwala podkreślić wzrost szybkości uczenia się systemu przez modyfikację parametrów:

Rys. 69. Wynik- wykres II symulacji

Wraz ze wzrostem szybkości uczenia się (N) następuje szybsza konwergencja. Mogą też występować większe wahania. Należy więc być ostrożny przy zmianie parametrów.

85

Trzecia symulacja:

Trzeci eksperyment pozwala podkreślić efekt uczenia się zależnie od funkcji aktywacji oraz weryfikacji całej sieci. Funkcję aktywacji zmieniono na tanges hiperboliczny:

Rys. 70. Wynik- wykres III symulacji

Wykres przedstawia zmiany w szybkości uczenia się jak również zmiany funkcji aktywacji. Rozbieżność krzywej walidacji wynika z braku uogólnienia ( brak testowania na danych testujących).

86

Czwarta symulacja:

Doświadczenie czwarte pokazuje jak liczba neuronów w warstwie ukrytej wpływa na całokształt symulacji.

Rys. 71. Wynik - wykres IV symulacji

Występują dwa efekty:

wzrasta zdolność uczenia się sieci (wynika z krzywej uczenia się – kolor czarny);

spadek liczby testów (krzywa walidacji – kolor czerwony). Występuje dość spora różnica między ilością błędów a walidacją uczenia się.

4.6.6 Podsumowanie symulacji

Po raz kolejny można zauważyć, jak funkcjonalnym narzędziem jest program DEVSimPy. Symulacje dotyczyły sieci neuronowych. Sztuczne sieci neuronowe nie dościgają w wynikach ludzkiego rozumu, ale dzięki takim symulacjom można rozwijać tą dziedzinię nauki. Kalibracja odpowiednich parametrów oraz przeprowadzenie symulacji – testów, pozwala na interpretację błędów nauki systemu.

87

5. Testowanie

W tym rozdziale zostanie przedstawiony wynik testowania programu DEVSimPy oraz wykonanych instrukcji i jak i samego oprogramowania. Test został wykonane przez dwie osoby które w różnym stopniu miały styczność z oprogramowaniem jak i z samym procesem symulacji komputerowej.

Test został podzielony na następujące dwa etapy:

Przetestowanie projektów aplikacji ćwiczeniowych;

Przetestowanie wykonanego oprogramowania w aplikacjach ćwiczeniowych.

5. 1 Przetestowanie projektów aplikacji ćwiczeniowych

Aplikacje ćwiczeniowe rozpoczynają się od instalacji programu DEVSimPy. Najnowsza wersja dostępna tego programu to wersja 3.0. By instalacja powiodła się należy posiadać zainstalowane dodatkowe narzędzia m.in biblioteki wxPython, Scipy, NumPy. Osoba testująca która miała mniejszą styczność z oprogramowaniem miała problemy z instalacją programu (rys. 72 ) gdyż nie wiedziała jakie dobrać odpowiednie komponenty.

Rys. 72. Problem z instalacją biblioteki wxPython

88

Druga osoba nie miała żadnych problemów z instalacją.

Obie osoby testujące stwierdziły iż rozdział Instalacja jest czytelny i zrozumiały. Rozdział Opis użytkowy modeli nie stanowił dla osób testujących większego problemu. Zapoznali się z pojęciem DEVS oraz z podstawowymi cechami modelów. Przedstawione informacje były dla nich zrozumiałe.

Rozdział Biblioteka DEVSimPy także nie stanowiła dla osób testujących żadnych problemów. Warto nadmienić iż osoby testujące swoją wiedzę uzupełniali rozdziałem rozszerzonym. Jest to Implementacja instrukcji ćwiczeniowych. zawiera szczegółowe rozwinięcie wszystkich etapów aplikacji ćwiczeniowych. Szczegółowy opis instalacji, opis interfejsu, zakres pracy poszczególnych elementów.

5.2 Przetestowanie wykonanego oprogramowania w aplikacjach ćwiczeniowych

Prosty przykład symulacji czyli prosty przykład symulacji, to następny tytuł aplikacji ćwiczeniowej. Pierwsza osoba miała problem z biblioteką. Po załadowaniu biblioteki „Generator” (rys. 73) wystąpił błąd. Po kliknięciu prawym przyciskiem myszki i odświeżeniem okna interfejsu, ten błąd niwelowało. Druga osoba nie miała żadnego problemu z przetestowaniem tej symulacji.

Rys. 73. Błąd biblioteki „Generator”

Symulacja linii produkcyjnej bez problemów została przetestowana przez testerów. Łatwo zrozumieli problem symulacji oraz rozwiązanie. Nie było żadnego problemu z załadowaniem biblioteki.

89

Symulacja Sztucznej Sieci Neuronowej wymagała zagłębienia wiedzy przez osoby testujące na temat Sztucznej Sieci neuronowej (SSN). Sam problem został zrozumiany dostatecznie lecz sama symulacja nie zbyt poprawnie. W ocenie testerów symulacja jak i jej problem był trudny do zrozumienia. Po uruchomieniu symulacji przez jednego z testerów wystąpił błąd (rys. 74). Błąd raportowany, wynikający raczej ze złej wersji platformy DEVSimPy.

Rys. 74. Błąd raportowany

5.3 Podsumowanie

Obie osoby zgodnie dobrze oceniły projekty aplikacji ćwiczeniowych. Problemy podczas obsługi programu wynikały głównie ze złego dobrania dodatkowych bibliotek. Symulacje zrozumiałe, lecz wymagały głębszej analizy przez osoby testujące.

90

6. Podsumowanie, wnioski – DEVSimPy

Projekt inżynierski miał za zadanie pokazać funkcjonalność programu DEVSimPy. Przedstawienie interfejsu jak i pokazanie głównych atutów w praktyce.

Bezpłatny projekt DEVSimPy narodził się w zespole laboratoryjnym SPE Uniwersytetu na Korsyce. Program służy do modelowania i symulacji złożonych systemów. Formalizm oparty na DEVS (Discrete Event Specification) jest w stanie oddzielić modelowanie i symulację. Ta koncepcja użyta w środowisku DEVSimPy pozwala na zwiększenie dokładności przeprowadzanych badań w tym programie. Biblioteka PyDEVS pokazuje jak funkcjonalnym językiem programowania jest Python. Biblioteka posiada także zaprojektowane przez autorów, gotowe modele do użycia w symulacji. We własnych potrzebach, łatwe do modyfikowania.

Interfejs główny jest przejrzysty. Każdy użytkownik w krótkim czasie odnajdzie się w obsłudze tego programu.

Głównym zadaniem programu DEVSimPy jakie przedstawiono tutaj w pracy jest przeprowadzanie zjawiska modelowania a później zasymulowanie jego. Badania dotyczą głównie dziedzin technicznych ale także służą do rozwiązywania problemów bieżących np. symulacja pożarów lasów.

Możliwość modyfikowania parametrów podczas symulacji jest największym atutem tej platformy. Pozwala zobaczyć istotę zjawiska symulacji zmieniając dane w czasie zadania. Środowisko DEVSimPy jest środowiskiem rozwojowym w każdej dziedzinie.

91

Spis ilustracji:

Rysunek 1. Struktura modelowania i symulacji w DEVS. Wykorzystano ilustracje z [5] ................................ 19

Rysunek 2. Warstwa DEVSimPy. Wykorzystano ilustracje z [1] .................................................................. 21

Rysunek 3. Współpraca w DEVSimPy. Wykorzystano ilustracje z [1] ......................................................... 22

Rysunek 4. Uruchomienie pliku DEVSimPy w Pythonie............................................................................... 26

Rysunek 5. Uruchomienie programu DEVSimPy .......................................................................................... 26

Rysunek 6. Graficzny blok modelu atomu .................................................................................................... 28

Rysunek 7. Własności modelu ...................................................................................................................... 28

Rysunek 8. Bibliotek w DEVSimPy ............................................................................................................. 30

Rysunek 9. Połączenie dwóch modeli ........................................................................................................... 31

Rysunek 10. Wynik symulacji w „MessageCollector” .................................................................................. 32

Rysunek 11. Powiązane ze sobą modele gotowe do symulacji ....................................................................... 33

Rysunek 12.Własności modelu „Generator_produkcyjny” ........................................................................... 34

Rysunek 13.Wynik symulacji w „Urządzenie_Odbierające” ........................................................................ 34

Rysunek 14. Tabelka XOR ........................................................................................................................... 35

Rysunek 15.Zakres danych funkcji XOR ...................................................................................................... 36

Rysunek 16. Układ modeli Sztucznej Sieci Neuronowej ............................................................................... 37

Rysunek 17.Wynik – wykres symulacji ........................................................................................................ 38

Rysunek 18. Instalacja Python 2.7 ................................................................................................................ 40

Rysunek 19.Instalacja biblioteki wxPython 2.8 ............................................................................................. 41

Rysunek 20.Uruchomienie pliku DEVSimPy w Pythonie.............................................................................. 41

Rysunek 21.Uruchomienie programu DEVSimPy ......................................................................................... 42

Rysunek 22. Okno dialogowe ....................................................................................................................... 42

Rysunek 23. Menu „File” w DEVSimPy....................................................................................................... 44

Rysunek 24. Menu ”Diagram” w DEVSimPy ............................................................................................... 45

Rysunek 25.Menu „Show” w DEVSimPy ..................................................................................................... 46

Rysunek 26. Menu „Perspectives” w DEVSimPy ......................................................................................... 46

Rysunek 27. Menu „Options” w DEVSimPy ................................................................................................ 46

Rysunek 28. Menu ,,Help” w DEVSimPy ..................................................................................................... 47

92

Rysunek 29. Okno wyboru modelu ............................................................................................................... 48

Rysunek 30. Właściwości modelu................................................................................................................. 49

Rysunek 31.Graficzny blok modelu atomu ................................................................................................... 50

Rysunek 32. Budowa modelu .amd ............................................................................................................... 50

Rysunek 33. Własności modelu atomowego ................................................................................................. 51

Rysunek 34.Parametry konstruktora z klasy pyDEVS ................................................................................... 52

Rysunek 35. Edytor kodu ............................................................................................................................. 53

Rysunek 36. Menadżer symulacji ................................................................................................................. 54

Rysunek 37.Menadżer wartości stałych ........................................................................................................ 55

Rysunek 38. Menadżer ustawień w DEVSimPy ............................................................................................ 55

Rysunek 39. Karta „Simulation” w DEVSimPy ............................................................................................ 56

Rysunek 40. Karta „Editor” w DEVSimPy ................................................................................................... 56

Rysunek 41. Karta „Plugins” w DEVSimPy ................................................................................................. 56

Rysunek 42. Biblioteka w DEVSimPy .......................................................................................................... 57

Rysunek 43. Import biblioteki ...................................................................................................................... 58

Rysunek 44. Biblioteka „Collector” ............................................................................................................. 59

Rysunek 45. Umieszczenie modeli w oknie interfejsu ................................................................................... 60

Rysunek 46 Połączenie dwóch modeli .......................................................................................................... 60

Rysunek 47. Uruchomienie przykładowej symulacji ..................................................................................... 61

Rysunek 48. Wynik symulacji w „MessageCollector” .................................................................................. 61

Rysunek 49. Debugowanie kodu w DEVSimPy ............................................................................................ 62

Rysunek 50. Powiązane ze sobą modele gotowe do symulacji ....................................................................... 62

Rysunek 51. Własności modelu „Generator_produkcyjny” .......................................................................... 64

Rysunek 52. Własności modelu „Maszyna” ................................................................................................. 64

Rysunek 53. Wynik symulacji w „Urządzenie_Odbierające” ....................................................................... 65

Rysunek 54. Okno „Blink Logger” .............................................................................................................. 66

Rysunek 55. Przesyłane dane z „Generatora” do „Maszyny” ........................................................................ 69

Rysunek 56. Wizualizacja symulacji etapu I ................................................................................................. 70

Rysunek 57. Wizualizacja symulacji etapu II ................................................................................................ 70

Rysunek 58. Wizualizacja symulacji etapu III ............................................................................................... 70

Rysunek 59. Schemat sieci neuronowych ...................................................................................................... 71

93

Rysunek 60. Sigmoidalna funkcja unipolarna ............................................................................................... 72

Rysunek 61. Tabela XOR ............................................................................................................................. 73

Rysunek 62. Układ logiczny XOR na płaszczyźnie ....................................................................................... 74

Rysunek 63. Zakres danych funkcji XOR ..................................................................................................... 74

Rysunek 64. Biblioteka sztucznej sieci neuronowej ...................................................................................... 75

Rysunek 65. Własności modelu „Hidden” .................................................................................................... 76

Rysunek 66. Własności modelu „FileGenerator” .......................................................................................... 76

Rysunek 67. Układ modeli Sztucznej Sieci Neuronowej ............................................................................... 77

Rysunek 68. Wynik – wykres I symulacji ..................................................................................................... 83

Rysunek 69. Wynik – wykres II symulacji .................................................................................................... 84

Rysunek 70. Wynik – wykres III symulacji ................................................................................................... 85

Rysunek 71. Wynik – wykres IV symulacji .................................................................................................. 86

Rysunek 72. Problem z instalacją biblioteki wxPython ................................................................................. 87

Rysunek 73. Błąd biblioteki „Generator” ..................................................................................................... 88

Rysunek 74. Błąd raportowany ..................................................................................................................... 89

94

Spis listingu:

Listing. 1 Fragment kodu modelu „Generator_produkcyjny” ....................................................................... 65

Listing. 2 Fragment kodu modelu „Maszyna” .............................................................................................. 66

Listing. 3 Fragment kodu modelu „Urządzenie_odbierające” ...................................................................... 67

Listing 4 Fragment kodu modelu „Input” .................................................................................................... 78

Listing. 5 Fragment kodu modelu „Hidden” ................................................................................................ 79

Listing. 6 Fragment kodu modelu „Output” ................................................................................................. 79

Listing. 7 Fragment kodu modelu „ErrorGenerator” .................................................................................... 80

Listing. 8 Fragment kodu modelu „ DeltaOutput_Weight” .......................................................................... 81

Spis tabel: Tabela 1. Parametry dla symulacji Sztucznej Sieci Neuronowej (SSN) ........................................................ 82

95

BIBLIOGRAFIA

[1] „Detection and identication methodology for multiple faults in complex systems using discrete-events and neural networks: applied to the wind turbines diagnosis” [online]. Samuel Toma, University of Corsica, 2014 [dostęp: 17-03-2015]. Dostępny w Internecie: https://hal.archives-ouvertes.fr/tel-01141844/document

[2] „Visualization of Folktales on a map by coupling dynamic DEVS simulation within Google Earth” [online]. Jean-François Santucci, Laurent Capocchi, Laboratoire SPE, University of Corsica, 2011 [dostęp: 25-03-2015]. Dostępny w Internecie: https://hal.archives-ouvertes.fr/hal-00603465

[3] „DEVSimPy - v2.8” [online]. Laurent Capocchi, Laboratoire SPE, University of Corsica, 2014 [dostęp 31-03-2015]. Dostępny w Internecie: http://devsimpy.univ-corse.fr/INFO-Serveur-Multicoeur_a24.html

[4] https://code.google.com/p/devsimpy/ [online] 2010

[5] „DEVSimPy Logiciel pour la simulation DEVS” [online]. University of Corsica, 2013 [dostęp 08-04-2015]. Dostępny w Internecie: http://devsimpy.univ-corse.fr/Guide-Utilisateur_r7.html

[6] http://pl.wikipedia.org/wiki/Sie%C4%87_neuronowa [online] 2013

[7] http://home.agh.edu.pl/~vlsi/AI/xor_t/glowna.htm [online] 2011

[8] Bernard Zeigler (1976). Theory of Modeling and Simulation (first ed.). Wiley Interscience, New York. ISBN 0-12-778455-1.

wydziaŁ elektrotechniki, automatyki i informatyki...

Documents