[Python] Analyse de données, pratique du machine learning (Kaggle) -Prétraitement des données-

introduction

Article précédent [Python] Première analyse de données / apprentissage automatique (Kaggle) [Python] Première analyse de données / apprentissage automatique (Kaggle) ~ Part2 ~ Dans la foulée, nous avons défié la concurrence relativement modérée «Prix des logements: Techniques de régression avancées» chez Kaggle!

Le concours cette fois-ci est d'estimer le prix d'une maison en fonction des variables d'information sur la maison. Cependant, il y a 80 variables liées à cette maison, et j'ai soudainement eu peur ... (rires)

En pensant "Est-ce possible de faire ça?", J'ai emprunté cette fois aussi la sagesse de mes ancêtres! Lol Code de référence ↓↓↓

• Stacked Regressions : Top 4% on LeaderBoard
• Comprehensive data exploration with Python

Le flux général est le suivant.

1. Ingénierie des fonctionnalités
2. ** Imputation des valeurs manquantes ** Remplissez les valeurs manquantes
3. ** Transformation ** Transformation de données (transformation de journal, etc.)
4. ** Codage des étiquettes ** Codage des données catégorielles
5. ** Transformation Box Cox **: Transformation pour la rapprocher d'une distribution normale
6. ** Obtenir des variables factices ** Convertir des données catégorielles en données numériques
7. Modélisation (apprentissage d'ensemble d'empilement)
8. Analyse du modèle de base
9. Analyse du deuxième modèle

Et dans cet article, nous nous concentrerons sur ** l'ingénierie des fonctionnalités **!

Acquisition de données / import de bibliothèque

#Import de bibliothèque

import numpy as np #algèbre linéaire
import pandas as pd #Traitement des données, fonctionnement du fichier csv
%matplotlib inline
import matplotlib.pyplot as plt  # Matlab-style plotting
import seaborn as sns
color = sns.color_palette()
sns.set_style('darkgrid')
import warnings
def ignore_warn(*args, **kwargs):
    pass
warnings.warn = ignore_warn #Ignorer les avertissements inutiles(from sklearn and seaborn)


from scipy import stats
from scipy.stats import norm, skew #Manipulation statistique

pd.set_option('display.float_format', lambda x: '{:.3f}'.format(x)) #Définir le point décimal

from subprocess import check_output
print(check_output(["ls", "../input"]).decode("utf8")) #Vérifiez si le fichier est valide

production

data_description.txt
sample_submission.csv
test.csv
train.csv

Création de trame de données

#Obtenez des données, créez un bloc de données
train = pd.read_csv('../input/train.csv')
test = pd.read_csv('../input/test.csv')

Jetons un coup d'œil à la trame de données!

##Affichage des trames de données
train.head(5)

#Nombre d'échantillons et fonctionnalités
print("The train data size before dropping Id feature is : {} ".format(train.shape))
print("The test data size before dropping Id feature is : {} ".format(test.shape))

#'Id'Enregistrer la colonne
train_ID = train['Id']
test_ID = test['Id']

#L'ID n'est pas nécessaire dans le processus de prédiction, supprimez-le
train.drop("Id", axis = 1, inplace = True)
test.drop("Id", axis = 1, inplace = True)

#Vérifiez à nouveau si l'ID a disparu
print("\nThe train data size after dropping Id feature is : {} ".format(train.shape)) 
print("The test data size after dropping Id feature is : {} ".format(test.shape))

production

The train data size before dropping Id feature is : (1460, 81) 
The test data size before dropping Id feature is : (1459, 80) 

The train data size after dropping Id feature is : (1460, 80) 
The test data size after dropping Id feature is : (1459, 79) 

1460 données d'entraînement, 80 fonctionnalités Il y a 1459 données de test et 79 fonctionnalités!

Eh, ** Trop de fonctionnalités! !! ** ** Comment dois-je analyser cela?

** Pour le moment, numérisons les valeurs manquantes, la distorsion et les données catégorielles **!

Prétraitement des données

Commençons par les valeurs manquantes! Fondamentalement * Il est normal d'effacer les fonctionnalités avec un taux de perte de données de 15% ou plus !! *

1. Valeur manquante

** Intégrez les données une fois pour ** gérer collectivement les valeurs manquantes ** avec le train de données d'entraînement et le test des données de test!

