Cliquez ici jusqu'à hier
Vous deviendrez ingénieur dans 100 jours-70-Programmation-À propos du scraping
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-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.
Le flux de travail lors de l'intégration de l'apprentissage automatique est le suivant.
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.
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.
À 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.
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
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
HP d'Otsu py: http://www.otupy.net/
Youtube： https://www.youtube.com/channel/UCaT7xpeq8n1G_HcJKKSOXMw
Twitter： https://twitter.com/otupython
Recommended Posts