<jupyter_start><jupyter_text>Einführung in Machine Learning Online Version: http://bit.ly/data2day-ml  Grundidee des Supervised Machine Learnings![Machine Learning](https://djcordhose.github.io/ai/img/sketch/ml.jpg "Machine Learning") Grundhoffnung: Generalisierung auf bisher unbekannte Daten und Situationen  Häufiger Anwendungsfall: Klassifikation![Machine Learning Classification](https://djcordhose.github.io/ai/img/sketch/classification.jpg "Machine Learning Classification")<jupyter_code>import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
%pylab inline
import matplotlib.pylab as plt
import numpy as np
from distutils.version import StrictVersion
import sklearn
print(sklearn.__version__)

assert StrictVersion(sklearn.__version__ ) >= StrictVersion('0.18.1')
# Evtl. hat Azure nur 0.19, wir brauchen aber .20 für das Plotting, dann das hier installieren und Notebook neu starten
# !conda update pandas -y
import pandas as pd
print(pd.__version__)

assert StrictVersion(pd.__version__) >= StrictVersion('0.20.0')<jupyter_output>0.20.3<jupyter_text>Der Klassiker als Beispiel: Lilien anhand von Blütengrößen unterscheiden  Zuerst laden wir den Iris Datensatz und verschaffen uns einen ersten Eindruck* https://de.wikipedia.org/wiki/Portal:Statistik/DatensaetzeIris* Sepal: Sepalum, Kelchblatt: der grüne Teil der das bunte umschließt: https://de.wikipedia.org/wiki/Kelchblatt* Petal: Petalum, Kronblatt: der bunte Teil, den wir allgemein als Blüte wahrnehmen: https://de.wikipedia.org/wiki/Kronblatt<jupyter_code>from sklearn.datasets import load_iris
iris = load_iris()
print(iris.DESCR)
X = iris.data
y = iris.target
X.shape, y.shape
X[0]
y[0]
X_sepal_length = X[:, 0]
X_sepal_width =  X[:, 1]
X_petal_length = X[:, 2]
X_petal_width = X[:, 3]
X_petal_width.shape<jupyter_output><empty_output><jupyter_text>Nur eine Art ist linear von den beiden anderen trennbar<jupyter_code>import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap

iris_df = pd.DataFrame(iris.data, columns=iris.feature_names)
CMAP = ListedColormap(['#FF0000', '#00FF00', '#0000FF'])
pd.plotting.scatter_matrix(iris_df, c=iris.target, edgecolor='black', figsize=(15, 15), cmap=CMAP)
plt.show()<jupyter_output><empty_output><jupyter_text>Problem: Wie wissen wir, ob wir unser System gut trainiert haben? Aufteilung der Daten in Training (60%) und Test (40%)http://scikit-learn.org/stable/modules/cross_validation.html<jupyter_code>from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=42, stratify=y)
X_train.shape, y_train.shape, X_test.shape, y_test.shape<jupyter_output><empty_output><jupyter_text>Wir trainieren einen einfachen KNN Klassifikator mit 2 Features und überprüfen die Ergebnissehttp://scikit-learn.org/stable/modules/neighbors.htmlclassification![KNN](https://djcordhose.github.io/ai/img/flashcards/Imputation_Using_k-NN.png "KNN")<jupyter_code>from sklearn import neighbors
# ignore this, it is just technical code
# should come from a lib, consider it to appear magically 
# http://scikit-learn.org/stable/auto_examples/neighbors/plot_classification.html

import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap

cmap_bold = ListedColormap(['#FF0000', '#00FF00', '#0000FF'])
cmap_light = ListedColormap(['#FFAAAA', '#AAFFAA', '#AAAAFF'])
font_size=25

def meshGrid(x_data, y_data):
    h = .02  # step size in the mesh
    x_min, x_max = x_data.min() - 1, x_data.max() + 1
    y_min, y_max = y_data.min() - 1, y_data.max() + 1
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                         np.arange(y_min, y_max, h))
    return (xx,yy)
    
def plotPrediction(clf, x_data, y_data, x_label, y_label, colors, title="", mesh=True):
    xx,yy = meshGrid(x_data, y_data)
    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])

    # Put the result into a color plot
    Z = Z.reshape(xx.shape)
    plt.figure(figsize=(20,10))
    if mesh:
        plt.pcolormesh(xx, yy, Z, cmap=cmap_light)
    plt.xlim(xx.min(), xx.max())
    plt.ylim(yy.min(), yy.max())
    plt.scatter(x_data, y_data, c=colors, cmap=cmap_bold, s=80, marker='o')
    plt.xlabel(x_label, fontsize=font_size)
    plt.ylabel(y_label, fontsize=font_size)
    plt.title(title, fontsize=font_size)<jupyter_output><empty_output><jupyter_text>Zuerst für die Sepal Features<jupyter_code>X_train_sepal_only = X_train[:, :2]
X_test_sepal_only = X_test[:, :2]
X_train_sepal_only[0]
X_train[0]<jupyter_output><empty_output><jupyter_text>Training ist sehr schnell, weil wir uns nur jeden der Punkte merken<jupyter_code>clf_sepal = neighbors.KNeighborsClassifier(1)
%time clf_sepal.fit(X_train_sepal_only, y_train)
plotPrediction(clf_sepal, X_train_sepal_only[:, 0], X_train_sepal_only[:, 1], 
               'Sepal length', 'Sepal width', y_train, mesh=False,
                title="Train Data for Sepal Features")<jupyter_output><empty_output><jupyter_text>Ein kleiner Test mit einem einzelnen, bisher unbekannten Datensatz<jupyter_code># 8 ist schwer, weil direkt zwischen 1 und 2
