Normalizace dat pro neuronovou síť GAME

České vysoké učení technické v Praze Fakulta elektrotechnická ČVUT FEL katedra počítačů Bakalářská práce Normalizace dat pro neuronovou síť GAME Dezider Meško Vedoucí práce: Ing. Mirek Čepek Studijní program: Elektrotechnika a informatika Obor: Výpočetní technika Červen 2008

iv

Poděkování V úvodu bych chtěl poděkovat všem, kteří mi při vzniku této práce pomáhali jak s technickou, tak s formální stránkou. v

vi

Prohlášení Prohlašuji, že jsem svou bakalářskou práci vypracoval samostatně a použil jsem pouze podklady uvedené v přiloženém seznamu. V Praze dne 13.6.2008............................................................. vii

viii

Abstrakt Tato práce pojednává o lineární a nelineární normalizaci vstupních dat před jejich použitím při výpočtech pomocí neuronových sítí. Tyto normalizace se implementují do systému FAKE GAME a poté je jejich implementace otestována. Následně je na několika souborech testovacích dat rámcově porovnán jejich vliv na úspěšnost modelů systému FAKE GAME. Abstract This thesis deals with the linear and nonlinear input data normalization before it is used for neural networks calculation. These normalizations are implemented into FAKE GAME system and the implementation is afterwards tested. Its influence on GAME models is generally compared through several testing data files. ix

x

Obsah Seznam obrázků xiii Seznam tabulek xiii 1 Úvod 1 2 Metody normalizace 3 2.1 Lineární transformace min-max normalizace............... 3 2.2 Nelineární transformace - soft-max normalizace.............. 5 2.3 Z-score normalizace.............................. 6 2.4 Transformace střední hodnoty........................ 9 2.5 Vlastní metody normalizace......................... 9 2.5.1 JavaScript............................... 10 2.5.2 Jazyk MATLAB........................... 10 3 Implementace 11 3.1 Podpůrná třída pro normalizaci....................... 12 3.2 Min-max normalizace............................. 13 3.3 Soft-max normalizace............................. 15 3.4 Z-score normalizace.............................. 17 3.5 Transformace střední hodnoty........................ 19 3.6 Uživatelem definovaná normalizace..................... 19 3.6.1 JavaScript............................... 19 3.6.2 Jazyk MATLAB........................... 20 4 Implementační testy 23 5 Funkční testy 25 5.1 Kosatce.................................... 26 5.2 Nevyžádaná pošta............................... 27 6 Závěr 29 xi

7 Příloha obsah přiloženého CD 31 8 Literatura 33 xii

Seznam obrázků 2.1 Kvůli hodnotě 80 jsou téměř všechny ostatní hodnoty transformovány do 60% výstupního rozsahu........................... 4 2.2 Průběh funkce podle rovnice 2.4 s různými hodnotami parametru α... 5 2.3 Hodnoty transformované vztahem 2.5 s různými hodnotami parametru λ 6 2.4 Hodnoty transformované vztahem 2.4 s různými hodnotami parametru α při λ = 3................................... 7 2.5 Velikost upravených hodnot po transformaci z-score normalizací..... 8 2.6 Velikost hodnot po transformaci střední hodnoty.............. 9 Seznam tabulek 3.1 Parametry modulu pro min-max normalizaci................ 14 3.2 Parametry modulu pro soft-max normalizaci................ 16 3.3 Parametry modulu pro z-score normalizaci................. 17 3.4 Parametry modulu pro normalizaci střední hodnoty............ 19 3.5 Parametry modulu pro normalizaci skriptu v jazyce JavaScript..... 20 3.6 Parametry modulu pro normalizaci skriptu v jazyce MATLAB...... 21 5.1 Některé parametry systému FAKE GAME pro použití z příkazového řádku 25 5.2 Výsledky klasifikace květin při použítí různých normalizačních metod.. 26 5.3 Výsledky klasifikace zpráv při použítí různých normalizačních metod... 27 xiii

xiv

KAPITOLA 1. ÚVOD 1 1 Úvod Neuronové sítě dnes nacházejí stále širší možnosti uplatnění v různých průmyslových odvětvích. Jednou z možností z využití neuronových sítí je i dolování informací. Mezi systémy pro dolování informací patří i systém FAKE GAME. Tento systém sestává ze dvou částí. Část GAME (The Group of Adaptive Models Evolution) je neuronová síť založená na metodě GMDH (The Group Method of Data Handling), která si klade za cíl modelovat systémy z reálného světa na základě mnoha vstupních veličin, ale relativně málého množství záznamů těchto dat. Druhou částí je framework FAKE (The Fully Automated Knowledge Extraction), který zjednodušuje a automatizuje použití části GAME. [1] Cílem této práce je rozšířit možnosti frameworku FAKE o základní metody normalizace vstupních dat a ukázat některé možnosti použití systému FAKE GAME.