ntrain = train.shape[0]
ntest = test.shape[0]
y_train = train.SalePrice.values
all_data = pd.concat((train, test)).reset_index(drop=True)
all_data.drop(['SalePrice'], axis=1, inplace=True)
print("all_data size is : {}".format(all_data.shape))

production

all_data size is : (2917, 79)

Le nombre de données est de 2917 et le nombre de fonctionnalités est de 79, donc ça a été bien intégré!

Pour identifier efficacement les fonctionnalités avec des valeurs manquantes

** 1. Calculez le taux manquant de toutes les fonctionnalités et placez la fonctionnalité avec un taux de valeur manquante> 0 dans une nouvelle trame de données ** ** 2. Visualisez le taux de défauts ** ** 3. Envisagez de supprimer ou d'attribuer des valeurs pour chaque fonctionnalité **

Nous traiterons les valeurs manquantes dans ce flux!

** 1. Calculez le taux manquant de toutes les fonctionnalités et placez la fonctionnalité avec un taux de valeur manquante> 0 dans une nouvelle trame de données **

all_data_na = (all_data.isnull().sum() / len(all_data)) * 100
all_data_na = all_data_na.drop(all_data_na[all_data_na == 0].index).sort_values(ascending=False)[:30]#Extraire uniquement les variables contenant des valeurs manquantes
missing_data = pd.DataFrame({'Missing Ratio' :all_data_na})#Mettez dans une trame de données.
missing_data.head(20)

production

** 2. Visualisez le taux de défauts **

f, ax = plt.subplots(figsize=(15, 12))
plt.xticks(rotation='90')
sns.barplot(x=all_data_na.index, y=all_data_na)
plt.xlabel('Features', fontsize=15)
plt.ylabel('Percent of missing values', fontsize=15)
plt.title('Percent missing data by feature', fontsize=15)

** 3. Envisagez de supprimer ou d'attribuer des valeurs pour chaque fonctionnalité ** Nous entrerons des valeurs pour les fonctionnalités, y compris les valeurs manquantes indiquées dans le graphique ci-dessus! C'est un peu difficile car nous considérons chaque fonctionnalité une par une, mais nous le ferons!

• ** PoolQC **: Principalement des valeurs manquantes. Entrez Aucun dans la valeur manquante pour signifier "pas de pool"

all_data["PoolQC"] = all_data["PoolQC"].fillna("None")

• ** MiscFeature **: Selon la description des données, NA signifie "pas d'autres fonctionnalités". Mettre None pour les valeurs manquantes

all_data["MiscFeature"] = all_data["MiscFeature"].fillna("None")

• ** Ruelle **: Selon la description des données, cela signifie "pas d'accès à la ruelle". Mettre None pour les valeurs manquantes

all_data["Alley"] = all_data["Alley"].fillna("None")

• ** Clôture **: signifie «pas de clôture». Mettre None pour les valeurs manquantes

all_data["Fence"] = all_data["Fence"].fillna("None")

• ** FireplaceQu **: signifie «pas de cheminée». Mettre None pour les valeurs manquantes

all_data["FireplaceQu"] = all_data["FireplaceQu"].fillna("None")

• ** LotFrontage **: Remplacez la valeur moyenne de la maison voisine par la valeur manquante Au fait, median () obtient la valeur moyenne

#Regrouper par quartier et remplacer le LotFrontage moyen du groupe par la valeur manquante
all_data["LotFrontage"] = all_data.groupby("Neighborhood")["LotFrontage"].transform(
    lambda x: x.fillna(x.median()))

• ** GarageType, GarageFinish, GarageQual et GarageCond **: remplissez les valeurs manquantes avec None

for col in ('GarageType', 'GarageFinish', 'GarageQual', 'GarageCond'):
    all_data[col] = all_data[col].fillna('None')

• ** GarageYrBlt, GarageArea et GarageCars **: Mettez 0 dans la valeur manquante

for col in ('GarageYrBlt', 'GarageArea', 'GarageCars'):
    all_data[col] = all_data[col].fillna(0)

• ** BsmtFinSF1, BsmtFinSF2, BsmtUnfSF, TotalBsmtSF, BsmtFullBath et BsmtHalfBath **: Mettez 0 dans la valeur manquante

for col in ('BsmtFinSF1', 'BsmtFinSF2', 'BsmtUnfSF','TotalBsmtSF', 'BsmtFullBath', 'BsmtHalfBath'):
    all_data[col] = all_data[col].fillna(0)

