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 aufg09():
#
# In dieser Aufgabe geht es um die Klassifikation mit neuronalen Netzen.
#
# Dazu sollen Sie ein einschichtiges (kein Hidden Layer) neuronales Netz
# zur Klassifikation auf dem data2d Datensatz verwenden.
# Ueberlegen Sie zunaechst welche Klassifikationsprobleme sich mit dieser
# Netzwerk-Topologie loesen lassen und waehlen Sie den Trainings- und
# Testdatensatz entsprechend.
#
# Implementieren Sie nun Training und Test fuer ein neuronales Netz, welches
# zwei Eingabe und ein Ausgabeneuron enthaehlt. Beruecksichtigen Sie auch das bias-Gewicht.
# Verwenden Sie sowohl eine lineare als auch eine nicht-lineare Aktivierungsfunktion
# im Ausgabeneuron.
#
# Visualisieren Sie den mittleren quadratischen Fehler ueber alle Iterationen.
# Visualisieren Sie das neuronale Netz ueber einige (optional alle) Iterationen durch
# Methode die plot_hyperplane im Modul common.visualization. Orientieren Sie sich an der
# Implementierung von plot_svm. Fuer die Erzeugung passender Funktionsobjekte koennen
# anonyme (lambda) Funktionen hilfreich sein.
#
# Hinweise:
# - Das oben beschriebene neuronale Netz laesst sich durch eine Matrixmultiplikation
# auswerten.
# - Beim batch Training koennen Sie pro Iterationsschritt die Aenderung der Gewichte
# ueber alle Samples mitteln.
# - Waehlen Sie die Lernrate nicht zu gross.
# - Den Klassenrumpf finden Sie im Modul common.classification.
#
#
# Was ist bei der Initialisierung des Trainings zu beachten?
# Was ist bei der Terminierung des Trainings zu beachten?
# Optional: Verwenden Sie eine Validierungsstichprobe.
# Welchen Zweck erfuellt das bias-Gewicht?
# Wie wirken sich unterschiedliche Lernraten aus?
# Wie wirken sich unterschiedliche Aktivierungsfunktionen aus?
# Wie verhalten sich die Ergebnisse im Vergleich zu einer linearen 2-Klassen SVM?
train_data_provider = DataProvider(DataProvider.DATA2DROOT_TRAIN)
test_data_provider = DataProvider(DataProvider.DATA2DROOT_TEST)
VISUALIZE = True
if VISUALIZE:
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()
# Zwei Klassen, welche mit einem einschichtigen neuronalen Netz separierbar sind, auswaehlen
raise NotImplementedError('Implement me')
# Waehlen Sie eine geeignete Lernrate und die Anzahl von Trainingsiterationen
lr = 0
max_iterations = 0
nn = NeuralNetwork(learning_rate=lr,
iterations=max_iterations,
activation='Linear')
nn.estimate(train_data, train_labels)
nn_result_labels = nn.classify(test_data, iteration=100)
#
# Nutzen Sie zur Evaluation der Ergebnisse die Klasse ClassificationEvaluator
# im Modul common.classifiers und visualisieren Sie die Ergebnisse.
raise NotImplementedError('Implement me')