2 KAPITOLA 1. ÚVOD

KAPITOLA 2. METODY NORMALIZACE 3 2 Metody normalizace Mezi nejpoužívanější metody normalizace při úpravě vstupních dat pro neuronové sítě patří: min-max normalizace (lineární transformace) z-score normalizace (normalizace na základě odchylky od průměrné hodnoty) dekadická normalizace (posuv desetinné čárky hodnot tak, aby spadaly do daného intervalu) soft-max normalizace (nelineární transformace logistickou funkcí) V této práci se budu zabývat implementací některých z nich do systému FAKE GAME. Pro lepší představu o funkci jednotlivých transformací a jejich vzorců jsem vygeneroval náhodnou řadu čísel se dvěma extrémními hodnotami (peaks). Dále zobrazené grafy pak budou na ose x reprezentovat vstupní data a jejich hodnotu a na ose y data transformovaná. Z grafů je možné porovnat hodnoty a udělat si obrázek o tom, jak se ta či ona trasformace chová k danemu souboru hodnot. 2.1 Lineární transformace min-max normalizace Obecný tvar lineární transformace můžeme vyjádřit rovnicí: x i = ax i + b (2.1) kde a je koeficient zmenšení (zvětšení), x je transformovaná hodnota a b je velikost posuvu nové hodnoty. Častou úpravou je transformace dat do intervalu 0, 1, pro kterou můžeme použít rovnici [2]: x i = x min(x 1..x i ) max(x 1..x i ) min(x 1..x i ) (2.2)

4 KAPITOLA 2. METODY NORMALIZACE kde funkce min() a max() vracejí hodnotu nejmenšího a největšího prvku transformované množiny. Toto ovšem může být problém, protože při normalizaci musíme znát minimální a maximální hodnoty, které jsou známé pro množinu cvičných dat, ale ne pro množinu reálných vstupních dat. Důsledkem překročení rozsahu vstupních dat, je transformace hodnot mimo interval 0, 1. Řešení tohoto problému spočívá v optimálním odhadu minimální a maximální vstupní hodnoty, nebo v ořezání, či úplnému vynechání hodnot překračujících předpokládaný vstupní rozsah. Převod z intervalu 0, 1 do jakéhokoli jiného už jednoduše provedeme pomocí rozšíření předchozí rovnice: x i = x i min(x 1..x i ) max(x 1..x i ) min(x 1..x i ) (O max O min ) + O min (2.3) kde O max a O min jsou hranice výstupního intervalu. Nevýhodou lineární normalizace je skutečnost, že v případě, kdy množina obsahuje hodnoty výrazně větší či menší, než je velikost střední hodnoty vstupních dat, zůstáva většina rozsahu nevyužita. Jestliže jsou tyto hodnoty navíc výsledkem špiček či anomálií, zapříčiní podstatné zkreslení relevantních vstupních informací. Obrázek 2.1: Kvůli hodnotě 80 jsou téměř všechny ostatní hodnoty transformovány do 60% výstupního rozsahu

KAPITOLA 2. METODY NORMALIZACE 5 Jednou z možností, jak tento nepříjemný efekt potlačit, je použití nelineární transformace soft-max normalizace. 2.2 Nelineární transformace - soft-max normalizace Tato transformace se chová k maximálním a minimálním hodnotám jemně. Transformuje je do úzkého rozsahu pomocí logaritmické funkce, zatímco většinu hodnot ve středu rozsahu transformuje lineárně. Takto se chová například tato funkce: L(x i ) = 1 1 + e αx i (2.4) kde α určuje strmost křivky. 1 0.8 0.6 0.4 0.2 0 α=1 α=2 α=3-10 -5 0 5 10 Obrázek 2.2: Průběh funkce podle rovnice 2.4 s různými hodnotami parametru α Tato funkce sice splňuje požadavky na tvar, ale nedovoluje transformovat hodnoty z požadovaného rozsahu a také nedovoluje určit, jaká šířka rozsahu se má ještě transformovat lineárně. Z grafu funkce 2.2 je navíc vidět, že změna parametru α nijak výrazně nedovoluje ovlivnit výsledek transformace, a proto jeho automatické nastavovaní nemá velký smysl.

