Vous serez ingénieur dans 100 jours ―― Jour 80 ―― Programmation ―― À propos de l'apprentissage automatique 5

Cliquez ici jusqu'à hier

Vous deviendrez ingénieur dans 100 jours - Jour 76 - Programmation - À propos de l'apprentissage automatique

Vous deviendrez ingénieur dans 100 jours-70-Programmation-À propos du scraping

Vous deviendrez ingénieur dans 100 jours - Jour 66 - Programmation - À propos du traitement du langage naturel

Vous deviendrez ingénieur dans 100 jours - Jour 63 - Programmation - À propos de la probabilité 1

Vous deviendrez ingénieur dans 100 jours - Jour 59 - Programmation - À propos des algorithmes

Vous deviendrez ingénieur dans 100 jours --- Jour 53 --Git --À propos de Git

Vous deviendrez ingénieur dans 100 jours --Jour 42 --Cloud --À propos des services cloud

Vous deviendrez ingénieur dans 100 jours - Jour 36 --Base de données --À propos de la base de données

Vous deviendrez ingénieur dans 100 jours-24 jours-Python-Bases du langage Python 1

Vous deviendrez ingénieur dans 100 jours --Jour 18 --Javascript --Les bases de JavaScript 1

Vous deviendrez ingénieur dans 100 jours - Jour 14 --CSS --CSS Basics 1

Vous deviendrez ingénieur dans 100 jours - Jour 6 --HTML - Bases du HTML 1

Cette fois, c'est une continuation de l'histoire de l'apprentissage automatique.

À propos du flux de traitement des données de l'apprentissage automatique

Le flux de travail lors de l'intégration de l'apprentissage automatique est le suivant.

  1. Décidez de l'objectif
  2. Acquisition de données
  3. Compréhension / sélection / traitement des données
  4. Création d'un magasin de données (ensemble de données)
  5. Création de modèles
  6. Vérification de l'exactitude
  7. Mise en œuvre du système

Parmi ceux-ci, 2-3 parties sont appelées prétraitement des données.

Cette fois, je voudrais créer un data mart à partir de ce prétraitement.

Prétraitement jusqu'à hier

Le langage est Python Les bibliothèques pour l'apprentissage automatique sont «Pandas» et «Numpy» La bibliothèque de visualisation utilise «seaborn», «matplotlib».

** Chargement de la bibliothèque **

#Charger la bibliothèque
import pandas as pd 
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')

%matplotlib inline

J'ai créé un data mart à partir d'ici.

Cliquez ici pour la conférence d'hier

À partir de là, nous allons commencer à créer un modèle à l'aide de Datamart.

À propos de la création de modèle

À partir de là, l'apprentissage automatique sera effectué à l'aide des données créées.

Tout d'abord, chargez la bibliothèque pour l'apprentissage automatique.

** Chargement de la bibliothèque d'apprentissage automatique **

scikit-learn: bibliothèque pour l'apprentissage automatique

from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

from sklearn.metrics import recall_score,precision_score,f1_score,accuracy_score
from sklearn.metrics import confusion_matrix

Expliquant grossièrement la bibliothèque, scikit-learn lui-même est une énorme bibliothèque. Chargez uniquement ce dont vous avez besoin. Je parlerai de chaque élément plus tard.

Flux de modélisme

Il y a plusieurs étapes pour créer un modèle.

Tout d'abord, c'est le travail de diviser en «données d'entraînement» et «données de test». Imaginez passer un examen d'entrée.

Si vous répondez au test à l'avance, vous obtiendrez un score proche du score parfait. Par conséquent, même dans l'apprentissage automatique, il n'a pas beaucoup de sens de vérifier avec les données qui ont été apprises à l'avance.

Les données à entraîner à l'avance sont entraînées de sorte que les données pour la vérification ne soient pas incluses, et une fois le modèle d'apprentissage terminé, la vérification est à nouveau exécutée avec les données de test restantes.

Après vérification, si vous n'en êtes pas satisfait, essayez de modifier la méthode, d'ajuster les paramètres et de retravailler à partir de la sélection de données pour créer un modèle.

** Répartition des données **

Ici, la division simple est effectuée par la «méthode hold-out». Divisez en données de test en utilisant train_test_split.

X = Données autres que l'étiquette correcte (plusieurs colonnes) Y = Corriger les données d'étiquette (1 colonne)

x_train, x_test, y_train, y_test = train_test_split (X, Y, test_size = taille du test)

Les "X" et "Y" spécifient ici les colonnes du bloc de données créé hier.

X = data_df.drop(['Survived'],axis=1)
Y = data_df['Survived']
x_train, x_test, y_train, y_test = train_test_split(X,Y, test_size=0.2)
print(len(x_train))
print(len(y_train))
print(len(x_test))
print(len(x_test))

712 712 179 179

