Mejor proyecto de predicción de enfermedades cardíacas en 2022

Bienvenido a este tutorial paso a paso de nuestro proyecto de predicción de enfermedades del corazón. Aquí, creará un modelo de aprendizaje automático que predice si a un paciente se le puede diagnosticar una enfermedad cardíaca o no.

Debe estar familiarizado con los conceptos básicos del aprendizaje automático y el análisis de datos para trabajar en este proyecto. Este proyecto requiere que esté familiarizado con varios algoritmos de ML, incluidos Random Forest, K-NN (K-vecino más cercano) y muchos otros.

Realizaremos la disputa de datos, el filtrado y probaremos seis algoritmos de ML diferentes para encontrar cuál ofrece los resultados óptimos para nuestro conjunto de datos. Vamos a empezar:

El objetivo del Proyecto de Predicción de Enfermedades del Corazón

El objetivo de nuestro proyecto de predicción de enfermedades cardíacas es determinar si a un paciente se le debe diagnosticar una enfermedad cardíaca o no, lo cual es un resultado binario, por lo que:

Resultado positivo = 1, el paciente será diagnosticado con enfermedad cardíaca.

Resultado negativo = 0, el paciente no será diagnosticado con enfermedad cardíaca.

Tenemos que encontrar qué modelo de clasificación tiene la mayor precisión e identificar correlaciones en nuestros datos. Finalmente, también tenemos que determinar qué características son las más influyentes en nuestro diagnóstico de enfermedades del corazón.

Características

Usamos las siguientes 13 características (X) para determinar nuestro predictor (Y):

1. Años.
2. Sexo: 1 = Masculino, 0 = Femenino.
3. (cp) tipo de dolor torácico (4 valores – Ordinal), 1° valor: angina típica, 2° valor: angina atípica, 3° valor: dolor no anginoso, 4° valor: asintomático.
4. (trestbps) presión arterial en reposo.
5. (chol) colesterol sérico.
6. (Fbs) – azúcar en sangre en ayunas > 120 mg/dl.
7. (restecg) – resultados de electrocardiografía en reposo.
8. (thalach) – frecuencia cardíaca máxima alcanzada.
9. (exang) – angina inducida por el ejercicio.
10. (pico antiguo): depresión del ST causada por el ejercicio en relación con el reposo.
11. (pendiente) – la pendiente del segmento ST de ejercicio máximo.
12. (ca) – el número de vasos principales coloreados por fluoroscopia.
13. (thal) – frecuencia cardíaca máxima alcanzada (ordinal), 3 = normal, 6 = defecto fijo, 7 = defecto reversible.

Paso #1: disputa de datos

Primero veremos el conjunto de datos con el que estamos trabajando convirtiéndolo a un formato más simple y comprensible. Nos ayudaría a utilizar los datos de forma más adecuada.

importar numpy como np

importar pandas como pd

importar matplotlib como plt

importar seaborn como sns

importar matplotlib.pyplot como plt

filePath = '/Usuarios/actualizar/Descargas/conjuntos de datos-33180-43520-heart.csv'

datos = pd.read_csv(filePath)

datos.head(5)

Así como el código anterior nos ayudó a mostrar nuestros datos en forma tabular, usaremos el siguiente código para más disputas de datos:

print(“(Filas, columnas): ” + str(datos.forma))

columnas.de.datos

El código anterior mostrará el número total de filas y columnas y los nombres de las columnas en nuestro conjunto de datos. El número total de filas y columnas en nuestros datos es 303 y 14 respectivamente. Ahora encontraremos el número de valores únicos para cada variable usando la siguiente función:

datos.nunique(eje=0

De manera similar, la siguiente función resume la media, el recuento, la desviación estándar, el mínimo y el máximo de las variables numéricas:

datos.describe()

Paso #2: Realización de EDA

Ahora que hemos completado la disputa de datos, podemos realizar un análisis exploratorio de datos. Estas son las tareas principales que realizaremos en esta etapa de nuestro proyecto de predicción de enfermedades cardíacas:

Encontrar correlaciones

Crearemos una matriz de correlación que nos ayude a ver las correlaciones entre diferentes variables:

corr = datos.corr()

plt.subparcelas(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.columnas,

annot=Verdadero,

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

Para encontrar correlaciones inmediatas entre características, también podemos crear diagramas de pares. Usaremos diagramas de pares pequeños con solo las variables continuas para profundizar en las relaciones:

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

sns.pairplot(subdatos)

Uso de diagramas de violín y caja

Con los diagramas de violín y caja podemos ver las estadísticas básicas y la distribución de nuestros datos. Puede usarlo para comparar la distribución de una variable específica en diferentes categorías. También nos ayudará a identificar valores atípicos en los datos. Usa el siguiente código:

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

sns.violinplot(x= 'objetivo', y= 'pico antiguo',hue=”sexo”, interior='cuartil',datos=datos)

plt.title ("Nivel de thalach frente a enfermedad cardíaca", tamaño de fuente = 20)

plt.xlabel ("Objetivo de enfermedad cardíaca", tamaño de fuente = 16)

plt.ylabel(“Nivel de Thalach”, tamaño de fuente=16)

En el primer diagrama de violín y caja, encontramos que los pacientes positivos tienen una mediana más baja de depresión del ST que los pacientes negativos. Entonces, usaremos una gráfica para comparar el nivel de depresión del ST y la enfermedad cardíaca.

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

sns.boxplot(x= 'objetivo', y= 'thalach',hue=”sexo”, data=data )

plt.title ("Nivel de depresión del ST frente a enfermedad cardíaca", tamaño de fuente = 20)

plt.xlabel ("Objetivo de enfermedad cardíaca", tamaño de fuente = 16)

plt.ylabel(“Depresión del ST inducida por el ejercicio en relación con el descanso”, tamaño de fuente=16)

Aquí, los pacientes positivos tenían una mediana más alta para el nivel de depresión del ST en comparación con los pacientes negativos.

Filtrado de datos

Ahora filtraremos los datos según los pacientes con enfermedades cardíacas positivas y negativas. Comenzaremos con el filtrado de datos por pacientes con enfermedad cardíaca positiva:

pos_data = datos[datos['objetivo']==1]

pos_data.describe()

Del mismo modo, filtraremos los datos según los pacientes con cardiopatías negativas:

pos_data = datos[datos['objetivo']==0]

pos_data.describe()

Paso #3: Uso de algoritmos de aprendizaje automático

Preparación

Aquí, prepararemos los datos para el entrenamiento asignando las funciones a X y la última columna al predictor Y:

X = datos.iloc[:, :-1].valores

Y = datos.iloc[:, -1}.valores

Luego, dividiremos los datos en dos conjuntos, conjunto de entrenamiento y conjunto de prueba:

de sklearn.model_selection import train_test_split

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

Finalmente, normalizaremos los datos para que su distribución tenga una media de 0:

de sklearn.preprocessing importar StandardScaler

sc = escalador estándar()

tren_x = sc.fit_transform(tren_x)

x_prueba = sc.transform(x_prueba)

Entrenando al modelo

En esta sección, utilizaremos varios algoritmos de aprendizaje automático y encontraremos el que ofrezca la mayor precisión:

1er Modelo: Regresión Logística

de sklearn.metrics importar clasificación_informe

de sklearn.linear_model import LogisticRegression

model1 = LogisticRegression(random_state=1) # obtener instancia del modelo

model1.fit(x_train, y_train) # Entrenar/Ajustar modelo

y_pred1 = model1.predict(x_test) # obtener y predicciones

print(classification_report(y_test, y_pred1)) # precisión de salida

La precisión de este modelo fue del 74%.

2do modelo: K-NN (K-vecinos más cercanos)

de sklearn.metrics importar clasificación_informe

de sklearn.neighbours importar KNeighboursClassifier

model2 = KNeighboursClassifier() # obtener una instancia del modelo

model2.fit(x_train, y_train) # Entrenar/Ajustar modelo

y_pred2 = model2.predict(x_test) # obtener y predicciones

print(classification_report(y_test, y_pred2)) # precisión de salida

La precisión de este modelo fue del 75%.

3.er modelo: máquina de vectores de soporte (SVM)

de sklearn.metrics importar clasificación_informe

desde sklearn.svm importar SVC

model3 = SVC(random_state=1) # obtener instancia del modelo

model3.fit(x_train, y_train) # Entrenar/Ajustar modelo

y_pred3 = model3.predict(x_test) # obtener y predicciones

print(classification_report(y_test, y_pred3)) # precisión de salida

La precisión de este modelo fue del 75%.

4to Modelo: Clasificador Naive Bayes

de sklearn.metrics importar clasificación_informe

de sklearn.naive_bayes importar GaussianNB

model4 = GaussianNB() # obtener una instancia del modelo

model4.fit(x_train, y_train) # Entrenar/Ajustar modelo

y_pred4 = model4.predict(x_test) # obtener y predicciones

print(classification_report(y_test, y_pred4)) # precisión de salida

La precisión de este modelo fue del 77%.

5to Modelo: Bosque Aleatorio

de sklearn.metrics importar clasificación_informe

de sklearn.ensemble importar RandomForestClassifier

model6 = RandomForestClassifier(random_state=1)# obtener instancia del modelo

model6.fit(x_train, y_train) # Entrenar/Ajustar modelo

y_pred6 = model6.predict(x_test) # obtener y predicciones

print(classification_report(y_test, y_pred6)) # precisión de salida

Este modelo tuvo la mayor precisión del 80%.

Sexto modelo: XGBoost

desde xgboost importar XGBClassifier

modelo7 = XGBClassifier(random_state=1)

modelo7.fit(x_tren, y_tren)

y_pred7 = modelo7.predecir(x_prueba)

imprimir (informe_clasificación (y_test, y_pred7))

La precisión de este modelo fue del 69%.

Después de probar diferentes algoritmos de ML, descubrimos que el mejor era Random Forest, ya que nos brindaba una precisión óptima del 80 %.

Tenga en cuenta que cualquier porcentaje de precisión superior al 80 % es demasiado bueno para ser verdad y puede deberse a un sobreajuste. Es por eso que el 80% es el número óptimo a alcanzar.

Paso n.º 4: encontrar la puntuación de la función

Aquí encontraremos el Feature Score, que nos ayuda a tomar decisiones importantes al indicarnos qué función fue la más útil para nuestro modelo:

# obtener importancia

importancia = model6.feature_importances_

# resumir la importancia de la característica

para i,v en enumerar (importancia):

print('Característica: %0d, Puntuación: %.5f' % (i,v))

Encontramos que las cuatro características principales fueron el tipo de dolor torácico (cp), la frecuencia cardíaca máxima alcanzada (thalach), el número de vasos principales (ca) y la depresión del segmento ST causada por el ejercicio en relación con el reposo (pico anterior).

Conclusión

Felicitaciones, ahora ha completado con éxito el proyecto de predicción de enfermedades del corazón. Teníamos 13 características, de las cuales descubrimos que las más importantes eran el tipo de dolor en el pecho y la frecuencia cardíaca máxima alcanzada.

Probamos seis algoritmos de ML diferentes y descubrimos que el algoritmo más preciso era Random Forest. Debe probar este modelo con el conjunto de prueba y ver qué tan bien funciona este modelo.

Por otro lado, si desea obtener más información sobre el aprendizaje automático y la IA, le recomendamos consultar nuestros cursos de IA . Estudiará directamente de expertos de la industria y trabajará en proyectos de la industria que le permitirán probar su conocimiento. Échales un vistazo si estás interesado en una carrera en aprendizaje automático e IA.

Si está interesado en obtener más información sobre el aprendizaje automático, consulte el Programa PG Ejecutivo en Aprendizaje Automático e IA de IIIT-B y upGrad, que está diseñado para profesionales que trabajan y ofrece más de 450 horas de capacitación rigurosa, más de 30 estudios de casos y asignaciones, IIIT -Estado de exalumno B, más de 5 proyectos prácticos finales prácticos y asistencia laboral con las mejores empresas.