O infarto do miocárdio, ou ataque cardíaco, é a morte das células de uma região do músculo do coração por conta da formação de um coágulo que interrompe o fluxo sanguíneo de forma súbita e intensa.

Fonte: ALVES, B. / O. / O.-M. Ataque cardíaco (infarto) | Biblioteca Virtual em Saúde MS. Disponível em: https://bvsms.saude.gov.br/ataque-cardiaco-infarto/#:~:text=O%20infarto%20do%20mioc%C3%A1rdio%2C%20ou.

Prever uma possível doença cardíaca com base no histórico dos pacientes é ajudar a pessoa se cuidar antes de ter um sintoma, ou adoecer com sequelas. Analisar dados de saúde é uma ação bastante delicada, não podemos expor os pacientes de nenhuma forma, além de algumas vezes ser preciso um especialista para ajudar essa interpretação de forma mais eficaz.

Como de costume, os exemplos desse post estão no colab.

Nesse post iremos realizar o treinamento com os algoritmos: Support Vector Machine
(SVM), Random Forest (RF), Logistic Regress (LR), K-Nearest Neighbor (KNN), Decision Tree (DT). Alguns algoritmos foram executados com diferentes parâmetros para chegar em uma configuração com uma boa acurácia.

Sobre o dataset

A base de dados que vamos usar nessa abordagem esta disponível em: https://www.kaggle.com/datasets/johnsmith88/heart-disease-dataset com os seguintes dados:

Pré processamento

Removendo duplicados

Existem 1025 instâncias nesse dataset, após usar a lib profile-report foi identificado várias instâncias repetidas. Instancias repetidas pode gerar um vício no algoritmo, ja que ele não irá predizer, e sim replicar um dado visto anteriormente. Removido, usando a função do pandas drop_duplicates().

Removendo outliers

Gerando uma visualização com bloxPlot, percebemos que existem outliers, e foi usado o Intervalo Interquartil para remove-los. Essa técnica foi comentado em outro post. Consulte aqui.

Treinando os modelos

Base de testes:

É muito importante separar a base em treino e teste. Para que um dado que esteja no treino, não esteja no teste. O scikit-learn, tem uma função que realiza isso:

y = df["target"]
X = df.drop('target',axis=1)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state = 0)

Decision Tree:

Esse algoritmo ja foi mencionado em outro post ( consulte aqui ). Basicamente, cada bifurcação é uma decisão, e vão sendo feitas, chamadas de nó, até chegar em uma folha, que é a decisão propriamente dita.

rf = RandomForestClassifier(n_estimators=20, random_state=12,max_depth=5)
rf.fit(X_train,y_train)
rf_predicted = rf.predict(X_test)
rf_conf_matrix = confusion_matrix(y_test, rf_predicted)
rf_acc_score = accuracy_score(y_test, rf_predicted)
print("confussion matrix")
print(rf_conf_matrix)
print("\n")
print("Accuracy of Random Forest:",rf_acc_score*100,'%\n')
print(classification_report(y_test,rf_predicted))

Accuracy of Random Forest: 84.78260869565217 %

Random Forest
Tem uma grande semelhança com o Decision Tree, a diferença é que de forma automatica, se realiza várias árvores, fazendo uma floresta. É uma ótima técnica quando se tem uma grande quantidade de dados e features.

rf = RandomForestClassifier(n_estimators=20, random_state=12,max_depth=5)
rf.fit(X_train,y_train)
rf_predicted = rf.predict(X_test)
rf_conf_matrix = confusion_matrix(y_test, rf_predicted)
rf_acc_score = accuracy_score(y_test, rf_predicted)
print("confussion matrix")
print(rf_conf_matrix)
print("\n")
print("Accuracy of Random Forest:",rf_acc_score*100,'%\n')
print(classification_report(y_test,rf_predicted))

Accuracy of Random Forest: 84.78260869565217 %

Interessante ressaltar, que ficou com o mesmo valor que a decision tree.

Decidi então realizar variações nas árvores de decisões, principalmente no critério de classificação e na profundidade máxima.

Através de medições de quanto uma instancia pertence a uma classe, o gini faz suas decisões, ja o entropy, além disso observa também a desordem dos outros dados.

k_range = range(1,11)
scores = {}

for k in k_range:
  dtFor = DecisionTreeClassifier(criterion = 'entropy',random_state=0,max_depth = k)
  dtFor.fit(X_train, y_train)
  y_pred = dtFor.predict(X_test)
  scores[k] = accuracy_score(y_test,y_pred)
plt.plot(k_range,list(scores.values()), label='entropy')
for k in k_range:
  dtFor = DecisionTreeClassifier(criterion = 'gini',random_state=0,max_depth = k)
  dtFor.fit(X_train, y_train)
  y_pred = dtFor.predict(X_test)
  scores[k] = accuracy_score(y_test,y_pred)
