Construya un modelo predictivo usando Python

Introducción

Me encontré con esta virtud estratégica de Sun Tzu recientemente:

¿Qué tiene esto que ver con un blog de ciencia de datos? Esta es la esencia de cómo se ganan competiciones y hackatones. Llegas a la competencia mejor preparado que los competidores, ejecutas rápidamente, aprendes e iteras para sacar lo mejor de ti.

La semana pasada, publicamos “Manera perfecta de construir un modelo predictivo en menos de 10 minutos usando R”. Cualquiera puede adivinar un seguimiento rápido de este post. Dado el auge de Python en los últimos años y su simplicidad, tiene sentido tener este kit de herramientas listo para los Pythonistas en el mundo de la ciencia de datos. Seguiré una estructura semejante a la del post anterior con mis aportes adicionales en diferentes etapas de la construcción del modelo. Estos dos posts le ayudarán a construir su primer modelo predictivo más rápido y con mejor potencia. La mayoría de los mejores científicos de datos y Kagglers construyen su primer modelo eficaz rápidamente y lo envían. Esto no solo les ayuda a tener una ventaja en la tabla de líderes, sino que además les proporciona una solución de referencia para superar.

Desglose del procedimiento de modelado predictivo

Siempre me concentro en invertir tiempo de calidad durante la etapa inicial de la construcción del modelo, como la generación de hipótesis / sesiones de lluvia de ideas / discusión (s) o la comprensión del dominio. Todas estas actividades me ayudan a relacionarme con el problema, lo que eventualmente me lleva a diseñar soluciones comerciales más poderosas. Hay buenas razones por las que debería dedicar este tiempo al principio:

Tienes tiempo suficiente para invertir y estás fresco (tiene impacto)
No está sesgado con otros puntos de datos o pensamientos (siempre sugiero que genere hipótesis antes de profundizar en los datos)
En una etapa posterior, tendría prisa por completar el proyecto y no podría dedicar tiempo de calidad.

Esta etapa necesitará un tiempo de calidad, por lo que no estoy mencionando la línea de tiempo aquí, le recomendaría que la haga como una práctica estándar. Le ayudará a construir mejores modelos predictivos y dará como consecuencia una menor iteración del trabajo en etapas posteriores. Veamos las etapas restantes en la primera compilación del modelo con líneas de tiempo:

Análisis descriptivo de los datos: 50% del tiempo
Tratamiento de datos (valor perdido y corrección de valores atípicos): 40% del tiempo
Modelado de datos: 4% del tiempo
Estimación del rendimiento: 6% del tiempo

PD: esta es la división del tiempo dedicado solo a la primera construcción del modelo

Repasemos el procedimiento paso a paso (con estimaciones del tiempo invertido en cada paso):

Etapa 1: Análisis descriptivo / Exploración de datos:

En mis primeros días como científico de datos, la exploración de datos solía llevarme mucho tiempo. Con el tiempo, he automatizado muchas operaciones con los datos. Dado que la preparación de datos ocupa el 50% del trabajo en la construcción de un primer modelo, los beneficios de la automatización son obvios. Puede consultar los «7 pasos de la exploración de datos» para ver las operaciones más comunes de exploración de datos.

Tavish ya ha mencionado en su post que con las herramientas avanzadas de aprendizaje automático en carrera, el tiempo necesario para realizar esta tarea se ha reducido significativamente. Dado que este es nuestro primer modelo de referencia, eliminamos cualquier tipo de ingeniería de funciones. Por eso, el tiempo que podría necesitar para realizar un análisis descriptivo está restringido para conocer los valores perdidos y las grandes características que son de forma directa visibles. En mi metodología, necesita 2 minutos para completar este paso (Supuesto, 100.000 observaciones en el conjunto de datos).

Las operaciones que realizo para mi primer modelo incluyen:

Identificar características de identificación, entrada y destino
Identificar características categóricas y numéricas
Identificar columnas con valores perdidos

Etapa 2: Tratamiento de datos (tratamiento de valores perdidos):

Hay varias alternativas para afrontarlo. Para nuestro primer modelo, nos centraremos en las técnicas inteligentes y rápidas para construir su primer modelo efectivo (estas ya fueron discutidas por Tavish en su post, estoy agregando algunos métodos)

Crear indicadores ficticios para los valores faltantes: funciona, a veces los valores faltantes en sí contienen una buena cantidad de información.
Imputar el valor faltante con media / mediana / cualquier otro método más sencillo: la imputación de la media y la mediana funciona bien, la mayoría de las personas prefieren imputar con el valor medio, pero en caso de distribución sesgada, le sugiero que elija la mediana. Otros métodos inteligentes están imputando valores por medio de casos similares y la imputación mediana usando otras características relevantes o construyendo un modelo. A modo de ejemplo: en el desafío de supervivencia del Titanic, puede imputar los valores faltantes de Edad usando el saludo del nombre de los pasajeros como «Sr.», «Señorita», «Sra.», «Maestro» y otros, y esto ha demostrado un buen impacto en el rendimiento del modelo. .
Imputar el valor faltante de la variable categórica: cree un nuevo nivel para imputar la variable categórica de modo que todo el valor faltante se codifique como un valor único, diga «New_Cat» o puede mirar la combinación de frecuencias e imputar el valor faltante con el valor que dispone de una frecuencia más alta.

