bachelorarbeit magic mushroom app - ntb.ch · der ntb hochladen, damit die neuronalen netze zu...

BACHELORARBEIT MAGIC MUSHROOM APP Mit Deep Learning essbare Pilze erkennen

Autoren:

Riccardo Jung Dominik Wagner

[email protected] [email protected]

Referenten:

Prof. Dr. Christoph Würsch Prof. Dr. Klaus Frick

[email protected] [email protected]

I / II Abstract

06.08.2018 Riccardo Jung, Dominik Wagner I

I Abstract DE

Die Klassifizierung verschiedener Pilzarten ist für Laien extrem schwierig. Die bis anhin zur Verfügung stehenden

Hilfsmittel, wie zum Beispiel Pilzbücher, sind für Laien als Entscheidungshilfen nur bedingt geeignet. Viele

Merkmale sind nur von Experten sicher zu bestimmen. Das Ziel dieser Bachelorarbeit ist die Entwicklung und die

Machbarkeitsabklärung einer App, mit der auch Laien Pilze klassifizieren können. Die Nutzer1 der App sollen

dafür lediglich ein oder mehrere Bilder des gefundenen Pilzes machen und Angaben über die Grösse des Pilzes

zur Verfügung stellen. Die Klassifizierung erfolgt durch ein tiefes neuronales Faltungsnetz (CNN).

Als Erstes wurde eine Datenbank mit ca. 35’000 Bildern von 15 Pilzarten erstellt. Diese Daten dienen sowohl als

Trainings als auch als Validierungsdaten. Über eine Gitter-Suche (grid search) wurde die optimale Architektur des

CNN bestimmt. Erreicht wird auf den Testdaten der Lamellenpilze eine Trefferquote von 85.2 % und bei den

Röhrlingen eine von 75.0 %. Die App steht als Webapplikation unter magic.ntb.ch für alle Anwender offen zur

Verfügung, mit dem Ziel, die App durch Inputs aus der Community zu verbessern.

II Abstract EN

The classification of different types of mushrooms is extremely difficult for non-professionals. The available tools,

such as mushroom books, are only conditionally suitable as decision aids for non-professionals. Experts can only

determine many features reliably. The aim of this bachelor thesis is to develop and check the feasibility of an

application that allows non-professionals to classify mushrooms. The users of the application shall only take one

or more photos of the mushroom and enter the size of the mushroom. The application will then classify the

mushroom by using a proven deep neural network.

First, a database with approximately 35’000 images of 15 different mushrooms was created. This data is used as

both training and validation data. A grid search was used to determine the optimal architecture of the CNN. A hit

rate of 85.2 % is achieved on the test data of the lamellar mushrooms and 75.0 % for the boletuses. The app is

available to all users as a web application at magic.ntb.ch with the aim of improving the app through inputs from

the community.

1 In der folgenden Arbeit wird aus Gründen der besseren Lesbarkeit ausschliesslich die männliche Form verwendet. Sie bezieht sich auf Personen beiderlei Geschlechts.

III Zusammenfassung

06.08.2018 Riccardo Jung, Dominik Wagner II

III Zusammenfassung

Das Ziel dieser Bachelorarbeit bestand in der Entwicklung einer Applikation, mit welcher Pilze anhand von Bildern

klassifiziert werden können. Mit dieser Entwicklung soll die Machbarkeit einer solchen App geklärt werden. Die

Klassifizierung war mithilfe von neuronalen Netzen durchzuführen. Zudem sollte eine grafische Benutzer-

oberfläche programmiert werden, die einfach und intuitiv zu bedienen ist.

Um solche neuronalen Netze trainieren zu können, mussten sowohl hardware- als auch softwaretechnische

Vorkehrungen getroffen werden. Zu Beginn wurde eine Workstation der NTB mit einer NVIDIA GTX 1080 Ti

Grafikkarte ausgerüstet und alle benötigten Programme und Bibliotheken installiert. Zudem erhielten wir einen

Zugriff auf eine NVIDIA Tesla V100 Grafikkarte der Hochschule für Technik Rapperswil (HSR), um die neuronalen

Netze zu trainieren. Einen Überblick der verwendeten Software und einen Vergleich der verschiedenen

Grafikkarten sind in den Kapiteln 2 und 3 dokumentiert.

Die Basis für das Training der neuronalen Netze waren die Trainingsbilder. Es wurden tausende Bilder von

verschiedenen Pilzen aus dem Internet heruntergeladen und standardisiert. Das bedeutet, dass in jedem Bild

mithilfe eines bereits trainierten neuronalen Netzes die Pilze lokalisiert wurden. Anschliessend wurden diese

Bilder zentriert, zugeschnitten und auf eine einheitliche Grösse von 256x256 Pixel gebracht. Damit die Anzahl an

Bildern möglichst gross ist, wurden anschliessend alle Bilder vervielfacht. Dies gelang durch das Spiegeln, Drehen

und durch die Anpassung des Gammawertes jedes einzelnen Bildes. Die gesamte Anzahl an Bildern stieg damit

auf ca. 35’000 Stück. Alle durchgeführten Arbeiten bis zur fertigen Pilzdatenbank sind im Kapitel 4 dieser Arbeit

dokumentiert.

Nachdem die Trainingsdaten vorbereitet waren, konnten erste Versuche mit tiefen neuronalen Faltungs-

netzwerken (CNNs) gestartet werden. Da keine Vorkenntnisse vorhanden waren, mussten wir uns zuerst in die

Theorie der neuronalen Netze einarbeiten. Eine Zusammenfassung der Theorie und die ersten Testergebnisse

sind dem Kapitel 5 zu entnehmen. Nach den ersten Versuchen mit fünf Pilzarten wurde das Training auf 15

Pilzarten ausgeweitet. Da die Ergebnisse nicht zufriedenstellend waren, wurden die 15 Pilzarten in Röhrlinge und

Lamellenpilze unterteilt. Zusätzlich wurden dem neuronalen Netz neben den Bildern auch Informationen über

die Grösse des Pilzes zur Verfügung gestellt.

Als die grundlegenden Funktionen der Software programmiert waren, wurde die optimale Architektur und die

optimalen Hyperparameter des CNN mit einer Gittersuche bestimmt. Damit die Ergebnisse bestmöglich

verglichen werden konnten, wurden bei jedem Test Logdateien erstellt, die anschliessend ausgewertet werden

konnten. Alle Testreihen und die dazugehörigen Resultate sind ebenfalls im Kapitel 5 dokumentiert.

Zum Schluss wurde eine Webapplikation entwickelt, welche sowohl von einem Computer, als auch von einem

Mobilgerät aus verwendet werden kann. Dazu ist weder eine Installation, noch ein bestimmtes Betriebssystem

vorausgesetzt. Der Benutzer hat damit die Möglichkeit, direkt ein oder mehrere Bilder mit seinem Mobilgerät

aufzunehmen oder Bilder aus seinem Verzeichnis auszuwählen, um diese anschliessend klassifizieren zu lassen.

Die Webapplikation zeigt daraufhin das Resultat inklusive eines Beispielbildes und einigen allgemeinen

Informationen zum klassifizierten Pilz. Zudem können die Benutzer auch eigene Bilder von Pilzen auf einen Server

der NTB hochladen, damit die neuronalen Netze zu einem späteren Zeitpunkt erweitert werden können. Alle

Funktionen und das Design der Webapplikation sind im Kapitel 6 ausführlich beschrieben und visualisiert.

Inhaltsverzeichnis

06.08.2018 Riccardo Jung, Dominik Wagner

Inhaltsverzeichnis

I Abstract DE ............................................................................................................................................................. I

II Abstract EN ............................................................................................................................................................ I

III Zusammenfassung .............................................................................................................................................. II

1 Motivation und Ziel ......................................................................................................................................... 1

1.1 Ziel ........................................................................................................................................................... 1

1.2 Vision ....................................................................................................................................................... 1

2 Software .......................................................................................................................................................... 2

2.1 Anaconda ................................................................................................................................................ 2

2.2 PyCharm .................................................................................................................................................. 2

2.3 OpenCV ................................................................................................................................................... 2

2.4 TensorFlow .............................................................................................................................................. 3

2.5 TensorBoard ............................................................................................................................................ 3

3 Hardware......................................................................................................................................................... 4

3.1 NVIDIA GeForce GTX 645 ........................................................................................................................ 4

3.2 NVIDIA GeForce GTX 1080 Ti ................................................................................................................... 4

3.3 NVIDIA Tesla V100 ................................................................................................................................... 4

3.4 Vergleich der Grafikkarten ...................................................................................................................... 5

4 Bildvorverarbeitung ........................................................................................................................................ 6

4.1 Rückblick Fachmodul ............................................................................................................................... 6

4.2 Kreuzkorrelation komplett ...................................................................................................................... 7

4.3 Kreuzkorrelation zeilenweise .................................................................................................................. 8

4.4 Vorverarbeitete Bilder............................................................................................................................. 9

5 Neuronales Netz ............................................................................................................................................ 12

5.1 Theorie Convolutional Neural Network (CNNs) ..................................................................................... 12

5.1.1 Convolutional Neural Networks Einführung .................................................................................. 12

5.1.2 Biologische Inspiration .................................................................................................................. 12

5.1.3 Convolutional Neural Network Architektur und Schichten ........................................................... 13

5.1.4 Optimizer ....................................................................................................................................... 17

5.1.5 Overfitting vermeiden ................................................................................................................... 17

5.2 Erstes Netzwerk..................................................................................................................................... 18

5.2.1 Resultate erster Tests .................................................................................................................... 19

5.3 Training mit 15 Pilzarten ....................................................................................................................... 20

5.3.1 Ergebnis ......................................................................................................................................... 20

5.3.2 Diskussion ...................................................................................................................................... 21

5.3.3 Fazit ............................................................................................................................................... 21

Inhaltsverzeichnis


5.4 Training mit zusätzlichen Features ........................................................................................................ 22

5.4.1 Ergebnis ......................................................................................................................................... 22

5.4.2 Diskussion ...................................................................................................................................... 23

5.4.3 Fazit ............................................................................................................................................... 23

5.5 Einleitung Testreihen ............................................................................................................................ 24

5.6 Lamellenpilze Testreihe 1 ...................................................................................................................... 26

5.6.1 Konfiguration ................................................................................................................................. 26

5.6.2 Ergebnis ......................................................................................................................................... 26

5.6.3 Diskussion ...................................................................................................................................... 28

5.6.4 Fazit ............................................................................................................................................... 28

5.7 Lamellenpilz Testreihe 2 ........................................................................................................................ 29

5.7.1 Konfiguration ................................................................................................................................. 29

5.7.2 Ergebnis ......................................................................................................................................... 29

5.7.3 Diskussion ...................................................................................................................................... 30

5.7.4 Fazit ............................................................................................................................................... 32

5.8 Lamellenpilze Testreihe 3 ...................................................................................................................... 33

5.8.1 Konfiguration ................................................................................................................................. 33

5.8.2 Ergebnis ......................................................................................................................................... 33

5.8.3 Diskussion ...................................................................................................................................... 34

5.8.4 Fazit ............................................................................................................................................... 35

5.9 Fazit Testreihen Lamellenpilze .............................................................................................................. 36

5.10 Röhrlinge Testreihe 1 ............................................................................................................................ 38

5.10.1 Konfiguration ................................................................................................................................. 38

5.10.2 Ergebnis ......................................................................................................................................... 38

5.10.3 Diskussion ...................................................................................................................................... 39

5.10.4 Fazit ............................................................................................................................................... 40


5.11.1 Konfiguration ................................................................................................................................. 41

5.11.2 Ergebnis ......................................................................................................................................... 41

5.11.3 Diskussion ...................................................................................................................................... 42

5.11.4 Fazit ............................................................................................................................................... 43


5.12.1 Konfiguration ................................................................................................................................. 44

5.12.2 Ergebnis ......................................................................................................................................... 44

5.12.3 Diskussion ...................................................................................................................................... 45

5.12.4 Fazit ............................................................................................................................................... 46

5.13 Fazit Testreihen Röhrlinge ..................................................................................................................... 47

Inhaltsverzeichnis


6 Webapplikation ............................................................................................................................................. 49

6.1 Pilz klassifizieren .................................................................................................................................... 50

6.2 Pilz Upload ............................................................................................................................................. 52

6.2.1 Sicherheit ...................................................................................................................................... 53

6.3 About ..................................................................................................................................................... 53

7 Schlussfolgerung ........................................................................................................................................... 54

8 Ausblick ......................................................................................................................................................... 55

9 Danksagung ................................................................................................................................................... 56

10 Eigenständigkeitserklärung ........................................................................................................................... 57

11 Abbildungsverzeichnis ................................................................................................................................... 58

12 Tabellenverzeichnis ....................................................................................................................................... 62

13 Literaturangaben ........................................................................................................................................... 63

14 Anhang .......................................................................................................................................................... 67

14.1 Anleitung: Einrichten der Workstation ................................................................................................. 67

14.2 Anleitung: Erweiterung der Applikation ................................................................................................ 68

14.2.1 Anleitung Bildvorverarbeitung ...................................................................................................... 68

14.2.2 Anleitung Training neuronales Netz .............................................................................................. 69

14.2.3 Anleitung Anpassung Webapplikation .......................................................................................... 71

14.3 Python Skripts ....................................................................................................................................... 72

14.3.1 Vorverarbeitung (Mushroom_Finder.py) ...................................................................................... 72

14.3.2 Training neuronales Netz (Mushroom_Classifier.py) .................................................................... 76

14.3.3 Datensatz vorbereiten (dataset.py) .............................................................................................. 80

14.3.4 Schichten für neuronales Netz (layer.py) ...................................................................................... 82

14.3.5 Logdateien (log.py) ........................................................................................................................ 83

14.3.6 Zusätzliche Features (MushroomFeatures_JSON.py).................................................................... 84

14.4 JSON File (MushroomFeatures.json) ..................................................................................................... 85

14.5 Testergebnisse Grid-Tests ..................................................................................................................... 87

1 Motivation und Ziel 1.1 Ziel

06.08.2018 Riccardo Jung, Dominik Wagner 1

1 Motivation und Ziel

Essbare von nicht essbaren Pilzen zu unterscheiden ist eine äusserst komplexe Disziplin, welche meist nur durch

fachliche geschulte Experten der Pilzkontrollstellen beherrscht wird. Für einen Laien ist die Bestimmung der Pilze

mittels Pilzbestimmungsbücher extrem schwierig. Hinzu kommt die Restunsicherheit, da viele Pilze einen

sogenannten Doppelgänger besitzen, welcher ungeniessbar oder gar giftig ist. Es fehlt schlicht die langjährige

Erfahrung in dieser Disziplin.

Genau dieses Problem stellt die Motivation dieser Arbeit dar. Die mangelnde Erfahrung eines Laien in der

Pilzbestimmung soll mit möglichst einfachen Mitteln abgedeckt werden, damit die Restunsicherheit möglichst

gering ist. Die jahrelange Erfahrung der Pilzexperten soll mittels künstlicher Intelligenz nachgebildet werden.

Dazu wird ein neuronales Netz mit tausenden Pilzbildern trainiert.

Doch wie kommt nun ein Laie an diese Informationen? Im Zeitalter der Digitalisierung trägt beinahe jeder ein

Smartphone mit sich herum. Daher ist es naheliegend, dass bei der Pilzbestimmung genau dieses Mittel genutzt

wird. Für den Benutzer soll es anhand von einem Bild und einfach erkennbaren Merkmalen möglich sein, den

gefundenen Pilz zu bestimmen. Damit könnte die Restunsicherheit wesentlich minimiert werden.

1.1 Ziel

Ziel dieser Bachelorarbeit ist die Entwicklung und das Trainieren eines convolutional neural networks (CNN) zur

Bestimmung von heimischen Pilzen (Schweiz, Österreich und Deutschland). Dabei sollen je zwei Bilder plus einige

wenige einfach bestimmbare Merkmale als Inputvektor für das convolutional neural network dienen. Die

Bachelorarbeit beinhaltet folgende Aufgaben:

Einarbeiten in die Theorie der neuronalen Netzwerke (Fachmodul)

Erste Schritte mit Python, ScikitLearn und TensorFlow (Fachmodul)

Bereitstellen einer Bilddatenbank für das Training der neuronalen Netze

Trainieren des convolutional neural network mit TensorFlow

Bestimmung der Klassifikationsfehlerraten

Erstellen einer Webapplikation [1]

1.2 Vision

Für Pilzsuchende soll eine einfach bedienbare Webapplikation entwickelt werden, mit der eine Pilzbestimmung

möglichst einfach durchgeführt werden kann. Diese App könnte zu einem grossen Erfolg werden.

Damit die Applikation wachsen und die Klassifizierung der Pilze immer genauer werden kann, wird die Mithilfe

der Community ein richtungsweisender Faktor sein. Aus diesem Grund soll die Applikation einfach erweiterbar

sein. So soll es möglich sein, immer mehr Pilzarten dem neuronalen Netz hinzuzufügen und damit den Benutzern

eine breitere Produktpalette zur Verfügung zu stellen. Mit der Hilfe der Benutzer könnte die Applikation gar einen

weltweiten Erfolg feiern, da dies die erste Applikation auf dem Markt ist, welche Pilze mittels Fotoaufnahmen

klassifizieren kann.

2 Software 2.1 Anaconda


2 Software

Auf den folgenden beiden Seiten werden alle nötigen Tools und Bibliotheken kurz erklärt. Alle von uns

verwendeten Tools sind kostenlos und können jederzeit im Internet heruntergeladen werden.

2.1 Anaconda

Die Anaconda Distribution ist eine Open Source Software für die

Programmiersprachen Python und R. Sie beinhaltet unter anderem die

Entwicklungsumgebung Spyder, den Kommandozeileninterpreter IPython und

weitere Tools für die Programmierung mit Python. [2]

Abbildung 1 Logo Anaconda [3]

Für die Programmierung mit Python wurde Spyder verwendet, welches in der Anaconda Distribution enthalten

ist. Weitere Bibliotheken wie OpenCV und CUDA konnten einfach über die Kommandozeile installiert werden.

Da die Arbeit mit Anaconda und Spyder während der Bachelorarbeit allerdings dauernd zu unerklärlichen

Problemen führte, wurde als Alternative PyCharm verwendet.

2.2 PyCharm

PyCharm ist eine integrierte Entwicklungsumgebung (IDE) für die Programmiersprache

Python, die von JetBrains entwickelt wurde. Mithilfe von PyCharm konnten

Softwarebibliotheken wie zum Beispiel OpenCV oder TensorFlow leicht importiert und

verwendet werden. PyCharm bietet zudem nützliche Funktionen wie zum Beispiel eine

intelligente Code-Vervollständigung, Code-Inspektionen oder umfassende Naviga-

tionsfunktionen. [4]

Abbildung 2 Logo PyCharm [5]

2.3 OpenCV

OpenCV, oder auch Open Source Computer Vision Library, ist wie der Name schon

vorwegnimmt, eine Open Source Computer Vision und Machine Learning Bibliothek.

OpenCV kann sowohl für kommerzielle, wie auch für nicht kommerzielle Anwendungen

verwendet werden, da sie als sogenannte BSD – Lizenz kopiert, verändert und verbreitet

werden darf. Einzig die Urheberrechte (Copyright) müssen deklariert werden.

Abbildung 3 Logo OpenCV [6]

Die Bibliothek beinhaltet mehr als 2500 optimierte Algorithmen, welche im Feld der Computer Vision und

Machine Learning Verwendung finden. Darunter sind beispielsweise Algorithmen für die Objekterkennung,

Klassifizierung von Personen in Videos, aber auch klassische Bildverarbeitungsalgorithmen, wie zum Beispiel das

Entfernen von roten Augen in Bildern.

OpenCV unterstützt sowohl Windows, Linux, wie auch Mac OS und hat Interfaces für die Programmiersprachen

C++, C, Java, Python und MATLAB. [7]

2 Software 2.4 TensorFlow


2.4 TensorFlow

TensorFlow ist eine Open Source Softwarebibliothek, die ursprünglich von

Forschern und Ingenieuren des Brain-Teams in der KI-Organisation von Google

entwickelt wurde. Die Softwarebibliothek bietet eine Vielzahl von

Möglichkeiten für maschinelles Lernen. [8]

Abbildung 4 Logo Tensorflow [9]

Durch die flexible Architektur können Berechnungen einfach auf verschiedenen Plattformen implementiert

werden. Unsere Berechnungen wurden mithilfe einer Grafikkarte, oder auch GPU (Graphics Processing Unit)

genannt, durchgeführt.

2.5 TensorBoard

Um die neuronalen Netze, welche mittels TensorFlow erzeugt

wurden, zu visualisieren, gibt es ein Visualisierungstool namens

TensorBoard. Mithilfe dieses Tools können verschiedene

neuronale Netze einfach verglichen und gezielt optimiert

werden. In der Abbildung 5 sieht man beispielsweise die

Ergebnisse zweier verschiedenen neuronalen Netze. Zudem

kann auch die Architektur des neuronalen Netzes einfach

dargestellt werden. Diese werden im weiteren Verlauf des

Dokuments aufgezeigt. [10]

Abbildung 5 TensorBoard – Dargestellt ist ein Beispiel

für die Visualisierung der validation accuracy und des

validation loss von zwei neuronalen Netzen in

TensorBoard.

3 Hardware 3.1 NVIDIA GeForce GTX 645


3 Hardware

Für die Entwicklung von neuronalen Netzen wird eine grosse Rechenleistung beansprucht. Damit diese Leistung

erbracht werden kann, wird meist auf Grafikprozessoren (GPU) gerechnet. Der grosse Vorteil der GPU ist die

grosse Anzahl an verbauten Kernen, welche parallele Berechnungen erlauben.

Mit der Hilfe des CUDA-Treibers konnten die bereits verbauten Grafikprozessoren der NTB-Rechner verwendet

werden. Dadurch wird der Vorteil genutzt, dass Programmteile, wie bei uns die Berechnung des neuronalen

Netzes, durch die signifikant schnellere GPU abgearbeitet werden, anstatt wie herkömmlich mit dem normalen

Prozessor (CPU). Zur Übersicht wird die verwendete Hardware kurz vorgestellt und verglichen.

3.1 NVIDIA GeForce GTX 645

In den bereitgestellten Rechnern der NTB waren Grafikprozessoren der Marke NVIDIA vom Typ NVIDIA GeForce

GTX 645 verbaut, welche CUDA unterstützen. Daher konnten diese für erste Tests verwendet werden.

Da diese Grafikkarte jedoch schon seit dem Jahre 2013 auf dem

Markt ist, kann sie bezüglich Leistung nicht mehr mit den neueren

Grafikkarten konkurrenzieren. Deswegen wurde für die weitere

Berechnung der neuronalen Netze eine neue Grafikkarte

angeschafft. Auch diese möchte kurz vorgestellt werden. [11]

Abbildung 6 NVIDIA GeForce GTX 645 [12]

3.2 NVIDIA GeForce GTX 1080 Ti

Die GeForce GTX 1080 Ti aus dem Hause NVIDIA ist das

momentane Flaggschiff (Stand April 2018) unter den NVIDIA-

Gaming-Grafikkarten. Verbaut in ein Asus Gehäuse bietet diese

Grafikkarte ein extrem leistungsstarkes Paket, welches ein

schnelleres Training der neuronalen Netze garantiert. [13]

Diese Grafikkarte wurde in die bereits bestehende Workstation

des Institutes ICE (Institut für Computational Engineering)

eingebaut.

Abbildung 7 NVIDIA GeForce GTX 1080 Ti [14]

3.3 NVIDIA Tesla V100

Eine noch stärkere Grafikkarte steht uns am GPU Cluster der

Partnerhochschule HSR (Hochschule für Technik Rapperswil) zur

Verfügung. Die NVIDIA Tesla V100 ist der bislang fortschrittlichste

KI-Grafikprozessor auf dem Markt und speziell für die Entwicklung

von neuronalen Netzen ausgelegt. [15]

Ein kurzer Vergleich der drei verwendeten Grafikkarten soll

Aufschluss über die Leistungsunterschiede geben.

Abbildung 8 NVIDIA Tesla V100 [16]

3 Hardware 3.4 Vergleich der Grafikkarten


3.4 Vergleich der Grafikkarten

Zur Veranschaulichung der Unterschiede werden in Tabelle 1 die signifikantesten Punkte aufgelistet.

NVIDIA GeForce GTX 645 NVIDIA GeForce GTX 1080 Ti NVIDIA Tesla V100

Prozessortaktung 823 MHz 1569 MHz 1455 MHz

Speicherkapazität 1 GB 11 GB 16 GB

CUDA

Recheneinheiten

576 3584 5120

Leistungsaufnahme 130 W 250 W 300 W

Tabelle 1 Vergleich Grafikkarten [15, 17, 18]

Wie in der Tabelle 1 ersichtlich, ist die GeForce GTX 1080 Ti um einiges besser bestückt als die GeForce GTX 645.

Dies macht sich in der Rechenleistung klar bemerkbar. Laut Datenblatt ist die neue GTX 1080 Ti rund zwölfmal

schneller als die etwas ältere Grafikkarte vom Typ GeForce GTX 645.

Mit der NVIDIA Tesla V100 haben wir die momentan beste Grafikkarte für das Trainieren von neuronalen Netzen

aus dem Hause NVIDIA zur Verfügung. Mit 5120 CUDA Recheneinheiten ist sie nochmals rund 50 % stärker

bestückt als die High-End-Gaming-Grafikkarte. [15]

Damit man einen guten Überblick über die Performance der drei Grafikkarten bekommt, werden diese über

einen Benchmark-Test verglichen. Als Test wurde ein neuronales Netz auf allen GPU’s trainiert und die benötigte

Rechenzeit verglichen. Dieser Vorgang wurde dreimal wiederholt, damit sich kurzfristige Seiteneffekte nicht auf

das Testresultat auswirken.

Im Benchmark-Test wurde dasselbe Python Skript wie für den Grid-Test verwendet, jedoch wurde nur ein Netz

mit 128x128 Pixel grossen Bildern und vier convolutional layer über 100 Epochen trainiert. Der grosse

Unterschied zu den Grid-Tests ist, dass nur mit einer Batchgrösse von 32 Bildern pro Batch gearbeitet werden

konnte, da die Ressourcen in der NVIDIA GeForce GTX 645 mit einem Speicher von 1GB sehr begrenzt sind. In

Tabelle 2 sind die Resultate des Benchmark-Tests ersichtlich.

NVIDIA GeForce GTX 645 NVIDIA GeForce GTX 1080 Ti NVIDIA Tesla V100

Benötigte Rechenzeit

Test 1

2h 40 min 25 s 16 min 56 s 16 min 18 s


Test 2

2h 40 min 1 s 16 min 54 s 16 min 19 s


Test 3

2h 40 min 15 s 16 min 55 s 16 min16 s

Durchschnittliche

Rechenzeit

2h 40min 14 s 16 min 55 s 16 min 18 s

Tabelle 2 Benchmark-Test

Anhand des Tests wird die enorme Performance der neuen Grafikkarten ersichtlich. Diese konnten wir uns beim

Berechnen der neuronalen Netze zu Nutze machen, da diese Berechnungen extrem zeitintensiv sind. Der kleine

Unterschied der NVIDIA GeForce GTX 1080 Ti und der NVIDIA Tesla V100 ist auf die kleine Batchgrösse

zurückzuführen. Dadurch kann nicht die volle Performance der NVIDIA Tesla V100 ausgenutzt werden.

4 Bildvorverarbeitung 4.1 Rückblick Fachmodul


4 Bildvorverarbeitung

4.1 Rückblick Fachmodul

Um die neuronalen Netze trainieren zu können, müssen möglichst viele

Trainingsdaten zur Verfügung gestellt werden. Dafür wurde als Vorbereitung

für die Bachelorarbeit im Fachmodul bereits ein neuronales Netz trainiert,

welches einen Pilz innerhalb eines Bildes lokalisiert. Mit dieser Information

konnte das Bild anschliessend zugeschnitten werden, damit zum Beispiel Laub,

wie in der Abbildung 9 zu sehen, das Training des neuronalen Netzes nicht

unnötig erschwert oder sogar unmöglich macht.

Abbildung 9 Pilz lokalisieren – Das blaue

Rechteck um den Pilz herum zeigt, wo

der Pilz lokalisiert wurde.[19]

Danach wurden die Pilze innerhalb des Ausschnitts zentriert. Dies erfolgte durch das Aufsummieren der

Grauwerte in der unteren Hälfte des Bildes. Das Ziel dabei war, die Position des Stiels zu bestimmen. Dafür wurde

das Maximum innerhalb des Diagramms, welches in der Abbildung 10 auf der rechten Seite ersichtlich ist, gesucht

und so das neue Zentrum des Bildes definiert.

Abbildung 10 Pilz zentrieren – Die blaue Linie zeigt, wo das Zentrum des Pilzes durch das Aufsummieren aller Grauwerte in der unteren

Hälfte des Bildes bestimmt wurde. [20]

Da allerdings nicht alle Pilze ausreichend im Bild zentriert waren, konnte es vorkommen, dass einige Pilze am

Rand abgeschnitten wurden, sobald sie gedreht wurden. Darum wurde im Rahmen der Bachelorarbeit versucht,

eine Zentrierung mittels Kreuzkorrelation durchzuführen, welche im Kapitel 4.2 und 4.3 dokumentiert ist.

Die zugeschnittenen Bilder wurden anschliessend vervielfacht, um den Datensatz künstlich zu vergrössern. Dafür

wurde das Originalbild gespiegelt, gedreht und der Gamma Wert angepasst. Zudem wurden die Bilder auf eine

einheitliche Grösse von 256x256 Pixel zugeschnitten. Mithilfe dieser Massnahmen konnten aus einem Bild 12

Trainingsbilder erzeugt werden. In der Abbildung 11 ist ein Beispiel mit einem Sommersteinpilz ersichtlich.

Abbildung 11 Bilder vervielfachen – Dargestellt sind alle Varianten der Vervielfachung der Pilzbilder. [21]

4 Bildvorverarbeitung 4.2 Kreuzkorrelation komplett


4.2 Kreuzkorrelation komplett

Wie bereits erwähnt, war die Zentrierung der Pilze innerhalb des Bildes bis anhin nicht immer optimal. Deshalb

wurde mittels Kreuzkorrelation versucht, die Pilze besser zu zentrieren. Dafür wurde der lokalisierte Pilz grob

zugeschnitten und an der Y-Achse gespiegelt. Dieses Bild wurde dann Pixel für Pixel entlang der X-Achse über das

Originalbild gelegt und die maximale Übereinstimmung bestimmt.

In der Abbildung 12 kann das Referenzbild über ca. 200 Pixel entlang der X-Achse geschoben werden. Als

Referenzpunkt wurde der linke Rand des Bildes verwendet, welcher dann für die Diagramme auf der rechten

Seite der Abbildungen verwendet wurde. Anhand dieses Punktes wurde der neue Ausschnitt berechnet und hier

mittels einem weissen Rahmen visualisiert. In der Abbildung 12 war die Korrelation am höchsten, als der linke

Rand des Referenzbildes ca. bei Pixel 45 auf der X-Achse war. Ein weiteres Beispiel ist in der Abbildung 13

dargestellt.

Abbildung 12 Kreuzkorrelation komplett – Der weisse Rahmen innerhalb des Bildes zeigt, wo die Korrelation zum Referenzbild am

höchsten war. Die Grafik rechts zeigt die Korrelation entlang der X-Achse. [22]

Abbildung 13 Kreuzkorrelation komplett – Der weisse Rahmen innerhalb des Bildes zeigt, wo die Korrelation zum Referenzbild am

höchsten war. Die Grafik rechts zeigt die Korrelation entlang der X-Achse. [23]

Wie in der Abbildung 12 und Abbildung 13 ersichtlich, war kein eindeutiges Maximum auszumachen. Die

Differenz zwischen dem Minimum und dem Maximum war extem gering. In der Abbildung 13 betrug diese

gerade einmal 2.5 %, was kein eindeutiges Ergebnis darstellt. Aus diesem Grund wurde in einem weiteren Test

versucht, die Korrelation zeilenweise zu berechnen.

4 Bildvorverarbeitung 4.3 Kreuzkorrelation zeilenweise


4.3 Kreuzkorrelation zeilenweise

Als zweite Variante wurde versucht, jede einzelne Zeile des gespiegelten Bildes über das Originalbild zu schieben,

um die Korrelation zeilenweise zu berechnen. Das Ziel dabei war, Zeilen, welche keine nützlichen Informationen

enthalten, zu eliminieren.

In der Abbildung 14 ist sehr schön ersichtlich, welche Zeilen nützliche Informationen über das Zentrum des Pilzes

enthalten. Der Bereich bis Zeile 80 weist kein eindeutiges Maximum auf, da der Hintergrund des Bildes relativ

homogen ist. Der Bereich ab Zeile 80 zeigt ein eindeutiges Maximum der Korrelation, wodurch die Position des

Pilzes genau bestimmt werden kann. Leider konnten solch gute Ergebnisse nur bei wenigen Bildern erzielt

werden. Häufig sah das Ergebnis wie in Abbildung 15 aus. Über alle Zeilen hinweg konnte kein eindeutiges

Maximum bestimmt werden, welches Informationen über den Standort des Pilzes innerhalb des Bildes lieferte.

Abbildung 14 Kreuzkorrelation zeilenweise – Das Diagramm zeigt die Korrelation des Referenzbildes (rechts) mit dem kompletten Bild

(links) jeder einzelnen Zeile. [24]

Abbildung 15 Kreuzkorrelation zeilenweise – Das Diagramm zeigt die Korrelation des Referenzbildes (rechts) mit dem kompletten Bild

(links) jeder einzelnen Zeile. [22]

4 Bildvorverarbeitung 4.4 Vorverarbeitete Bilder


4.4 Vorverarbeitete Bilder

Da weder die Kreuzkorrelation über das komplette Bild, noch die zeilenweise Kreuzkorrelation homogen gute

Ergebnisse erzielten, wurde diese in der endgültigen Bildvorverarbeitung weggelassen. Die Zentrierung der Bilder

erfolgt mittels Grauwertbestimmung, wie sie bereits im Fachmodul erarbeitet wurde.

Zur besseren Übersicht der Bildvorverarbeitung werden alle Schritte nochmals kurz aufgezeigt:

1. Bilder von Google downloaden (mittels Google Image Downloader, Verwendung von

wissenschaftlichem Namen ergibt bessere Resultate)

2. Aussortieren von schlechten Bildern (von Hand)

3. Neu Nummerieren der Bilder mittels Batch-Datei

4. Lokalisierung des Pilzes mittels Haar-Features

5. Grobes Zuschneiden der Bilder

6. Zentrierung mittels Grauwertbestimmung

7. Definitives Zuschneiden der Bilder

8. Standardisieren auf 256x256 Pixel

9. Vervielfachen

Dabei ist anzumerken, dass die Schritte 4 bis 9 alle automatisch mit einem Python Skript durchgeführt wurden,

welches im Anhang im Kapitel 14.3.1 zu finden ist.

Insgesamt wurden 15 Pilzarten mit diesen Tools für das neuronale Netz vorbereitet. Das Resultat der

Bildvorverarbeitung ist jedoch nicht bei jedem Pilz gleich ausgefallen. Beispielsweise konnten für den Butterpilz

nur 1500 Bilder generiert werden. Für andere Pilzarten, wie der Sommer-Steinpilz, wurden über 3800 Bilder

generiert. Das sind mehr als doppelt so viele Bilder, wie beim schlechtesten Ergebnis. Der Übersicht halber

werden nun alle bearbeiteten Pilzarten mit zwei Beispielbildern aufgezeigt.

Pilzart Wissenschaft-

licher Name

Anzahl

Bilder

Familie Beispielbilder

Sommer-Steinpilz Boletus

aestivalis

3864 Röhrling

Abbildung 16 Sommer-Steinpilz [25, 26]

Kiefern-Steinpilz Boletus

pinophilus

3048 Röhrling

Abbildung 17 Kiefern-Steinpilz [27, 28]

Gemeiner-Steinpilz Boletus edulis 2352 Röhrling

Abbildung 18 Gemeiner-Steinpilz [29, 30]




licher Name

Anzahl

Bilder


Schwarzhütiger-

Steinpilz

Boletus aereus 3612 Röhrling

Abbildung 19 Schwarzhütiger-Steinpilz [31, 32]

Fliegenpilz Amanita

muscaria

2075 Lamellenpilz

Abbildung 20 Fliegenpilz [33, 34]

Butterpilz Suillus luteus 1500 Röhrling

Abbildung 21 Butterpilz [35, 36]

Gold-Röhrling Suillus grevillei 2353 Röhrling

Abbildung 22 Gold-Röhrling [37, 38]

Sand-Röhrling Suillus

variegatus

1944 Röhrling

Abbildung 23 Sand-Röhrling [39, 40]

Ziegenlippe Xerocomus

subtomentosus

2041 Röhrling

Abbildung 24 Ziegenlippe [41, 42]




licher Name

Anzahl

Bilder


Gelber-

Knollenblätterpilz

Amanita citrina 3012 Lamellenpilz

Abbildung 25 Gelber-Knollenblätterpilz [43, 44]

Grauer-Wulstling Amanita

excelsa

2544 Lamellenpilz

Abbildung 26 Grauer-Wulstling [45, 46]

Grüner-

Knollenblätterpilz

Amanita

phalloides

2544 Lamellenpilz

Abbildung 27 Grüner-Knollenblätterpilz [47, 48]

Pantherpilz Amanita

pantherina

2232 Lamellenpilz

Abbildung 28 Pantherpilz [49, 50]

Perlpilz Amanita

rubescens

2496 Lamellenpilz

Abbildung 29 Perpilz [51, 52]

Pfifferling Cantharellus

cibarius

1632 Lamellenpilz

Abbildung 30 Pfifferling [53, 54]

Tabelle 3 Übersicht vorverarbeitete Bilder

5 Neuronales Netz 5.1 Theorie Convolutional Neural Network (CNNs)


5 Neuronales Netz

5.1 Theorie Convolutional Neural Network (CNNs)

In diesem Kapitel wird eine kurze Zusammenfassung über die Theorie der convolutional neural networks, oder

auch abgekürzt CNNs, verfasst. Dabei wird auf die in der Arbeit verwendeten Schichten, sowie dem Optimierer

(optimizer) eingegangen.

Aufgrund der etwas sperrigen Übersetzung der englischen Begriffe in die deutsche Sprache, werden in diesem,

