[PYTHON] [Kaggle] De la lecture des données au prétraitement et au codage

0. Premier

Lorsque vous essayez d'analyser des données à l'aide de l'apprentissage automatique, soudainement à partir des données csv obtenues
"OK! Revenons en arrière!" "OK! Classifions!"
De cette manière, il est rare de le mettre soudainement dans la génération de modèles. Au contraire, les barrières jusqu'à ce point sont assez élevées pour les débutants. Donc, cette fois, j'ai résumé le prétraitement des données.

1. Lire les données

Cette fois, j'ai emprunté des données au Titanic of Kaggle. Au fait, j'utilise jupyter. (Si quelqu'un sait comment combiner l'entrée et la sortie de jupyter dans Qiita, faites-le moi savoir ...)

In[1]

%matplotlib inline
import matplotlib as plt
import pandas as pd
import numpy as np
import seaborn as sns

df = pd.read_csv('./train.csv')
df = df.set_index('PassengerId') #Définir des colonnes uniques à indexer
print(df.shape)
df.head()

2. Supprimez les colonnes qui ne sont pas nécessaires pour l'analyse

In[2]

df = df.drop(['Name', 'Ticket'], axis=1) #Supprimer les colonnes qui ne sont pas nécessaires pour l'analyse
df.head()

3. Vérifiez le type de données et la perte

In[3]

print(df.info())
#print(df.dtypes) #Cliquez ici si vous souhaitez vérifier uniquement le type de données
df.isnull().sum(axis=0)
#df.isnull().any(axis=0) #Cliquez ici pour vérifier uniquement la présence ou l'absence de null

out[3]

<class 'pandas.core.frame.DataFrame'>
Int64Index: 891 entries, 1 to 891
Data columns (total 9 columns):
Survived    891 non-null int64
Pclass      891 non-null int64
Sex         891 non-null object
Age         714 non-null float64
SibSp       891 non-null int64
Parch       891 non-null int64
Fare        891 non-null float64
Cabin       204 non-null object
Embarked    889 non-null object
dtypes: float64(2), int64(4), object(3)
memory usage: 69.6+ KB
None
Survived      0
Pclass        0
Sex           0
Age         177
SibSp         0
Parch         0
Fare          0
Cabin       687
Embarked      2
dtype: int64

4. Comptez les types d'éléments sur l'échelle nominale

In[4]

#Compter les types d'éléments sur l'échelle nominale
import collections
c = collections.Counter(df['Sex'])
print('Sex:',c)
c = collections.Counter(df['Cabin'])
print('Cabin:',len(c))
c = collections.Counter(df['Embarked'])
print('Embarked:',c)

out[4]

Sex: Counter({'male': 577, 'female': 314})
Cabin: 148
Embarked: Counter({'S': 644, 'C': 168, 'Q': 77, nan: 2})

5. Supprimer / compléter les défauts

In[5]

df = df.drop(['Cabin'], axis=1) #Supprimé car il semble difficile à utiliser pour l'analyse
df = df.dropna(subset = ['Embarked']) #La cabine a peu de défauts, alors supprimez-la avec dropna dans une ligne
df = df.fillna(method = 'ffill') #D'autres colonnes complètent les données précédentes
print(df.isnull().any(axis=0))
df.shape

out[5]

Survived    False
Pclass      False
Sex         False
Age         False
SibSp       False
Parch       False
Fare        False
Embarked    False
dtype: bool
(889, 8)

6. Codage des étiquettes

Convertit les données de type objet (caractère) en données de type numérique (numérique) à l'aide du codage d'étiquette.

In[6]

from sklearn.preprocessing import LabelEncoder
for column in ['Sex','Embarked']:
    le = LabelEncoder()
    le.fit(df[column])
    df[column] = le.transform(df[column])
df.head()

Vous pouvez voir qu'il existe un encodage d'étiquette pour Sex and Embarked.

Grâce au codage des étiquettes, vous pouvez également voir le contour des données en utilisant le diagramme de paires de seaborn, etc.

sns.pairplot(df);

Je pense qu'il est également bon de sélectionner uniquement des variables continues et de les afficher. (Bien que ce qui suit en inclue certaines qui ne sont pas des variables strictement continues ...)

df_continuous = df[['Age','SibSp','Parch','Fare']]
sns.pairplot(df_continuous);

7. Un encodage à chaud

Codage à chaud des données numériques et autres données d'échelle nominale à l'aide du codage à chaud. Je ne savais pas comment bien utiliser OneHotEncoder de scikitlearn, j'ai donc utilisé get_dummies de pandas.

In[7]

df = pd.get_dummies(df, columns = ['Pclass','Embarked'])
df.head()

Vous pouvez voir qu'il existe un encodage à chaud pour Pclass et Embarked.

8. Résumé

Je pense que cette tendance est commune à de nombreuses analyses de données. Veuillez vous référer au déroulement du prétraitement.

Nous recherchons des commentaires, des articles, etc.