<jupyter_start><jupyter_text>Versões dos pacotes utilizados! Isto é relevante com respeito às questões 3 e 4, em que é pedido para especificar as versões das bibliotecas de Python para que os resultados possam ser reproduzidos.<jupyter_code>print('A versão do numpy é {}'.format(np.__version__))
print('A versão do pandas é {}'.format(pd.__version__))
print('A versão do seaborn é {}'.format(sns.__version__))
print('A versão do sklearn é {}'.format(sklearn.__version__))
print('A versão do h2o é {}'.format(h2o.__version__))<jupyter_output>A versão do numpy é 1.16.2
A versão do pandas é 0.23.4
A versão do seaborn é 0.9.0
A versão do sklearn é 0.20.3
A versão do h2o é 3.18.0.2<jupyter_text>vamos ler o dataset utilizando o pandas!<jupyter_code>data_json='./dataset.json'

df=pd.read_json(data_json)
df
# verificando o tipo das variaveis
df.dtypes<jupyter_output><empty_output><jupyter_text>Os tipos das variaveis parecem bem razoaveis A coluna 'register_date' que é do tipo objeto, ela representa datas  Vamos ver as dimensões desse DataFrame! Podemos acessar isso através do atributo .shape<jupyter_code>df.shape
print('Temos {0} linhas.'.format(df.shape[0]))
print('Temos {0} colunas.'.format(df.shape[1]))<jupyter_output>Temos 204428 linhas.
Temos 14 colunas.<jupyter_text>Verificando se há duplicatas!<jupyter_code>print(df.duplicated().any())
print(df.duplicated().sum())<jupyter_output>True
53<jupyter_text>Há 53 duplicatas! Vamos retirá-las.<jupyter_code>df.drop_duplicates(inplace=True)
# verificando, novamente, se há duplicatas

print(df.duplicated().any())
print(df.duplicated().sum())<jupyter_output>False
0<jupyter_text>Não há mais valores duplicados!  Vamos ver valores faltantes nesse DataFrame<jupyter_code>df.isnull().any()
df.isnull().sum()<jupyter_output><empty_output><jupyter_text>só há valores faltantes na coluna 'is_churn'  Há 1909 valores faltantes na coluna 'is_churn', o que pode parecer bastante, mas o correto é ver como esse número se compara com o total de linhas<jupyter_code>print('Porcentagem de valores faltantes {0}%'.format(100*1909/df.shape[0]))<jupyter_output>Porcentagem de valores faltantes 0.9340672782874617%<jupyter_text>Logo, temos menos de 1% de valores faltantes!  Vamos proceder removendo esses valores, que são relativamente poucos, que estão faltando na coluna 'is_churn'<jupyter_code>df.dropna(inplace=True)<jupyter_output><empty_output><jupyter_text>Vamos verificar se ainda há valores faltantes<jupyter_code>df.isnull().any()<jupyter_output><empty_output><jupyter_text>Não há mais valores faltantes!  Lidando com a coluna que é do tipo objeto, que representa data!<jupyter_code>df['register_date']
# vamos lidar com essa coluna!<jupyter_output><empty_output><jupyter_text>redefinindo os índices<jupyter_code>df=df.reset_index(drop=True)
# Usando série temporal!
df3=df.copy()
df3['Date']=pd.to_datetime(df3.register_date)
df3.sort_values(by='Date',inplace=True)
df3.drop('register_date',axis=1,inplace=True)
df3
#df3=df3.reset_index(drop=True,inplace=True)
df3=df3.reset_index(drop=True)
df3
# Extracting date features
#df3['Date'].dt.weekofyear

