Comment utiliser l'apprentissage automatique pour le travail? 03

introduction

Jusqu'à présent, nous avons livré des articles sur le thème "Comment utiliser l'apprentissage automatique pour le travail?" Dans ce troisième volet, nous introduirons une programmation spécifique sous le thème "Procédure de codage Python".

Si vous lisez le numéro précédent, vous pouvez comprendre l'ensemble des bases de l'apprentissage automatique au codage de Python, alors veuillez l'utiliser.

Diverses informations sont également publiées sur SNS, donc si vous pensez que vous pouvez lire l'article Je vous serais reconnaissant de bien vouloir suivre Compte Twitter "Saku731".

Compétences en programmation requises pour l'apprentissage automatique

Tout d'abord, les compétences requises pour maîtriser l'apprentissage automatique sont les suivantes. Codons-les un par un.

―― 1) Visualisation des données: saisissez le ressenti général des données et décidez de la politique de prétraitement -2) Prétraitement des données: nettoyez les données afin que la précision de la prédiction soit élevée. ―― 3) Sélection de l'algorithme: Déterminez l'algorithme approprié pour les données -4) Apprentissage du modèle: laissez l'ordinateur apprendre les règles des données -5) Vérification du modèle: confirmer l'exactitude de la prédiction du modèle terminé

Construire un environnement Python (vous pouvez l'ignorer)

** Jupyter Notebook ** est requis pour procéder à la programmation en Python.

Si vous n'avez pas d'environnement de programmation sur votre PC, veuillez vous préparer en vous reportant à ce qui suit. C'est un matériau très poli, donc même les débutants peuvent être rassurés.

Préparation) Obtention des données à utiliser

Récemment, les données "Titanic" sont souvent utilisées dans n'importe quel service Web tel que Kaggle. En d'autres termes, même si vous avez du mal à étudier, il existe de nombreux articles de référence, donc cet article utilisera également les données du Titanic.

Veuillez télécharger les données depuis ici. Codons maintenant une série d'étapes d'apprentissage automatique.

1) Visualisation des données

Le but de la visualisation des données est "d'avoir une idée de l'ensemble des données et de décider de la politique de prétraitement".

Lire les données

Tout d'abord, vérifiez de quel type de données il s'agit.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline

#Lire les données CSV
df_train = pd.read_csv('train.csv')

#Confirmation de la lecture des données CSV
df_train.head()

Si cela se passe bien, il sera affiché comme indiqué dans la figure ci-dessous. Gardez à l'esprit que ce format de données est appelé ** format DataFrame **.

L'explication de chaque ligne est la suivante. Cette fois, il est difficile de prédire le "résultat de survie", donc "Survived" est la cible de la prédiction.

--PassengerID: ID du passager --Survivé: résultat de survie (1: survie, 2: mort) --Pclass: classe passager --Nom: nom du passager --Sex: Genre -Age: Âge --SibSp: nombre de frères et sœurs et de conjoints. --Parque: nombre de parents et d'enfants. --Ticket: numéro de ticket.

Tarif: frais d'embarquement. --Cabine: numéro de chambre --Embarqué: Port à bord

Confirmation des statistiques de base

Ensuite, vérifiez la valeur moyenne des données et l'écart type qui indique une variation.

df_train.describe()

Les points à vérifier ici sont les suivants. Comment utiliser la valeur moyenne et l'écart type est une compétence que vous apprendrez après vous y être habitué, je vais donc l'introduire dans un autre article.

--mean: valeur moyenne des données --std: écart type des données (degré de variation des valeurs numériques) --min: valeur minimale des données --50%: données médianes --max: valeur maximale des données

Traitement des valeurs manquantes

Le processus suivant à effectuer est le processus de ** valeur manquante **. Une valeur manquante est un état dans lequel des données sont manquantes pour une raison quelconque. Si rien n'est fait, une erreur se produira au cours de la progression du programme, il est donc nécessaire de la traiter à un stade précoce.

Si vous voulez en savoir plus, veuillez vous référer à [here] pour comprendre la procédure de programmation détaillée. Exécutez le code suivant pour voir si vos données contiennent des valeurs manquantes.

df_train.isnull().sum()

Cette fois, il semble que les colonnes "Age" et "Cabin" contiennent des valeurs manquantes. En général, il existe deux types de contre-mesures pour les valeurs manquantes: «suppression» et «complémentation».

Suppression: si une valeur manquante est incluse, supprimez la ligne entière et supposez que les données elles-mêmes étaient manquantes.
Complémentation: Complétez la valeur manquante avec une valeur numérique (valeur moyenne, valeur médiane, etc.) pour la rendre non manquante.

C'est plus facile à supprimer, donc cette fois nous utiliserons dropna () pour le supprimer.

