Introdução

Ideia Geral

Utilizando os dados de câncer da FOSP, somente do tipo colorretal, serão utilizados quatro modelos de machine learning diferentes, com o intuito de testar diferentes tipos de algoritmo na classificação de sobrevida por um ano.

O label é 0 se o paciente não sobreviveu após um ano do diagnóstico e 1 se sobreviveu.

Modelos de ML

Foram escolhidos os modelos Naive Bayes, que utiliza o Teorema de Bayes para realizar as previsões, Random Forest, XGBoost e LightGBM, que utilizam os conceitos de árvores de decisão, além de bagging e boosting. Além disso, será testado um modelo de votação com os melhores classificadores obtidos, visando obter um algoritmo ainda mais acertivo.

Validação dos modelos

Para validar os modelos treinados foi utilizada primeiramente a matriz de confusão, sendo possível avaliar os acertos em ambas as classes. Para entender de houve overfitting nos modelos, foi utilizada a curva ROC para os conjuntos de treino e teste, comparando a métrica AUC entre ambos os conjuntos.

Por fim, os modelos Random Forest, XGBoost e LightGBM oferecem a possibilidade de saber quais foram as features mais importantes, ou seja, que mais influenciam na previsão das classes. Assim, foram mostradas duas maneiras diferentes de analisar a importância das variáveis de entrada, uma usando a própria função dos modelos e outra usando a biblioteca SHAP, que mostra a influência das features em ambas as classes.

# Leitura dos dados
df = read_csv('/content/drive/MyDrive/Trabalho/Cancer/Datasets/colorretal_labels.csv')
df.head(3)

(31916, 37)

	ESCOLARI	IDADE	SEXO	IBGE	CATEATEND	DIAGPREV	EC	ECGRUP	TRATHOSP	NENHUM	...	IBGEATEN	ULTICONS	ULTIDIAG	ULTITRAT	obito_geral	obito_cancer	vivo_ano1	vivo_ano3	vivo_ano5	ESCOLARI_2
0	4	19	2	3538709	9	2	IV	IV	I	0	...	3538709	4985	4985	4951	0	0	1	1	1	4.0
1	9	19	1	3537107	2	2	IIIA	III	I	0	...	3509502	2680	2744	2674	1	1	1	1	1	4.0
2	4	19	1	3516200	9	2	IIB	II	F	0	...	3516200	4725	4734	4719	0	0	1	1	1	4.0

3 rows × 37 columns

# Valores faltantes
df.isna().sum().sort_values(ascending=False).head(6)

ESCOLARI     0
CONSDIAG     0
DIAGTRAT     0
ANODIAG      0
FAIXAETAR    0
DRS          0
dtype: int64

# Correlação com a saída
corr_matrix = df.corr()
abs(corr_matrix['vivo_ano1']).sort_values(ascending = False).head(20)

The default value of numeric_only in DataFrame.corr is deprecated. In a future version, it will default to False. Select only valid columns or specify the value of numeric_only to silence this warning.

vivo_ano1       1.000000
vivo_ano3       0.529451
ULTIDIAG        0.521620
ULTICONS        0.516761
ULTITRAT        0.513101
vivo_ano5       0.369942
obito_cancer    0.279604
obito_geral     0.261431
CIRURGIA        0.178875
RECNENHUM       0.164131
QUIMIO          0.150516
ANODIAG         0.106157
ULTINFO         0.103939
DIAGTRAT        0.088385
RADIO           0.085948
IDADE           0.084717
TRATCONS        0.063135
ESCOLARI_2      0.045089
HORMONIO        0.034786
DIAGPREV        0.032389
Name: vivo_ano1, dtype: float64

# Quantidade de pacientes em cada classe da saída
df.vivo_ano1.value_counts()

1    23200
0     8716
Name: vivo_ano1, dtype: int64

df[['obito_geral', 'ULTIDIAG', 'vivo_ano1', 'vivo_ano3', 'vivo_ano5']].sample(5)

	obito_geral	ULTIDIAG	vivo_ano1	vivo_ano3	vivo_ano5
19425	0	1554	1	1	0
23922	0	3676	1	1	1
4295	1	3	0	0	0
17873	0	6359	1	1	1
4395	1	14	0	0	0

DataFrame vivo_ano1

Antes de realizar o pré-processamento dos dados é necessário filtrar os dados, de modo a retirar pacientes que não foram acompanhados por pelo menos um ano e que a última informação consta como vivos.

# Dataset da sobrevida de um ano
df_ano1 = df[~((df.obito_geral == 0) & (df.vivo_ano1 == 0))].reset_index(drop=True)
df_ano1.shape

(29670, 37)

df_ano1.head(3)

	ESCOLARI	IDADE	SEXO	IBGE	CATEATEND	DIAGPREV	EC	ECGRUP	TRATHOSP	NENHUM	...	IBGEATEN	ULTICONS	ULTIDIAG	ULTITRAT	obito_geral	obito_cancer	vivo_ano1	vivo_ano3	vivo_ano5	ESCOLARI_2
0	4	19	2	3538709	9	2	IV	IV	I	0	...	3538709	4985	4985	4951	0	0	1	1	1	4.0
1	9	19	1	3537107	2	2	IIIA	III	I	0	...	3509502	2680	2744	2674	1	1	1	1	1	4.0
2	4	19	1	3516200	9	2	IIB	II	F	0	...	3516200	4725	4734	4719	0	0	1	1	1	4.0

3 rows × 37 columns

Análise - Sobrevida um ano

Pré-processamento

Como o dataset já foi limpo anteriormente, aqui na etapa de pré-processamento serão realizadas a divisão dos dados em treino e teste, a codificação das colunas textuais para colunas numéricas e a normalização dos dados. Com isso, temos os dados prontos para o treinamento dos modelos de machine learning e consequentemente sua validação.

Neste primeiro momento, serão definidas as colunas que não serão utilizadas como features, assim, foi escolhido manter a coluna IDADE, então a coluna FAIXAETAR será retirada. O mesmo ocorre com a coluna EC, retirando a coluna ECGRUP. Por fim, as outras colunas contidas na list_drop são possíveis saídas para os modelos, mas estamos interessados somente na sobrevida de um ano, por isso só ela será mantida como label e as outras serão retiradas.

list_drop = ['FAIXAETAR', 'ULTICONS', 'ULTIDIAG', 'ULTITRAT', 'obito_geral',
             'vivo_ano3', 'vivo_ano5', 'ULTINFO', 'obito_cancer', 'ECGRUP', 'ESCOLARI']

lb = 'vivo_ano1'

Uma função foi criada para realizar o pré-processamento inteiro, chamada preprocessing, internamente ela utiliza outras funções criadas que são: get_train_test (divide os dados em treino e teste), train_preprocessing (prepara os dados de treino) e test_preprocessing (prepara os dados de teste).

Mais detalhes em funções.

X_train, X_test, y_train, y_test, feat_cols, enc, norm = preprocessing(df_ano1, list_drop, lb,
                                                                       random_state=seed,
                                                                       balance_data=False,
                                                                       encoder_type='LabelEncoder',
                                                                       norm_name='StandardScaler',
                                                                       return_enc_norm=True)

X_train = (22252, 25), X_test = (7418, 25)
y_train = (22252,), y_test = (7418,)

y_train.value_counts(normalize=True)

1    0.781952
0    0.218048
Name: vivo_ano1, dtype: float64

y_test.value_counts(normalize=True)

1    0.781882
0    0.218118
Name: vivo_ano1, dtype: float64

Treinamento e validação dos modelos de machine learning

Depois das etapas de preparação, os dados estão prontos para serem utilizados nos modelos escolhidos.

Naive Bayes

# Criação e treinamento do modelo Naive Bayes
nb = GaussianNB()
nb.fit(X_train, y_train)

GaussianNB()

In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.

# Matriz de confusão
plot_confusion_matrix(nb, X_test, y_test)

              precision    recall  f1-score   support

           0      0.279     0.888     0.424      1618
           1      0.920     0.359     0.516      5800

    accuracy                          0.474      7418
   macro avg      0.599     0.623     0.470      7418
weighted avg      0.780     0.474     0.496      7418

Claramente percebe-se que o modelo previu boa parte dos dados como sendo da classe 0, portanto não teve um aprendizado satisfatório.

Na matriz de confusão, buscamos uma diagonal principal equilibrada e com a maior acertividade possível.

# Curva ROC
plot_roc_curve(nb, X_train, X_test, y_train, y_test)

Pelas curvas ROC, pode-se dizer que não há overfitting, mas o modelo é ruim para a previsão da classe 1, portanto qualquer análise além dessa não possui tanta relevância.

Random Forest

