add README for task 1

print(__doc__)

# Code source: Gaël Varoquaux

#              Andreas Müller

# Modified for documentation by Jaques Grobler and for teaching purposes by Letitia Parcalabescu

# License: BSD 3 clause

import numpy as np

import matplotlib.pyplot as plt

from matplotlib.colors import ListedColormap

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

from sklearn.datasets import make_moons, make_circles, make_classification

from sklearn.neural_network import MLPClassifier

from sklearn.neighbors import KNeighborsClassifier

from sklearn.svm import SVC

from sklearn.gaussian_process.kernels import RBF

from sklearn.tree import DecisionTreeClassifier

from sklearn.ensemble import RandomForestClassifier

from sklearn.naive_bayes import GaussianNB

from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis

h = .02  # step size in the mesh

names = ["Nearest Neighbors", "Linear SVM", "Kernel SVM",

         "Decision Tree", "Random Forest", "Neural Net",

         "Naive Bayes"]

classifiers = [

    KNeighborsClassifier(3),

    SVC(kernel="linear", C=0.025),

    SVC(gamma=2, C=1),

    DecisionTreeClassifier(max_depth=5),

    RandomForestClassifier(max_depth=5, n_estimators=10, max_features=1),

    MLPClassifier(alpha=1, max_iter=1000),

    GaussianNB()]

X, y = make_classification(n_features=2, n_redundant=0, n_informative=2,

                           random_state=1, n_clusters_per_class=1)

rng = np.random.RandomState(2)

X += 2 * rng.uniform(size=X.shape)

linearly_separable = (X, y)

datasets = [make_moons(noise=0.3, random_state=0),

            make_circles(noise=0.2, factor=0.5, random_state=1),

            linearly_separable

            ]

figure = plt.figure(figsize=(27, 11))

i = 1

# iterate over datasets

for ds_cnt, ds in enumerate(datasets):

    # preprocess dataset, split into training and test part

    X, y = ds

    X = StandardScaler().fit_transform(X)

    X_train, X_test, y_train, y_test = \

        train_test_split(X, y, test_size=.4, random_state=42)

    x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5

    y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5

    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),

                         np.arange(y_min, y_max, h))

    # just plot the dataset first

    cm = plt.cm.RdBu

    cm_bright = ListedColormap(['#FF0000', '#0000FF'])

    ax = plt.subplot(len(datasets), len(classifiers) + 1, i)

    if ds_cnt == 0:

        ax.set_title("Input data")

    # Plot the training points

    ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright,

               edgecolors='k')

    # Plot the testing points

    ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.6,

               edgecolors='k')

    ax.set_xlim(xx.min(), xx.max())

    ax.set_ylim(yy.min(), yy.max())

    ax.set_xticks(())

    ax.set_yticks(())

    i += 1

    # iterate over classifiers

    for name, clf in zip(names, classifiers):

        ax = plt.subplot(len(datasets), len(classifiers) + 1, i)

        clf.fit(X_train, y_train)

        score = clf.score(X_test, y_test)

        # Plot the decision boundary. For that, we will assign a color to each

        # point in the mesh [x_min, x_max]x[y_min, y_max].

        if hasattr(clf, "decision_function"):

            Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])

        else:

            Z = clf.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1]

        # Put the result into a color plot

        Z = Z.reshape(xx.shape)

        ax.contourf(xx, yy, Z, cmap=cm, alpha=.8)

        # Plot the training points

        ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright,

                   edgecolors='k')

        # Plot the testing points

        ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright,

                   edgecolors='k', alpha=0.6)

        ax.set_xlim(xx.min(), xx.max())

        ax.set_ylim(yy.min(), yy.max())

        ax.set_xticks(())

        ax.set_yticks(())

        if ds_cnt == 0:

            ax.set_title(name)

        ax.text(xx.max() - .3, yy.min() + .3, ('%.2f' % score).lstrip('0'),

                size=15, horizontalalignment='right')

        i += 1

plt.tight_layout()

plt.show() # not needed in interactive Jupyter session

 No newline at end of file

# 02_Übung

# Beschreibung

Dieser Ordner enthält die Lösungen für das Übungsblatt 2 It`s time for Machine Learning

# Aufgabe 1: 

- Zeile 30 - 38: initalisiere die benutzten  ML Methoden mit ihren jeweiligen Parametern

    - Knearest Neighbor bei für die Klassifikation eines Punktes jeweils seine 3 Nachbarn berücksichtigt werden 

    - SVC mit einem linaren Kernel und einem regularization parameter $C=0.025$

    - SVC mit einem rbf Kernel mit $\gamma$=2,regularization parameter $C=1$

    - Decision Tree Classifier 

    - Random Forest Classifier 

    - Ein neuronales Netz das mit 1000 Iterationen über die Trainingdaten trainiert wird 

    - Gaussian Naive Bayes

- Zeile 39: lasse ein zufälliges Datenset von sklearn erzeugen mit zwei nicht redudanten

  Feautures und zwei Klassen die jeweils ein Cluster haben

- Zeile 45: erzeuge drei weitere Datensets mit sklearn und füge das in Zeile 39 erzeugte Datenset hinzu, jedes Datenset besteht aus einem Array von samples und dem dazugehörige Klassenlabel 

- Zeile 56: hier findet das Preprocessing statt: diese Daten werden als Vektoren repräsentiert und anschließend wird der Mittelwert der Repräsentationen abgezogen und schlussendlich skaliert  mit der Standardvarianz der gewählten Repräsentation 

- Zeile 57: teilt das Datenset auf: $\frac{3}{4}$ des Datenset werden Trainingsdaten und der Rest sind Testdaten. Beide sind aufgeteilt in die tatsächlichen Daten und ein dem Daten zugewiesenes Label.

- Zeile 60-62: erzeugt ein (x_max -x_min) * (y_max-y_min) großes Rechteck das jede Kombinastion von x und y zwischen  (x_max -x_min) und (y_max -y_min) enthält.

Dieses Rechteck wird später genutzt um darauf die Trainings- und Testdaten zu zeichnen.

- Zeile 66-81: Zeichnet die Trainings- und Testdaten auf dem vorher erstellten Rechteck und nimmt noch eine Achseneinteilung und eine Achsenbeschriftung vor

- Zeile 84 -115: iteriert über jeden oben erstellen Classifier und den Namen und

  plottet die Decision boundary,die Trainings und Testdaten und  nimmt noch eine Achseneinteilung und eine Achsenbeschriftung vor. 

  Zwei Zeilen sind in dem Abschnitt dabei besonders relevant:

  - Zeile 86: trainiere den in der aktuellen Iteration ausgewählten Classifier auf den Trainingsdaten

  - Zeile 87: hier wird evaluiert, dafür wird die durschnittliche Accuary(=Genauigkeit) des in der aktuellen Iteration ausgewählten Classifier auf den Testdaten berechnet

 No newline at end of file