Cet article est un aperçu de la session d'étude pratique Tech-Circle Commençons le développement d'applications à l'aide de l'apprentissage automatique ... Il s'agit d'une version personnalisée du Tutoriel PyCon 2015 qui a été annoncé ci-dessus.

objectif

Comprendre les grandes lignes de l'apprentissage automatique
Obtenez des conseils sur l'utilisation de l'apprentissage automatique
Obtenez un environnement de développement pour l'apprentissage automatique

Préparation préalable

L'article suivant résume la procédure de création d'un environnement, veuillez donc le configurer en fonction de votre environnement.

Création d'un environnement de développement d'applications d'apprentissage automatique avec Python

Explication sur l'apprentissage automatique

Tout d'abord, je vais vous expliquer les grandes lignes de l'apprentissage automatique.

Machine Learning Bootstrap

Début pratique à partir de la P37. La diapositive est l'explication, et cet article est la procédure pour déplacer votre main, veuillez donc lire l'explication sur la diapositive -> essayez la procédure.

Procédure pratique

** La pratique est basée sur Python 3 **

# 0 Préparation

# 0-1 Télécharger le code source

** fork ** le référentiel GitHub suivant et télécharger à partir de là icoxfog417/number_recognizer

Vous pouvez le cloner tel quel, mais si vous ne le faites pas, vous ne pourrez pas refléter ce que vous avez appris.

# 0-2 Vérification du fonctionnement de l'application

Activer l'environnement virtuel

(Ce qui suit suppose que vous vous êtes préparé comme préparé à l'avance (créez un environnement virtuel ml_env avec conda). Si vous l'avez modifié, veuillez le lire comme il convient).

Windows

activate ml_env

Mac/Linux

#Pour éviter de battre avec pyenv, activate vérifie le chemin de l'environnement virtuel et l'exécute directement
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

Contrôle de fonctionnement

Application (lancée sur localhost: 3000)

Exécutez run_application.py directement sous le dossier number_recognition.

python run_application.py

Bloc-notes IPython pour la création de modèles d'apprentissage automatique (lancé sur localhost: 8888)

Directement sous number_recognition / machines / number_recognizer, exécutez ce qui suit.

ipython notebook

L'application se sent vraiment mal au début. Je vais rendre cela plus intelligent.

# 1 Découvrez le processus de création d'un modèle d'apprentissage automatique

Ouvrez le bloc-notes iPython. Vous trouverez ici chaque étape de l'apprentissage automatique dans l'ordre. Puisque le code de la phrase peut réellement être exécuté avec le notebook iPython, expliquons-le et exécutons-le dans l'ordre du haut (voir ici pour une utilisation détaillée. S'il te plait donne moi).

Si vous allez à la dernière sauvegarde, le modèle (number_recognition / machines / number_recognizer / machine.pkl) devrait en fait être mis à jour.

# 2 Divisez les données d'entraînement

Explication du Handson n ° 2

Ici, nous allons effectuer les deux choses suivantes.

Divisez les données en apprentissage et évaluation
Calculez respectivement la précision des données d'entraînement et la précision des données d'évaluation.

Utilisez cross_validation.train_test_split pour diviser les données d'entraînement. Utilisez ceci et placez le traitement suivant avant Entraînement du modèle.

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))
     )

Puisque nous avons divisé les données en training_set et test_set ci-dessus, modifiez Entraînement du modèle comme suit.

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

L'apprentissage est maintenant terminé. Grâce aux données fractionnées, nous avons 30% de données en plus pour l'évaluation. Vous pouvez l'utiliser pour mesurer l'exactitude des données non formées.

Modifiez la partie calcul de précision de Evaluer le modèle comme suit.

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

# 3 Évaluez le modèle

Explication du Handson # 3

Mesurez comment la précision de chaque donnée d'entraînement et de chaque donnée d'évaluation change pour vérifier si elle est surentraînée.
Vérifiez la précision et rappelez-vous pour éviter "quel modèle très précis" en raison d'un déséquilibre des données.

Confirmation de l'exactitude des données de formation / d'évaluation

Vérifiez la transition de l'exactitude des données d'entraînement / d'évaluation avec le script suivant. Le graphique avec le nombre de données d'entraînement sur l'axe horizontal et la précision sur l'axe vertical est appelé courbe d'apprentissage. Vous pouvez facilement dessiner en utilisant /modules/generated/sklearn.learning_curve.learning_curve.html).

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)

Lorsque vous avez fini de l'ajouter, essayez de l'exécuter. La figure doit être tracée comme indiqué ci-dessous.

Confirmation du taux de conformité et du taux de rappel

Avec scikit-learn, vous pouvez facilement vérifier en utilisant la fonction classification_report. Confusion_matrix est une analyse du nombre de prédictions concrètes correctes dans chaque étiquette (# 0 à # 9). Vous pouvez le faire avec sklearn.metrics.confusion_matrix.html # sklearn.metrics.confusion_matrix).

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

Déployer sur Heroku

Essayez d'appuyer sur le bouton Heroku.

En utilisant conda-buildpack, il est possible de créer un environnement d'application avec conda sur Heroku. Cela facilite l'exécution d'applications d'apprentissage automatique sur Heroku. Veuillez consulter ici pour plus de détails.

Réglage du modèle

Utilisez GridSearch pour savoir quel paramètre a la plus grande précision lors de la modification des paramètres du modèle. Avec scikit-learn, cette recherche est possible en utilisant GridSearchCV.

Veuillez essayer de régler en insérant le code suivant avant d'évaluer le modèle.

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)

Apprentissage automatique en ligne

Cette application est conçue pour vous donner la bonne réponse si les nombres prédits sont différents. Sa valeur est stockée sous le nom feedback.txt dans le dossier data et est utilisée pour entraîner le modèle (https://github.com/icoxfog417/number_recognizer/blob/master/application/server.py#L43) ..

Encore une fois, veuillez vérifier comment l'apprentissage fera une différence.

※Mise en garde

Rien n'est plus fiable que la saisie de l'utilisateur, nous ne nous entraînons donc généralement pas dans ce style. Il est sage de collecter les données une fois, d'exclure les données non pertinentes, puis de les former.
Si vous apprenez de manière dynamique, on s'attend à ce que l'apprentissage se déroule dans une direction inattendue. Par conséquent, lors de l'adoption de l'apprentissage automatique en ligne, il est nécessaire de le concevoir soigneusement.

Autre

Utilisation efficace de l'ensemble de données: [Validation croisée](http://nbviewer.ipython.org/github/icoxfog417/scikit-learn-notebook/blob/master/scikit-learn-tutorial.ipynb#Split-the- Les données)
Combinez plusieurs machines d'apprentissage pour améliorer la précision: [Ensemble Learning](http://nbviewer.ipython.org/github/icoxfog417/scikit-learn-notebook/blob/master/scikit-learn-tutorial.ipynb#Ensemble -Lerning)
Pour une évaluation plus approfondie de la précision du modèle: [Confusion Matrix](http://nbviewer.ipython.org/github/icoxfog417/scikit-learn-notebook/blob/master/scikit-learn-tutorial.ipynb#Evaluate- Résultat de la formation)
En savoir plus sur l'organisation de vos données: [Organiser les données](http://nbviewer.ipython.org/github/icoxfog417/scikit-learn-notebook/blob/master/scikit-learn-tutorial.ipynb#Arrange- les données)

[PYTHON] Tech-Circle Commençons le développement d'applications à l'aide de l'apprentissage automatique (auto-apprentissage)