O modelo Random Forest é mais complexo em relação ao Naive Bayes, assim alguns hiperparâmetros serão definidos para obter um modelo base e depois será realizada a busca dos melhores parâmetros utilizando o Optuna.

Os parâmetros definidos para este primeiro modelo serão:

• random_state: para repetibilidade do treinamento do modelo. Será utilizado na busca pelos hiperparâmetros também, sempre como mesmo valor definido na variável seed.

• max_depth: será definido como 8, pois o padrão do modelo é não ter profundidade máxima para as árvores, o que dificulta e faz o treinamento ser muito longo, além da maior chance de overfitting.

• class_weight: usado para definir os pesos de cada classe no treinamento do modelo, muito útil quando temos classes desbalanceadas no conjunto de dados, como neste caso.

# Criação e treinamento do modelo Random Forest
rf = RandomForestClassifier(random_state=seed,
                            class_weight={0:3.75, 1:1},
                            max_depth=8,
                            criterion='entropy')

rf.fit(X_train, y_train)

RandomForestClassifier(class_weight={0: 3.75, 1: 1}, criterion='entropy',
                       max_depth=8, random_state=10)

In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.

# Matriz de confusão
plot_confusion_matrix(rf, X_test, y_test)

              precision    recall  f1-score   support

           0      0.481     0.768     0.592      1618
           1      0.922     0.769     0.839      5800

    accuracy                          0.769      7418
   macro avg      0.702     0.768     0.715      7418
weighted avg      0.826     0.769     0.785      7418

A matriz obtida para o modelo Random Forest apresentou diagonal equilibrada em ambas as classes, com 77% de acurácia.

# Pedaço de uma das árvores do modelo Random Forest
show_tree(rf, feat_cols, 2)

# Curva ROC
plot_roc_curve(rf, X_train, X_test, y_train, y_test)

Como a métrica AUC possui valores próximos para o conjunto de treino e de teste, 0,862 e 0,842 respectivamente, pode-se dizer que há apenas um pouco de overfitting, não sendo algo de grande preocupação.

# Importância das features
plot_feat_importances(rf, feat_cols)

As features mais importantes nesta visualização são EC, com uma grande vantagem, TRATHOSP, DIAGTRAT e RECNENHUM.

# Importância das features pelos valores SHAP
plot_shap_values(rf, X_train, feat_cols)

A coluna EC foi a mais importante aqui também, com isso, os valores mais altos desta variável, mostrados em rosa, influenciaram mais o modelo na previsão da classe 0 (não sobreviveu ao primeiro ano após o diagnóstico). Já os valores mais baixos desta coluna, em azul, tem mais peso para previsão ser da classe 1. Este comportamento faz sentido, pois quanto mais alto o estágio, maior é a extensão do câncer, assim menor a chance de sobrevivência.

O raciocínio para analisar as outras colunas é o mesmo utilizado para o estadiamento clínico.

Optuna

Para fazer a busca pelos melhores hiperparâmetros, será utilizado a biblioteca Optuna, definindo o intervalo para os parâmetros do modelo a serem buscados.

# Folds com a mesma proporção das classes
skf = StratifiedKFold(10, shuffle=True, random_state=seed)

# Função com o modelos e seus parâmetros, que terá sua métrica maximizada
def objective(trial):

    n_estimators = trial.suggest_int('n_estimators', 50, 250)
    max_depth = trial.suggest_int('max_depth', 3, 18)
    min_samples_split = trial.suggest_int('min_samples_split', 2, 10)
    min_samples_leaf = trial.suggest_int('min_samples_leaf', 1, 7)
    max_samples = trial.suggest_float('max_samples', 0.7, 1.0, step=0.1)
    optimizer = trial.suggest_categorical('criterion', ['gini', 'entropy'])

    cls = RandomForestClassifier(n_estimators=n_estimators,
                                 max_depth=max_depth,
                                 min_samples_split=min_samples_split,
                                 min_samples_leaf=min_samples_leaf,
                                 max_samples=max_samples,
                                 criterion=optimizer,
                                 random_state=seed)

    return cross_val_score(cls, X_train, y_train,
                           cv=skf, scoring='balanced_accuracy').mean()

# Criação do estudo e procura pelos hiperparâmetros
studyRF = optuna.create_study(direction='maximize', sampler=RandomSampler(seed))
studyRF.optimize(objective, n_trials=100)

# Melhor tentativa
studyRF.best_trial

FrozenTrial(number=62, state=TrialState.COMPLETE, values=[0.6665759868570232], datetime_start=datetime.datetime(2023, 4, 11, 22, 14, 45, 562373), datetime_complete=datetime.datetime(2023, 4, 11, 22, 15, 33, 873202), params={'n_estimators': 173, 'max_depth': 18, 'min_samples_split': 8, 'min_samples_leaf': 1, 'max_samples': 0.7999999999999999, 'criterion': 'gini'}, user_attrs={}, system_attrs={}, intermediate_values={}, distributions={'n_estimators': IntDistribution(high=250, log=False, low=50, step=1), 'max_depth': IntDistribution(high=18, log=False, low=3, step=1), 'min_samples_split': IntDistribution(high=10, log=False, low=2, step=1), 'min_samples_leaf': IntDistribution(high=7, log=False, low=1, step=1), 'max_samples': FloatDistribution(high=1.0, log=False, low=0.7, step=0.1), 'criterion': CategoricalDistribution(choices=('gini', 'entropy'))}, trial_id=62, value=None)

# Melhores parâmetros
studyRF.best_params

{'n_estimators': 173,
 'max_depth': 18,
 'min_samples_split': 8,
 'min_samples_leaf': 1,
 'max_samples': 0.7999999999999999,
 'criterion': 'gini'}

plot_optimization_history(studyRF).show()

# Modelo com os melhores parâmetros
params = studyRF.best_params
params['random_state'] = seed
params['class_weight'] = {0: 24.5, 1: 1}

rf_optuna = RandomForestClassifier()
rf_optuna.set_params(**params)

rf_optuna.fit(X_train, y_train)

RandomForestClassifier(class_weight={0: 24.5, 1: 1}, max_depth=18,
                       max_samples=0.7999999999999999, min_samples_split=8,
                       n_estimators=173, random_state=10)

In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.

# Matriz de confusão do modelo Random Forest otimizado
plot_confusion_matrix(rf_optuna, X_test, y_test)

              precision    recall  f1-score   support

           0      0.458     0.753     0.570      1618
           1      0.916     0.752     0.826      5800

    accuracy                          0.752      7418
   macro avg      0.687     0.752     0.698      7418
weighted avg      0.816     0.752     0.770      7418

Há uma queda de acurácia em relação ao primeiro modelo testado, de 77% para 75%. Os motivos podem ser variados, mas um deles talvez seja a escolha dos parâmetros e/ou overfitting, como mostrado na curva ROC a seguir.

# Curva ROC do modelo otimizado
plot_roc_curve(rf_optuna, X_train, X_test, y_train, y_test)

A curva ROC mostra que o modelo possui overfitting, pois para o conjunto de treino temos AUC = 0,954 e para o teste AUC = 0,829, essa diferença caracteriza o problema.

XGBoost

O modelo XGBoost também terá alguns hiperparâmetros definidos para obter um modelo base e depois será realizada a busca dos melhores parâmetros utilizando o Optuna.

Os parâmetros definidos para este primeiro modelo serão:

• random_state: para repetibilidade do treinamento do modelo. Será utilizado na busca pelos hiperparâmetros também, sempre como mesmo valor definido na variável seed.

• max_depth: será utilizado o padrão do modelo, valor 3.

• scale_pos_weight: usado para definir o peso da classe 1 no treinamento do modelo, pois temos classes desbalanceadas.

# Criação e treinamento do modelo XGBoost
xgb = XGBClassifier(max_depth=3,
                    scale_pos_weight=0.274,
                    random_state=seed)

xgb.fit(X_train, y_train)

XGBClassifier(base_score=None, booster=None, callbacks=None,
              colsample_bylevel=None, colsample_bynode=None,
              colsample_bytree=None, early_stopping_rounds=None,
              enable_categorical=False, eval_metric=None, feature_types=None,
              gamma=None, gpu_id=None, grow_policy=None, importance_type=None,
              interaction_constraints=None, learning_rate=None, max_bin=None,
              max_cat_threshold=None, max_cat_to_onehot=None,
              max_delta_step=None, max_depth=3, max_leaves=None,
              min_child_weight=None, missing=nan, monotone_constraints=None,
              n_estimators=100, n_jobs=None, num_parallel_tree=None,
              predictor=None, random_state=10, ...)

In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.

# Matriz de confusão
plot_confusion_matrix(xgb, X_test, y_test)

              precision    recall  f1-score   support

           0      0.488     0.774     0.598      1618
           1      0.925     0.773     0.842      5800

    accuracy                          0.773      7418
   macro avg      0.706     0.774     0.720      7418
