Dieser Artikel ist eine Auffrischung der praktischen Lernsitzung Tech-Circle Beginnen wir mit der Anwendungsentwicklung mithilfe von maschinellem Lernen ... Dies ist eine angepasste Version des PyCon 2015 Tutorial, das oben angekündigt wurde.

Tor

Verstehen Sie die Umrisse des maschinellen Lernens
Erhalten Sie Hinweise zur Verwendung von maschinellem Lernen
Holen Sie sich eine Entwicklungsumgebung für maschinelles Lernen

Vorbereitungen

Der folgende Artikel fasst das Verfahren zum Erstellen einer Umgebung zusammen. Richten Sie es daher entsprechend Ihrer Umgebung ein.

Erstellen einer Entwicklungsumgebung für maschinelles Lernen mit Python

Erklärung zum maschinellen Lernen

Zunächst werde ich die Umrisse des maschinellen Lernens erläutern.

Machine Learning Bootstrap

Praktischer Start ab P37. Die Folien sind die Erklärungen, und dieser Artikel ist das Verfahren zum Bewegen Ihrer Hände. Lesen Sie daher bitte die Erklärungen auf den Folien -> probieren Sie das Verfahren aus.

Praktisches Verfahren

** Hands-on basiert auf Python 3 **

# 0 Vorbereitung

# 0-1 Quellcode herunterladen

** Fork ** das folgende GitHub-Repository und lade es von dort herunter icoxfog417/number_recognizer

Sie können es so klonen, wie es ist, aber wenn Sie nicht gabeln, können Sie nicht reflektieren, was Sie gelernt haben.

# 0-2 Überprüfung des Anwendungsbetriebs

Virtuelle Umgebung aktivieren

(Im Folgenden wird davon ausgegangen, dass Sie sich wie im Voraus vorbereitet vorbereitet haben (erstellen Sie eine virtuelle Umgebung ml_env mit conda). Wenn Sie diese geändert haben, lesen Sie sie bitte entsprechend.)

Windows

activate ml_env

Mac/Linux

#Aktivieren Sie den Pfad der virtuellen Umgebung und führt ihn direkt aus, um zu verhindern, dass Sie mit pyenv spielen
conda info -e
# conda environments:
#
ml_env                   /usr/local/pyenv/versions/miniconda3-3.4.2/envs/ml_env
root                  *  /usr/local/pyenv/versions/miniconda3-3.4.2

source /usr/local/pyenv/versions/miniconda3-3.4.2/envs/ml_env/bin/activate ml_env

Funktionsprüfung

Anwendung (gestartet bei localhost: 3000)

Führen Sie run_application.py direkt unter dem Ordner number_recognition aus.

python run_application.py

IPython-Notebook zum Erstellen von Modellen für maschinelles Lernen (gestartet bei localhost: 8888)

Führen Sie direkt unter "number_recognition / machine / number_recognizer" Folgendes aus.

ipython notebook

Die Anwendung fühlt sich zunächst sehr schlecht an. Ich werde das schlauer machen.

# 1 Erleben Sie den Prozess der Erstellung eines maschinellen Lernmodells

Öffnen Sie das iPython-Notizbuch. Hier finden Sie jeden Schritt des maschinellen Lernens in der richtigen Reihenfolge. Da der Code im Satz tatsächlich mit dem iPython-Notizbuch ausgeführt werden kann, erklären wir ihn und führen ihn in der Reihenfolge von oben aus (siehe hier für eine detaillierte Verwendung. Bitte gib mir).

Wenn Sie zum letzten Speichern gehen, sollte das Modell (number_recognition / machine / number_recognizer / machine.pkl) tatsächlich aktualisiert werden.

# 2 Teilen Sie die Trainingsdaten

Handson # 2 Erklärung

Hier werden wir die folgenden zwei Dinge ausführen.