• ** BsmtQual, BsmtCond, BsmtExposure, BsmtFinType1 et BsmtFinType2 **: mettez None dans la valeur manquante des données catégorielles

for col in ('BsmtQual', 'BsmtCond', 'BsmtExposure', 'BsmtFinType1', 'BsmtFinType2'):
    all_data[col] = all_data[col].fillna('None')

• ** MasVnrArea et MasVnrType **: entrez Aucun pour le type et 0 pour la zone

all_data["MasVnrType"] = all_data["MasVnrType"].fillna("None")
all_data["MasVnrArea"] = all_data["MasVnrArea"].fillna(0)

• ** MSZoning (La classification générale de zonage) **: «RL» est la valeur la plus éloignée de la valeur moyenne. Par conséquent, mettez RL dans la valeur manquante.

all_data['MSZoning'] = all_data['MSZoning'].fillna(all_data['MSZoning'].mode()[0])

• ** Utilitaires **: supprimé car il est inutile

all_data = all_data.drop(['Utilities'], axis=1)

• ** Fonctionnel **: NA est Typique, entrez donc Typ

all_data["Functional"] = all_data["Functional"].fillna("Typ")

• ** Électricité **: Il ne manque qu'une seule valeur. Cela inclut sBkrk mode (): obtenir la valeur la plus fréquente

all_data['Electrical'] = all_data['Electrical'].fillna(all_data['Electrical'].mode()[0])

• ** KitchenQual **: Entrez la valeur la plus fréquente pour une seule valeur manquante

all_data['KitchenQual'] = all_data['KitchenQual'].fillna(all_data['KitchenQual'].mode()[0])

• ** Exterior1st et Exterior2nd **: Mettez la valeur la plus fréquente dans la valeur manquante

all_data['Exterior1st'] = all_data['Exterior1st'].fillna(all_data['Exterior1st'].mode()[0])
all_data['Exterior2nd'] = all_data['Exterior2nd'].fillna(all_data['Exterior2nd'].mode()[0])

• ** SaleType **: valeur la plus fréquente

all_data['SaleType'] = all_data['SaleType'].fillna(all_data['SaleType'].mode()[0])

• ** MSSubClass **: Mettre None dans Nan

all_data['MSSubClass'] = all_data['MSSubClass'].fillna("None")

Vérifiez les valeurs manquantes restantes

#Vérifiez s'il y a des valeurs manquantes
all_data_na = (all_data.isnull().sum() / len(all_data)) * 100
all_data_na = all_data_na.drop(all_data_na[all_data_na == 0].index).sort_values(ascending=False)
missing_data = pd.DataFrame({'Missing Ratio' :all_data_na})
missing_data.head()

Aucune valeur manquante Ceci termine le traitement des valeurs manquantes! Il y avait beaucoup ...

2. Traitement des données de catégorie

Les données de catégorie sont des données représentées par une échelle nominale ou une échelle ordinale. En gros, ce sont des données non numériques!

Si les données de catégorie restent, elles ne peuvent pas être analysées ou apprises, nous allons donc les quantifier!

Traitement des données d'échelle ordinale

Les données d'échelle de commande sont des données qui n'ont de sens que dans l'ordre. Par exemple, la taille «s, M, L» d'une boisson de restauration rapide est quantifiée comme s → 0, M → 1, L → 2. Une chose à noter à propos des données ordinales est que ** les calculs numériques tels que la moyenne et l'écart type ne sont pas possibles **.

Commencez par convertir la valeur numérique des données de commande en données de caractère. (Plus tard, pour quantifier les données de catégorie ensemble)

#MSSubClass=The building class
all_data['MSSubClass'] = all_data['MSSubClass'].apply(str)


#Changing OverallCond into a categorical variable
all_data['OverallCond'] = all_data['OverallCond'].astype(str)


#Year and month sold are transformed into categorical features.
all_data['YrSold'] = all_data['YrSold'].astype(str)
all_data['MoSold'] = all_data['MoSold'].astype(str)

Convertir les données de catégorie en données numériques

LabelEncoder () sera utilisé pour numériser les données de commande et les données nominales ensemble! Sélectionnez les données avec .fit, convertissez en valeur numérique avec .transform (), Référence: Comment utiliser LabelEncoder de scicit-learn