6 KAPITOLA 2. METODY NORMALIZACE Obrázek 2.3: Hodnoty transformované vztahem 2.5 s různými hodnotami parametru λ Jako řešní se nabízí transformovat nejdříve vstupní proměnnou lineárně k hodnotě blízké střední hodnotě m x následovně: x i = x i E(x) λ( σx 2π ) (2.5) kde E(x) je střední hodnota veličiny x, σ x je směrodatná odchylka veličiny x (výpočet hodnoty σ x je uveden v kapitole 2.4) a λ je velikost lineární odezvy měřená v násobcích σ x (σ x pokrývá 68%, 2σ x pokrývá 95,5% a 3σ x pokrývá 99,7% rozsahu). Tyto hodnoty následně můžeme transformovat pomocí vztahu 2.4 do požadovaného rozsahu. Všimněme si na obrázku 2.4, že při parametrech α = 2 a 3 jsou už hodnoty okolo 40 transformovány stejně jako extrémní hodnota 80 a blíží se 1,0. 2.3 Z-score normalizace Často používanou metodou pro standardizaci dat ve statistice je použití z-score normalizace. Z-score vyjadřuje vzdálenost daného bodu (hodnoty) od střední hodnoty množiny. Tato vzdálenost je v případě z-score normalizace vyjádřena násobkem velkosti výběrové směrodatné odchylky.

KAPITOLA 2. METODY NORMALIZACE 7 Obrázek 2.4: Hodnoty transformované vztahem 2.4 s různými hodnotami parametru α při λ = 3 Střední hodnotu pro danou řadu dat získame vydělením součtu výsledků pozorování počtem těchto pozorování (rovnice 2.6). Střední hodnota udává centrální umístění a směrodatná odchylka udává rozptyl dané množiny dat. [3] x = 1 n x i (2.6) n i=1 Jako příklad lze uvést pohled na průměrnou teplotu ve dvou místech s různým klimatem. Zatímco obě místa mohou mít totožnou průměrnou teplotu, směrodatná odchylka místa ve vnitrozemí bude větší než místa na pobřeží. Toto poskytuje informaci o tom, že předpověď teploty pro místo ve vnitrozemí bude méně spolehlivá pravě kvůli větším odchylkám od průměru. [3] Zde je ještě dobré se pozastavit nad výpočtem hodnoty směrodatné odchylky σ x. Pro empiricky zjištěnou řadu čísel se používá výběrová směrodatná odchylka, kterou lze vypočítat podle vzorce: σ x = 1 N 1 N (x i x) 2 (2.7) i=1

8 KAPITOLA 2. METODY NORMALIZACE kde x je aritmetický průměr ze zadaných hodnot. Tento vzorec však vyžaduje předběžný výpočet x, což znamená jednu iteraci přes všechny vstupní hodnoty. Pomocí transformace tohoto vzorce na vzorec 2.8 však můžeme výpočet optimalizovat a všechny operace provést v jedině iteraci. Toto bude mít za následek téměř dvojnásobné zrychlení výpočtu. Podle [4] je však nevýhodou tohoto způsobu optimalizace riziko vlivu zaokrouhlovacích chyb na přesnost výsledku. σ x = 1 ( N ) x 2 i Nx N 1 2 i=1 (2.8) Obrázek 2.5: Velikost upravených hodnot po transformaci z-score normalizací Vstupní data normalizujeme tak, že od každé hodnoty odečteme střední hodnotu vstupních dat a poté výsledek vydělíme velikostí směrodatné odchylky. z = x x σ (2.9)

KAPITOLA 2. METODY NORMALIZACE 9 2.4 Transformace střední hodnoty Cílem této metody je docílit, nulové střední hodnoty vstupních dat. Toto může být užitečné v případě, že máme více zdrojů porovnatelných dat se vzájemným offsetem. Jako dobrý příklad je možné uvést zpracování dat z několika teplotních senzorů. Tyto senzory nemusí být správně zkalibrované, ale správně vyjadřují hodnotu rozdílu měřených teplot. Normalizace probíhá zpracováním hodnot podle vzorce 2.10 x = x x (2.10) množiny. kde x je střední hodnota dané množiny hodnot, x je aktuální hodnota z dané Obrázek 2.6: Velikost hodnot po transformaci střední hodnoty 2.5 Vlastní metody normalizace Existuje velké množství metod pro normalizaci, ale v projektu FAKE GAME není možné všechny dopředu zahrnout. Uživatel systému navíc může chtít upravit vstupní

