[PYTHON] Apprentissage automatique / prétraitement des données

1.Tout d'abord

Je résumerai le prétraitement souvent utilisé en machine learning sous forme de mémorandum au format jupyter_notebook. L'ensemble de données utilise le [prêt_home] de kaggle (https://www.kaggle.com/sazid28/home-loan).

2. Modifier les paramètres d'affichage

L'affichage à l'écran de jupyter notebbok est étrangement étroit, et si vous affichez beaucoup de colonnes et de lignes, le milieu sera omis. Par conséquent, il est pratique de modifier d'abord les paramètres d'affichage si nécessaire.

#Extension de la largeur d'affichage de l'écran
from IPython.core.display import display, HTML
display(HTML("<style>.container { width:100% !important; }</style>"))

#Modifier le nombre maximal de colonnes et de lignes affichées
import pandas as pd
pd.options.display.max_columns = 50  #Paramètre d'affichage maximal de la colonne(Par défaut 20)
pd.options.display.max_rows = 100  #Paramètre d'affichage de ligne maximum(Par défaut 60)

3. Lire les données d'entraînement

Cette fois, les données d'entraînement et les données de test sont lues et traitées séparément. Tout d'abord, lisez les données d'entraînement.

train = pd.read_csv('./train.csv')
train.head()

Ensuite, séparez la quantité de caractéristiques et la cible.

#Divisé en fonctionnalités et cibles
X_train = train.iloc[ : , :-1]  #Toutes les lignes, colonnes sauf la dernière colonne
y_train = train.iloc[ : , -1]  #Toutes les lignes, dernière colonne
X_train = X_train.drop('Loan_ID', axis=1)  # Loan_Supprimer la colonne ID
y_train = y_train.map( {'Y':1, 'N':0} )  #Y 1,Remplacez N par 0
X_train.head()

Afin de vérifier facilement la quantité de caractéristiques à chaque fois, définissez le contrôle de fonction (df).

#Vérification des fonctionnalités
def check(df):
    col_list = df.columns.values  #Obtenir le nom de la colonne
    row = []    
    for col in col_list:
        tmp = ( col,  #Nom de colonne
                df[col].dtypes,  #Type de données
                df[col].isnull().sum(),  #Nombre de nuls
                df[col].count(),  #Le nombre de données(Exclure les valeurs manquantes)
                df[col].nunique(),  #Nombre de valeurs uniques(Exclure les valeurs manquantes) 
                df[col].unique() )  #Valeur unique
        row.append(tmp)  #Enregistrer le tmp sur la ligne de manière séquentielle
    df = pd.DataFrame(row)  #Convertir la ligne en format de trame de données
    df.columns = ['feature', 'dtypes', 'nan',  'count', 'num_unique', 'unique']  #Spécifiez le nom de la colonne du bloc de données
    return df

check(X_train)

feature est le nom de la quantité de caractéristiques, dtypes est le type de données, nan est le nombre de valeurs manquantes, count est le nombre de données (à l'exclusion des valeurs manquantes), num_unique est le nombre de valeurs uniques (à l'exclusion des valeurs manquantes) et unique est la valeur unique.

4. Traitement des variables de catégorie

Fondamentalement, l'objet est une variable catégorielle, mais il existe un moyen d'en faire une variable catégorielle même s'il s'agit d'une valeur numérique. Credit_History est un nombre (float64), mais comme le nombre de valeurs uniques est de 2, faisons-en une variable catégorielle cette fois.

Modifiez le type de données de Credit_History en object.

# Credit_Convertir l'historique en objet
X_train['Credit_History'] = X_train['Credit_History'].astype(object)

Voyons la relation entre la quantité de fonctionnalités du type d'objet et la cible. Tout d'abord, remplacez la valeur manquante de object par "nan".

#Valeur manquante de l'objet'nan'Remplacer par
c_list = X_train.dtypes[X_train.dtypes=='object'].index.tolist()  #Obtenir la liste des noms de colonne de l'objet
X_train[c_list] = X_train[c_list].fillna('nan')

Utilisez sns.barplot pour représenter graphiquement la relation entre chaque caractéristique du type d'objet et Loan_Status. Le graphique montre la valeur moyenne sous forme de hauteur et l'intervalle de confiance sous forme de barre d'erreur.

#Relation entre la quantité de caractéristiques de type d'objet et la cible
import matplotlib.pyplot as plt
import seaborn as sns

fig = plt.figure(figsize=(14,6))
for j , i in enumerate([0, 1, 2, 3, 4, 9, 10]):
    ax = fig.add_subplot(2, 4 , j+1)
    sns.barplot(x=X_train.iloc[:,i], y=y_train, data=X_train, palette='Set3' )

plt.tight_layout()
plt.show()

Credit_History semble avoir le plus d'influence sur Loan_Status. 　 Pour les variables catégorielles, il est souvent encodé à chaud. En effet, en décomposant les éléments de quantité d'entités, seuls les éléments de quantité d'entités qui sont efficaces pour la prédiction peuvent être sélectionnés. Encore une fois, on encode l'objet à chaud.

#Un encodage à chaud des variables catégorielles
X_train1 = pd.get_dummies(X_train) 
check(X_train1)

Le nombre total de fonctionnalités est de 26.

5. Traitement des variables numériques

Pour les variables numériques, les complétions de valeurs manquantes incluent la moyenne, la médiane, la plus fréquente et la constante, mais ici nous utilisons la moyenne.

#Saisie des valeurs manquantes numériques
X_train2 = X_train1.fillna(X_train1.mean())
check(X_train2)

Maintenant, utilisons sns.FacetGrid pour dessiner un histogramme pour chaque variable numérique lorsque Loan_Status vaut 0 et 1.

