Mathesis Wiki

Erste Annäherung an Machine Learning mithilfe des Buchs: „Hands-On Machine Learnign with Scikit-Learn & TensorFlow“. Vor allem haben wir versucht zu verstehen, wie Classifikatoren funktionieren.

Grobe Programmstruktur für das Buchstabenausschneiden entworfen. Vorteile/Nachteile von Watershed und Thresholding angeguckt → Thresholding ist besser. Programm geschrieben, das aus Fotos Farbwerte auslesen kann.

Den Großteil der Zeit haben wir damit verbracht Machine Learning zu verstehen. Dabei haben wir uns vor allem auf Linear Regression konzentriert.

Wir haben eine Funktion geschrieben, die den ersten Pixel vom Anfangsbuchstaben eines Textes findet. Wir haben uns überlegt, wie wir eine weitere Funktion schreiben können die den Buchstaben in einem Rechteck isoliert.

Wir haben angefangen einen allgemeinen Code für das Machine Learning zu schreiben welches mit dem MNIST Dataset arbeitet. Dies wollen wir dann möglichst bald gegen das richtige Dataset austauschen. Wir haben bis jetzt nur den SGD als Classifier aber da wollen wir noch weitere hinzufügen.

Über die Woche haben wir eine Methode geschrieben, die die untere, rechte Ecke eines Buchstabens findet. Um diese zu realisieren, war eine Methode von Nöten, welche testet, wo der Buchstabe zu Ende ist. Basierend auf diesem Code, entstanden Methoden, die die obere, linke Ecke des Buchstabens finden können. Danach wurde eine kurze Methode geschrieben, welche den nächsten Buchstaben „ansteuert“ bzw erkennt, ob die Zeile zu Ende ist.

Letzte Woche haben wir mit Arik unseren SGD Classifier code verfeinert.

from sklearn.datasets import fetch_mldata
import numpy as np
from sklearn.linear_model import SGDClassifier
from sklearn.model_selection import train_test_split
 
class Classifiers(object):
 
	training_numbers = []
	testing_numbers = []
 
	X_train = []
	X_test = []
	y_train = []
	y_test = []
 
	sgd_clf = []
 
	def __init__(self):
		self.getData()
		self.cheatsheet()
 
	def getData(self):
		data = fetch_mldata("MNIST original")
		self.X, self.y = np.array(data["data"]), np.array(data["target"])
		self.X_train, self.X_test, self.y_train, self.y_test = train_test_split(self.X,self.y,test_size=0.1)	
 
	def cheatsheet(self):
		for nr in range(10):
			self.training_numbers.append(self.y_train == nr)
		for nr in range(10):
			self.testing_numbers.append(self.y_test == nr)
 
	def sgd_clf_fit(self):
		self.sgd = SGDClassifier(random_state = 42)
		self.sgd.fit(self.X_train,self.y_train)
 
	def sgd_clf_predict(self):
	    return self.sgd.score(self.X_test,self.y_test)
 
ai = Classifiers()
 
ai.sgd_clf_fit()
print ai.sgd_clf_predict()

Um einen möglichst präzisen Classifier zu wählen, brauchen wir jedoch erstmal die endgültigen Daten auf dem unserer Classifier trainieren wird. Deshalb haben begonnen uns um die Kreation der für uns relevanten Daten zu kümmern. Die Idee ist das wir zuerst mithilfe der vorinstallierten Fonts eine Reihe an Daten kreeiren. Diese Daten werden noch verunreinigt bevor wir unsere Classifier auf sie üben lassen. Heute haben wir uns erstmal um die Kreeirung der „reinen“ Daten gekümmert.

Wir haben den Buchstabenscanner und die Methode zum nächsten Buchstaben finden neu geschrieben. ⇒ Buchstabenscanner umfunktioniert (Fehler in einer Schleife) ⇒ sehr viel Stress: HYDRAFEHLER