Cela créera quatre données: «Données variables explicatives pour l'entraînement», «Données variables objectives pour l'entraînement», «Données variables explicatives pour les tests» et «Données variables objectives pour les tests».

** Modèle d'appel **

Vient ensuite l'appel de modèle. Décidez de la méthode à utiliser et appelez-la depuis la bibliothèque.

ici Appelez le «modèle de régression logistique». La «régression logistique» est souvent utilisée pour distinguer les valeurs binaires. «LogisticRegression» devient un modèle de «régression logistique».

clf = LogisticRegression()

** Apprentissage de modèle **

Après avoir appelé le modèle, l'étape suivante consiste à apprendre. L'apprentissage est effectué à l'aide de "données de variables explicatives pour la formation" et de "données de variables objectives pour la formation". Fondamentalement, l'apprentissage peut être écrit en une seule ligne.

clf.fit(x_train, y_train)

LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True, intercept_scaling=1, l1_ratio=None, max_iter=100, multi_class='warn', n_jobs=None, penalty='l2', random_state=None, solver='warn', tol=0.0001, verbose=0, warm_start=False)

C'est la fin de l'apprentissage.

** Faire une prédiction **

Ensuite, vérifiez avec test data. La vérification prédit (détermine) le "label" du test en utilisant les "données de test divisées".

y_predict = clf.predict(x_test)

Le résultat prédit est maintenant stocké dans y_predict. Le contenu contient un tableau qui prédit la bonne réponse.

y_predict[0:5]

array([0, 0, 1, 0, 0])

La prédiction génère la valeur «0» ou «1». Étant donné que «l'étiquette de réponse correcte» est également les données de la valeur «0» ou «1», la précision peut être vérifiée en la comparant à celle-ci.

** Vérifiez l'exactitude du modèle **

Vient ensuite la vérification de la précision du modèle. Calculez la précision du modèle. Étant donné que la bibliothèque pour la vérification de l'exactitude est chargée à partir de la bibliothèque, je vais la présenter

confusion_matrix: sortie 2x2 table correcte / incorrecte precision_score: calculez le taux de réponse correct precision_score: calcule le taux de précision rappel_score: calculer le rappel f1_score: Calcule la moyenne harmonisée de rappel de précision x

Il est devenu.

Lorsque j'essaye de vérifier l'exactitude immédiatement

print(pd.DataFrame(confusion_matrix(y_predict, y_test), index=['predict 0', 'predict 1'], columns=['real 0', 'real 1']))
print()
print('accuracy  : ',accuracy_score(y_test, y_predict))
print('precision : ',precision_score(y_test, y_predict))
print('recall    : ',recall_score(y_test, y_predict))
print('f1_score  : ',f1_score(y_test, y_predict))

real 0 real 1 predict 0 100 25 predict 1 15 39

accuracy : 0.776536312849162 precision : 0.7222222222222222 recall : 0.609375 f1_score : 0.6610169491525424

Le résultat est comme ça. Lors de la création d'un modèle avec ces données, la précision de la «précision» est d'environ 77,6%.

Comment lire la valeur numérique au moment de la vérification

Tout d'abord, le résultat de la prédiction est divisé en "0" et "1". Étant donné que les données d'étiquette de réponse correcte sont également divisées en "0" et "1" à l'avance, il existe un modèle 2x2 en tant que table correcte / incorrecte.

La relation entre la prédiction et la mesure réelle est la suivante.

Mesure réelle 0 Mesure réelle 1
Prédiction 0 100 25
Prédiction 1 15 39

De là, nous calculerons le taux de précision. Le taux de réponse correct est (Mesure réelle 0 prédiction 0 valeur + mesure réelle 1 prédiction 1 valeur) / valeur totale de tous Ce sera.

(100 + 39)/(100 + 25 + 15 + 39) = 139/179 = 0.7765

Vient ensuite la précision. Le taux de précision est Mesure réelle 1 Valeur de prédiction 1 / Valeur de prédiction 1 Ce sera.

39/(15 + 39) = 39/54 = 0.7222

Vient ensuite le taux de rappel. Le taux de rappel est «Mesure réelle 1 Valeur de prédiction 1 / Valeur de mesure réelle 1» Ce sera.

39/(25 + 39) = 39/64 = 0.609

Enfin, f1_score. f1_score est C'est une moyenne harmonisée de précision et de rappel.

2 * Taux de conformité * Taux de rappel / (Taux de conformité + taux de rappel)

2 * 0.7222 * 0.609 / (0.7222 + 0.609) = 0.8802 / 1.3316 = 0.6610

La valeur numérique mise en évidence dans la vérification dépend de l'objectif de l'apprentissage automatique. Cette fois, nous faisons un jugement binaire, mais si les étiquettes de réponses correctes sont divisées uniformément dans le même montant, le taux de réponse correct fera l'affaire. Si l'une des données est petite ou grande et biaisée, il peut ne pas être souhaitable d'utiliser le taux de réponse correct.

