Construire un modèle prédictif à l'aide de Python

introduction

Je suis tombé sur cette vertu stratégique de Sun Tzu récemment:

Qu'est-ce que cela a à voir avec un blog de science des données? C'est l'essence de la façon dont les compétitions sont gagnées et hackaton. Vous arrivez à la compétition mieux préparé que les concurrents, tu cours vite, vous apprenez et itérez pour tirer le meilleur de vous-même.

La semaine dernière, Nous publions « Un moyen parfait de construire un modèle prédictif en moins de 10 minutes en utilisant R". Tout le monde peut deviner une suite rapide à ce post. Compte tenu de l'essor de Python ces dernières années et de sa simplicité, il est logique que cette boîte à outils soit prête pour les pythonistes du monde de la science des données. Je suivrai une structure similaire à celle du post précédent avec mes contributions supplémentaires à différentes étapes de la construction du modèle. Ces deux articles vous aideront à construire votre premier modèle prédictif plus rapidement et avec une meilleure puissance. La plupart des meilleurs data scientists et Kagglers construisent rapidement leur premier modèle efficace et l'expédie. Cela les aide non seulement à avoir un avantage sur le tableau des leaders, mais leur fournit également une solution de référence pour surmonter.

Décomposition de la procédure de modélisation prédictive

Je me concentre toujours sur l'investissement de temps de qualité pendant la phase initiale de la construction du modèle, comme génération d'hypothèses / séances de remue-méninges / discussion (s) ou compréhension du domaine. Toutes ces activités m'aident à comprendre le problème, ce qui m'amène finalement à concevoir des solutions d'affaires plus puissantes. Il y a de bonnes raisons pour lesquelles vous devriez passer ce temps au début:

Vous avez suffisamment de temps pour investir et vous êtes frais (a un impact)
Il n'est pas biaisé avec d'autres points de données ou pensées (Je vous suggère toujours de générer des hypothèses avant de creuser dans les données)
À un stade ultérieur, serait pressé de terminer le projet et ne serait pas en mesure de consacrer du temps de qualité.

Cette étape nécessitera du temps de qualité, donc je ne mentionne pas la chronologie ici, Je recommanderais que vous le fassiez comme une pratique standard. Cela vous aidera à créer de meilleurs modèles prédictifs et à réduire le nombre d'itérations de travail dans les étapes ultérieures. Examinons les étapes restantes de la première construction du modèle avec des échéanciers:

Analyse descriptive des données: 50% du temps
Traitement des données (valeur manquante et correction des valeurs aberrantes): 40% du temps
La modélisation des données: 4% du temps
Estimation des performances: 6% du temps

PD: c'est la division du temps consacré uniquement à la première construction du modèle

Passons en revue la procédure étape par étape (avec des estimations du temps passé à chaque étape):

Étape 1: Analyse descriptive / Exploration des données:

À mes débuts en tant que data scientist, l'exploration des données prenait beaucoup de temps. Avec le temps, J'ai automatisé de nombreuses opérations avec les données. Étant donné que la préparation des données occupe le 50% du travail dans la construction d'un premier modèle, les avantages de l'automatisation sont évidents. Vous pouvez vérifier le “7 étapes d'exploration des données” pour voir les opérations d'exploration de données les plus courantes.

Tavish a déjà mentionné dans son article qu'avec des outils avancés d'apprentissage automatique en marche, le temps requis pour effectuer cette tâche a été considérablement réduit. Puisqu'il s'agit de notre premier modèle de référence, nous éliminons tout type d'ingénierie fonctionnelle. Pour cela, le temps dont vous pourriez avoir besoin pour effectuer une analyse descriptive est limité à la connaissance des valeurs manquantes et des grandes fonctionnalités directement visibles. Dans ma méthodologie, a besoin de 2 minutes pour terminer cette étape (Hypothèse, 100.000 observations dans l'ensemble de données).

Les opérations que j'effectue pour mon premier modèle comprennent:

Identifier les caractéristiques d'identification, entrée et destination
Identifier les caractéristiques catégorielles et numériques
Identifier les colonnes avec des valeurs manquantes