weighted avg      0.829     0.773     0.789      7418

A matriz obtida para o modelo XGBoost apresentou diagonal equilibrada em ambas as classes, com 77% de acurácia.

# Curva ROC
plot_roc_curve(xgb, X_train, X_test, y_train, y_test)

Como a métrica AUC possui valores próximos para o conjunto de treino e de teste, 0,865 e 0,846 respectivamente, pode-se dizer que há apenas um pouco de overfitting, não sendo algo de grande preocupação.

# Importância das features
plot_feat_importances(xgb, feat_cols)

As features mais importantes nesta visualização são EC, QUIMIO, CIRURGIA e RECNENHUM.

# Importância das features pelos valores SHAP
plot_shap_values(xgb, X_train, feat_cols)

A coluna EC foi a mais importante aqui também, com isso, os valores mais altos desta variável, mostrados em rosa, influenciaram mais o modelo na previsão da classe 0 (não sobreviveu ao primeiro ano após o diagnóstico). Já os valores mais baixos desta coluna, em azul, tem mais peso para previsão ser da classe 1. Este comportamento faz sentido, pois quanto mais alto o estágio, maior é a extensão do câncer, assim menor a chance de sobrevivência.

O raciocínio para analisar as outras colunas é o mesmo utilizado para o estadiamento clínico.

Optuna

Para fazer a busca pelos melhores hiperparâmetros, será utilizado a biblioteca Optuna, definindo o intervalo para os parâmetros do modelo a serem buscados.

# Folds com a mesma proporção das classes
skf = StratifiedKFold(10, shuffle=True, random_state=seed)

# Função com o modelos e seus parâmetros, que terá sua métrica maximizada
def objective(trial):

    n_estimators = trial.suggest_int('n_estimators', 50, 250)
    max_depth = trial.suggest_int('max_depth', 3, 18)
    learning_rate = trial.suggest_float('learning_rate', 0.05, 0.2, step=0.05)
    gamma = trial.suggest_float('gamma', 0.0, 0.3, step=0.1)
    min_child_weight = trial.suggest_int('min_child_weight', 1, 7)
    colsample_bytree = trial.suggest_float('colsample_bytree', 0.3, 0.7, step=0.1)

    cls = XGBClassifier(n_estimators=n_estimators,
                        max_depth=max_depth,
                        learning_rate=learning_rate,
                        gamma=gamma,
                        min_child_weight=min_child_weight,
                        colsample_bytree=colsample_bytree,
                        random_state=seed)

    return cross_val_score(cls, X_train, y_train,
                           cv=skf, scoring='balanced_accuracy').mean()

# Criação do estudo e procura pelos hiperparâmetros
studyXGB = optuna.create_study(direction='maximize', sampler=RandomSampler(seed))
studyXGB.optimize(objective, n_trials=100)

# Melhor tentativa
studyXGB.best_trial

FrozenTrial(number=34, state=TrialState.COMPLETE, values=[0.690408417561615], datetime_start=datetime.datetime(2023, 4, 11, 23, 4, 35, 672447), datetime_complete=datetime.datetime(2023, 4, 11, 23, 5, 11, 49526), params={'n_estimators': 127, 'max_depth': 7, 'learning_rate': 0.2, 'gamma': 0.2, 'min_child_weight': 4, 'colsample_bytree': 0.6000000000000001}, user_attrs={}, system_attrs={}, intermediate_values={}, distributions={'n_estimators': IntDistribution(high=250, log=False, low=50, step=1), 'max_depth': IntDistribution(high=18, log=False, low=3, step=1), 'learning_rate': FloatDistribution(high=0.2, log=False, low=0.05, step=0.05), 'gamma': FloatDistribution(high=0.3, log=False, low=0.0, step=0.1), 'min_child_weight': IntDistribution(high=7, log=False, low=1, step=1), 'colsample_bytree': FloatDistribution(high=0.7, log=False, low=0.3, step=0.1)}, trial_id=34, value=None)

# Melhores parâmetros
studyXGB.best_params

{'n_estimators': 127,
 'max_depth': 7,
 'learning_rate': 0.2,
 'gamma': 0.2,
 'min_child_weight': 4,
 'colsample_bytree': 0.6000000000000001}

plot_optimization_history(studyXGB).show()

# Modelo com os melhores parâmetros
params = studyXGB.best_params
params['random_state'] = seed
params['scale_pos_weight'] = 0.22

xgb_optuna = XGBClassifier()
xgb_optuna.set_params(**params)

xgb_optuna.fit(X_train, y_train)

XGBClassifier(base_score=None, booster=None, callbacks=None,
              colsample_bylevel=None, colsample_bynode=None,
              colsample_bytree=0.6000000000000001, early_stopping_rounds=None,
              enable_categorical=False, eval_metric=None, feature_types=None,
              gamma=0.2, gpu_id=None, grow_policy=None, importance_type=None,
              interaction_constraints=None, learning_rate=0.2, max_bin=None,
              max_cat_threshold=None, max_cat_to_onehot=None,
              max_delta_step=None, max_depth=7, max_leaves=None,
              min_child_weight=4, missing=nan, monotone_constraints=None,
              n_estimators=127, n_jobs=None, num_parallel_tree=None,
              predictor=None, random_state=10, ...)

In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.

# Matriz de confusão do modelo XGBoost otimizado
plot_confusion_matrix(xgb_optuna, X_test, y_test)

              precision    recall  f1-score   support

           0      0.488     0.774     0.599      1618
           1      0.925     0.773     0.842      5800

    accuracy                          0.774      7418
   macro avg      0.706     0.774     0.720      7418
weighted avg      0.829     0.774     0.789      7418

Após a escolha dos hiperparâmetros, a acurácia de ambos os modelos ficou em torno de 77%.

# Curva ROC do modelo otimizado
plot_roc_curve(xgb_optuna, X_train, X_test, y_train, y_test)

A curva ROC mostra que o modelo possui um pouco de overfitting, pois para o conjunto de treino temos AUC = 0,935 e para o teste AUC = 0,845, essa diferença caracteriza o problema.

ROCs

# Treino
roc_together(X_train, y_train, nb, rf, xgb)

# Teste
roc_together(X_test, y_test, nb, rf, xgb)

RN

Importação das bibliotecas e funções

import tensorflow as tf
from tensorflow import keras

import matplotlib.pyplot as plt

from tensorflow.keras.models import Sequential, Model
from tensorflow.keras.layers import Dense, Dropout, Add, Input, Activation
from tensorflow.keras.optimizers import Adam

from tensorflow.keras.regularizers import l2
from tensorflow.keras.callbacks import EarlyStopping

# Definição de cores para gráficos
colors = plt.rcParams['axes.prop_cycle'].by_key()['color']

def plot_metrics(history):
    """Plot metrics after training the RNA.

    :param history: RNA training history.

    :return: no value
    :rtype: none
    """
    metrics = ['loss', 'accuracy', 'precision', 'recall']
    plt.figure(figsize=(12,8))
    for n, metric in enumerate(metrics):
        name = metric.replace("_"," ").capitalize()
        plt.subplot(2, 2, n + 1)
        plt.plot(history.epoch, history.history[metric], color=colors[0], label='Train')
        plt.plot(history.epoch, history.history['val_'+ metric],
                 color=colors[0], linestyle="--", label='Val')
        plt.xlabel('Epoch')
        plt.ylabel(name)
        if metric == 'loss':
            plt.ylim([0, plt.ylim()[1]])
        if metric == 'accuracy':
            plt.ylim([0.7, 1])
        else:
            plt.ylim([0, 1])
        plt.legend()

Criação e treinamento da RNA Complexa

neg, pos = np.bincount(y_train)
total = neg + pos
print(f'Exemplos:\n Total: {total}\n Positivos: {pos} ({100*pos/total:.2f}% do total)')

# Cálculo dos pesos das duas classe
weight_for_0 = (1 / neg)*(total)/2.0
weight_for_1 = (1 / pos)*(total)/2.0

# Dicionário de pesos das classes para treinamento
class_weight = {0: weight_for_0, 1: weight_for_1}
print('Peso da classe 0: {:.2f}'.format(weight_for_0))
print('Peso da classe 1: {:.2f}'.format(weight_for_1))

Exemplos:
 Total: 22252
 Positivos: 17400 (78.20% do total)
Peso da classe 0: 2.29
Peso da classe 1: 0.64

input_shape = X_train.shape[1:]
input_features = Input(shape=input_shape, name='input_features')

x1 = Dense(128, activation='tanh', kernel_regularizer=l2())(input_features)
x2 = Dense(128, activation='selu', kernel_regularizer=l2())(input_features)
x3 = Dense(128, activation='sigmoid', kernel_regularizer=l2())(input_features)

from tensorflow.keras.layers import Concatenate
x_concat = Concatenate()([x1, x2, x3, input_features])

x4 = Dense(32, activation='relu', kernel_regularizer=l2())(x_concat)
out = Dense(1, activation='sigmoid', name='out_dense')(x4)

model = keras.Model(inputs=[input_features],
                    outputs=[out])

model.summary()

Model: "model"
__________________________________________________________________________________________________
 Layer (type)                   Output Shape         Param #     Connected to
==================================================================================================
 input_features (InputLayer)    [(None, 25)]         0           []

 dense (Dense)                  (None, 128)          3328        ['input_features[0][0]']

 dense_1 (Dense)                (None, 128)          3328        ['input_features[0][0]']

 dense_2 (Dense)                (None, 128)          3328        ['input_features[0][0]']

 concatenate (Concatenate)      (None, 409)          0           ['dense[0][0]',
                                                                  'dense_1[0][0]',
                                                                  'dense_2[0][0]',
                                                                  'input_features[0][0]']

 dense_3 (Dense)                (None, 32)           13120       ['concatenate[0][0]']

 out_dense (Dense)              (None, 1)            33          ['dense_3[0][0]']

==================================================================================================
Total params: 23,137
Trainable params: 23,137
Non-trainable params: 0
__________________________________________________________________________________________________

keras.utils.plot_model(model, show_shapes=True)

from tensorflow.keras.callbacks import EarlyStopping

# Define métricas
METRICS = [keras.metrics.BinaryAccuracy(name='accuracy'),
           keras.metrics.Precision(name='precision'),
           keras.metrics.Recall(name='recall'),
           keras.metrics.AUC(name='auc')]

call_es = EarlyStopping(monitor='val_loss', patience=20, restore_best_weights=True)

adam = Adam(learning_rate=0.001)
model.compile(optimizer=adam, loss='binary_crossentropy',
              metrics=METRICS)

history = model.fit(X_train, y_train, epochs=50,
                    class_weight=class_weight,
                    verbose=2, batch_size=32,
                    validation_data=(X_test, y_test),
                    callbacks=[call_es])

Epoch 1/50
696/696 - 6s - loss: 0.9041 - accuracy: 0.7318 - precision: 0.9048 - recall: 0.7343 - auc: 0.7983 - val_loss: 0.4938 - val_accuracy: 0.8052 - val_precision: 0.8888 - val_recall: 0.8583 - val_auc: 0.8226 - 6s/epoch - 9ms/step
Epoch 2/50
696/696 - 2s - loss: 0.5664 - accuracy: 0.7316 - precision: 0.9031 - recall: 0.7357 - auc: 0.8048 - val_loss: 0.5486 - val_accuracy: 0.7478 - val_precision: 0.9135 - val_recall: 0.7483 - val_auc: 0.8260 - 2s/epoch - 3ms/step
Epoch 3/50
696/696 - 2s - loss: 0.5515 - accuracy: 0.7391 - precision: 0.9059 - recall: 0.7436 - auc: 0.8086 - val_loss: 0.5383 - val_accuracy: 0.7528 - val_precision: 0.9133 - val_recall: 0.7555 - val_auc: 0.8249 - 2s/epoch - 3ms/step
Epoch 4/50
696/696 - 4s - loss: 0.5464 - accuracy: 0.7447 - precision: 0.9079 - recall: 0.7497 - auc: 0.8106 - val_loss: 0.5182 - val_accuracy: 0.7672 - val_precision: 0.9048 - val_recall: 0.7848 - val_auc: 0.8246 - 4s/epoch - 5ms/step
Epoch 5/50
696/696 - 5s - loss: 0.5462 - accuracy: 0.7417 - precision: 0.9042 - recall: 0.7490 - auc: 0.8101 - val_loss: 0.5775 - val_accuracy: 0.7273 - val_precision: 0.9218 - val_recall: 0.7116 - val_auc: 0.8260 - 5s/epoch - 7ms/step
Epoch 6/50
696/696 - 5s - loss: 0.5464 - accuracy: 0.7430 - precision: 0.9061 - recall: 0.7489 - auc: 0.8110 - val_loss: 0.5288 - val_accuracy: 0.7591 - val_precision: 0.9118 - val_recall: 0.7660 - val_auc: 0.8277 - 5s/epoch - 7ms/step
Epoch 7/50
696/696 - 2s - loss: 0.5444 - accuracy: 0.7458 - precision: 0.9069 - recall: 0.7522 - auc: 0.8124 - val_loss: 0.5458 - val_accuracy: 0.7509 - val_precision: 0.9144 - val_recall: 0.7517 - val_auc: 0.8252 - 2s/epoch - 3ms/step
Epoch 8/50
696/696 - 2s - loss: 0.5438 - accuracy: 0.7447 - precision: 0.9076 - recall: 0.7499 - auc: 0.8132 - val_loss: 0.5483 - val_accuracy: 0.7431 - val_precision: 0.9175 - val_recall: 0.7378 - val_auc: 0.8258 - 2s/epoch - 3ms/step
Epoch 9/50
696/696 - 2s - loss: 0.5429 - accuracy: 0.7444 - precision: 0.9079 - recall: 0.7491 - auc: 0.8134 - val_loss: 0.4555 - val_accuracy: 0.8153 - val_precision: 0.8901 - val_recall: 0.8714 - val_auc: 0.8282 - 2s/epoch - 3ms/step
Epoch 10/50
696/696 - 2s - loss: 0.5414 - accuracy: 0.7464 - precision: 0.9063 - recall: 0.7536 - auc: 0.8146 - val_loss: 0.5017 - val_accuracy: 0.7753 - val_precision: 0.9029 - val_recall: 0.7984 - val_auc: 0.8283 - 2s/epoch - 3ms/step
Epoch 11/50
696/696 - 3s - loss: 0.5407 - accuracy: 0.7491 - precision: 0.9084 - recall: 0.7553 - auc: 0.8151 - val_loss: 0.6131 - val_accuracy: 0.6889 - val_precision: 0.9318 - val_recall: 0.6497 - val_auc: 0.8281 - 3s/epoch - 5ms/step
Epoch 12/50
696/696 - 2s - loss: 0.5399 - accuracy: 0.7493 - precision: 0.9090 - recall: 0.7550 - auc: 0.8159 - val_loss: 0.5942 - val_accuracy: 0.7033 - val_precision: 0.9281 - val_recall: 0.6726 - val_auc: 0.8269 - 2s/epoch - 3ms/step
Epoch 13/50
696/696 - 2s - loss: 0.5377 - accuracy: 0.7512 - precision: 0.9096 - recall: 0.7571 - auc: 0.8163 - val_loss: 0.5290 - val_accuracy: 0.7631 - val_precision: 0.9159 - val_recall: 0.7676 - val_auc: 0.8311 - 2s/epoch - 3ms/step
Epoch 14/50
696/696 - 2s - loss: 0.5377 - accuracy: 0.7513 - precision: 0.9101 - recall: 0.7567 - auc: 0.8177 - val_loss: 0.5179 - val_accuracy: 0.7661 - val_precision: 0.9139 - val_recall: 0.7738 - val_auc: 0.8298 - 2s/epoch - 3ms/step
Epoch 15/50
696/696 - 2s - loss: 0.5372 - accuracy: 0.7497 - precision: 0.9097 - recall: 0.7548 - auc: 0.8169 - val_loss: 0.5463 - val_accuracy: 0.7429 - val_precision: 0.9212 - val_recall: 0.7340 - val_auc: 0.8316 - 2s/epoch - 3ms/step
Epoch 16/50
696/696 - 2s - loss: 0.5352 - accuracy: 0.7478 - precision: 0.9103 - recall: 0.7516 - auc: 0.8186 - val_loss: 0.5593 - val_accuracy: 0.7332 - val_precision: 0.9235 - val_recall: 0.7183 - val_auc: 0.8291 - 2s/epoch - 3ms/step
Epoch 17/50
696/696 - 3s - loss: 0.5364 - accuracy: 0.7474 - precision: 0.9085 - recall: 0.7529 - auc: 0.8181 - val_loss: 0.5491 - val_accuracy: 0.7429 - val_precision: 0.9216 - val_recall: 0.7336 - val_auc: 0.8305 - 3s/epoch - 4ms/step
Epoch 18/50
696/696 - 3s - loss: 0.5348 - accuracy: 0.7507 - precision: 0.9105 - recall: 0.7555 - auc: 0.8187 - val_loss: 0.5019 - val_accuracy: 0.7739 - val_precision: 0.9080 - val_recall: 0.7910 - val_auc: 0.8275 - 3s/epoch - 4ms/step
Epoch 19/50
696/696 - 2s - loss: 0.5327 - accuracy: 0.7517 - precision: 0.9097 - recall: 0.7576 - auc: 0.8201 - val_loss: 0.5580 - val_accuracy: 0.7340 - val_precision: 0.9240 - val_recall: 0.7190 - val_auc: 0.8318 - 2s/epoch - 3ms/step
Epoch 20/50
696/696 - 2s - loss: 0.5340 - accuracy: 0.7500 - precision: 0.9110 - recall: 0.7539 - auc: 0.8196 - val_loss: 0.5638 - val_accuracy: 0.7328 - val_precision: 0.9276 - val_recall: 0.7140 - val_auc: 0.8320 - 2s/epoch - 3ms/step
Epoch 21/50
696/696 - 2s - loss: 0.5322 - accuracy: 0.7501 - precision: 0.9106 - recall: 0.7544 - auc: 0.8207 - val_loss: 0.5234 - val_accuracy: 0.7645 - val_precision: 0.9165 - val_recall: 0.7688 - val_auc: 0.8321 - 2s/epoch - 3ms/step
Epoch 22/50
696/696 - 2s - loss: 0.5318 - accuracy: 0.7517 - precision: 0.9112 - recall: 0.7562 - auc: 0.8209 - val_loss: 0.5098 - val_accuracy: 0.7656 - val_precision: 0.9135 - val_recall: 0.7734 - val_auc: 0.8307 - 2s/epoch - 3ms/step
Epoch 23/50
696/696 - 3s - loss: 0.5312 - accuracy: 0.7527 - precision: 0.9111 - recall: 0.7577 - auc: 0.8208 - val_loss: 0.5280 - val_accuracy: 0.7561 - val_precision: 0.9190 - val_recall: 0.7547 - val_auc: 0.8304 - 3s/epoch - 4ms/step
Epoch 24/50
696/696 - 3s - loss: 0.5313 - accuracy: 0.7528 - precision: 0.9112 - recall: 0.7576 - auc: 0.8211 - val_loss: 0.5257 - val_accuracy: 0.7607 - val_precision: 0.9195 - val_recall: 0.7605 - val_auc: 0.8330 - 3s/epoch - 4ms/step
Epoch 25/50
696/696 - 2s - loss: 0.5300 - accuracy: 0.7533 - precision: 0.9115 - recall: 0.7580 - auc: 0.8220 - val_loss: 0.5695 - val_accuracy: 0.7230 - val_precision: 0.9261 - val_recall: 0.7017 - val_auc: 0.8289 - 2s/epoch - 3ms/step
Epoch 26/50
696/696 - 2s - loss: 0.5279 - accuracy: 0.7539 - precision: 0.9117 - recall: 0.7587 - auc: 0.8231 - val_loss: 0.5232 - val_accuracy: 0.7621 - val_precision: 0.9162 - val_recall: 0.7657 - val_auc: 0.8312 - 2s/epoch - 3ms/step
Epoch 27/50
696/696 - 2s - loss: 0.5286 - accuracy: 0.7551 - precision: 0.9113 - recall: 0.7609 - auc: 0.8226 - val_loss: 0.5261 - val_accuracy: 0.7528 - val_precision: 0.9171 - val_recall: 0.7517 - val_auc: 0.8304 - 2s/epoch - 3ms/step
Epoch 28/50
696/696 - 2s - loss: 0.5308 - accuracy: 0.7540 - precision: 0.9127 - recall: 0.7579 - auc: 0.8214 - val_loss: 0.5220 - val_accuracy: 0.7599 - val_precision: 0.9151 - val_recall: 0.7638 - val_auc: 0.8312 - 2s/epoch - 3ms/step
Epoch 29/50
696/696 - 2s - loss: 0.5285 - accuracy: 0.7537 - precision: 0.9123 - recall: 0.7579 - auc: 0.8224 - val_loss: 0.5315 - val_accuracy: 0.7541 - val_precision: 0.9178 - val_recall: 0.7529 - val_auc: 0.8293 - 2s/epoch - 3ms/step

Resultados

plot_metrics(history)

train_pred = model.predict(X_train)
test_pred = model.predict(X_test)

print('Número de exemplos positivos do conjunto de teste =', len(y_test[y_test > 0.9]))
results = model.evaluate(X_test, y_test, verbose=0)

for name, value in zip(model.metrics_names, results):
    print(f'{name}: {value:.4f}')

696/696 [==============================] - 2s 2ms/step
232/232 [==============================] - 0s 1ms/step
Número de exemplos positivos do conjunto de teste = 5800
loss: 0.4555
accuracy: 0.8153
precision: 0.8901
recall: 0.8714
auc: 0.8282

precision = results[2]
recall = results[3]
F1 = 2*precision*recall/(precision + recall)
print(f'Pontuação F1 = {F1:.4f}')

Pontuação F1 = 0.8806

ConfusionMatrixDisplay.from_predictions(y_test, np.round(test_pred),
                                        normalize='true', cmap='Blues',
                                        values_format='.3f')
plt.show()

from sklearn.metrics import balanced_accuracy_score

balanced_accuracy_score(y_test, np.round(test_pred))

0.742859000042624

fp_train, tp_train, _ = roc_curve(y_train, train_pred)
fp_test, tp_test, _ = roc_curve(y_test, test_pred)
plt.figure(figsize=(8, 6))
plt.plot(100*fp_train, 100*tp_train, 'b', label='Dados treinamento')
plt.plot(100*fp_test, 100*tp_test, 'r', label='Dados teste')
plt.xlabel('Positivos falsos [%]')
plt.ylabel('Positivos verdadeiros [%]')
plt.xlim([0,100])
plt.ylim([0,100])
plt.grid(True)
plt.legend()
plt.show()

custo_e_metricas_train = model.evaluate(X_train, y_train)
# custo_e_metricas_val = rna_reg.evaluate(X_val_norm, y_val)
custo_e_metricas_test = model.evaluate(X_test, y_test)

696/696 [==============================] - 2s 3ms/step - loss: 0.4602 - accuracy: 0.8025 - precision: 0.8811 - recall: 0.8640 - auc: 0.8200
232/232 [==============================] - 1s 3ms/step - loss: 0.4555 - accuracy: 0.8153 - precision: 0.8901 - recall: 0.8714 - auc: 0.8282

Criação e treinamento da RNA Residual

# Função que cria o bloco para a RN residual
def bloco_residual(x, n):

    z1 = Dense(n, activation='relu')(x)
    z2 = Dense(n)(z1)
    sum = Add()([x, z2])
    a2 = Activation('relu')(sum)

    return a2

# Definição da entrada
input_shape = X_train.shape[1:]
input_features = Input(shape=input_shape)

X1 = Dense(64, activation='relu')(input_features)

X2 = bloco_residual(X1, 64)

X3 = Dense(64, activation='relu')(X2)

X4 = bloco_residual(X3, 64)

X5 = Dense(16, activation='relu')(X4)

Y = Dense(units=1, activation='sigmoid')(X5)

# Criação da RNA
rna = Model(input_features, Y)

# Mostra resumo da RNA
rna.summary()

Model: "model_10"
__________________________________________________________________________________________________
 Layer (type)                   Output Shape         Param #     Connected to
==================================================================================================
 input_13 (InputLayer)          [(None, 25)]         0           []

 dense_99 (Dense)               (None, 64)           1664        ['input_13[0][0]']

 dense_100 (Dense)              (None, 64)           4160        ['dense_99[0][0]']

 dense_101 (Dense)              (None, 64)           4160        ['dense_100[0][0]']

 add_23 (Add)                   (None, 64)           0           ['dense_99[0][0]',
                                                                  'dense_101[0][0]']

 activation_20 (Activation)     (None, 64)           0           ['add_23[0][0]']

 dense_102 (Dense)              (None, 64)           4160        ['activation_20[0][0]']

 dense_103 (Dense)              (None, 64)           4160        ['dense_102[0][0]']

 dense_104 (Dense)              (None, 64)           4160        ['dense_103[0][0]']

 add_24 (Add)                   (None, 64)           0           ['dense_102[0][0]',
                                                                  'dense_104[0][0]']

 activation_21 (Activation)     (None, 64)           0           ['add_24[0][0]']

 dense_105 (Dense)              (None, 16)           1040        ['activation_21[0][0]']

 dense_106 (Dense)              (None, 1)            17          ['dense_105[0][0]']

==================================================================================================
Total params: 23,521
Trainable params: 23,521
Non-trainable params: 0
__________________________________________________________________________________________________

keras.utils.plot_model(rna, show_shapes=True)

from tensorflow.keras.callbacks import EarlyStopping

# Define métricas
METRICS = [keras.metrics.BinaryAccuracy(name='accuracy'),
           keras.metrics.Precision(name='precision'),
           keras.metrics.Recall(name='recall'),
           keras.metrics.AUC(name='auc')]