Teilen Sie die Daten in Lernen und Auswerten
Berechnen Sie die Genauigkeit für Trainingsdaten bzw. die Genauigkeit für Bewertungsdaten.

Verwenden Sie cross_validation.train_test_split, um die Trainingsdaten aufzuteilen. Verwenden Sie diese Option und führen Sie die folgende Verarbeitung durch, bevor Sie das Modell trainieren.

def split_dataset(dataset, test_size=0.3):
    from sklearn import cross_validation
    from collections import namedtuple

    DataSet = namedtuple("DataSet", ["data", "target"])
    train_d, test_d, train_t, test_t = cross_validation.train_test_split(dataset.data, dataset.target, test_size=test_size, random_state=0)

    left = DataSet(train_d, train_t)
    right = DataSet(test_d, test_t)
    
    return left, right

# use 30% of data to test the model
training_set, test_set = split_dataset(digits, 0.3)
print("dataset is splited to train/test = {0} -> {1}, {2}".format(
        len(digits.data), len(training_set.data), len(test_set.data))
     )

Da wir die Daten oben in "training_set" und "test_set" aufgeteilt haben, ändern Sie das Training des Modells wie folgt.

classifier.fit(training_set.data, training_set.target)

Das Lernen ist jetzt abgeschlossen. Dank der geteilten Daten haben wir 30% der Daten zur Auswertung. Mit dieser Option können Sie die Genauigkeit nicht trainierter Daten messen.

Ändern Sie den Genauigkeitsberechnungsteil von Modell bewerten wie folgt.

print(calculate_accuracy(classifier, training_set))
print(calculate_accuracy(classifier, test_set))

# 3 Bewerten Sie das Modell

Handson # 3 Erklärung

Messen Sie, wie sich die Genauigkeit der einzelnen Trainingsdaten und Bewertungsdaten ändert, um zu überprüfen, ob sie übertrainiert sind.
Überprüfen Sie die Genauigkeit und den Rückruf, um zu verhindern, dass "was für ein hochgenaues Modell" aufgrund eines Datenungleichgewichts auftritt.

Bestätigung der Genauigkeit für Trainings- / Bewertungsdaten

Überprüfen Sie den Genauigkeitsübergang für Trainings- / Bewertungsdaten mit dem folgenden Skript. Dieses Diagramm mit der Anzahl der Trainingsdaten auf der horizontalen Achse und der Genauigkeit auf der vertikalen Achse wird als Lernkurve bezeichnet. In scikit-learn sklearn.learning_curve Sie können einfach mit /modules/generated/sklearn.learning_curve.learning_curve.html zeichnen.

def plot_learning_curve(model_func, dataset):
    from sklearn.learning_curve import learning_curve
    import matplotlib.pyplot as plt
    import numpy as np

    sizes = [i / 10 for i in range(1, 11)]
    train_sizes, train_scores, valid_scores = learning_curve(model_func(), dataset.data, dataset.target, train_sizes=sizes, cv=5)
    
    take_means = lambda s: np.mean(s, axis=1)
    plt.plot(sizes, take_means(train_scores), label="training")
    plt.plot(sizes, take_means(valid_scores), label="test")
    plt.ylim(0, 1.1)
    plt.title("learning curve")
    plt.legend(loc="lower right")
    plt.show()

plot_learning_curve(make_model, digits)

Wenn Sie mit dem Hinzufügen fertig sind, führen Sie es aus. Die Abbildung sollte wie unten dargestellt dargestellt werden.

Bestätigung der Konformitätsrate und der Rückrufrate

Mit scikit-learn können Sie dies einfach mithilfe der Funktion Klassifizierungsbericht überprüfen. Confusion_matrix ist eine Analyse, wie viele der konkreten Vorhersagen in jedem Label korrekt waren (Nr. 0 bis Nr. 9). Sie können dies mit sklearn.metrics.confusion_matrix.html # sklearn.metrics.confusion_matrix) tun.

