Traduzido de: Build a Predictive Model in 10 Minutes (using Python)
Autor:
Introdução
Me deparei com essa visão estratégica de Sun Tzu recentemente:
VELOCIDADE E PREPARAÇÃO
Velocidade é a essência da guerra. Aproveite-se da falta de preparo do inimigo; siga por rotas secretas e ataque-o onde ele menos espera. Apoiar-se em simplismos e não se preparar é o maior dos crimes; estar preparado para qualquer contigência é a maior das virtudes.
O que isso tem a ver com um blog de Data Science? Porque esta é a essência de como você ganha competições e hackathons. Você chega na competição mais bem preparado do que os concorrentes, você executa com rapidez, aprende e interage trazendo o melhor de você.
Na semana passada, publicamos “A maneira perfeita para construir um modelo preditivo em menos de 10 minutos, utilizando R”. Qualquer um pode adivinhar facilmente um artigo de prosseguimento a esse. Dado o aumento do uso de Python no últimos anos e à sua simplicidade, faz sentido ter este kit de ferramentas pronto para os Pythonistas do mundo de Data Science. Vou seguir estrutura semelhante ao artigo anterior com as minhas notas adicionais em diferentes estágios da construção dos modelos. Estes dois artigos irão ajudá-lo a construir o seu primeiro modelo preditivo mais rápido e com maior poder. A maioria dos melhores Data Scientist e Kagglers constroem seu primeiro modelo de forma rápida e eficaz e então os submetem. Isso não só os ajuda a obter uma vantagem inicial no quadro de líderes, mas também fornece uma solução de referência a ser perseguida.
Detalhando o processo de modelagem preditiva
Eu sempre me concentro em investir tempo durante a fase inicial de construção de modelos na geração de hipóteses, em sessões de brainstorming e discussões de compreensão do domínio. Todas essas atividades me ajudam a me relacionar com o problema, o que, eventualmente, leva-me a projetar soluções de negócios mais robustas. Há boas razões para que você invista tempo nisso logo no começo:
1- Você tem tempo suficiente e ainda está com todo gás
2- Você não está tendencioso com relação a outros pontos de dados ou idéias (Eu sempre sugiro: faça a geração de hipóteses antes de mergulhar profundamente nos dados)
3- Na fase posterior, você vai estar com pressa para concluir o projeto e é capaz de não ter mais tempo
Esta etapa vai precisar desse tempo de reflexão sendo que eu não estou mencionando aqui uma linha do tempo, recomendo que você torne essa uma prática padrão. Ela irá ajudá-lo a construir melhores modelos preditivos e resultará em menos iteração do trabalho em fases posteriores. Vamos olhar para as etapas restantes com prazos na construção do primeiro modelo:
- Análise descritiva sobre os dados – 50% do tempo
- Tratamento dos dados (Valores faltantes e fixação de outliers) – 40%
- Modelagem de Dados – 4%
- Estimativa de desempenho – 6%
PS. Esta é a divisão de tempo gasto apenas com a primeira compilação do modelo
Vamos percorrer o processo passo a passo (com estimativas de tempo gasto em cada etapa):
Fase 1: Análise Descritiva / Exploração dos Dados:
Nos meus primeiros dias como cientista de dados, exploração de dados costumava me tomar um monte de tempo. Com o tempo, tenho automatizado uma série de operações nos dados. Dado que preparar os dados ocupa 50% do trabalho na construção do primeiro modelo, os benefícios da automação são óbvias. Você pode olhar para “7 etapas de exploração de dados” para olhar para as operações mais comuns na exploração de dados.
Tavish já mencionou em seu artigo que com ferramentas avançadas de machine learning chegando, o tempo necessário para executar esta tarefa tem sido reduzido significativamente. Uma vez que este é o nosso primeiro modelo padrão, nós iremos acabar com qualquer tipo de engenharia de recurso. Assim, o tempo que pode ser necessário para fazer uma análise descritiva é restrito a conhecer valores faltantes e características maiores que são diretamente visíveis. Na minha metodologia, você vai precisar de 2 minutos para concluir esta etapa (para uma premissa de 100.000 observações em conjunto de dados).
As operações que sigo para o meu primeiro modelo incluem:
- Identificar ID, input e recursos alvo
- Identificar as características categóricas e numéricas
- Identificar colunas com valores faltantes
Fase 2: Tratamento de Dados (tratamento de valores faltantes):
Existem várias maneiras de lidar com isso. Para o nosso primeiro modelo, vamos nos concentrar em técnicas inteligentes e rápidas para construir o seu primeiro modelo.
Criar bandeiras dummy para valores faltantes: isso funciona, às vezes valores faltantes por si prórpios carregam uma boa quantidade de informações.
Imputar valores faltantes com a média, a mediana ou outro método mais fácil: Imputar a média ou mediana tem um bom desempenho, a maioria das pessoas prefere imputar com valor médio, mas no caso de uma distribuição assimétrica eu sugiro que você para use a mediana. Outros métodos inteligentes são imputar médias ou medianas usando outros valores semelhantes e relevantes ou a construir um modelo. Por exemplo: No desafio de sobrevivência Titanic, você pode imputar valores de idade usando saudação de passageiros desaparecidos nome como “Mr.”, “Senhorita.”, “Sra.”, “Mestre” e outros e isso mostrou bom resultado no desempenho do modelo .
Imputar valor faltante da variável categórica: Crie um novo nível para imputar variável categórica para que todo o valor faltante seja codificado como um único valor como “New_Cat” ou você pode olhar para o mix frequência e imputar o valor faltante com o valor que tem maior frequência.
Com tais métodos simples de tratamento de dados, você pode reduzir o tempo para o tratamento de dados para 3-4 minutos.
Fase 3. Modelagem de Dados:
Eu recomendo usar qualquer uma das técnicas de GBM Random forest, dependendo do problema de negócio. Estas duas técnicas são extremamente eficazes para criar uma solução de referência. Já vi cientista de dados utilizar estes dois métodos frequentemente como seu primeiro modelo e, em alguns casos, acua como um modelo final também. Isso vai levar um tempo máximo de 4-5 minutos.
Fase 4. Estimativa de desempenho:
Existem vários métodos para validar o desempenho do modelo, eu sugiro que você divida seu conjunto de dados de treinamento em Treinamento e Validação (idealmente 70:30) e construa o modelo baseado em 70% do conjunto de dados de treinamento. Agora, faça validação cruzada utilizando 30% do conjunto de dados para validar e avaliar o desempenho usando métricas de avaliação. Isto finalmente leva 1-2 minutos para executar e documentar.
A intenção deste artigo não é ganhar a competição, mas estabelecer um ponto de referência para nós mesmos. Vamos olhar para os códigos python para executar os passos acima e construir o seu primeiro modelo.
Vamos começar a por em prática
Eu assumi que você fez toda a geração de hipóteses primeiro e que você proficiência com Data Science básico usando python. Estou ilustrando isto com um exemplo de desafio de Data Science. Vamos ver para a estrutura:
Passo 1: importe as bibliotecas necessárias e leia o conjunto de dados de treinamento. Acrescente 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/Analytics Vidhya/Desktop/challenge/Train.csv')
test=pd.read_csv('C:/Users/Analytics Vidhya/Desktop/challenge/Test.csv')
train['Type']='Train' #Cria uma bandeira para o conjunto de dados de treino e de teste
test['Type']='Test'
fullData = pd.concat([train,test],axis=0) #Combina ambos conjuntos de dados de treino e de teste
Passo 2: Passo 2 do framework não é necessário no Python. Para o próximo passo.
Passo 3: Veja os nomes das colunas e o resumo do conjunto de dados.
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
Passo 4: Identifique as (a) variáveis de ID, as (b) variáveis-alvo, as (c) as variáveis categóricas, as (d) as variáveis numéricas e (e) outras variáveis.
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'] #Identificador do conjunto de dados de treino e de teste
Passo 5: Identifique as variáveis com valores faltantes e crie uma bandeira (flag) para eles
fullData.isnull().any() #Vai retornar Falso ou Verdadeiro, Verdadeiro significa que há valor faltante senão Falso
num_cat_cols = num_cols+cat_cols # Combina variáveis numéricas e categóricas
#Cria uma uma variável para cada variável que tenha valores faltantes com VariableName_NA
# e marca o valor faltante com 1 e os outros com 0
for var in num_cat_cols:
if fullData[var].isnull().any()== True:
fullData[var+'_NA']=fullData[var].isnull()*1
Passo 6: impute os valores faltantes
#Preenche valores faltantes com a média fullData[num_cols] = fullData[num_cols].fillna(fullData[num_cols].mean(),inplace=True)
#Preenche valores categóricos faltantes com -9999 fullData[cat_cols] = fullData[cat_cols].fillna(value = -9999)
Passo 7: Crie codificadores de etiqueta para as variáveis categóricas e dividaa o conjunto de dados em treino e teste, divida ainda mais o conjunto de treino em treinamento e validação.
#creia rótulos codificadores para itens categóricos for var in cat_cols: number = LabelEncoder() fullData[var] = number.fit_transform(fullData[var].astype('str')) #Variável alvo também é categórica então é convertida 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]
Passo 8: Passe para o processo de modelagem as variáveis imputadas e as dummies (valores faltantes marcados com bandeiras). Estou usando Random Forest para prever a classe.
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)
Passo 9: Verifique o desempenho e faça previsões
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/Analytics Vidhya/Desktop/model_output.csv',columns=['REF_NO','Account.Status'])
E finalmente pronto, envie o modelo!
Notas finais
Esperamos que este artigo lhe tenha dado um começo sobre como fazer o seu próprio código de pontuação em 10 min. A maioria dos mestres sobre Kaggle e os melhores cientistas nos nossos hackathons têm esses códigos prontos e já disparam sua primeira apresentação antes de fazer uma análise detalhada. Uma vez que eles têm alguma estimativa do índice de referência, eles começam a improvisar mais. Compartilhe os seus códigos completos na caixa de comentários abaixo.
Você achou este artigo útil? Por favor, compartilhe suas opiniões e ideias na seção de comentários abaixo.
Veja também: