import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline

df = pd.read_csv('./data/train.csv')
df

df.set_index('ID', inplace=True)
df

df.describe()

# Verificando quantos valores únicos há em cada coluna do dataset
n_unicos = pd.DataFrame(columns=['N_unicos'])
for col in df.columns:
    n_unicos.loc[col] = len(df[col].unique())

# Extraindo o número de valores únicos existente em cada variável do dataset.
n_unicos

agrup = n_unicos.reset_index()
agrup.groupby('N_unicos', as_index=True).count().head(20)

# Variáveis que não apresentam variação:
n_unicos[n_unicos['N_unicos']==1]

excluir = n_unicos[n_unicos['N_unicos']==1].index
excluir

df[excluir]

# Excluindo do dataset as variáveis que não apresentam variação
df.drop(excluir, axis=1, inplace=True)
df

# Verificando e excluindo possíveis valores missing do dataframe
df.dropna(inplace=True)
df

df.groupby('TARGET', as_index=True).count()

#%pip install imbalanced-learn

#import imblearn
#print(imblearn.__version__)

from imblearn.over_sampling import SMOTE

oversampling = SMOTE()

df.drop('TARGET', axis=1)

X, y = oversampling.fit_resample(df.drop('TARGET', axis=1), df['TARGET'])

# summarize the new class distribution
from collections import Counter
counter = Counter(y)
print(counter)

#y = pd.DataFrame(y)
df_balanceado = pd.concat([X, y], axis=1)
df_balanceado

df_balanceado.groupby('TARGET', as_index=True).count()

df_balanceado.describe()

corr = df_balanceado.corr()

corr

corr['TARGET']

faixa_corr = corr['TARGET'].sort_values()
faixa_corr

faixa_corr.plot(figsize=(19, 15), grid=True)

faixa_corr[abs(faixa_corr.values) > 0.05]

filtro1 = faixa_corr[abs(faixa_corr.values) > 0.05].index
filtro1

df_filt1 = df_balanceado[filtro1]
df_filt1

from sklearn.model_selection import train_test_split

X = df_filt1.iloc[:,:-1]
Y = df_filt1.iloc[:, -1]

X_treino, X_teste, Y_treino, Y_teste = train_test_split(X, Y, test_size=0.3)
print(f'Dimensão de X_treino: {X_treino.shape}')
print(f'Dimensão de Y_treino: {Y_treino.shape}')
print(f'Dimensão de X_teste: {X_teste.shape}')
print(f'Dimensão de Y_teste: {Y_teste.shape}')

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix, classification_report

%%time

# Criação do modelo
mod1_LogReg = LogisticRegression()

# Treinamento do modelo
mod1_LogReg.fit(X_treino, Y_treino)

# Score do modelo nos dados de teste
mod1_result = mod1_LogReg.score(X_teste, Y_teste)
print("Acurácia nos Dados de Teste: %.3f%%" % (mod1_result * 100.0))

# Matriz de confusão
Y_pred = mod1_LogReg.predict(X_teste)
matrix = confusion_matrix(Y_teste, Y_pred)
print("\nMatriz de confusão:")
print(matrix)
print("\n")

# Relatório de Classificação
report = classification_report(Y_teste, Y_pred)
print(report)

from sklearn.neighbors import KNeighborsClassifier

%%time

# Criação do modelo
mod2_knn = KNeighborsClassifier()

# Treinamento do modelo
mod2_knn.fit(X_treino, Y_treino)

# Score do modelo nos dados de teste
mod2_result = mod2_knn.score(X_teste, Y_teste)
print("Acurácia nos Dados de Teste: %.3f%%" % (mod2_result * 100.0))

# Matriz de confusão
Y_pred = mod2_knn.predict(X_teste)
matrix = confusion_matrix(Y_teste, Y_pred)
print("\nMatriz de confusão:")
print(matrix)
print("\n")

# Relatório de Classificação
report = classification_report(Y_teste, Y_pred)
print(report)

from sklearn.naive_bayes import GaussianNB

%%time

# Criação do modelo
mod3_naiveBayes = GaussianNB()

# Treinamento do modelo
mod3_naiveBayes.fit(X_treino, Y_treino)

# Score do modelo nos dados de teste
mod3_result = mod3_naiveBayes.score(X_teste, Y_teste)
print("Acurácia nos Dados de Teste: %.3f%%" % (mod3_result * 100.0))

# Matriz de confusão
Y_pred = mod3_naiveBayes.predict(X_teste)
matrix = confusion_matrix(Y_teste, Y_pred)
print("\nMatriz de confusão:")
print(matrix)
print("\n")

# Relatório de Classificação
report = classification_report(Y_teste, Y_pred)
print(report)

from sklearn.tree import DecisionTreeClassifier

%%time

# Criação do modelo
mod4_DecisionTree = DecisionTreeClassifier()

# Treinamento do modelo
mod4_DecisionTree.fit(X_treino, Y_treino)

# Score do modelo nos dados de teste
mod4_result = mod4_DecisionTree.score(X_teste, Y_teste)
print("Acurácia nos Dados de Teste: %.3f%%" % (mod4_result * 100.0))