sample_id = 8
# sample_id = 50
sample_feature = X_test_sepal_only[sample_id]
sample_label = y_test[sample_id]
sample_feature
sample_label
clf_sepal.predict([sample_feature])<jupyter_output><empty_output><jupyter_text>Generalisierung funktioniert grundsätzlich, wir probieren es mit einem ausgedachten Wert, der in keinem Datensatz vorkommt<jupyter_code>clf_sepal.predict([[6.0, 4.5]]) # slightly different from above, still gives 0<jupyter_output><empty_output><jupyter_text>Wir berechnen nun welcher Anteil der Daten richtig vorhergesagt werden kann<jupyter_code># clf_sepal.score?
clf_sepal.score(X_train_sepal_only, y_train)
clf_sepal.score(X_test_sepal_only, y_test)<jupyter_output><empty_output><jupyter_text>Scores sind ok für die Trainingsdaten, aber nicht so toll für Testdaten, das bedeutet vor allem Overfitting Um zu versehen, was das heißt und was passiert ist, zeichnen wir die Decision Boundaries einFür jeden möglichen Datenpunkte zeichnen wir flächig die Vorhersage ein<jupyter_code>plotPrediction(clf_sepal, X_train_sepal_only[:, 0], X_train_sepal_only[:, 1], 
               'Sepal length', 'Sepal width', y_train,
               title="Highly Fragmented Decision Boundaries for Train Data")
plotPrediction(clf_sepal, X_test_sepal_only[:, 0], X_test_sepal_only[:, 1],
               'Sepal length', 'Sepal width', y_test,
               title="Same Decision Boundaries don't work well for Test Data")<jupyter_output><empty_output><jupyter_text>Wir machen das Modell weniger komplex, allgemeiner![KNN Size](https://djcordhose.github.io/ai/img/flashcards/K-NN_Neighborhood_Size.png "KNN Size")  Jetzt mit k=10 Nachbarn<jupyter_code># neighbors.KNeighborsClassifier?
clf_sepal_10 = neighbors.KNeighborsClassifier(10)
clf_sepal_10.fit(X_train_sepal_only, y_train)
clf_sepal_10.score(X_train_sepal_only, y_train)
clf_sepal_10.score(X_test_sepal_only, y_test)<jupyter_output><empty_output><jupyter_text>Das ist nun klares Underfitting, das Modell ist zu simpel, sogar für die Trainingsdaten<jupyter_code>plotPrediction(clf_sepal_10, X_train_sepal_only[:, 0], X_train_sepal_only[:, 1], 
               'Sepal length', 'Sepal width', y_train,
               title="Model too simple even for Train Data")
plotPrediction(clf_sepal_10, X_test_sepal_only[:, 0], X_test_sepal_only[:, 1], 
               'Sepal length', 'Sepal width', y_test,
               title="Model also too simplefor Test Data")<jupyter_output><empty_output><jupyter_text>Zusammenhang Overfittung / Underfitting* Schwarze Punkte: Trainingsdaten* Graue Punkte: Testdaten![Overfitting, Underfitting](https://djcordhose.github.io/ai/img/bias_variance/underfitting_overfitting.png "Overfitting, Underfitting")  Feature Selektion Spoiler Alert: Mit den Sepal Features werden wir immer entweder overfitten oder underfitten Wir versuchen es noch einmal mit den Petal Features<jupyter_code>X_train_petal_only = X_train[:, 2:]
X_test_petal_only = X_test[:, 2:]
X_train_petal_only[0]
X_train[0]
clf_petal_10 = neighbors.KNeighborsClassifier(10)
clf_petal_10.fit(X_train_petal_only, y_train)
plotPrediction(clf_petal_10, X_train_petal_only[:, 0], X_train_petal_only[:, 1], 
               'Petal length', 'Petal width', y_train,
               title="Simple model looks good for Train Data")
plotPrediction(clf_petal_10, X_test_petal_only[:, 0], X_test_petal_only[:, 1], 
               'Petal length', 'Petal width', y_test,
               title="Simple model looks good even for Test Data")
clf_petal_10.score(X_train_petal_only, y_train)
clf_petal_10.score(X_test_petal_only, y_test)<jupyter_output><empty_output><jupyter_text>Das klappt schon erstaunlich gut, aber was kriegen wir mit allen 4 Features hin?<jupyter_code>clf = neighbors.KNeighborsClassifier(1)
clf.fit(X_train, y_train)
clf.score(X_train, y_train)
clf.score(X_test, y_test)<jupyter_output><empty_output><jupyter_text>Mit nur einem Nachbarn kriegen wir die Trainingsdaten perfekt hin, overfitten aber leicht Probieren wir es also mit mehr Nachbarn<jupyter_code>clf = neighbors.KNeighborsClassifier(13)
clf.fit(X_train, y_train)
clf.score(X_train, y_train)
clf.score(X_test, y_test)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.10597031097627045, 'fraction_numerical': 0.015494636471990465, 'mean_word_length': 6.024353120243531, 'pattern_counts': {'":': 0, '<': 64, '<?xml version=': 0, '>': 66, 'https://': 8, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '16', 'dir': 'jupyter-structured-clean-dedup', 'id': '159364', 'license': 'MIT', 'n_tokens_mistral': 3531, 'n_tokens_neox': 3440, 'n_words': 735, 'path': 'notebooks/talks/2017_intro_data2day.ipynb', 'repo_name': 'subodhchhabra/ai', 'size': '9229'}