<jupyter_start><jupyter_text>Awari - Data Science Projeto - Classificação 1. Considerações iniciaisNeste notebook vamos praticar a construção de um modelo de Machine Learning. Mais especificamente, iremos utilizar um algoritmo para realizar um processo de classificação. Propositalmente, evitaremos adentrar em algoritmos e explicações mais complexas, pois o foco é percorrer o fluxo do Aprendizado de Máquina por inteiro, ou o máximo dele. 1.1. O Problema de NegócioA _churn rate_ (taxa de rotatividade ou cancelamento) é a porcentagem de assinantes de um serviço que interrompe suas assinaturas dentro de um determinado período de tempo. Para uma empresa expandir sua clientela, sua taxa de crescimento, medida pelo número de novos clientes, deve exceder sua taxa de cancelamento (_churn rate_).Portanto, neste projeto, um banco deseja que você construa um modelo de Machine Learning que possa prever a probabilidade de seus clientes atuais fecharem suas contas em um futuro próximo e, portanto, calcular sua _churn rate_.Esse é um problema de classificação no qual você classifica se um cliente irá sair (y=1) ou permanecer (y=0) com base diversos atributos. 1.2. Descrição do dadosNo arquivo *Churn_Modelling.csv* você encontrará:- **RowNumber**: id do registro/linha.- **CustomerId**: identificador único do cliente.- **Surname**: sobrenome do cliente.- **CreditScore**: pontuação de crédito do cliente.- **Geography**: país de origem do cliente.- **Gender**: sexo do cliente.- **Age**: idade do cliente.- **Tenure**: número de anos em que o cliente está com o banco.- **Balance**: saldo bancário.- **NumOfProducts**: número de produtos que o cliente utiliza.- **HasCrCard**: indica se o cliente tem (1) ou não tem (0) cartão de crédito.- **IsActiveMember**: indica se o cliente é (1) ou não é (0) ativo no banco.- **EstimatedSalary**: salário estimado em dólares.- **Exited**: indica se o cliente encerrou (1) a conta no banco ou se o cliente foi retido (0). 1.3 Métricas de AvaliaçãoAvalie seu modelo utilizando as métricas Acurácia e AUC (area under the ROC) estudadas nos módulos anteriores.Trabalhe até conseguir uma acurácia acima e 85%. 2. Etapas do ProjetoNeste projeto você poderá seguir o fluxo que preferir, mas como sugestão pode seguir as seguintes etapas:1. Análise exploratória 2. Preparação e limpeza dos dados3. Seleção de atributos4. Construção do modelo5. Avaliação do modelo6. Otimização do modeloLembrando que esses passos, provavelmente, serão executados várias vezes até se obter um resultado satisfatório.Sugestões de modelos:* Logistic Regression Classification* K-Nearest Neighbour (KNN) Classification* Support Vector Machine (SVM) Classification* Naive Bayes Classification* Decision Tree Classification* Random Forest ClassificationEm caso de dúvidas, não esqueça de conversar com seu mentor.  3. Desenvolvimento do Projeto<jupyter_code># seu código
import pandas as pd 
import numpy as np
import seaborn as sns
clients = pd.read_csv('Churn_Modelling.csv', index_col='RowNumber')
# seu código
var_explicativas = ['CreditScore', 'Age', 'Tenure', 'Balance', 'NumOfProducts', 'HasCrCard', 'IsActiveMember', 'EstimatedSalary' ]
var_naoexplicativas = ['CustomerId', 'Surname']
clients.drop(var_naoexplicativas, axis=1, inplace=True)
clients.head()<jupyter_output><empty_output><jupyter_text>Inicialmente escolhi 8 variaveis quantitativas que acredito podem especificar os clientes que mais se adequam ao perfil do banco. As variaveis Geography e Gender serão adicionadas caso o score do modelo não esteja satisfatório.<jupyter_code>clients.shape
clients.info()<jupyter_output><class 'pandas.core.frame.DataFrame'>
Int64Index: 10000 entries, 1 to 10000
Data columns (total 11 columns):
CreditScore        10000 non-null int64
Geography          10000 non-null object
Gender             10000 non-null object
Age                10000 non-null int64
Tenure             10000 non-null int64
Balance            10000 non-null float64
NumOfProducts      10000 non-null int64
HasCrCard          10000 non-null int64
IsActiveMember     10000 non-null int64
EstimatedSalary    10000 non-null float64
Exited             10000 non-null int64
dtypes: float64(2), int64(7), object(2)
memory usage: 937.5+ KB<jupyter_text>O número de 10000 observações e nenhuma coluna com missings, me dá a possibilidade de utilizar diversos modelos de classificação. Além disso, pude observar que os dados são numéricos, tal qual pedem os modelos de Machine Learning.<jupyter_code>clients['Exited'].value_counts()<jupyter_output><empty_output><jupyter_text><jupyter_code>from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report, roc_auc_score, roc_curve
from sklearn.model_selection import train_test_split, cross_validate