Par exemple, si vous avez des données avec un rapport de 99: 1, vous pouvez obtenir un taux de réponse correct de 99% si vous faites correspondre toutes les étiquettes avec la plus grande. Pensez à diagnostiquer une maladie.

Si vous faites un modèle selon lequel tout le monde n'est pas malade, le taux de réponse correct est de 99%, mais le 1% restant sera négligé et les personnes malades auront des problèmes. Dans ce cas, il est normal de faire une légère erreur, donc si vous n'avez pas de modèle capable de détecter les personnes malades, vous manquerez la minorité.

La précision est le pourcentage des données supposées positives qui sont réellement positives, et le rappel est le pourcentage des données positives réelles dont on peut prédire qu'elles sont positives. Je vais.

Si vous voyez que le but de l'apprentissage automatique est de s'appuyer sur la minorité, vous pouvez choisir un modèle qui peut être détecté correctement en mettant l'accent sur le rappel.

Cependant, si vous le faites, vous risquez de vous faire trop prendre. Dans ce cas, f1_score, qui prend en compte à la fois la précision et le rappel, est utilisé comme index.

** Autres modèles **

Regardons également d'autres modèles. Nous présenterons uniquement le modèle ici et n'entrerons pas dans les détails. Le premier est l'arbre de décision.


#Arbre de décision
clf = DecisionTreeClassifier()
clf.fit(x_train, y_train)
y_predict = clf.predict(x_test)
print(pd.DataFrame(confusion_matrix(y_predict, y_test), index=['predict 0', 'predict 1'], columns=['real 0', 'real 1']))
print()
print('accuracy  : ',accuracy_score(y_test, y_predict))
print('precision : ',precision_score(y_test, y_predict))
print('recall    : ',recall_score(y_test, y_predict))
print('f1_score  : ',f1_score(y_test, y_predict))

real 0 real 1 predict 0 95 26 predict 1 20 38

accuracy : 0.7430167597765364 precision : 0.6551724137931034 recall : 0.59375 f1_score : 0.6229508196721311

Vient ensuite Random Forest


# RandomForest
clf = RandomForestClassifier()
clf.fit(x_train, y_train)
y_predict = clf.predict(x_test)
print(pd.DataFrame(confusion_matrix(y_predict, y_test), index=['predict 0', 'predict 1'], columns=['real 0', 'real 1']))
print()
print('accuracy  : ',accuracy_score(y_test, y_predict))
print('precision : ',precision_score(y_test, y_predict))
print('recall    : ',recall_score(y_test, y_predict))
print('f1_score  : ',f1_score(y_test, y_predict))

real 0 real 1 predict 0 98 26 predict 1 17 38

accuracy : 0.7597765363128491 precision : 0.6909090909090909 recall : 0.59375 f1_score : 0.6386554621848739

​ ** Calcul du taux de cotisation **

Dans le modèle d'apprentissage automatique, il y a des éléments qui peuvent donner le taux de cotisation en fonction des données qui ont contribué.

clf.featureimportances


for i,v in zip(x_train.columns,clf.feature_importances_):
    print(i,'\t',v)

SibSp 0.08181730881501241 Parch 0.053030544663722166 Fare 0.40243782816341556 Sex2 0.28228147632317596 Pe_0.0 0.03352832009152742 Pe_1.0 0.014542002215684312 Pe_2.0 0.02212292439144309 Pe_3.0 0.022599544658725688 Pe_4.0 0.013099652111940165 Pe_5.0 0.013494114387414768 Pe_6.0 0.005599733163595443 Pe_7.0 0.002340597855733169 Pe_8.0 0.0030199997376331917 Em_C 0.012248329962351154 Em_N 0.0010747396045908525 Em_Q 0.010808812977944686 Em_S 0.025954070876089957

Résumé

Hier, j'ai traité les données pour créer un data mart pour l'apprentissage automatique. Aujourd'hui, nous allons créer un modèle de prédiction et vérifier l'exactitude à l'aide de ces données. La création du modèle lui-même est assez simple et la quantité de code que vous écrivez est bien moindre.

Par conséquent, lors de la création d'un modèle, il est important de décider quel modèle sélectionner. Étant donné que la quantité totale de code à écrire est faible, la tâche consiste à créer divers modèles, à les vérifier et à sélectionner celui avec la plus grande précision.

Si la précision est faible, essayez d'autres modèles, et si elle est encore faible, revenez au prétraitement des données et recommencez. Ce cycle est répété jusqu'à ce qu'un modèle convaincant soit créé et que la pire acquisition de données soit redémarrée.

Tout d'abord, réveillons-nous à tout le flux.

20 jours avant de devenir ingénieur

Informations sur l'auteur

HP d'Otsu py: http://www.otupy.net/

Youtube: https://www.youtube.com/channel/UCaT7xpeq8n1G_HcJKKSOXMw

Twitter: https://twitter.com/otupython

Recommended Posts

Vous serez ingénieur dans 100 jours ――Jour 81 ――Programmation ――À propos de l'apprentissage automatique 6
Vous serez ingénieur dans 100 jours ――Jour 79 ――Programmation ――À propos de l'apprentissage automatique 4
Vous serez ingénieur dans 100 jours ――Jour 76 ――Programmation ――À propos de l'apprentissage automatique
Vous serez ingénieur dans 100 jours ―― Jour 80 ―― Programmation ―― À propos de l'apprentissage automatique 5
Vous serez ingénieur dans 100 jours ――Jour 78 ――Programmation ――À propos de l'apprentissage automatique 3
Vous serez ingénieur dans 100 jours ――Jour 84 ――Programmation ――À propos de l'apprentissage automatique 9
Vous serez ingénieur dans 100 jours ――Jour 83 ――Programmation ――À propos de l'apprentissage automatique 8
Vous serez ingénieur dans 100 jours ――Jour 77 ――Programmation ――À propos de l'apprentissage automatique 2
Vous serez ingénieur dans 100 jours ――Jour 85 ――Programmation ――À propos de l'apprentissage automatique 10
Vous serez ingénieur dans 100 jours ――Jour 71 ――Programmation ――À propos du scraping 2
Vous serez ingénieur dans 100 jours ――Jour 61 ――Programmation ――A propos de l'exploration
Vous serez ingénieur dans 100 jours ――Jour 74 ――Programmation ――À propos du scraping 5
Vous serez ingénieur dans 100 jours ――Jour 75 ――Programmation ――À propos du scraping 6
Vous deviendrez ingénieur dans 100 jours --Jour 68 --Programmation --A propos de TF-IDF
Vous serez ingénieur dans 100 jours ――Jour 70 ――Programmation ――À propos du grattage
Vous serez ingénieur dans 100 jours ――Jour 65 ――Programmation ――A propos de la probabilité 3
Vous serez ingénieur dans 100 jours --Jour 86 --Base de données -
Vous serez ingénieur dans 100 jours ―― Jour 60 ―― Programmation ―― À propos de la structure des données et de l'algorithme de tri
Vous serez ingénieur dans 100 jours - Jour 34 - Python - Exercice Python 3
Vous serez ingénieur dans 100 jours - Jour 31 - Python - Python Exercice 2
Vous devenez ingénieur en 100 jours ――Jour 67 ――Programmation ――A propos de l'analyse morphologique
Vous devenez ingénieur en 100 jours ――Jour 66 ――Programmation ――À propos du traitement du langage naturel
Vous serez ingénieur dans 100 jours ――Jour 30 ―― Python ―― Bases du langage Python 6
Vous serez ingénieur dans 100 jours ――Jour 25 ―― Python ―― Bases du langage Python 2
Vous serez ingénieur dans 100 jours - Jour 29 - Python - Bases du langage Python 5
Vous serez ingénieur dans 100 jours - Jour 33 - Python - Bases du langage Python 8
Vous serez ingénieur dans 100 jours --Jour 26 --Python --Basiques du langage Python 3
Vous devenez ingénieur en 100 jours - Jour 35 - Python - Ce que vous pouvez faire avec Python
Vous serez ingénieur dans 100 jours --Jour 32 --Python --Basiques du langage Python 7
Vous serez ingénieur dans 100 jours --Jour 28 --Python --Les bases du langage Python 4
Devenez bientôt un ingénieur IA! Apprenez complètement Python / AI / Machine learning / Deep learning / Analyse statistique en quelques jours!
Vous devez faire attention aux commandes que vous utilisez quotidiennement dans l'environnement de production.
Créez un environnement interactif pour l'apprentissage automatique avec Python
À propos des tests dans la mise en œuvre de modèles d'apprentissage automatique
Apprentissage automatique sur le surapprentissage
Enregistrement d'apprentissage de la programmation 2ème jour
Jusqu'à ce qu'un ingénieur qui était autrefois frustré par l'apprentissage automatique parvienne à utiliser l'apprentissage automatique au travail
[Apprentissage automatique] Résumons la forêt aléatoire de manière simple à comprendre
Apprentissage automatique dans Delemas (s'entraîner)
Une introduction à l'apprentissage automatique
Programmation Python Machine Learning> Mots-clés
Utilisé en EDA pour l'apprentissage automatique
Que diriez-vous d'Anaconda pour créer un environnement d'apprentissage automatique avec Python?
Apprenez le machine learning à tout moment et en tout lieu dans l'environnement Jupyter Notebook à la demande