df_train = df_train.dropna()

Vérifions si les valeurs manquantes ont été supprimées avec succès.

df_train.isnull().sum()

De cette façon, nous avons confirmé qu'il n'y avait aucune valeur manquante dans toutes les lignes, afin que nous puissions passer au processus suivant.

Dessinez un graphique

Après avoir terminé cette étape, dessinez divers graphiques pour saisir les tendances des données.

Il n'y a pas de modèle fixe qui fonctionnera certainement, mais "1) Données introduites dans Divulgation complète des méthodes utilisées dans l'apprentissage automatique Vous pouvez obtenir une vue d'ensemble des compétences requises en cochant «Visualisation».

Par exemple, si vous utilisez l'histogramme le plus fréquemment utilisé pour la représentation graphique, vous pouvez dessiner le graphique suivant.

■ Préparation: Importer la bibliothèque

import matplotlib.pyplot as plt
%matplotlib inline

■ Graphique 1: Vérifiez le nombre de survivants et de décès de passagers

Tout d'abord, nous comparerons le nombre de survivants et le nombre de décès à partir des données. Quand j'ai exécuté le code et vérifié l'histogramme, j'ai trouvé que c'était ** "60 survie: 120 décès" **.

plt.hist(df_train['Survived'], bins=3)

■ Graphique 2: dessiner la distribution de l'âge Si vous tracez la répartition par âge, vous pouvez voir que le nombre de passagers âgés de 35 à 40 ans était le plus élevé. De plus, étant donné qu'il y a beaucoup de passagers âgés de 0 à 5 ans, il est possible de déduire que «** Il y avait un parent qui était à bord avec un bébé **».

plt.hist(df_train['Age'], bins=15)

■ Graphique 3: Répartition par sexe Si vous tracez la répartition par sexe, vous pouvez voir que presque le même nombre d'hommes et de femmes étaient à bord.

plt.hist(df_train['Sex'], bins=3)

■ Graphique 4: Tracez la distribution du sexe x taux de survie C'est un peu appliqué, mais lors de la représentation graphique, les données sont souvent agrégées.

Le sentiment général du type de méthode disponible est présenté dans "1) Visualisation des données" de Divulgation complète des méthodes utilisées dans l'apprentissage automatique. Cependant, cette fois, j'utiliserai une méthode appelée ** tabulation croisée **.

#Tableau croisé
df_survived = pd.crosstab(df_train['Sex'], df_train['Survived'])
df_survived

Si vous vérifiez les résultats de la tabulation croisée, vous pouvez voir que le nombre de survivants est nettement plus élevé chez les femmes.

Survived = 1 est "survie".

C'est un peu déroutant, alors divisons par le nombre total et croisons par ** taux de survie **.

#Tableau croisé
df_survived = pd.crosstab(df_train['Sex'], df_train['Survived'], normalize='index')
df_survived

Si vous faites un graphique, vous pouvez clairement voir qu'il existe une différence de taux de survie entre les hommes et les femmes. ** Le taux de survie des femmes est extrêmement élevé **, il semble donc que les femmes aient eu la priorité dans le sauvetage.

#Obtention du rapport homme-femme du taux de survie et du taux de mortalité

#Ratio hommes-femmes de survivants
df_survived_1 = df_survived[1].values

#Ratio hommes-femmes des décès
df_survived_0 = df_survived[0].values.tolist()

#Ratio hommes-femmes du taux de survie
plt.bar(x=np.array(['female','male']), height=df_survived_1)

#Ratio hommes-femmes de mortalité
plt.bar(x=np.array(['female','male']), height=df_survived_0)

En dessinant divers graphiques de cette manière, nous saisirons les caractéristiques des données. Il existe diverses autres méthodes, donc si vous êtes intéressé, vous devriez étudier à [here].

2) Prétraitement des données

Après confirmation des données, un prétraitement est effectué afin que les données puissent être utilisées dans l'apprentissage automatique (données avec une bonne précision de prédiction).

A l'origine, différents traitements de données sont effectués en référence aux informations obtenues par visualisation, mais comme c'est trop difficile pour la première étude, nous traiterons du «codage» le plus simple et le plus important.

Codage des variables catégorielles

Ensuite, un traitement est requis pour une variable appelée ** variable catégorielle . Une explication simple des variables catégorielles est " données de caractères **".

Ce ne sont pas toujours des données de caractères, mais elles sont suffisantes pour une introduction.

Veuillez essayer d'afficher à nouveau les données initialement affichées. Ensuite, les ** données de caractères ** telles que "** homme " et " femme **" sont incluses.

df_train.head()