10 KAPITOLA 2. METODY NORMALIZACE hodnoty nějakým nestandartním způsobem. Pro tento účel je vhodné, aby si celý algoritmus normalizace mohl navrhnout a implementovat sám i za cenu snížené rychlosti výpočtu a větší pracnosti. Při volbě druhu skriptovacího jazyka jsem se rozhodl pro JavaScript a jazyk systému Matlab. 2.5.1 JavaScript JavaScript je skriptovací jazyk nejčastěji používaný při tvorbě webových stránek. Je dynamický, slabě typovaný a objektově orientovaný. Jeho syntax se podobá syntaxi jazyka C a jazyka JAVA, které mnoho uživatelů ovládá, proto tvořit skripty v tomto jazyce pro ně nebude příliž složité. Od verze 1.6 jazyka JAVA je podpora tohoto skriptovacího jazyka nativní, což znamená, že pro psaní skriptů a jejich spuštění není třeba do systému instalovat žádné dodatečné knihovny či aplikace. Kód pro připočtení hodnoty 100 k vektoru testvector1 v jazyce JavaScript: for(i=0; i<testvector1.length; i++) { testvector1[i]= (+testvector1[i])+100; } 2.5.2 Jazyk MATLAB Tento jazyk je rozšířený hlavně v akademické a výzkumné sféře. Jeho syntax je navíc přizpůsobena práci s maticemi a vektory. To velice ulehčuje zpracování vstupních dat, která jsou reprezentovány pravě jako vektory. Zatímco v jazyce JavaScript je třeba pomocí cyklu procházet všechny hodnoty a upravovat je jednotlivě, v jazyce MATLAB stačí provést operaci nad vektorem. Kód pro připočtení hodnoty 100 k vektoru testvector1 v jazyce MATLAB: testvector1=testvector1+100;

KAPITOLA 3. IMPLEMENTACE 11 3 Implementace Protože systém FAKE GAME je psaný v jazyce Java a je uvolněn pod licencí GPL [5], byla volba jazyka pro implementaci jednoznačná. Konkrétní použitá verze je Java 1.6. [6] Projekt využívá pro správu verzí systém Subversion. [7] Díky modularitě FAKE GAME je rozšíření systému velice snadné. Metody pro normalizaci si našly své místo v balíčku game.preprocessing.methods.normalization.*. Každý typ normalizace má svou vlastní třídu, jejíž jméno je ve tvaru TypNormalizaceNormalizer a svoji vlastní třídu pro konfiguraci, jejíž jméno má tvar TypNormalizaceNormalizerConfig. Například pro soft-max normalizaci je to SoftmaxNormalizer a SoftmaxNormalizerConfig. Třída TypNormalizaceNormalizer od třídy game.preprocessing.methods.basepreprocessor dědí a předefinuje metody. Jde například o run() (pro spuštění samotné normalizace) load- ConfigurationFromFile(String filename) (pro načtení konfigurace při dávkovém zpracování vstupních dat) a některé další. Třída TypNormalizaceNormalizerConfig rozšiřuje třídu game.preprocessing.methods.base- PreprocessorConfig předefinováním funkce setinitialvalues(). Tato metoda obsahuje volání funkcí addconfigkey() a add2ionames(), které slouží pro přidání, či inicializaci vstupních parametrů a výběr vstupních a výstupních hodnot. Konfigurace jednotlivých vstupních parametrů se provádí v konfiguračním dialogu každé jednotlivé normalizace (neplatí pro automatizované výpočty bez GUI, kdy se načte z uloženého souboru). Protože se bude zpracovávat více vstupních datových vektorů, je možné u všech číselných parametrů nastavit hodnotu pro každý vektor samostatně ve tvaru: vektor1=hodnota;vektor2=hodnota;vekstorx=hodnota Uživatelské rozhraní je možné rozšířit o nové funkce tak, že přidáme do souboru./cfg/units.cfg řádek ve tvaru: #Normalization.LinearNormalizer, kde znak mřížky určuje dialog, kam se má daná možnost přidat (v našem případě je to preprocessing dialog). Normalization je název větve stromu, od kterého tečkou oddělíme jméno třídy, která se má pro daný úkon spustit.