Étape 2: Traitement des données (traitement des valeurs manquantes):

Il existe plusieurs alternatives pour y faire face. Pour notre premier modèle, nous nous concentrerons sur les techniques intelligentes et rapides pour construire votre premier modèle efficace (ceux-ci ont déjà été discutés par Tavish dans son post, j'ajoute des méthodes)

Créer des indicateurs factices pour les valeurs manquantes: Ça marche, parfois les valeurs manquantes elles-mêmes contiennent une bonne quantité d'informations.
Imputer la valeur manquante avec la moyenne / médian / toute autre méthode plus simple: l'imputation de la moyenne et de la médiane fonctionne bien, la plupart des gens préfèrent imputer avec la valeur moyenne, mais en cas de distribution asymétrique, Je vous suggère de choisir la médiane. D'autres méthodes intelligentes sont l'imputation de valeurs à travers des cas similaires et l'imputation médiane à l'aide d'autres caractéristiques pertinentes ou la construction d'un modèle. Par exemple: dans le défi de survie du Titanic, Vous pouvez imputer les valeurs d'âge manquantes en utilisant la salutation du nom du passager comme “Sr.”, “Mademoiselle”, “M / s.”, “Maestro” et autres, et cela a montré un bon impact sur les performances du modèle. .
Imputer la valeur manquante de la variable catégorielle: créer un nouveau niveau pour imputer la variable catégorielle afin que toutes les valeurs manquantes soient codées comme une valeur unique, dis-le “Nouveau_Chat” ou vous pouvez regarder la combinaison de fréquences et imputer la valeur manquante avec la valeur qui a une fréquence plus élevée.

Avec des méthodes de traitement de données aussi simples, peut réduire le temps de traitement des données pour 3-4 minutes.

Étape 3. La modélisation des données:

Je recommande d'utiliser l'une des techniques GBM / Forêt aléatoire, selon le problème de l'entreprise. Ces deux techniques sont extrêmement efficaces pour créer une solution de référence.. J'ai vu des data scientists utiliser souvent ces deux méthodes comme premier modèle et, dans certains cas, il sert également de modèle final. Cela prendra le maximum de temps (~ 4-5 minutes).

Étape 4. Estimation des performances:

Il existe plusieurs méthodes pour valider les performances de votre modèle, Je vous suggère de diviser votre jeu de données de train en Train et de valider (idéalement 70:30) et créer un modèle basé sur 70% à partir du jeu de données du train. À présent, effectuer une validation croisée à l'aide du 30% à partir de l'ensemble de données validé et évaluer les performances à l'aide de la métrique d'évaluation. Ceci en conclusion prend 1-2 minutes exécuter et documenter.

L'intention de ce poste n'est pas de gagner la compétition, mais pour se déterminer un point de référence. Examinons les codes Python pour effectuer les étapes ci-dessus et créer votre premier modèle avec le plus grand impact.

Commençons à mettre cela en action

J’ai supposé qu’il avait fait toute la génération d’hypothèses en premier et qu’il était bon avec la science des données de base en utilisant Python.. J’illustre cela avec un exemple de défi de science des données.. Regardons la structure:

Paso 1 : Importez les bibliothèques indispensables et lisez le jeu de données de test et de formation. Attachez les deux.

import pandas as pd
import numpy as np
from sklearn.preprocessing import LabelEncoder
import random
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import GradientBoostingClassifier

train=pd.read_csv('C:/Utilisateurs/DataPeaker/Desktop/challenge/Train.csv')
test=pd.read_csv('C:/Utilisateurs/DataPeaker/Desktop/challenge/Test.csv')
former['Type']='Train' #Create a flag for Train and Test Data set
test['Type']='Test'
fullData = pd.concat([former,test],axe=0) #Ensemble combiné de données de train et de test

Paso 2: Le pas 2 del marco no es necesario en Python. Pasamos al siguiente paso.

Paso 3: Afficher les noms de colonnes / résumé de l'ensemble de données

fullData.columns # This will show all the column names
fullData.head(10) # Afficher d’abord 10 records of dataframe
fullData.describe() #Vous pouvez consulter le résumé des champs numériques à l’aide de décrire() une fonction

Paso 4: Identificar las a) Variables de identificación b) Variables objetivo c) Variables categóricas d) Variables numéricas e) Variables Otras