plt.plot(k_range,list(scores.values()), label='gini')
plt.xlabel('Profundidade da Árvore')
plt.ylabel('% de Acurácia')
plt.legend()

Conseguimos ver um gráfico, que inicia com uma ótima acurácia:

Quando exibimos a árvore visual com apenas 1 nível de profundidade, percebemos que só se observa a feature thal, que é a referente a dor no peito, algo muito previsível, provavelmente quem vai ao hospital, a chance de possuir alguma dor, é bastante alta, o ideal era observar outras features.

O segundo valor com uma boa acurácia, é o 3 profundidades, e ao plotar de forma visual, percebemos que existem outras observações.

K-NeighborsClassifier

Esse algoritmo analisa os vizinhos para tomar sua decisão e agrupar os dados. Possui algumas métricas, e podemos varias a quantidade de vizinhos analisados. No estudo foi usado euclidean e Manhattan, varias de 1 a 4 vizinhos, obtendo os seguintes níveis de acurácia.

Então, usando 3 vizinhos e métrica manhattan, obtemos 71% de acurácia.

knn = KNeighborsClassifier(n_neighbors=3, metric='manhattan')
knn.fit(X_train, y_train)
knn_predicted = knn.predict(X_test)
knn_conf_matrix = confusion_matrix(y_test, knn_predicted)
knn_acc_score_1_neighbors = accuracy_score(y_test, knn_predicted)
print("confussion matrix")
print(knn_conf_matrix)
print("\n")
print("Accuracy of K-NeighborsClassifier:",knn_acc_score_1_neighbors*100,'%\n')
print(classification_report(y_test,knn_predicted))

Accuracy of K-NeighborsClassifier: 71.73913043478261 %

Support Vector Classifier

svc =  SVC(kernel='rbf', C=2)
svc.fit(X_train, y_train)
svc_predicted = svc.predict(X_test)
svc_conf_matrix = confusion_matrix(y_test, svc_predicted)
svc_acc_score = accuracy_score(y_test, svc_predicted)
print("confussion matrix")
print(svc_conf_matrix)
print("\n")
print("Accuracy of Support Vector Classifier:",svc_acc_score*100,'%\n')
print(classification_report(y_test,svc_predicted))

Accuracy of Support Vector Classifier: 71.73913043478261 %

Logistic Regression

from sklearn.linear_model import  LogisticRegression
reg = LogisticRegression( )
reg.fit(X_train, y_train)
reg_predicted = reg.predict(X_test)
reg_conf_matrix = confusion_matrix(y_test, reg_predicted)
reg_acc_score = accuracy_score(y_test, reg_predicted)
print("confussion matrix")
print(reg_conf_matrix)
print("\n")
print("Accuracy of Support Vector Classifier:",reg_acc_score*100,'%\n')
print(classification_report(y_test,reg_predicted))

Accuracy of Support Vector Classifier: 91.30434782608695 %

Comparação dos resultados

Random Forest 84.7826091%

K-Nearest Neighbour (10) 60.8695652%

K-Nearest Neighbour (3) 71.7391303%

Decision Tree 84.7826094%

Support Vector Machine 71.7391305%

Logistic Regression 91.304348%

Pela característica do problema, o modelo de regressão logistica tem um resultado melhor.

Observações sobre o estudo:

Esse trabalho foi apresentado na disciplina de Aprendizagem de máquina e produzido artigo. Junto do meu colega Gerfesson. Obtivemos nota máxima.

Usamos também com referência diversos outros estudos, mas o principal foi esse, e fica a recomendação de leitura:

K. Rashid, M. A. Islam, R. A. Tanzin, M. L. Labib, and M. Khan, “Heart disease pre- diction using interquartile range preprocessing and hypertuned machine learning,” in 2022 4th International Conference on Inventive Research in Computing Applications (ICIRCA), IEEE, Sept. 2022.

O post Aplicando Machine Learning no dataset sobre Doenças cardíacas apareceu primeiro em Ramon Domingos Blog.

Como de costume, todo os exemplos estão no colab.

Vamos iniciar importando as nossas bibliotecas, iniciando nosso Toy Dataset Iris e transformando num dataframe do pandas.

import pandas as pd
from sklearn.datasets import load_iris
data = load_iris()
iris = pd.DataFrame(data.data)
iris.columns = data.feature_names
iris['target'] = data.target
iris.head()

Para ser mais didático, e melhorar a compreensão, vamos iniciar o nosso estudo, apenas com 2 features referente a pétalas, para conseguirmos visualizar em um plano cartesiano. Em seguida adicionamos todos os campos.

irisCopy = iris.loc[iris.target.isin([1,2]), ['petal length (cm)','petal width (cm)' , 'target']]
# separa em x e y
x = irisCopy.drop( 'target', axis=1)
y = irisCopy.target

Como temos uma dataset bem grande, conseguimos dividi-lo em duas base, treino e teste. Vamos fazer isso usando o `train_test_split`.