X_tmp = X_train2.join(y_train)
for i in [0, 1, 2, 3]:
    facet = sns.FacetGrid(X_tmp, hue='Loan_Status', aspect=2)
    facet.map(sns.kdeplot, X_tmp.columns.values[i], shade= True)
    facet.set(xlim=(0, X_tmp.iloc[:, i].max()))
    facet.add_legend()
    plt.show()

Les quatre caractéristiques ont des zones où Loan_Status1 est clairement dominant.

8. Importance des fonctionnalités

Donnons la priorité à 26 fonctionnalités en utilisant le coefficient Random Forest Gini.

import numpy as np
from sklearn.ensemble import RandomForestClassifier

#Monter dans une forêt aléatoire
clf = RandomForestClassifier(n_estimators=100, random_state=0)
clf.fit(X_train2, y_train)

#Affichage de l'importance de la quantité de caractéristiques
labels = X_train2.columns.values  #Acquisition d'étiquettes de fonctionnalités
importances = clf.feature_importances_  #Acquisition numérique de la quantité de caractéristiques
index = np.argsort(importances)  #Obtenir un index croissant

plt.figure(figsize=(8, 5))
plt.barh(range(X_train2.shape[1]), importances[index])
plt.yticks(range(X_train2.shape[1]), labels[index])
plt.title('feature importances')
plt.show()

Les trois meilleurs sont Credit_History_0.0, ApplicantIncome et LoanAmount.

9. Réduisez le nombre de fonctionnalités

RFE (Recursive Feature Elimination) réduit le nombre de fonctionnalités. L'algorithme crée un modèle en commençant par toutes les fonctionnalités et supprime les fonctionnalités les moins importantes du modèle. Ensuite, le processus de création d'un modèle et de suppression des caractéristiques les moins importantes est répété jusqu'à ce qu'un nombre prédéterminé de caractéristiques soit atteint.

from sklearn.feature_selection import RFE

clf = RandomForestClassifier(n_estimators=100, random_state=0)
selector = RFE(estimator=clf,
                        n_features_to_select=10,  #Nombre de fonctionnalités réduit
                        step=.05)  #Pourcentage d'entités à tronquer à chaque étape

selector.fit(X_train2, y_train)

#Compressez 26 dimensions en 10 dimensions
select = selector.transform(X_train2)
X_train3 = pd.DataFrame(select,
                            columns=X_train2.columns[selector.support_])

check(X_train3)

Ce sont les données d'entraînement finalement obtenues.

10. Lecture et traitement des données d'essai

Ensuite, chargez les données de test.

#Lire les données de test
test = pd.read_csv('./test.csv')
X_test = test.drop('Loan_ID', axis=1)  # Loan_Supprimer la colonne ID
check(X_test)

Comme précédemment, convertissez Credit_History en objet, puis effectuez un encodage à chaud avec les valeurs manquantes.

Ici, en ajoutant l'option dummy_na = True à la méthode pd.get_dummies (), l'encodage one-hot incluant les valeurs manquantes est effectué en un seul coup.

# Credit_Convertir l'historique en objet
X_test['Credit_History'] = X_test['Credit_History'].astype(object)

#Saisie des valeurs manquantes et encodage à chaud des variables catégorielles
X_test1 = pd.get_dummies(X_test, 
                         dummy_na = True)  #Inclure les valeurs manquantes
check(X_test1)

Ah, le nombre de fonctionnalités a augmenté de deux par rapport aux données d'entraînement.

En effet, l'utilisation de l'option dummy_na = True crée XX_nan avec toutes les données 0, même s'il n'y a aucune valeur manquante.

Ici, 9.Married_nan, 17.Education_nan, 27.Property_Area_nan lui correspondent.

Voyons la différence entre les fonctionnalités des données d'entraînement et les données de test.

#Lire les noms des quantités d'entités comme un ensemble
cols_train = set(X_train1.columns.values)
cols_test = set(X_test1.columns.values)

#Fonctionnalités en train mais pas en test
diff1 = cols_train - cols_test
print('train seulement', diff1)

#Fonctionnalités en test mais pas en train
diff2 = cols_test - cols_train
print('test uniquement', diff2)

Seul le test a beaucoup de Education_nan et Property_Area_nan. Ce qui est arrivé à Married_nan, c'est que Married_nan existe correctement dans les données d'entraînement avec une valeur unique [0,1].

Fondamentalement, les entités qui ne sont pas dans le test mais dans le train sont restaurées et les entités qui sont dans le test et non dans le train sont supprimées. Ici, seules les fonctionnalités qui sont en test mais pas en train sont supprimées.

X_test1 = X_test1.drop(['Education_nan', 'Property_Area_nan'], axis=1)
check(X_test1)

Maintenant, utilisons la valeur moyenne des données d'entraînement pour compléter la valeur manquante de la variable numérique.

#Saisie des valeurs manquantes numériques
X_test2 = X_test1.fillna(X_train1.mean())

Ensuite, comme pour les données d'entraînement, la quantité de fonctionnalités est finalement réduite à 10. Avant cela, sécurisez l'ordre des quantités de caractéristiques des données d'entraînement et des données de test.

# X_X les fonctionnalités de test2_Faites la même commande que train2
X_test1 = X_test1.reindex(X_train1.columns.values,axis=1)

Enfin, les données de test sont également réduites à l'aide du sélecteur de résultat de filtrage RFE.support_ effectué sur les données d'apprentissage.

X_test3 = X_test2.loc[ : , X_test2.columns[selector.support_]]
check(X_test3)

Ce sont les données de test finales. Ceci termine le prétraitement des données.