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.
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
Zunächst werde ich die Umrisse des maschinellen Lernens erläutern.
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.
** Hands-on basiert auf Python 3 **
** Fork ** das folgende GitHub-Repository und lade es von dort herunter icoxfog417/number_recognizer
(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
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.
Ö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.
Handson # 2 Erklärung
Hier werden wir die folgenden zwei Dinge ausführen.
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))
Handson # 3 Erklärung
Ü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.
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
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.
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)
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
Recommended Posts