from sklearn.model_selection import train_test_split
x_train, x_teste, y_train, y_test = train_test_split( x, y , test_size=0.30, random_state=22)

Temos nossa base de teste e treino, agora vamos criar nosso classificador, usando nossa base de treino.

from sklearn import tree
import matplotlib.pyplot as plt

clf =  tree.DecisionTreeClassifier(random_state=22)
clf = clf.fit(x_train, y_train)
fig, ax = plt.subplots(figsize=(10,8))

tree.plot_tree(clf)
plt.show()

Obtemos essa árvore:

Agora, vamos analisar cada nó, as decisões que estao sendo analisadas, e baseado nisso, vamos traças linhas em um gráfico, para identificar como estão sendo feito cada decisão:

• x[0] < 4.75
• x[0] < 5.05
• x[1] < 1.65 ( nesse caso x[1], é o Y )
• x[1] < 1.6
• x[0] < 4.85

fig, ax = plt.subplots()
ax.scatter(
    x_train['petal length (cm)'],
    x_train['petal width (cm)'],
    c=y_train
)

ax.plot([4.75,4.75], [0,3], '--r') # primeiro nó
ax.plot([2,4.75],[1.65,1.65], '--r') # segundo nó
ax.plot([5.05,5.05], [3,0], '--r') # terceiro nó
ax.plot([4.75,5.05],[1.6,1.6], '--r') # quarto nó
ax.plot([4.75,5.05],[1.75,1.75], '--r') # quinto nó
ax.plot([4.85,4.85], [1.75,3], '--r') # sexto nó

ax.set( xlim=(3, 7), xticks=[2,3,4,5,6,7], ylim=(0.9,2.7), yticks=[1,1.5,2,2.5])
plt.show()

Conseguimos ver as seguintes linhas:

Dessa forma, podemos ver quais decisões foram tomadas pelo software. Agora, podemos evoluir, deixar de ser apenas 2 escolhas, e colocar para o algoritmo treinar todas as escolhas possíveis, ver a árvore ainda maior.

x_train, x_teste, y_train, y_test = train_test_split( iris.drop( 'target', axis=1), iris.target , test_size=0.20, random_state=10)

clf2 =  tree.DecisionTreeClassifier(random_state=22).fit(x_train, y_train)

fig, ax = plt.subplots(figsize=(10,8))

tree.plot_tree(clf2)
plt.show()

Agora, vamos avaliar nosso modelo, qual o score que ele possui:

clf2.score(x_train, y_train)
# 1

Um excelente aprendizado, nota máxima. Mas essa não é a única maneira de se avaliar um modelo. Existem outras métricas, que veremos em outro post.

O post Aplicando Árvore de decisão no dataset Íris apareceu primeiro em Ramon Domingos Blog.

Neste post vamos utilizar uma situação simples, com poucos nós. Para entendermos como ele funciona, e em quais situações ele é uma boa escolha, no próximo post utilizaremos datasets maiores, com mais decisões, além de Sim/Não.

No geral esse algoritmo busca classificar um registro ( problemas de classificação) ou estimar um valor ( problemas de regressão). Como vemos nessa imagem , cada pergunta, chamadas de nó decisão, respondemos SIM ou NÃO, a primeira pergunta, o nó inicial é o nó raiz e o último, com a resposta, é o nó folha. Em inglês, Decision node, Chance node, Endpoint Node.

Mas como sair de uma simplesmente diagramação visual e chegar num modelo?

O sckit-learn faz esse treinamento, além de exibir uma representação visual das decisões como essa:

Preparei um colab com esses exemplos que teremos nesse post.

Inicialmente, preparei um array, usando numPy, baseado nessa situação, e exibir a tabela

import pandas as pd
import numpy as np
# Criando um array de resultados
numpy_array = np.array([
[True,True,False,False,False], [False,False,False,False,False],
[True,False,True,False,True], [True,False,False,True,True], 
[True,False,False,False,False]])
# Convertendo em Pandas dataFrame
df = pd.DataFrame(numpy_array, columns=['Tenho aula?', 'É Remoto', 'Vou de Carro', 'Vou de ônibus', 'target'])
df["target"] = df["target"].astype(int)
df['target_names']= pd.Categorical.from_codes (df["target"], ['Não vou', 'Vou'])
# Exibindo
df.head()

Ficou assim:

Em seguida, usando o sckitLearn para criar uma classificador, treinar o modelo e criar a árvore de decisão, em seguida apresento aquela representação gráfica. Mostrada inicialmente.

from sklearn import tree
clf = tree.DecisionTreeClassifier( random_state=42)
clf = clf.fit(dados, df.target)
tree.plot_tree(clf)

No próximo post, vamos utilizar algum Toy dataset para esse algoritmo.

O post Conceito da Árvore de decisão – Aprendizado de máquina apareceu primeiro em Ramon Domingos Blog.