from sklearn.preprocessing import LabelEncoder
cols = ('FireplaceQu', 'BsmtQual', 'BsmtCond', 'GarageQual', 'GarageCond', 
        'ExterQual', 'ExterCond','HeatingQC', 'PoolQC', 'KitchenQual', 'BsmtFinType1', 
        'BsmtFinType2', 'Functional', 'Fence', 'BsmtExposure', 'GarageFinish', 'LandSlope',
        'LotShape', 'PavedDrive', 'Street', 'Alley', 'CentralAir', 'MSSubClass', 'OverallCond', 
        'YrSold', 'MoSold')
# process columns, apply LabelEncoder to categorical features
for c in cols:
    lbl = LabelEncoder() 
    lbl.fit(list(all_data[c].values)) 
    all_data[c] = lbl.transform(list(all_data[c].values))

# shape        
print('Shape all_data: {}'.format(all_data.shape))

production

Shape all_data: (2917, 78)

Supplément 1: Ajout de nouvelles fonctionnalités

Étant donné que la superficie de tous les étages est également importante, nous ajouterons la valeur totale de TotalBsmtSF, 1stSF et 2ndFlrSF à la nouvelle tombe spéciale!

# Adding total sqfootage feature 
all_data['TotalSF'] = all_data['TotalBsmtSF'] + all_data['1stFlrSF'] + all_data['2ndFlrSF']

3. Transférer les données vers la distribution normale

En apprentissage automatique, on dit que ** c'est plus précis si les données suivent une distribution normale **! Alors, regardez d'abord la distorsion des données ** actuelle (à quelle distance elle est de la distribution normale) et laissez Box Cox faire en sorte que les données suivent la distribution normale! ** **

1. Tout d'abord, le degré de distorsion des données

numeric_feats = all_data.dtypes[all_data.dtypes != "object"].index

# Check the skew of all numerical features
skewed_feats = all_data[numeric_feats].apply(lambda x: skew(x.dropna())).sort_values(ascending=False)
print("\nSkew in numerical features: \n")
skewness = pd.DataFrame({'Skew' :skewed_feats})
skewness.head(10)

Après tout, vous pouvez voir plusieurs fonctionnalités qui ne sont pas normalement distribuées!

2. Passez à la distribution normale avec BoxCox!

skewness = skewness[abs(skewness) > 0.75]
print("There are {} skewed numerical features to Box Cox transform".format(skewness.shape[0]))

from scipy.special import boxcox1p
skewed_features = skewness.index
lam = 0.15
for feat in skewed_features:
    #all_data[feat] += 1
    all_data[feat] = boxcox1p(all_data[feat], lam)
    
#all_data[skewed_features] = np.log1p(all_data[skewed_features])

4. Enfin, ajoutez une variable factice à la fonction catégorielle!

Si vous utilisez une variable factice, la variable est définie de manière à ce que les données catégorielles soient représentées par 0,1. Référence: [Comment créer des variables factices et des précautions](https://newtechnologylifestyle.net/%E3%83%80%E3%83%9F%E3%83%BC%E5%A4%89%E6%95% B0% E3% 81% AE% E4% BD% 9C% E3% 82% 8A% E6% 96% B9% E3% 81% A8% E6% B3% A8% E6% 84% 8F% E7% 82% B9% E3% 81% AB% E3% 81% A4% E3% 81% 84% E3% 81% A6 /)

all_data = pd.get_dummies(all_data)
print(all_data.shape)

production

(2917, 220)

3. Ingénierie de la quantité d'objets terminée

Ceci termine le prétraitement des données!

Divisons les données d'entraînement et de test combinées!

train = all_data[:ntrain]
test = all_data[ntrain:]

Résumé

Cette fois, nous nous sommes concentrés sur ** le prétraitement des données ** du concours de prévision des prix des terrains résidentiels de Kaggle! Il y a 80 fonctionnalités, et c'était assez difficile au début, mais je pense que j'ai pu le gérer correctement en suivant les étapes ci-dessous!

Procédure de prétraitement des données ** 1. Intégration des données de train et de test ** ** 2. Traitement des valeurs manquantes ** ** 3. Traitement des données de catégorie **

Dans le prochain article, nous allons réellement apprendre et prédire à l'aide d'un modèle! !!

Merci pour votre visite! !!