call_es = EarlyStopping(monitor='val_loss', patience=20,
                        restore_best_weights=True)

adam = Adam(learning_rate=0.001)
rna.compile(optimizer=adam, loss='binary_crossentropy',
              metrics=METRICS)

history = rna.fit(X_train, y_train, epochs=50,
                    class_weight=class_weight,
                    verbose=2, batch_size=32,
                    validation_data=(X_test, y_test),
                    callbacks=[call_es])

Epoch 1/50
696/696 - 6s - loss: 0.9472 - accuracy: 0.7342 - precision: 0.9045 - recall: 0.7380 - auc: 0.8004 - val_loss: 0.5788 - val_accuracy: 0.7208 - val_precision: 0.9293 - val_recall: 0.6959 - val_auc: 0.8316 - 6s/epoch - 9ms/step
Epoch 2/50
696/696 - 4s - loss: 0.5237 - accuracy: 0.7491 - precision: 0.9116 - recall: 0.7521 - auc: 0.8207 - val_loss: 0.5463 - val_accuracy: 0.7340 - val_precision: 0.9257 - val_recall: 0.7174 - val_auc: 0.8337 - 4s/epoch - 6ms/step
Epoch 3/50
696/696 - 6s - loss: 0.5107 - accuracy: 0.7516 - precision: 0.9135 - recall: 0.7537 - auc: 0.8277 - val_loss: 0.5075 - val_accuracy: 0.7591 - val_precision: 0.9181 - val_recall: 0.7597 - val_auc: 0.8337 - 6s/epoch - 9ms/step
Epoch 4/50
696/696 - 5s - loss: 0.5063 - accuracy: 0.7559 - precision: 0.9166 - recall: 0.7567 - auc: 0.8309 - val_loss: 0.4829 - val_accuracy: 0.7749 - val_precision: 0.9096 - val_recall: 0.7907 - val_auc: 0.8333 - 5s/epoch - 7ms/step
Epoch 5/50
696/696 - 7s - loss: 0.5028 - accuracy: 0.7605 - precision: 0.9179 - recall: 0.7619 - auc: 0.8335 - val_loss: 0.4650 - val_accuracy: 0.7851 - val_precision: 0.9087 - val_recall: 0.8062 - val_auc: 0.8335 - 7s/epoch - 9ms/step
Epoch 6/50
696/696 - 3s - loss: 0.4993 - accuracy: 0.7570 - precision: 0.9173 - recall: 0.7575 - auc: 0.8361 - val_loss: 0.5008 - val_accuracy: 0.7629 - val_precision: 0.9195 - val_recall: 0.7636 - val_auc: 0.8350 - 3s/epoch - 4ms/step
Epoch 7/50
696/696 - 2s - loss: 0.4950 - accuracy: 0.7601 - precision: 0.9200 - recall: 0.7592 - auc: 0.8392 - val_loss: 0.4730 - val_accuracy: 0.7796 - val_precision: 0.9116 - val_recall: 0.7952 - val_auc: 0.8325 - 2s/epoch - 4ms/step
Epoch 8/50
696/696 - 4s - loss: 0.4918 - accuracy: 0.7605 - precision: 0.9215 - recall: 0.7583 - auc: 0.8415 - val_loss: 0.5118 - val_accuracy: 0.7537 - val_precision: 0.9199 - val_recall: 0.7503 - val_auc: 0.8320 - 4s/epoch - 6ms/step
Epoch 9/50
696/696 - 7s - loss: 0.4860 - accuracy: 0.7646 - precision: 0.9242 - recall: 0.7614 - auc: 0.8458 - val_loss: 0.5141 - val_accuracy: 0.7561 - val_precision: 0.9218 - val_recall: 0.7519 - val_auc: 0.8326 - 7s/epoch - 10ms/step
Epoch 10/50
696/696 - 3s - loss: 0.4833 - accuracy: 0.7685 - precision: 0.9243 - recall: 0.7667 - auc: 0.8476 - val_loss: 0.5043 - val_accuracy: 0.7609 - val_precision: 0.9182 - val_recall: 0.7621 - val_auc: 0.8292 - 3s/epoch - 4ms/step
Epoch 11/50
696/696 - 2s - loss: 0.4801 - accuracy: 0.7655 - precision: 0.9242 - recall: 0.7626 - auc: 0.8496 - val_loss: 0.4963 - val_accuracy: 0.7661 - val_precision: 0.9173 - val_recall: 0.7703 - val_auc: 0.8297 - 2s/epoch - 3ms/step
Epoch 12/50
696/696 - 2s - loss: 0.4762 - accuracy: 0.7692 - precision: 0.9259 - recall: 0.7661 - auc: 0.8522 - val_loss: 0.5135 - val_accuracy: 0.7547 - val_precision: 0.9189 - val_recall: 0.7526 - val_auc: 0.8299 - 2s/epoch - 3ms/step
Epoch 13/50
696/696 - 2s - loss: 0.4718 - accuracy: 0.7695 - precision: 0.9263 - recall: 0.7661 - auc: 0.8552 - val_loss: 0.5000 - val_accuracy: 0.7609 - val_precision: 0.9168 - val_recall: 0.7634 - val_auc: 0.8294 - 2s/epoch - 3ms/step
Epoch 14/50
696/696 - 3s - loss: 0.4678 - accuracy: 0.7716 - precision: 0.9291 - recall: 0.7664 - auc: 0.8575 - val_loss: 0.4652 - val_accuracy: 0.7815 - val_precision: 0.9090 - val_recall: 0.8007 - val_auc: 0.8290 - 3s/epoch - 5ms/step
Epoch 15/50
696/696 - 3s - loss: 0.4626 - accuracy: 0.7714 - precision: 0.9284 - recall: 0.7668 - auc: 0.8609 - val_loss: 0.4837 - val_accuracy: 0.7688 - val_precision: 0.9124 - val_recall: 0.7791 - val_auc: 0.8272 - 3s/epoch - 4ms/step
Epoch 16/50
696/696 - 2s - loss: 0.4590 - accuracy: 0.7754 - precision: 0.9309 - recall: 0.7700 - auc: 0.8633 - val_loss: 0.5025 - val_accuracy: 0.7603 - val_precision: 0.9158 - val_recall: 0.7636 - val_auc: 0.8260 - 2s/epoch - 3ms/step
Epoch 17/50
696/696 - 2s - loss: 0.4542 - accuracy: 0.7758 - precision: 0.9319 - recall: 0.7695 - auc: 0.8659 - val_loss: 0.4890 - val_accuracy: 0.7623 - val_precision: 0.9100 - val_recall: 0.7724 - val_auc: 0.8235 - 2s/epoch - 3ms/step
Epoch 18/50
696/696 - 2s - loss: 0.4522 - accuracy: 0.7778 - precision: 0.9349 - recall: 0.7694 - auc: 0.8670 - val_loss: 0.4980 - val_accuracy: 0.7572 - val_precision: 0.9124 - val_recall: 0.7628 - val_auc: 0.8232 - 2s/epoch - 3ms/step
Epoch 19/50
696/696 - 2s - loss: 0.4490 - accuracy: 0.7749 - precision: 0.9333 - recall: 0.7669 - auc: 0.8691 - val_loss: 0.4953 - val_accuracy: 0.7666 - val_precision: 0.9094 - val_recall: 0.7791 - val_auc: 0.8211 - 2s/epoch - 3ms/step
Epoch 20/50
696/696 - 3s - loss: 0.4425 - accuracy: 0.7779 - precision: 0.9351 - recall: 0.7693 - auc: 0.8726 - val_loss: 0.5015 - val_accuracy: 0.7664 - val_precision: 0.9132 - val_recall: 0.7748 - val_auc: 0.8264 - 3s/epoch - 5ms/step
Epoch 21/50
696/696 - 3s - loss: 0.4399 - accuracy: 0.7797 - precision: 0.9364 - recall: 0.7705 - auc: 0.8740 - val_loss: 0.5319 - val_accuracy: 0.7484 - val_precision: 0.9157 - val_recall: 0.7471 - val_auc: 0.8214 - 3s/epoch - 4ms/step
Epoch 22/50
696/696 - 2s - loss: 0.4375 - accuracy: 0.7815 - precision: 0.9387 - recall: 0.7709 - auc: 0.8753 - val_loss: 0.5112 - val_accuracy: 0.7507 - val_precision: 0.9111 - val_recall: 0.7548 - val_auc: 0.8176 - 2s/epoch - 3ms/step
Epoch 23/50
696/696 - 2s - loss: 0.4326 - accuracy: 0.7828 - precision: 0.9403 - recall: 0.7711 - auc: 0.8783 - val_loss: 0.5174 - val_accuracy: 0.7474 - val_precision: 0.9161 - val_recall: 0.7452 - val_auc: 0.8163 - 2s/epoch - 3ms/step
Epoch 24/50
696/696 - 2s - loss: 0.4277 - accuracy: 0.7853 - precision: 0.9399 - recall: 0.7749 - auc: 0.8808 - val_loss: 0.5146 - val_accuracy: 0.7583 - val_precision: 0.9158 - val_recall: 0.7609 - val_auc: 0.8201 - 2s/epoch - 3ms/step
Epoch 25/50
696/696 - 3s - loss: 0.4248 - accuracy: 0.7839 - precision: 0.9426 - recall: 0.7706 - auc: 0.8823 - val_loss: 0.4969 - val_accuracy: 0.7626 - val_precision: 0.9059 - val_recall: 0.7771 - val_auc: 0.8163 - 3s/epoch - 4ms/step