wie auch in den folgenden Kapiteln, für alle mit CNNs zusammenhängende Themen, die englischen Begriffe

benutzt.

5.1.1 Convolutional Neural Networks Einführung

Convolutional neural networks haben ihren Ursprung in der Erforschung des visuellen Kortexes des menschlichen

Gehirns und werden schon seit den 1980er Jahren für die Bilderkennung verwendet. Dank der zunehmenden

Rechenleistung der Computer, sowie der grossen Menge an zur Verfügung stehenden Trainingsdaten, haben sich

die CNNs in den letzten Jahren stark entwickelt. Durch diese Mittel konnten die convolutional neural networks in

visuellen Aufgaben gar übermenschliche Leistungen erbringen. So werden diese Netze für verschiedene

Aufgaben, wie die Gesichtserkennung, die Erkennung von Strassenschildern oder gar für selbstfahrende Autos

eingesetzt. Doch die CNNs beschränken sich nicht nur auf visuelle Wahrnehmungen. Des Weiteren werden sie

für die Sprach-, Text- und Liederkennung eingesetzt. Wir wollen uns aber auf die Bearbeitung von visuellen

Wahrnehmungen in convolutional neural networks beschränken.

Bis vor ein paar Jahren waren solche Aufgaben wie die Erkennung eines Welpen auf einem Bild oder die

Texterkennung für Computer eine fast unlösbare Aufgabe. Daher stellt sich die Frage, weshalb solche Aufgaben

für den Menschen mühelos zu bewältigen sind und für Maschinen nicht? Diese Frage ist nicht ganz einfach zu

beantworten. Denn zum Zeitpunkt, wenn die Informationen unser Gehirn erreichen, sind diese bereits mit

hochrangigen Merkmalen geschmückt. Für den Menschen ist es beinahe unmöglich zu erklären, wie zum Beispiel

das Bild des Welpen erkannt wird. Dabei wird klar, dass die Wahrnehmung überhaupt nicht trivial ist. Damit das

Konzept hinter der Wahrnehmung und somit auch den convolutional neural networks genauer verstanden wird,

muss im nächsten Abschnitt genauer angesehen werden, wie diese sensorischen Module funktionieren.

[55, S. 355–357, 56, S. 129]

5.1.2 Biologische Inspiration

Die Idee des convolutional neural networks hat einen biologischen Hintergrund. In einer Serie von Experimenten

haben die Wissenschaftler David H. Humber und Torsten Wiesel den visuellen Kortex von Katzen genauer

analysiert. Dabei ist Ihnen aufgefallen, dass das Sehfeld in viele verschiedene lokale rezeptive Felder unterteilt

ist. Überlappend wiederspiegelt dieses rezeptive Feld von verschiedenen Neuronen das gesamte Sehfeld. Zudem

wurde ersichtlich, dass diese Felder für verschieden komplexe Muster ausgebildet sind. Die Architektur der

unterschiedlichen Felder teilt sich auf grosse Felder auf, welche für die weniger komplexen Strukturen

verantwortlich sind, und kleinere rezeptive Felder, welche für komplexere Strukturen im Sehfeld zuständig sind.

Diese Felder werden dann über einzelne Verbindungen verbunden.

Genau diese Studie hat das im Jahre 1980 eingeführte Neocognitron inspiriert, welches sich über die Jahre

allmählich zu dem entwickelte, was wir unter dem Namen convolutional neural network kennen. Ein Meilenstein

für die CNNs wurde im Jahre 1998 mit der Erfindung der LeNet-5 Architektur gesetzt, mit welcher

handgeschriebene Nummern erkannt werden konnten. Dabei wurden Schichten wie fully connected layer,

pooling layer, aber auch convolutional layer verwendet. Diese werden in den nächsten Abschnitten genauer

erklärt. [55, S. 356, 56, S. 126]



5.1.3 Convolutional Neural Network Architektur und Schichten

Convolutional neural networks sind typischerweise aus vielen Schichten aufgebaut. Wie die Abbildung 31 zeigt,

kann die Architektur generell in 3 verschiedene Stufen aufgeteilt werden, wobei die Struktur innerhalb der Stufen

stark variieren kann. Über diese drei Stufen hinweg werden die Eingangsdaten in ein gegebenes Set von Klassen

transformiert. [56, S. 128–129]

Abbildung 31 Generelle Struktur eines CNNs – Die Abbildung zeigt die grundsätzliche Struktur eines CNN mit dem input layer, den

feature-extraction layers und den classification layers. [56, S. 128]

5.1.3.1 Input Layer

Die erste Stufe bildet der input layer. Hier werden die Bilddaten in das Netz eingegeben. Parameter der

Eingangsdaten bilden die Länge, Breite, sowie die Anzahl der Kanäle. Mit der Anzahl an Kanälen sind die

Farbkanäle gemeint. Bei einem Farbbild sind dies drei, für jeden Wert von R (Rot), G (Grün) und B (Blau) einen

Wert pro Pixel. [56, S. 130]

5.1.3.2 Convolutional Layer

Ein Teil der zweiten Stufe (feature-extraction layers) bilden die convolutional layer. Diese Schicht ist auch die

wichtigste in einem convolutional neural network. Sie bildet den Kern der CNNs.

Wichtig für das Verständnis dieses layers ist,

dass nicht jeder Pixel des Eingangsbildes mit

einem Neuron des convolutional layers der

ersten Schicht verbunden ist. Das Gleiche gilt

auch für den zweiten convolutional layer. Es

sind nur die Neuronen verbunden, welche

sich innerhalb des Rechteckes der

darunterliegenden Schicht befinden. Sehr

schön dargestellt ist dieser Vorgang in der

Abbildung 32.

Abbildung 32 Convolutional layer mit rechteckigen rezeptiven Feldern – Die

Abbildung zeigt, wie die Neuronen zwischen den einzelnen layers verbunden

sind. [55, S. 358]

https://www.safaribooksonline.com/library/view/deep-learning/9781491924570/ch04.html



Durch diese Architektur, welche auch in realistischen Bildern üblich ist, wird es möglich, dass sich jede Schicht

auf spezielle Features im Bild konzentrieren kann. Dies ist auch der Grund, weshalb CNNs oft für die

Bilderkennung eingesetzt werden. [55, S. 357–358]

Zum Verständnis der Faltung muss ein kurzer Exkurs in die Mathematik gemacht werden. Die Faltung oder

englisch convolution wird in den convolutional neural networks auch als Merkmalsdetektor betitelt. In der

Abbildung 33 wird gezeigt, wie der Kernel, oder auch Filter genannt, über die Eingangsdaten geschoben wird. Für

jede Position wird der Kernel mit den Eingangsdaten multipliziert. Anschliessend werden alle Resultate der

Multiplikation addiert und das Resultat wird in die Ausgabe (feature map oder hier convoluted feature)

geschrieben. Dieser Vorgang wird Faltung genannt. [56, S. 131–132]

Abbildung 33 Beispiel Faltungsoperation - In der Abbildung wird gezeigt, wie der Kernel, oder auch Filter genannt, über die Eingangsdaten

geschoben wird und daraus die feature map berechnet wird. [56, S. 131]

Wird dieser Vorgang nun mit demselben Filter über das ganze Bild angewendet, so entstehen die sogenannten

feature maps. Der Aufbau der Filter wird während dem Training automatisch an die Eingabedaten angepasst,

sodass diese möglichst gut klassifiziert werden können.

Bis anhin wurde der Einfachheit halber der

convolutional layer als zweidimensionaler layer

betrachtet. In Wirklichkeit besteht dieser jedoch

aus mehreren feature maps gleicher Grösse,

welche als dreidimensionales Gebilde darzu-

stellen sind. Ersichtlich ist dieses Gebilde in der

Abbildung 34. Die verschiedenen feature maps

teilen sich innerhalb eines convolutional layers

sowohl die Gewichtungen, wie auch die

Bias - Werte. Einziger Unterschied bilden die

Filter, welche unterschiedliche Parameter auf-

weisen können. Mithilfe dieser verschiedenen

Filter ist es für den convolutional layer möglich,

mehrere Merkmale im Eingangsbild zu erken-

nen.[55, S. 360–361]

Abbildung 34 Convolutional layer mit verschiedenen feature maps – Die

Abbildung zeigt zwei convolutional layer mit mehreren feature maps und ein Bild

mit drei Kanälen (RGB). [55, S. 361]



Weitere Parameter eines convolutional layers sind der stride, sowie das padding. Diese Parameter werden

anhand der nächsten Abbildungen erklärt.

In der Abbildung 35 ist ein Bild mit dem Parameter padding same zu sehen. Dieser legt fest, wie die Ränder eines

Bildes bearbeitet werden, wenn der Filter über den Rand hinauskommt. Mögliche Varianten, welche in

Tensorflow zur Verfügung stehen sind padding same oder padding valid. Bei padding same wird das Bild am

Randbereich mit Nullen ergänzt, sodass das Bild im Output dieselbe Grösse hat und alle Pixel berücksichtigt

werden. Bei padding valid wird dies nicht gemacht, was zur Folge hat, dass die äussersten Pixel nicht bearbeitet

werden können, weil der Filter nicht vollständig im Bild platziert werden kann.

Abbildung 35 Erklärung Parameter padding – Die Abbildung visualisiert den Parameter padding, der festlegt, wie die Ränder eines Bildes

bearbeitet werden. Der Parameter fw definiert die Filterweite und der Parameter fh die Filterhöhe. Der hier verwendete Filter hat

dementsprechend die Grösse 3x3 Pixel. Die Ränder des Bildes werden mit Nullen aufgefüllt (zero padding). [55, S. 358]

Der zweite Parameter, welcher beim convolutional layer definiert werden muss, ist die Schrittweite oder englisch

stride. Dieser legt fest, wie weit der Filter nach einem Schritt weitergeschoben wird, bevor das rezeptive Feld

erneut ausgewertet wird. Dieser Parameter hat auch einen grossen Einfluss auf die Anzahl Parameter des

neuronalen Netzes. Denn zum Beispiel mit einem stride von 2 wird das Bild um diesen Faktor in der nächsten

Schicht verkleinert. Sehr gut ersichtlich ist dies in der Abbildung 36, wobei das obere Rechteck den Output, und

somit den Input der nächsten Schicht darstellt. Dieser Parameter wird jedoch meist auf 1 gesetzt und die

Reduzierung des Bildes wird mit dem pooling layer durchgeführt. Dieser wird im nächsten Abschnitt genauer

erklärt. [55, S. 358–359]

Abbildung 36 Erklärung Parameter stride – Dieser Parameter dient zur Dimensionsreduktion. Zu sehen ist ein Bild mit der Schrittweite 2,

welche zur Folge hat, dass das Ausgangsbild (oberes Rechteck) um den Faktor 2 kleiner ist. Die Randstellen sind wiederum mit Nullen

gefüllt, damit das Ausgangsbild alle Pixel des Eingangsbildes berücksichtigen kann. [55, S. 359]



5.1.3.3 Pooling Layer

Ein weiterer Bestandteil der zweiten Stufe bilden die pooling layer. Diese sind im Gegensatz zu den convolutional

layer sehr einfach zu verstehen und man findet sie üblicherweise nach jedem dieser Schichten. Die Reduzierung

des Eingangsbildes ist die Aufgabe dieses layers. Die Reduzierung der Bildgrösse zieht viele positive Eigenschaften

mit sich. Damit wird auch die Anzahl der Parameter reduziert. Dies hat einen grossen Einfluss auf den

Rechenaufwand und den Speicherbedarf, welche dadurch ebenfalls reduziert werden. Zudem ergibt sich durch

die Reduktion des Bildes eine Standortinvarianz.

Für die Reduktion der Bildgrösse werden keine Gewichtungen benötigt. Mit der Hilfe einer Aggregierungs-

funktion wie max (Maximum) oder mean (Mittelwert) werden nur einzelne Gewichtungen in die nächste Schicht

übernommen. Am Beispiel der Abbildung 37 kann man die Funktion des pooling layers sehr gut darstellen. Die

Abbildung zeigt den am meisten verwendeten pooling layer, nämlich den max pooling layer. Als

Aggregationsfunktion wird die Maximalfunktion verwendet. Ein weiterer Parameter bildet der sogenannte

pooling kernel. Dieser hat in unserem Beispiel der Abbildung 37 eine Grösse von 2x2 Pixel. Die Schrittweite oder

englisch stride wurde in diesem Beispiel mit 2 Pixel pro Schritt gewählt. Der letzte Parameter, welcher definiert

werden muss, ist das padding. Dieser bestimmt, wie die Randstellen des Bildes behandelt werden. Hier wurde

padding valid gewählt, wodurch der Rand einfach abgeschnitten wird.

Abbildung 37 Max pooling layer (2x2 pooling kernel, stride 2) – Die Abbildung zeigt, wie die Bildgrösse dank des pooling layers verringert

werden kann. Links im Bild ersichtlich ist die Auswahl der Aggregierungsfunktion, welche hier den Wert 5 übernimmt, da eine

Maximalfunktion gewählt wurde. Weil padding valid für die Randbehandlung gewählt wurde, wird dieser abgeschnitten.

Mit dieser Konfiguration des pooling layers wird das Bild um den Faktor 2 verkleinert. Dabei ist anzumerken, dass

nur der maximale Wert des Kernels übernommen wird, alle anderen Gewichtungen fallen weg. So fallen in

diesem Beispiel insgesamt 75 % aller Gewichtungen weg, was enorme Einsparungen im Rechenaufwand zur Folge

hat. [55, S. 365–367]

5.1.3.4 Fully Connected Layer

Die dritte Stufe bildet der Classification layer. Dieser wird durch sogenannte fully connected layer abgebildet.

Wie es der Name schon verrät, sind diese Schichten vollständig mit den Neuronen der davorliegenden Schicht

verbunden. In einem neuronalen Netz können mehrere dieser Schichten nacheinander folgen. Die allerletzte

Schicht bildet dabei das Netz auf die Ausgänge der Vorhersage ab. Meist wird dies mit einem speziellen fully

connected layer realisiert, dem sogenannten softmax layer. Dieser berechnet für jede Klasse die

Wahrscheinlichkeit und gibt diese aus. [56, S. 140–141]



5.1.4 Optimizer

Das Training eines neuronalen Netzes kann je nach Grösse des Netzwerkes sehr lange dauern. Die Wahl des

richtigen Optimierers kann die Zeit bis gute Ergebnisse erzielt werden um ein Vielfaches verringern. Die Wahl des

Optimierers fiel in unserem Fall auf den Adam optimizer, welcher untenstehend genauer erläutert wird.

5.1.4.1 Adam Optimizer

Der Adam optimizer ist ein Optimierungsalgorithmus, welcher anstelle des klassischen stochastischen

Gradientenabstiegsverfahrens verwendet werden kann, um die optimalen Gewichte des neuronalen Netzes zu

bestimmen. Adam steht für adaptive moment estimation und kombiniert die Ideen von Momentum optimization

und RMSProp. Wie bei der Momentum optimization werden alle bereits berechneten Gradienten miteinbezogen,

um schneller ein Minium zu erreichen, falls die Gradienten mehrmals in die gleiche Richtung zeigen. Als Beispiel

kann man sich einen Ball vorstellen, der von einem Hügel herunterrollt. Dieser wird kontinuierlich schneller, bis

ein Minimum erreicht ist. Wenn der Ball allerdings nach jedem Meter gestoppt und erneut losgelassen wird,

dauert es viel länger, bis der Ball das Minimum erreicht. Wenn man also weiss, dass der Ball bereits vorhin mit

einer gewissen Geschwindigkeit in diese Richtung unterwegs war, kann man ihn nach jedem Stopp mit einer

Anfangsgeschwindigkeit loslassen, damit er schneller das Minium erreicht. Anders als bei Momentum

optimization werden bei RMSProp nicht alle berechneten Gradienten miteinbezogen. Es werden nur einzelne

Gradienten mit einem exponentiellen Verfall miteinberechnet.

Da der Adam optimizer ein adaptiver Lernratenalgorithmus ist, ist die Wahl der Lernrate nicht so wichtig. Oft

kann eine standartmässige Lernrate von 0.001 verwendet werden, wodurch die Verwendung sogar einfacher

wird, als mit dem Gradientenabstiegsverfahren. [55, S. 295–301]

5.1.5 Overfitt ing vermeiden

Neuronale Netze haben normalerweise zehntausende von Parametern, manchmal sogar bis zu mehreren

Millionen. Mit dieser riesigen Anzahl von Parametern hat das Netzwerk viel Freiheit sich an viele verschiedene

komplexe Datensätze anzupassen. Diese Flexibilität hat allerdings auch den Nachteil, dass das neuronale Netz

anfällig auf das Übertraining der Lerndaten ist. Das bedeutet, dass das neuronale Netz die Klassifikation auf den

Lerndaten gut bewältigt, die Verallgemeinerung auf unbekannten Daten fällt dem neuronalen Netz allerdings

schwer.

Da auch wir während dieser Arbeit mit dem Thema Übertraining konfrontiert wurden, sind nachfolgend zwei

mögliche Lösungsvarianten dokumentiert. [55, S. 305]

5.1.5.1 Early Stopping

Eine gute Variante, um das Übertraining zu verhindern, ist das verfrühte Beenden des Trainings, sobald die

accuracy der Validierungsdaten anfängt zu sinken. Dies kann erreicht werden, indem das neuronale Netz in

regelmässigen Abständen mittels Validierungsdaten getestet wird und das Modell gespeichert wird, falls sich die

Ergebnisse verbessert haben. Nach jedem Speichern des Modells werden die Schritte gezählt, bis ein neues

besseres Modell trainiert wurde. Falls nach einer gewissen Anzahl Schritte kein besseres Modell gefunden wurde,

kann das bereits gespeicherte beste Modell wiederhergestellt werden. [55, S. 305]

5.1.5.2 Data Augmentation

Eine weitere Variante, um das Übertraining zu verhindern, ist die Vergrösserung des Datensatzes. Dies wird

erreicht, indem aus den aktuellen Trainingsdaten neue Trainingsdaten erzeugt werden. So kann die Anzahl an

Daten künstlich vergrössert werden. Die Vergrösserung des Datensatzes kann beispielsweise durch das Ändern

des Kontrasts, Spiegelung oder Drehen eines Bildes erreicht werden. Wir haben bei der Klassifizierung der Pilze

ebenfalls alle Daten vervielfacht. Eine ausführliche Dokumentation über die Art und Weise der Vervielfachung

wurde bereits im Kapitel 4.1 dokumentiert. [55, S. 311]

5 Neuronales Netz 5.2 Erstes Netzwerk


5.2 Erstes Netzwerk

Für erste Tests mit fünf verschiedenen Pilzarten wurde ein neuronales Netz, basierend auf einem Tutorial [57],

entwickelt. Den Code dafür konnte auf GitHub [58] entnommen werden. Mit nur kleinen Anpassungen konnten

so erste Tests durchgeführt werden.

Die Architektur des ersten Netzes wurde bewusst klein gewählt, damit diese bei Bedarf stetig ausgebaut werden

kann. Als Basis wurden drei convolutional layer, ein flattened layer, sowie ein fully connected layer eingebaut.

Zur besseren Übersicht wird die Architektur, wie sie dem Tutorial entnommen werden konnte, aufgezeigt. Diese

ist in Abbildung 38 ersichtlich.

Abbildung 38 Architektur Neuronales Netzwerk – In dieser Abbildung ist ein neuronales Netz mit drei convolutional layer, einem

flattened layer und einem fully connected layer dargestellt, welches als Basis für die ersten Tests diente. [59]

Zur besseren Veranschaulichung des Netzes wurde der Programmcode durch Inputs in das Tensorboard

erweitert. Beispielsweise wird die Treffsicherheit (validation accuracy und validation loss), bei den

Validierungsdaten, zyklisch aufgezeichnet. Den benötigten Code dafür kann in wenigen Zeilen geschrieben

werden.

accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

tf.summary.scalar("Validation_accuracy", accuracy)

Des Weiteren wurde der Code mit einer sogenannten Confusion Matrix erweitert, damit die

Validierungsergebnisse besser visualisiert werden konnten. Ein kurzer Exkurs zur Confusion Matrix:

Die Confusion Matrix, welche teilweise auch als Error Matrix bezeichnet wird, repräsentiert die Performance

eines Algorithmus. Dabei werden in den Spalten die vorhergesagten Labels und in den Zeilen die wirklichen Labels

aufgezeigt. Damit kann genauer evaluiert werden, bei welchen Labels die Fehler entstanden sind und welche

Labels gut erkannt werden. [60]

Am Beispiel in Abbildung 39 ist gut ersichtlich, dass

das neuronale Netz Probleme mit dem ersten Label

(Sommersteinpilz) hat. Diese werden in fünf Fällen

falsch vorhergesagt. Nur die Diagonale wieder-

spiegelt eine richtige Vorhersage. Auch die Basis

dieses Codes stammt aus dem Internet [61] und

wurde auf unsere Bedürfnisse angepasst. Auf der

nächsten Seite ist der Code für die Confusion Matrix

zu finden.

Abbildung 39 Confusion Matrix - Die Confusion Matrix, welche teilweise

auch als Error Matrix bezeichnet wird, repräsentiert die Performance

eines Algorithmus.

5 Neuronales Netz 5.2 Erstes Netzwerk


# Create Folder for ConfusionMatrix

if not os.path.exists("./log/ConfusionMatrix"): os.makedirs("./log/ConfusionMatrix")

# Confusion matrix

y_pred_show = session.run(y_pred, feed_dict=feed_dict_validate)

y_pred_show_1 = np.argmax(y_pred_show, axis=1)

y_val_1 = np.argmax(y_valid_batch, axis=1)

conf_matrix = confusion_matrix(y_val_1, y_pred_show_1)

plt.imshow(conf_matrix, interpolation='nearest', cmap=plt.cm.Blues)

plt.title('Confusion matrix Epoche: ' + str(epoch))

plt.colorbar(boundaries=np.linspace(0, int(batch_size/6), int(batch_size/12)+1)) tick_marks = np.arange(len(classes))

plt.xticks(tick_marks, classes, rotation=90, fontsize=7) plt.yticks(tick_marks, classes, fontsize=7)

thresh = conf_matrix.max() / 2. for u, j in itertools.product(range(conf_matrix.shape[0]), range(conf_matrix.shape[1])):

plt.text(j, u, format(conf_matrix[u, j], 'd'),horizontalalignment="center",

verticalalignment="center", fontsize=7,

color="white" if conf_matrix[u, j] > thresh else "black") plt.ylabel("True label")

plt.xlabel("Predicted label")

plt.tight_layout()

if not os.path.exists("./log/ConfusionMatrix/" + hparam): os.makedirs("./log/ConfusionMatrix/" + hparam)

plt.savefig("./log/ConfusionMatrix/" + hparam + "/" + str(epoch+1)) plt.close()

plt.clf()

Mit der Hilfe des angepassten Python Skripts konnten nun die ersten Tests durchgeführt und ausgewertet

werden. Diese wurden anfänglich mit nur fünf Pilzarten durchgeführt, bevor die Architektur des Netzes stetig

erweitert und die Anzahl der Pilze erhöht wurde.

Der gesamte Code kann dem Anhang im Kapitel 14.3 Python Skripts, sowie Kapitel 14.4 JSON File entnommen

werden. Es werden zwischendurch kurze Codestücke aufgezeigt, welche der Erklärung dienen sollen.

Des Weiteren wurden in dieser Phase etliche Tests auf der Keras Plattform gemacht. Dies ist eine einfache API

(application programming interface) für das Trainieren neuronaler Netze, welche auf TensorFlow aufgebaut ist.

Damit können neuronale Netze sehr elegant und mit wenigen Codezeilen entworfen werden. Da jedoch nicht die

exakt gleiche Architektur, welche mit Tensorflow aufgebaut wurde, nachgebaut werden konnte und dadurch die

Resultate schlechter ausfielen, wurde auf eine weitere Entwicklung mit der Hilfe dieses Tools verzichtet.

5.2.1 Resultate erster Tests

Die ersten Tests wurden allesamt auf den internen Grafikkarten (NVIDIA GeForce GTX 645) durchgeführt,

weshalb die Batchgrösse auf 32 Bilder pro Batch limitiert war. Bei diesen Tests wurde der Fehler gemacht, dass

die Validierungs- und Trainingsdaten nicht sauber getrennt wurden. Daher kannte das neuronale Netz die Bilder

bereits und konnte diese sehr gut klassifizieren. Dieser Fehler wurde erst bei den Tests mit 15 Pilzarten erkannt

und ist auch in diesem Kapitel genauer dokumentiert.

Bei diesen Tests fiel auf, dass sich das neuronale Netz mit kleineren Filtergrössen besser verhielt als mit

grösseren. Zudem wurde beobachtet, dass das Netz sehr schnell konvergiert, danach jedoch meist nur noch

schlechtere Ergebnisse lieferte. Aufgrund des vorhandenen Fehlers wird auf die nähere Betrachtung dieser Tests

verzichtet.

5 Neuronales Netz 5.3 Training mit 15 Pilzarten


5.3 Training mit 15 Pilzarten

Nachdem eine Datenbank mit den bereits vorgestellten 15 Pilzarten erstellt wurde, konnten die ersten Tests mit

allen Pilzen durchgeführt werden. Es zeigte sich allerdings schnell, dass das Training eines neuronalen Netzes für

die Klassifizierung von 15 Pilzarten eine grosse Herausforderung darstellt. Im nächsten Abschnitt wird das

Ergebnis der ersten Tests mit 15 Pilzen genauer unter die Lupe genommen.

5.3.1 Ergebnis

Erste Tests haben eine validation accuracy von über 90 % ergeben. Einige Tests später wurde allerdings bemerkt,

dass die Test- und Validierungsdaten auf demselben Datensatz beruhten. Das Problem bei gleichen Daten ist,

dass das Netz mit denselben Daten trainiert und validiert wurde. Dadurch hat das neuronale Netz die Bilder

bereits eintrainiert und kann diese in einem späteren Validierungszyklus viel einfacher klassifizieren. Als

Lösungsansatz für dieses Problem wurde die Trennung der Daten ausgewählt. Dazu wurde bereits beim Einlesen

der Daten 20 % des Datensatzes für einen separaten Validierungsdatensatz reserviert und ausgeschlossen. Der

Effekt dieses Fehlers war enorm gross, denn die validation accuracy verschlechterte sich nach dem Auftrennen

der Daten auf ca. 50 %. In der Abbildung 40 und Abbildung 41 ist jeweils das beste Ergebnis, welches nach dem

Trennen der Datensätze erreicht wurde, dargestellt.

Abbildung 40 Graph accuracy mit 15 Pilzarten – In dieser Abbildung ist die accuracy, welche nach dem Trennen der Datensätze mit 15

Pilzarten erreicht wurde, dargestellt. Eine validation accuracy von 50 % wird schon nach wenigen Epochen erreicht, danach stagniert das

Wachstum.

Abbildung 41 Graph loss mit 15 Pilzarten Pilzarten – In dieser Abbildung ist der loss, welcher nach dem Trennen der Datensätze mit 15

Pilzarten erreicht wurde, dargestellt. Der validation loss steigt bereits früh nach dem Start des Trainings wieder an, was ein klares Zeichen

für ein Übertraining ist.

5 Neuronales Netz 5.3 Training mit 15 Pilzarten


5.3.2 Diskussion

5.3.2.1 Graph

Eine validation accuracy von 50 % wird schon nach wenigen Epochen erreicht, danach stagniert das Wachstum.

Ab Epoche 30 lernt das neuronale Netz nur noch auf den Trainingsdaten, was mit einem stetigen Anstieg der

training accuracy zu beobachten ist. Gleichzeitig zum Wachstum der training accuracy steigt der loss an. Dies ist

ein klares Zeichen für ein Übertraining der Daten.

5.3.2.2 Confusion Matrix

Anhand der Confusion Matrix in

Abbildung 42 sieht man, dass sich die

Pilze grundsätzlich gut klassifizieren

lassen. Jedoch gibt es keine Klasse, bei

welchen keine Fehlerklassifizierungen

aufgetreten sind. Auffällig sind einzelne

Sektoren wie jener der vier Steinpilz-

arten. Spannend zu sehen ist, dass dies

auch bei den Lamellenpilzen derselben

Familie der Fall ist. Namentlich sind dies

der Graue-Wulstling, Pantherpilz, Perl-

pilz und die Knollenblätterpilze, welche

alle zur Familie Amanita gehören.

Genau wie beim Menschen tritt auch

beim neuronalen Netz die grösste

Fehlklassifizierung bei solch ähnlichen

Pilzen auf.

Abbildung 42 Confusion Matrix 15 Pilzarten – Anhand der Confusion Matrix sieht

man, dass es bei jeder Pilzart zu Fehlklassifizierungen kam. Auffällig sind zwei

Sektoren, bei welchen die Fehlklassifizierungen auf die gleiche Familien-

zugehörigkeit zurückzuführen sind.

5.3.3 Fazit

Die Klassifizierung der 15 Pilze funktioniert nur sehr bedingt mit diesem neuronalen Netz. Mit einer validation

accuracy von gerade einmal knapp über 50 % ist die Wahrscheinlichkeit für eine sichere Klassifizierung sehr

gering. Deswegen wurden weitere Lösungsvarianten ausprobiert, damit die Klassifizierung genauer wird. Diese

Varianten wurden auf den nächsten Seiten dokumentiert und erläutert.

5 Neuronales Netz 5.4 Training mit zusätzlichen Features


5.4 Training mit zusätzl ichen Features

Nachdem die ersten Tests nicht zufriedenstellend

waren, wurde versucht, dem neuronalen Netz weitere

Informationen zur Verfügung zu stellen, welche zu einer

besseren Klassifizierung führen. Dazu wurden neben

dem Bild als Input auch Informationen über die Grösse

des Pilzes miteinbezogen.

Für das Training bedeutet das, dass jedem Pilz eine

Stiellänge und ein Hutdurchmesser zugeordnet wird.

Dazu wurde für jede Pilzart eine durchschnittliche

Länge des Stiels und des Hutdurchmessers inklusive

einer Standardabweichung bestimmt. Diese Informa-

tionen wurden in einem JSON File hinterlegt, damit sie

sowohl für das Training, als auch für die Webapplikation

verwendet werden können, welche später ausführlich

beschrieben wird. Anhand der durchschnittlichen

Grösse und der Standardabweichung wurden über eine

Normalverteilung jedem Pilz eine Stiellänge und ein

Hutdurchmesser zugeordnet. Diese Informationen

wurde anschliessend dem fully connected layer

angehängt. Ein Beispiel eines neuronalen Netzes mit

diesen Zusatzinformationen ist in der Abbildung 43

dargestellt.

Abbildung 43 Neuronales Netz mit zusätzlichen Features – Die Abbildung

zeigt, wie die zusätzlichen Informationen dem neuronalen Netz zur

Verfügung gestellt werden.

5.4.1 Ergebnis

In der Abbildung 44 und Abbildung 45 sind die validation accuracy und der validation loss von zwei neuronalen

Netzen abgebildet, welche sich nur durch die zusätzlichen Features unterscheiden. Beide Netze wurden mit den

Daten der Lamellenpilze trainiert.

Abbildung 44 Graph accuracy mit zusätzlichen Features – In der Abbildung ist sehr gut zu erkennen, dass der Verlauf der jeweiligen

Graphen beinahe identisch ist. Der wesentliche Unterschied liegt darin, dass die accuracy um ca. 10 % höher ist, wenn das neuronale Netz

mit den zusätzlichen Features trainiert wurde.

5 Neuronales Netz 5.4 Training mit zusätzlichen Features


Abbildung 45 Graph loss mit zusätzlichen Features – Die Abbildung zeigt den positiven Effekt der zusätzlichen Features. Dank diesen

zusätzlichen Informationen konnte der loss gesenkt werden.

5.4.2 Diskussion

In der Abbildung 44 ist sehr gut zu erkennen, dass der Verlauf der jeweiligen Graphen beinahe identisch ist, mit

der Ausnahme, dass die accuracy um ca. 10 Prozent höher ist. Dieser Unterschied ist auf die zusätzlichen

Informationen, welche dem neuronalen Netz hinzugefügt wurden, zurückzuführen.

Betrachtet man Abbildung 45, so wird ein zusätzlich positiver Effekt der Informationen ersichtlich. Mit den

zusätzlichen Features wird nicht nur die validation accuracy verbessert, sondern auch der loss um einiges

verringert, was zur Folge hat, dass die Fehlertoleranz des Netzes geringer ist.

Es soll aber auch angemerkt werden, dass sowohl die training accuracy, wie auch der training loss immer noch

viel besser als die Ergebnisse der Validierungsdaten ausfallen.

5.4.3 Fazit

Der Test hat gezeigt, dass die validation accuracy um zirka 10 % verbessert werden konnte. Das Problem des

Übertrainings konnte allerdings noch nicht verringert werden.

Das Ergebnis war allerdings nach wie vor nicht zufriedenstellend, weshalb die Pilze in Röhrlinge und Lamellenpilze

unterteilt wurden. Dies hat aber zur Folge, dass der Benutzer der Applikation anschliessend auch selber

entscheiden muss, ob es sich um einen Röhrling oder einen Lamellenpilz handelt. Dies kann unter Umständen

auch zu Fehlklassifizierungen führen. Da die Unterschiede dieser Features jedoch relativ einfach mit dem

menschlichen Auge zu erkennen sind, werden die Fehlklassifizierungen durch dieses Feature relativ gering

ausfallen.

Zur kurzen Erklärung dieses Features werden diese in der Abbildung 46 und Abbildung 47 dargestellt. Es muss

lediglich die Unterseite des Pilzes betrachtet werden, um zu erkennen, ob es sich um einen Röhrling oder einen

Lamellenpilz handelt.

Abbildung 46 Beispiel Lamellenpilz [62]

Abbildung 47 Beispiel Röhrling [63]

5 Neuronales Netz 5.5 Einleitung Testreihen


5.5 Einleitung Testreihen

Nachdem die ersten Tests mit verschiedenen Konfigurationen und Features durchgeführt wurden, entschieden

wir uns, mit ähnlichen Architekturen weiterzuarbeiten. Die Trennung der zwei Pilzfamilien (Lamellenpilze und

Röhrlinge) führte in ersten kleineren Tests zu vielversprechenden Ergebnissen. Deswegen wurde diese Idee

weiterverfolgt.

Mit sogenannten Grid-Tests wurde in den folgenden Tests die bestmögliche Architektur für das jeweilige

neuronale Netz gesucht. In den Grid-Tests werden viele verschiedene Parameter verändert und dafür jeweilige

Netze trainiert. Der grosse Vorteil dieser Tests ist, dass man sie durch einen Befehl starten kann und automatisch

viele verschiedene Tests gestartet werden. Zur besseren Veranschaulichung wird ein Codeausschnitt dargestellt

und erklärt.

def main(): for img_size in [64,128,256]: # Load Dataset

data = dataset.read_train_sets(train_path, img_size, classes,

validation_size=validation_size) print("Complete reading input data. Will Now print a snippet of it") print("Number of files in Training-set:\t\t{}".format(len(data.train.labels))) print("Number of files in Validation-set:\t{}".format(len(data.valid.labels)))

num_epochs = 100

if img_size == 64: batch_size = 256 number_of_iteration = int(num_epochs*len(data.train.labels)/batch_size)

elif img_size == 128: batch_size = 128 number_of_iteration = int(num_epochs * len(data.train.labels) / batch_size)


for learning_rate in [1E-3, 1E-4]: global i i = 0

for num_filter in [32]: for fc1_layer_size in [64,128]: for num_convlayer in [2, 3, 4]: if num_convlayer == 2: for filter in [[10, 10], [8, 8], [6, 6], [4, 4]]: train(data, img_size, batch_size, learning_rate,

number_of_iteration, num_convlayer, filter,

num_filter, fc1_layer_size)

