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()