# Matriz de confusão
Y_pred = mod4_DecisionTree.predict(X_teste)
matrix = confusion_matrix(Y_teste, Y_pred)
print("\nMatriz de confusão:")
print(matrix)
print("\n")

# Relatório de Classificação
report = classification_report(Y_teste, Y_pred)
print(report)

from sklearn.svm import SVC

%%time

# Criação do modelo
mod5_svm = SVC()

# Treinamento do modelo
mod5_svm.fit(X_treino, Y_treino)

# Score do modelo nos dados de teste
mod5_result = mod5_svm.score(X_teste, Y_teste)
print("Acurácia nos Dados de Teste: %.3f%%" % (mod5_result * 100.0))

# Matriz de confusão
Y_pred = mod5_svm.predict(X_teste)
matrix = confusion_matrix(Y_teste, Y_pred)
print("\nMatriz de confusão:")
print(matrix)
print("\n")

# Relatório de Classificação
report = classification_report(Y_teste, Y_pred)
print(report)

from sklearn.model_selection import KFold, cross_validate, cross_val_predict
from sklearn.metrics import plot_roc_curve

# Definindo os valores para os folds
num_folds = 10

# Separando os dados em folds
kfold = KFold(num_folds, shuffle=True)

resultado = cross_validate(mod4_DecisionTree, X, Y, cv=kfold, scoring=['accuracy', 'precision', 'recall', 'f1', 'roc_auc'])

resultado

# Função para plotagem das áreas abaixo da curva para diferentes folds.
def plot_ROC(modelo, X, y, folds):
    from sklearn.metrics import auc
    from sklearn.metrics import plot_roc_curve
    from sklearn.model_selection import StratifiedKFold

    # #############################################################################
    # Classification and ROC analysis

    # Run classifier with cross-validation and plot ROC curves
    cv = StratifiedKFold(n_splits=folds)
    classifier = modelo

    tprs = []
    aucs = []
    mean_fpr = np.linspace(0, 1, 100)

    fig, ax = plt.subplots(figsize=(20, 10), dpi=300)
    for i, (train, test) in enumerate(cv.split(X, y)):
        classifier.fit(X.iloc[train], y.iloc[train])
        viz = plot_roc_curve(classifier, X.iloc[test], y.iloc[test],
                             name='ROC fold {}'.format(i),
                             alpha=0.3, lw=1, ax=ax)
        interp_tpr = np.interp(mean_fpr, viz.fpr, viz.tpr)
        interp_tpr[0] = 0.0
        tprs.append(interp_tpr)
        aucs.append(viz.roc_auc)

    ax.plot([0, 1], [0, 1], linestyle='--', lw=2, color='r',
            label='Chance', alpha=.8)

    mean_tpr = np.mean(tprs, axis=0)
    mean_tpr[-1] = 1.0
    mean_auc = auc(mean_fpr, mean_tpr)
    std_auc = np.std(aucs)
    ax.plot(mean_fpr, mean_tpr, color='b',
            label=r'Mean ROC (AUC = %0.2f $\pm$ %0.2f)' % (mean_auc, std_auc),
            lw=2, alpha=.8)

    std_tpr = np.std(tprs, axis=0)
    tprs_upper = np.minimum(mean_tpr + std_tpr, 1)
    tprs_lower = np.maximum(mean_tpr - std_tpr, 0)
    ax.fill_between(mean_fpr, tprs_lower, tprs_upper, color='grey', alpha=.2,
                    label=r'$\pm$ 1 std. dev.')

    ax.set(xlim=[-0.05, 1.05], ylim=[-0.05, 1.05],
           title="Receiver operating characteristic example")
    ax.legend(loc="lower right")
    plt.show()

plot_ROC(mod4_DecisionTree, X, Y, 10)

X_teste_kaggle = pd.read_csv('./data/test.csv')
X_teste_kaggle

# Aplicando as mesmas operações que foram aplicadas ao dataset de treinamento
X_teste_kaggle.set_index('ID', inplace=True)
X_teste_kaggle = X_teste_kaggle[filtro1[:-1]]
X_teste_kaggle

Y_pred_kaggle = mod4_DecisionTree.predict(X_teste_kaggle)

X_teste_kaggle.reset_index(inplace=True)
Y_pred_kaggle = pd.Series(Y_pred_kaggle, name='TARGET')
#pd.concat([X_teste_kaggle, Y_pred_kaggle], axis=1)

submissao = pd.concat([X_teste_kaggle, Y_pred_kaggle], axis=1)[['ID', 'TARGET']]
submissao

# Verificando se o arquivo de submissão apresenta exatamente os mesmos IDs
arq_subm = pd.read_csv('./data/sample_submission.csv')
arq_subm

# Mesma quantidade de linhas e colunas. Verificando se a coluna ID é idêntica
comparativo = submissao.ID != arq_subm.ID

comparativo.any()

# Verificado que a coluna ID é exatamente igual ao arquivo fornecido, pode-se gravar para submissão.
submissao.to_csv('./data/sample_submission.csv', index=False)