Resultados

plot_metrics(history)

train_pred = rna.predict(X_train)
test_pred = rna.predict(X_test)

print('Número de exemplos positivos do conjunto de teste =', len(y_test[y_test > 0.9]))
results = rna.evaluate(X_test, y_test, verbose=0)

for name, value in zip(rna.metrics_names, results):
    print(f'{name}: {value:.4f}')

696/696 [==============================] - 1s 1ms/step
232/232 [==============================] - 1s 2ms/step
Número de exemplos positivos do conjunto de teste = 5800
loss: 0.4650
accuracy: 0.7851
precision: 0.9087
recall: 0.8062
auc: 0.8335

precision = results[2]
recall = results[3]
F1 = 2*precision*recall/(precision + recall)
print(f'Pontuação F1 = {F1:.4f}')

Pontuação F1 = 0.8544

ConfusionMatrixDisplay.from_predictions(y_test, np.round(test_pred),
                                        normalize='true', cmap='Blues',
                                        values_format='.3f')
plt.show()

from sklearn.metrics import balanced_accuracy_score

balanced_accuracy_score(y_test, np.round(test_pred))

0.7578624099569499

fp_train, tp_train, _ = roc_curve(y_train, train_pred)
fp_test, tp_test, _ = roc_curve(y_test, test_pred)
plt.figure(figsize=(8, 6))
plt.plot(100*fp_train, 100*tp_train, 'b', label='Dados treinamento')
plt.plot(100*fp_test, 100*tp_test, 'r', label='Dados teste')
plt.xlabel('Positivos falsos [%]')
plt.ylabel('Positivos verdadeiros [%]')
plt.xlim([0,100])
plt.ylim([0,100])
plt.grid(True)
plt.legend()
plt.show()

custo_e_metricas_train = rna.evaluate(X_train, y_train)
custo_e_metricas_test = rna.evaluate(X_test, y_test)

696/696 [==============================] - 1s 2ms/step - loss: 0.4556 - accuracy: 0.7882 - precision: 0.9073 - recall: 0.8122 - auc: 0.8417
232/232 [==============================] - 0s 2ms/step - loss: 0.4650 - accuracy: 0.7851 - precision: 0.9087 - recall: 0.8062 - auc: 0.8335

Criação e treinamento da RNA Sequencial

neg, pos = np.bincount(y_train)
total = neg + pos
print(f'Exemplos:\n Total: {total}\n Positivos: {pos} ({100*pos/total:.2f}% do total)')

# Cálculo dos pesos das duas classe
weight_for_0 = (1 / neg)*(total)/2.0
weight_for_1 = (1 / pos)*(total)/2.0

# Dicionário de pesos das classes para treinamento
class_weight = {0: weight_for_0, 1: weight_for_1}
print('Peso da classe 0: {:.2f}'.format(weight_for_0))
print('Peso da classe 1: {:.2f}'.format(weight_for_1))

Exemplos:
 Total: 22252
 Positivos: 17400 (78.20% do total)
Peso da classe 0: 2.29
Peso da classe 1: 0.64

rna = Sequential()
rna.add(Dense(units=128, activation='relu', input_shape=X_train.shape[1:]))
rna.add(Dense(units=128, activation='relu'))
rna.add(Dense(units=32, activation='relu'))
rna.add(Dense(units=1, activation='sigmoid'))
rna.summary()

Model: "sequential_2"
_________________________________________________________________
 Layer (type)                Output Shape              Param #
=================================================================
 dense_12 (Dense)            (None, 128)               3328

 dense_13 (Dense)            (None, 128)               16512

 dense_14 (Dense)            (None, 32)                4128

 dense_15 (Dense)            (None, 1)                 33

=================================================================
Total params: 24,001
Trainable params: 24,001
Non-trainable params: 0
_________________________________________________________________

keras.utils.plot_model(rna, show_shapes=True)

from tensorflow.keras.callbacks import EarlyStopping

# Define métricas
METRICS = [keras.metrics.BinaryAccuracy(name='accuracy'),
           keras.metrics.Precision(name='precision'),
           keras.metrics.Recall(name='recall'),
           keras.metrics.AUC(name='auc')]

call_es = EarlyStopping(monitor='val_loss', patience=20,
                        restore_best_weights=True)

adam = Adam(learning_rate=0.001)
rna.compile(optimizer=adam, loss='binary_crossentropy',
            metrics=METRICS)

history = rna.fit(X_train, y_train, epochs=50,
                  class_weight=class_weight,
                  verbose=2, batch_size=32,
                  validation_data=(X_test, y_test),
                  callbacks=[call_es])