def show_confusion_matrix(model, dataset):
    from sklearn.metrics import classification_report
    
    predicted = model.predict(dataset.data)
    target_names = ["#{0}".format(i) for i in range(0, 10)]

    print(classification_report(dataset.target, predicted, target_names=target_names))

show_confusion_matrix(classifier, digits)

Handson Advanced

In Heroku bereitstellen

Versuchen Sie, die Heroku-Taste zu drücken.

Mit conda-buildpack ist es möglich, eine Anwendungsumgebung mit conda auf Heroku zu erstellen. Dies macht es einfach, Anwendungen für maschinelles Lernen auf Heroku auszuführen. Weitere Informationen finden Sie unter hier.

Modellabstimmung

Verwenden Sie GridSearch, um herauszufinden, welcher Parameter die höchste Genauigkeit aufweist, während Sie die Parameter des Modells ändern. Mit scikit-learn ist diese Suche mithilfe von GridSearchCV möglich.

Bitte versuchen Sie die Abstimmung, indem Sie den folgenden Code einfügen, bevor Sie das Modell bewerten.

def tuning_model(model_func, dataset):
    from sklearn.grid_search import GridSearchCV
    
    candidates = [
        {"loss": ["hinge", "log"],
         "alpha": [1e-5, 1e-4, 1e-3]
        }]
    
    searcher = GridSearchCV(model_func(), candidates, cv=5, scoring="f1_weighted")
    searcher.fit(dataset.data, dataset.target)
    
    for params, mean_score, scores in sorted(searcher.grid_scores_, key=lambda s: s[1], reverse=True):
        print("%0.3f (+/-%0.03f) for %r" % (mean_score, scores.std() / 2, params))
    
    return searcher.best_estimator_
    
classifier = tuning_model(make_model, digits)

Online maschinelles Lernen

Diese Anwendung soll Ihnen die richtige Antwort geben, wenn die vorhergesagten Zahlen unterschiedlich sind. Sein Wert wird als feedback.txt im Datenordner gespeichert und zum Trainieren des Modells verwendet (https://github.com/icoxfog417/number_recognizer/blob/master/application/server.py#L43). ..

Überprüfen Sie erneut, wie sich das Lernen auswirkt.

※Hinweis

Nichts ist zuverlässiger als Benutzereingaben, daher trainieren wir normalerweise nicht in diesem Stil. Es ist ratsam, die Daten einmal zu sammeln, die irrelevanten Daten auszuschließen und sie dann zu trainieren.
Wenn Sie dynamisch lernen, wird erwartet, dass das Lernen in eine unerwartete Richtung verläuft. Daher ist es bei der Einführung des maschinellen Online-Lernens erforderlich, es sorgfältig zu gestalten.

Andere

Effektive Verwendung des Datensatzes: [Cross Validation](http://nbviewer.ipython.org/github/icoxfog417/scikit-learn-notebook/blob/master/scikit-learn-tutorial.ipynb#Split-the- Daten)
Kombinieren Sie mehrere Lernmaschinen, um die Genauigkeit zu verbessern: [Ensemble Learning](http://nbviewer.ipython.org/github/icoxfog417/scikit-learn-notebook/blob/master/scikit-learn-tutorial.ipynb#Ensemble -Lerning)
Für eine eingehendere Bewertung der Modellgenauigkeit: [Confusion Matrix](http://nbviewer.ipython.org/github/icoxfog417/scikit-learn-notebook/blob/master/scikit-learn-tutorial.ipynb#Evaluate- Trainingsergebnis)
Weitere Informationen zum Organisieren Ihrer Daten: [Daten anordnen](http://nbviewer.ipython.org/github/icoxfog417/scikit-learn-notebook/blob/master/scikit-learn-tutorial.ipynb#Arrange- die Daten)

[PYTHON] Tech-Circle Beginnen wir mit der Anwendungsentwicklung durch maschinelles Lernen (Selbststudium)

Tor