X = clients[var_explicativas]
y= clients['Exited']
##sns.pairplot()
clients.corr()<jupyter_output><empty_output><jupyter_text>nenhuma variavel parece explicar muitíssimo bem a nossa variável alvo, vejamos como elas se saem no modelo.<jupyter_code>X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
clf_lr = LogisticRegression()
clf_lr.fit(X_train, y_train)
avaliacaorl = cross_validate(clf_lr, X, y, cv=5, scoring='accuracy')
avaliacaorl['test_score'].mean()
predit_test = clf_lr.predict(X_test)
print(accuracy_score(y_test,predit_test))
print(classification_report(y_test, predit_test))<jupyter_output>0.8006666666666666
              precision    recall  f1-score   support

           0       0.81      0.97      0.89      2416
           1       0.44      0.08      0.14       584

    accuracy                           0.80      3000
   macro avg       0.63      0.53      0.51      3000
weighted avg       0.74      0.80      0.74      3000<jupyter_text>Testaremos agora outros modelos para ver se algum deles se sai melhor e bate nosso baseline.<jupyter_code>from sklearn.tree import DecisionTreeClassifier
modelo_arvore = DecisionTreeClassifier()
modelo_arvore.fit(X_train, y_train)
avaliacaodt = cross_validate(modelo_arvore, X, y, cv=5, scoring='accuracy')
print(avaliacaodt['test_score'].mean())
pred_arvore = modelo_arvore.predict(X_test)
print(accuracy_score(y_test,pred_arvore))
print(classification_report(y_test2, pred_arvore))
from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier(n_neighbors=2)
knn.fit(X_train, y_train)
avaliacaoknn = cross_validate(knn, X, y, cv=5, scoring='accuracy')
print(avaliacaoknn['test_score'].mean())
pred_knn = knn.predict(X_test)
print(accuracy_score(y_test,pred_knn))
print(classification_report(y_test, pred_knn))<jupyter_output>0.7724
0.781
              precision    recall  f1-score   support

           0       0.81      0.96      0.88      2416
           1       0.23      0.05      0.09       584

    accuracy                           0.78      3000
   macro avg       0.52      0.51      0.48      3000
weighted avg       0.70      0.78      0.72      3000<jupyter_text>Apesar de todos terem se saído bem, nenhum deles bateu o baseline. Passaremos agora a utilizar as variáveis qualitativas para verificar se eles se adaptam melhor com essas informações e batem o nosso baseline.<jupyter_code>from sklearn.dummy import DummyClassifier
clients_new = clients
clients_new = pd.get_dummies(clients_new)
var_explicativas2 = ['CreditScore', 'Age', 'Tenure', 'Balance', 'NumOfProducts', 'HasCrCard',
       'IsActiveMember', 'EstimatedSalary',
       'Geography_France', 'Geography_Germany', 'Geography_Spain',
       'Gender_Female', 'Gender_Male']