12 KAPITOLA 3. IMPLEMENTACE 3.1 Podpůrná třída pro normalizaci Protože většina normalizačních tříd používá stejné funkce, umístnil jsem je do jedné třídy NormalizationToolbox. Tato třída obsahuje dvě statické funkce. 1. separatecfgvalues(hashmap String, Double values, String configstring) tato funkce slouží pro separaci konfiguračních řetězců. Rozkládá řetězce ve tvaru vektor1=hodnota; vektor2=hodnota; vekstorx=hodnota na páry klíč-hodnota. Toto umožňuje individuální konfiguraci pro každý datový vektor. 01: static public void separatecfgvalues( HashMap<String, Double> values, String configstring) { 02: String[] pairs = configstring.split(";"); 03: for (String pair : pairs) { 04: String[] keyvalue = pair.trim().split("="); 05: if (keyvalue.length!= 2) 06: continue; 07: 08: keyvalue[0] = keyvalue[0].trim(); 09: keyvalue[1] = keyvalue[1].trim(); 10: 11: if (keyvalue[0].isempty() keyvalue[1].isempty()) 12: continue; 13: 14: Double value=0d; 15: try { 16: value = Double.parseDouble(keyvalue[1]); 17: } catch (NumberFormatException e) { 18: continue; 19: } 20: values.put(keyvalue[0], value); 21: } 22: } 2. getsigma(fastvector data, Double avg) tato funkce se používá na výpočet směrodatné odchylky. Jako parametry má proměnnou data typu FastVector a proměnnou avg typu Double. V proměnné data jsou uložena data, pro která se má σ vypočítat. V proměnné avg funkce očekává střední hodnotu předávaných dat, kterou použije pro výpočet podle vzorce 2.7. V případě, že hodnota avg je null, funkce zvolí pro výpočet vzorec 2.8