Con métodos tan simples de tratamiento de datos, puede reducir el tiempo de tratamiento de datos para 3-4 minutos.

Etapa 3. Modelado de datos:

Recomiendo utilizar cualquiera de las técnicas de GBM / Random Forest, dependiendo del problema comercial. Estas dos técnicas son extremadamente efectivas para crear una solución de referencia. He visto que los científicos de datos usan estos dos métodos a menudo como su primer modelo y, en algunos casos, además actúa como modelo final. Esto llevará la máxima cantidad de tiempo (~ 4-5 minutos).

Etapa 4. Estimación del rendimiento:

Existen varios métodos para validar el rendimiento de su modelo, le sugiero que divida el conjunto de datos de su tren en Train y valide (idealmente 70:30) y cree un modelo basado en el 70% del conjunto de datos del tren. Ahora, realice una validación cruzada usando el 30% del conjunto de datos validados y evalúe el rendimiento usando la métrica de evaluación. Esto en conclusión toma 1-2 minutos ejecutar y documentar.

La intención de este post no es ganar la competencia, sino determinar un punto de referencia para nosotros mismos. Veamos los códigos de Python para realizar los pasos anteriores y construir su primer modelo con mayor impacto.

Comencemos a poner esto en acción

Supuse que primero ha realizado toda la generación de hipótesis y es bueno con la ciencia de datos básica usando Python. Estoy ilustrando esto con un ejemplo de desafío de ciencia de datos. Veamos la estructura:

Paso 1 : Importe las bibliotecas imprescindibles y lea el conjunto de datos de prueba y entrenamiento. Adjunte ambos.

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:/Users/DataPeaker/Desktop/challenge/Train.csv')
test=pd.read_csv('C:/Users/DataPeaker/Desktop/challenge/Test.csv')
train['Type']='Train' #Create a flag for Train and Test Data set
test['Type']='Test'
fullData = pd.concat([train,test],axis=0) #Combined both Train and Test Data set

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

Paso 3: Ver los nombres de columna / resumen del conjunto de datos

fullData.columns # This will show all the column names
fullData.head(10) # Show first 10 records of dataframe
fullData.describe() #You can look at summary of numerical fields by using describe() function

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

ID_col = ['REF_NO']
target_col = ["Account.Status"]
cat_cols = ['children','age_band','status','occupation','occupation_partner','home_status','family_income','self_employed', 'self_employed_partner','year_last_moved','TVarea','post_code','post_area','gender','region']
num_cols= list(set(list(fullData.columns))-set(cat_cols)-set(ID_col)-set(target_col)-set(data_col))
other_col=['Type'] #Test and Train Data set identifier

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

fullData.isnull().any()#Will return the feature with True or False,True means have missing value else 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 
# and flag missing value with 1 and other with 0

for var in num_cat_cols:
    if fullData[var].isnull().any()==True:
        fullData[var+'_NA']=fullData[var].isnull()*1

Paso 6 : Imputar valores perdidos

#Impute numerical missing values with mean
fullData[num_cols] = fullData[num_cols].fillna(fullData[num_cols].mean(),inplace=True)

#Impute categorical missing values with -9999
fullData[cat_cols] = fullData[cat_cols].fillna(value = -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:
 number = LabelEncoder()
 fullData[var] = number.fit_transform(fullData[var].astype('str'))

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

train=fullData[fullData['Type']=='Train']
test=fullData[fullData['Type']=='Test']

train['is_train'] = np.random.uniform(0, 1, len(train)) <= .75
Train, Validate = train[train['is_train']==True], train[train['is_train']==False]

Paso 8 : Pase las variables imputadas y ficticias (indicadores de valores perdidos) al procedimiento de modelado. Estoy usando un bosque aleatorio para predecir la clase.

features=list(set(list(fullData.columns))-set(ID_col)-set(target_col)-set(other_col))

x_train = Train[list(features)].values
y_train = Train["Account.Status"].values
x_validate = Validate[list(features)].values
y_validate = Validate["Account.Status"].values
x_test=test[list(features)].values

random.seed(100)
rf = RandomForestClassifier(n_estimators=1000)
rf.fit(x_train, y_train)

Paso 9 : Compruebe el rendimiento y haga predicciones

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

final_status = rf.predict_proba(x_test)
test["Account.Status"]=final_status[:,1]
test.to_csv('C:/Users/DataPeaker/Desktop/model_output.csv',columns=['REF_NO','Account.Status'])

¡Y somete!

Notas finales

Con suerte, este post le permitirá comenzar a crear su propio código de puntuación de 10 minutos. La mayoría de los maestros de Kaggle y los mejores científicos de nuestra hackatones Tenga estos códigos listos y dispare su primer envío antes de realizar un análisis detallado. Una vez que disponen una estimación del punto de referencia, comienzan a improvisar más. Comparta sus códigos completos en el cuadro de comentarios a continuación.