Principais projetos de previsão de doenças cardíacas em 2022

Bem-vindo a este tutorial passo a passo do nosso projeto de previsão de doenças cardíacas. Aqui, você criará um modelo de aprendizado de máquina que prevê se um paciente pode ser diagnosticado com doença cardíaca ou não.

Você deve estar familiarizado com os conceitos básicos de aprendizado de máquina e análise de dados para trabalhar neste projeto. Este projeto exige que você esteja familiarizado com vários algoritmos de ML, incluindo Random Forest, K-NN (K-neest neighbor) e muitos outros.

Faremos a organização de dados, filtragem e testaremos seis algoritmos de ML diferentes para descobrir qual deles oferece os melhores resultados para nosso conjunto de dados. Vamos começar:

O objetivo do projeto de previsão de doenças cardíacas

O objetivo do nosso projeto de previsão de doenças cardíacas é determinar se um paciente deve ser diagnosticado com doença cardíaca ou não, que é um resultado binário, portanto:

Resultado positivo = 1, o paciente será diagnosticado com cardiopatia.

Resultado negativo = 0, o paciente não será diagnosticado com cardiopatia.

Temos que descobrir qual modelo de classificação tem a maior precisão e identificar correlações em nossos dados. Finalmente, também temos que determinar quais características são as mais influentes em nosso diagnóstico de doença cardíaca.

Recursos

Usamos os seguintes 13 recursos (X) para determinar nosso preditor (Y):

1. Idade.
2. Sexo: 1 = Masculino, 0 = Feminino.
3. (cp) tipo de dor torácica (4 valores – Ordinal), 1º valor: angina típica, 2º valor: angina atípica, 3º valor: dor não anginosa, 4º valor: assintomática.
4. (trestbps) pressão arterial em repouso.
5. (col) colesterol sérico.
6. (Fbs) – glicemia de jejum > 120 mg/dl.
7. (restecg) – resultados do eletrocardiograma de repouso.
8. (talach) – frequência cardíaca máxima atingida.
9. (exang) – angina induzida pelo exercício.
10. (pico antigo) – depressão do segmento ST causada pelo exercício em relação ao repouso.
11. (inclinação) – a inclinação do segmento ST do exercício de pico.
12. (ca) – o número de vasos principais coloridos por fluoroscopia.
13. (thal) – frequência cardíaca máxima atingida (Ordinal), 3 = normal, 6 = defeito fixo, 7 = defeito reversível.

Etapa 1: disputa de dados

Primeiro, veremos o conjunto de dados com o qual estamos trabalhando, convertendo-o em um formato mais simples e compreensível. Isso nos ajudaria a usar os dados de forma mais adequada.

importar numpy como np

importar pandas como pd

importar matplotlib como plt

importar seaborn como sns

importar matplotlib.pyplot como plt

filePath = '/Users/upgrad/Downloads/datasets-33180-43520-heart.csv'

dados = pd.read_csv(filePath)

data.head(5)

Assim como o código acima nos ajudou a exibir nossos dados em forma de tabela, usaremos o seguinte código para mais organização de dados:

print(“(Linhas, colunas): ” + str(data.shape))

dados.colunas

O código acima mostrará o número total de linhas e colunas e os nomes das colunas em nosso conjunto de dados. O número total de linhas e colunas em nossos dados é 303 e 14, respectivamente. Agora vamos encontrar o número de valores únicos para cada variável usando a seguinte função:

data.nunique(eixo=0

Da mesma forma, a seguinte função resume a média, contagem, desvio padrão, mínimo e máximo para as variáveis ​​numéricas:

dados.descrever()

Etapa 2: Conduzindo a EDA

Agora que concluímos a disputa de dados, podemos realizar uma análise exploratória de dados. Aqui estão as principais tarefas que realizaremos nesta etapa do nosso projeto de previsão de doenças cardíacas:

Encontrando correlações

Vamos criar uma matriz de correlação que nos ajuda a ver as correlações entre diferentes variáveis:

corr = data.corr()

plt.subplots(figsize=(15,10))

sns.heatmap(corr, xticklabels=corr.columns, yticklabels=corr.columns, annot=True, cmap=sns.diverging_palette(220, 20, as_cmap=True))

sns.heatmap(corr, xticklabels=corr.columns,

yticklabels=corr.columns,

annot=Verdadeiro,

cmap=sns.diverging_palette(220, 20, as_cmap=True))

Para encontrar correlações imediatas entre os recursos, também podemos criar diagramas de pares. Usaremos pequenos diagramas de pares com apenas as variáveis ​​contínuas para aprofundar os relacionamentos:

subData = data[['idade','trestbps','chol','thalach','oldpeak']]

sns.pairplot(subData)

Usando Violino e Box Plots

Com os gráficos de violino e caixa, podemos ver as estatísticas básicas e a distribuição de nossos dados. Você pode usá-lo para comparar a distribuição de uma variável específica em diferentes categorias. Isso também nos ajudará a identificar discrepâncias nos dados. Utilize o seguinte código:

plt.figura(figsize=(12,8))

sns.violinplot(x= 'target', y= 'oldpeak',hue=”sex”, inner='quartil',data= data )

plt.title(“Nível de Thalach vs. Doença Cardíaca”,fontsize=20)

plt.xlabel(“Alvo da Doença Cardíaca”, fontsize=16)

plt.ylabel(“Nível Thalach”, fontsize=16)

No primeiro Violin and Box plot, descobrimos que os pacientes positivos têm uma mediana mais baixa para depressão do segmento ST do que os pacientes negativos. Então, vamos usar um gráfico para comparar o nível de depressão ST e doença cardíaca.

plt.figura(figsize=(12,8))

sns.boxplot(x= 'alvo', y= 'talach', matiz=”sexo”, dados=dados)

plt.title(“Nível de depressão ST vs. Doença cardíaca”, fontsize=20)

plt.xlabel(“Alvo de doença cardíaca”,fontsize=16)

plt.ylabel(“Depressão do segmento ST induzida pelo exercício em relação ao repouso”, fontsize=16)

Aqui, os pacientes positivos tiveram uma mediana maior para o nível de depressão do segmento ST em comparação aos pacientes negativos.

Filtrando dados

Agora vamos filtrar os dados de acordo com pacientes com doenças cardíacas positivas e negativas. Começaremos com a filtragem de dados por pacientes com doença cardíaca positiva:

pos_data = data[data['target']==1]

pos_data.describe()

Da mesma forma, filtraremos os dados de acordo com pacientes com doenças cardíacas negativas:

pos_data = data[data['target']==0]

pos_data.describe()

Etapa 3: usando algoritmos de aprendizado de máquina

Preparação

Aqui, prepararemos os dados para treinamento atribuindo os recursos a X e a última coluna ao preditor Y:

X = data.iloc[:, :-1].values

Y = data.iloc[:, -1}.values

Em seguida, dividiremos os dados em dois conjuntos, conjunto de treinamento e conjunto de teste:

de sklearn.model_selection importar train_test_split

x_train, x_test, y_train, y_test = train_test_split(X,y,test_size = 0,2, random_state = 1)

Por fim, normalizaremos os dados para que sua distribuição tenha uma média de 0:

de sklearn.preprocessing importação StandardScaler

sc = StandardScaler()

x_train = sc.fit_transform(x_train)

x_test = sc.transform(x_test)

Treinando o Modelo

Nesta seção, usaremos vários algoritmos de aprendizado de máquina e encontraremos aquele que oferece a maior precisão:

1º Modelo: Regressão Logística

de sklearn.metrics importar classificação_report

de sklearn.linear_model importar LogisticRegression

model1 = LogisticRegression(random_state=1) # obtém a instância do modelo

model1.fit(x_train, y_train) # Treinar/ajustar modelo

y_pred1 = model1.predict(x_test) # obtém y previsões

print(classification_report(y_test, y_pred1)) # precisão de saída

A precisão deste modelo foi de 74%.

2º Modelo: K-NN (K-Vizinhos Mais Próximos)

de sklearn.metrics importar classificação_report

de sklearn.neighbours importar KNeighboursClassifier

model2 = KNeighboursClassifier() # obtém a instância do modelo

model2.fit(x_train, y_train) # Treinar/ajustar modelo

y_pred2 = model2.predict(x_test) # obtém y previsões

print(classification_report(y_test, y_pred2)) # precisão de saída

A precisão deste modelo foi de 75%.

3º Modelo: Máquina de vetores de suporte (SVM)

de sklearn.metrics importar classificação_report

de sklearn.svm importar SVC

model3 = SVC(random_state=1) # obtém a instância do modelo

model3.fit(x_train, y_train) # Treinar/ajustar modelo

y_pred3 = model3.predict(x_test) # obtém y previsões

print(classification_report(y_test, y_pred3)) # precisão de saída

A precisão deste modelo foi de 75%.

4º Modelo: Classificador Naive Bayes

de sklearn.metrics importar classificação_report

de sklearn.naive_bayes importar GaussianNB

model4 = GaussianNB() # obtém instância do modelo

model4.fit(x_train, y_train) # Treinar/ajustar modelo

y_pred4 = model4.predict(x_test) # obtém y previsões

print(classification_report(y_test, y_pred4)) # precisão da saída

A precisão deste modelo foi de 77%.

5º Modelo: Floresta Aleatória

de sklearn.metrics importar classificação_report

de sklearn.ensemble importar RandomForestClassifier

model6 = RandomForestClassifier(random_state=1)# obtém instância do modelo

model6.fit(x_train, y_train) # Treinar/ajustar modelo

y_pred6 = model6.predict(x_test) # obtém y previsões

print(classification_report(y_test, y_pred6)) # precisão da saída

Este modelo teve a maior precisão de 80%.

6º Modelo: XGBoost

de xgboost importar XGBClassifier

model7 = XGBClassifier(random_state=1)

model7.fit(x_train, y_train)

y_pred7 = model7.predict(x_test)

print(classification_report(y_test, y_pred7))

A precisão deste modelo foi de 69%.

Depois de testar diferentes algoritmos de ML, descobrimos que o melhor foi o Random Forest, pois nos deu a precisão ideal de 80%.

Tenha em mente que qualquer porcentagem de precisão superior a 80% é boa demais para ser verdade, e pode ser por causa do overfitting. É por isso que 80% é o número ideal para alcançar.

Etapa 4: Encontrando a pontuação do recurso

Aqui, encontraremos o Feature Score, que nos ajuda a tomar decisões importantes, informando qual recurso foi o mais útil para nosso modelo:

# ganha importância

importância = model6.feature_importances_

# resumir a importância do recurso

para i,v em enumerate(importância):

print('Recurso: %0d, Pontuação: %.5f' % (i,v))

Descobrimos que as quatro principais características foram tipo de dor no peito (cp), frequência cardíaca máxima alcançada (talach), número de vasos principais (ca) e depressão do segmento ST causada pelo exercício em relação ao repouso (antigo pico).

Conclusão

Parabéns, você concluiu com sucesso o projeto de previsão de doenças cardíacas. Tínhamos 13 características, das quais descobrimos que as mais importantes foram o tipo de dor no peito e a frequência cardíaca máxima alcançada.

Testamos seis algoritmos de ML diferentes e descobrimos que o algoritmo mais preciso era o Random Forest. Você deve testar esse modelo com o conjunto de testes e ver como esse modelo funciona.

Por outro lado, se você quiser saber mais sobre machine learning e IA, recomendamos conferir nossos cursos de IA . Você estudará diretamente com especialistas do setor e trabalhará em projetos do setor que permitem testar seus conhecimentos. Confira-os se estiver interessado em uma carreira em aprendizado de máquina e IA.

Se você estiver interessado em aprender mais sobre aprendizado de máquina, confira o Programa PG Executivo do IIIT-B e do upGrad em Machine Learning e IA, projetado para profissionais que trabalham e oferece mais de 450 horas de treinamento rigoroso, mais de 30 estudos de caso e atribuições, IIIT -B Alumni status, mais de 5 projetos práticos práticos e assistência de trabalho com as principais empresas.