if num_convlayer == 3: for filter in [[10, 8, 6], [8, 8, 6], [8, 6, 4], [6, 6, 4]]: train(data, img_size, batch_size, learning_rate,



if num_convlayer == 4: for filter in [[10, 8, 6, 6], [8, 8, 6, 4], [8, 6, 6, 4]]: train(data, img_size, batch_size, learning_rate,



Oben ersichtlich ist die main-Methode des Python Skriptes. Der Grid-Test wurde mittels mehreren for-Schleifen

voll ausprogrammiert. In den jeweiligen Schleifen können die Parameter des Tests angegeben werden.

Beispielsweise wird in img_size über drei verschiedenen Bildgrössen von 64x64, 128x128 und 256x256 Pixeln

iteriert. Jede Bildgrösse durchläuft dann alle anderen Parameter, welche wiederum in den verschiedenen

for-Schleifen definiert sind. So durchläuft beispielsweise dieser Test das Training von 132 verschiedenen Netzen,

welche anschliessend ausgewertet werden können.

5 Neuronales Netz 5.5 Einleitung Testreihen


Zur Darstellung der Resultate wurde wiederum die Confusion Matrix, sowie das TensorBoard verwendet. Da

diese beiden Tools bereits in den vorherigen Tests ausführlich erklärt wurden, verzichten wir auf eine weitere

Erklärung. Zusätzlich zu den bereits programmierten Ausgaben wurde noch eine Ausgabe in ein Textdokument

realisiert. Dazu wurde ein separates Python Skript (log.py) erstellt, welches im Testskript importiert wurde. Im

Textdokument werden zuerst alle Hyperparameter des Tests niedergeschrieben, danach folgt die Ausgabe des

Trainings. Am Schluss wird dann das beste Ergebnis vermerkt, damit die Auswertung erleichtert wird. Eine

gekürzte Version der Ausgabe in das Textdokument wird unten dargestellt.

Classes: ['004_Fliegenpilz', '009_Gelber-Knollenblaetterpilz', '010_Grauer-Wulstling', '011_Gruener-Knollenblaetterpilz', '012_Pantherpilz', '013_Perlpilz', '014_Pfifferling']

Image size: 64x64 Pixel

Batch size: 256

Learning rate: 0.001

Optimizer: AdamOptimizer

Number of convolutional layers: 2

Filter size: [3, 3]

Number of filters: 32

Fully connected layer size: 64

------------------------------------------------------------------

Start Training:

Training Epoch 0 --- Training Accuracy: 10.9%, Validation Accuracy: 13.3%, Validation Loss: 2.364


…



Training done! Highest val acc: 0.7734375 val loss: 0.7956599

Zu guter Letzt wurde auch das Modell abgespeichert, damit dies für eine spätere Prognose verwendet werden

kann. Auch dieses wird automatisch durch das Programm abgespeichert. Damit nur das beste Modell

abgespeichert wird, vergichen wir die validation accuracy mit den vorherigen Epochen und speicherten jeweils

nur das beste Ergebnis ab. Dies kann mit nur wenigen Codezeilen realisiert werden.

Der gesamte Code für die Realisierung des Grid-Tests kann dem Anhang im Kapitel 14.3.2 entnommen werden.

5 Neuronales Netz 5.6 Lamellenpilze Testreihe 1


5.6 Lamellenpilze Testreihe 1

Auf den folgenden Seiten werden die Grid-Tests mit mehreren Testreihen der Lamellenpilze genau erläutert.

Dabei wird jeweils auf die Konfiguration, die Ergebnisse und eine daraus folgende Diskussion eingegangen. Mit

einem kurzen Fazit wird die Testreihe anschliessend abgeschlossen.

5.6.1 Konfiguration

Für den ersten Test wurden folgende Parameter getestet und verglichen:

Pilze: Fliegenpilz, Gelber-Knollenblätterpilz, Grüner-Knollenblätterpilz, Grauer-

Wulstling, Pantherpilz, Perlpilz, Pfifferling

Bildgrösse: 64x64 Pixel, 128x128 Pixel

Farbkanäle: 3

Batchgrösse: 256 (64x64 Pixel), 128 (128x128 Pixel)

Anzahl convolutional layer: 2, 3, 4

Filtergrösse: [10, 10], [8, 8], [6, 6], [4, 4]

[10 ,8, 6], [8, 8, 6], [8, 6, 4], [6, 6, 4]

[10, 8, 6, 6], [8, 8, 6, 4], [8, 6, 6, 4], [8, 6, 4, 4]

Anzahl Filter: 32

Grösse fully connected layer: 32, 64, 128

Lernrate: 0.0001

Anzahl Epochen: 100

5.6.2 Ergebnis

Mithilfe dieser Parameter wurden 72 verschiedene neuronale Netze trainiert und verglichen. Das Ergebnis der

fünf besten neuronalen Netze wird in Tabelle 4 in gekürzter Form dargestellt. Alle Testresultate sind dem Anhang

im Kapitel 14.5 Testergebnisse Grid-Tests zu entnehmen.

Image size

[Pixel]

Number of

convolutional

layer

Filter size Fully connected

layer size

Validation

accuracy

Validation loss

128x128 3 [6,6,4] 64 80.5 % 1.394

128x128 3 [8,6,4] 128 79.7 % 0.816

64x64 3 [6,6,4] 128 78.1 % 1.016

128x128 4 [8,6,4,4] 64 78.1 % 1.112

128x128 2 [4,4] 128 78.1 % 1.395

Tabelle 4 Ergebnis der fünf besten neuronalen Netze der 1. Testreihe (Lamellenpilze)



In der Abbildung 48 und Abbildung 49 ist das neuronale Netze dargestellt, welches die höchste validation

accuracy mit rund 80 % erreicht hat. Sehr auffällig sind die Sprünge in der validation accuracy, welche in den

Tests aller Lamellenpilze vorkommen. In weiteren Tests auf Bildern der Röhrlinge, welche im Kapitel 5.10 bis 5.12

dokumentiert sind, wurde ein solcher Effekt nicht mehr verzeichnet. Zurückzuführen ist dies auf die Batchgrösse,

welche bei den Tests der Lamellenpilze durch die Grafikkarte NVIDIA GeForce GTX 1080 Ti auf 128 Bilder pro

Batch, aufgrund des Speicherbedarfs, begrenzt ist. Bei den Tests mit den Bildern der Röhrlinge und einer

Batchgrösse von 256 Bilder pro Batch ist dieses Sprungverhalten nicht mehr festzustellen. Diese Tests wurden

auf der noch stärkeren Grafikkarte NVIDA Tesla V100 mit einem grösseren Speicher von 16GB durchgeführt,

weshalb die Batchgrösse auf 256 Bilder pro Batch erhöht werden konnte.

Abbildung 48 Graph accuracy Lamellenpilze Testreihe 1 – In der Abbildung ist das neuronale Netze dargestellt, welches die höchste

validation accuracy mit rund 80 % erreicht hat.

Abbildung 49 Graph loss Lamellenpilze Testreihe 1 – Die Abbildung zeigt, dass das Problem des Übertrainings immer noch besteht, da der

loss ab der 20. Epoche stetig ansteigt.



5.6.3 Diskussion

5.6.3.1 Graph

Abgesehen von den Sprüngen, welche sehr markant sind, ist ein viel besseres Ergebnis als mit allen 15 Pilzarten

zu verzeichnen. Das Problem des Übertrainings besteht jedoch immer noch, denn der loss erhöht sich nach 20

Epochen stetig.

5.6.3.2 Tabelle

Aus der Auswertung aller Tests in der Excel-Tabelle wird ersichtlich, dass sich hauptsächlich zwei Parameter auf

das Resultat auswirken. Dies sind die Filtergrösse und die Bildeingangsgrösse.

Bei den Bildergrössen ist zu vermerken, dass die neuronalen Netze mit Bildern der Grösse 128x128 Pixel

tendenziell bessere Resultate liefern. Vier der fünf besten Resultate wurden auf dieser Bildeingangsgrösse erzielt.

Ein ebenfalls wichtiger Faktor zeigte sich in den Filtergrössen. Hier wurden stets bessere Resultate mit kleineren

Filtergrössen erzielt.


Anhand der Confusion Matrix der Abbildung 50 sieht

man sehr gut, dass der Fliegenpilz und der Pfifferling

kaum falsch klassifiziert werden. Bei den anderen

Pilzen kommt es häufiger zu Fehlklassifizierungen, was

daran liegt, dass sich die Pilze sehr ähneln. Insgesamt

werden bei diesem Validierungsbatch 103 von 128

Pilzen richtig klassifiziert, was zu einer Trefferquote

von rund 80 % führt.

Abbildung 50 Confusion Matrix 1. Testreihe Lamellenpilze – Die

Confusion Matrix zeigt deutlich, dass die Fliegenpilze und Pfifferlinge

kaum falsch klassifiziert werden. Insgesamt werden 103 von 128 Pilzen

richtig klassifiziert, was zu einer Trefferquote von rund 80 % führt.

5.6.4 Fazit

Anhand der Resultate wird ersichtlich, dass die fünf besten Ergebnisse mit den kleineren Filtern erzielt werden,

weshalb in einem zweiten Test der Fokus auf kleinere Filter gelegt und dieser Parameter noch ausgiebiger

getestet wird. Das Problem des ständig ansteigenden loss wird im nächsten Test ebenfalls unter die Lupe

genommen. Dies wird mit einem Test mit verschiedenen Lernraten realisiert.

5 Neuronales Netz 5.7 Lamellenpilz Testreihe 2


5.7 Lamellenpilz Testreihe 2

5.7.1 Konfiguration

Für den zweiten Test wurden folgende Parameter getestet und verglichen:




Farbkanäle: 3

Batchgrösse: 256 (64x64 Pixel), 128 (128x128 Pixel)

Anzahl convolutional layer: 2, 3, 4, 5

Filtergrösse: [6, 6], [6, 4], [4, 4], [3, 3]

[6, 6, 4], [6, 4, 4], [4, 4, 4], [3, 3, 3]

[6, 6, 6, 4], [6, 6, 4, 4], [4, 4, 4, 4], [3, 3, 3, 3]

[6, 6, 6, 6, 4], [6, 6, 4, 4, 4], [4, 4, 4, 4, 4], [3, 3, 3, 3, 3]

Anzahl Filter: 32


Lernrate: 0.0001, 0.001

Anzahl Epochen: 100

5.7.2 Ergebnis

In unserer zweiten Testreihe zur Klassifizierung der Lamellenpilze wurden mithilfe der obenstehenden Parameter

192 verschiedene neuronale Netze trainiert und verglichen. Das Ziel lag darin, kleinere Filtergrössen

untereinander zu vergleichen und eine definitive Bildgrösse für die weiteren Tests festzulegen. Wiederum

werden die fünf besten Resultate in Tabelle 5 dargestellt. Die restlichen Testresultate sind dem Anhang im Kapitel

14.5 Testergebnisse Grid-Tests zu entnehmen.

Image size

[Pixel]

Number of

convolutional

layer


layer size

Validation

accuracy

Validation loss

128x128 5 [4,4,4,4,4] 128 85.2 % 1.528

128x128 4 [3,3,3,3] 256 84.4 % 0.640

128x128 5 [6,6,4,4,4] 256 84.4 % 1.203

128x128 5 [6,6,4,4,4] 128 83.6 % 1.052

64x64 4 [3,3,3,3] 256 83.2 % 1.356




In der Abbildung 51, sowie in der Abbildung 52 ist das neuronalen Netze dargestellt, welches die höchste

validation accuracy erreicht hat.

Abbildung 51 Graph accuracy Lamellenpilze Testreihe 2 – Gut ersichtlich ist, dass das neuronale Netz extrem schnell lernt. Bereits nach

wenigen Epochen wird eine validation accuracy von über 50 % erreicht. Nach 12 Epochen werden sogar schon über 75 % erreicht.

Abbildung 52 Graph loss Lamellenpilze Testreihe 2 – Auch in dieser Abbildung wird ersichtlich, dass das neuronale Netz ab Epoche 30 mit

dem Übertraining zu kämpfen hat.

5.7.3 Diskussion

5.7.3.1 Graph

Gut ersichtlich ist, dass das neuronale Netz extrem schnell lernt. Bereits nach wenigen Epochen wird eine

validation accuracy von über 50 % erreicht. Nach 12 Epochen werden gar über 75 % erreicht, was als ein gutes

Resultat interpretiert werden kann. Danach stagniert die validation accuracy und der loss pendelt sich ein, bevor

dieser nach oben geht. Das beste Resultat wird dann knapp vor 60 Epochen erreicht. In diesem Teil befindet sich

das Netz jedoch schon leicht in einem Übertraining, was am höheren loss zu erkennen ist.



5.7.3.2 Tabelle

Hier wird ganz klar gezeigt, dass sich etwas kleinere Filter besser zur Erkennung von Pilzen eignen. Insgesamt

erreichen 24 Netze den vorherigen Bestwert von 80.4 % in der validation accuracy. Das allerbeste Netz erreicht

sogar 85.2 %, was mit beinahe 5 % Steigerung eine klare Verbesserung darstellt.

Ein weiterer Parameter, welcher grosse Unterschiede in der Performance der neuronalen Netze darstellt, ist die

Anzahl der convolutional layer. Am unteren Ende der Tabelle angesiedelt sind die Netze mit zwei und drei

convolutional layer. Die besseren Netze sind meist mit vier oder fünf convolutional layer ausgestattet. Nur

einzelne Ausreisser mit drei convolutional layer sind in der oberen Tabellenhälfte angesiedelt.

Ein ähnlicher Effekt wird wiederum in der Bildgrösse entdeckt. Die Netze mit den grösseren Bildern (128x128

Pixel) als Input verzeichnen generell bessere Resultate als solche mit einem Input von Bildern mit 64x64 Pixel.


Die Confusion Matrix, welche in der Abbildung 53

ersichtlich ist, zeigt erneut relativ klar, wo das

neuronale Netz Probleme bei der Klassifizierung hat.

Die Unterscheidung zwischen den beiden Knollen-

blätterpilzen fällt dem neuronalen Netz schwer und

führt immer wieder zu Fehlklassifizierungen. Das

gleiche Problem zeichnet sich beim Pantherpilz und

dem grauen Wulstling ab. Pilze wie der Fliegenpilz

oder der Pfifferling, die sich auch für das menschliche

Auge klar von den anderen Pilzen unterscheiden

lassen, werden kaum falsch klassifiziert.

Abbildung 53 Confusion Matrix 2. Testreihe Lamellenpilze – Die

Confusion Matrix zeigt, dass das neuronale Netz Schwierigkeiten hat, die

beiden Knollenblätterpilze zu unterscheiden.

5.7.3.4 Vergleich Lernraten

In der Abbildung 54 und Abbildung 55, welche auf der nächsten Seite ersichtlich sind, wurden die accuracy und

der loss der Trainings- und Validierungs-Daten von zwei neuronalen Netzen abgebildet, die sich nur durch

unterschiedliche Lernraten unterscheiden. Es ist sehr gut zu erkennen, dass das neuronale Netz mit der höheren

Lernrate sehr viel schneller bei den gegebenen Trainingsdaten lernt. Die validation accuracy pendelt sich bereits

nach kurzer Zeit zwischen 65 % und 80 % ein. Man sieht allerdings auch, dass der validation loss bereits nach 10

Epochen wieder anfängt zu steigen, was auf ein Übertraining hindeutet. Zudem wird der loss bedeutend grösser,

wenn die Lernrate grösser gewählt wird.



Abbildung 54 Graph accuracy Vergleich Lernraten – Anhand dieser Abbildung ist sehr gut zu erkennen, dass das neuronale Netz mit der

höheren Lernrate sehr viel schneller bei den gegebenen Trainingsdaten lernt.

Abbildung 55 Graph loss Vergleich Lernraten – Die Abbildung zeigt, dass der loss bedeutend grösser wird, wenn die Lernrate grösser

gewählt wird.

5.7.4 Fazit

Das Resultat der zweiten Testreihe hat erneut gezeigt, dass mit den grösseren 128x128 Pixel grossen Bildern

allgemein die besseren Ergebnisse erzielt werden können, weshalb keine weiteren Tests mit 64x64 Pixel grossen

Bildern durchgeführt werden. Zudem ist ersichtlich, dass die Pilze besser klassifiziert werden, wenn das

neuronale Netz mindestens vier convolutional layer besitzt. Bezüglich der Filtergrössen wird weiter mit kleinen

Grössen gearbeitet, da diese zu klar besseren Resultaten geführt haben.

Da keine Verbesserung durch eine Erhöhung der Lernrate erzielt werden konnte, werden in einer dritten

Testreihe Versuche mit einer kleineren Lernrate durchgeführt.



5.8 Lamellenpilze Testreihe 3

5.8.1 Konfiguration

Für die dritte Testreihe wurden folgende Parameter getestet und verglichen:



Bildgrösse: 128x128 Pixel

Farbkanäle: 3

Batchgrösse: 128

Anzahl convolutional layer: 4, 5

Filtergrösse: [6, 6, 6, 4], [6, 6, 4, 4], [4, 4, 4, 4], [4, 4, 3, 3], [3, 3, 3, 3]

[6, 6, 6, 6, 4], [6, 6, 4, 4, 4], [4, 4, 4, 4, 4], [4, 4, 3, 3, 3], [3, 3, 3, 3, 3]

Anzahl Filter: 32


Lernrate: 0.00001

Anzahl Epochen: 300

5.8.2 Ergebnis

Ziel dieses Tests war die Reduktion des Übertrainings durch eine kleinere Lernrate. Diese Reduktion zog auch

eine Erhöhung der Epochen mit sich, wodurch die Trainingszeit des neuronalen Netzes bedeutend länger wurde.

Die fünf besten Resultate des Tests werden in Tabelle 6 aufgezeigt. Alle Daten und die restlichen Tests können

dem Anhang im Kapitel 14.5 Testergebnisse Grid-Tests entnommen werden.

Image size

[Pixel]

Number of

convolutional

layer


layer size

Validation

accuracy

Validation loss

128x128 4 [4, 4, 3, 3] 256 84.4 % 0.800

128x128 4 [4, 4, 3, 3] 64 83.6 % 0.703

128x128 5 [3, 3, 3, 3, 3] 256 82.8 % 0.792

128x128 5 [6, 6, 4, 4, 4] 64 82.8 % 0.620

128x128 4 [6, 6, 4, 4] 256 82.0 % 0.815




Das beste Resultat der dritten Testreihe ist in der Abbildung 56 und Abbildung 57 dargestellt. Durch die

Verkleinerung der Lernrate konnte das Netz viel langsamer trainiert werden. Die Anzahl der Epochen musste auf

300 erhöht werden, damit das Netz eine training accuracy von über 90 % erreichen konnte.

Abbildung 56 Graph accuracy Lamellenpilze Testreihe 3 – Ca. bis zur 150. Epoche kann die validaiton accuracy mit der training accuracy

mithalten, danach steigt nur noch die training accuracy an.

Abbildung 57 Graph loss Lamellenpilze Testreihe 3 – Sehr gut ersichtlich wird in dieser Abbildung , dass sich der validation loss erst nach

150 Epochen erhöht und damit der Effekt des Übertrainings wesentlich verringert werden konnte.

5.8.3 Diskussion

5.8.3.1 Graph

Sehr gut ersichtlich wird in der Abbildung 57, dass sich der validaiton loss erst nach 150 Epochen erhöht und

damit der Effekt des Übertrainings wesentlich verringert werden konnte. Dies ist auch in Abbildung 56 zu

beobachten. Bis ca. 150 Epochen kann die validation accuracy mit der training accuracy mithalten, danach erhöht

sich die training accuracy und die validation accuracy stagniert.



5.8.3.2 Tabelle

Mit einem Resultat von 84.4 % ist das Ergebnis nur leicht schlechter wie jenes der 2. Testreihe. Auffällig ist, dass

der validaiton loss in allen Tests sehr niedrig ausfällt. Dies liegt an der niedrigeren Lernrate, welche das

Übertraining verringert. Auch wieder gut ersichtlich wird, dass die kleineren Filter generell bessere Resultate

liefern wie grössere Filter.

Kein eindeutiges Resultat können die Parameter fully connected layers size und number of convolutional layer

liefern. Daher kann kein eindeutiges Fazit über die optimale Grösse des neuronalen Netzes gezogen werden.


In der Abbildung 58 ist erneut die Confusion Matrix

der Validierungsdaten abgebildet. In dieser Epoche

wird die höchste validation accuracy von 84.4 %

erreicht. Die Fliegenpilze und die Pfifferlinge werden

wie erwartet nahezu fehlerfrei klassifiziert. Bei den

restlichen Pilzen sind die Fehlklassifizierungen

relativ homogen verteilt.

Abbildung 58 Confusion Matrix 3. Testreihe Lamellenpilze – In dieser

Abbildung ist ausser bei den Fliegenpilzen und den Pfifferlingen eine

relativ homogene Verteilung an Fehlklassifizierungen zu beobachten.

5.8.4 Fazit

Durch die Verringerung der Lernrate wird im Verglich zur 2. Testreihe kein besseres Ergebnis erzielt. Die kleinere

Lernrate vermeidet aber das Übertraining, was sich in einem generell tieferen loss auswirkt.

Ein wesentlicher Aspekt des Trainings des neuronalen Netzes bildet jedoch auch die benötigte Trainingszeit.

Diese wird durch die Verringerung der Lernrate und der damit verbundenen Erhöhung der Anzahl Epochen

enorm in die Länge gezogen.

5 Neuronales Netz 5.9 Fazit Testreihen Lamellenpilze


5.9 Fazit Testreihen Lamellenpilze

Zur besseren Übersicht über alle Testreihen werden die besten zehn Resultate in der Tabelle 7 aufgeführt.

Testreihe Image size

[Pixel]

Lernrate Filter size Fully

connected

layer size

Validation

accuracy

Validation

loss

2 128x128 0.001 [4,4,4,4,4] 128 85.2 % 1.528

2 128x128 0.0001 [3,3,3,3] 256 84.4 % 0.640

3 128x128 0.00001 [4, 4, 3, 3] 256 84.4 % 0.800

2 128x128 0.001 [6,6,4,4,4] 256 84.4 % 1.203

3 128x128 0.00001 [4, 4, 3, 3] 64 83.6 % 0.703

2 128x128 0.001 [6,6,4,4,4] 128 83.6 % 1.052

2 64x64 0.001 [3,3,3,3] 256 83.2 % 1.356

3 128x128 0.00001 [3, 3, 3, 3, 3] 256 82.8 % 0.792

3 128x128 0.00001 [6, 6, 4, 4, 4] 64 82.8 % 0.620

2 128x128 0.001 [3,3,3,3,3] 64 82.8 % 1.037

Tabelle 7 Übersicht der zehn besten neuronalen Netze aller Testreihen (Lamellenpilze)

Die besten Resultate werden allesamt in der 2. und 3. Testreihe erzielt.

Ein eindeutiger Parameter, welcher bei allen Tests zu ähnlichen Resultaten führte, ist die Bildgrösse. Hier werden

mit einer Bildgrösse von 128x128 Pixel meist die besten Ergebnisse erzielt, nur einzelne Ausreisser, wie dies beim

siebtbesten Netz der Fall ist, sind zu verzeichnen. Ebenso ein eindeutiges Ergebnis bringt die Filtergrösse hervor.

In Architekturen mit kleineren Filtergrössen werden generell bessere Resultate erzielt.

In der 3. Testreihe wurde sehr gut ersichtlich, dass sich die kleinere Lernrate positiv auf das Übertraining auswirkt.

Dieser Effekt ist sehr gut in den Abbildungen des validation loss zu beobachten. Dieser befindet sich durch eine

kleinere Lernrate viel länger im Abwärtstrend, als dies bei grösseren Lernraten von 0.0001 der Fall ist. Da dieser

Test jedoch leicht schlechtere Resultate zur Folge hatte, werden Lernraten von 0.001 oder 0.0001 in unserem

Fall leicht bevorzugt.

Alle anderen Parameter müssen durch etliche Tests ausprobiert werden, damit man das beste Netz für die

Pilzsuche bestimmen kann. Daher ist eine eindeutige beste Architektur nicht generell zu erwähnen, sondern

muss stets auf die Inputdaten angepasst und durch Tests validiert werden. In unserem Fall mit den

Lamellenpilzen entscheiden wir uns für das neuronale Netz an 2. Stelle.

Doch wieso wird nun nicht das etwas bessere Netz für die Vorhersage der Pilze verwendet? Dies lässt sich durch

einen kurzen Blick auf die Tabelle 7 begründen. Der validation loss beim neuronalen Netz an zweiter Stelle ist

wesentlich niedriger, was auf eine exaktere Vorhersage hindeutet. Aus diesem Grund wird für die

Webapplikation das zweitbeste neuronale Netz verwendet.

5 Neuronales Netz 5.9 Fazit Testreihen Lamellenpilze


In der Abbildung 59 ist die von uns ausgewählte Architektur mit vier convolutional layer dargestellt. Mit dieser

Architektur gibt es 555’751 verschiedene Parameter, die optimiert werden mussten, um eine möglichst gute

Klassifizierung zu erhalten. Die Anzahl an Parameter ist im Vergleich zu den Anzahl Trainingsbilder um den Faktor

15 grösser, was definitiv nicht optimal ist. Da dieses neuronale Netz allerdings bessere Ergebnisse erzielte als

andere neuronale Netze mit weniger Parameter und wir keine Möglichkeit hatten, die Anzahl an Trainingsdaten

zu erhöhen, wurde trotzdem dieses Netz für die Webapplikation verwendet.

Abbildung 59 Architektur neuronales Netz Lamellenpilze – Die Abbildung zeigt sehr schön die Architektur des besten neuronalen Netzes,

welches aus vier convolutional layer und insgesamt zwei fully connected layer besteht.

5 Neuronales Netz 5.10 Röhrlinge Testreihe 1


5.10 Röhrlinge Testreihe 1

Auf den nachfolgenden Seiten werden die Tests mit den Röhrlingen dokumentiert. Diese wurden parallel zu den

Tests mit den Lamellenpilzen auf der Grafikkarte des Clusters der HSR durchgeführt, weshalb sich einige

Erkenntnisse wiederholen werden. Diese werden aber der Vollständigkeit halber trotzdem dokumentiert.

5.10.1 Konfiguration

Für den ersten Test wurden folgende Parameter getestet und verglichen:

Pilze: Sommer-Steinpilz, Kiefern-Steinpilz, Gemeiner-Steinpilz, Schwarzhütiger-

Steinpilz, Butterpilz, Gold-Röhrling, Sand-Röhrling, Ziegenlippe

Bildgrösse: 64x64 Pixel, 128x128 Pixel, 256x256 Pixel

Farbkanäle: 3

Batchgrösse: 256

Anzahl convolutional layer: 2, 3, 4

Filtergrösse: [10, 10], [8, 8], [6, 6], [4, 4]

[10 ,8, 6], [8, 8, 6], [8, 6, 4], [6, 6, 4]

[10, 8, 6, 6], [8, 8, 6, 4], [8, 6, 6, 4], [8, 6, 4, 4]

Anzahl Filter: 32


Lernrate: 0.0001

Anzahl Epochen: 100

5.10.2 Ergebnis

Mithilfe dieser Parameter wurden 108 verschiedene neuronale Netze trainiert und verglichen. Bei diesem Test

wurden alle neuronalen Netze auf dem GPU Cluster der Hochschule in Rapperswil trainiert. Dank des grösseren

Speichers der Grafikkarte war es möglich, alle Tests mit einer Batchgrösse von 256 durchzuführen. Wie bei den

Tests mit den Lamellenpilzen werden auch hier die fünf besten Ergebnisse in Tabelle 8 dargestellt. Alle

Testresultate sind dem Anhang im Kapitel 14.5 Testergebnisse Grid-Tests zu entnehmen.

Image size

[Pixel]

Number of

convolutional

layer


layer Size

Validation

accuracy

Validation loss

64x64 2 [4,4] 32 62.9 % 1.093

64x64 3 [8,6,4] 64 61.3 % 1.541

64x64 4 [8,6,4,4] 128 61.3 % 1.105

64x64 3 [6,6,4] 128 60.9 % 2.168

64x64 4 [8,6,4,4] 64 60.2 % 1.685

Tabelle 8 Ergebnis der fünf besten neuronalen Netze der 1. Testreihe (Röhrlinge)



Die Plots des besten Netzes dieser Testreihe sind in der Abbildung 60 und Abbildung 61 ersichtlich. Hier ist der

Effekt der grösseren Batchgrösse gut zu erkennen, denn die Sprünge, welche in allen Tests der Lamellenpilze zu

beobachten waren, sind nicht mehr vorhanden.

Abbildung 60 Graph accuracy Röhrlinge Testreihe 1 – Die Abbildung zeigt ein ähnliches Verhalten wie bei den Lamellenpilzen. Bereits nach

40 Epochen wird die maximale validation accuracy erreicht.

Abbildung 61 Graph loss Röhrlinge Testreihe 1 – Auch bei diesem neuronalen Netz steigt der validation loss während des Trainings wieder

an, was auf ein Übertraining hindeutet.

5.10.3 Diskussion

5.10.3.1 Graph

Ähnlich wie bei den Lamellenpilzen ist auch das Verhalten der Röhrlinge. Schon nach wenigen Epochen erreicht

die validation accuracy 50 % und die Steigung nimmt ab. Bereits nach 40 Epochen wird der Höhepunkt erreicht

und der loss wird langsam wieder höher. Auch hier besteht das Problem des Übertrainings auf den

Trainingsdaten.



5.10.3.2 Tabelle

Mit 62.9 % fallen die Resultate einiges schlechter aus als jene der ersten Testreihe mit den Lamellenpilzen. Dies

liegt daran, dass sehr viele Pilze Ähnlichkeiten untereinander aufweisen. Genauere Resultate zu diesem Problem

werden im nächsten Abschnitt genauer betrachtet.

Grosse Filter haben auch bei diesen Pilzen zu keinem guten Ergebnis geführt. Es sind eher kleine Filtergrössen,

welche gute Resultate hervorbrachten.

Ein erstaunliches Resultat ergibt sich bei der Bildgrösse. Hier wird entgegen den Erwartungen ein besseres

Resultat mit den Bildern mit 64x64 Pixel erzielt, anstatt mit 128x128 Pixel, wie es bei den Lamellenpilzen der Fall

war.


Die Confusion Matrix, welche in Abbildung 62

abgebildet ist, zeigt auch bei diesem Test sehr gut die

Probleme bei der Klassifizierung auf. Da sich die vier

Steinpilzarten sehr ähnlich sind, kommt es häufig zu

Fehlklassifizierungen. Viele Fehlklassifizierungen sind

auch beim Gold-Röhrling zu verzeichnen.

Abbildung 62 Confusion Matrix 1. Testreihe Röhrlinge – Die Confusion

Matrix zeigt deutlich, dass die Klassifizierung der vier Steinpilzarten

Schwierigkeiten bereitet.

5.10.4 Fazit

Die erste Testreihe zeigt, dass die Klassifizierung der Röhrlinge allgemein schlechter funktioniert als die der

Lamellenpilze. Der Hauptgrund liegt vor allem darin, dass sich die vier verschiedenen Steinpilze zum Teil sehr

ähnlich sind, und dadurch auch häufiger falsch klassifiziert werden. Da auch bei dieser Testreihe die Ergebnisse

mit den kleineren Filtern etwas besser sind, wird eine zweite Testreihe mit kleineren Filtern durchgeführt.

Überraschend ist allerdings, dass die 64x64 Pixel grossen Bilder am besten klassifiziert werden, weshalb in der

zweiten Testreihe nur noch mit den 64x64 und 128x128x Pixel grossen Bilder trainiert wird. Des Weiteren wird

in der nächsten Testreihe mit der Anzahl der Filter ein weiterer Parameter getestet.

Durch die Erhöhung der Batchgrösse auf 256 Bilder gibt es keine extremen Sprünge mehr zwischen den einzelnen

Epochen, wie es bei den Lamellenpilzen zu beobachten war.





Für den zweiten Test der Röhrlinge wurden folgende Parameter getestet und verglichen:




Farbkanäle: 3

Batchgrösse: 256


Filtergrösse: [6, 6, 6, 4], [6, 6, 4, 4], [4, 4, 4, 4], [3, 3, 3, 3]

[6, 6, 6, 6, 4], [6, 6, 4, 4, 4], [4, 4, 4, 4, 4], [3, 3, 3, 3, 3]

Anzahl Filter: 32, 64


Lernrate: 0.001, 0.0001

Anzahl Epochen: 100

5.11.2 Ergebnis

Bei dieser Testreihe wurden insgesamt 192 Tests durchgeführt. Die besten fünf Resultate der Testreihe werden

in gekürzter Form in Tabelle 9 dargestellt. Die ganze Tabelle mit allen Informationen, sowie allen Tests, ist dem

Anhang im Kapitel 14.5 Testergebnisse Grid-Tests zu entnehmen.

Image size

[Pixel]

Number of

convolutional

layer


layer size

Validation

accuracy

Validation loss

64x64 5 [3, 3, 3, 3, 3] 128 69.5 % 0.971

64x64 5 [3, 3, 3, 3, 3] 256 66.4 % 0.994

128x128 5 [3, 3, 3, 3, 3] 128 66.4 % 0.976

64x64 5 [3, 3, 3, 3, 3] 256 66.0 % 1.049

64x64 4 [3, 3, 3, 3 ] 256 66.0 % 1.006


Da der Graph des besten neuronalen Netzes ähnlich wie jener der letzten Testreihe ausfiel, wird auf der nächsten

Seite in der Abbildung 63 und Abbildung 64 ausnahmsweise nicht das beste Ergebnis visualisiert, sondern ein

etwas schlechteres neuronales Netz, um die Unterschiede aufzuzeigen.



Abbildung 63 Graph accuracy Röhrlinge Testreihe 2 – Diese Abbildung zeigt die accuracy eines schlechten Resultats.

Abbildung 64 Graph loss Röhrlinge Testreihe 2 – Diese Abbildung zeigt den grossen Unterschied zu den guten Ergebnissen. Der validation

loss steigt bei diesem neuronalen Netz viel stärker an, als bei besseren neuronalen Netzen.

5.11.3 Diskussion

5.11.3.1 Graph

Wie schon auf der vorherigen Seite erwähnt, handelt es sich bei dieser Betrachtung des Graphen um ein

schlechtes Resultat.

In der Abbildung 63 sind keine grossen Unterschiede zu einem Graph mit besseren Resultaten zu sehen. Einzig

die maximal erreichte accuracy ist tiefer. Der grosse Unterschied von guten zu schlechten Resultaten ist in der

Abbildung 64 im loss zu finden. Bei der ersten Betrachtung werden kaum Unterschiede entdeckt, wenn man

allerdings genauer hinsieht, erkennt man, dass sich der Wertebereich beim schlechten Ergebnis in einem

grösseren Rahmen bewegt. Bei guten Resultaten variiert dieser im Bereich von 20 bis 100 Epochen um ca. 0.2.

Beim schlechten Netz variiert dieser im gleichen Bereich um mehr als 1, was somit auch zum schlechten Resultat

führt.



5.11.3.2 Tabelle

Durch die Veränderung der Parameter können um knapp 7 % bessere Resultate als in der ersten Testreihe

erreicht werden. Der grösste Einfluss auf das Ergebnis hat die Anzahl der convolutional layer. Bei der letzten

Testreihe wurden nur bis vier convolutional layer getestet. Durch das Hinzufügen eines weiteren layer können

nun in dieser Testreihe signifikant bessere Resultate erzielt werden. Unter den zehn besten Architekturen aus

diesem Test sind deren sieben mit fünf convolutional layer ausgestattet. Die kleinen Filtergrössen verzeichnen

auch hier bessere Resultate als die grossen Filter mit einer Grösse von sechs Pixeln.

In diesem Test werden bessere Resultate mit Bildern der Grösse 64x64 Pixel erreicht. Es sind nur einzelne gute

Resultate mit Bildern der Grösse von 128x128 Pixel in der obersten Tabellenhälfte zu finden.

Ein weiterer Parameter, welcher in diesem Test genauer unter die Lupe genommen wurde, war die Anzahl der

Filter, welche ein convolutional layer besitzt. Es wurden sowohl 32, wie auch 64 Filter getestet. Aus den

Resultaten wird ersichtlich, dass 32 Filter generell bessere Resultate hervorbringen als 64 Filter. Einzelne gute

Resultate mit 64 Filtern pro convolutional layer sind in der oberen Tabellenhälfte zu sehen, jedoch häufen sich

diese eher in der unteren Hälfte.


In der Confusion Matrix des besten Netzes aus dieser

Testreihe, welche in Abbildung 65 zu sehen ist, kann

man wiederum die Probleme der Klassifizierung

aufzeigen. Diese sind vorwiegend bei den vier

verschiedenen Steinpilzen zu beobachten. Doch auch

bei den anderen Pilzen wie dem Sandröhrling oder

der Ziegenlippe sind einige Fehlklassifizierungen zu

verzeichnen.

Abbildung 65 Confusion Matrix 2. Testreihe Röhrlinge – Die Probleme bei

der Klassifizierung der Steinpilzarten sind auch bei dieser Confusion

Matrix eindeutig zu erkennen.

5.11.4 Fazit

Diese Testreihe hat bereits einige bessere Resultate als die letzte Testreihe hervorgebracht. Der wohl grösste

Einfluss hat dabei die Anzahl convolutional layer. Andere Parameter, welche in diesem Test verändert wurden,

wie die Anzahl der Filter, werden aufgrund von schlechteren Ergebnissen nicht mehr verfolgt. Da die Lernrate

einen sehr grossen Einfluss bei den Lamellenpilzen hatte, wird auch dieser Parameter in den nächsten Tests

untersucht. Dazu wird die Lernrate auf 10-5 eingestellt, und die Anzahl Epochen auf 300 erhöht, damit man in der

training accuracy nahe an die 100 % und somit in den Bereich des Übertrainings kommt.





Für die dritte Testreihe der Röhrlinge wurden folgende Parameter getestet und verglichen:



Bildgrösse: 64x64 Pixel, 128x128 Pixel, 256x256 Pixel

Farbkanäle: 3

Batchgrösse: 128


Filtergrösse: [6, 6, 6, 4], [6, 6, 4, 4], [4, 4, 4, 4], [4, 4, 3, 3], [3, 3, 3, 3]

[6, 6, 6, 6, 4], [6, 6, 4, 4, 4], [4, 4, 4, 4, 4], [4, 4, 3, 3, 3], [3, 3, 3, 3, 3]

Anzahl Filter: 32, 64


Lernrate: 0.00001

Anzahl Epochen: 300

5.12.2 Ergebnis

Zu guter Letzt wurden nochmals Tests mit 90 verschiedenen neuronalen Netzen gestartet. Dabei wurde entgegen

den Erkenntnissen der vorherigen Tests nochmals die Bildgrösse auf 256x256 als Input getestet. Nach zwei Tests

wurden die Tests mit so grossen Bildern jedoch vom Programm beendet, da der Speicherbedarf für ein Netz

dieser Grösse (mit der Verwendung von vier oder fünf convolutional layer) derjenigen der Grafikkarte

überschritten hatte. Deswegen konnten keine weiteren Tests mit der Bildgrösse 256x256 Pixel durchgeführt

werden. In der Excel-Tabelle sind alle Tests aufgeführt, welche mit der gegebenen Hardware durchgeführt

werden konnten. Insgesamt sind dies 60 verschiedene Architekturen. Die besten fünf Ergebnisse können der

Tabelle 10 entnommen werden. Die restlichen Resultate können dem Anhang im Kapitel 14.5 Testergebnisse

Grid-Tests entnommen werden.

Image size

[Pixel]

Number of

convolutional

layer


layer size

Validation

accuracy

Validation loss

128x128 5 [4, 4, 3, 3, 3 ] 256 75.0 % 0.862

128x128 5 [3, 3, 3, 3, 3 ] 128 75.0 % 0.879

64x64 5 [4, 4, 3, 3, 3 ] 256 73.4 % 0.908

128x128 5 [4, 4, 3, 3, 3 ] 128 73.4 % 0.838

64x64 4 [4, 4, 3, 3] 256 72.7 % 0.912




Die Abbildung 66 und Abbildung 67 zeigen wieder die accuracy sowie den loss, welche beim besten neuronalen

Netz erreicht wurde. Aufgrund der Tests mit den grösseren Bildern wurden in diesem Test alle Netze mit der

Batchgrösse von 128 Bilder pro Batch trainiert. Dies wiederspiegelt sich im Graph, da in den Validierungs-

ergebnissen wieder grosse Sprünge zu beobachten sind.

Abbildung 66 Graph accuracy Röhrlinge Testreihe 3 – In dieser Abbildung fallen die starken Sprünge zwischen den einzelnen Epochen auf,

die auf die kleinere Batchgrösse zurückzuführen sind.

Abbildung 67 Graph loss Röhrlinge Testreihe 3 – Der in dieser Abbildung dargestellte validation loss steigt erst gegen Ende des Trainings

ein wenig an, was darauf hindeutet, dass das neuronale Netz kaum übertrainiert.

5.12.3 Diskussion

5.12.3.1 Graph

Wie schon erwähnt sind die Sprünge wegen der kleinen Batchgrösse wieder zu beobachten. Abgesehen von

diesen ist im loss der Abbildung 67 eine sehr schöne Lernkurve zu sehen. Bis ca. zur Epoche 100 kann dieser gar

mit dem training loss mithalten. Danach stagniert dieser und gegen den Schluss erhöht sich dieser gar leicht. Ein

ähnliches Ergebnis ist in der Abbildung 66 der accuracy zu beobachten. Die besten Gewichtungen findet das Netz

erst nach 230 Epochen, was bedeutet, dass sich das Netz bis zu diesem Zeitpunkt noch in keinem Übertraining

befindet. In den letzten 10 Epochen kann dann von Übertraining der Daten gesprochen werden, da die training

accuracy einen Anstieg verzeichnet und die validation accuracy immer auf demselben Level bleibt.



5.12.3.2 Tabelle

Mit einem besten Ergebnis von 75 % können durch diese Veränderungen in der Testreihe 3 eine Steigerung von

5 % gegenüber der Testreihe 2 erreicht werden. In der Tabelle 10 zu sehen ist, dass die Bildgrösse des Netzinputs

für 64x64 und 128x128 Pixel gute Resultate hervorbringt. Die besten zwei Resultate werden jedoch mit

128x128 Pixel grossen Bildern erreicht.

In dieser Testreihe sind unter den besten fünf neuronalen Netzen deren vier Netze mit fünf convolutional layer.

Die Filtergrössen sind immer noch in eher kleineren Filtern der Grösse drei oder vier Pixel zu finden.

Bei der Grösse des fully connected layer zeichnet sich wiederum ein nicht so klares Ergebnis ab. Unter den zehn

besten Resultaten ist eine relativ homogene Verteilung aller getesteten Grössen zu vermerken. Aufgrund dessen

kann hier keine eindeutige Grösse für die Architektur festgestellt werden.


In der Confusion Matrix der Abbildung 68 zeichnet sich

wieder ein klares Resultat ab. Auch hier werden die

Probleme der Klassifizierung sehr schön aufgezeigt. Die

meisten Fehlklassifizierungen sind bei den Steinpilzen

zu vermerken. Alleine bei diesen vier Arten sind 23

Fehlklassifizierungen zu verschreiben, was eine

Einbusse in der validation accuracy von knapp 18 %

ausmacht. Ansonsten sind nicht viele Fehler in den

Klassifizierungen festzustellen.

Abbildung 68 Confusion Matrix 3. Testreihe Röhrlinge – Die Confusion

Matrix zeigt, dass alleine bei den Steinpilzarten 23 Fehlklassifizierungen

auftreten, was eine Einbusse von knapp 18 % in der validation accuracy

bedeutet. Ansonsten sind nicht viele Fehlklassifizierungen zu vermerken.

5.12.4 Fazit

Durch diese Testreihe kann erneut eine gute Verbesserung in der validation accuracy erreicht werden. Mit 75 %

ist eine Steigerung von 25 % gegenüber der ersten Testreihe zu verzeichnen. Sieht man von den

Fehlklassifizierungen der Steinpilze ab, so wird eine validation accuracy von 93 % bei den Röhrlingen erreicht,

was ein sehr gutes Resultat darstellt.

An den Tests der dritten Testreihe ist jedoch auch anzumerken, dass diese Testreihe extrem viel Zeit in Anspruch

genommen hat, da auf allen Netzen mit 300 Epochen gar 3mal so lange trainiert wurde wie in den vorherigen

Testreihen.

5 Neuronales Netz 5.13 Fazit Testreihen Röhrlinge


5.13 Fazit Testreihen Röhrlinge

In Tabelle 11 werden die zehn besten Resultate aller Tests der Röhrlinge aufgelistet:

Testreihe Image size

[Pixel]

Lernrate Filter size Fully

connected

layer size

Validation

accuracy

Validation

loss

3 128x128 0.00001 [3, 3, 3, 3, 3 ] 128 75.0 % 0.879

3 128x128 0.00001 [4, 4, 3, 3, 3 ] 256 75.0 % 0.862

3 64x64 0.00001 [4, 4, 3, 3, 3 ] 256 73.4 % 0.908

3 128x128 0.00001 [4, 4, 3, 3, 3 ] 128 73.4 % 0.838

3 64x64 0.00001 [4, 4, 3, 3] 256 72.7 % 0.912

3 128x128 0.00001 [3, 3, 3, 3 ] 64 72.7 % 0.859

3 64x64 0.00001 [4, 4, 3, 3, 3 ] 64 72.7 % 0.835

3 64x64 0.00001 [3, 3, 3, 3 ] 64 71.9 % 0.860

3 64x64 0.00001 [3, 3, 3, 3, 3 ] 256 71.9 % 0.912

3 128x128 0.00001 [3, 3, 3, 3 ] 256 71.1 % 0.960

Tabelle 11 Übersicht der zehn besten neuronalen Netze aller Testreihen (Röhrlinge)

Auffällig ist, dass alle Resultate der Top Ten in der 3. Testreihe erreicht wurden. Dies lässt daraus folgen, dass die

Lernrate bei diesen Daten den grössten Einfluss auf das Resultat hatte.

Sehr spannend ist auch, dass viele gute Resultate mit einer Bildgrösse von 64x64 Pixel erreicht wurden. Anders

als bei den Lamellenpilzen scheinen sich diese Bilder auch mit kleineren Eingangsdaten klassifizieren zu lassen.

Trotzdem wurden die allerbesten Ergebnisse mit der Bildgrösse von 128x128 Pixel erreicht.

Wie es schon bei den Lamellenpilzen zu beobachten war, ist der Parameter fully ocnnected layer size nicht

eindeutig zu bestimmen. Auch bei den Röhrlingen muss dieser Parameter durch etliche Tests herausgefunden

werden.

Eine sehr schöne Darstellung lieferte die Confusion Matrix, durch welche die Probleme des neuronalen Netzes

sehr gut erkennbar gemacht wurden. Diese lagen vorwiegend bei den Steinpilzen. Da wir für das Training vier

verschiedene Steinpilzarten gewählt haben, wurde das Training der Röhrlinge extrem erschwert. Wenn man

diese Fehlklassifizierungen weglässt, so kann man wie in der 3. Testreihe bereits erwähnt, eine validation

accuracy von 93 % erreichen. Damit ist dieses Resultat als sehr gut einzuschätzen.

Ähnlich wie beim Fazit der Lamellenpilze wird auch hier das in der Tabelle an zweiter Stelle liegende Netz als das

beste eingestuft, da der validation loss ein wenig geringer ist.

Ein kurzer Vergleich mit der Testreihe der Lamellenpilze zeigt, dass trotz des gleichen Problems, Pilze zu

erkennen, ganz andere Architekturen für die Klassifizierung verwendet werden. Aufgrund dessen müssen bei

einer allfälligen Erweiterung der Daten wiederum Grid-Tests durchgeführt werden, damit die beste auf diese

Daten angepasste Architektur gefunden werden kann.

5 Neuronales Netz 5.13 Fazit Testreihen Röhrlinge


In der Abbildung 69 ist die von uns ausgewählte Architektur mit fünf convolutional layer dargestellt. Mit dieser

Architektur gibt es 179’994 verschiedene Parameter, die optimiert werden mussten, um eine möglichst gute

Klassifizierung zu erhalten. Die Anzahl an Parameter ist im Vergleich zu der ausgewählten Architektur bei den

Lamellenpilzen um einiges geringer, da dank dem zusätzlichen Layer die Bildgrösse erneut halbiert wird, und so

die Anzahl Parameter im fully connected layer viel geringer ist.

Abbildung 69 Architektur neuronales Netz Röhrlinge – Die Abbildung zeigt sehr schön die Architektur des neuronalen Netzes, welches aus

fünf convolutional layer und insgesamt zwei fully connected layer besteht.

6 Webapplikation


6 Webapplikation

Aus der Sicht der Benutzer ist die Benutzeroberfläche der wichtigste Teil der Magic Mushroom App. Es wurde

entschieden, dass die App als Webapplikation entwickelt wird, damit die Anwendung mit relativ geringem

Aufwand sowohl am Computer, als auch auf Mobilgeräten funktioniert. Die Webanwendung ist auf Deutsch als

auch auf Englisch verfügbar, damit möglichst viele potenzielle Benutzer die Magic Mushroom App verwenden

können. Der gesamte Quellcode der Webapplikation ist auf dem beigelegten USB-Stick im Verzeichnis

«Software/Web» zu finden. Die App ist unter magic.ntb.ch abrufbar.

Die Webapplikation lässt sich in zwei grundlegende Bereiche unterteilen. Zum einen können Pilze klassifiziert

werden, und zum anderen ist es auch möglich, Bilder von Pilzen auf einen Server der NTB hochzuladen, damit

die neuronalen Netze zu einem späteren Zeitpunkt mit mehr Pilzarten trainiert werden können.

Beim Zugriff auf die Webanwendung, welcher in der Abbildung 70 dargestellt ist, muss der Benutzer zuerst

bestätigen, dass er zur Kenntnis genommen hat, dass die Magic Mushroom App ein Forschungsprojekt ist und

keinen Pilzexperten ersetzen kann.

Abbildung 70 Startseite Webapplikation – Diese Abbildung zeigt die Startseite der Webapplikation, bei welcher der Benutzer

bestätigen muss, dass er alle Informationen gelesen und zur Kenntnis genommen hat.

6 Webapplikation 6.1 Pilz klassifizieren


6.1 Pilz klassifiz ieren

Der Benutzer hat die Möglichkeit, mit bis zu drei Bildern einen Pilz zu klassifizieren. Er ist dabei selber

verantwortlich, dass alle Bilder vom selben Pilz stammen. Auf den Mobilgeräten hat der Benutzer zusätzlich die

Möglichkeit, direkt ein Bild mit seiner Kamera aufzunehmen. Nachdem der Benutzer ein Bild ausgewählt hat,

kann er das Bild nachträglich zuschneiden, damit der Pilz zentriert ist.

Damit die Pilze klassifiziert werden

können, muss der Benutzer neben den

Bildern auch noch weitere Informati-

onen bereitstellen. Er muss die Ent-

scheidung treffen, ob es sich um einen

Röhrling oder um einen Lamellenpilz

handelt. Falls sich der Benutzer nicht

im Klaren ist, worin die Unterschiede

liegen, kann er sich über den «Info»

Button Beispiele ansehen, die Ihn bei

seiner Entscheidung unterstützen.

Anschliessend muss der Benutzer nur

noch den ungefähren Hutdurchmesser

und die Stiellänge des Pilzes angeben,

welche er bequem über die beiden

Slider einstellen kann.

In der Abbildung 71 ist ein Beispiel

abgebildet, bei dem der Benutzer alle

Schritte durchgeführt hat und bereit

ist, seinen Pilz klassifizieren zu lassen.

In diesem Fall handelt es sich um einen

Gelben-Knollenblätterpilz, der klassifi-

ziert werden soll.

Abbildung 71 Home Webapplikation – Die Abbildung zeigt ein Beispiel, bei der ein

Benutzer alle nötigen Schritte für die Klassifizierung eines Pilzes durchgeführt hat.

Sobald der Benutzer auf den Button «Pilz bestimmen!» drückt, wird ein Formular mittels PHP an den Server

gesendet. Dieses enthält alle Informationen, die der Benutzer vorhin angegeben hat. Auf dem Server der NTB

wird anschliessend ein Python Skript ausgeführt, das die gespeicherten Modelle der neuronalen Netze lädt und

die Bilder mit den zusätzlichen Informationen den neuronalen Netzen zur Verfügung stellt. Ein Aufruf des Python

Skripts anhand des Beispiels in Abbildung 71 sähe dann folgendermassen aus:

Python predict_web.py ”Session_ID” Lamellen 10 6 img1_”Session_ID”.jpg

6 Webapplikation 6.1 Pilz klassifizieren


Das neuronale Netz gibt nach der Klassifizierung die Wahrscheinlichkeiten für alle trainierten Pilzarten aus. Für

die Darstellung auf der Webapplikation wird anschliessend die höchste Wahrscheinlichkeit zusammen mit dem

Pilznamen und weiteren allgemeinen Informationen zurückgegeben. Diese Informationen werden aus dem JSON

File geholt, welches bereits für das Training der neuronalen Netze eingesetzt wurde und im Anhang im Kapitel

14.4 zu finden ist. In der Abbildung 72 ist das Resultat der Klassifizierung der letzten Seite (Abbildung 71) zu

sehen. Es wird ein Beispielbild des klassifizierten Pilzes angezeigt, damit der Benutzer der Applikation selbst auch

beurteilen kann, ob der von ihm klassifizierte Pilz in etwa gleich aussieht. Zudem werden Informationen über die

durchschnittliche Grösse und die Essbarkeit angezeigt. Über den Button «Zeige Details / Verstecke Details» kann

zusätzlich angezeigt werden, wie gross die Wahrscheinlichkeiten der anderen Pilzarten sind.

Mithilfe des «Zurück» Button gelangt der Benutzer wieder auf die ursprüngliche Seite, um weitere Pilze

klassifizieren zu lassen. In der Abbildung 72 ist das Resultat einer Klassifizierung inklusive der Detailansicht

ersichtlich.

Abbildung 72 Resultat Webapplikation – In dieser Abbildung ist das Resultat einer Klassifizierung inklusive der

Detailansicht dargestellt.

6 Webapplikation 6.2 Pilz Upload


6.2 Pilz Upload

Das Ziel dieser Funktion ist es, die Datenbank der Pilze fortlaufend zu erweitern und damit auch die

Pilzklassifizierung zu verbessern, weil es wie bereits erwähnt nicht einfach ist, an genügend Daten für das Training

eines neuronalen Netzes zu gelangen.

In der Abbildung 73 ist die Visualisierung der Upload-Seite dargestellt. Der Benutzer hat die Möglichkeit, bis zu

10 MB grosse Bilder hochzuladen und für das Training von weiteren neuronalen Netzen zur Verfügung zu stellen.

Insgesamt können maximal 200 MB an Daten pro Upload hochgeladen werden und die maximale Anzahl an

Bildern ist auf 100 Stück begrenzt. Falls der Benutzer mehr Dateien ausgewählt hat oder die Dateien zu gross

sind, wird er mithilfe eines Popup Fensters dazu aufgefordert, seine Auswahl anzupassen.

Um Bilder hochzuladen, wählt der Benutzer ein Bild aus seinem Verzeichnis aus, falls er vom Computer auf die

Applikation zugreift, oder er nimmt direkt ein Bild mithilfe der Kamera seines Mobilgerätes auf. Anschliessend

gibt er an, um was für eine Pilzart es sich handelt. Sobald der Benutzer das CAPTCHA korrekt ausgefüllt hat und

auf den «Upload» Button drückt, werden die Bilder auf dem Server der NTB abgelegt. In der Abbildung 73 werden

beispielsweise fünf Bilder eines Fliegenpilzes hochgeladen.

Abbildung 73 Upload Webapplikation – Die Abbildung zeigt ein Beispiel der Uploadfunktion, bei der ein Benutzer fünf Bilder eines

Fliegenpilzes hochladen will.

6 Webapplikation 6.3 About


6.2.1 Sicherheit

Die auf der letzten Seite gezeigte Funktion sieht auf den ersten Blick sehr einfach aus. Im Hintergrund müssen

allerdings einige Massnahmen getroffen werden, damit die Upload Funktion nicht missbraucht werden kann.

Folgende Funktionen wurden dafür implementiert:

- Die maximale Dateigrösse ist auf 10 MB festgelegt, was für normale Bilder völlig ausreichend ist.

- Die Gesamtgrösse aller Dateien darf maximal 200 MB betragen.

- Die maximale Anzahl Bilder pro Upload ist auf 100 Stück beschränkt.

- Bevor die Bilder hochgeladen werden können, muss der Benutzer ein CAPTCHA ausfüllen, damit ein

potenzieller Angreifer nicht ein Skript programmieren kann, welches den Server ununterbrochen mit

Bildern zumüllt.

- Die Bildgrösse wird überprüft. Falls keine Bildgrösse vorhanden ist, handelt es sich dementsprechend

nicht um ein Bild und wird nicht hochgeladen.

- Der MIME-Type (Multipurpose Internet Mail Extension) wird überprüft. Es werden nur Daten hoch-

geladen, die vom Typ «Image» sind.

- Jedem hochgeladenen Bild wird ein zufälliger Name zugewiesen, damit die Dateien nicht mehr anhand

des Dateinamens identifiziert werden können, sobald sie hochgeladen wurden. [64]

6.3 About

Die letzte Seite der Webapplikation, welche in der Abbildung 74 zu sehen ist, ist die About Seite. Hier wird in

einigen wenigen Sätzen der Sinn und Zweck der Magic Mushroom App erläutert und alle Pilzarten aufgelistet,

mit denen das neuronale Netz aktuell trainiert wurde. Zudem werden die Benutzer erneut darauf aufmerksam

gemacht, dass die Magic Mushroom App ein Forschungsprojekt ist und keinen Pilzexperten ersetzen kann.

Abbildung 74 About Webapplikation – Die Abbildung der About Seite zeigt dem Benutzer alle Pilzarten, die momentan

mithilfe des neuronalen Netzes klassifiziert werden können.

7 Schlussfolgerung


7 Schlussfolgerung

Diese Arbeit hat grundsätzlich gezeigt, dass die Pilzerkennung mittels neuronalen Netzen möglich ist. Mit einer

validation accuracy von 75 % mit den Bildern der Röhrlinge und 85.2 % mit den Lamellenpilzen kann man das

Ergebnis als gut einstufen. Bei der Bearbeitung der Arbeit sind uns folgende Stichworte aufgefallen:

Vorverarbeitung und Zentrierung der Bilder, Wahl der Architektur, Trennung der Daten und zusätzliche Features.

Auf diese Punkte möchten wir in der Schlussfolgerung kurz eingehen.

Die Daten, in unserem Fall die Pilzbilder, gehören zu einem der wichtigsten Punkte bei der Arbeit mit neuronalen

Netzen. Dadurch, dass wir die Bilder ausschliesslich von Google herunterladen konnten, waren wir in diesem Fall

eingeschränkt. Durch eine saubere Vorverarbeitung der Bilder konnte dann der Datensatz generiert werden.

Dabei ist anzumerken, dass die Vorverarbeitung auch ein wesentlicher Punkt für einen guten Datensatz darstellt.

Durch eine korrekte Zentrierung kann die Qualität des Datensatzes enorm gesteigert werden. In diesem Punkt

gibt es sicherlich noch Verbesserungspotenzial auf unserem Datensatz. Als Fazit dieser Punkte muss nochmals

klargemacht werden, dass der Datensatz, und somit die Pilzbilder, der Grundstein für eine gute Klassifizierung

darstellen und somit als der wichtigste Punkt angesehen werden muss.

Die Architektur bildet einen weiteren wichtigen Punkt des neuronalen Netzes. Von einer Grundarchitektur

ausgehend, kann diese mit einem Grid-Test sehr gut ausgebaut und getestet werden. Einziger Nachteil dieser

Tests ist, dass sehr viele neuronale Netze getestet werden, was sehr zeitintensiv ist. Mit einer neueren

Hochleistungsgrafikkarte, wie die NVIDIA GeForce GTX 1080 Ti, welche wir zur Verfügung hatten, sind solche

Tests jedoch in einer geraumen Zeit machbar.

Durch die Visualisierung der Ergebnisse mit der Confusion Matrix konnte die Struktur der Daten genauer

analysiert werden. Dabei ist die Ähnlichkeit der Pilze innerhalb der gleichen Familie aufgefallen. Durch die

Trennung in zwei verschiedene neuronale Netze konnte eine Verbesserung in der validation accuracy von knapp

15 % erreicht werden. Daraus lässt sich schliessen, dass ähnliche Daten wenn möglich aufgeteilt werden sollten,

sodass die Klassifizierung im neuronalen Netz vereinfacht wird.

Der letzte Punkt, welcher noch angesprochen werden möchte, ist jener der zusätzlichen Features. Durch die

Einbindung des Hutdurchmessers, sowie der Stiellänge vor dem fully connected layer wurde eine Steigerung von

rund 10 % in der validation accuracy erreicht. Eine solche Steigerung zeigt, dass diese Features einen grossen

Einfluss auf das Resultat des neuronalen Netzes nehmen. Einziger Nachteil dieser Features, sowie der Trennung

in zwei verschiedene Netze ist, dass sie eine Entscheidung der Benutzer erzwingt. Dadurch können

Fehlinformationen bei der Vorhersage eingebracht werden, was zu einer Fehlklassifizierung führen kann. Da es

sich jedoch um einfach zu erkennende Merkmale handelt, ist diese Fehlerquelle als gering einzustufen.

8 Ausblick


8 Ausblick

Der Grundstein für die Magic Mushroom App ist gesetzt. Nun wird grosse Hoffnung auf die Community gelegt.

Mit der Hilfe dieser kann die App wachsen und stetig erweitert werden. Sobald genügend Bilder einer weiteren

Pilzart vorhanden sind, kann erneut ein neuronales Netz trainiert werden, das anschliessend der Community zur

Verfügung gestellt wird. Damit profitiert nicht nur die NTB, sondern auch die Community. Je schneller die

Pilzdatenbank gefüllt wird, desto schneller kann auch das neuronale Netz entwickelt werden.

Jedoch ist das neuronale Netz auch noch nicht perfekt. Dieses könnte mit mehreren zusätzlichen Features

erweitert werden. Ein einfach zu erkennendes Feature wäre beispielsweise der Ring, welcher zum Beispiel bei

einem Fliegenpilz vorhanden ist. Dadurch könnten die Pilze noch genauer abstrahiert werden und die

Klassifizierung würde wahrscheinlich etwas genauer werden. Auch dieser Grundstein ist im Programm gelegt,

sodass solche Features mit nur kleinen Anpassungen hinzugefügt werden können.

Ein Schritt, welcher auch in Zukunft sehr zeitintensiv sein wird, ist die Auswahl der geeigneten Architektur des

neuronalen Netzes. Diese muss wiederum durch Grid-Tests bestimmt werden. Mit dem Python Skript im Anhang

des Kapitels 14.3.2 können diese Tests jedoch relativ schnell gestartet werden. Die Auswertung kann dann ganz

einfach mit den automatisch erstellten Textdokumenten geschehen.

Der genaue Ablauf zur Erweiterung des neuronalen Netzes mit allen Anpassungen samt Webanwendung kann

dem Dokument «Anleitung_ErweiterungApplikation.docx», welches auch im Anhang im Kapitel 14.2 zu finden

ist, entnommen werden. Des Weiteren befindet sich im Kapitel 14.1 eine Anleitung zur Inbetriebnahme der

vorhandenen Workstations der NTB. Auch diese könnten in näherer Zukunft mit der Grafikkarte NVIDIA GeForce

GTX 1080 Ti ausgestattet werden, damit auf diesen Rechnern neuronale Netze trainiert werden könnten.

Mit diesen Werkzeugen und Programmen sollte man nun fähig sein, die Magic Mushroom App zu erweitern. Mit

stetigen Aktualisierungen und Erweiterungen könnte die App zu einem gänzlichen Erfolg werden. So sind wir

überzeugt, dass diese App bei Pilzsuchenden zukünftig zum Equipment dazugehören wird und nicht nur

schweizweit einen Erfolg feiern kann, sondern auch weltweit zum Einsatz kommen wird.

9 Danksagung


9 Danksagung

Einen besonderen Dank geht an die Referenten Prof. Dr. Christoph Würsch und Prof. Dr. Klaus Frick. Durch Sie

wurde die Bachelorarbeit Magic Mushroom App erst ins Leben gerufen und tatkräftig unterstützt. Bei Fragen

jeglicher Art konnten wir uns stets auf Ihr Wissen abstützen und waren immer willkommen.

Bedanken möchten wir uns ebenfalls beim gesamten Team der Informatik-Dienste der NTB, welche uns tatkräftig

beim Einrichten des Servers unterstützten.

Ein weiterer Dank geht an die Partnerhochschule der NTB, die Hochschule für Technik Rapperswil (HSR), welche

unsere Arbeit durch die Bereitstellung des Clusters unterstützten. Dadurch war es uns möglich, viele Tests mit

neuronalen Netzen durchzuführen und die nötigen Schlüsse daraus zu ziehen.

10 Eigenständigkeitserklärung


10 Eigenständigkeitserklärung

Hiermit versichern wir, dass wir die vorliegende Arbeit selbstständig verfasst und keine anderen als die

angegebenen Quellen und Hilfsmittel benutzt haben, dass alle Stellen der Arbeit, die wörtlich oder sinngemäß

aus anderen Quellen übernommen wurden, als solche kenntlich gemacht und dass die Arbeit in gleicher oder

ähnlicher Form noch keiner Prüfungsbehörde vorgelegt wurde.

St.Gallen, den 06.08.2018.

Riccardo Jung Dominik Wagner

11 Abbildungsverzeichnis



Abbildung 1 Logo Anaconda [3] .............................................................................................................................. 2

Abbildung 2 Logo PyCharm [5] ................................................................................................................................ 2

Abbildung 3 Logo OpenCV [6] ................................................................................................................................. 2

Abbildung 4 Logo Tensorflow [9] ............................................................................................................................ 3

Abbildung 5 TensorBoard – Dargestellt ist ein Beispiel für die Visualisierung der validation accuracy und des

validation loss von zwei neuronalen Netzen in TensorBoard. ................................................................................ 3

Abbildung 6 NVIDIA GeForce GTX 645 [12] ............................................................................................................. 4

Abbildung 7 NVIDIA GeForce GTX 1080 Ti [14] ....................................................................................................... 4

Abbildung 8 NVIDIA Tesla V100 [16] ....................................................................................................................... 4

Abbildung 9 Pilz lokalisieren – Das blaue Rechteck um den Pilz herum zeigt, wo der Pilz lokalisiert wurde.[19] .. 6

Abbildung 10 Pilz zentrieren – Die blaue Linie zeigt, wo das Zentrum des Pilzes durch das Aufsummieren aller

Grauwerte in der unteren Hälfte des Bildes bestimmt wurde. [20] ....................................................................... 6

Abbildung 11 Bilder vervielfachen – Dargestellt sind alle Varianten der Vervielfachung der Pilzbilder. [21] ........ 6

Abbildung 12 Kreuzkorrelation komplett – Der weisse Rahmen innerhalb des Bildes zeigt, wo die Korrelation

zum Referenzbild am höchsten war. Die Grafik rechts zeigt die Korrelation entlang der X-Achse. [22] ................ 7

Abbildung 13 Kreuzkorrelation komplett – Der weisse Rahmen innerhalb des Bildes zeigt, wo die Korrelation

zum Referenzbild am höchsten war. Die Grafik rechts zeigt die Korrelation entlang der X-Achse. [23] ................ 7

Abbildung 14 Kreuzkorrelation zeilenweise – Das Diagramm zeigt die Korrelation des Referenzbildes (rechts)

mit dem kompletten Bild (links) jeder einzelnen Zeile. [24] ................................................................................... 8

Abbildung 15 Kreuzkorrelation zeilenweise – Das Diagramm zeigt die Korrelation des Referenzbildes (rechts)

mit dem kompletten Bild (links) jeder einzelnen Zeile. [22] ................................................................................... 8

Abbildung 16 Sommer-Steinpilz [25, 26] ................................................................................................................ 9

Abbildung 17 Kiefern-Steinpilz [27, 28]................................................................................................................... 9

Abbildung 18 Gemeiner-Steinpilz [29, 30] .............................................................................................................. 9

Abbildung 19 Schwarzhütiger-Steinpilz [31, 32] ................................................................................................... 10

Abbildung 20 Fliegenpilz [33, 34] .......................................................................................................................... 10

Abbildung 21 Butterpilz [35, 36] ........................................................................................................................... 10

Abbildung 22 Gold-Röhrling [37, 38] ..................................................................................................................... 10

Abbildung 23 Sand-Röhrling [39, 40] .................................................................................................................... 10

Abbildung 24 Ziegenlippe [41, 42] ........................................................................................................................ 10

Abbildung 25 Gelber-Knollenblätterpilz [43, 44] .................................................................................................. 11

Abbildung 26 Grauer-Wulstling [45, 46] ............................................................................................................... 11

Abbildung 27 Grüner-Knollenblätterpilz [47, 48] .................................................................................................. 11

Abbildung 28 Pantherpilz [49, 50] ......................................................................................................................... 11

Abbildung 29 Perpilz [51, 52] ................................................................................................................................ 11

Abbildung 30 Pfifferling [53, 54] ........................................................................................................................... 11

Abbildung 31 Generelle Struktur eines CNNs – Die Abbildung zeigt die grundsätzliche Struktur eines CNN mit

dem input layer, den feature-extraction layers und den classification layers. [56, S. 128] .................................. 13



Abbildung 32 Convolutional layer mit rechteckigen rezeptiven Feldern – Die Abbildung zeigt, wie die Neuronen

zwischen den einzelnen layers verbunden sind. [55, S. 358] ................................................................................ 13

Abbildung 33 Beispiel Faltungsoperation - In der Abbildung wird gezeigt, wie der Kernel, oder auch Filter

genannt, über die Eingangsdaten geschoben wird und daraus die feature map berechnet wird. [56, S. 131] .... 14

Abbildung 34 Convolutional layer mit verschiedenen feature maps – Die Abbildung zeigt zwei convolutional

layer mit mehreren feature maps und ein Bild mit drei Kanälen (RGB). [55, S. 361] ........................................... 14

Abbildung 35 Erklärung Parameter padding – Die Abbildung visualisiert den Parameter padding, der festlegt,

wie die Ränder eines Bildes bearbeitet werden. Der Parameter fw definiert die Filterweite und der Parameter fh

die Filterhöhe. Der hier verwendete Filter hat dementsprechend die Grösse 3x3 Pixel. Die Ränder des Bildes

werden mit Nullen aufgefüllt (zero padding). [55, S. 358] .................................................................................... 15

Abbildung 36 Erklärung Parameter stride – Dieser Parameter dient zur Dimensionsreduktion. Zu sehen ist ein

Bild mit der Schrittweite 2, welche zur Folge hat, dass das Ausgangsbild (oberes Rechteck) um den Faktor 2

kleiner ist. Die Randstellen sind wiederum mit Nullen gefüllt, damit das Ausgangsbild alle Pixel des

Eingangsbildes berücksichtigen kann. [55, S. 359] ................................................................................................ 15

Abbildung 37 Max pooling layer (2x2 pooling kernel, stride 2) – Die Abbildung zeigt, wie die Bildgrösse dank des

pooling layers verringert werden kann. Links im Bild ersichtlich ist die Auswahl der Aggregierungsfunktion,

welche hier den Wert 5 übernimmt, da eine Maximalfunktion gewählt wurde. Weil padding valid für die

Randbehandlung gewählt wurde, wird dieser abgeschnitten. ............................................................................. 16

Abbildung 38 Architektur Neuronales Netzwerk – In dieser Abbildung ist ein neuronales Netz mit drei

convolutional layer, einem flattened layer und einem fully connected layer dargestellt, welches als Basis für die

ersten Tests diente. [59] ....................................................................................................................................... 18

Abbildung 39 Confusion Matrix - Die Confusion Matrix, welche teilweise auch als Error Matrix bezeichnet wird,

repräsentiert die Performance eines Algorithmus................................................................................................ 18

Abbildung 40 Graph accuracy mit 15 Pilzarten – In dieser Abbildung ist die accuracy, welche nach dem Trennen

der Datensätze mit 15 Pilzarten erreicht wurde, dargestellt. Eine validation accuracy von 50 % wird schon nach

wenigen Epochen erreicht, danach stagniert das Wachstum. .............................................................................. 20

Abbildung 41 Graph loss mit 15 Pilzarten Pilzarten – In dieser Abbildung ist der loss, welcher nach dem Trennen

der Datensätze mit 15 Pilzarten erreicht wurde, dargestellt. Der validation loss steigt bereits früh nach dem

Start des Trainings wieder an, was ein klares Zeichen für ein Übertraining ist. ................................................... 20

Abbildung 42 Confusion Matrix 15 Pilzarten – Anhand der Confusion Matrix sieht man, dass es bei jeder Pilzart

zu Fehlklassifizierungen kam. Auffällig sind zwei Sektoren, bei welchen die Fehlklassifizierungen auf die gleiche

Familienzugehörigkeit zurückzuführen sind. ........................................................................................................ 21

Abbildung 43 Neuronales Netz mit zusätzlichen Features – Die Abbildung zeigt, wie die zusätzlichen

Informationen dem neuronalen Netz zur Verfügung gestellt werden. ................................................................. 22

Abbildung 44 Graph accuracy mit zusätzlichen Features – In der Abbildung ist sehr gut zu erkennen, dass der

Verlauf der jeweiligen Graphen beinahe identisch ist. Der wesentliche Unterschied liegt darin, dass die accuracy

um ca. 10 % höher ist, wenn das neuronale Netz mit den zusätzlichen Features trainiert wurde. ...................... 22

Abbildung 45 Graph loss mit zusätzlichen Features – Die Abbildung zeigt den positiven Effekt der zusätzlichen

Features. Dank diesen zusätzlichen Informationen konnte der loss gesenkt werden. ......................................... 23

Abbildung 46 Beispiel Lamellenpilz [62] ............................................................................................................... 23

Abbildung 47 Beispiel Röhrling [63] ...................................................................................................................... 23

Abbildung 48 Graph accuracy Lamellenpilze Testreihe 1 – In der Abbildung ist das neuronale Netze dargestellt,

welches die höchste validation accuracy mit rund 80 % erreicht hat. ................................................................. 27



Abbildung 49 Graph loss Lamellenpilze Testreihe 1 – Die Abbildung zeigt, dass das Problem des Übertrainings

immer noch besteht, da der loss ab der 20. Epoche stetig ansteigt. .................................................................... 27

Abbildung 50 Confusion Matrix 1. Testreihe Lamellenpilze – Die Confusion Matrix zeigt deutlich, dass die

Fliegenpilze und Pfifferlinge kaum falsch klassifiziert werden. Insgesamt werden 103 von 128 Pilzen richtig

klassifiziert, was zu einer Trefferquote von rund 80 % führt. ............................................................................... 28

Abbildung 51 Graph accuracy Lamellenpilze Testreihe 2 – Gut ersichtlich ist, dass das neuronale Netz extrem

schnell lernt. Bereits nach wenigen Epochen wird eine validation accuracy von über 50 % erreicht. Nach 12

Epochen werden sogar schon über 75 % erreicht. ............................................................................................... 30

Abbildung 52 Graph loss Lamellenpilze Testreihe 2 – Auch in dieser Abbildung wird ersichtlich, dass das

neuronale Netz ab Epoche 30 mit dem Übertraining zu kämpfen hat. ................................................................ 30

Abbildung 53 Confusion Matrix 2. Testreihe Lamellenpilze – Die Confusion Matrix zeigt, dass das neuronale

Netz Schwierigkeiten hat, die beiden Knollenblätterpilze zu unterscheiden. ...................................................... 31

Abbildung 54 Graph accuracy Vergleich Lernraten – Anhand dieser Abbildung ist sehr gut zu erkennen, dass das

neuronale Netz mit der höheren Lernrate sehr viel schneller bei den gegebenen Trainingsdaten lernt. ............ 32

Abbildung 55 Graph loss Vergleich Lernraten – Die Abbildung zeigt, dass der loss bedeutend grösser wird, wenn

die Lernrate grösser gewählt wird. ....................................................................................................................... 32

Abbildung 56 Graph accuracy Lamellenpilze Testreihe 3 – Ca. bis zur 150. Epoche kann die validaiton accuracy

mit der training accuracy mithalten, danach steigt nur noch die training accuracy an. ...................................... 34

Abbildung 57 Graph loss Lamellenpilze Testreihe 3 – Sehr gut ersichtlich wird in dieser Abbildung , dass sich der

validation loss erst nach 150 Epochen erhöht und damit der Effekt des Übertrainings wesentlich verringert

werden konnte. ..................................................................................................................................................... 34

Abbildung 58 Confusion Matrix 3. Testreihe Lamellenpilze – In dieser Abbildung ist ausser bei den Fliegenpilzen

und den Pfifferlingen eine relativ homogene Verteilung an Fehlklassifizierungen zu beobachten. ..................... 35

Abbildung 59 Architektur neuronales Netz Lamellenpilze – Die Abbildung zeigt sehr schön die Architektur des

besten neuronalen Netzes, welches aus vier convolutional layer und insgesamt zwei fully connected layer

besteht. ................................................................................................................................................................. 37

Abbildung 60 Graph accuracy Röhrlinge Testreihe 1 – Die Abbildung zeigt ein ähnliches Verhalten wie bei den

Lamellenpilzen. Bereits nach 40 Epochen wird die maximale validation accuracy erreicht................................. 39

Abbildung 61 Graph loss Röhrlinge Testreihe 1 – Auch bei diesem neuronalen Netz steigt der validation loss

während des Trainings wieder an, was auf ein Übertraining hindeutet. .............................................................. 39

Abbildung 62 Confusion Matrix 1. Testreihe Röhrlinge – Die Confusion Matrix zeigt deutlich, dass die

Klassifizierung der vier Steinpilzarten Schwierigkeiten bereitet. .......................................................................... 40

Abbildung 63 Graph accuracy Röhrlinge Testreihe 2 – Diese Abbildung zeigt die accuracy eines schlechten

Resultats. ............................................................................................................................................................... 42

Abbildung 64 Graph loss Röhrlinge Testreihe 2 – Diese Abbildung zeigt den grossen Unterschied zu den guten

Ergebnissen. Der validation loss steigt bei diesem neuronalen Netz viel stärker an, als bei besseren neuronalen

Netzen. .................................................................................................................................................................. 42

Abbildung 65 Confusion Matrix 2. Testreihe Röhrlinge – Die Probleme bei der Klassifizierung der Steinpilzarten

sind auch bei dieser Confusion Matrix eindeutig zu erkennen. ............................................................................ 43

Abbildung 66 Graph accuracy Röhrlinge Testreihe 3 – In dieser Abbildung fallen die starken Sprünge zwischen

den einzelnen Epochen auf, die auf die kleinere Batchgrösse zurückzuführen sind. ........................................... 45

Abbildung 67 Graph loss Röhrlinge Testreihe 3 – Der in dieser Abbildung dargestellte validation loss steigt erst

gegen Ende des Trainings ein wenig an, was darauf hindeutet, dass das neuronale Netz kaum übertrainiert. .. 45



Abbildung 68 Confusion Matrix 3. Testreihe Röhrlinge – Die Confusion Matrix zeigt, dass alleine bei den

Steinpilzarten 23 Fehlklassifizierungen auftreten, was eine Einbusse von knapp 18 % in der validation accuracy

bedeutet. Ansonsten sind nicht viele Fehlklassifizierungen zu vermerken. ......................................................... 46

Abbildung 69 Architektur neuronales Netz Röhrlinge – Die Abbildung zeigt sehr schön die Architektur des

neuronalen Netzes, welches aus fünf convolutional layer und insgesamt zwei fully connected layer besteht. ... 48

Abbildung 70 Startseite Webapplikation – Diese Abbildung zeigt die Startseite der Webapplikation, bei welcher

der Benutzer bestätigen muss, dass er alle Informationen gelesen und zur Kenntnis genommen hat. .............. 49

Abbildung 71 Home Webapplikation – Die Abbildung zeigt ein Beispiel, bei der ein Benutzer alle nötigen

Schritte für die Klassifizierung eines Pilzes durchgeführt hat. .............................................................................. 50

Abbildung 72 Resultat Webapplikation – In dieser Abbildung ist das Resultat einer Klassifizierung inklusive der

Detailansicht dargestellt. ...................................................................................................................................... 51

Abbildung 73 Upload Webapplikation – Die Abbildung zeigt ein Beispiel der Uploadfunktion, bei der ein

Benutzer fünf Bilder eines Fliegenpilzes hochladen will. ...................................................................................... 52

Abbildung 74 About Webapplikation – Die Abbildung der About Seite zeigt dem Benutzer alle Pilzarten, die

momentan mithilfe des neuronalen Netzes klassifiziert werden können. .......................................................... 53

12 Tabellenverzeichnis


12 Tabellenverzeichnis

Tabelle 1 Vergleich Grafikkarten [15, 17, 18] .......................................................................................................... 5

Tabelle 2 Benchmark-Test ....................................................................................................................................... 5

Tabelle 3 Übersicht vorverarbeitete Bilder ........................................................................................................... 11

Tabelle 4 Ergebnis der fünf besten neuronalen Netze der 1. Testreihe (Lamellenpilze) ...................................... 26



Tabelle 7 Übersicht der zehn besten neuronalen Netze aller Testreihen (Lamellenpilze) ................................... 36

Tabelle 8 Ergebnis der fünf besten neuronalen Netze der 1. Testreihe (Röhrlinge) ............................................. 38

Tabelle 9 Ergebnis der fünf besten neuronalen Netze der 2. Testreihe (Röhrlinge) ............................................. 41

Tabelle 10 Ergebnis der fünf besten neuronalen Netze der 3. Testreihe (Röhrlinge) ........................................... 44

Tabelle 11 Übersicht der zehn besten neuronalen Netze aller Testreihen (Röhrlinge) ........................................ 47

13 Literaturangaben


13 Literaturangaben

[1] Würsch Christoph: Ausschreibung Bachelorarbeit, 2018.

https://intranet.ntb.ch/studium/bachelor/bachelorarbeiten/bachelorarbeiten-2018/liste-nach-

student/?DA=1032&r=p, abgerufen am: 09.01.2018

[2] Anaconda Inc.: Conda — Conda documentation, 2018. https://conda.io/docs/, abgerufen am: 10.01.2018

[3] Logo Anaconda, 2015. http://www.gurobi.com/images/logo-anaconda.png, abgerufen am: 10.01.2018

[4] JetBrains s.r.o.: PyCharm. https://www.jetbrains.com/pycharm/features/, abgerufen am: 21.06.2018

[5] JetBrains s.r.o.: Logo PyCharm, 2015.

https://d3nmt5vlzunoa1.cloudfront.net/pycharm/files/2015/12/PyCharm_400x400_Twitter_logo_white.

png, abgerufen am: 21.06.2018

[6] OpenCV team: Logo OpenCV, 2018. https://opencv.org/, abgerufen am: 26.04.2018

[7] OpenCV team: OpenCV library, 2018. https://opencv.org/about.html, abgerufen am: 10.01.2018

[8] TensorFlow: TensorFlow, 2018. https://www.tensorflow.org/, abgerufen am: 26.04.2018

[9] LeanBI: Logo TensorFlow. http://leanbi.ch/blog/tensorflow/, abgerufen am: 26.04.2018

[10] TensorFlow: TensorBoard: Visualizing Learning , 2018.

https://www.tensorflow.org/programmers_guide/summaries_and_tensorboard, abgerufen am:

26.04.2018

[11] Techpowerup: NVIDIA GeForce GTX 645 OEM. https://www.techpowerup.com/gpudb/2359/geforce-gtx-

645-oem, abgerufen am: 18.07.2018

[12] NVIDIA: NVIDIA GTX 645, 2013. http://www.nvidia.de/content/product-detail-pages/geforce-gtx-645-

oem/geforce-gtx-660-645-front.png, abgerufen am: 26.04.2018

[13] NVIDIA: NVIDIA GeForce GTX 1080Ti Graphics Card, 2018.

https://www.nvidia.co.uk/geforce/products/10series/geforce-gtx-1080-ti/, abgerufen am: 18.07.2018

[14] Digitec Galaxus AG: NVIDIA GTX 1080 Ti, 2017.

https://static.digitecgalaxus.ch/Files/7/4/9/6/1/5/5/4502.jpg?fit=inside%7C802:639&output-

format=progressive-jpeg, abgerufen am: 26.04.2018

[15] NVIDIA Corporation: NVIDIA Tesla V100. https://www.nvidia.de/data-center/tesla-v100/, abgerufen am:

21.06.2018

[16] NVIDIA: NVIDIA Tesla V100, 2018. https://www.nvidia.de/content/dam/en-zz/Solutions/Data-

Center/tesla-v100/[email protected], abgerufen am: 21.06.2018

[17] NVIDIA Corporation: GeForce GTX 645. https://www.geforce.com/hardware/desktop-gpus/geforce-gtx-

645-oem/specifications, abgerufen am: 26.04.2018

[18] Digitec Galaxus AG: ASUS GeForce GTX 1080 Ti STRIX O11G-GAMING.

https://www.digitec.ch/de/s1/product/asus-geforce-gtx-1080-ti-strix-o11g-gaming-11gb-high-end-

grafikkarte-6188992, abgerufen am: 26.04.2018

[19] Pilze Birsfelden: Sommer-Steinpilz 1, 2012. http://www.pilze-

birsfelden.ch/typo3temp/pics/ef3089b2d8.jpg, abgerufen am: 10.01.2018

[20] Alamy Ltd: Sommer-Steinpilz 2. http://c8.alamy.com/compde/dak5ab/sommer-bolete-sommer-cep-

boletus-reticulatus-boletus-aestivalis-zwei-fruchtkorper-deutschland-mecklenburg-vorpommern-

dak5ab.jpg, abgerufen am: 10.01.2018

[21] Salvatore Saitta: Sommer-Steinpilz 3, 2016.

http://www.salvatoresaitta.it/pages/fungi/boletus_aestivalis.htm, abgerufen am: 26.04.2018

13 Literaturangaben


[22] Marjan Kustera: Sommer-Steinpilz 4.

https://www.flickr.com/photos/59698578@N06/9741966226/in/photostream/, abgerufen am:

26.04.2018

[23] t4.ftcdn.net: Sommer-Steinpilz 5, 2016.

https://t4.ftcdn.net/jpg/00/69/04/53/240_F_69045303_K8wNAVui0Ql8ghejwrweX1YJodD1xg38.jpg,

abgerufen am: 26.04.2018

[24] Northamptonshirewildlife: Sommer-Steinpilz 6, 2007.

http://www.northamptonshirewildlife.co.uk/Images/boletus_edulis.jpg, abgerufen am: 17.07.2018

[25] Wikipedia: Archenzo: Sommer-Steinpilz 7, 2013.

https://upload.wikimedia.org/wikipedia/commons/8/83/2006-10-

07_Boletus_aestivalis_cropped.jpg?uselang=de, abgerufen am: 18.07.2018

[26] Wikipedia: Xth-Floor: Sommer-Steinpilz 8, 2013.

https://upload.wikimedia.org/wikipedia/commons/e/e4/Vrbensk%C3%A9_rybn%C3%ADky_-

_Boletus_aestivalis_02.jpg, abgerufen am: 18.07.2018

[27] Flickr: Charles de Mille-Isles: Kiefern-Steinpilz 1.

https://www.flickr.com/photos/demartigny/6139036791/, abgerufen am: 18.07.2018

[28] Wikipedia: Paffka: Kiefern-Steinpilz 2, 2013.

https://upload.wikimedia.org/wikipedia/commons/6/66/Boletus_pinophilus3.JPG, abgerufen am:

18.07.2018

[29] Pxhere: Gemeiner-Steinpilz 1, 2017.

https://c.pxhere.com/photos/af/36/grzyb_ceps_porcini_boletus_edulis-1079733.jpg!d, abgerufen am:

18.07.2018

[30] Wikipedia: Jörg Hempel: Gemeiner-Steinpilz 2, 2018.

https://commons.wikimedia.org/wiki/File:Boletus_edulis_LC0371.jpg, abgerufen am: 18.07.2018

[31] Flickr: GLJIVARSKO DRUSTVO NIS: Schwarzhütiger-Steinpilz 1. https://www.flickr.com/photos/fungi-

nis/9109097740, abgerufen am: 18.07.2018

[32] Wikipedia: Roberto Petruzzo: Schwarzhütiger-Steinpilz 2, 2018.

https://commons.wikimedia.org/wiki/File:Boletus_aereus_IT.JPG, abgerufen am: 18.07.2018

[33] Pixabay: snd63: Fliegenpilz 1. https://pixabay.com/en/amanita-amanita-muscaria-mushroom-2902116/,


[34] Flickr: Bernard Spragg: Fliegenpilz 2. https://www.flickr.com/photos/volvob12b/32830552834, abgerufen

am: 18.07.2018

[35] Wikipedia: Pumber: Butterpilz 1, 2018.

https://commons.wikimedia.org/wiki/File:Barnagy%C5%B1r%C5%B1s.jpg, abgerufen am: 18.07.2018

[36] Wikipedia: Σ64: Butterpilz 2, 2018. https://commons.wikimedia.org/wiki/File:Suillus_luteus_01.jpg,


[37] Wikipedia: Szabi237: Gold-Röhrling 1. https://fr.wikipedia.org/wiki/Fichier:Suillus_grevillei2.JPG,


[38] Pixabay: adege: Gold-Röhrling 2. https://pixabay.com/en/mushroom-suillus-grevillei-yellow-2759709/,


[39] Wikipedia: Andrey Gaverdovsky: Sand-Röhrling 1, 2018.

https://commons.wikimedia.org/wiki/File:Suillus_variegatus_(21685100733).jpg, abgerufen am:

18.07.2018

13 Literaturangaben


[40] Wikipedia: Tocekas: Sand-Röhrling 2. https://lt.wikipedia.org/wiki/Vaizdas:Suillus_variegatus_1.jpg,


[41] Wikipedia : Daniel Ullrich: Ziegenlippe 1. https://de.wikipedia.org/wiki/Datei:Boletus_subtomentosus.jpg,


[42] Wikipedia: Dendrofil: Ziegenlippe 2, 2018.

https://commons.wikimedia.org/wiki/File:Xerocomus_subtomentosus_Podkomorsk%C3%A9_lesy.jpg,


[43] Wikipedia: Jim Champion: Gelber-Knollenblätterpilz 1, 2018.

https://commons.wikimedia.org/wiki/File:Amanita_citrina_fungus_in_Bignell_Wood,_New_Forest_-

_geograph.org.uk_-_260930.jpg, abgerufen am: 18.07.2018

[44] Wikipedia: Jean-Marc Pascolo: Gelber-Knollenblätterpilz 2, 2018.

https://commons.wikimedia.org/wiki/File:Amanita_citrina_%C3%A0_Carling.jpg, abgerufen am:

18.07.2018

[45] Wikipedia: Björn S.: Grauer-Wulstling 1, 2018.

https://commons.wikimedia.org/wiki/File:Botanical_Garden_Gothenburg_and_Angg%C3%A5rdsbergen_

13.08.2017_Grey_Spotted_Amanita_-_Amanita_excelsa_(37330338051).jpg, abgerufen am: 18.07.2018

[46] Wikipedia: Björn S.: Grauer-Wulstling 2, 2018.

https://commons.wikimedia.org/wiki/File:Eichhof_06.08.2017_Grey_Spotted_Amanita_-

_Amanita_excelsa_(37339552175).jpg, abgerufen am: 18.07.2018

[47] Wikipedia: George Chernilevsky: Grüner-Knollenblätterpilz 1, 2018.

https://commons.wikimedia.org/wiki/File:Amanita_phalloides_2011_G2.jpg, abgerufen am: 18.07.2018

[48] Flickr: GLJIVARSKO DRUSTVO NIS: Grüner-Knollenblätterpilz 2. https://www.flickr.com/photos/fungi-

nis/5830935134, abgerufen am: 18.07.2018

[49] Wikipedia: ccfarmer: Pantherpilz 1. https://de.wikipedia.org/wiki/Datei:2008-

10_Amanita_pantherina_cropped.jpg, abgerufen am: 18.07.2018

[50] Wikipedia: Quartl: Pantherpilz 2, 2018.

https://commons.wikimedia.org/wiki/File:Amanita_pantherina_qtl2.jpg, abgerufen am: 18.07.2018

[51] Wikipedia: Archenzo: Perlpilz 1, 2018. https://commons.wikimedia.org/wiki/File:Amanita_rubescens.JPG,


[52] Wikipedia: Andreas Kunze: Perlpilz 2. https://de.wikipedia.org/wiki/Datei:2011-07-

30_Amanita_rubescens_1.jpg, abgerufen am: 18.07.2018

[53] Wikipedia: Henk Monster: Pfifferling 1, 2018.

https://commons.wikimedia.org/wiki/File:Cantharellus_cibarius_(GB%3D_Chanterelle,_D%3D_Pfifferling,

_Reherling,_Eierschwamm,_NL%3D_Hanenkam)_at_Wofheze_at_30_July_2015_-_panoramio.jpg,


[54] Wikipedia: H. Krisp: Pfifferling 2, 2018.

https://commons.wikimedia.org/wiki/File:Pfifferling_Cantharellus_cibarius.jpg, abgerufen am:

18.07.2018

[55] Géron, A.: Hands-on machine learning with Scikit-Learn and TensorFlow. Concepts, tools, and techniques

to build intelligent systems / Aurélien Géron. Beijing: O'Reilly 2017

[56] Patterson, J. u. Gibson, A.: Deep learning. A practitioner's approach / Josh Patterson and Adam Gibson.

Beijing: O'Reilly 2017

[57] cv-tricks.com: Tensorflow Tutorial. http://cv-tricks.com/tensorflow-tutorial/training-convolutional-

neural-network-for-image-classification/, abgerufen am: 26.04.2018

13 Literaturangaben


[58] cv-tricks.com: Github: Tensorflow Tutorial. https://github.com/sankit1/cv-tricks.com, abgerufen am:

26.04.2018

[59] cv-tricks.com: Architektur Beispielprojekt. http://cv-tricks.com/wp-

content/uploads/2017/02/Tensorflow-tutorial-2-1.jpg, abgerufen am: 26.04.2018

[60] Data School: Confusion Matrix. https://www.dataschool.io/simple-guide-to-confusion-matrix-

terminology/, abgerufen am: 20.07.2018

[61] Scikit-learn developers: Confusion matrix, 2018. http://scikit-

learn.org/stable/auto_examples/model_selection/plot_confusion_matrix.html, abgerufen am:

16.07.2018

[62] Thomas Regnery: Feature_Lamellenpilz, 2013. http://pilztom.de/ees-001.png, abgerufen am: 27.06.2018

[63] Thomas Regnery: Feature_Röhrling, 2010. http://pilztom.de/ees-002.png, abgerufen am: 27.06.2018

[64] Stack Overflow: PHP,Full Secure Image Upload Script.

https://stackoverflow.com/questions/38509334/full-secure-image-upload-script, abgerufen am:

16.07.2018

14 Anhang 14.1 Anleitung: Einrichten der Workstation


14 Anhang

14.1 Anleitung: Einrichten der Workstation

Für das Training der neuronalen Netze hatten wir eine alte Workstation der NTB zur Verfügung. Eine solche

Workstation war notwendig, um die NVIDIA GeForce GTX 1080 Ti Grafikkarte einbauen zu können. Damit die

neuronalen Netze mithilfe der Grafikkarte trainiert werden können, müssen folgende Dinge erledigt werden:

1) Installation von Python 3.6:

https://www.python.org/downloads/release/python-360/

2) Installation von PyCharm Community:

https://www.jetbrains.com/pycharm/download/#section=windows

3) Installation von CUDA 9.1:

https://developer.nvidia.com/cuda-91-download-archive

Hinweis: Überprüfen Sie, ob die Umgebungsvariablen für CUDA angelegt wurden.

4) Download der cudnn 7.1 Dateien (NVIDIA Account erforderlich):

https://developer.nvidia.com/rdp/cudnn-archive

5) Verschieben der cudnn 7.1 Dateien nach:

C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v9.1

6) Projekt erstellen in PyCharm:

File -> New Project…

7) Auswahl des Python Interpreters in PyCharm:

File -> Settings -> Project: «Workspace»

8) Falls TensorFlow auf einem Rechner installiert werden soll, der eine alte CPU ohne AVX Instruktionen

besitzt, wie es bei der Workstation der NTB der Fall war, muss folgende Wheel Datei mittels «pip install»

direkt im Projekt installiert werden:

https://github.com/fo40225/tensorflow-windows-

wheel/tree/master/1.8.0/py36/GPU/cuda91cudnn71sse2

Falls TensorFlow auf einem Rechner installiert werden soll, der eine CPU mit AVX Instruktionen besitzt,

kann TensorFlow direkt in PyCharm installiert werden:

File -> Settings -> Project: «Workspace» -> Install -> «tensorflow-gpu»

9) Test mittels Import von TensorFlow über die Konsole in PyCharm:

«import tensorflow as tf»

Wenn keine Fehlermeldung nach dem Import von TensorFlow erscheint, ist die Workstation bereit für das

Training von neuronalen Netzen mithilfe der Grafikkarte.

https://www.python.org/downloads/release/python-360/

https://www.jetbrains.com/pycharm/download/#section=windows

https://developer.nvidia.com/cuda-91-download-archive

https://developer.nvidia.com/rdp/cudnn-archive

https://github.com/fo40225/tensorflow-windows-wheel/tree/master/1.8.0/py36/GPU/cuda91cudnn71sse2

https://github.com/fo40225/tensorflow-windows-wheel/tree/master/1.8.0/py36/GPU/cuda91cudnn71sse2

14 Anhang 14.2 Anleitung: Erweiterung der Applikation


14.2 Anleitung: Erweiterung der Applikation

Damit die Webapplikation zu einem späteren Zeitpunkt auch von Drittpersonen relativ einfach erweitert werden

kann, sind auf den nächsten Seiten alle Schritte dokumentiert, die für eine Erweiterung notwendig sind. Dazu

zählen die Bildvorverarbeitung, das Training des neuronalen Netzes und die Anpassung der Webapplikation.

Alle Skripts, Bilder und die Dateien der Webapplikation sind dem Anhang angehängt und zudem auf einem USB-

Stick gespeichert, welcher zur ausgedruckten Dokumentation mitgegeben wird.

14.2.1 Anleitung Bildvorverarbeitung

Sobald einige hundert Bilder eines Pilzes vorhanden sind, kann das neuronale Netz um eine weitere Pilzart

erweitert werden. Dafür werden alle Bilder standardisiert und vervielfacht. Folgende Schritte sind dafür

durchzuführen:

1) Bilder von Auge vorsortieren.

2) Die Bilder mithilfe der Batch Datei «Dateien_Nummerieren.bat», welche im Verzeichnis

«Software/Bildvorverarbeitung» zu finden sind, nummerieren:

Dazu muss die Batchdatei in den Ordner mit den Bildern verschoben werden und der Name des Pilzes

angepasst werden.

set ZAEHLER=0

mkdir end

:start

if not exist *.jpg goto end

set /a ZAEHLER=ZAEHLER+1

ren *.jpg pfifferling_%ZAEHLER%.jpg

move pfifferling_%ZAEHLER%.jpg end

goto start

:end

exit

3) Python Skript «Mushroom_Classifier.py» im Verzeichnis «Software/Python» öffnen und folgende

Parameter anpassen:

numberOfPictures = 462

link_CascadeClassifier = str("./cascade_files/myhaar_48x48.xml")

imageOutputSize = 256, 256

fileType = str(".jpg")

link_InputImage = str("./images/mushrooms/Pfifferling/end/pfifferling_")

link_OutputImage = str("./images/ergebnis/Pfifferling/")



4) Python Skript «Mushroom_Classifier.py» ausführen

5) Bilder von Auge nachsortieren, falls die Pilze schlecht zentriert oder andere Dinge lokalisiert wurden.

6) Bilder mithilfe der Batch Datei «Dateien_Nummerieren.bat» erneut, wie bei Punkt 2 aufgezeigt,

nummerieren.

7) Nachdem alle Punkte abgearbeitet wurden, kann der Ordner mit den zentrierten und vervielfachten

Bildern in den Ordner der Pilzdatenbank verschoben werden.

14.2.2 Anleitung Training neuronales Netz

Hinweis: Das Training der neuronalen Netze kann nur auf einem Rechner durchgeführt werden, auf dem die

TensorFlow und OpenCV Bibliothek installiert sind. Eine Anleitung dazu ist im Kapitel 14.1 zu finden.

Für das Training der neuronalen Netze sind folgende Schritte notwendig:

1) JSON File «MushroomFeatures.json» im Verzeichnis «Software/Python» öffnen und einen neue Pilzart

folgendermassen definieren:

"014_Pfifferling" : [ {

"Name": "Cantharellus cibarius / Pfifferling",

"Stiellaenge": 4,

"Stiellaenge_Standardabweichung": 1,

"Hutdurchmesser": 8,

"Hutdurchmesser_Standardabweichung": 3,

"Essbar": "Yes/Ja"}

]

Wichtig ist dabei, dass wie in diesem Beispiel der Name «014_Pfifferling» auch im Python Skript

«Mushroom_Classifier.py» unter «classes» verwendet wird.

2) Python Skript «Mushroom_Classifier.py» im Verzeichnis «Software/Python» öffnen

3) Parameter anpassen: (Der folgende Codeausschnitt zeigt die Klassennamen für das Training der

Lamellenpilze)

# Paths

train_path = 'D:/BA_MagicMushroom/Test/Datenbank/training_data'

# Prepare input data

classes = ['004_Fliegenpilz', '009_Gelber-Knollenblaetterpilz', '010_Grauer-Wulstling',

'011_Gruener-Knollenblaetterpilz', '012_Pantherpilz', '013_Perlpilz',

'014_Pfifferling']

#classes = ['000_Sommer-Steinpilz', '001_Kiefern-Steinpilz', '002_Gemeiner-Steinpilz',

'003_Schwarzhuetiger-Steinpilz', '005_Butterpilz', '006_Gold-Roehrling',

'007_Sandroehrling', '008_Ziegenlippe']



4) Gewünschte Architektur des neuronalen Netzes im Python Skript «Mushroom_Classifier.py» definieren:

def main(): for img_size in [64,128,256]: # Load Dataset


validation_size=validation_size) print("Complete reading input data. Will Now print a snippet of it") print("Number of files in Training-set:\t\t{}".format(len(data.train.labels))) print("Number of files in Validation-set:\t{}".format(len(data.valid.labels)))

num_epochs = 100

if img_size == 64: batch_size = 256 number_of_iteration = int(num_epochs*len(data.train.labels)/batch_size)



for learning_rate in [1E-3, 1E-4]: global i i = 0

for num_filter in [32]: for fc1_layer_size in [64,128]: for num_convlayer in [2, 3, 4]: if num_convlayer == 2: for filter in [[10, 10], [8, 8], [6, 6], [4, 4]]: train(data, img_size, batch_size, learning_rate,



if num_convlayer == 3: for filter in [[10, 8, 6], [8, 8, 6], [8, 6, 4], [6, 6, 4]]: train(data, img_size, batch_size, learning_rate,



if num_convlayer == 4: for filter in [[10, 8, 6, 6], [8, 8, 6, 4], [8, 6, 6, 4]]: train(data, img_size, batch_size, learning_rate,



Im Beispiel oben wird eine ganze Testreihe mit verschiedenen Parametern trainiert, damit anschliessend

das neuronale Netz verwendet werden kann, das die besten Ergebnisse erzielt hat.

5) Python Skript «Mushroom_Classifier.py» ausführen.

6) Während des Trainings der neuronalen Netze wird ein Unterordner «log» erzeugt, in dem sich alle

Modelle, die Confusion Matrix, Dateien für das TensorBoard und weitere Logdateien befinden.

7) Wenn ein Modell zufriedenstellende Ergebnisse erzielt hat, kann es anschliessend für die

Webapplikation verwendet werden.



14.2.3 Anleitung Anpassung Webapplikation

Nachdem bereits die JSON File «MushroomFeatures.json» angepasst und ein neuronales Netz trainiert wurde,

muss nur noch die Webapplikation angepasst werden. Dazu sind folgende Anpassungen notwendig:

1) Im Verzeichnis «Software/Web/Image» muss ein Beispielbild von jeder zu klassifizierenden Pilzart

abgelegt sein. Falls mehr Pilze als bis anhin klassifiziert werden, muss ein solches Beispielbild abgelegt

werden, welches anschliessend in der Webapplikation dargestellt wird.

2) Wenn eine weitere Pilzart klassifiziert werden kann, muss dies in den beiden HTML Dateien

«about-de.html» und «about-en.html» eingetragen werden, damit die Benutzer der Webapplikation

wissen, welche Pilze klassifiziert werden können. Beide Dateien sind im Verzeichnis «Web» zu finden.

3) Falls ein anderes neuronales Netz für die Klassifizierung der Pilze verwendet werden soll, muss das

Modell im passenden Verzeichnis «Software/Web/Python/…» abgelegt werden.

4) Das Python Skript «predict_web.py» im Verzeichnis «Software/Web/Python» muss ebenfalls angepasst

werden. Falls weitere Pilzarten trainiert wurden, müssen diese unter «classes_roehrling» oder

«classes_lamellen» eingetragen werden. Zudem müssen die Pfade für die Modelle der neuronalen

Netze angepasst werden, welche im Schritt 3 abgelegt wurden.

classes_roehrling = ['000_Sommer-Steinpilz', '001_Kiefern-Steinpilz', '002_Gemeiner-

Steinpilz', '003_Schwarzhuetiger-Steinpilz', '005_Butterpilz',

'006_Gold-Roehrling', '007_Sandroehrling', '008_Ziegenlippe']

classes_lamellen = ['004_Fliegenpilz', '009_Gelber-Knollenblaetterpilz', '010_Grauer-

Wulstling', '011_Gruener-Knollenblaetterpilz', '012_Pantherpilz',

'013_Perlpilz', '014_Pfifferling']

# Model

model_roehrling = './Python/Model_Roehrling/img=128,batch=128,lr_1E-05,conv=5,fs=[4, 4,

3, 3, 3],nf=32,fc=256_model.meta'

model_lamellen = './Python/Model_Lamellen/img=128,batch=128,lr_1E-04,conv=4,fs=[3, 3, 3,

3],nf=32,fc=256_model.meta'

14 Anhang 14.3.1 Vorverarbeitung (Mushroom_Finder.py)


14.3 Python Skripts

14.3.1 Vorverarbeitung (Mushroom_Finder.py)

USB-Stick: « Software/Bildvorverarbeitung /Mushroom_Finder.py »

### Bachelorarbeit Magic Mushroom App

### Pilze lokalisieren, zentrieren, standardisieren

### Riccardo Jung / Dominik Wagner

### 08.07.2018

# Import

import cv2

import numpy as np

# Parameter

numberOfPictures = 462

link_CascadeClassifier = str("./cascade_files/myhaar_48x48.xml")

imageOutputSize = 256, 256

fileType = str(".jpg")

# link_InputImage = str("./images/mushrooms/Sommer-Steinpilz/end/sommer_steinpilz_")

# link_InputImage = str("./images/mushrooms/Kiefern-Steinpilz/end/kiefern_steinpilz_")

# link_InputImage = str("./images/mushrooms/Gemeiner-Steinpilz/end/gemeiner_steinpilz_")

# link_InputImage = str("./images/mushrooms/Schwarzhuetiger-

Steinpilz/end/schwarzhuetiger_steinpilz_")

# link_InputImage = str("./images/mushrooms/Fliegenpilz/end/fliegenpilz_")

# link_InputImage = str("./images/mushrooms/Sandroehrling/end/sandroehrling_")

# link_InputImage = str("./images/mushrooms/Butterpilz/end/butterpilz_")

# link_InputImage = str("./images/mushrooms/Gold-Roehrling/end/gold-roehrling_")

# link_InputImage = str("./images/mushrooms/Ziegenlippe/end/ziegenlippe_")

# link_InputImage = str("./images/mushrooms/Gelber-Knollenblaetterpilz/end/gelber-

knollenblaetterpilz_")

# link_InputImage = str("./images/mushrooms/Grauer-Wulstling/end/grauer-wulstling_")

# link_InputImage = str("./images/mushrooms/Gruener-Knollenblaetterpilz/end/gruener-

knollenblaetterpilz_")

# link_InputImage = str("./images/mushrooms/Pantherpilz/end/pantherpilz_")

# link_InputImage = str("./images/mushrooms/Perlpilz/end/perlpilz_")

link_InputImage = str("./images/mushrooms/Pfifferling/end/pfifferling_")

# link_OutputImage = str("./images/ergebnis/Sommer-Steinpilz_final/")

# link_OutputImage = str("./images/ergebnis/Kiefern-Steinpilz_final/")

# link_OutputImage = str("./images/ergebnis/Gemeiner-Steinpilz/")

# link_OutputImage = str("./images/ergebnis/Schwarzhuetiger-Steinpilz/")

# link_OutputImage = str("./images/ergebnis/Fliegenpilz/")

# link_OutputImage = str("./images/ergebnis/Sandroehrling/")

# link_OutputImage = str("./images/ergebnis/Butterpilz/")

# link_OutputImage = str("./images/ergebnis/Gold-Roehrling/")

# link_OutputImage = str("./images/ergebnis/Ziegenlippe/")

# link_OutputImage = str("./images/ergebnis/Gelber-Knollenblaetterpilz/")

# link_OutputImage = str("./images/ergebnis/Grauer-Wulstling/")

# link_OutputImage = str("./images/ergebnis/Gruener-Knollenblaetterpilz/")

# link_OutputImage = str("./images/ergebnis/Pantherpilz/")

# link_OutputImage = str("./images/ergebnis/Perlpilz/")

link_OutputImage = str("./images/ergebnis/Pfifferling/")

# Import Cascade Classifier

mushroom_cascade = cv2.CascadeClassifier(link_CascadeClassifier)

if mushroom_cascade.empty():

raise IOError('Unable to load the mushroom cascade classifier xml file')

mushroomCount = 0

def resizeImg(img, OutputSize):

print("Resize image!")

return cv2.resize(img, OutputSize)



def cropImg(img, x, y, height, width):

print("Crop image!")

return img[y: y + height, x: x + width]

def saveImg(img, link, name, type):

print("Save image!")

cv2.imwrite(link + str(name) + type, img)

def flipImg(img):

print("Flip image!")

return cv2.flip(img, 1)

def rotateImg(img, x, y, height, width, angle):

print("Rotate image!")

rot_mat_right = cv2.getRotationMatrix2D((x + width / 2, y + height / 2), angle, 1.0)

return cv2.warpAffine(img, rot_mat_right, img.shape[1::-1], flags=cv2.INTER_LINEAR)

def changeGamma(img, gamma):

print("Change gamma image!")

table = np.array([((i / 255.0) ** gamma) * 255

for i in np.arange(0, 256)]).astype("uint8")

return cv2.LUT(img, table)

for i_images in range(1, numberOfPictures):

# Import image

img = cv2.imread(link_InputImage + str(i_images) + fileType)

img_width = img.shape[1]

img_height = img.shape[0]

img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Find mushroom

mushroom = mushroom_cascade.detectMultiScale(img_gray, 1.03, 50,

minSize=(int(img_width / 3),

int(img_height / 3)))

for (x, y, w, h) in mushroom:

# Calculate Window

xWindow = int(x - (w * 0.15)) # Start coordinate X

yWindow = int(y - (h * 0.25)) # Start coordinate Y

xWidth = int(w + 2 * (x - xWindow)) # Window width X

yHeight = int(w + (y - yWindow)) # Window height Y

if xWindow < 0:

xWindow = 0

xWidth = w + 2 * x

if yWindow < 0:

yWindow = 0

yHeight = h + y

if (xWidth + xWindow) > img_width:

xcalc = (img_width - w - x)

xWindow = x - xcalc

xWidth = img_width - xWindow

if (yHeight + yWindow) > img_height:

yWindow = y - (img_height - y - h)

yHeight = img_height - yWindow

# Cut Image first time (rough)

crop_img = cropImg(img, xWindow, yWindow, yHeight, xWidth)

# Resize Image first time

crop_img = resizeImg(crop_img, imageOutputSize)

# Find center X coordinate

array_greyMeansX = np.zeros((32, 1))

array_numberOfPixels = np.zeros((32, 1))



for i_mask in range(0, 32):

# Create a mask

mask = np.zeros(crop_img.shape[:2], np.uint8)

mask[int(crop_img.shape[0] / 2):int(crop_img.shape[0]), int(i_mask *

(crop_img.shape[1] / 32)):

int(crop_img.shape[1] / 32 +

i_mask * crop_img.shape[1] / 32)] = 255

masked_img = cv2.bitwise_and(crop_img, crop_img, mask=mask)

# Calculate histogram with mask

hist_mask = cv2.calcHist([crop_img], [0], mask, [256], [0, 256])

for i_greyscale in range(0, 255):

array_greyMeansX[i_mask] = (

array_greyMeansX[i_mask] + hist_mask[i_greyscale] * i_greyscale)

array_numberOfPixels[i_mask] = (

array_numberOfPixels[i_mask] + hist_mask[i_greyscale])

brightestPosition = 8

for i_meanBrightness in range(8, 24):

if (array_greyMeansX[i_meanBrightness] >=

array_greyMeansX[brightestPosition]):

brightestPosition = i_meanBrightness

# Find brightest Area

greyscaleBrightestArea = array_greyMeansX[brightestPosition]

brightestAreaRange = greyscaleBrightestArea * 0.7

array_range = np.zeros((16, 1))

numberOfBrightAreas = 0

for y in range(8, 24):

if (array_greyMeansX[y] >= brightestAreaRange):

array_range[numberOfBrightAreas] = y

numberOfBrightAreas = numberOfBrightAreas + 1

highestAreaInRange = 0

for i_areaInRange in range(0, 15):

if (array_range[i_areaInRange] > 0):

highestAreaInRange = i_areaInRange

# Define Center X coordinate

centerMushroomX = (array_range[0] + array_range[highestAreaInRange]) / 2

# Calculate Window

distanceToCenter = int((crop_img.shape[1] / 2) - (crop_img.shape[1] / 32 *

centerMushroomX))

xWindow = xWindow - distanceToCenter

if xWindow < 0:

xWindow = 0

xWidth = w + 2 * x

if (xWidth + xWindow) > img_width:

xcalc = (img_width - w - x)

xWindow = x - xcalc

xWidth = img_width - xWindow

# Cut image second time

crop_img = cropImg(img, xWindow, yWindow, yHeight, xWidth)

# Resize Image second time

final_img = resizeImg(crop_img, imageOutputSize)

################################################################

# Save Images

################################################################

# Save Image 1

saveImg(final_img, link_OutputImage, mushroomCount, fileType)

mushroomCount = mushroomCount + 1

# Save Image 2, flipped

saveImg(flipImg(final_img), link_OutputImage, mushroomCount, fileType)




# Save Image 3, rotated right

saveImg(resizeImg(cropImg(rotateImg(img, xWindow, yWindow, yHeight, xWidth, -

15), xWindow, yWindow, yHeight,

xWidth), imageOutputSize), link_OutputImage,

mushroomCount, fileType)


# Save Image 4, rotated left

saveImg(resizeImg(cropImg(rotateImg(img, xWindow, yWindow, yHeight, xWidth, 15),

xWindow, yWindow, yHeight,

xWidth), imageOutputSize), link_OutputImage,

mushroomCount, fileType)


# Save Image 5, change Gamma

saveImg(changeGamma(final_img, 0.5), link_OutputImage, mushroomCount, fileType)


# Save Image 6, change Gamma and flipped

saveImg(flipImg(changeGamma(final_img, 0.5)), link_OutputImage, mushroomCount,

fileType)


# Save Image 7, rotated right and change Gamma

saveImg(changeGamma(resizeImg(cropImg(rotateImg(img, xWindow, yWindow, yHeight,

xWidth, -15),

xWindow, yWindow, yHeight, xWidth),

imageOutputSize), 0.5),

link_OutputImage, mushroomCount, fileType)


# Save Image 8, rotated left and change Gamma

saveImg(changeGamma(

resizeImg(cropImg(rotateImg(img, xWindow, yWindow, yHeight, xWidth, 15),


imageOutputSize), 0.5), link_OutputImage, mushroomCount, fileType)


# Save Image 9, rotated right and flipped

saveImg(flipImg(resizeImg(

cropImg(rotateImg(img, xWindow, yWindow, yHeight, xWidth, -15), xWindow,

yWindow, yHeight, xWidth),

imageOutputSize)), link_OutputImage, mushroomCount, fileType)


# Save Image 10, rotated left and flipped

saveImg(flipImg(



imageOutputSize)), link_OutputImage, mushroomCount, fileType)


# Save Image 11, rotated right and flipped and change Gamma

saveImg(changeGamma(flipImg(resizeImg(

cropImg(rotateImg(img, xWindow, yWindow, yHeight, xWidth, -15), xWindow,

yWindow, yHeight, xWidth),

imageOutputSize)), 0.5), link_OutputImage, mushroomCount, fileType)


# Save Image 12, rotated left and flipped and change Gamma

saveImg(changeGamma(flipImg(



imageOutputSize)), 0.5), link_OutputImage, mushroomCount,

fileType)


i_images = i_images + 1

14 Anhang 14.3.2 Training neuronales Netz (Mushroom_Classifier.py)


14.3.2 Training neuronales Netz (Mushroom_Classifier.py)

USB-Stick: « Software/Python/Mushroom_Classifier.py »

# -*- coding: utf-8 -*-


### V4


### 08.07.2018

# Imports

import dataset

import layer

import log

import tensorflow as tf

import os

from sklearn.metrics import confusion_matrix

import numpy as np

import matplotlib.pyplot as plt

import itertools

# Adding Seed so that random initialization is consistent

from numpy.random import seed

seed(1)

tf.set_random_seed(2)

# Disable Warnings

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '4'

# Parameter

validation_size = 0.2

num_channels = 3 # channels RGB = 3

# Paths

train_path = 'D:/BA_MagicMushroom/Test/Datenbank/training_data'

# Prepare input data

classes = ['004_Fliegenpilz',

'009_Gelber-Knollenblaetterpilz', '010_Grauer-Wulstling', '011_Gruener-

Knollenblaetterpilz',

'012_Pantherpilz', '013_Perlpilz', '014_Pfifferling']

num_classes = len(classes)

def train(data, img_size, batch_size, learning_rate, number_of_iteration, num_convlayer,

filter, num_filter, fc1_layer_size):

# Construct a hyperparameter string for each one (example: "lr_1E-

3,fc=2,conv=2,fs=3")

global hparam

hparam = make_hparam_string(img_size, batch_size, learning_rate, num_convlayer,

fc1_layer_size, filter, num_filter)

print("Start training: " + hparam)

# Create log file for each test

global logfile

logfile = log.openLogFile(hparam)

log.createLogHeader(logfile, classes, img_size, batch_size, learning_rate,

"AdamOptimizer", num_convlayer, filter, num_filter, fc1_layer_size)

model_path = str('./log/model/' + hparam)

if not os.path.exists(model_path):

os.makedirs(model_path)

tf.reset_default_graph()

global session

session = tf.Session()

# Setup placeholders, and reshape the data

x = tf.placeholder(tf.float32, shape=[None, img_size, img_size, num_channels],

name='x')

x_features = tf.placeholder(tf.float32, shape=[None, 2], name='x_features')

global y

y = tf.placeholder(tf.float32, shape=[None, num_classes], name='labels')



# Create network

conv = []

conv.append(layer.create_conv_layer(x, num_channels, filter[0], num_filter,

"conv0"))

for num in range(1, num_convlayer):

conv.append(layer.create_conv_layer(conv[num-1], num_filter, filter[num],

num_filter, "conv"+ str(num)))

flattened = layer.create_flatten_layer(conv[num_convlayer-1])

merged = tf.concat([flattened, x_features], -1)

fc1 = layer.create_fc_layer(merged, merged.get_shape()[1:4].num_elements(),

fc1_layer_size, True, "fc1")

logits = layer.create_fc_layer(fc1, fc1_layer_size, num_classes, False, "fc2")

# Calculate prediction and visualize

with tf.name_scope("xent"):

global xent

xent = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=logits,

labels=y), name="xent") # Cost

tf.summary.scalar("Loss", xent)

with tf.name_scope("train"):

train_step = tf.train.AdamOptimizer(learning_rate).minimize(xent)

global y_pred

y_pred = tf.nn.softmax(logits, name='y_pred')

with tf.name_scope("accuracy"):

correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.argmax(y, 1))

global accuracy

accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

tf.summary.scalar("Accuracy", accuracy)

saver = tf.train.Saver(max_to_keep=2)

# session.run(tf.global_variables_initializer())

## for tensorboard

global writer_val

global writer_train

global write_op

writer_val = tf.summary.FileWriter("./log/tensorboard/plot_val_" + hparam)

writer_train = tf.summary.FileWriter("./log/tensorboard/plot_train_" + hparam)

# writer_train.add_graph(session.graph)

write_op = tf.summary.merge_all()

session.run(tf.global_variables_initializer())

total_iterations = 0

val_acc_old = 0;

val_loss_old = 1000;

for i in range(total_iterations, total_iterations + number_of_iteration):

global y_valid_batch

x_batch, x_features_batch, y_batch, _, cls_batch =

data.train.next_batch(batch_size)

x_valid_batch, x_valid_features_batch, y_valid_batch, _, valid_cls_batch =

data.valid.next_batch(batch_size)

feed_dict_tr = {x: x_batch, x_features: x_features_batch, y: y_batch}

feed_dict_val = {x: x_valid_batch, x_features: x_valid_features_batch, y:

y_valid_batch}

# Visualize in Console

if i % int(data.train.num_examples / batch_size) == 0:

epoch = int(i / int(data.train.num_examples / batch_size))

show_progress(epoch, feed_dict_tr, feed_dict_val, batch_size)



###################### Save model ##################################

if (val_acc > val_acc_old):

saver.save(session, os.path.join(model_path,

hparam + "_model"))

val_loss_old = val_loss

val_acc_old = val_acc

session.run(train_step, feed_dict=feed_dict_tr)

total_iterations += number_of_iteration

# Close log file

log.writeInFile(logfile, "Training done!")

log.writeInFile(logfile, " Highest val acc: " + str(val_acc_old))

log.writeInFile(logfile, " val loss: " + str(val_loss_old))

log.closeLogFile(logfile)

def make_hparam_string(img_size, batch_size, learning_rate, number_conv, number_fc,

filter_size, num_filter):

img_param = "img=%i" % img_size

batch_param = "batch=%i" % batch_size

conv_param = "conv=%i" % number_conv

fc_param = "fc=%i" % number_fc

filter_param = "fs=%s" % filter_size

num_filter_param = "nf=%s" % num_filter

return "%s,%s,lr_%.0E,%s,%s,%s,%s" % (img_param, batch_param, learning_rate,

conv_param, filter_param, num_filter_param, fc_param)

def main():

for img_size in [128]:

# Load Datasets


validation_size=validation_size)

print("Complete reading input data. Will Now print a snippet of it")

print("Number of files in Training-set:\t\t{}".format(len(data.train.labels)))

print("Number of files in Validation-set:\t{}".format(len(data.valid.labels)))

num_epochs = 300

if img_size == 64:

batch_size = 256

number_of_iteration = int(num_epochs*len(data.train.labels)/batch_size)

elif img_size == 128:

batch_size = 128

number_of_iteration = int(num_epochs * len(data.train.labels) / batch_size)

elif img_size == 256:

batch_size = 64

number_of_iteration = int(num_epochs * len(data.train.labels) / batch_size)

for learning_rate in [1E-5]:

global i

i = 0

for num_filter in [32]:

for fc1_layer_size in [64, 128, 256]:

for num_convlayer in [4, 5]:

if num_convlayer == 4:

for filter in [[6, 6, 6, 4], [6, 6, 4, 4], [4, 4, 4, 4], [4,

4, 3, 3], [3, 3, 3, 3]]:

train(data, img_size, batch_size, learning_rate,

number_of_iteration, num_convlayer, filter, num_filter, fc1_layer_size)

if num_convlayer == 5:

for filter in [[6, 6, 6, 6, 4], [6, 6, 4, 4, 4], [4, 4, 4,

4, 4], [4, 4, 3, 3, 3], [3, 3, 3, 3, 3]]:

train(data, img_size, batch_size, learning_rate,

number_of_iteration, num_convlayer, filter, num_filter, fc1_layer_size)

def show_progress(epoch, feed_dict_train, feed_dict_validate, batch_size):



#### Tensorboard

[acc, summary] = session.run([accuracy, write_op], feed_dict=feed_dict_train)

writer_train.add_summary(summary, epoch)

[loss, summary] = session.run([xent, write_op], feed_dict=feed_dict_train)

writer_train.add_summary(summary, epoch)

global val_acc

[val_acc, summary] = session.run([accuracy, write_op], feed_dict=feed_dict_validate)

writer_val.add_summary(summary, epoch)

global val_loss

[val_loss, summary] = session.run([xent, write_op], feed_dict=feed_dict_validate)

writer_val.add_summary(summary, epoch)

# create Folder for ConfusionMatrix

if not os.path.exists("./log/ConfusionMatrix"):

os.makedirs("./log/ConfusionMatrix")

# Confusion matrix

y_pred_show = session.run(y_pred, feed_dict=feed_dict_validate)

y_pred_show_1 = np.argmax(y_pred_show, axis=1)

y_val_1 = np.argmax(y_valid_batch, axis=1)

conf_matrix = confusion_matrix(y_val_1, y_pred_show_1)

plt.imshow(conf_matrix, interpolation='nearest', cmap=plt.cm.Blues)

plt.title('Confusion matrix Epoche: ' + str(epoch))

plt.colorbar(boundaries=np.linspace(0, int(batch_size/6), int(batch_size/12)+1))

tick_marks = np.arange(len(classes))

plt.xticks(tick_marks, classes, rotation=90, fontsize=7)

plt.yticks(tick_marks, classes, fontsize=7)

thresh = conf_matrix.max() / 2.

for u, j in itertools.product(range(conf_matrix.shape[0]),

range(conf_matrix.shape[1])):

plt.text(j, u, format(conf_matrix[u, j], 'd'),

horizontalalignment="center", verticalalignment="center", fontsize=7,

color="white" if conf_matrix[u, j] > thresh else "black")

plt.ylabel("True label")

plt.xlabel("Predicted label")

plt.tight_layout()

if not os.path.exists("./log/ConfusionMatrix/" + hparam):

os.makedirs("./log/ConfusionMatrix/" + hparam)

plt.savefig("./log/ConfusionMatrix/" + hparam + "/" + str(epoch+1))

plt.close()

plt.clf()

# Visualize in Console

msg = "Training Epoch {0} --- Training Accuracy: {1:>6.1%}, Validation Accuracy:

{2:>6.1%}, Validation Loss: {3:.3f} \n"

print(msg.format(epoch, acc, val_acc, val_loss))

# Visualize in log file

log.writeInFile(logfile, msg.format(epoch, acc, val_acc, val_loss))

main()

14 Anhang 14.3.3 Datensatz vorbereiten (dataset.py)


14.3.3 Datensatz vorbereiten (dataset.py)

USB-Stick: « Software/Python/dataset.py »


### Load Dataset


# Import

import cv2

import os

import glob

from sklearn.utils import shuffle

import numpy as np

import MushroomFeatures_JSON

def load_train(train_path, image_size, classes, validation_size):

train_images = []

train_features = []

train_labels = []

train_img_names = []

train_cls = []

valid_images = []

valid_features = []

valid_labels = []

valid_img_names = []

valid_cls = []

print('Going to read training images')

for fields in classes:

index = classes.index(fields)

print('Now going to read {} files (Index: {})'.format(fields, index))

path = os.path.join(train_path, fields, '*g')

files = glob.glob(path)

for fl in files:

files_index = files.index(fl)

numberoffiles = len(files)

image = cv2.imread(fl)

image = cv2.resize(image, (image_size, image_size), 0, 0, cv2.INTER_LINEAR)

image = image.astype(np.float32)

image = np.multiply(image, 1.0 / 255.0)

randomStemLength = MushroomFeatures_JSON.getRandomStemLength(fields)

randomHatDiameter = MushroomFeatures_JSON.getRandomHatDiameter(fields)

features = [randomStemLength, randomHatDiameter]

if(files_index < int(numberoffiles*(1-validation_size))):

train_images.append(image)

label = np.zeros(len(classes))

label[index] = 1.0

train_labels.append(label)

flbase = os.path.basename(fl)

train_img_names.append(flbase)

train_cls.append(fields)

train_features.append(features)

else:

valid_images.append(image)

label = np.zeros(len(classes))

label[index] = 1.0

valid_labels.append(label)

flbase = os.path.basename(fl)

valid_img_names.append(flbase)

valid_cls.append(fields)

valid_features.append(features)

14 Anhang 14.3.3 Datensatz vorbereiten (dataset.py)


train_images = np.array(train_images)

train_features = np.array(train_features)

train_labels = np.array(train_labels)

train_img_names = np.array(train_img_names)

train_cls = np.array(train_cls)

valid_images = np.array(valid_images)

valid_features = np.array(valid_features)

valid_labels = np.array(valid_labels)

valid_img_names = np.array(valid_img_names)

valid_cls = np.array(valid_cls)

return train_images, train_features, train_labels, train_img_names, train_cls,

valid_images, valid_features, valid_labels, valid_img_names, valid_cls

class DataSet(object):

def __init__(self, images, features, labels, img_names, cls):

self._num_examples = images.shape[0]

self._images = images

self._features = features

self._labels = labels

self._img_names = img_names

self._cls = cls

self._epochs_done = 0

self._index_in_epoch = 0

@property

def images(self):

return self._images

@property

def features(self):

return self._features

@property

def labels(self):

return self._labels

@property

def img_names(self):

return self._img_names

@property

def cls(self):

return self._cls

@property

def num_examples(self):

return self._num_examples

@property

def epochs_done(self):

return self._epochs_done

def next_batch(self, batch_size):

"""Return the next `batch_size` examples from this data set."""

start = self._index_in_epoch

self._index_in_epoch += batch_size

if self._index_in_epoch > self._num_examples:

# After each epoch we update this

self._epochs_done += 1

start = 0

self._index_in_epoch = batch_size

assert batch_size <= self._num_examples

end = self._index_in_epoch

return self._images[start:end], self._features[start:end], self._labels[start:end],

self._img_names[start:end], self._cls[start:end]

14 Anhang 14.3.4 Schichten für neuronales Netz (layer.py)


def read_train_sets(train_path, image_size, classes, validation_size):

class DataSets(object):

pass

data_sets = DataSets()

train_images, train_features, train_labels, train_img_names, train_cls, valid_images,

valid_features, valid_labels, valid_img_names, valid_cls = load_train(train_path,

image_size, classes, validation_size)

train_images, train_features, train_labels, train_img_names, train_cls =

shuffle(train_images, train_features, train_labels, train_img_names, train_cls)

valid_images, valid_features, valid_labels, valid_img_names, valid_cls =

shuffle(valid_images, valid_features, valid_labels, valid_img_names, valid_cls)

data_sets.train = DataSet(train_images, train_features, train_labels, train_img_names,

train_cls)

data_sets.valid = DataSet(valid_images, valid_features, valid_labels, valid_img_names,

valid_cls)

return data_sets

14.3.4 Schichten für neuronales Netz (layer.py)

USB-Stick: « Software/Python/layer.py »


### Create layer


### 08.07.2018

# Import

import tensorflow as tf

# Convutional layer

def create_conv_layer(input, size_in, filter_size, size_out, name="conv"):

with tf.name_scope(name):

w = tf.Variable(tf.truncated_normal([filter_size, filter_size, size_in,

size_out], stddev=0.1), name="W")

b = tf.Variable(tf.constant(0.05, shape=[size_out]), name="B")

conv = tf.nn.conv2d(input, w, strides=[1, 1, 1, 1], padding="SAME")

act = tf.nn.relu(conv + b)

# tf.summary.histogram("weights", w)

# tf.summary.histogram("biases", b)

# tf.summary.histogram("activations", act)

return tf.layers.batch_normalization(tf.nn.max_pool(act, ksize=[1, 2, 2, 1],

strides=[1, 2, 2, 1], padding="SAME"))

# Flatten layer --> needed for fully connected layer

def create_flatten_layer(layer):

# Shape of the layer: [batch_size img_size img_size num_channels]

layer_shape = layer.get_shape()

# Number of features: img_height * img_width* num_channels

num_features = layer_shape[1:4].num_elements()

layer = tf.reshape(layer, [-1, num_features])

return layer

# Full connected layer

def create_fc_layer(input, size_in, size_out, use_relu=True, name="fc"): # Fully

connected Layer

with tf.name_scope(name):

w = tf.Variable(tf.truncated_normal([size_in, size_out], stddev=0.1), name="W")

b = tf.Variable(tf.constant(0.05, shape=[size_out]), name="B")

act = tf.matmul(input, w) + b

if use_relu:

act = tf.nn.relu(act)

# tf.summary.histogram("weights", w)

# tf.summary.histogram("biases", b)

# tf.summary.histogram("activations", act)

return act

14 Anhang 14.3.5 Logdateien (log.py)


14.3.5 Logdateien (log.py)

USB-Stick: « Software/Python/log.py »


### Create Log File


### 08.07.2018

# Import

import os

def openLogFile(name):

if not os.path.exists("./log/txt"):

os.makedirs("./log/txt")

logfile = open("log/txt/" + name + ".txt", "w")

return logfile

def closeLogFile(logfile):

logfile.close()

def writeInFile(logfile, text):

logfile.write(text)

def createLogHeader(logfile, classes, img_size, batch_size, learning_rate, optimizer,

num_convlayer, filter, num_filter, fc1_layer_size):

msg_classes = "Classes: {0} \n"

msg_img_size = "Image size: {0}x{0} Pixel \n"

msg_batch_size = "Batch size: {0} \n"

msg_learning_rate = "Learning rate: {0} \n"

msg_optimizer = "Optimizer: {0} \n"

msg_num_convlayer = "Number of convolutional layers: {0} \n"

msg_filter = "Filter size: {0} \n"

msg_num_filter = "Number of filters: {0} \n"

mgs_fc1_layersize = "Fully connected layer size: {0} \n \n"

logfile.write(msg_classes.format(classes))

logfile.write(msg_img_size.format(img_size))

logfile.write(msg_batch_size.format(batch_size))

logfile.write(msg_learning_rate.format(learning_rate))

logfile.write(msg_optimizer.format(optimizer))

logfile.write(msg_num_convlayer.format(num_convlayer))

logfile.write(msg_filter.format(filter))

logfile.write(msg_num_filter.format(num_filter))

logfile.write(mgs_fc1_layersize.format(fc1_layer_size))