KAPITOLA 3. IMPLEMENTACE 13 01: static public double getsigma(fastvector data, Double avg) { 02: int count = data.size(); 03: double temp = 0; 04: // if avg == null, we will use one pass sigma calculation 05: if (avg == null) { 06: avg = 0D; 07: for (int j = 0; j < count; j++) { 08: double value = ((Double) data.elementat(j)).doublevalue(); 09: temp += (value * value); 10: avg += value; 11: } 12: avg /= count; 13: avg *= avg; 14: avg = avg * count; 15: temp = (temp - avg) / (count - 1); 16: return Math.sqrt(temp); 17: } 18: for (int j = 0; j < count; j++) { 19: double value = ((Double) data.elementat(j)).doublevalue() - avg; 20: temp += value * value; 21: } 22: return Math.sqrt(temp / (count - 1)); 23: } 3.2 Min-max normalizace Jak bylo zmíněno v kapitole 2.1, při min-max normalizaci potřebujeme znát maximální a minimální hodnotu transformované množiny. Tu můžeme získat tak, že v prvním průchodu zjistíme extrémní hodnoty, v druhém průchodu provedeme samotnou transformaci. Další možnost je nechat na uživateli, aby zvolil hranice a všechny hodnoty, které jsou mimo tento rozsah budou ořezány na spodní resp. horní hranici. Mnou použitá implementace umožňuje aplikovat obě výše zmíněné metody. Pokud uživatel nenastaví konfigurační proměnné Input Low a Input High, nebo je nastaví obě na stejnou hodnotu, modul zjistí minum a maximum vstupních hodnot a tyto použije pro samotnou normalizaci. V opačném připadě použije hodnoty zadané uživatelem. Podobně funguje i nastavení výstupního rozsahu modulu. Jestliže jej uživatel nezadá, nebo zadá identické hodnoty Output Low a Output High, modul použije jako vý-

14 KAPITOLA 3. IMPLEMENTACE Jméno parametru Význam Datový typ Předvolená hodnota Input Low Dolní hranice vstupu Double automaticky Input High Horní hranice vstupu Double automaticky Output Low Dolní hranice výstupu Double 0 Output High Horní hranice výstupu Double 1 Tabulka 3.1: Parametry modulu pro min-max normalizaci stupní rozsah interval 0, 1. Rychlost výpočtu je závislá jenom na počtu vstupních hodnot a na tom, jestli uživatel sám zvolí Input Low a Input High. V případě, že tak neučiní, je třeba tyto hodnoty zjistit a projít všechny vstupní hodnoty. Pak může proběhnout samotný výpočet podle vzorce 2.3. Časová složitost výpočtu je tak lineární. Podle toho, zda uživatel zadal vstupní hranice, funkce Run() zjistí maximální a minimální hodnotu vstupních dat (řádky 6-26). Poté v případě potřeby jednotlivé hodnoty ořeže tak, aby nebyly větší než zadané vstupní hranice (řádky 31-35) a nakonec je transformuje podle vzorce 2.3 (řádek 36) a přepočítá do daného výstupního rozsahu (řádek 38). 01: FastVector f = store.getdeepcopy(idx); 02: Double inputmin = 0D, inputmax = 0D, avg = 0D; 03: Integer count; 04: count = store.getattributelength(idx); 05: 06: if (autorange) { 07: for (int j = 0; j < count; j++) { 08: double value = ((Double) f.elementat(j)).doublevalue(); 09: if (j == 0) { // initialize min and max value 10: inputmin = value; 11: inputmax = value; 12: } 13: avg += value; 14: if (value < inputmin) { 15: inputmin = value; 16: continue; 17: } 18: if (value > inputmax) { 19: inputmax = value; 20: continue; 21: }

KAPITOLA 3. IMPLEMENTACE 15 22: } 23: avg /= count; 24: imin = inputmin; 25: imax = inputmax; 26: } 27: 28: for (int j = 0; j < count; j++) { 29: double value = ((Double) f.elementat(j)).doublevalue(); 30: double nvalue = 0; 31: if (value > imax) { 32: value = imax; 33: } else if (value < imin) { 34: value = imin; 35: } 36: nvalue = (value - imin) / (imax - imin); 37: 38: nvalue = nvalue * (omax - omin) + omin; 39: 40: f.setelementat(new Double(nvalue), j); 41: } 42: store.setdeepcopy(idx, f); 3.3 Soft-max normalizace Logistická funkce použitá pro soft-max normalizaci má jen omezený rozsah, a tedy i použití. Nastavení parametru α taktéž nepřináší rozšíření kontroly nad samotnou transformací. Jak bylo zmíněno a ukázáno v kapitole 2.2, je zajímavější kontrolovat transformaci prvotní úpravou hodnot, kde určíme šířku lineární odezvy funkce parametrem λ a až poté použít logistickou funkci. Implementace dovoluje nastavit všechny zmíněné parametry podle požadavků uživatele. Pokud uživatel nezadá parametr σ, funkce ho vypočítá automaticky. Rychlost výpočtu v tomto případě není závislá od nastavení parametrů uživatelem. I když jsme v kapitole 2.4 uvedli možnost, jak zrychlit výpočet parametru σ, střední hodnotu potřebujeme znát i pro výpočet podle rovnice 2.4, modul tedy vždy provede dva průchody vstupními hodnotami. V prvním průchodu vypočítá střední hodnotu, která se použije pro výpočet logistické funkce a výpočet parametru σ. Druhý průchod už přímo transformuje jednotlivé hodnoty podle vzorce 2.5 a 2.4. Časová složitost transformace je tak opět lineární.

16 KAPITOLA 3. IMPLEMENTACE Jméno parametru Význam Datový typ Předvolená hodnota Alpha Parametr logistické funkce Double 2 Lambda Násobek směrodatné odchylky Double 2 (95,5%) Sigma Směrodatná odchylka Double automaticky Output Low Dolní hranice výstupu Double 0 Output High Horní hranice výstupu Double 1 Tabulka 3.2: Parametry modulu pro soft-max normalizaci Samotná funkce Run() nejdříve vypočítá průměr ze vstupních hodnot (řádky 6-10), v případě že uživatel nezadal parametr Sigma vypočítá ho (řádky 11 a 12) a poté na každou hodnotu ze vstupních dat použije vzorce 2.5 a 2.4 (řádky 18 a 19). Finálně výslednou hodnotu přepočítá do zvoleného výstupního rozsahu (řádek 21). Zde stojí za zmínku, že pro výpočet podle vzorce 2.4 je použita funkce Math.expm1() (řádek 19), která podle [6] dává pro hodnoty blízké nule výrazně přesnější výsledky. 01: FastVector f = store.getdeepcopy(idx); 02: Double avg = 0D; 03: Integer count; 04: count = store.getattributelength(idx); 05: 06: for (int j = 0; j < count; j++) { 07: double value = ((Double) f.elementat(j)).doublevalue(); 08: avg += value; 09: } 10: avg /= count; 11: if (sigma == 0) 12: sigma = NormalizationToolbox.getSigma(f, avg); 13: 14: for (int j = 0; j < count; j++) { 15: double value = ((Double) f.elementat(j)).doublevalue(); 16: double nvalue = 0; 17: 18: nvalue = (value - avg) / (lambda * (sigma / (2 * Math.PI))); 19: nvalue = 1 / (1 + Math.expm1(-alpha * nvalue) + 1); 20: 21: nvalue = nvalue * (omax - omin) + omin; 22: 23: f.setelementat(new Double(nvalue), j); 24: } 25: store.setdeepcopy(idx, f);

KAPITOLA 3. IMPLEMENTACE 17 Jméno parametru Význam Datový typ Předvolená hodnota Average Střední hodnota Double 0 Sigma Směrodatná odchylka Double 1 Mode Konfigurační režim String AUTO(0) Config file path Cesta ke konfiguračnímu String.\ZscoreNormalizer.cfg souboru Tabulka 3.3: Parametry modulu pro z-score normalizaci 3.4 Z-score normalizace Z-score normalizace má pro každý z vektorů dat jako nastavitelné parametry velikost střední hodnoty a směrodatné odchylky. Tato třída má tři pracovní režimy: 1. Režim AUTO. V tomto režimu se vypočítá směrodatná odchylka i střední hodnota každého z vektorů automaticky. Tento režim se zapíná nastavením konfigurační proměnné Mode na hodnotu AUTO nebo 0. Tento režim je předvolený. 2. Režim SEMI. V tomto režimu se v případě, že není nalezen konfigurační soubor na cestě zadané parametrem Config file path, vypočítají střední hodnota a směrodatná odchylka automaticky. Poté se vytvoří soubor, do kterého se spočítané hodnoty uloží. Při dalším spuštění se již použije vytvořený soubor. Tento postup je možné použít pro zjednodušení konfigurace (uživatel nemusí vyplňovat všechny hodnoty stačí když upraví vytvořený soubor) nebo pro automatické nastavení, či jeho zachování pro opakované spuštění pro jinou množinu dat. Tento režim se zapíná nastavením konfigurační proměnné Mode na hodnotu SEMI nebo 1. 3. Režim MANUAL. V tomto režimu velikost střední hodnoty i směrodatné odchylky zadá sám uživatel. Tento režim se zapíná nastavením konfigurační proměnné Mode na hodnotu MANUAL nebo 2. 01: FastVector f = store.getdeepcopy(idx); 02: Double avg = 0D, sigma = 0D;

18 KAPITOLA 3. IMPLEMENTACE 03: Integer count; 04: count = store.getattributelength(idx); 05: 06: switch (mode) { 07: default: 08: case AUTO: 09: // average input values 10: for (int j = 0; j < count; j++) { 11: double value = ((Double) f.elementat(j)).doublevalue(); 12: avg += value; 13: } 14: avg /= count; 15: sigma = NormalizationToolbox.getSigma(f, avg); 16: break; 17: case SEMI: 18: if (compute) { 19: for (int j = 0; j < count; j++) { 20: double value = ((Double) f.elementat(j)).doublevalue(); 21: avg += value; 22: } 23: avg /= count; 24: sigma = NormalizationToolbox.getSigma(f, avg); 25: avgstring += ";" + datasetname + "=" + avg; 26: sigmastring += ";" + datasetname + "=" + sigma; 27: } else { 28: avg = cavg; 29: sigma = csigma; 30: } 31: break; 32: case MANUAL: 33: // use user defined value 34: avg = cavg; 35: sigma = csigma; 36: break; 37: } 38: // process every value in dataset 39: for (int j = 0; j < count; j++) { 40: double value = ((Double) f.elementat(j)).doublevalue(); 41: double nvalue = (value - avg) / sigma; 42: f.setelementat(new Double(nvalue), j); 43: } 44: 45: store.setdeepcopy(idx, f); Funkce Run() operuje v závislosti na nastaveném režimu. V režimu AUTO (řádky 8-16) vypočítá velikost střední hodnoty a směrodatné odchylky. V režimu SEMI (řádky

KAPITOLA 3. IMPLEMENTACE 19 17-31) dle toho zda existuje nebo neexistuje konfigurační soubor hodnoty spočíta respektive načte. V režimu MANUAL (řádky 17-36) použije hodnoty zadané uživatelem. Poté podle vzorce 2.9 upraví jednotlivé hodnoty (řádky 39-43). Pro výpočet střední hodnoty a směrodatné odchylky je třeba projít všechny hodnoty časová složitost algoritmu je linární. 3.5 Transformace střední hodnoty Třída pro transformaci střední hodnoty se téměř úplně shoduje s třídou pro z- score normalizaci. Rovněž má tři funkční režimy. Chybí v ní však výpočet a konfigurační parametr pro hodnotu směrodatné odchylky σ. Výpočet proběhne podle vzorce 2.10. Jméno parametru Význam Datový typ Předvolená hodnota Average Střední hodnota Double 0 Mode Konfigurační režim String AUTO(0) Config file path Cesta ke konfiguračnímu String.\MeanNormalizer.cfg souboru Tabulka 3.4: Parametry modulu pro normalizaci střední hodnoty 3.6 Uživatelem definovaná normalizace 3.6.1 JavaScript Skriptování jazykem JavaScript je implementováno třídou CustomJsNormalization. Tato třída ma jediný parametr Script path, který udává cestu ke skriptu, jenž se má vykonat. Skript obdrží najednou všechny vektory dat jako jednotlivá pole. Tato pole jsou datového typu String a jejich jméno se shoduje se jmény vektoru v systému FAKE GAME. Zde je důležité upozornit na to, že pole je předáváno jako pole řetězců. Operace sčítání tedy automaticky přetypuje případné číslo opět na řetězec. To pak může mít za následek nepředvídatelné chování skriptu a programu. 01: ScriptEngineManager manager = new ScriptEngineManager(); 02: ScriptEngine engine = manager.getenginebyname("javascript"); 03:

20 KAPITOLA 3. IMPLEMENTACE Jméno parametru Význam Datový typ Předvolená hodnota Script path Cesta k skriptu String c:\script.js Tabulka 3.5: Parametry modulu pro normalizaci skriptu v jazyce JavaScript 04: // load every dataset as array into the javascript engine 05: for (int i = 0; i < s.length; i++) { 06: String datasetname = s[i]; 07: int idx = store.getattributeindex(datasetname); 08: FastVector f = store.getdeepcopy(idx); 09: engine.put(datasetname, f.toarray()); 10: } 11: 12: // execute script 13: try { 14: File tmp = new File(sPath); 15: System.out.println(tmp.getAbsolutePath()); 16: engine.eval(new FileReader(sPath)); 17: } catch (FileNotFoundException e) { 18: } catch (ScriptException e) { 19: } 20: 21: // get variables back and store them 22: for(string name : s){ 23: int idx = store.getattributeindex(name); 24: Object[] newvalues = (Object[]) engine.get(name); 25: FastVector f = new FastVector(); 26: for (int j=0; j<newvalues.length; j++){ 27: f.addelement(newvalues[j]); 28: } 29: store.setdeepcopy(idx, f); 30: } Funkce Run() nejdříve vytvoří JavaScript engine (řádky 1-2), poté do něj přídá všechny vektory dat (řádky 5-9) a vykoná skript na cestě zadané uživatelem v parametru Script path (řádky 13-19). Nakonec vybere všechny hodnoty a uloží je zpět do systému FAKE GAME (řádky 22-30). 3.6.2 Jazyk MATLAB Implementace jazyka MATLAB je složitější než implementace jazyka JavaScript. Pro vykonání samotného skriptu byl použit systém Octave, který je volně šířitelný pod

KAPITOLA 3. IMPLEMENTACE 21 Jméno parametru Význam Datový typ Předvolená hodnota Script path Cesta k skriptu String c:\script.m Octave path Cesta k systému Octave String c:\program files\octave \bin\octave.exe Tabulka 3.6: Parametry modulu pro normalizaci skriptu v jazyce MATLAB licencí GPL. [8] Jazyk tohoto systému je kompatibilní s jazykem MATLAB. Pro provázání systémů FAKE GAME a Octave bylo navíc potřeba využít knihovny jopas. [9] Stabilní verze knihovny jopas už je několik let stará a bylo ji potřeba upravit tak, aby fungovala s jazykem Java ve verzi 1.6. Při této úpravě jsem také odstranil starší knihovny, které jsou už použity v systému FAKE GAME a zmenšil tak velikost knihovny jopas na 30kB (původně 4,1MB). Taktéž jsem přidal další konstruktor pro objekt Matrix, díky kterému se zjednodušší jeho používání. Stejně jako v předchozím případě jsou všechny datové vektory předány najednou pod jménem vystupujícím v systému FAKE GAME. Samotnou implementaci je možno najít ve třídě CustomOctaveNormalizer. Kromě parametru Script path, který by měl odkazovat na soubor se skriptem, má tato třída ještě parametr Octave path, kde je třeba nastavit cestu k systému Octave. Poměrně závažným nedostatkem je, že systém Octave startuje až několik sekund a tak výrazně prodlužuje celý proces normalizace. 01: // jopas initialization 02: String[] path = { opath }; 03: Jopas jopas = new Jopas(path); 04: 05: // load every dataset into the jopas variable 06: for (int i = 0; i < s.length; i++) { 07: String datasetname = s[i]; 08: int idx = store.getattributeindex(datasetname); 09: FastVector f = store.getdeepcopy(idx); 10: 11: Double[] doublearray = new Double[f.size()]; 12: Object[] objarray = f.toarray(); 13: 14: for(int j=0; j<doublearray.length; j++){ 15: doublearray[j]=(double) objarray[j]; 16: }