Orchideen Klassifikation¶
Ein erstes Anwendungsbeispiel, das die Orchideen-Beispiele von Dietmar Jakely mit Hilfe von maschinellen Mitteln automatisch zu erkennen und richtig zuzuordenen lernt.
Detailiertere Informationen zur Reproduktion dieser Resultate auf dem eigenen Rechner sind dem File README bzw. dem betreffenden GitLab Repository zu entnehmen.
%reload_ext autoreload
%autoreload 2
%matplotlib inline
import os
import torch, torchvision
from torch.utils.data import Dataset, DataLoader
import pandas as pd
import matplotlib.pyplot as plt
from scipy import misc
from sklearn.metrics import confusion_matrix, classification_report
from fastai.conv_learner import *
#from fastai.dataset import *
#from fastai.metrics import *
from fastai.plots import *
plt.rcParams['figure.figsize'] = (10,10)
# Anzeigen, ob Rechenunterstützung durch die Grafikkarte verfügbar ist
torch.cuda.is_available()
Schnittstelle zum Einlesen der Orchideenauswahl¶
Da ich sehr viel Zeit darauf verwenden musste, mich mit ärgerliche Fehler der fastai-Library herumzuschlagen, die das Einlesen von Tabellen betreffen, hab ich schließlich einen eigenen Ersatz dafür geschrieben, um unsere Orchideendaten vernünftig nutzen zu können.:
class OrchideenData(ImageClassifierData):
@classmethod
def from_csv(cls, path, orch_dir, trn_csv , val_csv, tfms=(None,None), bs=64, num_workers=8):
""" Auswahl der Bilder an Hand von vorbereiteten CSV-Listen
Arguments:
path: a root path of the data (for storing trained models, precomputed values, etc)
orch_dir: Verzeichnis mit Orchideendaten
trn_csv: CSV-File der Trainingsauswahl
val_csv: CSV-File der Validierungsauswahl
bs: batch size
tfms: transformations (for data augmentations). e.g. output of `tfms_from_model`
trn_name: a name of the folder that contains training images.
val_name: a name of the folder that contains validation images.
num_workers: number of workers
Returns:
ImageClassifierData
"""
trn,val = [cls.parse_csv(orch_dir, o) for o in (trn_csv, val_csv)]
datasets = cls.get_ds(FilesIndexArrayDataset, trn, val, tfms, path=path, test=None)
return cls(path, datasets, bs, num_workers, classes=trn[2])
@staticmethod
def parse_csv(orch_dir, cvs):
with open(os.path.join(PATH, orch_dir, cvs)) as handle:
fields = [line.strip().split(',') for line in handle][1:]
fnames = [os.path.join(orch_dir, fname) for fname,label in fields]
all_labels = list(set([label for fname,label in fields]))
idxs = [all_labels.index(label) for fname,label in fields]
label_arr = np.array(idxs, dtype=int)
return fnames, label_arr, all_labels
Der eigentliche Lernprozess:¶
Der hier vorliegende Lösungsansatz bedient sich einer Technik, die als Transfer Learning bekannt ist. Man benutzt dazu fertige, für ihre diesbezügliche Eignung bekannte Modelle -- im konkreten Fall: ResNet152 --, die im Vorfeld bereits mit Millionen von Bildern aus dem ImageNet trainiert wurden, und ergänzt sie nur um kleine Adaptionen an die neue Problemstellung. Auch wenn diese vortrainierten Modelle noch nie mit den hier zu erlernenden Unterscheidungen konfrontiert waren, verfügen sie doch bereits über einen umfangreichen Bestand an bereits erworbenen Differenzierungsmustern, auf die sie beim Trainieren der neunen Aufgabenstellung zurückgreifen können.
PATH='data/orchideen' # Arbeitsverzeichnis mit den genutzten Daten, generierte Modellen, etc.
sz=256 # 'image size' auf die Bilder bei der Verarbeitung herunterskaliert werden.
bs=4 # 'batch size' anzahl der gleichzeitig zu verarbeitenden Bilder
# Beide Werte sind ausgesprochen nieder angesetzt, da die Berechnungen auf einer
# relativ leistungsschwache Grafikkarte (GTX750Ti, 2GB) erfolgte. Ein Ãœberschreiten
# der GPU-Speicherapazität zieht unweiglich Abstürze nach sich, die einen Neustart
# des Jupyter Kernels erfordern.
#
# Die verwendeten CNNs werden im Vorfeld mit mind. 224px Bildgröße vortrainiert, was
# als vernünftiger Anhaltspunkt für die zu verwendende Größe dienen sollte.
#arch=resnet34
arch=resnet152
!rm -rf ./{PATH}/tmp
data = OrchideenData.from_csv(PATH, orch_dir='orchideen',
trn_csv='min50_training.csv',
val_csv='min50_validation.csv',
tfms=tfms_from_model(arch, sz, aug_tfms=transforms_side_on, max_zoom=1.5))
learn = ConvLearner.pretrained(arch, data, precompute=True)
Nach der Vorbereitung des zu verwendenden neuronalen Netzwerks, wird in einer Schleife wiederholt der gesamte Umfang der zum Trainieren bestimmten Bilder genutzt, um das Modell Schritt für Schritt in seiner Unterscheidungs- und Zuordnungsleistung zu optimieren.
Der Rückgabewert der sgn. Loss function dient dabei als Orientierung. Darin drückt sich aus, wie weit es gelungen ist, sich dem erwünschten Ziel zu nähern -- in unserem Fall also, die Bilder möglicht korrekt zuzordnen. Je kleiner der entsprechende Wert ausfällt, umso besser.
Die lange Zahlenkolonne, die bei jedem vollen Durchlauf durch alle Bilder (=epoche) um eine Zeile erweitert wird, enthält zwei solche Loss-Angaben:
Die erste Spalte nach der Durchlaufsnummer zeigt den Loss-Wert bezogen auf die Gesamtheit der Trainings-Bilder.
Die zweite Spalte enthält einen ganz ähnlich eruierten Wert, der sich aber in diesem Fall auf eine Validierungsgruppe von Bilder bezieht -- in unserem Fall 20% der Gesamtheit, die bereits im Vorfeld zufällig aus jeder Orchideenart herausgegriffen wurden. Diese Validierungsbilder bekommt der eigentliche Lernprozess nie zu Gesicht. Sie dienen ausschließlich der Überprüfung, wie weit die Erkennung tatsächlich auch auf andere Bilder außerhalb der Lernmenge übertragbar ist.
Wichtig ist ist die Beziehung der Werteentwicklung in diesen beiden Spalten vor allem deshalb, um sgn. overfitting zu erkennen. Dabei handelt es sich um ein Phänomen, das sich bei zu intensivem Training einstellt. Dabei wird zwar weiter die Annäherung an den Trainingsdatensatz vorangetrieben -- der Loss-Wer in der ersten Spalte nimmt als Schritt für Schritt weiter ab --, aber die Generalisierbarkeit der repräsentierten Beschreibung nimmt zusehends ab. Es werden also nur mehr die tatsächlichen Lernbeispiele immer präziser erkannt, nicht aber fremde Daten, die man an Hand ihrer Ähnlichkeit bestimmen wollte -- deshalb steigt der Wert in der zweiten Spalte wieder an.
Die letzte Spalte der Ausgabe steht für die accuracy, was bereits als Prozentangabe für die Treffergenauigkeit der Bilder gelesen werden kann, wenn man das Komma um zwei Stellen nach rechts verschiebt.
Wichtig an dieser Art des Lernens bzw. der Optimierung von Modellen ist der Umstand, das dabei auch stochastische Momente im Spiel sind. Es wird also zumindest jener Ausgangspunkt zufällig gewählt, von dem aus man dann in unzähligen Versuchen auf eine besseren Lösungen hinzuarbeiten versucht. Die Enwicklung der Werte und das resultierende Modell nehmen also bei jedem erneuten Programmdurchlauf eine andere Form an.
Da in diesem ersten Trainingsschritt vorerst einmal nur jener kleine Teil trainiert wird, der zum bereits vortrainierte Model hinzugefügt wurde, geht das in diesem Fall ausgesprochen schnell. Die Ergebnisse wirken aber trotzdem bereits nach einigen Iterationen bzw. nach Sekunden relativ brauchbar. Darin zeigt sich der Vorzug des Transfer Learnings.
%time learn.fit(0.001, 100)
learn.sched.plot_loss()
Im Anschluss oder auch in Verbindung mit diesem elementaren Trainingsvorgang können noch einige weitere sinnvolle Verfeinerungen vorgenommen werden, um die Erkennungsgenauigkeit ein weiter zu steigern.
Eine solche Methode besteht darin, das Netz nicht ausschließlich nur mit den unveränderten Lernbeispielen zu trainieren, sondern die betreffenden Bilder bewusst mehrfach einzulesen, und dabei jeweils in verschiedenen Winkeln zu rotieren, zu spiegeln oder skalierte Ausschnitte daraus zu wählen, um auch die damit verbundenen abgeleiteten Ansichten besser zu erkennen. Diese Technik bezeichnet man als Augmentierung.
In userem Fall hat das allerdings keinen nennenswerten Gewinn gebracht, weshalb es hier auskommentiert ist, um die Verarbeitung nicht sinnlos zu verlangsamen.
#learn.precompute=False
#%time learn.fit(0.001, 10)
Abschießend wird nun der Lernprozess bzw. die Optimierung der Parameter, die ja bisher nur den hinzugefügten Teil betroffen haben, einige Iterationen lang auf das gesamte Netz ausgedehnt. Damit wird der Rechenaufwand gravierend größer, aber doch auch wieder eine geringe Qualitätssteigerung in der Erkennungsrate bewirkt.
learn.unfreeze()
learn.bn_freeze(True)
%time learn.fit([1e-5,1e-4,1e-3], 8)
learn.sched.plot_loss()
Das fertig trainierte Netz kann abschließend in einer Datei abgespeichert werden, um es in Zukunft ohne langwierigen Trainingsaufwand für div. Anwendungen nutzen zu können.
learn.save('min50')
Auswertung der Daten¶
Als Beispiel wurden hier nur jene Arten herausgegriffen, von denen mehr als 50 Abbildungen verfügbar waren, da das Erlernenen an Hand von noch weniger Beispielen ganz spezielle Lösungsansätze erfordern würde.
Alle Angaben zur tatsächlichen maschinellen Klassifizierungsleistung beziehen sich auf jene Validierungsstichprobe (20% der verfügbaren Gesamtheit), mit der der Lernprozess vorher nicht in Berührung kam.
log_probs_tta,y = learn.TTA()
probs_tta = np.mean(np.exp(log_probs_tta),0)
preds_tta = np.argmax(probs_tta, axis=1)
# eine leichet erweiterte darstellung der confusion matrix
def plot_orchideen_confusion_matrix(cm, classes, y, order, title='Confusion matrix', cmap=plt.cm.Blues):
"""
This function prints and plots the confusion matrix.
Normalization can be applied by setting `normalize=True`.
(This function is copied from the scikit docs.)
"""
count = np.unique(y, return_counts=True)[1][np.array(order)]
plt.figure()
plt.imshow(cm, interpolation='nearest', cmap=cmap)
plt.title(title)
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=90)
plt.yticks(tick_marks, [f'{l} [{nr}]' for l,nr in zip(classes, count)])
thresh = cm.max() / 2.
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
plt.text(j, i, f'{cm[i, j]}\n{cm[i,j]*100/count[i]:.3}%'if i==j else cm[i, j],
horizontalalignment="center", verticalalignment="top",
color="white" if cm[i, j] > thresh else "black")
plt.tight_layout()
plt.ylabel('Korrekte Zuordnung [Anzahl an Überprüfungsbildern]')
plt.xlabel('Ermittelte Zuordnung')
classes = np.array(data.classes)
order = classes.argsort()
labels = classes[order]
print(classification_report(y, preds_tta, order, labels, digits=3))
cm = confusion_matrix(y, preds_tta, order)
out = plot_orchideen_confusion_matrix(cm, labels, y, order)
res = ImageModelResults(data.val_ds, np.mean(log_probs_tta, 0))
Am besten erkannte Beispiele:¶
for nr in order:
print(f'Am besten erkannte Beispiele aus der Kategorie: "{classes[nr]}":')
res.plot_by_correct(nr, True)
plt.show()
Nicht erkannte Beispiele:¶
for nr in order:
print(f'Nicht erkannte Beispiele aus der Kategorie: "{classes[nr]}":')
res.plot_by_correct(nr, False)
plt.show()
Vergleich mit ganz einfachen nicht-vortrainierten CNNs¶
Wie Eingangs erwähnt, habe ich bei der Umsetzung ein bereits vortrainiertes Modell von ausgesprochen hoher Komplexitität verwendet. CNNs von solcher Dichte sind überhaupt erst seit zwei-drei Jahren umsetzbar und haben die Bilderkennung massiv verbessert. (Eine recht verständliche Einführung in die damit verbundenen Probleme und revolutionierenden Fortschritte, gibt der Vortrag: "Really Deep Neural Networks with PyTorch" von David Dao auf der PyCon 2017)
Derartiges zu nutzen ist heute mit den richtigen Werkzeugen fast einfacher als ein ganz simples CNN von Grund auf neu zu definieren. Mich hat es trotzem interessiert, ob man auch mit bewusster Beschränkung auf primitivere historische Mittel, in unserem konkreten Fall auch das Auslangen finden könnte bzw. mit welchen Konsequenzen das verbunden wäre?
Aus diesem Grund hab ich die ganze Geschichte noch ein zweites mal mit anderen Mitteln umzusetzten versucht. Ganz zurück, zu völlig unausgegorenen Eigenkreationen od. CNNs der uralten LeNet-Architektur, die nur für unvergleichbar kleinere Bildauflösung vorgesehen war, wollte ich dabei aber auch nicht gehen. Ich hab daher als realistischen Kompromiss ein völlig untrainiertes AlexNet herangezogen. Eine Architektur, die zwar einerseits noch relativ überschaubar und einfach wirkt, aber trotzdem schon länger zur Klassifizierung ähnlicher Abbildungen herangezogen wird.
PATH='data/orchideen'
sz=224 #32
bs=32
data = OrchideenData.from_csv(PATH, orch_dir='orchideen',
trn_csv='min50_training.csv',
val_csv='min50_validation.csv',
tfms=tfms_from_stats(imagenet_stats, sz, aug_tfms=transforms_side_on, max_zoom=1.5))
model = torchvision.models.alexnet(pretrained=False)
model.classifier = nn.Sequential(*children(model.classifier)[:-1],
nn.Linear(4096, data.c),
nn.LogSoftmax())
model
learn = ConvLearner.from_model_data(model, data)
Das Lernen dauert in diesem Fall natürlich beträchtlich länger!
Trotzdem lässt sich auf diesem Weg nach ca. zwei Stunden Rechenzeit ein Modell gewinnen, das dem oben genutzten in unserem konkreten Fall nur unwesentlich nachsteht.
Das ist vorallem auch deshalb eine recht positive Erfahrung, weil es ja nicht immer Sinn macht, mit völlig überdimmnsionierten Modellen zu arbeiten. Speziell, wenn man an die Verwendung auf kleinen Bastelcomputern, Handys oder Download und Ausführung direkt im WebBrowser denkt, haben derartige deutlich schlankere Lösungen auch ihren Reiz.
%time learn.fit(0.01, 100)
learn.sched.plot_loss()
learn.save('min50-alexnet')
log_probs_tta,y = learn.TTA()
probs_tta = np.mean(np.exp(log_probs_tta),0)
preds_tta = np.argmax(probs_tta, axis=1)
classes = np.array(data.classes)
order = classes.argsort()
labels = classes[order]
print(classification_report(y, preds_tta, order, labels, digits=3))
cm = confusion_matrix(y, preds_tta, order)
out = plot_orchideen_confusion_matrix(cm, labels, y, order)
