def aufg06():
#
# Nun sollen die Daten des MNIST-Datensatzes mit den vorher erstellten
# Klassifikatoren klassifiziert werden. Trainieren Sie dazu jeweils mit den
# Trainigsdaten einen Klassifikator und berechnen Sie den sich ergebenden
# Klassifikationsfehler auf dem Testdatensatz. Variieren Sie die
# Parametrisierung der Klassifikatoren,
# um einen moeglichst geringen Klassifikationsfehler zu erreichen.
#
# Trainieren Sie einen Mischverteilungsklassifikator fuer verschiedene mit
# PCA dimensionsreduzierte Versionen des MNIST-Datensatzes und vergleichen
# Sie die erzielten Ergebnisse.
#
# Trainieren Sie einen k-NN-Klassifikator fuer verschiedene mit PCA
# dimensionsreduzierte Versionen des MNIST-Datensatzes und vergleichen Sie
# die erzielten Ergebnisse.
train_data_provider = DataProvider(DataProvider.MNIST_TRAIN_PCA)
test_data_provider = DataProvider(DataProvider.MNIST_TEST_PCA)
train_data, train_labels = train_data_provider.get_dataset_and_labels()
test_data, test_labels_gt = test_data_provider.get_dataset_and_labels()
raise NotImplementedError('Implement me')
def aufg02():
# In dieser Aufgabe soll ein Bayes'scher Normalverteilungs-Klassifikator
# mit drei Dichten realisiert werden.
#
# Zunaechst sollen Mittelwert und Kovarianzmatrix der drei Klassen geschaetzt
# und visualisiert werden:
train_data_provider = DataProvider(DataProvider.DATA2DROOT_TRAIN)
train_data, train_labels = train_data_provider.get_dataset_and_labels()
#
# Extrahieren Sie die Klassen-Labels aus dem Trainingsdatensatz und speichern
# Sie sie in der lokalen Variablen labels
#
# Nuetzliche Funktionen:
# https://docs.scipy.org/doc/numpy/reference/generated/numpy.unique.html
labels = np.unique(train_labels)
# raise NotImplementedError('Implement me')
mean_list = []
cov_list = []
for label in labels:
#
# Berechnen Sie Mittelwert und Kovarianz der drei Klassen durch
# Matrixoperationen in NumPy.
# Speichern Sie fuer jeden Schleifendurchlauf den Mittelwert in der
# lokalen Variablen mean und die Kovarianzmatrix in der lokalen Variablen
# cov. Benutzen Sie zur Schaetzung die korrigierte Kovarianzmatrix:
# https://de.wikipedia.org/wiki/Stichprobenkovarianz#Korrigierte_Stichprobenkovarianz
class_data = train_data[train_labels == label]
mean = np.mean(class_data, axis=0)
cov = np.cov(class_data, rowvar=0)
# raise NotImplementedError('Implement me')
# -----------------------nachfragen---------------------------
np.testing.assert_almost_equal(actual=mean,
desired=np.mean(class_data, axis=0),
err_msg='Der Mittelwert ist falsch')
np.testing.assert_almost_equal(
actual=cov,
desired=np.cov(class_data, rowvar=0),
err_msg='Die Kovarianzmatrix ist falsch')
mean_list.append(mean)
cov_list.append(cov)
# Visualisieren Sie die Datenpunkte der drei Klassen, sowie die geschaetzen
# Mittelwerte und Kovarianzmatrizen durch eine Normalverteilung.
# Zur Visualisierung der Normalverteilungen: visualization.plot_norm_dist_ellipse
fig = plt.figure()
ax = fig.add_subplot(111)
colors = ['#FF0000', '#00FF00', '#0000FF']
for label, color in zip(labels, colors):
class_data = train_data[train_labels == label]
ax.scatter(class_data[:, 0],
class_data[:, 1],
c=color,
edgecolor=(0, 0, 0))
plot_norm_dist_ellipse(ax, mean_list, cov_list, colors)
plt.show()
# raise NotImplementedError('Implement me')
# Implementieren sie einen Bayes'schen Normalverteilungs-Klassifikator (ohne
# Rueckweisung), der die soeben berechneten Verteilungen als Modell
# verwendet. Vervollstaendigen Sie dazu die Klasse GaussianClassifier im Modul
# classification.
#
# Hinweise:
#
# Achten Sie darauf, dass Ihre Implementierung unabhaengig von den
# verwendeten Klassenlabels ist. Aus den Trainingsdaten lassen sich diese mit
# np.unique bestimmen.
# http://docs.scipy.org/doc/numpy/reference/generated/numpy.unique.html
#
# Durch welche geeignete monotone Transformation lassen sich numerische
# Probleme bei der Auswertung von extrem kleinen Dichtewerten vermeiden?
# Beruecksichtigen Sie das in Ihrer Implementierung.
test_data_provider = DataProvider(DataProvider.DATA2DROOT_TEST)
test_data, test_labels_gt = test_data_provider.get_dataset_and_labels()
bayes = GaussianClassifier()
bayes.estimate(train_data, train_labels)
estimated_labels = bayes.classify(test_data)
# Fuehren Sie eine Evaluierung der Ergebnisse wie in Aufgabe 1 durch.
evaluator = ClassificationEvaluator(estimated_labels, test_labels_gt)
print("Error rate {}".format(evaluator.error_rate()))
print("Category error rate {}".format(evaluator.category_error_rates()))
crossvali = CrossValidation(train_data, train_labels, 5)
over_all_result, class_result = crossvali.validate(GaussianClassifier())
print(over_all_result)
def aufg01():
# Zur Einfuehrung werden auf einem Beispieldatensatz Klassifikatoren
# implementiert. Der Datensatz data2d enthaelt zweidimensionalen
# Trainingsmerkmale fuer drei Musterklassen. Fuer diese Daten soll eine
# Klassifikation ueber Naechster-Nachbar realisiert werden.
# Achtung: Gestalten Sie Ihre Implementierung so, dass Sie die Klassifikatoren
# fuer zukuenftige Aufgaben wiederverwenden koennen.
# Im Folgenden wird der Beispieldatensatz ueber die Klasse DataProvided
# geladen und anschliessend visualisiert. Machen Sie sich mit sowohl dem
# Laden als auch der Visualisierung vertraut, da Sie in den kommenden
# Aufgaben diese Aspekte wiederverwenden werden.
# http://matplotlib.org/users/pyplot_tutorial.html
#
# Nuetzliche Funktionen: plt.scatter
# http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.scatter
#
# Tipp: zu einer besseren Visualisierung sollten alle scatter plots in Matplotlib
# immer mit dem Argument "edgecolor=(0, 0, 0)" aufgerufen werden.
train_data_provider = DataProvider(DataProvider.DATA2DROOT_TRAIN)
test_data_provider = DataProvider(DataProvider.DATA2DROOT_TEST)
fig = plt.figure()
ax = fig.add_subplot(111)
# fig, (ax, ax2) = plt.subplots(1, 2)
data = train_data_provider.get_class_arr(0)
ax.scatter(data[:, 0], data[:, 1], c='#FF0000', edgecolor=(0, 0, 0))
data = train_data_provider.get_class_arr(1)
ax.scatter(data[:, 0], data[:, 1], c='#00FF00', edgecolor=(0, 0, 0))
data = train_data_provider.get_class_arr(2)
ax.scatter(data[:, 0], data[:, 1], c='#0000FF', edgecolor=(0, 0, 0))
# plt.show()
#
# Implementieren Sie einen Naechster-Nachbar-Klassifikator.
# Vervollstaendigen Sie dazu die Klasse KNNClassifier im Modul common.classifiers.
# Testen Sie verschiedene Abstandsmasse. Welche halten Sie insbesondere fuer sinnvoll?
train_data, train_labels = train_data_provider.get_dataset_and_labels()
test_data, test_labels_gt = test_data_provider.get_dataset_and_labels()
test_labels_gt = test_labels_gt.astype('float64')
train_labels = train_labels.astype('float64')
knn_classifier = KNNClassifier(
k_neighbors=70, metric='cityblock') # euclidean, cityblock, chebyshev
knn_classifier.estimate(train_data, train_labels)
estimated_labels = knn_classifier.classify(test_data)
# print(len(estimated_labels==0))
# print(test_labels_gt.shape, estimated_labels.shape)
# print(test_labels_gt.dtype, estimated_labels.dtype)
#
#data_x = test_data[mask, 0]
#data_y = test_data[mask, 1]
#ax2.scatter(data_x, data_y, c='#FF0000', edgecolor=(0, 0, 0))
#data = test_data[estimated_labels == 1]
#ax2.scatter(data[:, 0], data[:, 1], c='#00FF00', edgecolor=(0, 0, 0))
#data = test_data[estimated_labels == 2]
#ax2.scatter(data[:, 0], data[:, 1], c='#0000FF', edgecolor=(0, 0, 0))
#fig.tight_layout()
#plt.show()
#
# Nutzen Sie zur Evaluation der Ergebnisse die Klasse ClassificationEvaluator
# im Modul common.classifiers.
evals = ClassificationEvaluator(estimated_labels, test_labels_gt)
error_rate, n_wrong, n_samples = evals.error_rate()
print(error_rate, n_wrong, n_samples)
# raise NotImplementedError('Implement me')
# Ein NN-Klassifikator alleine ist meist nicht ausreichend. Erweitern Sie
# den Klassifikator zum k-NN Klassifikator.
# Fuer den Mehrheitsentscheid ist das defaultdict nuetzlich (siehe intro).
# https://docs.python.org/3/library/collections.html#collections.defaultdict
# Trainingsparameter sollten immer per Kreuzvalidierung auf den Trainingsdaten
# optimiert werden. Mit den besten Parametern wird dann ein Klassifikator
# erstellt und auf den Testdaten evaluiert.
# Nutzen Sie die Klasse CrossValidation im Modul classification um den
# Parameter k zu optimieren.
# In den folgenden Aufgaben ist es Ihnen freigestellt, ob Sie Kreuzvalidierung
# nutzen oder direkt auf den Testdaten optimieren.
cross = CrossValidation(train_data, train_labels, 5)
for i in range(65, 76):
knn = KNNClassifier(i, 'cityblock')
crossval_overall_result, crossval_class_results = cross.validate(knn)
print('Anzahl der Nachbarn = ', i, ' : ', crossval_overall_result)
''' Optimum bei k_neighbours = 70 '''
def aufg04():
#
# Nutzen Sie den in Aufgabe 3 Vektorquantisierer fuer die Schaetzung eines
# Gaussian Mixture Models.
#
# Implementieren Sie dazu die Klasse MDClassifierClassIndep im Modul common.classifiers.
#
# Welche zusaetzlichen Parameter werden neben den Mischverteilungsparametern
# noch fuer die Klassifizierung benoetigt?
#
# Werten Sie Ihre Implementierung mit dem unten stehenden Code aus.
train_data_provider = DataProvider(DataProvider.DATA2DROOT_TRAIN)
train_data, train_labels = train_data_provider.get_dataset_and_labels()
test_data_provider = DataProvider(DataProvider.DATA2DROOT_TEST)
test_data, test_labels_gt = test_data_provider.get_dataset_and_labels()
quant = Lloyd()
classifier = MDClassifierClassIndep(quant, 10)
classifier.estimate(train_data, train_labels)
estimated_labels = classifier.classify(test_data)
evaluator = ClassificationEvaluator(estimated_labels, test_labels_gt)
print('Klassenunabhaengig:')
print(
'Fehlerrate: %.1f; Anzahl falsch-klassifizierte Muster: %d; Anzahl Muster: %d'
% evaluator.error_rate())
print('Klassenspezifische Fehlerraten')
for res in evaluator.category_error_rates():
print(
'Klasse %s:\tFehlerrate: %.1f;\tAnzahl falsch-klassifizierte Muster: %d;\tAnzahl Muster: %d'
% res)
cmap = cm.get_cmap('hsv')
fig = plt.figure()
ax = fig.add_subplot(111)
mean = classifier.mean
cov = classifier.cov
c = cmap(np.linspace(0, 1, len(cov)))
visualization.plot_norm_dist_ellipse(ax, mean, cov, c)
ax.scatter(train_data[:, 0],
train_data[:, 1],
c='#FFFFFF',
edgecolor=(0, 0, 0))
# Realisieren Sie den Mischverteilungsklassifikator mit klassenabhaengigen
# Komponentendichten. Implementieren Sie dazu die Klasse MDClassifierClassDep
# im Modul common.classifiers.
classifier = MDClassifierClassDep(quant, (1, 3, 1))
classifier.estimate(train_data, train_labels)
estimated_labels = classifier.classify(test_data)
evaluator = ClassificationEvaluator(estimated_labels, test_labels_gt)
print('\n##################################################\n')
print('Klassenabhaengig')
print(
'Fehlerrate: %.1f; Anzahl falsch-klassifizierte Muster: %d; Anzahl Muster: %d'
% evaluator.error_rate())
print('Klassenspezifische Fehlerraten')
for res in evaluator.category_error_rates():
print(
'Klasse %s:\tFehlerrate: %.1f;\tAnzahl falsch-klassifizierte Muster: %d;\tAnzahl Muster: %d'
% res)
classes = classifier.classifier
fig = plt.figure()
ax = fig.add_subplot(111)
for index, c in enumerate(classes):
cov = c.cov
col = [cmap(index / float(len(classes)))] * len(cov)
visualization.plot_norm_dist_ellipse(ax, c.mean, cov, col)
data = train_data_provider.get_class_arr(index)
ax.scatter(data[:, 0], data[:, 1], c=col, edgecolor=(0, 0, 0))
plt.show()
def aufg02():
# In dieser Aufgabe soll ein Bayes'scher Normalverteilungs-Klassifikator
# mit drei Dichten realisiert werden.
#
# Zunaechst sollen Mittelwert und Kovarianzmatrix der drei Klassen geschaetzt
# und visualisiert werden:
train_data_provider = DataProvider(DataProvider.DATA2DROOT_TRAIN)
train_data, train_labels = train_data_provider.get_dataset_and_labels()
train_labels = train_labels.astype('float64')
labels = np.unique(train_labels)
#
# Extrahieren Sie die Klassen-Labels aus dem Trainingsdatensatz und speichern
# Sie sie in der lokalen Variablen labels
#
# Nuetzliche Funktionen:
# https://docs.scipy.org/doc/numpy/reference/generated/numpy.unique.html
# raise NotImplementedError('Implement me')
mean_list = []
cov_list = []
for label in labels:
#
# Berechnen Sie Mittelwert und Kovarianz der drei Klassen durch
# Matrixoperationen in NumPy.
# Speichern Sie fuer jeden Schleifendurchlauf den Mittelwert in der
# lokalen Variablen mean und die Kovarianzmatrix in der lokalen Variablen
# cov. Benutzen Sie zur Schaetzung die korrigierte Kovarianzmatrix:
# https://de.wikipedia.org/wiki/Stichprobenkovarianz#Korrigierte_Stichprobenkovarianz
class_data = train_data[train_labels==label]
mean = sum(class_data)/len(class_data)
meanx = sum(class_data[:, 0])/len(class_data[:, 0])
meany = sum(class_data[:, 1])/len(class_data[:, 1])
sx = 1/(len(class_data[:, 0]) - 1) * sum((class_data[:, 0] - meanx)**2)
sy = 1/(len(class_data[:, 1]) - 1) * sum((class_data[:, 1] - meany)**2)
sxy = 1/(len(class_data[:,0]) - 1) * sum((class_data[:, 0] - meanx) * (class_data[:, 1] - meany))
cov = np.matrix([[sx, sxy], [sxy, sy]])
#raise NotImplementedError('Implement me')
np.testing.assert_almost_equal(actual=mean,
desired=np.mean(class_data, axis=0),
err_msg='Der Mittelwert ist falsch')
np.testing.assert_almost_equal(actual=cov,
desired=np.cov(class_data, rowvar=0),
err_msg='Die Kovarianzmatrix ist falsch')
mean_list.append(mean)
cov_list.append(cov)
#
# Visualisieren Sie die Datenpunkte der drei Klassen, sowie die geschaetzen
# Mittelwerte und Kovarianzmatrizen durch eine Normalverteilung.
# Zur Visualisierung der Normalverteilungen: visualization.plot_norm_dist_ellipse
fig = plt.figure()
ax = fig.add_subplot(111)
data = train_data_provider.get_class_arr(0)
ax.scatter(data[:, 0], data[:, 1], c='#FF0000', edgecolor=(0, 0, 0))
data = train_data_provider.get_class_arr(1)
ax.scatter(data[:, 0], data[:, 1], c='#00FF00', edgecolor=(0, 0, 0))
data = train_data_provider.get_class_arr(2)
ax.scatter(data[:, 0], data[:, 1], c='#0000FF', edgecolor=(0, 0, 0))
visualization.plot_norm_dist_ellipse(ax, mean_list, cov_list, color=['orange', 'darkgreen', 'cyan'])
plt.show()
# raise NotImplementedError('Implement me')
#
# Implementieren sie einen Bayes'schen Normalverteilungs-Klassifikator (ohne
# Rueckweisung), der die soeben berechneten Verteilungen als Modell
# verwendet. Vervollstaendigen Sie dazu die Klasse GaussianClassifier im Modul
# classification.
#
# Hinweise:
#
# Achten Sie darauf, dass Ihre Implementierung unabhaengig von den
# verwendeten Klassenlabels ist. Aus den Trainingsdaten lassen sich diese mit
# np.unique bestimmen.
# http://docs.scipy.org/doc/numpy/reference/generated/numpy.unique.html
#
# Durch welche geeignete monotone Transformation lassen sich numerische
# Probleme bei der Auswertung von extrem kleinen Dichtewerten vermeiden?
# Beruecksichtigen Sie das in Ihrer Implementierung.
test_data_provider = DataProvider(DataProvider.DATA2DROOT_TEST)
test_data, test_labels_gt = test_data_provider.get_dataset_and_labels()
test_labels_gt = test_labels_gt.astype('float64')
bayes = GaussianClassifier()
bayes.estimate(train_data, train_labels)
estimated_labels = bayes.classify(test_data)
#
# Fuehren Sie eine Evaluierung der Ergebnisse wie in Aufgabe 1 durch.
evals = ClassificationEvaluator(estimated_labels, test_labels_gt)
error_rate, n_wrong, n_samples = evals.error_rate()
print('Bayes:', error_rate, n_wrong, n_samples)
def aufg07():
#
# Im Gegensatz zu den bisher verwendeten Klassifikatoren, die Klassengebiete
# explizit ueber (Mischungen von) Gaussverteilungen modellieren, sollen nun
# diskriminative Klassifikatoren untersucht werden. Als besonders leistungs-
# faehig haben sich die in der Vorlesung behandelten Support Vector Maschinen
# erwiesen.
# Anhand der beiden bisher benutzten aber auch unter Verwendung eigener
# Datensaetze soll nun die Mustererkennung mittels Support Vector Machines
# untersucht werden.
# Fuer Python stellt die Bibliothek 'sklearn' die Implementierung einer SVM
# bereit.
# http://scikit-learn.org/stable/modules/svm.html#svm
# Zur Visualisierung der SVM kann die Funktion visualization.plot_svm
# genutzt werden.
# Der zweidimensionale Datensatz data2d enthaelt 3 Klassen.
# Trainieren Sie zunaechst eine lineare Support Vector Maschine, die zur
# Trennung von Klasse 0 und 2 verwendet werden soll. Klasse 1 wird hier
# nicht betrachtet, da sie sich nicht linear von den Klassen 0 und 2 trennen
# laesst (Siehe unten).
# Wie hoch ist der Klassifikationsfehler im Vergleich zum Normalverteilungs-
# klassifikator? Visualisieren Sie die resultierende Trennfunktion. Im Modul
# visualization steht dafuer die Methode plot_svm bereit.
# Diskutieren Sie den Einfluss der Slack-Variablen (in Form des C-Parameters)
# auf die Trennfunktion und damit den entstehenden Klassifikationsfehler.
#
# Fuer die Evaluierung koennen Sie im Folgenden wieder den ClassificationEvaluator
# aus dem Modul common.classifiers verwenden.
train_data_provider = DataProvider(DataProvider.DATA2DROOT_TRAIN)
test_data_provider = DataProvider(DataProvider.DATA2DROOT_TEST)
train_data, train_labels = train_data_provider.get_dataset_and_labels()
test_data, test_labels_gt = test_data_provider.get_dataset_and_labels()
train_labels = train_labels.astype(dtype='float64')
test_labels_gt = test_labels_gt.astype(dtype='float64')
train_data_02 = np.concatenate((train_data_provider.get_class_arr(0),
train_data_provider.get_class_arr(2)))
train_labels_02 = np.concatenate(
(train_labels[train_labels == 0], train_labels[train_labels == 2]))
test_data_02 = np.concatenate((test_data_provider.get_class_arr(0),
test_data_provider.get_class_arr(2)))
test_labels_02 = np.concatenate((test_labels_gt[test_labels_gt == 0],
test_labels_gt[test_labels_gt == 2]))
clf = svm.LinearSVC()
clf.fit(train_data_02, train_labels_02)
estimated_labels = clf.predict(test_data_02)
evals = ClassificationEvaluator(estimated_labels, test_labels_02)
error_rate, n_wrong, n_samples = evals.error_rate()
print(error_rate, n_wrong, n_samples)
fig = plt.figure()
ax = fig.add_subplot(111)
visualization.plot_svm(ax,
test_data_02,
test_labels_02,
clf,
step_size=0.1)
#plt.show()
# raise NotImplementedError('Implement me')
# Trainieren Sie nun eine SVM fuer die Klassen 1 und 2.
# Evaluieren Sie, welcher Kernel geeignet ist, um das Problem zu loesen.
train_data_12 = np.concatenate((train_data_provider.get_class_arr(1),
train_data_provider.get_class_arr(2)))
train_labels_12 = np.concatenate(
(train_labels[train_labels == 1], train_labels[train_labels == 2]))
test_data_12 = np.concatenate((test_data_provider.get_class_arr(1),
test_data_provider.get_class_arr(2)))
test_labels_12 = np.concatenate((test_labels_gt[test_labels_gt == 1],
test_labels_gt[test_labels_gt == 2]))
kernels = ['linear', 'poly', 'rbf', 'sigmoid']
for kernel in kernels:
clf = svm.SVC(kernel=kernel)
clf.fit(train_data_12, train_labels_12)
estimated_labels = clf.predict(test_data_12)
evals = ClassificationEvaluator(estimated_labels, test_labels_12)
error_rate, n_wrong, n_samples = evals.error_rate()
print(kernel, error_rate, n_wrong, n_samples)
fig = plt.figure()
ax = fig.add_subplot(111)
visualization.plot_svm(ax,
test_data_12,
test_labels_12,
clf,
step_size=0.1)
#plt.show()
# raise NotImplementedError('Implement me')
# Trainieren Sie nun eine Multi-Class SVM zur Loesung des 3-Klassenproblems
# unter Verwendung eines geeigneten Kernels.
# Wie koennen die optimalen kernelspezifischen Parameter sinnvoll ermittelt
# werden?
# Hinweis: Starten Sie zunaechst mit den Grundeinstellungen der Bibliothek.
clf = svm.SVC()
clf.fit(train_data, train_labels)
estimated_labels = clf.predict(test_data)
evals = ClassificationEvaluator(estimated_labels, test_labels_gt)
error_rate, n_wrong, n_samples = evals.error_rate()
print('3 Klassen: bcf', error_rate, n_wrong, n_samples)
fig = plt.figure()
ax = fig.add_subplot(111)
visualization.plot_svm(ax, test_data, test_labels_gt, clf, step_size=0.1)
def aufg01():
# Zur Einfuehrung werden auf einem Beispieldatensatz Klassifikatoren
# implementiert. Der Datensatz data2d enthaelt zweidimensionalen
# Trainingsmerkmale fuer drei Musterklassen. Fuer diese Daten soll eine
# Klassifikation ueber Naechster-Nachbar realisiert werden.
# Achtung: Gestalten Sie Ihre Implementierung so, dass Sie die Klassifikatoren
# fuer zukuenftige Aufgaben wiederverwenden koennen.
# Im Folgenden wird der Beispieldatensatz ueber die Klasse DataProvided
# geladen und anschliessend visualisiert. Machen Sie sich mit sowohl dem
# Laden als auch der Visualisierung vertraut, da Sie in den kommenden
# Aufgaben diese Aspekte wiederverwenden werden.
# http://matplotlib.org/users/pyplot_tutorial.html
#
# Nuetzliche Funktionen: plt.scatter
# http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.scatter
#
# Tipp: zu einer besseren Visualisierung sollten alle scatter plots in Matplotlib
# immer mit dem Argument "edgecolor=(0, 0, 0)" aufgerufen werden.
train_data_provider = DataProvider(DataProvider.DATA2DROOT_TRAIN)
test_data_provider = DataProvider(DataProvider.DATA2DROOT_TEST)
fig = plt.figure()
ax = fig.add_subplot(111)
data = train_data_provider.get_class_arr(0)
ax.scatter(data[:, 0], data[:, 1], c='#FF0000', edgecolor=(0, 0, 0))
data = train_data_provider.get_class_arr(1)
ax.scatter(data[:, 0], data[:, 1], c='#00FF00', edgecolor=(0, 0, 0))
data = train_data_provider.get_class_arr(2)
ax.scatter(data[:, 0], data[:, 1], c='#0000FF', edgecolor=(0, 0, 0))
plt.show()
# Implementieren Sie einen Naechster-Nachbar-Klassifikator.
# Vervollstaendigen Sie dazu die Klasse KNNClassifier im Modul common.classifiers.
# Testen Sie verschiedene Abstandsmasse. Welche halten Sie insbesondere fuer sinnvoll?
train_data, train_labels = train_data_provider.get_dataset_and_labels()
test_data, test_labels_gt = test_data_provider.get_dataset_and_labels()
knn_classifier = KNNClassifier(k_neighbors=29, metric='euclidean')
knn_classifier.estimate(train_data, train_labels)
estimated_labels = knn_classifier.classify(test_data)
# Nutzen Sie zur Evaluation der Ergebnisse die Klasse ClassificationEvaluator
# im Modul common.classifiers.
evaluator = ClassificationEvaluator(estimated_labels, test_labels_gt)
print("Error rate {}".format(evaluator.error_rate()))
print("Category error rate {}".format(evaluator.category_error_rates()))
# Ein NN-Klassifikator alleine ist meist nicht ausreichend. Erweitern Sie
# den Klassifikator zum k-NN Klassifikator.
# Fuer den Mehrheitsentscheid ist das defaultdict nuetzlich (siehe intro).
# https://docs.python.org/2/library/collections.html#collections.defaultdict
# Trainingsparameter sollten immer per Kreuzvalidierung auf den Trainingsdaten
# optimiert werden. Mit den besten Parametern wird dann ein Klassifikator
# erstellt und auf den Testdaten evaluiert.
# Nutzen Sie die Klasse CrossValidation im Modul classification um den
# Parameter k zu optimieren.
# In den folgenden Aufgaben ist es Ihnen freigestellt, ob Sie Kreuzvalidierung
# nutzen oder direkt auf den Testdaten optimieren.
cross_vali = CrossValidation(train_data, train_labels, 5)
over_all_result, class_result = cross_vali.validate(
KNNClassifier(k_neighbors=10, metric='euclidean'))
print("Over all result:".format(over_all_result))
print("class_result:".format(class_result))
def aufg05():
#
# Realisieren Sie eine Hauptachsen-Transformation (PCA) in der Klasse PCA.
# Zunaechst schauen wir uns das Prinzip an einem Spielbeispiel an.
#
# Mit der Methode pca_example wird die PCA anhand eines
# 3D-Beispieldatensatzes visualisiert.
# Nuetzliche Funktionen: np.linalg.eig
# http://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.eig.html
# Achten Sie darauf, dass die NumPy Methode np.linalg.eig komplexwertige Ergebnisse
# liefern kann. Dies kann an numerischen Ungenauigkeiten liegen. Verwenden Sie in
# diesem Fall nur den Realteil.
pca_example()
#
# Nachdem bisher mit artifiziellen Datensaetzen gearbeitet wurde, wenden wir
# uns jetzt realen Daten zu. Dazu verwenden wir den MNIST-Datensatz der
# Grauwert-Bilder handgeschriebener Ziffern enthaelt. Der MNIST-Datensatz
# besteht im Original aus 60000 Trainingsbildern und 10000 Testbildern. Um
# den Aufwand geringer zu halten, werden im Rahmen dieser Uebung
# lediglich 1000 zufaellig ausgewaehlte Trainingsbilder pro Klasse verwendet.
#
# Somit ergibt sich ein Trainingsdatensatz von 10000 sowie ein
# Testdatensatz von 10000 Bildern.
#
# Die 28 x 28 Pixel grossen Bilder koennen als 784-dimensionale Merkmalsvektoren
# aufgefasst werden.
#
# Laden Sie die Trainingsdaten des MNIST-Datensatz.
# Das Laden des Datensatzes kann einige Sekunden in Anspruch nehmen.
# Mit show_data(data, width) koennen Sie Bilder anzeigen lassen. Die Anzahl der
# Bilder muss ein Vielfaches des Parameters width sein.
train_data_provider = DataProvider(DataProvider.MNIST_TRAIN)
train_data, train_label = train_data_provider.get_dataset_and_labels()[:10000]
show_data(train_data[:10],10)
plt.show()
#raise NotImplementedError('Implement me')
# Transformieren Sie die 784-dimensionalen Daten des MNIST-Datensatzes in
# einen geeignet gewaehlten niedriger-dimensionalen Merkmalsraum. Begruenden
# Sie die gewaehlte Groesse.
# Hinweis: Die Unterraumdimension laesst sich mit der moeglichen
# Rekonstruktionsqualitaet verknuepfen.
# Es ist empfehlenswert, die dimensionsreduzierten Daten fuer die spaetere
# Nutzung zu speichern.
# Nuetzliche Funktion: DataProvider.write_data oder pickle
# Achten Sie darauf, dass DataProvider.write_data ein dictionary als
# Eingabe erwartet.
# Zu pickle finden Sie weitere Informationen hier:
# https://docs.python.org/2/library/pickle.html
# https://wiki.python.org/moin/UsingPickle
# Optional: Visualisieren Sie die MNIST-Daten in einem 2D Unterraum. Faerben Sie
# die Datenpunkte nach Klassenzugehoerigkeit.
train_data = train_data.astype(np.float64)
pca = PCA(train_data)
samplezweid = np.transpose(pca.transform_samples(train_data, 2))
fig = plt.figure()
ax = fig.add_subplot(111)
for label in np.unique(train_label):
class_data = samplezweid[train_label==label]
ax.scatter(class_data[:,0], class_data[:,1], label=label, alpha=0.6)
plt.legend()
plt.show()