Um unser Datenset zu erstellen haben wir uns damit beschäftigt wie man Rauschen in ein Bild einfügen kann. Dies kann man einfach so machen in dem man von den Grauwert für jeden Pixel einen Bestimmten Wert abzieht. Dies hat dann mit Coden jedoch länger gedauert als wir dachten.

Wir haben eine Methode geschrieben, die die obere, linke Ecke eines Zeichens besser bestimmen kann. Um dies zu erleichtern, wurden verschiedene Methoden zerlegt und finden nun in mehreren Anwedungen Verwendung.

Wir haben verschiedene Kassenbon ähnliche Fonts zusammen gesucht. Dazu haben wir sehr viele Bugs gefixt und am Ende haben wir einen laufenden Algorithmus erhalten. Einer dieser Bugs war zum Beispiel noch im Rauschen Algorithmus wo wir nicht wussten dass man in eine img Matrix keine Pixelwerte die höher als 255 sind eintragen kann. Ein weiterer Bug war, dass wir den Schwerpunkt für Bilder nicht berechnen können, wenn der Buchstabe nicht vollständig abgebildet ist. Was daran lag, dass die Fonts unterschiedliche Größen haben.

Wir haben ein Zeilenfinder geschrieben. Dieser behebt das Problem, dass beim schrägen Scannen nach Buchstaben ein Buchstabe aus einer unteren Zeile gefunden wird. Dank der Zeilenober- und untergrenze, können Umlaute, Buchstaben mit Accents und ähnliche, mehrteilige Buchstaben vollständig gefunden werden.

Einigung auf ein zu übergebenes Format. Die ausschneide Gruppe wir uns einen Ordner von .png Dateien übergeben, wobei sich der Name aus der Position des Buchstaben zusammensetzt.

Die Methode, die für das Finden des nächsten Zeichens zuständig war, wurde entfernt. Ihre Funktion wurde aus Effizienzgründen vom ursprünglichen Zeichenfinder übernommen. Dazu wurde der Zeichenfinder stark umstrukturiert. Verschieden kleine Methoden, die bei der Zeichenerkennung geholfen haben, wurden entfernt. Bereits vorhandene Methoden haben ihre Funktion übernommen. Dazu wurden sie leicht verändert. Bis jetzt wurden fast ein drittel der zwischenzeitlich vorhandenen Methoden entfernt und ihre Funktionen auf andere Methoden umverteilt.

Wir haben recherchiert, wie wir die gefundenen Symbole am besten als PNG Bilder exportieren können. Die beste Lösung schien scipy.misc.imsave zu sein, da wir scipy sowieso schon verwenden und die gefundenen symbole als scipy arryas speichern.

Das Symbol-Erkennungs Programm speichert jetzt die gefundenen Zeichen als PNG Dateien. Das gesamte Program ist nun in Methoden verpackt. Nur eine der Methoden muss aufgerufen werden um das gesamte Bild zu scannen und Symbol-PNGs zu generieren. Die PNGs werden in einem Unterordner des Program-Verzeichnisses gespeichert.

Ein kleiner Bug im Symbolerkennungsprogram wurde mit großem Aufwand behoben. Nach Stunden ist es gelungen, tensorflow zum laufen zu kriegen. Irgendwie klappt jetzt alles zusammen, auch wenn überall noch kleine Fehler und Zeugs sind. Symbole werden ausgeschnitten und an das neurale Netz übergeben, welches die Zeichen mehr oder weniger richtig erkennt.

Wir haben ein neues neurales Netz getestet, das Arik ausgebrütet hat. Leider ist die Erkennungsquote relativ niedrig. Womöglich liegt das an der Skalierung der Buchstaben.

Jan versucht das neuronale Netzwerk auf seinem Heim-Computer unter Windows 10 zum laufen zu bekommen. CPU-Berechnung funktioniert nach vielen Tagen (und Nächten) Arbeit und Herumprobieren und ist einige male schneller als die Berechnung auf den Laptops in der Uni. Aber es ist trotzdem nicht schnell genug. Leider sind jegliche Bemühungen, Theano dazu zu überreden die 1920 CUDA-Kerne der GPU zu nutzen vergeblich.