logfile.write("------------------------------------------------------------------

\n")

logfile.write("Start Training: \n")

14 Anhang 14.3.6 Zusätzliche Features (MushroomFeatures_JSON.py)


14.3.6 Zusätzliche Features (MushroomFeatures_JSON.py)

USB-Stick: « Software/Python/MushroomFeatures_JSON.py »


### Get mushroom features from JSON file


### 08.07.2018

# Import

import json

import numpy as np

from pprint import pprint

with open('MushroomFeatures.json') as data_file:

data = json.load(data_file)

def getStemLength(mushroom):

return data[mushroom][0]["Stiellaenge"]

def getStemStandardDeviation(mushroom):

return data[mushroom][0]["Stiellaenge_Standardabweichung"]

def getHatDiameter(mushroom):

return data[mushroom][0]["Hutdurchmesser"]

def getHatStandardDeviation(mushroom):

return data[mushroom][0]["Hutdurchmesser_Standardabweichung"]

def getRandomStemLength(mushroom):

stemLength = getStemLength(mushroom)

randomStemLength = np.random.normal(stemLength, getStemStandardDeviation(mushroom))

if(randomStemLength < stemLength/10 or randomStemLength > stemLength*2):

return getRandomStemLength(mushroom)

else:

return randomStemLength

def getRandomHatDiameter(mushroom):

hatDiameter = getHatDiameter(mushroom)

randomhatDiameter = np.random.normal(hatDiameter, getHatStandardDeviation(mushroom))

if (randomhatDiameter < hatDiameter / 10 or randomhatDiameter > hatDiameter * 2):

return getRandomHatDiameter(mushroom)

else:

return randomhatDiameter



14.4 JSON File (MushroomFeatures.json)

USB-Stick: « Software/Python/MushroomFeatures.json »

{

"000_Sommer-Steinpilz" : [ {

"Name": " Boletus aestivalis / Sommer-Steinpilz",

"Stiellaenge": 12,




"Essbar": "Yes/Ja"}

],

"001_Kiefern-Steinpilz" : [ {

"Name": "Boletus pinophilus / Kiefern-Steinpilz",

"Stiellaenge": 8,




"Essbar": "Yes/Ja"}

],

"002_Gemeiner-Steinpilz" : [ {

"Name": "Boletus edulis / Gemeiner-Steinpilz",

"Stiellaenge": 12,




"Essbar": "Yes/Ja"}

],

"003_Schwarzhuetiger-Steinpilz" : [ {

"Name": "Boletus aereus / Schwarzhütiger-Steinpilz",

"Stiellaenge": 10,




"Essbar": "Yes/Ja"}

],

"004_Fliegenpilz" : [ {

"Name": "Amanita muscaria / Fliegenpilz",

"Stiellaenge": 10,




"Essbar": "No, attention toxic!/Nein, Achtung giftig!"}

],

"005_Butterpilz" : [ {

"Name": "Suillus luteus / Butterpilz",

"Stiellaenge": 6,




"Essbar": "Yes/Ja"}

],

"006_Gold-Roehrling" : [ {

"Name": "Suillus grevillei / Gold-Röhrling",

"Stiellaenge": 7,




"Essbar": "Yes/Ja"}

],

"007_Sandroehrling" : [ {

"Name": "Suillus variegatus / Sand-Röhrling",

"Stiellaenge": 6,




"Essbar": "Yes/Ja"}

],



"008_Ziegenlippe" : [ {

"Name": "Xerocomus subtomentosus / Ziegenlippe",

"Stiellaenge": 6,




"Essbar": "Yes/Ja"}

],

"009_Gelber-Knollenblaetterpilz" : [ {

"Name": "Amanita citrina / Gelber-Knollenblätterpilz",

"Stiellaenge": 10,





],

"010_Grauer-Wulstling" : [ {

"Name": "Amanita excelsa / Grauer-Wulstling",

"Stiellaenge": 10,




"Essbar": "Limited edible, raw: toxic, cooked: edible/Bedingt, roh: giftig,

gekocht: essbar"}

],

"011_Gruener-Knollenblaetterpilz" : [ {

"Name": "Amanita phalloides / Grüner-Knollenblätterpilz",

"Stiellaenge": 11,





],

"012_Pantherpilz" : [ {

"Name": "Amanita pantherina / Pantherpilz",

"Stiellaenge": 9,





],

"013_Perlpilz" : [ {

"Name": "Amanita rubescens / Perlpilz",

"Stiellaenge": 12,




"Essbar": "Limited edible, raw: toxic, cooked: edible/Bedingt, roh: giftig,

gekocht: essbar"}

],

"014_Pfifferling" : [ {

"Name": "Cantharellus cibarius / Pfifferling",

"Stiellaenge": 4,




"Essbar": "Yes/Ja"}

]

}

14 Anhang 14.5 Testergebnisse Grid-Tests


14.5 Testergebnisse Grid-Tests

Lamellenpilze Testreihe 1

Date Test-number

Mushrooms Batch size

Image size

Number of channels

Number of convolutional layers

Filter size Number of filters

Fully connected layer size

Learning rate

Number of epochs

Validation accuracy

Validation loss

13.06.2018 56 Lamellen(7) 128 128 3 3 [6,6,4] 32 64 0.0001 100 80.5 % 1.394

13.06.2018 67 Lamellen(7) 128 128 3 3 [8,6,4] 32 128 0.0001 100 79.7 % 0.816

13.06.2018 32 Lamellen(7) 256 64 3 3 [6,6,4] 32 128 0.0001 100 78.1 % 1.016

13.06.2018 60 Lamellen(7) 128 128 3 4 [8,6,4,4] 32 64 0.0001 100 78.1 % 1.112

13.06.2018 64 Lamellen(7) 128 128 3 2 [4,4] 32 128 0.0001 100 78.1 % 1.395

13.06.2018 71 Lamellen(7) 128 128 3 4 [8,6,6,4] 32 128 0.0001 100 78.1 % 1.679

13.06.2018 8 Lamellen(7) 256 64 3 3 [6,6,4] 32 32 0.0001 100 77.7 % 0.772

13.06.2018 28 Lamellen(7) 256 64 3 2 [4,4] 32 128 0.0001 100 77.0 % 0.833

13.06.2018 12 Lamellen(7) 256 64 3 4 [8,6,4,4] 32 32 0.0001 100 76.7 % 0.952

13.06.2018 16 Lamellen(7) 256 64 3 2 [4,4] 32 64 0.0001 100 76.6 % 0.794

13.06.2018 48 Lamellen(7) 128 128 3 4 [8,6,4,4] 32 32 0.0001 100 76.6 % 1.239

13.06.2018 63 Lamellen(7) 128 128 3 2 [6,6] 32 128 0.0001 100 76.6 % 1.300

13.06.2018 69 Lamellen(7) 128 128 3 4 [10,8,6,6] 32 128 0.0001 100 76.6 % 1.655

13.06.2018 4 Lamellen(7) 256 64 3 2 [4,4] 32 32 0.0001 100 76.2 % 0.814

13.06.2018 43 Lamellen(7) 128 128 3 3 [8,6,4] 32 32 0.0001 100 75.8 % 1.887

13.06.2018 52 Lamellen(7) 128 128 3 2 [4,4] 32 64 0.0001 100 75.8 % 0.968

13.06.2018 53 Lamellen(7) 128 128 3 3 [10,8,6] 32 64 0.0001 100 75.8 % 2.062

13.06.2018 58 Lamellen(7) 128 128 3 4 [8,8,6,4] 32 64 0.0001 100 75.8 % 0.933

13.06.2018 59 Lamellen(7) 128 128 3 4 [8,6,6,4] 32 64 0.0001 100 75.8 % 0.936

13.06.2018 68 Lamellen(7) 128 128 3 3 [6,6,4] 32 128 0.0001 100 75.8 % 2.134

13.06.2018 72 Lamellen(7) 128 128 3 4 [8,6,4,4] 32 128 0.0001 100 75.8 % 1.259

13.06.2018 34 Lamellen(7) 256 64 3 4 [8,8,6,4] 32 128 0.0001 100 75.4 % 1.097

13.06.2018 46 Lamellen(7) 128 128 3 4 [8,8,6,4] 32 32 0.0001 100 75.0 % 1.278

13.06.2018 54 Lamellen(7) 128 128 3 3 [8,8,6] 32 64 0.0001 100 75.0 % 1.400

13.06.2018 55 Lamellen(7) 128 128 3 3 [8,6,4] 32 64 0.0001 100 75.0 % 1.325

13.06.2018 6 Lamellen(7) 256 64 3 3 [8,8,6] 32 32 0.0001 100 74.6 % 1.406

13.06.2018 20 Lamellen(7) 256 64 3 3 [6,6,4] 32 64 0.0001 100 74.2 % 0.859

13.06.2018 23 Lamellen(7) 256 64 3 4 [8,6,6,4] 32 64 0.0001 100 74.2 % 1.074

13.06.2018 44 Lamellen(7) 128 128 3 3 [6,6,4] 32 32 0.0001 100 74.2 % 1.829

13.06.2018 47 Lamellen(7) 128 128 3 4 [8,6,6,4] 32 32 0.0001 100 74.2 % 0.874

13.06.2018 57 Lamellen(7) 128 128 3 4 [10,8,6,6] 32 64 0.0001 100 74.2 % 1.661

13.06.2018 66 Lamellen(7) 128 128 3 3 [8,8,6] 32 128 0.0001 100 74.2 % 1.542

13.06.2018 70 Lamellen(7) 128 128 3 4 [8,8,6,4] 32 128 0.0001 100 74.2 % 1.288

13.06.2018 11 Lamellen(7) 256 64 3 4 [8,6,6,4] 32 32 0.0001 100 73.8 % 1.039

13.06.2018 18 Lamellen(7) 256 64 3 3 [8,8,6] 32 64 0.0001 100 73.8 % 1.178

13.06.2018 19 Lamellen(7) 256 64 3 3 [8,6,4] 32 64 0.0001 100 73.8 % 1.052



13.06.2018 31 Lamellen(7) 256 64 3 3 [8,6,4] 32 128 0.0001 100 73.8 % 0.887

13.06.2018 33 Lamellen(7) 256 64 3 4 [10,8,6,6] 32 128 0.0001 100 73.8 % 1.448

13.06.2018 65 Lamellen(7) 128 128 3 3 [10,8,6] 32 128 0.0001 100 73.4 % 1.228

13.06.2018 7 Lamellen(7) 256 64 3 3 [8,6,4] 32 32 0.0001 100 73.0 % 0.855

13.06.2018 15 Lamellen(7) 256 64 3 2 [6,6] 32 64 0.0001 100 72.7 % 0.877

13.06.2018 50 Lamellen(7) 128 128 3 2 [8,8] 32 64 0.0001 100 72.7 % 1.933

13.06.2018 10 Lamellen(7) 256 64 3 4 [8,8,6,4] 32 32 0.0001 100 72.3 % 0.984

13.06.2018 35 Lamellen(7) 256 64 3 4 [8,6,6,4] 32 128 0.0001 100 72.3 % 1.119

13.06.2018 5 Lamellen(7) 256 64 3 3 [10,8,6] 32 32 0.0001 100 71.9 % 1.303

13.06.2018 26 Lamellen(7) 256 64 3 2 [8,8] 32 128 0.0001 100 71.9 % 1.366

13.06.2018 37 Lamellen(7) 128 128 3 2 [10,10] 32 32 0.0001 100 71.9 % 2.045

13.06.2018 45 Lamellen(7) 128 128 3 4 [10,8,6,6] 32 32 0.0001 100 71.9 % 1.257

13.06.2018 36 Lamellen(7) 256 64 3 4 [8,6,4,4] 32 128 0.0001 100 71.5 % 1.010

13.06.2018 27 Lamellen(7) 256 64 3 2 [6,6] 32 128 0.0001 100 71.1 % 1.413

13.06.2018 39 Lamellen(7) 128 128 3 2 [6,6] 32 32 0.0001 100 71.1 % 0.853

13.06.2018 41 Lamellen(7) 128 128 3 3 [10,8,6] 32 32 0.0001 100 71.1 % 2.053

13.06.2018 42 Lamellen(7) 128 128 3 3 [8,8,6] 32 32 0.0001 100 71.1 % 1.752

13.06.2018 51 Lamellen(7) 128 128 3 2 [6,6] 32 64 0.0001 100 71.1 % 1.493

13.06.2018 61 Lamellen(7) 128 128 3 2 [10,10] 32 128 0.0001 100 71.1 % 2.804

13.06.2018 62 Lamellen(7) 128 128 3 2 [8,8] 32 128 0.0001 100 71.1 % 1.910

13.06.2018 3 Lamellen(7) 256 64 3 2 [6,6] 32 32 0.0001 100 70.7 % 1.295

13.06.2018 2 Lamellen(7) 256 64 3 2 [8,8] 32 32 0.0001 100 70.3 % 1.328

13.06.2018 17 Lamellen(7) 256 64 3 3 [10,8,6] 32 64 0.0001 100 70.3 % 1.245

13.06.2018 29 Lamellen(7) 256 64 3 3 [10,8,6] 32 128 0.0001 100 70.3 % 1.384

13.06.2018 1 Lamellen(7) 256 64 3 2 [10,10] 32 32 0.0001 100 69.9 % 1.264

13.06.2018 24 Lamellen(7) 256 64 3 4 [8,6,4,4] 32 64 0.0001 100 69.5 % 1.157

13.06.2018 49 Lamellen(7) 128 128 3 2 [10,10] 32 64 0.0001 100 69.5 % 2.655

13.06.2018 9 Lamellen(7) 256 64 3 4 [10,8,6,6] 32 32 0.0001 100 68.8 % 1.293

13.06.2018 21 Lamellen(7) 256 64 3 4 [10,8,6,6] 32 64 0.0001 100 68.8 % 1.227

13.06.2018 38 Lamellen(7) 128 128 3 2 [8,8] 32 32 0.0001 100 68.8 % 1.431

13.06.2018 40 Lamellen(7) 128 128 3 2 [4,4] 32 32 0.0001 100 68.8 % 1.126

13.06.2018 30 Lamellen(7) 256 64 3 3 [8,8,6] 32 128 0.0001 100 68.4 % 1.440

13.06.2018 13 Lamellen(7) 256 64 3 2 [10,10] 32 64 0.0001 100 68.0 % 1.644

13.06.2018 14 Lamellen(7) 256 64 3 2 [8,8] 32 64 0.0001 100 68.0 % 1.724

13.06.2018 22 Lamellen(7) 256 64 3 4 [8,8,6,4] 32 64 0.0001 100 68.0 % 1.221

13.06.2018 25 Lamellen(7) 256 64 3 2 [10,10] 32 128 0.0001 100 64.1 % 1.929




Date Test-number


Image size

Number of channels




Learning rate

Number of epochs

Validation accuracy

Validation loss

15.06.2018 175 Lamellen(7) 128 128 3 5 [4,4,4,4,4] 32 128 0.001 100 85.2 % 1.528

15.06.2018 140 Lamellen(7) 128 128 3 4 [3,3,3,3] 32 256 0.0001 100 84.4 % 0.640

15.06.2018 190 Lamellen(7) 128 128 3 5 [6,6,4,4,4] 32 256 0.001 100 84.4 % 1.203

15.06.2018 174 Lamellen(7) 128 128 3 5 [6,6,4,4,4] 32 128 0.001 100 83.6 % 1.052

15.06.2018 92 Lamellen(7) 256 64 3 4 [3,3,3,3] 32 256 0.001 100 83.2 % 1.356

15.06.2018 160 Lamellen(7) 128 128 3 5 [3,3,3,3,3] 32 64 0.001 100 82.8 % 1.037

15.06.2018 168 Lamellen(7) 128 128 3 3 [3,3,3] 32 128 0.001 100 82.8 % 1.422

15.06.2018 192 Lamellen(7) 128 128 3 5 [3,3,3,3,3] 32 256 0.001 100 82.8 % 1.386

15.06.2018 60 Lamellen(7) 256 64 3 4 [3,3,3,3] 32 64 0.001 100 82.0 % 0.661

15.06.2018 112 Lamellen(7) 128 128 3 5 [3,3,3,3,3] 32 64 0.0001 100 82.0 % 0.691

15.06.2018 123 Lamellen(7) 128 128 3 4 [4,4,4,4] 32 128 0.0001 100 82.0 % 0.870

15.06.2018 155 Lamellen(7) 128 128 3 4 [4,4,4,4] 32 64 0.001 100 82.0 % 0.948

15.06.2018 156 Lamellen(7) 128 128 3 4 [3,3,3,3] 32 64 0.001 100 82.0 % 1.831

15.06.2018 172 Lamellen(7) 128 128 3 4 [3,3,3,3] 32 128 0.001 100 82.0 % 1.833

15.06.2018 71 Lamellen(7) 256 64 3 3 [4,4,4] 32 128 0.001 100 81.3 % 0.712

15.06.2018 111 Lamellen(7) 128 128 3 5 [4,4,4,4,4] 32 64 0.0001 100 81.3 % 0.810

15.06.2018 128 Lamellen(7) 128 128 3 5 [3,3,3,3,3] 32 128 0.0001 100 81.3 % 0.658

15.06.2018 144 Lamellen(7) 128 128 3 5 [3,3,3,3,3] 32 256 0.0001 100 81.3 % 0.792

15.06.2018 72 Lamellen(7) 256 64 3 3 [3,3,3] 32 128 0.001 100 80.9 % 1.714

15.06.2018 8 Lamellen(7) 256 64 3 3 [3,3,3] 32 64 0.0001 100 80.5 % 0.662

15.06.2018 135 Lamellen(7) 128 128 3 3 [4,4,4] 32 256 0.0001 100 80.5 % 1.451

15.06.2018 176 Lamellen(7) 128 128 3 5 [3,3,3,3,3] 32 128 0.001 100 80.5 % 1.620

15.06.2018 183 Lamellen(7) 128 128 3 3 [4,4,4] 32 256 0.001 100 80.5 % 1.628

15.06.2018 188 Lamellen(7) 128 128 3 4 [3,3,3,3] 32 256 0.001 100 80.5 % 1.646

15.06.2018 137 Lamellen(7) 128 128 3 4 [6,6,6,4] 32 256 0.0001 100 80.4 % 1.318

15.06.2018 24 Lamellen(7) 256 64 3 3 [3,3,3] 32 128 0.0001 100 79.7 % 0.761

15.06.2018 104 Lamellen(7) 128 128 3 3 [3,3,3] 32 64 0.0001 100 79.7 % 1.334

15.06.2018 108 Lamellen(7) 128 128 3 4 [3,3,3,3] 32 64 0.0001 100 79.7 % 0.761

15.06.2018 122 Lamellen(7) 128 128 3 4 [6,6,4,4] 32 128 0.0001 100 79.7 % 1.267

15.06.2018 124 Lamellen(7) 128 128 3 4 [3,3,3,3] 32 128 0.0001 100 79.7 % 0.639

15.06.2018 139 Lamellen(7) 128 128 3 4 [4,4,4,4] 32 256 0.0001 100 79.7 % 0.658

15.06.2018 165 Lamellen(7) 128 128 3 3 [6,6,4] 32 128 0.001 100 79.7 % 1.753

15.06.2018 191 Lamellen(7) 128 128 3 5 [4,4,4,4,4] 32 256 0.001 100 79.7 % 1.730

15.06.2018 12 Lamellen(7) 256 64 3 4 [3,3,3,3] 32 64 0.0001 100 79.3 % 0.688

15.06.2018 11 Lamellen(7) 256 64 3 4 [4,4,4,4] 32 64 0.0001 100 78.9 % 0.775

15.06.2018 16 Lamellen(7) 256 64 3 5 [3,3,3,3,3] 32 64 0.0001 100 78.9 % 0.693

15.06.2018 31 Lamellen(7) 256 64 3 5 [4,4,4,4,4] 32 128 0.0001 100 78.9 % 0.711

15.06.2018 44 Lamellen(7) 256 64 3 4 [3,3,3,3] 32 256 0.0001 100 78.9 % 0.670



15.06.2018 88 Lamellen(7) 256 64 3 3 [3,3,3] 32 256 0.001 100 78.9 % 1.582

15.06.2018 90 Lamellen(7) 256 64 3 4 [6,6,4,4] 32 256 0.001 100 78.9 % 1.844

15.06.2018 109 Lamellen(7) 128 128 3 5 [6,6,6,6,4] 32 64 0.0001 100 78.9 % 1.171

15.06.2018 126 Lamellen(7) 128 128 3 5 [6,6,4,4,4] 32 128 0.0001 100 78.9 % 0.942

15.06.2018 127 Lamellen(7) 128 128 3 5 [4,4,4,4,4] 32 128 0.0001 100 78.9 % 0.642

15.06.2018 136 Lamellen(7) 128 128 3 3 [3,3,3] 32 256 0.0001 100 78.9 % 1.231

15.06.2018 138 Lamellen(7) 128 128 3 4 [6,6,4,4] 32 256 0.0001 100 78.9 % 1.278

15.06.2018 143 Lamellen(7) 128 128 3 5 [4,4,4,4,4] 32 256 0.0001 100 78.9 % 1.237

15.06.2018 148 Lamellen(7) 128 128 3 2 [3,3] 32 64 0.001 100 78.9 % 0.873

15.06.2018 151 Lamellen(7) 128 128 3 3 [4,4,4] 32 64 0.001 100 78.9 % 2.563

15.06.2018 153 Lamellen(7) 128 128 3 4 [6,6,6,4] 32 64 0.001 100 78.9 % 1.960

15.06.2018 157 Lamellen(7) 128 128 3 5 [6,6,6,6,4] 32 64 0.001 100 78.9 % 1.043

15.06.2018 169 Lamellen(7) 128 128 3 4 [6,6,6,4] 32 128 0.001 100 78.9 % 1.782

15.06.2018 171 Lamellen(7) 128 128 3 4 [4,4,4,4] 32 128 0.001 100 78.9 % 2.183

15.06.2018 181 Lamellen(7) 128 128 3 3 [6,6,4] 32 256 0.001 100 78.9 % 1.566

15.06.2018 182 Lamellen(7) 128 128 3 3 [6,4,4] 32 256 0.001 100 78.9 % 1.879

15.06.2018 184 Lamellen(7) 128 128 3 3 [3,3,3] 32 256 0.001 100 78.9 % 1.465

15.06.2018 185 Lamellen(7) 128 128 3 4 [6,6,6,4] 32 256 0.001 100 78.9 % 1.510

15.06.2018 187 Lamellen(7) 128 128 3 4 [4,4,4,4] 32 256 0.001 100 78.9 % 1.112

15.06.2018 14 Lamellen(7) 256 64 3 5 [6,6,4,4,4] 32 64 0.0001 100 78.5 % 0.854

15.06.2018 64 Lamellen(7) 256 64 3 5 [3,3,3,3,3] 32 64 0.001 100 78.5 % 0.715

15.06.2018 35 Lamellen(7) 256 64 3 2 [4,4] 32 256 0.0001 100 78.1 % 0.938

15.06.2018 37 Lamellen(7) 256 64 3 3 [6,6,4] 32 256 0.0001 100 78.1 % 0.886

15.06.2018 46 Lamellen(7) 256 64 3 5 [6,6,4,4,4] 32 256 0.0001 100 78.1 % 0.881

15.06.2018 96 Lamellen(7) 256 64 3 5 [3,3,3,3,3] 32 256 0.001 100 78.1 % 1.574

15.06.2018 105 Lamellen(7) 128 128 3 4 [6,6,6,4] 32 64 0.0001 100 78.1 % 1.700

15.06.2018 115 Lamellen(7) 128 128 3 2 [4,4] 32 128 0.0001 100 78.1 % 0.725

15.06.2018 119 Lamellen(7) 128 128 3 3 [4,4,4] 32 128 0.0001 100 78.1 % 1.982

15.06.2018 120 Lamellen(7) 128 128 3 3 [3,3,3] 32 128 0.0001 100 78.1 % 1.026

15.06.2018 132 Lamellen(7) 128 128 3 2 [3,3] 32 256 0.0001 100 78.1 % 1.170

15.06.2018 164 Lamellen(7) 128 128 3 2 [3,3] 32 128 0.001 100 78.1 % 0.721

15.06.2018 167 Lamellen(7) 128 128 3 3 [4,4,4] 32 128 0.001 100 78.1 % 1.393

15.06.2018 170 Lamellen(7) 128 128 3 4 [6,6,4,4] 32 128 0.001 100 78.1 % 0.772

15.06.2018 189 Lamellen(7) 128 128 3 5 [6,6,6,6,4] 32 256 0.001 100 78.1 % 1.678

15.06.2018 38 Lamellen(7) 256 64 3 3 [6,4,4] 32 256 0.0001 100 77.7 % 0.788

15.06.2018 53 Lamellen(7) 256 64 3 3 [6,6,4] 32 64 0.001 100 77.7 % 1.996

15.06.2018 62 Lamellen(7) 256 64 3 5 [6,6,4,4,4] 32 64 0.001 100 77.7 % 1.724

15.06.2018 94 Lamellen(7) 256 64 3 5 [6,6,4,4,4] 32 256 0.001 100 77.7 % 1.848

15.06.2018 6 Lamellen(7) 256 64 3 3 [6,4,4] 32 64 0.0001 100 77.3 % 1.107

15.06.2018 17 Lamellen(7) 256 64 3 2 [6,6] 32 128 0.0001 100 77.3 % 1.157

15.06.2018 27 Lamellen(7) 256 64 3 4 [4,4,4,4] 32 128 0.0001 100 77.3 % 0.730

15.06.2018 39 Lamellen(7) 256 64 3 3 [4,4,4] 32 256 0.0001 100 77.3 % 0.797

15.06.2018 40 Lamellen(7) 256 64 3 3 [3,3,3] 32 256 0.0001 100 77.3 % 0.738

15.06.2018 52 Lamellen(7) 256 64 3 2 [3,3] 32 64 0.001 100 77.3 % 0.796



15.06.2018 70 Lamellen(7) 256 64 3 3 [6,4,4] 32 128 0.001 100 77.3 % 1.316

15.06.2018 87 Lamellen(7) 256 64 3 3 [4,4,4] 32 256 0.001 100 77.3 % 1.621

15.06.2018 103 Lamellen(7) 128 128 3 3 [4,4,4] 32 64 0.0001 100 77.3 % 1.332

15.06.2018 107 Lamellen(7) 128 128 3 4 [4,4,4,4] 32 64 0.0001 100 77.3 % 0.737

15.06.2018 142 Lamellen(7) 128 128 3 5 [6,6,4,4,4] 32 256 0.0001 100 77.3 % 0.811

15.06.2018 158 Lamellen(7) 128 128 3 5 [6,6,4,4,4] 32 64 0.001 100 77.3 % 2.470

15.06.2018 159 Lamellen(7) 128 128 3 5 [4,4,4,4,4] 32 64 0.001 100 77.3 % 2.268

15.06.2018 186 Lamellen(7) 128 128 3 4 [6,6,4,4] 32 256 0.001 100 77.3 % 1.370

15.06.2018 4 Lamellen(7) 256 64 3 2 [3,3] 32 64 0.0001 100 77.0 % 0.786

15.06.2018 7 Lamellen(7) 256 64 3 3 [4,4,4] 32 64 0.0001 100 77.0 % 0.813

15.06.2018 15 Lamellen(7) 256 64 3 5 [4,4,4,4,4] 32 64 0.0001 100 77.0 % 0.758

15.06.2018 28 Lamellen(7) 256 64 3 4 [3,3,3,3] 32 128 0.0001 100 77.0 % 0.725

15.06.2018 42 Lamellen(7) 256 64 3 4 [6,6,4,4] 32 256 0.0001 100 77.0 % 0.815

15.06.2018 43 Lamellen(7) 256 64 3 4 [4,4,4,4] 32 256 0.0001 100 77.0 % 0.732

15.06.2018 54 Lamellen(7) 256 64 3 3 [6,4,4] 32 64 0.001 100 77.0 % 1.865

15.06.2018 56 Lamellen(7) 256 64 3 3 [3,3,3] 32 64 0.001 100 77.0 % 0.724

15.06.2018 69 Lamellen(7) 256 64 3 3 [6,6,4] 32 128 0.001 100 77.0 % 1.613

15.06.2018 80 Lamellen(7) 256 64 3 5 [3,3,3,3,3] 32 128 0.001 100 77.0 % 1.926

15.06.2018 147 Lamellen(7) 128 128 3 2 [4,4] 32 64 0.001 100 76.7 % 0.726

15.06.2018 21 Lamellen(7) 256 64 3 3 [6,6,4] 32 128 0.0001 100 76.6 % 0.832

15.06.2018 22 Lamellen(7) 256 64 3 3 [6,4,4] 32 128 0.0001 100 76.6 % 1.243

15.06.2018 26 Lamellen(7) 256 64 3 4 [6,6,4,4] 32 128 0.0001 100 76.6 % 0.817

15.06.2018 30 Lamellen(7) 256 64 3 5 [6,6,4,4,4] 32 128 0.0001 100 76.6 % 0.930

15.06.2018 47 Lamellen(7) 256 64 3 5 [4,4,4,4,4] 32 256 0.0001 100 76.6 % 0.826

15.06.2018 85 Lamellen(7) 256 64 3 3 [6,6,4] 32 256 0.001 100 76.6 % 1.367

15.06.2018 86 Lamellen(7) 256 64 3 3 [6,4,4] 32 256 0.001 100 76.6 % 1.408

15.06.2018 101 Lamellen(7) 128 128 3 3 [6,6,4] 32 64 0.0001 100 76.6 % 0.900

15.06.2018 102 Lamellen(7) 128 128 3 3 [6,4,4] 32 64 0.0001 100 76.6 % 1.557

15.06.2018 106 Lamellen(7) 128 128 3 4 [6,6,4,4] 32 64 0.0001 100 76.6 % 0.790

15.06.2018 110 Lamellen(7) 128 128 3 5 [6,6,4,4,4] 32 64 0.0001 100 76.6 % 0.752

15.06.2018 154 Lamellen(7) 128 128 3 4 [6,6,4,4] 32 64 0.001 100 76.6 % 2.322

15.06.2018 10 Lamellen(7) 256 64 3 4 [6,6,4,4] 32 64 0.0001 100 76.2 % 0.843

15.06.2018 48 Lamellen(7) 256 64 3 5 [3,3,3,3,3] 32 256 0.0001 100 76.2 % 0.696

15.06.2018 51 Lamellen(7) 256 64 3 2 [4,4] 32 64 0.001 100 76.2 % 1.232

15.06.2018 59 Lamellen(7) 256 64 3 4 [4,4,4,4] 32 64 0.001 100 76.2 % 1.990

15.06.2018 68 Lamellen(7) 256 64 3 2 [3,3] 32 128 0.001 100 76.2 % 0.779

15.06.2018 73 Lamellen(7) 256 64 3 4 [6,6,6,4] 32 128 0.001 100 76.2 % 2.173

15.06.2018 76 Lamellen(7) 256 64 3 4 [3,3,3,3] 32 128 0.001 100 76.2 % 0.705

15.06.2018 79 Lamellen(7) 256 64 3 5 [4,4,4,4,4] 32 128 0.001 100 76.2 % 1.460

15.06.2018 74 Lamellen(7) 256 64 3 4 [6,6,4,4] 32 128 0.001 100 75.8 % 0.906

15.06.2018 77 Lamellen(7) 256 64 3 5 [6,6,6,6,4] 32 128 0.001 100 75.8 % 0.826

15.06.2018 91 Lamellen(7) 256 64 3 4 [4,4,4,4] 32 256 0.001 100 75.8 % 0.693

15.06.2018 95 Lamellen(7) 256 64 3 5 [4,4,4,4,4] 32 256 0.001 100 75.8 % 0.834

15.06.2018 133 Lamellen(7) 128 128 3 3 [6,6,4] 32 256 0.0001 100 75.8 % 1.692



15.06.2018 150 Lamellen(7) 128 128 3 3 [6,4,4] 32 64 0.001 100 75.8 % 2.046

15.06.2018 166 Lamellen(7) 128 128 3 3 [6,4,4] 32 128 0.001 100 75.8 % 1.590

15.06.2018 173 Lamellen(7) 128 128 3 5 [6,6,6,6,4] 32 128 0.001 100 75.8 % 1.534

15.06.2018 5 Lamellen(7) 256 64 3 3 [6,6,4] 32 64 0.0001 100 75.4 % 0.972

15.06.2018 20 Lamellen(7) 256 64 3 2 [3,3] 32 128 0.0001 100 75.4 % 0.770

15.06.2018 41 Lamellen(7) 256 64 3 4 [6,6,6,4] 32 256 0.0001 100 75.4 % 0.795

15.06.2018 63 Lamellen(7) 256 64 3 5 [4,4,4,4,4] 32 64 0.001 100 75.4 % 1.666

15.06.2018 2 Lamellen(7) 256 64 3 2 [6,4] 32 64 0.0001 100 75.0 % 1.217

15.06.2018 23 Lamellen(7) 256 64 3 3 [4,4,4] 32 128 0.0001 100 75.0 % 0.839

15.06.2018 25 Lamellen(7) 256 64 3 4 [6,6,6,4] 32 128 0.0001 100 75.0 % 0.953

15.06.2018 55 Lamellen(7) 256 64 3 3 [4,4,4] 32 64 0.001 100 75.0 % 0.767

15.06.2018 58 Lamellen(7) 256 64 3 4 [6,6,4,4] 32 64 0.001 100 75.0 % 1.344

15.06.2018 75 Lamellen(7) 256 64 3 4 [4,4,4,4] 32 128 0.001 100 75.0 % 1.455

15.06.2018 99 Lamellen(7) 128 128 3 2 [4,4] 32 64 0.0001 100 75.0 % 1.505

15.06.2018 100 Lamellen(7) 128 128 3 2 [3,3] 32 64 0.0001 100 75.0 % 0.714

15.06.2018 116 Lamellen(7) 128 128 3 2 [3,3] 32 128 0.0001 100 75.0 % 1.464

15.06.2018 117 Lamellen(7) 128 128 3 3 [6,6,4] 32 128 0.0001 100 75.0 % 0.858

15.06.2018 118 Lamellen(7) 128 128 3 3 [6,4,4] 32 128 0.0001 100 75.0 % 1.015

15.06.2018 121 Lamellen(7) 128 128 3 4 [6,6,6,4] 32 128 0.0001 100 75.0 % 0.712

15.06.2018 125 Lamellen(7) 128 128 3 5 [6,6,6,6,4] 32 128 0.0001 100 75.0 % 1.001

15.06.2018 141 Lamellen(7) 128 128 3 5 [6,6,6,6,4] 32 256 0.0001 100 75.0 % 0.985

15.06.2018 152 Lamellen(7) 128 128 3 3 [3,3,3] 32 64 0.001 100 75.0 % 0.868

15.06.2018 163 Lamellen(7) 128 128 3 2 [4,4] 32 128 0.001 100 75.0 % 2.166

15.06.2018 57 Lamellen(7) 256 64 3 4 [6,6,6,4] 32 64 0.001 100 74.6 % 1.330

15.06.2018 84 Lamellen(7) 256 64 3 2 [3,3] 32 256 0.001 100 74.6 % 1.277

15.06.2018 19 Lamellen(7) 256 64 3 2 [4,4] 32 128 0.0001 100 74.2 % 0.903

15.06.2018 32 Lamellen(7) 256 64 3 5 [3,3,3,3,3] 32 128 0.0001 100 74.2 % 0.731

15.06.2018 34 Lamellen(7) 256 64 3 2 [6,4] 32 256 0.0001 100 74.2 % 1.013

15.06.2018 36 Lamellen(7) 256 64 3 2 [3,3] 32 256 0.0001 100 74.2 % 1.095

15.06.2018 50 Lamellen(7) 256 64 3 2 [6,4] 32 64 0.001 100 74.2 % 1.064

15.06.2018 98 Lamellen(7) 128 128 3 2 [6,4] 32 64 0.0001 100 74.2 % 0.857

15.06.2018 131 Lamellen(7) 128 128 3 2 [4,4] 32 256 0.0001 100 74.2 % 1.221

15.06.2018 61 Lamellen(7) 256 64 3 5 [6,6,6,6,4] 32 64 0.001 100 73.8 % 0.970

15.06.2018 67 Lamellen(7) 256 64 3 2 [4,4] 32 128 0.001 100 73.4 % 1.112

15.06.2018 78 Lamellen(7) 256 64 3 5 [6,6,4,4,4] 32 128 0.001 100 73.4 % 0.770

15.06.2018 89 Lamellen(7) 256 64 3 4 [6,6,6,4] 32 256 0.001 100 73.4 % 1.603

15.06.2018 113 Lamellen(7) 128 128 3 2 [6,6] 32 128 0.0001 100 73.4 % 2.286

15.06.2018 129 Lamellen(7) 128 128 3 2 [6,6] 32 256 0.0001 100 73.4 % 1.854

15.06.2018 130 Lamellen(7) 128 128 3 2 [6,4] 32 256 0.0001 100 73.4 % 1.641

15.06.2018 134 Lamellen(7) 128 128 3 3 [6,4,4] 32 256 0.0001 100 73.4 % 1.447

15.06.2018 146 Lamellen(7) 128 128 3 2 [6,4] 32 64 0.001 100 73.4 % 1.973

15.06.2018 149 Lamellen(7) 128 128 3 3 [6,6,4] 32 64 0.001 100 73.4 % 2.572

15.06.2018 178 Lamellen(7) 128 128 3 2 [6,4] 32 256 0.001 100 73.4 % 1.456

15.06.2018 9 Lamellen(7) 256 64 3 4 [6,6,6,4] 32 64 0.0001 100 73.0 % 1.176



15.06.2018 18 Lamellen(7) 256 64 3 2 [6,4] 32 128 0.0001 100 73.0 % 1.277

15.06.2018 29 Lamellen(7) 256 64 3 5 [6,6,6,6,4] 32 128 0.0001 100 73.0 % 1.225

15.06.2018 93 Lamellen(7) 256 64 3 5 [6,6,6,6,4] 32 256 0.001 100 73.0 % 0.960

15.06.2018 83 Lamellen(7) 256 64 3 2 [4,4] 32 256 0.001 100 72.7 % 1.514

15.06.2018 180 Lamellen(7) 128 128 3 2 [3,3] 32 256 0.001 100 72.7 % 1.693

15.06.2018 1 Lamellen(7) 256 64 3 2 [6,6] 32 64 0.0001 100 71.9 % 0.945

15.06.2018 3 Lamellen(7) 256 64 3 2 [4,4] 32 64 0.0001 100 71.9 % 0.863

15.06.2018 33 Lamellen(7) 256 64 3 2 [6,6] 32 256 0.0001 100 71.9 % 1.545

15.06.2018 82 Lamellen(7) 256 64 3 2 [6,4] 32 256 0.001 100 71.9 % 0.878

15.06.2018 13 Lamellen(7) 256 64 3 5 [6,6,6,6,4] 32 64 0.0001 100 71.5 % 1.033

15.06.2018 65 Lamellen(7) 256 64 3 2 [6,6] 32 128 0.001 100 71.5 % 2.007

15.06.2018 66 Lamellen(7) 256 64 3 2 [6,4] 32 128 0.001 100 71.1 % 0.883

15.06.2018 81 Lamellen(7) 256 64 3 2 [6,6] 32 256 0.001 100 71.1 % 0.905

15.06.2018 145 Lamellen(7) 128 128 3 2 [6,6] 32 64 0.001 100 71.1 % 2.375

15.06.2018 97 Lamellen(7) 128 128 3 2 [6,6] 32 64 0.0001 100 70.3 % 2.029

15.06.2018 114 Lamellen(7) 128 128 3 2 [6,4] 32 128 0.0001 100 70.3 % 0.960

15.06.2018 161 Lamellen(7) 128 128 3 2 [6,6] 32 128 0.001 100 70.3 % 1.938

15.06.2018 162 Lamellen(7) 128 128 3 2 [6,4] 32 128 0.001 100 70.3 % 2.375

15.06.2018 177 Lamellen(7) 128 128 3 2 [6,6] 32 256 0.001 100 70.3 % 1.702

15.06.2018 179 Lamellen(7) 128 128 3 2 [4,4] 32 256 0.001 100 70.3 % 1.413

15.06.2018 49 Lamellen(7) 256 64 3 2 [6,6] 32 64 0.001 100 69.9 % 1.588

15.06.2018 45 Lamellen(7) 256 64 3 5 [6,6,6,6,4] 32 256 0.0001 100 68.8 % 1.211




Date Test-number


Image size

Number of channels




Learning rate

Number of epochs

Validation accuracy

Validation loss

21.06.2018 6 Lamellen(7) 128 128 3 4 [4, 4, 3, 3] 32 256 0.00001 300 84.4 % 0.800

21.06.2018 4 Lamellen(7) 128 128 3 4 [4, 4, 3, 3] 32 64 0.00001 300 83.6 % 0.703

21.06.2018 18 Lamellen(7) 128 128 3 5 [3, 3, 3, 3, 3] 32 256 0.00001 300 82.8 % 0.792

21.06.2018 25 Lamellen(7) 128 128 3 5 [6, 6, 4, 4, 4] 32 64 0.00001 300 82.8 % 0.620

21.06.2018 12 Lamellen(7) 128 128 3 4 [6, 6, 4, 4] 32 256 0.00001 300 82.0 % 0.815

21.06.2018 17 Lamellen(7) 128 128 3 5 [3, 3, 3, 3, 3] 32 128 0.00001 300 82.0 % 0.744

21.06.2018 21 Lamellen(7) 128 128 3 5 [4, 4, 3, 3, 3] 32 256 0.00001 300 82.0 % 0.632

21.06.2018 3 Lamellen(7) 128 128 3 4 [3, 3, 3, 3] 32 256 0.00001 300 81.3 % 0.686

21.06.2018 14 Lamellen(7) 128 128 3 4 [6, 6, 6, 4] 32 128 0.00001 300 81.3 % 0.570

21.06.2018 2 Lamellen(7) 128 128 3 4 [3, 3, 3, 3] 32 128 0.00001 300 80.5 % 0.608

21.06.2018 5 Lamellen(7) 128 128 3 4 [4, 4, 3, 3] 32 128 0.00001 300 80.5 % 0.670

21.06.2018 9 Lamellen(7) 128 128 3 4 [4, 4, 4, 4] 32 256 0.00001 300 80.5 % 0.649

21.06.2018 8 Lamellen(7) 128 128 3 4 [4, 4, 4, 4] 32 128 0.00001 300 79.7 % 0.627

21.06.2018 10 Lamellen(7) 128 128 3 4 [6, 6, 4, 4] 32 64 0.00001 300 79.7 % 0.644

21.06.2018 15 Lamellen(7) 128 128 3 4 [6, 6, 6, 4] 32 256 0.00001 300 79.7 % 0.715

21.06.2018 20 Lamellen(7) 128 128 3 5 [4, 4, 3, 3, 3] 32 128 0.00001 300 79.7 % 0.676

21.06.2018 22 Lamellen(7) 128 128 3 5 [4, 4, 4, 4, 4] 32 64 0.00001 300 79.7 % 0.871

21.06.2018 23 Lamellen(7) 128 128 3 5 [4, 4, 4, 4, 4] 32 128 0.00001 300 79.7 % 0.622

21.06.2018 24 Lamellen(7) 128 128 3 5 [4, 4, 4, 4, 4] 32 256 0.00001 300 79.7 % 0.641

21.06.2018 26 Lamellen(7) 128 128 3 5 [6, 6, 4, 4, 4] 32 128 0.00001 300 79.7 % 0.740

21.06.2018 1 Lamellen(7) 128 128 3 4 [3, 3, 3, 3] 32 64 0.00001 300 78.9 % 0.647

21.06.2018 16 Lamellen(7) 128 128 3 5 [3, 3, 3, 3, 3] 32 64 0.00001 300 78.9 % 0.757

21.06.2018 19 Lamellen(7) 128 128 3 5 [4, 4, 3, 3, 3] 32 64 0.00001 300 78.9 % 0.666

21.06.2018 27 Lamellen(7) 128 128 3 5 [6, 6, 4, 4, 4] 32 256 0.00001 300 78.9 % 0.662

21.06.2018 28 Lamellen(7) 128 128 3 5 [6, 6, 6, 6, 4] 32 64 0.00001 300 78.9 % 0.750

21.06.2018 7 Lamellen(7) 128 128 3 4 [4, 4, 4, 4] 32 64 0.00001 300 78.1 % 0.656

21.06.2018 11 Lamellen(7) 128 128 3 4 [6, 6, 4, 4] 32 128 0.00001 300 78.1 % 0.737

21.06.2018 13 Lamellen(7) 128 128 3 4 [6, 6, 6, 4] 32 64 0.00001 300 76.6 % 0.750

21.06.2018 29 Lamellen(7) 128 128 3 5 [6, 6, 6, 6, 4] 32 128 0.00001 300 75.8 % 0.815

21.06.2018 30 Lamellen(7) 128 128 3 5 [6, 6, 6, 6, 4] 32 256 0.00001 300 73.4 % 0.880



Röhrlinge Testreihe 1

Date Test-number


Image size

Number of channels




Learning rate

Number of epochs

Validation accuracy

Validation loss

13.06.2018 4 Röhrling (8) 256 64 3 2 [4,4] 32 32 0.0001 100 62.9 % 1.093

13.06.2018 19 Röhrling (8) 256 64 3 3 [8,6,4] 32 64 0.0001 100 61.3 % 1.541

13.06.2018 36 Röhrling (8) 256 64 3 4 [8,6,4,4] 32 128 0.0001 100 61.3 % 1.105

13.06.2018 32 Röhrling (8) 256 64 3 3 [6,6,4] 32 128 0.0001 100 60.9 % 2.168

13.06.2018 24 Röhrling (8) 256 64 3 4 [8,6,4,4] 32 64 0.0001 100 60.2 % 1.685

13.06.2018 21 Röhrling (8) 256 64 3 4 [10,8,6,6] 32 64 0.0001 100 59.8 % 1.286

13.06.2018 72 Röhrling (8) 256 128 3 4 [8,6,4,4] 32 128 0.0001 100 59.8 % 1.246

13.06.2018 16 Röhrling (8) 256 64 3 2 [4,4] 32 64 0.0001 100 59.4 % 1.192

13.06.2018 35 Röhrling (8) 256 64 3 4 [8,6,6,4] 32 128 0.0001 100 59.4 % 1.185

13.06.2018 7 Röhrling (8) 256 64 3 3 [8,6,4] 32 32 0.0001 100 59.0 % 1.202

13.06.2018 8 Röhrling (8) 256 64 3 3 [6,6,4] 32 32 0.0001 100 59.0 % 1.187

13.06.2018 12 Röhrling (8) 256 64 3 4 [8,6,4,4] 32 32 0.0001 100 59.0 % 1.265

13.06.2018 23 Röhrling (8) 256 64 3 4 [8,6,6,4] 32 64 0.0001 100 59.0 % 1.358

13.06.2018 28 Röhrling (8) 256 64 3 2 [4,4] 32 128 0.0001 100 59.0 % 1.325

13.06.2018 71 Röhrling (8) 256 128 3 4 [8,6,6,4] 32 128 0.0001 100 59.0 % 1.672

13.06.2018 106 Röhrling (8) 256 256 3 4 [8,8,6,4] 32 128 0.0001 100 59.0 % 1.519

13.06.2018 20 Röhrling (8) 256 64 3 3 [6,6,4] 32 64 0.0001 100 58.6 % 1.483

13.06.2018 48 Röhrling (8) 256 128 3 4 [8,6,4,4] 32 32 0.0001 100 58.6 % 1.337

13.06.2018 59 Röhrling (8) 256 128 3 4 [8,6,6,4] 32 64 0.0001 100 58.6 % 2.192

13.06.2018 60 Röhrling (8) 256 128 3 4 [8,6,4,4] 32 64 0.0001 100 58.6 % 1.228

13.06.2018 94 Röhrling (8) 256 256 3 4 [8,8,6,4] 32 64 0.0001 100 58.6 % 1.853

13.06.2018 29 Röhrling (8) 256 64 3 3 [10,8,6] 32 128 0.0001 100 57.8 % 2.054

13.06.2018 33 Röhrling (8) 256 64 3 4 [10,8,6,6] 32 128 0.0001 100 57.8 % 1.222

13.06.2018 67 Röhrling (8) 256 128 3 3 [8,6,4] 32 128 0.0001 100 57.8 % 1.841

13.06.2018 10 Röhrling (8) 256 64 3 4 [8,8,6,4] 32 32 0.0001 100 57.4 % 1.668

13.06.2018 44 Röhrling (8) 256 128 3 3 [6,6,4] 32 32 0.0001 100 57.4 % 1.254

13.06.2018 5 Röhrling (8) 256 64 3 3 [10,8,6] 32 32 0.0001 100 57.0 % 1.908

13.06.2018 46 Röhrling (8) 256 128 3 4 [8,8,6,4] 32 32 0.0001 100 57.0 % 2.032

13.06.2018 95 Röhrling (8) 256 256 3 4 [8,6,6,4] 32 64 0.0001 100 57.0 % 1.833

13.06.2018 108 Röhrling (8) 256 256 3 4 [8,6,4,4] 32 128 0.0001 100 57.0 % 1.249

13.06.2018 47 Röhrling (8) 256 128 3 4 [8,6,6,4] 32 32 0.0001 100 56.2 % 1.529

13.06.2018 66 Röhrling (8) 256 128 3 3 [8,8,6] 32 128 0.0001 100 56.2 % 2.674

13.06.2018 107 Röhrling (8) 256 256 3 4 [8,6,6,4] 32 128 0.0001 100 56.2 % 1.441

13.06.2018 9 Röhrling (8) 256 64 3 4 [10,8,6,6] 32 32 0.0001 100 55.9 % 1.489

13.06.2018 15 Röhrling (8) 256 64 3 2 [6,6] 32 64 0.0001 100 55.9 % 1.250

13.06.2018 13 Röhrling (8) 256 64 3 2 [10,10] 32 64 0.0001 100 55.5 % 1.366

13.06.2018 31 Röhrling (8) 256 64 3 3 [8,6,4] 32 128 0.0001 100 55.5 % 2.120

13.06.2018 57 Röhrling (8) 256 128 3 4 [10,8,6,6] 32 64 0.0001 100 55.5 % 1.887



13.06.2018 65 Röhrling (8) 256 128 3 3 [10,8,6] 32 128 0.0001 100 55.5 % 3.032

13.06.2018 93 Röhrling (8) 256 256 3 4 [10,8,6,6] 32 64 0.0001 100 55.5 % 1.887

13.06.2018 96 Röhrling (8) 256 256 3 4 [8,6,4,4] 32 64 0.0001 100 55.5 % 1.448

13.06.2018 30 Röhrling (8) 256 64 3 3 [8,8,6] 32 128 0.0001 100 55.1 % 2.247

13.06.2018 82 Röhrling (8) 256 256 3 4 [8,8,6,4] 32 32 0.0001 100 55.1 % 1.631

13.06.2018 40 Röhrling (8) 256 128 3 2 [4,4] 32 32 0.0001 100 54.7 % 1.302

13.06.2018 41 Röhrling (8) 256 128 3 3 [10,8,6] 32 32 0.0001 100 54.7 % 2.590

13.06.2018 50 Röhrling (8) 256 128 3 2 [8,8] 32 64 0.0001 100 54.7 % 3.006

13.06.2018 58 Röhrling (8) 256 128 3 4 [8,8,6,4] 32 64 0.0001 100 54.7 % 2.268

13.06.2018 64 Röhrling (8) 256 128 3 2 [4,4] 32 128 0.0001 100 54.7 % 1.278

13.06.2018 11 Röhrling (8) 256 64 3 4 [8,6,6,4] 32 32 0.0001 100 54.3 % 1.361

13.06.2018 17 Röhrling (8) 256 64 3 3 [10,8,6] 32 64 0.0001 100 54.3 % 1.529

13.06.2018 26 Röhrling (8) 256 64 3 2 [8,8] 32 128 0.0001 100 54.3 % 2.378

13.06.2018 34 Röhrling (8) 256 64 3 4 [8,8,6,4] 32 128 0.0001 100 54.3 % 1.534

13.06.2018 68 Röhrling (8) 256 128 3 3 [6,6,4] 32 128 0.0001 100 54.3 % 2.227

13.06.2018 69 Röhrling (8) 256 128 3 4 [10,8,6,6] 32 128 0.0001 100 54.3 % 1.990

13.06.2018 70 Röhrling (8) 256 128 3 4 [8,8,6,4] 32 128 0.0001 100 54.3 % 1.259

13.06.2018 14 Röhrling (8) 256 64 3 2 [8,8] 32 64 0.0001 100 53.9 % 2.578

13.06.2018 101 Röhrling (8) 256 256 3 3 [10,8,6] 32 128 0.0001 100 53.9 % 3.532

13.06.2018 105 Röhrling (8) 256 256 3 4 [10,8,6,6] 32 128 0.0001 100 53.9 % 3.219

13.06.2018 27 Röhrling (8) 256 64 3 2 [6,6] 32 128 0.0001 100 53.5 % 1.924

13.06.2018 56 Röhrling (8) 256 128 3 3 [6,6,4] 32 64 0.0001 100 53.5 % 1.288

13.06.2018 43 Röhrling (8) 256 128 3 3 [8,6,4] 32 32 0.0001 100 53.1 % 1.433

13.06.2018 49 Röhrling (8) 256 128 3 2 [10,10] 32 64 0.0001 100 53.1 % 3.753

13.06.2018 103 Röhrling (8) 256 256 3 3 [8,6,4] 32 128 0.0001 100 53.1 % 1.507

13.06.2018 6 Röhrling (8) 256 64 3 3 [8,8,6] 32 32 0.0001 100 52.7 % 1.523

13.06.2018 22 Röhrling (8) 256 64 3 4 [8,8,6,4] 32 64 0.0001 100 52.7 % 1.296

13.06.2018 18 Röhrling (8) 256 64 3 3 [8,8,6] 32 64 0.0001 100 52.3 % 1.425

13.06.2018 62 Röhrling (8) 256 128 3 2 [8,8] 32 128 0.0001 100 52.3 % 3.041

13.06.2018 79 Röhrling (8) 256 256 3 3 [8,6,4] 32 32 0.0001 100 52.3 % 1.665

13.06.2018 25 Röhrling (8) 256 64 3 2 [10,10] 32 128 0.0001 100 52.0 % 2.379

13.06.2018 84 Röhrling (8) 256 256 3 4 [8,6,4,4] 32 32 0.0001 100 52.0 % 2.769

13.06.2018 3 Röhrling (8) 256 64 3 2 [6,6] 32 32 0.0001 100 51.6 % 1.366

13.06.2018 52 Röhrling (8) 256 128 3 2 [4,4] 32 64 0.0001 100 51.6 % 1.408

13.06.2018 90 Röhrling (8) 256 256 3 3 [8,8,6] 32 64 0.0001 100 51.6 % 1.603

13.06.2018 45 Röhrling (8) 256 128 3 4 [10,8,6,6] 32 32 0.0001 100 51.2 % 1.551

13.06.2018 54 Röhrling (8) 256 128 3 3 [8,8,6] 32 64 0.0001 100 51.2 % 2.436

13.06.2018 55 Röhrling (8) 256 128 3 3 [8,6,4] 32 64 0.0001 100 51.2 % 2.998

13.06.2018 81 Röhrling (8) 256 256 3 4 [10,8,6,6] 32 32 0.0001 100 51.2 % 1.821

13.06.2018 88 Röhrling (8) 256 256 3 2 [4,4] 32 64 0.0001 100 51.2 % 1.450

13.06.2018 92 Röhrling (8) 256 256 3 3 [6,6,4] 32 64 0.0001 100 51.2 % 2.674

13.06.2018 1 Röhrling (8) 256 64 3 2 [10,10] 32 32 0.0001 100 50.8 % 2.355

13.06.2018 2 Röhrling (8) 256 64 3 2 [8,8] 32 32 0.0001 100 50.8 % 1.794

13.06.2018 42 Röhrling (8) 256 128 3 3 [8,8,6] 32 32 0.0001 100 50.4 % 2.509



13.06.2018 104 Röhrling (8) 256 256 3 3 [6,6,4] 32 128 0.0001 100 50.4 % 3.049

13.06.2018 39 Röhrling (8) 256 128 3 2 [6,6] 32 32 0.0001 100 50.0 % 2.213

13.06.2018 51 Röhrling (8) 256 128 3 2 [6,6] 32 64 0.0001 100 50.0 % 2.029

13.06.2018 61 Röhrling (8) 256 128 3 2 [10,10] 32 128 0.0001 100 49.2 % 3.387

13.06.2018 63 Röhrling (8) 256 128 3 2 [6,6] 32 128 0.0001 100 49.2 % 3.289

13.06.2018 100 Röhrling (8) 256 256 3 2 [4,4] 32 128 0.0001 100 49.2 % 2.959

13.06.2018 53 Röhrling (8) 256 128 3 3 [10,8,6] 32 64 0.0001 100 48.4 % 3.534

13.06.2018 102 Röhrling (8) 256 256 3 3 [8,8,6] 32 128 0.0001 100 48.4 % 3.552

13.06.2018 38 Röhrling (8) 256 128 3 2 [8,8] 32 32 0.0001 100 48.0 % 2.758

13.06.2018 83 Röhrling (8) 256 256 3 4 [8,6,6,4] 32 32 0.0001 100 48.0 % 1.543

13.06.2018 85 Röhrling (8) 256 256 3 2 [10,10] 32 64 0.0001 100 48.0 % 4.787

13.06.2018 97 Röhrling (8) 256 256 3 2 [10,10] 32 128 0.0001 100 48.0 % 4.069

13.06.2018 98 Röhrling (8) 256 256 3 2 [8,8] 32 128 0.0001 100 48.0 % 4.046

13.06.2018 37 Röhrling (8) 256 128 3 2 [10,10] 32 32 0.0001 100 47.7 % 2.125

13.06.2018 80 Röhrling (8) 256 256 3 3 [6,6,4] 32 32 0.0001 100 47.7 % 1.521

13.06.2018 89 Röhrling (8) 256 256 3 3 [10,8,6] 32 64 0.0001 100 47.7 % 3.023

13.06.2018 87 Röhrling (8) 256 256 3 2 [6,6] 32 64 0.0001 100 47.3 % 4.059

13.06.2018 76 Röhrling (8) 256 256 3 2 [4,4] 32 32 0.0001 100 46.5 % 1.606

13.06.2018 91 Röhrling (8) 256 256 3 3 [8,6,4] 32 64 0.0001 100 46.5 % 1.791

13.06.2018 99 Röhrling (8) 256 256 3 2 [6,6] 32 128 0.0001 100 46.5 % 3.245

13.06.2018 77 Röhrling (8) 256 256 3 3 [10,8,6] 32 32 0.0001 100 45.7 % 2.067

13.06.2018 86 Röhrling (8) 256 256 3 2 [8,8] 32 64 0.0001 100 45.7 % 4.246

13.06.2018 73 Röhrling (8) 256 256 3 2 [10,10] 32 32 0.0001 100 44.1 % 1.722

13.06.2018 74 Röhrling (8) 256 256 3 2 [8,8] 32 32 0.0001 100 43.4 % 2.460

13.06.2018 75 Röhrling (8) 256 256 3 2 [6,6] 32 32 0.0001 100 43.4 % 4.346

13.06.2018 78 Röhrling (8) 256 256 3 3 [8,8,6] 32 32 0.0001 100 43.0 % 3.161




Date Test-number


Image size

Number of channels




Learning rate

Number of epochs

Validation accuracy

Validation loss

15.06.2018 60 Röhrling (8) 256 64 3 5 [3, 3, 3, 3, 3] 32 128 0.0001 100 69.5 % 0.971

15.06.2018 92 Röhrling (8) 256 64 3 5 [3, 3, 3, 3, 3] 64 256 0.0001 100 66.4 % 0.994

15.06.2018 156 Röhrling (8) 256 128 3 5 [3, 3, 3, 3, 3] 32 128 0.0001 100 66.4 % 0.976

15.06.2018 96 Röhrling (8) 256 64 3 5 [3, 3, 3, 3, 3] 64 256 0.00001 100 66.0 % 1.049

15.06.2018 17 Röhrling (8) 256 64 3 4 [3, 3, 3, 3 ] 32 256 0.0001 100 66.0 % 1.006

15.06.2018 68 Röhrling (8) 256 64 3 5 [3, 3, 3, 3, 3] 32 256 0.0001 100 65.6 % 1.047

15.06.2018 20 Röhrling (8) 256 64 3 4 [6, 6, 6, 4] 32 256 0.0001 100 65.6 % 1.020

15.06.2018 2 Röhrling (8) 256 64 3 4 [4, 4, 4, 4] 32 64 0.0001 100 65.2 % 1.159

15.06.2018 51 Röhrling (8) 256 64 3 5 [4, 4, 4, 4, 4] 32 64 0.0001 100 65.2 % 0.927

15.06.2018 167 Röhrling (8) 256 128 3 5 [4, 4, 4, 4, 4] 32 256 0.00001 100 64.4 % 1.046

15.06.2018 33 Röhrling (8) 256 64 3 4 [3, 3, 3, 3 ] 64 128 0.0001 100 64.4 % 1.034

15.06.2018 41 Röhrling (8) 256 64 3 4 [3, 3, 3, 3 ] 64 256 0.0001 100 64.1 % 1.917

15.06.2018 34 Röhrling (8) 256 64 3 4 [4, 4, 4, 4] 64 128 0.0001 100 64.1 % 1.252

15.06.2018 148 Röhrling (8) 256 128 3 5 [3, 3, 3, 3, 3] 32 64 0.0001 100 64.1 % 1.185

15.06.2018 130 Röhrling (8) 256 128 3 4 [4, 4, 4, 4] 64 128 0.0001 100 63.7 % 1.820

15.06.2018 107 Röhrling (8) 256 128 3 4 [6, 6, 4, 4] 32 128 0.0001 100 63.7 % 1.531

15.06.2018 180 Röhrling (8) 256 128 3 5 [3, 3, 3, 3, 3] 64 128 0.0001 100 63.7 % 1.060

15.06.2018 76 Röhrling (8) 256 64 3 5 [3, 3, 3, 3, 3] 64 64 0.0001 100 63.7 % 1.058

15.06.2018 163 Röhrling (8) 256 128 3 5 [4, 4, 4, 4, 4] 32 256 0.0001 100 63.7 % 1.035

15.06.2018 18 Röhrling (8) 256 64 3 4 [4, 4, 4, 4] 32 256 0.0001 100 63.7 % 1.022

15.06.2018 129 Röhrling (8) 256 128 3 4 [3, 3, 3, 3 ] 64 128 0.0001 100 63.3 % 1.285

15.06.2018 147 Röhrling (8) 256 128 3 5 [4, 4, 4, 4, 4] 32 64 0.0001 100 63.3 % 1.248

15.06.2018 145 Röhrling (8) 256 128 3 5 [6, 6, 6, 6, 4] 32 64 0.0001 100 62.9 % 1.418

15.06.2018 97 Röhrling (8) 256 128 3 4 [3, 3, 3, 3 ] 32 64 0.0001 100 62.9 % 1.263

15.06.2018 4 Röhrling (8) 256 64 3 4 [6, 6, 6, 4] 32 64 0.0001 100 62.9 % 1.239

15.06.2018 188 Röhrling (8) 256 128 3 5 [3, 3, 3, 3, 3] 64 256 0.0001 100 62.9 % 1.136

15.06.2018 1 Röhrling (8) 256 64 3 4 [3, 3, 3, 3 ] 32 64 0.0001 100 62.9 % 1.052

15.06.2018 88 Röhrling (8) 256 64 3 5 [3, 3, 3, 3, 3] 64 128 0.00001 100 62.9 % 1.049

15.06.2018 67 Röhrling (8) 256 64 3 5 [4, 4, 4, 4, 4] 32 256 0.0001 100 62.9 % 1.015

15.06.2018 98 Röhrling (8) 256 128 3 4 [4, 4, 4, 4] 32 64 0.0001 100 62.5 % 1.192

15.06.2018 161 Röhrling (8) 256 128 3 5 [6, 6, 6, 6, 4] 32 256 0.0001 100 62.5 % 1.192

15.06.2018 25 Röhrling (8) 256 64 3 4 [3, 3, 3, 3 ] 64 64 0.0001 100 62.5 % 1.040

15.06.2018 65 Röhrling (8) 256 64 3 5 [6, 6, 6, 6, 4] 32 256 0.0001 100 62.1 % 1.594

15.06.2018 64 Röhrling (8) 256 64 3 5 [3, 3, 3, 3, 3] 32 128 0.00001 100 62.1 % 1.075

15.06.2018 113 Röhrling (8) 256 128 3 4 [3, 3, 3, 3 ] 32 256 0.0001 100 62.1 % 1.072

15.06.2018 11 Röhrling (8) 256 64 3 4 [6, 6, 4, 4] 32 128 0.0001 100 62.1 % 1.055

15.06.2018 164 Röhrling (8) 256 128 3 5 [3, 3, 3, 3, 3] 32 256 0.0001 100 62.1 % 1.028

15.06.2018 146 Röhrling (8) 256 128 3 5 [6, 6, 4, 4, 4] 32 64 0.0001 100 61.7 % 1.503



15.06.2018 114 Röhrling (8) 256 128 3 4 [4, 4, 4, 4] 32 256 0.0001 100 61.7 % 1.249

15.06.2018 176 Röhrling (8) 256 128 3 5 [3, 3, 3, 3, 3] 64 64 0.00001 100 61.7 % 1.209

15.06.2018 71 Röhrling (8) 256 64 3 5 [4, 4, 4, 4, 4] 32 256 0.00001 100 61.7 % 1.098

15.06.2018 192 Röhrling (8) 256 128 3 5 [3, 3, 3, 3, 3] 64 256 0.00001 100 61.7 % 1.09

15.06.2018 184 Röhrling (8) 256 128 3 5 [3, 3, 3, 3, 3] 64 128 0.00001 100 61.7 % 1.089

15.06.2018 52 Röhrling (8) 256 64 3 5 [3, 3, 3, 3, 3] 32 64 0.0001 100 61.7 % 1.083

15.06.2018 137 Röhrling (8) 256 128 3 4 [3, 3, 3, 3 ] 64 256 0.0001 100 61.3 % 1.422

15.06.2018 155 Röhrling (8) 256 128 3 5 [4, 4, 4, 4, 4] 32 128 0.0001 100 61.3 % 1.316

15.06.2018 117 Röhrling (8) 256 128 3 4 [3, 3, 3, 3 ] 32 256 0.00001 100 61.3 % 1.093

15.06.2018 84 Röhrling (8) 256 64 3 5 [3, 3, 3, 3, 3] 64 128 0.0001 100 60.9 % 1.521

15.06.2018 58 Röhrling (8) 256 64 3 5 [6, 6, 4, 4, 4] 32 128 0.0001 100 60.9 % 1.432

15.06.2018 57 Röhrling (8) 256 64 3 5 [6, 6, 6, 6, 4] 32 128 0.0001 100 60.9 % 1.272

15.06.2018 9 Röhrling (8) 256 64 3 4 [3, 3, 3, 3 ] 32 128 0.0001 100 60.9 % 1.223

15.06.2018 153 Röhrling (8) 256 128 3 5 [6, 6, 6, 6, 4] 32 128 0.0001 100 60.9 % 1.179

15.06.2018 108 Röhrling (8) 256 128 3 4 [6, 6, 6, 4] 32 128 0.0001 100 60.5 % 1.188

15.06.2018 191 Röhrling (8) 256 128 3 5 [4, 4, 4, 4, 4] 64 256 0.00001 100 60.5 % 1.163

15.06.2018 168 Röhrling (8) 256 128 3 5 [3, 3, 3, 3, 3] 32 256 0.00001 100 60.5 % 0.994

15.06.2018 91 Röhrling (8) 256 64 3 5 [4, 4, 4, 4, 4] 64 256 0.0001 100 60.2 % 1.896

15.06.2018 42 Röhrling (8) 256 64 3 4 [4, 4, 4, 4] 64 256 0.0001 100 60.2 % 1.697

15.06.2018 162 Röhrling (8) 256 128 3 5 [6, 6, 4, 4, 4] 32 256 0.0001 100 60.2 % 1.469

15.06.2018 100 Röhrling (8) 256 128 3 4 [6, 6, 6, 4] 32 64 0.0001 100 60.2 % 1.200

15.06.2018 80 Röhrling (8) 256 64 3 5 [3, 3, 3, 3, 3] 64 64 0.00001 100 60.2 % 1.167

15.06.2018 172 Röhrling (8) 256 128 3 5 [3, 3, 3, 3, 3] 64 64 0.0001 100 60.2 % 1.139

15.06.2018 105 Röhrling (8) 256 128 3 4 [3, 3, 3, 3 ] 32 128 0.0001 100 60.2 % 1.071

15.06.2018 121 Röhrling (8) 256 128 3 4 [3, 3, 3, 3 ] 64 64 0.0001 100 59.8 % 1.422

15.06.2018 59 Röhrling (8) 256 64 3 5 [4, 4, 4, 4, 4] 32 128 0.0001 100 59.8 % 1.352

15.06.2018 83 Röhrling (8) 256 64 3 5 [4, 4, 4, 4, 4] 64 128 0.0001 100 59.8 % 1.128

15.06.2018 21 Röhrling (8) 256 64 3 4 [3, 3, 3, 3 ] 32 256 0.00001 100 59.8 % 1.087

15.06.2018 179 Röhrling (8) 256 128 3 5 [4, 4, 4, 4, 4] 64 128 0.0001 100 59.4 % 1.453

15.06.2018 75 Röhrling (8) 256 64 3 5 [4, 4, 4, 4, 4] 64 64 0.0001 100 59.4 % 1.269

15.06.2018 49 Röhrling (8) 256 64 3 5 [6, 6, 6, 6, 4] 32 64 0.0001 100 59.4 % 1.171

15.06.2018 160 Röhrling (8) 256 128 3 5 [3, 3, 3, 3, 3] 32 128 0.00001 100 59.4 % 1.061

15.06.2018 187 Röhrling (8) 256 128 3 5 [4, 4, 4, 4, 4] 64 256 0.0001 100 59.0 % 1.248

15.06.2018 151 Röhrling (8) 256 128 3 5 [4, 4, 4, 4, 4] 32 64 0.00001 100 59.0 % 1.248

15.06.2018 118 Röhrling (8) 256 128 3 4 [4, 4, 4, 4] 32 256 0.00001 100 59.0 % 1.127

15.06.2018 43 Röhrling (8) 256 64 3 4 [6, 6, 4, 4] 64 256 0.0001 100 58.6 % 2.130

15.06.2018 171 Röhrling (8) 256 128 3 5 [4, 4, 4, 4, 4] 64 64 0.0001 100 58.6 % 1.590

15.06.2018 66 Röhrling (8) 256 64 3 5 [6, 6, 4, 4, 4] 32 256 0.0001 100 58.6 % 1.508

15.06.2018 154 Röhrling (8) 256 128 3 5 [6, 6, 4, 4, 4] 32 128 0.0001 100 58.6 % 1.242

15.06.2018 166 Röhrling (8) 256 128 3 5 [6, 6, 4, 4, 4] 32 256 0.00001 100 58.6 % 1.180

15.06.2018 141 Röhrling (8) 256 128 3 4 [3, 3, 3, 3 ] 64 256 0.00001 100 58.6 % 1.178

15.06.2018 61 Röhrling (8) 256 64 3 5 [6, 6, 6, 6, 4] 32 128 0.00001 100 58.6 % 1.160

15.06.2018 37 Röhrling (8) 256 64 3 4 [3, 3, 3, 3 ] 64 128 0.00001 100 58.6 % 1.081

15.06.2018 116 Röhrling (8) 256 128 3 4 [6, 6, 6, 4] 32 256 0.0001 100 58.2 % 1.329



15.06.2018 183 Röhrling (8) 256 128 3 5 [4, 4, 4, 4, 4] 64 128 0.00001 100 58.2 % 1.258

15.06.2018 95 Röhrling (8) 256 64 3 5 [4, 4, 4, 4, 4] 64 256 0.00001 100 58.2 % 1.113

15.06.2018 22 Röhrling (8) 256 64 3 4 [4, 4, 4, 4] 32 256 0.00001 100 58.2 % 1.085

15.06.2018 101 Röhrling (8) 256 128 3 4 [3, 3, 3, 3 ] 32 64 0.00001 100 57.8 % 1.204

15.06.2018 12 Röhrling (8) 256 64 3 4 [6, 6, 6, 4] 32 128 0.0001 100 57.8 % 1.189

15.06.2018 120 Röhrling (8) 256 128 3 4 [6, 6, 6, 4] 32 256 0.00001 100 57.8 % 1.173

15.06.2018 50 Röhrling (8) 256 64 3 5 [6, 6, 4, 4, 4] 32 64 0.0001 100 57.8 % 1.171

15.06.2018 45 Röhrling (8) 256 64 3 4 [3, 3, 3, 3 ] 64 256 0.00001 100 57.8 % 1.164

15.06.2018 109 Röhrling (8) 256 128 3 4 [3, 3, 3, 3 ] 32 128 0.00001 100 57.8 % 1.154

15.06.2018 29 Röhrling (8) 256 64 3 4 [3, 3, 3, 3 ] 64 64 0.00001 100 57.8 % 1.145

15.06.2018 185 Röhrling (8) 256 128 3 5 [6, 6, 6, 6, 4] 64 256 0.0001 100 57.4 % 1.795

15.06.2018 26 Röhrling (8) 256 64 3 4 [4, 4, 4, 4] 64 64 0.0001 100 57.4 % 1.296

15.06.2018 106 Röhrling (8) 256 128 3 4 [4, 4, 4, 4] 32 128 0.0001 100 57.4 % 1.227

15.06.2018 72 Röhrling (8) 256 64 3 5 [3, 3, 3, 3, 3] 32 256 0.00001 100 57.4 % 1.120

15.06.2018 139 Röhrling (8) 256 128 3 4 [6, 6, 4, 4] 64 256 0.0001 100 57.0 % 2.623

15.06.2018 36 Röhrling (8) 256 64 3 4 [6, 6, 6, 4] 64 128 0.0001 100 57.0 % 1.438

15.06.2018 89 Röhrling (8) 256 64 3 5 [6, 6, 6, 6, 4] 64 256 0.0001 100 57.0 % 1.359

15.06.2018 53 Röhrling (8) 256 64 3 5 [6, 6, 6, 6, 4] 32 64 0.00001 100 56.6 % 1.324

15.06.2018 38 Röhrling (8) 256 64 3 4 [4, 4, 4, 4] 64 128 0.00001 100 56.6 % 1.216

15.06.2018 6 Röhrling (8) 256 64 3 4 [4, 4, 4, 4] 32 64 0.00001 100 56.6 % 1.191

15.06.2018 159 Röhrling (8) 256 128 3 5 [4, 4, 4, 4, 4] 32 128 0.00001 100 56.6 % 1.172

15.06.2018 69 Röhrling (8) 256 64 3 5 [6, 6, 6, 6, 4] 32 256 0.00001 100 56.6 % 1.138

15.06.2018 138 Röhrling (8) 256 128 3 4 [4, 4, 4, 4] 64 256 0.0001 100 56.3 % 2.954

15.06.2018 82 Röhrling (8) 256 64 3 5 [6, 6, 4, 4, 4] 64 128 0.0001 100 56.3 % 1.269

15.06.2018 70 Röhrling (8) 256 64 3 5 [6, 6, 4, 4, 4] 32 256 0.00001 100 56.3 % 1.225

15.06.2018 10 Röhrling (8) 256 64 3 4 [4, 4, 4, 4] 32 128 0.0001 100 56.3 % 1.221

15.06.2018 125 Röhrling (8) 256 128 3 4 [3, 3, 3, 3 ] 64 64 0.00001 100 56.3 % 1.204

15.06.2018 133 Röhrling (8) 256 128 3 4 [3, 3, 3, 3 ] 64 128 0.00001 100 56.3 % 1.162

15.06.2018 132 Röhrling (8) 256 128 3 4 [6, 6, 6, 4] 64 128 0.0001 100 55.9 % 2.545

15.06.2018 178 Röhrling (8) 256 128 3 5 [6, 6, 4, 4, 4] 64 128 0.0001 100 55.9 % 1.789

15.06.2018 55 Röhrling (8) 256 64 3 5 [4, 4, 4, 4, 4] 32 64 0.00001 100 55.9 % 1.371

15.06.2018 158 Röhrling (8) 256 128 3 5 [6, 6, 4, 4, 4] 32 128 0.00001 100 55.9 % 1.211

15.06.2018 157 Röhrling (8) 256 128 3 5 [6, 6, 6, 6, 4] 32 128 0.00001 100 55.9 % 1.196

15.06.2018 111 Röhrling (8) 256 128 3 4 [6, 6, 4, 4] 32 128 0.00001 100 55.9 % 1.188

15.06.2018 152 Röhrling (8) 256 128 3 5 [3, 3, 3, 3, 3] 32 64 0.00001 100 55.9 % 1.180

15.06.2018 44 Röhrling (8) 256 64 3 4 [6, 6, 6, 4] 64 256 0.0001 100 55.5 % 2.194

15.06.2018 3 Röhrling (8) 256 64 3 4 [6, 6, 4, 4] 32 64 0.0001 100 55.5 % 1.563

15.06.2018 150 Röhrling (8) 256 128 3 5 [6, 6, 4, 4, 4] 32 64 0.00001 100 55.5 % 1.313

15.06.2018 94 Röhrling (8) 256 64 3 5 [6, 6, 4, 4, 4] 64 256 0.00001 100 55.5 % 1.270

15.06.2018 14 Röhrling (8) 256 64 3 4 [4, 4, 4, 4] 32 128 0.00001 100 55.5 % 1.238

15.06.2018 28 Röhrling (8) 256 64 3 4 [6, 6, 6, 4] 64 64 0.0001 100 55.1 % 2.491

15.06.2018 115 Röhrling (8) 256 128 3 4 [6, 6, 4, 4] 32 256 0.0001 100 55.1 % 2.000

15.06.2018 27 Röhrling (8) 256 64 3 4 [6, 6, 4, 4] 64 64 0.0001 100 55.1 % 1.333

15.06.2018 16 Röhrling (8) 256 64 3 4 [6, 6, 6, 4] 32 128 0.00001 100 55.1 % 1.252



15.06.2018 90 Röhrling (8) 256 64 3 5 [6, 6, 4, 4, 4] 64 256 0.0001 100 55.1 % 1.232

15.06.2018 13 Röhrling (8) 256 64 3 4 [3, 3, 3, 3 ] 32 128 0.00001 100 55.1 % 1.218

15.06.2018 123 Röhrling (8) 256 128 3 4 [6, 6, 4, 4] 64 64 0.0001 100 54.7 % 1.551

15.06.2018 102 Röhrling (8) 256 128 3 4 [4, 4, 4, 4] 32 64 0.00001 100 54.7 % 1.188

15.06.2018 35 Röhrling (8) 256 64 3 4 [6, 6, 4, 4] 64 128 0.0001 100 54.3 % 1.766

15.06.2018 19 Röhrling (8) 256 64 3 4 [6, 6, 4, 4] 32 256 0.0001 100 54.3 % 1.398

15.06.2018 112 Röhrling (8) 256 128 3 4 [6, 6, 6, 4] 32 128 0.00001 100 54.3 % 1.232

15.06.2018 73 Röhrling (8) 256 64 3 5 [6, 6, 6, 6, 4] 64 64 0.0001 100 53.9 % 2.519

15.06.2018 134 Röhrling (8) 256 128 3 4 [4, 4, 4, 4] 64 128 0.00001 100 53.9 % 1.335

15.06.2018 46 Röhrling (8) 256 64 3 4 [4, 4, 4, 4] 64 256 0.00001 100 53.9 % 1.291

15.06.2018 175 Röhrling (8) 256 128 3 5 [4, 4, 4, 4, 4] 64 64 0.00001 100 53.9 % 1.287

15.06.2018 62 Röhrling (8) 256 64 3 5 [6, 6, 4, 4, 4] 32 128 0.00001 100 53.9 % 1.227

15.06.2018 140 Röhrling (8) 256 128 3 4 [6, 6, 6, 4] 64 256 0.0001 100 53.5 % 3.321

15.06.2018 186 Röhrling (8) 256 128 3 5 [6, 6, 4, 4, 4] 64 256 0.0001 100 53.5 % 2.100

15.06.2018 177 Röhrling (8) 256 128 3 5 [6, 6, 6, 6, 4] 64 128 0.0001 100 53.5 % 1.667

15.06.2018 54 Röhrling (8) 256 64 3 5 [6, 6, 4, 4, 4] 32 64 0.00001 100 53.5 % 1.258

15.06.2018 104 Röhrling (8) 256 128 3 4 [6, 6, 6, 4] 32 64 0.00001 100 53.5 % 1.221

15.06.2018 63 Röhrling (8) 256 64 3 5 [4, 4, 4, 4, 4] 32 128 0.00001 100 53.5 % 1.161

15.06.2018 122 Röhrling (8) 256 128 3 4 [4, 4, 4, 4] 64 64 0.0001 100 53.1 % 1.914

15.06.2018 74 Röhrling (8) 256 64 3 5 [6, 6, 4, 4, 4] 64 64 0.0001 100 53.1 % 1.888

15.06.2018 15 Röhrling (8) 256 64 3 4 [6, 6, 4, 4] 32 128 0.00001 100 53.1 % 1.232

15.06.2018 81 Röhrling (8) 256 64 3 5 [6, 6, 6, 6, 4] 64 128 0.0001 100 52.7 % 2.917

15.06.2018 169 Röhrling (8) 256 128 3 5 [6, 6, 6, 6, 4] 64 64 0.0001 100 52.7 % 1.909

15.06.2018 131 Röhrling (8) 256 128 3 4 [6, 6, 4, 4] 64 128 0.0001 100 52.7 % 1.737

15.06.2018 99 Röhrling (8) 256 128 3 4 [6, 6, 4, 4] 32 64 0.0001 100 52.7 % 1.693

15.06.2018 86 Röhrling (8) 256 64 3 5 [6, 6, 4, 4, 4] 64 128 0.00001 100 52.7 % 1.373

15.06.2018 165 Röhrling (8) 256 128 3 5 [6, 6, 6, 6, 4] 32 256 0.00001 100 52.7 % 1.346

15.06.2018 7 Röhrling (8) 256 64 3 4 [6, 6, 4, 4] 32 64 0.00001 100 52.7 % 1.292

15.06.2018 23 Röhrling (8) 256 64 3 4 [6, 6, 4, 4] 32 256 0.00001 100 52.7 % 1.280

15.06.2018 79 Röhrling (8) 256 64 3 5 [4, 4, 4, 4, 4] 64 64 0.00001 100 52.7 % 1.252

15.06.2018 124 Röhrling (8) 256 128 3 4 [6, 6, 6, 4] 64 64 0.0001 100 52.3 % 2.268

15.06.2018 87 Röhrling (8) 256 64 3 5 [4, 4, 4, 4, 4] 64 128 0.00001 100 52.3 % 1.304

15.06.2018 56 Röhrling (8) 256 64 3 5 [3, 3, 3, 3, 3] 32 64 0.00001 100 52.3 % 1.292

15.06.2018 5 Röhrling (8) 256 64 3 4 [3, 3, 3, 3 ] 32 64 0.00001 100 52.3 % 1.285

15.06.2018 30 Röhrling (8) 256 64 3 4 [4, 4, 4, 4] 64 64 0.00001 100 52.0 % 1.413

15.06.2018 170 Röhrling (8) 256 128 3 5 [6, 6, 4, 4, 4] 64 64 0.0001 100 51.6 % 2.628

15.06.2018 119 Röhrling (8) 256 128 3 4 [6, 6, 4, 4] 32 256 0.00001 100 51.6 % 1.352

15.06.2018 149 Röhrling (8) 256 128 3 5 [6, 6, 6, 6, 4] 32 64 0.00001 100 51.2 % 1.286

15.06.2018 32 Röhrling (8) 256 64 3 4 [6, 6, 6, 4] 64 64 0.00001 100 51.1 % 1.473

15.06.2018 24 Röhrling (8) 256 64 3 4 [6, 6, 6, 4] 32 256 0.00001 100 51.1 % 1.175

15.06.2018 77 Röhrling (8) 256 64 3 5 [6, 6, 6, 6, 4] 64 64 0.00001 100 50.8 % 1.339

15.06.2018 8 Röhrling (8) 256 64 3 4 [6, 6, 6, 4] 32 64 0.00001 100 50.8 % 1.321

15.06.2018 39 Röhrling (8) 256 64 3 4 [6, 6, 4, 4] 64 128 0.00001 100 50.4 % 1.569

15.06.2018 47 Röhrling (8) 256 64 3 4 [6, 6, 4, 4] 64 256 0.00001 100 50.4 % 1.435



15.06.2018 40 Röhrling (8) 256 64 3 4 [6, 6, 6, 4] 64 128 0.00001 100 50.4 % 1.343

15.06.2018 110 Röhrling (8) 256 128 3 4 [4, 4, 4, 4] 32 128 0.00001 100 49.6 % 1.266

15.06.2018 31 Röhrling (8) 256 64 3 4 [6, 6, 4, 4] 64 64 0.00001 100 49.2 % 1.520

15.06.2018 142 Röhrling (8) 256 128 3 4 [4, 4, 4, 4] 64 256 0.00001 100 49.2 % 1.443

15.06.2018 136 Röhrling (8) 256 128 3 4 [6, 6, 6, 4] 64 128 0.00001 100 48.8 % 1.528

15.06.2018 182 Röhrling (8) 256 128 3 5 [6, 6, 4, 4, 4] 64 128 0.00001 100 48.8 % 1.405

15.06.2018 143 Röhrling (8) 256 128 3 4 [6, 6, 4, 4] 64 256 0.00001 100 48.4 % 1.584

15.06.2018 174 Röhrling (8) 256 128 3 5 [6, 6, 4, 4, 4] 64 64 0.00001 100 48.0 % 1.460

15.06.2018 48 Röhrling (8) 256 64 3 4 [6, 6, 6, 4] 64 256 0.00001 100 47.7 % 1.609

15.06.2018 78 Röhrling (8) 256 64 3 5 [6, 6, 4, 4, 4] 64 64 0.00001 100 47.7 % 1.472

15.06.2018 126 Röhrling (8) 256 128 3 4 [4, 4, 4, 4] 64 64 0.00001 100 46.9 % 1.413

15.06.2018 85 Röhrling (8) 256 64 3 5 [6, 6, 6, 6, 4] 64 128 0.00001 100 46.5 % 1.685

15.06.2018 128 Röhrling (8) 256 128 3 4 [6, 6, 6, 4] 64 64 0.00001 100 46.1 % 1.593

15.06.2018 93 Röhrling (8) 256 64 3 5 [6, 6, 6, 6, 4] 64 256 0.00001 100 46.1 % 1.547

15.06.2018 103 Röhrling (8) 256 128 3 4 [6, 6, 4, 4] 32 64 0.00001 100 46.1 % 1.503

15.06.2018 144 Röhrling (8) 256 128 3 4 [6, 6, 6, 4] 64 256 0.00001 100 45.3 % 1.959

15.06.2018 173 Röhrling (8) 256 128 3 5 [6, 6, 6, 6, 4] 64 64 0.00001 100 44.9 % 1.520

15.06.2018 135 Röhrling (8) 256 128 3 4 [6, 6, 4, 4] 64 128 0.00001 100 44.5 % 1.663

15.06.2018 127 Röhrling (8) 256 128 3 4 [6, 6, 4, 4] 64 64 0.00001 100 44.1 % 1.622

15.06.2018 189 Röhrling (8) 256 128 3 5 [6, 6, 6, 6, 4] 64 256 0.00001 100 43.8 % 2.163

15.06.2018 181 Röhrling (8) 256 128 3 5 [6, 6, 6, 6, 4] 64 128 0.00001 100 43.8 % 1.736

15.06.2018 190 Röhrling (8) 256 128 3 5 [6, 6, 4, 4, 4] 64 256 0.00001 100 43.0 % 1.622




Date Test-number


Image size

Number of channels




Learning rate

Number of epochs

Validation accuracy

Validation loss

21.06.2018 47 Röhrling (8) 128 128 3 5 [3, 3, 3, 3, 3 ] 32 128 0.00001 300 75.0 % 0.879

21.06.2018 51 Röhrling (8) 128 128 3 5 [4, 4, 3, 3, 3 ] 32 256 0.00001 300 75.0 % 0.862

21.06.2018 21 Röhrling (8) 128 64 3 5 [4, 4, 3, 3, 3 ] 32 256 0.00001 300 73.4 % 0.908

21.06.2018 50 Röhrling (8) 128 128 3 5 [4, 4, 3, 3, 3 ] 32 128 0.00001 300 73.4 % 0.838

21.06.2018 6 Röhrling (8) 128 64 3 4 [4, 4, 3, 3] 32 256 0.00001 300 72.7 % 0.912

21.06.2018 31 Röhrling (8) 128 128 3 4 [3, 3, 3, 3 ] 32 64 0.00001 300 72.7 % 0.859

21.06.2018 49 Röhrling (8) 128 128 3 5 [4, 4, 3, 3, 3 ] 32 64 0.00001 300 72.7 % 0.835

21.06.2018 1 Röhrling (8) 128 64 3 4 [3, 3, 3, 3 ] 32 64 0.00001 300 71.9 % 0.860

21.06.2018 18 Röhrling (8) 128 64 3 5 [3, 3, 3, 3, 3 ] 32 256 0.00001 300 71.9 % 0.912

21.06.2018 32 Röhrling (8) 128 128 3 4 [3, 3, 3, 3 ] 32 128 0.00001 300 71.1 % 0.960

21.06.2018 33 Röhrling (8) 128 128 3 4 [3, 3, 3, 3 ] 32 256 0.00001 300 71.1 % 0.870

21.06.2018 35 Röhrling (8) 128 128 3 4 [4, 4, 3, 3] 32 128 0.00001 300 71.1 % 0.943

21.06.2018 46 Röhrling (8) 128 128 3 5 [3, 3, 3, 3, 3 ] 32 64 0.00001 300 71.1 % 0.907

21.06.2018 54 Röhrling (8) 128 128 3 5 [4, 4, 4, 4, 4] 32 256 0.00001 300 71.1 % 0.972

21.06.2018 2 Röhrling (8) 128 64 3 4 [3, 3, 3, 3 ] 32 128 0.00001 300 70.3 % 0.884

21.06.2018 3 Röhrling (8) 128 64 3 4 [3, 3, 3, 3 ] 32 256 0.00001 300 70.3 % 0.984

21.06.2018 5 Röhrling (8) 128 64 3 4 [4, 4, 3, 3] 32 128 0.00001 300 70.3 % 0.916

21.06.2018 7 Röhrling (8) 128 64 3 4 [4, 4, 4, 4] 32 64 0.00001 300 70.3 % 0.938

21.06.2018 9 Röhrling (8) 128 64 3 4 [4, 4, 4, 4] 32 256 0.00001 300 70.3 % 1.015

21.06.2018 17 Röhrling (8) 128 64 3 5 [3, 3, 3, 3, 3 ] 32 128 0.00001 300 70.3 % 0.962

21.06.2018 19 Röhrling (8) 128 64 3 5 [4, 4, 3, 3, 3 ] 32 64 0.00001 300 70.3 % 0.932

21.06.2018 23 Röhrling (8) 128 64 3 5 [4, 4, 4, 4, 4] 32 128 0.00001 300 70.3 % 1.006

21.06.2018 48 Röhrling (8) 128 128 3 5 [3, 3, 3, 3, 3 ] 32 256 0.00001 300 70.3 % 0.992

21.06.2018 52 Röhrling (8) 128 128 3 5 [4, 4, 4, 4, 4] 32 64 0.00001 300 70.3 % 0.887

21.06.2018 53 Röhrling (8) 128 128 3 5 [4, 4, 4, 4, 4] 32 128 0.00001 300 70.3 % 0.840

21.06.2018 20 Röhrling (8) 128 64 3 5 [4, 4, 3, 3, 3 ] 32 128 0.00001 300 69.5 % 1.003

21.06.2018 27 Röhrling (8) 128 64 3 5 [6, 6, 4, 4, 4] 32 256 0.00001 300 69.5 % 0.937

21.06.2018 36 Röhrling (8) 128 128 3 4 [4, 4, 3, 3] 32 256 0.00001 300 69.5 % 0.855

21.06.2018 37 Röhrling (8) 128 128 3 4 [4, 4, 4, 4] 32 64 0.00001 300 69.5 % 0.909

21.06.2018 38 Röhrling (8) 128 128 3 4 [4, 4, 4, 4] 32 128 0.00001 300 69.5 % 0.891

21.06.2018 39 Röhrling (8) 128 128 3 4 [4, 4, 4, 4] 32 256 0.00001 300 69.5 % 0.965

21.06.2018 41 Röhrling (8) 128 128 3 4 [6, 6, 4, 4] 32 128 0.00001 300 69.5 % 0.953

21.06.2018 8 Röhrling (8) 128 64 3 4 [4, 4, 4, 4] 32 128 0.00001 300 68.8 % 0.961

21.06.2018 15 Röhrling (8) 128 64 3 4 [6, 6, 6, 4] 32 256 0.00001 300 68.8 % 1.031

21.06.2018 16 Röhrling (8) 128 64 3 5 [3, 3, 3, 3, 3 ] 32 64 0.00001 300 68.8 % 0.923

21.06.2018 25 Röhrling (8) 128 64 3 5 [6, 6, 4, 4, 4] 32 64 0.00001 300 68.8 % 0.965

21.06.2018 34 Röhrling (8) 128 128 3 4 [4, 4, 3, 3] 32 64 0.00001 300 68.8 % 0.829

21.06.2018 42 Röhrling (8) 128 128 3 4 [6, 6, 4, 4] 32 256 0.00001 300 68.8 % 1.012



21.06.2018 59 Röhrling (8) 128 128 3 5 [6, 6, 6, 6, 4] 32 128 0.00001 300 68.8 % 1.077

21.06.2018 4 Röhrling (8) 128 64 3 4 [4, 4, 3, 3] 32 64 0.00001 300 68.0 % 0.962

21.06.2018 12 Röhrling (8) 128 64 3 4 [6, 6, 4, 4] 32 256 0.00001 300 68.0 % 1.077

21.06.2018 22 Röhrling (8) 128 64 3 5 [4, 4, 4, 4, 4] 32 64 0.00001 300 68.0 % 0.993

21.06.2018 40 Röhrling (8) 128 128 3 4 [6, 6, 4, 4] 32 64 0.00001 300 68.0 % 0.979

21.06.2018 44 Röhrling (8) 128 128 3 4 [6, 6, 6, 4] 32 128 0.00001 300 68.0 % 1.049

21.06.2018 56 Röhrling (8) 128 128 3 5 [6, 6, 4, 4, 4] 32 128 0.00001 300 68.0 % 1.131

21.06.2018 57 Röhrling (8) 128 128 3 5 [6, 6, 4, 4, 4] 32 256 0.00001 300 68.0 % 0.906

21.06.2018 10 Röhrling (8) 128 64 3 4 [6, 6, 4, 4] 32 64 0.00001 300 67.2 % 0.989

21.06.2018 11 Röhrling (8) 128 64 3 4 [6, 6, 4, 4] 32 128 0.00001 300 67.2 % 1.009

21.06.2018 24 Röhrling (8) 128 64 3 5 [4, 4, 4, 4, 4] 32 256 0.00001 300 67.2 % 1.060

21.06.2018 45 Röhrling (8) 128 128 3 4 [6, 6, 6, 4] 32 256 0.00001 300 67.2 % 1.266

21.06.2018 55 Röhrling (8) 128 128 3 5 [6, 6, 4, 4, 4] 32 64 0.00001 300 67.2 % 1.031

21.06.2018 13 Röhrling (8) 128 64 3 4 [6, 6, 6, 4] 32 64 0.00001 300 66.4 % 1.131

21.06.2018 26 Röhrling (8) 128 64 3 5 [6, 6, 4, 4, 4] 32 128 0.00001 300 66.4 % 1.058

21.06.2018 14 Röhrling (8) 128 64 3 4 [6, 6, 6, 4] 32 128 0.00001 300 65.6 % 1.160

21.06.2018 28 Röhrling (8) 128 64 3 5 [6, 6, 6, 6, 4] 32 64 0.00001 300 65.6 % 1.055

21.06.2018 29 Röhrling (8) 128 64 3 5 [6, 6, 6, 6, 4] 32 128 0.00001 300 65.6 % 1.208

21.06.2018 58 Röhrling (8) 128 128 3 5 [6, 6, 6, 6, 4] 32 64 0.00001 300 65.6 % 1.049

21.06.2018 60 Röhrling (8) 128 128 3 5 [6, 6, 6, 6, 4] 32 256 0.00001 300 64.8 % 1.140

21.06.2018 30 Röhrling (8) 128 64 3 5 [6, 6, 6, 6, 4] 32 256 0.00001 300 64.1 % 1.071

21.06.2018 43 Röhrling (8) 128 128 3 4 [6, 6, 6, 4] 32 64 0.00001 300 63.3 % 1.184

bachelorarbeit magic mushroom app - ntb.ch · der ntb hochladen, damit die neuronalen netze zu...

Documents