Les données utilisées dans l'apprentissage automatique ont la restriction "** Utiliser des données numériques **". Par conséquent, il est nécessaire de convertir les données de caractères en données numériques d'une manière ou d'une autre.

La méthode la plus courante est le ** encodage One-Hot ** avec get_dummies ().

# One-Encodage à chaud
df_train = pd.get_dummies(df_train)

#Vérifiez les données converties
df_train.head()

Comme le montre la figure ci-dessous, les données de caractères ont été remplacées par "0" et "1", de sorte qu'elles peuvent être utilisées dans l'apprentissage automatique. Si vous voulez comprendre le contexte détaillé, veuillez vous référer à l'article [ici].

3) Sélection de l'algorithme

Qu'est-ce qu'un algorithme?

Afin d'extraire des règles à partir de données par apprentissage automatique, des ** méthodes d'analyse adaptées aux données ** sont nécessaires. La méthode d'analyse est appelée un algorithme.

Il existe différents types d'algorithmes, et les plus typiques sont les suivants. Si vous souhaitez en savoir plus sur chaque algorithme, veuillez vous référer à [here].

--Retour (prévision numérique des ventes, nombre de visites en magasin, etc.) --Régression linéaire (régression simple, régression multiple)

Arbre de retour
Retour de forêt aléatoire --Classification (prédiction de problèmes de choix comme A ou B)
Retour logistique --Arbre de décision --Forêt aléatoire -Support Vector Machine (SVM) --Peut être utilisé pour les deux --Réseau neuronal (apprentissage profond)
- XGBoost
- LightGBM

Algorithme utilisé cette fois

Il est important de comprendre que les résultats changeront à mesure que l'algorithme utilisé change. Alors. Utilisons trois types: SVM, arbre de décision et forêt aléatoire.

Il est pratique d'utiliser sklearn car la plupart des algorithmes sont complets.

#Machine à vecteurs de soutien (SVM)
from sklearn.svm import SVC

#Arbre de décision
from sklearn.tree import DecisionTreeClassifier

#Forêt aléatoire
from sklearn.ensemble import RandomForestClassifier

4) Apprentissage du modèle

Maintenant que vous avez l'algorithme que vous souhaitez utiliser, entraînons le modèle. Tout d'abord, il est nécessaire de diviser les données en données d'entraînement et données de vérification.

La raison en est qu'après l'entraînement du modèle, Nous avons besoin d'une phase de vérification pour voir si l'apprentissage s'est bien passé.

Une méthode appelée ** méthode holdout ** est bien connue pour diviser les données.

Division des données en "variables explicatives" et "variables objectives" --Chaque données d'entraînement: données de vérification = 7: 3

Divisé en variables explicatives et objectives

Commençons par le diviser en «variables explicatives» et «variables objectives».

--Variable objective: cible à prédire par l'IA (cette fois, il s'agit d'une situation de survie, donc la colonne "Survived") --Variable explicative: informations utilisées pour prédire la variable objective (colonne "Non-survécu")

Notez les noms de colonne dans les données que vous venez d'afficher. «Survived» est dans la deuxième ligne, et les autres lignes sont dans la troisième et les suivantes.

"Passenger Id: Passenger ID" n'est pas nécessaire car il ne s'agit que d'un numéro de colonne.

Il est pratique d'utiliser ʻiloc [] `pour diviser les données au format DataFrame en variables explicatives et variables objectives. Pour plus de détails, reportez-vous à l'article [ici].

#Variable explicative
X = df_train.iloc[:, 2:]

#Variable objectif
t = df_train.iloc[:, 1]

Si vous cochez la variable explicative «X», les colonnes après «Pclass» sont correctement extraites comme indiqué ci-dessous.

X.head()

De plus, si vous cochez t, vous pouvez extraire l'état de survie" 0/1 ".

t.head()

Données de formation: données de vérification = 7: 3

Ensuite, les variables explicatives et les variables objectives sont divisées en ** données d'entraînement ** et ** données de validation **. Utilisez train_test_split de sklearn.

#Importer la bibliothèque
from sklearn.model_selection import train_test_split

#Exécution de la division à 7: 3
X_train, X_valid, t_train, t_valid = train_test_split(X, t, train_size=0.7, random_state=0)

Vous pouvez vérifier la quantité de données en utilisant len (), donc vérifions qu'elle est correctement divisée en 7: 3.

#données brutes
print(len(df_train))

#Données après division
print(len(X_train), len(X_valid))

Paramètres des hyper paramètres

Une fois que vous avez l'algorithme et les données en place, vous devez enfin définir un nombre appelé ** HyperParamètre **.

Les hyperparamètres sont des paramètres chargés de régler finement l'algorithme pour l'adapter aux données.