X2 = clients_new[var_explicativas2]
y2 = clients_new ['Exited']
X_train2, X_test2, y_train2, y_test2 = train_test_split(X2, y2, test_size=0.3, random_state=42)
clf_lr = LogisticRegression()
clf_lr.fit(X_train2, y_train2)
avaliacaorl2 = cross_validate(clf_lr, X2, y2, cv=5, scoring='accuracy')
print(avaliacaorl2['test_score'].mean())
predit_test2 = clf_lr.predict(X_test2)
print(accuracy_score(y_test2,predit_test2))
print(classification_report(y_test2, predit_test2))
modelo_arvore.fit(X_train2, y_train2)
pred_arvore2 = modelo_arvore.predict(X_test2)
avaliacaodt2 = cross_validate(modelo_arvore, X, y, cv=5, scoring='accuracy')
print(avaliacaodt2['test_score'].mean())
print(accuracy_score(y_test2,pred_arvore2))
print(classification_report(y_test2, pred_arvore2))
knn = KNeighborsClassifier(n_neighbors=2)
knn.fit(X_train2, y_train2)
avaliacaoknn2 = cross_validate(knn, X, y, cv=5, scoring='accuracy')
print(avaliacaoknn2['test_score'].mean())
pred_knn2 = knn.predict(X_test2)
print(accuracy_score(y_test2,pred_knn2))
print(classification_report(y_test2, pred_knn2))<jupyter_output>0.7724
0.781
              precision    recall  f1-score   support

           0       0.81      0.96      0.88      2416
           1       0.23      0.05      0.09       584

    accuracy                           0.78      3000
   macro avg       0.52      0.51      0.48      3000
weighted avg       0.70      0.78      0.72      3000<jupyter_text>Observamos que a inclusão de novas variáveis não afetou em nada a nossa Regressão Logística, ou o Knn. Mas que o modelo de Árvore teve um alto ganho de performance, batendo o baseline. Nesse caso, seguiremos com ele utilizando uma camada decisora sobre árvores aleatórias.<jupyter_code>from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(random_state=42)
rf.fit(X_train2, y_train2)
avaliacaorf = cross_validate(rf, X2, y2, cv=5, scoring='accuracy')
print(avaliacaorf['test_score'].mean())
pred_arvore3 = rf.predict(X_test2)
print(accuracy_score(y_test2,pred_arvore3))
print(classification_report(y_test2, pred_arvore3))
print(roc_auc_score(y_test2, pred_arvore3))<jupyter_output>0.8629
0.867
              precision    recall  f1-score   support

           0       0.88      0.96      0.92      2416
           1       0.76      0.47      0.58       584

    accuracy                           0.87      3000
   macro avg       0.82      0.72      0.75      3000
weighted avg       0.86      0.87      0.85      3000

0.7155209561825274<jupyter_text>4. ConclusãoO fluxo de trabalho de Aprendizado de Máquina não termina após avaliação de performance do modelo escolhido. Na verdade, esta seria somente a primeira iteração de um processo que pode ter dezenas de tentativas.Encorajamos você a repetir novamente o processo descrito neste notebook. Contudo, explorando novas possibilidades para verificar a melhora/piora da performance do seu modelo. Você pode remover variáveis/atributos menos importantes, normalizar variáveis importantes, escolher outros algoritmos de aprendizagem supervisionada, etc. O Aprendizado de Máquina é uma área interessante justamente por causa disto. Você testa, você erra, você recomeça.  Awari -   awari.com.br<jupyter_code><jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.07845855281397283, 'fraction_numerical': 0.04722299232972923, 'mean_word_length': 4.133776091081594, 'pattern_counts': {'":': 0, '<': 33, '<?xml version=': 0, '>': 33, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 1, 'word_list_counts': {'cursed_substrings.json': 16, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '9', 'dir': 'jupyter-structured-clean-dedup', 'id': '266826', 'license': 'MIT', 'n_tokens_mistral': 4007, 'n_tokens_neox': 3701, 'n_words': 1076, 'path': 'Projeto_Classificacao.ipynb', 'repo_name': 'felipemoreia/Data-Science-com-Python---Awari', 'size': '10821'}