Epoch 1/50
696/696 - 4s - loss: 0.5404 - accuracy: 0.7324 - precision: 0.9068 - recall: 0.7332 - auc: 0.8038 - val_loss: 0.5814 - val_accuracy: 0.7246 - val_precision: 0.9257 - val_recall: 0.7043 - val_auc: 0.8276 - 4s/epoch - 6ms/step
Epoch 2/50
696/696 - 3s - loss: 0.5145 - accuracy: 0.7551 - precision: 0.9129 - recall: 0.7592 - auc: 0.8249 - val_loss: 0.5312 - val_accuracy: 0.7501 - val_precision: 0.9230 - val_recall: 0.7422 - val_auc: 0.8323 - 3s/epoch - 4ms/step
Epoch 3/50
696/696 - 2s - loss: 0.5079 - accuracy: 0.7552 - precision: 0.9174 - recall: 0.7549 - auc: 0.8298 - val_loss: 0.5185 - val_accuracy: 0.7657 - val_precision: 0.9195 - val_recall: 0.7676 - val_auc: 0.8332 - 2s/epoch - 3ms/step
Epoch 4/50
696/696 - 2s - loss: 0.5025 - accuracy: 0.7618 - precision: 0.9182 - recall: 0.7634 - auc: 0.8343 - val_loss: 0.5208 - val_accuracy: 0.7586 - val_precision: 0.9214 - val_recall: 0.7557 - val_auc: 0.8335 - 2s/epoch - 3ms/step
Epoch 5/50
696/696 - 2s - loss: 0.4972 - accuracy: 0.7642 - precision: 0.9199 - recall: 0.7651 - auc: 0.8378 - val_loss: 0.5065 - val_accuracy: 0.7609 - val_precision: 0.9213 - val_recall: 0.7590 - val_auc: 0.8334 - 2s/epoch - 3ms/step
Epoch 6/50
696/696 - 2s - loss: 0.4918 - accuracy: 0.7666 - precision: 0.9207 - recall: 0.7676 - auc: 0.8416 - val_loss: 0.5214 - val_accuracy: 0.7495 - val_precision: 0.9241 - val_recall: 0.7405 - val_auc: 0.8346 - 2s/epoch - 3ms/step
Epoch 7/50
696/696 - 2s - loss: 0.4859 - accuracy: 0.7653 - precision: 0.9238 - recall: 0.7628 - auc: 0.8459 - val_loss: 0.4591 - val_accuracy: 0.7937 - val_precision: 0.9087 - val_recall: 0.8184 - val_auc: 0.8329 - 2s/epoch - 3ms/step
Epoch 8/50
696/696 - 3s - loss: 0.4807 - accuracy: 0.7705 - precision: 0.9243 - recall: 0.7696 - auc: 0.8498 - val_loss: 0.4908 - val_accuracy: 0.7731 - val_precision: 0.9188 - val_recall: 0.7786 - val_auc: 0.8323 - 3s/epoch - 4ms/step
Epoch 9/50
696/696 - 3s - loss: 0.4720 - accuracy: 0.7742 - precision: 0.9277 - recall: 0.7714 - auc: 0.8553 - val_loss: 0.4855 - val_accuracy: 0.7676 - val_precision: 0.9181 - val_recall: 0.7716 - val_auc: 0.8346 - 3s/epoch - 4ms/step
Epoch 10/50
696/696 - 2s - loss: 0.4677 - accuracy: 0.7737 - precision: 0.9296 - recall: 0.7689 - auc: 0.8583 - val_loss: 0.4941 - val_accuracy: 0.7660 - val_precision: 0.9214 - val_recall: 0.7660 - val_auc: 0.8326 - 2s/epoch - 3ms/step
Epoch 11/50
696/696 - 2s - loss: 0.4621 - accuracy: 0.7763 - precision: 0.9310 - recall: 0.7710 - auc: 0.8618 - val_loss: 0.5195 - val_accuracy: 0.7580 - val_precision: 0.9195 - val_recall: 0.7567 - val_auc: 0.8277 - 2s/epoch - 3ms/step
Epoch 12/50
696/696 - 2s - loss: 0.4540 - accuracy: 0.7760 - precision: 0.9323 - recall: 0.7695 - auc: 0.8667 - val_loss: 0.5157 - val_accuracy: 0.7471 - val_precision: 0.9198 - val_recall: 0.7412 - val_auc: 0.8263 - 2s/epoch - 3ms/step
Epoch 13/50
696/696 - 2s - loss: 0.4485 - accuracy: 0.7802 - precision: 0.9350 - recall: 0.7726 - auc: 0.8699 - val_loss: 0.5093 - val_accuracy: 0.7578 - val_precision: 0.9190 - val_recall: 0.7569 - val_auc: 0.8264 - 2s/epoch - 3ms/step
Epoch 14/50
696/696 - 3s - loss: 0.4393 - accuracy: 0.7831 - precision: 0.9379 - recall: 0.7739 - auc: 0.8757 - val_loss: 0.5081 - val_accuracy: 0.7511 - val_precision: 0.9133 - val_recall: 0.7533 - val_auc: 0.8184 - 3s/epoch - 4ms/step
Epoch 15/50
696/696 - 3s - loss: 0.4301 - accuracy: 0.7865 - precision: 0.9404 - recall: 0.7762 - auc: 0.8809 - val_loss: 0.5369 - val_accuracy: 0.7441 - val_precision: 0.9210 - val_recall: 0.7359 - val_auc: 0.8229 - 3s/epoch - 4ms/step
Epoch 16/50
696/696 - 2s - loss: 0.4233 - accuracy: 0.7890 - precision: 0.9417 - recall: 0.7783 - auc: 0.8848 - val_loss: 0.5274 - val_accuracy: 0.7617 - val_precision: 0.9207 - val_recall: 0.7607 - val_auc: 0.8232 - 2s/epoch - 3ms/step
Epoch 17/50
696/696 - 2s - loss: 0.4179 - accuracy: 0.7907 - precision: 0.9418 - recall: 0.7806 - auc: 0.8871 - val_loss: 0.5517 - val_accuracy: 0.7311 - val_precision: 0.9186 - val_recall: 0.7198 - val_auc: 0.8148 - 2s/epoch - 3ms/step
Epoch 18/50
696/696 - 3s - loss: 0.4057 - accuracy: 0.7955 - precision: 0.9465 - recall: 0.7826 - auc: 0.8938 - val_loss: 0.5188 - val_accuracy: 0.7596 - val_precision: 0.9088 - val_recall: 0.7698 - val_auc: 0.8113 - 3s/epoch - 4ms/step
Epoch 19/50
696/696 - 2s - loss: 0.3961 - accuracy: 0.8003 - precision: 0.9481 - recall: 0.7878 - auc: 0.8989 - val_loss: 0.5355 - val_accuracy: 0.7425 - val_precision: 0.9100 - val_recall: 0.7443 - val_auc: 0.8079 - 2s/epoch - 3ms/step
Epoch 20/50
696/696 - 3s - loss: 0.3882 - accuracy: 0.8049 - precision: 0.9493 - recall: 0.7928 - auc: 0.9028 - val_loss: 0.5391 - val_accuracy: 0.7478 - val_precision: 0.9100 - val_recall: 0.7517 - val_auc: 0.8087 - 3s/epoch - 4ms/step
Epoch 21/50
696/696 - 3s - loss: 0.3790 - accuracy: 0.8098 - precision: 0.9534 - recall: 0.7957 - auc: 0.9077 - val_loss: 0.5231 - val_accuracy: 0.7617 - val_precision: 0.9058 - val_recall: 0.7759 - val_auc: 0.8112 - 3s/epoch - 4ms/step
Epoch 22/50
696/696 - 2s - loss: 0.3706 - accuracy: 0.8120 - precision: 0.9543 - recall: 0.7977 - auc: 0.9114 - val_loss: 0.5977 - val_accuracy: 0.7320 - val_precision: 0.9118 - val_recall: 0.7276 - val_auc: 0.8056 - 2s/epoch - 3ms/step
Epoch 23/50
696/696 - 2s - loss: 0.3610 - accuracy: 0.8207 - precision: 0.9579 - recall: 0.8061 - auc: 0.9158 - val_loss: 0.5455 - val_accuracy: 0.7530 - val_precision: 0.9019 - val_recall: 0.7676 - val_auc: 0.8048 - 2s/epoch - 3ms/step
Epoch 24/50
696/696 - 2s - loss: 0.3543 - accuracy: 0.8219 - precision: 0.9583 - recall: 0.8074 - auc: 0.9189 - val_loss: 0.5590 - val_accuracy: 0.7503 - val_precision: 0.9038 - val_recall: 0.7617 - val_auc: 0.8023 - 2s/epoch - 3ms/step
Epoch 25/50
696/696 - 2s - loss: 0.3459 - accuracy: 0.8258 - precision: 0.9592 - recall: 0.8118 - auc: 0.9225 - val_loss: 0.5694 - val_accuracy: 0.7470 - val_precision: 0.8983 - val_recall: 0.7628 - val_auc: 0.7960 - 2s/epoch - 3ms/step
Epoch 26/50
696/696 - 2s - loss: 0.3350 - accuracy: 0.8321 - precision: 0.9636 - recall: 0.8161 - auc: 0.9273 - val_loss: 0.6194 - val_accuracy: 0.7329 - val_precision: 0.9057 - val_recall: 0.7350 - val_auc: 0.7944 - 2s/epoch - 3ms/step
Epoch 27/50
696/696 - 3s - loss: 0.3245 - accuracy: 0.8374 - precision: 0.9640 - recall: 0.8228 - auc: 0.9316 - val_loss: 0.6083 - val_accuracy: 0.7475 - val_precision: 0.9001 - val_recall: 0.7616 - val_auc: 0.7958 - 3s/epoch - 4ms/step

Resultados

plot_metrics(history)

train_pred = rna.predict(X_train)
test_pred = rna.predict(X_test)

print('Número de exemplos positivos do conjunto de teste =', len(y_test[y_test > 0.9]))
results = rna.evaluate(X_test, y_test, verbose=0)

for name, value in zip(rna.metrics_names, results):
    print(f'{name}: {value:.4f}')

696/696 [==============================] - 4s 5ms/step
232/232 [==============================] - 0s 1ms/step
Número de exemplos positivos do conjunto de teste = 5800
loss: 0.4591
accuracy: 0.7937
precision: 0.9087
recall: 0.8184
auc: 0.8329

precision = results[2]
recall = results[3]
F1 = 2*precision*recall/(precision + recall)
print(f'Pontuação F1 = {F1:.4f}')

Pontuação F1 = 0.8612

ConfusionMatrixDisplay.from_predictions(y_test, np.round(test_pred),
                                        normalize='true', cmap='Blues',
                                        values_format='.3f')
plt.show()

from sklearn.metrics import balanced_accuracy_score

balanced_accuracy_score(y_test, np.round(test_pred))

0.7618199352116277

fp_train, tp_train, _ = roc_curve(y_train, train_pred)
fp_test, tp_test, _ = roc_curve(y_test, test_pred)
plt.figure(figsize=(8, 6))
plt.plot(100*fp_train, 100*tp_train, 'b', label='Dados treinamento')
plt.plot(100*fp_test, 100*tp_test, 'r', label='Dados teste')
plt.xlabel('Positivos falsos [%]')
plt.ylabel('Positivos verdadeiros [%]')
plt.xlim([0,100])
plt.ylim([0,100])
plt.grid(True)
plt.legend()
plt.show()

custo_e_metricas_train = rna.evaluate(X_train, y_train)
custo_e_metricas_test = rna.evaluate(X_test, y_test)

696/696 [==============================] - 2s 3ms/step - loss: 0.4326 - accuracy: 0.8029 - precision: 0.9138 - recall: 0.8259 - auc: 0.8583
232/232 [==============================] - 0s 2ms/step - loss: 0.4591 - accuracy: 0.7937 - precision: 0.9087 - recall: 0.8184 - auc: 0.8329