--Algorithme: Le but est de déterminer la ** coupure d'analyse ** pour les données --Hyperparamètres: Le but est de faire des ** ajustements fins ** pour que l'algorithme corresponde aux données.

Définissons trois hyperparamètres pour chaque algorithme afin que vous puissiez comprendre les effets des algorithmes et des hyperparamètres. En d'autres termes, «3 types d'algorithmes x 3 types d'hyper paramètres = 9 types de modèles» seront formés.


#Machine à vecteurs de soutien (SVM)
model_svm_1 = SVC(C=0.1)
model_svm_2 = SVC(C=1.0)
model_svm_3 = SVC(C=10.0)

model_svm_1.fit(X_train, t_train)
model_svm_2.fit(X_train, t_train)
model_svm_3.fit(X_train, t_train)


#Arbre de décision
model_dt_1 = DecisionTreeClassifier(max_depth=3)
model_dt_2 = DecisionTreeClassifier(max_depth=5)
model_dt_3 = DecisionTreeClassifier(max_depth=10)

model_dt_1.fit(X_train, t_train)
model_dt_2.fit(X_train, t_train)
model_dt_3.fit(X_train, t_train)


#Forêt aléatoire
model_rf_1 = RandomForestClassifier(max_depth=3)
model_rf_2 = RandomForestClassifier(max_depth=5)
model_rf_3 = RandomForestClassifier(max_depth=10)

model_rf_1.fit(X_train, t_train)
model_rf_2.fit(X_train, t_train)
model_rf_3.fit(X_train, t_train)

5) Vérification du modèle

Maintenant que nous avons appris 9 types de modèles, vérifions la précision de prédiction de chaque modèle.

print('SVM_Précision de prédiction de 1:', round(model_svm_1.score(X_valid, t_valid) * 100, 2), '%')
print('SVM_Précision de prédiction de 2:', round(model_svm_2.score(X_valid, t_valid) * 100, 2), '%')
print('SVM_Précision de prédiction de 3:', round(model_svm_3.score(X_valid, t_valid) * 100, 2), '%')

print('Arbre de décision_Précision de prédiction de 1:', round(model_dt_1.score(X_valid, t_valid) * 100, 2), '%')
print('Arbre de décision_Précision de prédiction de 2:', round(model_dt_2.score(X_valid, t_valid) * 100, 2), '%')
print('Arbre de décision_Précision de prédiction de 3:', round(model_dt_3.score(X_valid, t_valid) * 100, 2), '%')

print('Forêt aléatoire_Précision de prédiction de 1:', round(model_rf_1.score(X_valid, t_valid) * 100, 2), '%')
print('Forêt aléatoire_Précision de prédiction de 2:', round(model_rf_2.score(X_valid, t_valid) * 100, 2), '%')
print('Forêt aléatoire_Précision de prédiction de 3:', round(model_rf_3.score(X_valid, t_valid) * 100, 2), '%')

Lorsque j'exécute le code ci-dessus, le résultat ressemble à ceci: Il peut être confirmé que le résultat (précision de la prédiction) change en fonction de la différence d'algorithme et d'hyperparamètres.

Cette fois, le deuxième arbre décisionnel était la meilleure précision de prédiction.

Lors du développement de l'IA, vous pouvez régler les hyper paramètres plus facilement en utilisant la ** recherche de grille ** présentée précédemment. Si vous voulez en savoir plus, vous pouvez vérifier la méthode d'implémentation en voyant Article de référence.

à la fin

Ce qui précède est la séquence de base de l'apprentissage automatique requise pour le développement de l'IA (modèle entraîné). Sur la base de ce flux, il est bon de comprendre la méthode compliquée qui peut donner une meilleure précision de prédiction.

Si vous lisez le numéro précédent, vous pouvez comprendre l'ensemble des bases de l'apprentissage automatique au codage de Python.

Si vous souhaitez approfondir votre programmation, veuillez vous référer à l'article qui couvre les compétences nécessaires.

Divulgation complète des méthodes utilisées dans l'apprentissage automatique

P.S. Diverses informations sont également publiées sur SNS, donc si vous pensez que vous pouvez lire l'article Je vous serais reconnaissant de bien vouloir suivre Compte Twitter "Saku731".

~~ De plus, à la fin de la phrase, nous faisons "** Team Development Experience Project **" pour une durée limitée. ~~ ~~ Si vous êtes intéressé, veuillez consulter [Fiche de candidature] pour plus de détails. ~~ (Une addition) La date limite a été fermée car elle est pleine. La prochaine fois est prévue pour mars 2019, donc si vous souhaitez être informé, veuillez remplir le [Formulaire de réservation].

Comment utiliser l'apprentissage automatique pour le travail? 03_Procédure de codage Python