df3['dayofmonth'] = df3['Date'].dt.day
df3['dayofyear'] = df3['Date'].dt.dayofyear
df3['dayofweek'] = df3['Date'].dt.dayofweek
df3['month'] = df3['Date'].dt.month
df3['year'] = df3['Date'].dt.year
df3['weekofyear'] = df3['Date'].dt.weekofyear
df3['is_month_start'] = (df3['Date'].dt.is_month_start).astype(int)
df3['is_month_end'] = (df3['Date'].dt.is_month_end).astype(int)
df3.drop('Date',axis=1,inplace=True)
df3<jupyter_output><empty_output><jupyter_text>Agora vamos às questões!  Question 1 (10 Points)List as many use cases for the dataset as possible. Re: Os casos de uso de uso para o conjunto de dados são:1. saber em função do preço total 'total price' quantos clientes estão comprando certo item, criando intervalos para o preço total onde há maior lucro; 2. saber qual canal de venda gera maior lucro 'sales_channel', determinando uma preferência e onde investir;3. determinar a partir de 'register_date' (data de pedido) qual ano período gerou maior lucro;4. determinar a partir de 'total_price' (preço total) qual faixa gera mais lucro, buscando assim maximizar o lucro e otimizar o tipo de cliente;5. a partir de 'segment_code' (código de segmento que o cliente pertence) otimizar ...6. a partir de 'group_code' (código de grupo) otimizar o lucro da empresa e encontrar qual é o grupo ótimo de consumidor em que se deve ser investido mais esforços;7. criar um modelo preditivo a partir de 'is_churn' para obter informações sobre qual grupo, segmento, canal de venda, vendedor, tem maior chance de que esse cliente retorne;8. estudar qual 'seller_code' (código de vendedor) tem mais sucesso com os clientes.  Question 2 (10 Points)Pick one of the use cases you listed in question 1 and describe how building a statistical model based on the dataset could best be used to improve the business this data comes from. Re: Escolhendo o caso de uso $7$ da questão $1$ podemos criar um modelo estatístico, de machine learning, para prever se um dado cliente voltará, estudando então a influência dos features na predição dos dados.  Question 3 (20 Points)Implement the model you described in question 2, preferably in Python. The code has to retrieve the data, train and test a statistical model, and report relevant performance criteria. Ideally, we should be able to replicate your analysis from your submitted source-code, so please explicit the versions of the tools and packages you are using.  A versão dos pacotes!<jupyter_code>print('A versão do numpy é {}'.format(np.__version__))
print('A versão do pandas é {}'.format(pd.__version__))
print('A versão do seaborn é {}'.format(sns.__version__))
print('A versão do sklearn é {}'.format(sklearn.__version__))
print('A versão do h2o é {}'.format(h2o.__version__))<jupyter_output>A versão do numpy é 1.16.2
A versão do pandas é 0.23.4
A versão do seaborn é 0.9.0
A versão do sklearn é 0.20.3
A versão do h2o é 3.18.0.2<jupyter_text>separando em dados de treino e teste<jupyter_code>#df_ml=df2.copy()
df_ml=df3.copy()
#msk = np.random.random(len(df_ml)) < 0.8
# criando a mascara
percent=0.66

msk=[]
for i in range(len(df_ml)):
    msk.append(i<=percent*len(df_ml))
msk=np.array(msk)
train = df_ml[msk]
test=df_ml[~msk]<jupyter_output><empty_output><jupyter_text>Vamos utilizar h2o para automatizar os cálculos estatísticos de machine learning. Vamos initializar h2o!<jupyter_code>h2o.init()

train.iloc[-1]
test.iloc[1]
train=h2o.H2OFrame(train)

test=h2o.H2OFrame(test)

# Identify predictors and response
x = train.columns
y = "is_churn"
x.remove(y)

x<jupyter_output><empty_output><jupyter_text>Let us visualize train<jupyter_code>train<jupyter_output><empty_output><jupyter_text>Let us visualize the test<jupyter_code>test
# For binary classification, response should be a factor
train[y] = train[y].asfactor()

test[y] = test[y].asfactor()

# Vamos limitar o número máximo de modelos
# Vamos tirar cross-validation, colocando nfols=0
# vamos limitar o tempo maximo de calculo
# Run AutoML for 20 base models (limited to 1 hour max runtime by default)
aml = H2OAutoML(max_models=5,nfolds=0,max_runtime_secs=1200, seed=1)
aml.train(x=x, y=y, training_frame=train)

#salvando o modelo
#model_path = h2o.save_model(model=aml, path="./mymodel", force=True)
#h2o.save_model(aml.leader, path = "./mymodel")

aml.leader
aml.leaderboard
# If you need to generate predictions on a test set, you can make
# predictions directly on the `"H2OAutoML"` object, or on the leader
# model object directly

preds = aml.predict(test)

(train.as_data_frame)
lb=aml.leaderboard
lb.head(rows=lb.nrows)
print('Generate Predictions!')

testy=aml.leader.predict(test)
#testy=testy.as_data_frame()
# very nice
testy

#(test['is_churn']==testy['predict']).sum()/testy.shape[0]
test['is_churn']
testy['predict']<jupyter_output><empty_output><jupyter_text>Calculation of some metrics of the predicted model!  The f1_score<jupyter_code>f1_score(testy['predict'].as_data_frame(),test['is_churn'].as_data_frame())<jupyter_output><empty_output><jupyter_text>The Recall<jupyter_code>recall_score(testy['predict'].as_data_frame(),test['is_churn'].as_data_frame())<jupyter_output><empty_output><jupyter_text>The Precision<jupyter_code>precision_score(testy['predict'].as_data_frame(),test['is_churn'].as_data_frame())<jupyter_output><empty_output><jupyter_text>The ROC AUC score<jupyter_code>roc_auc_score(testy['predict'].as_data_frame(),test['is_churn'].as_data_frame())<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.11246485473289597, 'fraction_numerical': 0.021438612933458293, 'mean_word_length': 6.789233576642336, 'pattern_counts': {'":': 0, '<': 77, '<?xml version=': 0, '>': 75, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 2, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '20', 'dir': 'jupyter-structured-clean-dedup', 'id': '330108', 'license': 'Unlicense', 'n_tokens_mistral': 3237, 'n_tokens_neox': 3134, 'n_words': 854, 'path': 'project_ambev2019_v1.ipynb', 'repo_name': 'vzeizer/Ambev-DataScienceChallenge', 'size': '8536'}