ID_col = [« REF_NO »]
target_col = ["Compte.Statut"]
cat_cols = ['enfants',« age_band »,« statut »,« profession »,« occupation_partner »,« home_status »,« family_income »,« self_employed », « self_employed_partner »,« year_last_moved »,'TVarea',« post_code »,« post_area »,'genre','Région']
num_cols= liste(ensemble(liste(fullData.columns))-ensemble(cat_cols)-ensemble(ID_col)-ensemble(target_col)-ensemble(data_col))
other_col=['Type'] #Identificateur de l’ensemble de données de test et de train

Paso 5 : Identifique las variables con valores perdidos y cree una bandera para esas

fullData.isnull().tout()#Renvoie la fonctionnalité avec True ou False,True signifie avoir une valeur manquante sinon False

num_cat_cols = num_cols+cat_cols # Combined numerical and Categorical variables

#Create a new variable for each variable having missing value with VariableName_NA 
# et signalez la valeur manquante avec 1 et autres avec 0

pour var en num_cat_cols:
    si fullData[où].est nul().tout()== Vrai:
        fullData[var+'_NA']=fullData[où].est nul()*1

Paso 6 : Imputer les valeurs manquantes

#Impute numerical missing values with mean
fullData[num_cols] = fullData[num_cols].remplir(fullData[num_cols].moyenne(),inplace=Vrai)

#Imputer les valeurs manquantes catégorielles avec -9999
fullData[cat_cols] = fullData[cat_cols].remplir(valeur = -9999)

Paso 7 : Cree codificadores de etiquetas para variables categóricas y divida el conjunto de datos para entrenar y probar, divida aún más el conjunto de datos del tren para entrenar y validar

#create label encoders for categorical features
for var in cat_cols:
 nombre = LabelEncoder()
 fullData[où] = number.fit_transform(fullData[où].astype('str'))

#Target variable is also a categorical so convert it
fullData["Compte.Statut"] = number.fit_transform(fullData["Compte.Statut"].astype('str'))

train=fullDonnées[fullData['Type']== 'Train']
test=fullData[fullData['Type']== 'Test']

former[« is_train »] = np.random.uniform(0, 1, longueur(former)) <= .75
Former, Valider = train[former[« is_train »]== Vrai], former[former[« is_train »]== Faux]

Paso 8 : Passer les variables imputées et fictives (indicateurs des valeurs perdues) à la procédure de modélisation. J’utilise une forêt aléatoire pour prédire la classe.

caractéristiques=liste(ensemble(liste(fullData.columns))-ensemble(ID_col)-ensemble(target_col)-ensemble(other_col))

x_train = Train[liste(caractéristiques)].values
y_train = Train["Compte.Statut"].values
x_validate = Validate[liste(caractéristiques)].values
y_validate = Validate["Compte.Statut"].values
x_test=test[liste(caractéristiques)].valeurs

graine.aléatoire(100)
rf = RandomForestClassifier(n_estimateurs = 1000)
rf.fit(x_train, y_train)

Paso 9 : Vérifier les performances et faire des prédictions

statut = rf.predict_proba(x_validate)
fpr, tpr, _ = roc_curve(y_validate, statut[:,1])
roc_auc = auc(fpr, tpr)
print roc_auc

final_status = rf.predict_proba(x_test)
test["Compte.Statut"]=final_status[:,1]
test.to_csv('C:/Utilisateurs/DataPeaker/Desktop/model_output.csv',colonnes=[« REF_NO »,'Compte.Statut'])

Et soumettre!

Remarques finales

Avec chance, cet article vous permettra de commencer à créer votre propre code de notation à partir de 10 minutes. La plupart des enseignants de Kaggle et les meilleurs scientifiques de notre pays hackaton Préparez ces codes et lancez votre premier envoi avant de faire une analyse détaillée. Une fois qu'ils ont une estimation du point de référence, ils commencent à improviser plus. Partagez vos codes complets dans la zone de commentaire ci-dessous.