Proyecto: Predecir Enfermedades del Corazón en Sudáfrica

Una de las mejores formar para poner en práctica nuestros conocimientos de Inteligencia Artificial y, en especial, de Machine Learning, es desarrollando proyectos por nuestra cuenta. De esta forma practicamos no solamente la parte teórica de los algoritmos de Machine Learning sino también mejoramos nuestras habilidades de programación, en este caso de Python. Adicional a todo esto, y algo fundamental es que cada uno de estos proyectos que desarrollamos practicando nuestros conocimientos pueden servir para ingresarlos a nuestro portafolio de Machine Learning el cual podemos mostrar al momento de buscar trabajo dentro de esta área.

Por esta razón acá te traigo un proyecto en donde desarrollaremos un modelo para predecir si una persona puede sufrir una enfermedad en el corazón.

En una región de Sudáfrica, los hombres de esa comunidad tienen un alto riesgo de padecer enfermedades cardíaca. Por tal motivo se han tomado algunos datos médicos y de acuerdo a estos se han determinado si es posible padecer la enfermedad o no.

El link para descargar los datos es el siguiente: https://www.openml.org/d/1498

Los atributos que contiene este conjunto de datos son los siguientes:

Sbp: que se refiere a la presión arterial sistólica

Tabaco: la acumulación en kg de tabaco dentro de su organismo

Ldl: proteína de baja densidad del colesterol

Adiposity

Antecedentes familiares de padecer alguna enfermedad cardíaca

Comportamiento Tipo-A

Obesidad

Consumo recurrente de alcohol

Enfermedad cardíaca

Recuerda que estos son términos médicos, por lo que es muy probable que no entiendas la mayoría de ellos. Lo que sí debes saber es que la última columna será nuestros datos objetivos, es decir esos serán los datos que vamos a predecir.

Entonces comencemos a desarrollar el programa.

Lo primero será importar la librería básica que vamos a utilizar, Pandas para manejar los datos.

### IMPORTAR LIBRERÍAS ###
import pandas as pd

Seguidamente importamos los datos. Este es el mismo procedimiento que realizamos siempre, utilizamos read_csv y colocamos el nombre exacto del archivo junto a su extensión, todo esto debe estar entre comillas.

### IMPORTAR LOS DATOS ###
data = pd.read_csv('phpgNaXZe.csv')
data.head()

Si imprimimos los datos que acabamos de exportar podemos observar que los nombres de las columnas se refieren a una númeración V1 hasta V9. Por esta razón es conveniente cambiar estos nombres por los reales de cada columna. Esta información la obtenemos directamente de la página donde descargamos los datos.

Por lo tanto, definimos la variable columnas y colocamos los nuevos nombres. Debes tener cuidado en el orden que escribes cada nombre, este orden debe coincidir con el orden de las columnas dispuestas.

Ahora agregamos estos nombres a nuestros datos, para ello nos valemos de la instrucción “columns” que nos proporciona Panda para realizar este cambio.

#Colocar nombres a las columnas
columnas = ['sbp','Tabaco','ldl','Adiposity','Familia','Tipo','Obesidad','Alcohol','Edad','chd']
data.columns=columnas
data.head()

Imprimamos el resultado final. Como puedes ver ahora nuestros datos tienen los nombres respectivos para cada una de las columnas.

Continuemos con el análisis de los datos.

Lo primero es verificar el formato que contiene nuestros datos, para ello implementamos la instrucción dtypes.

#Conocer el formato de los datos
data.dtypes

Como podemos observar los datos son enteros y flotantes, por lo que no es necesario realizar un procesamiento mayor en cuanto al tipo de datos.

Posteriormente verificamos si se cuentan con datos perdidos. Para esto nos apoyamos de la instrucción isnull y sumamos los resultados. De acuerdo a los resultados obtenidos no se cuentan con ningún dato perdido.

#Conocer los datos nulos
data.isnull().sum()

Según el análisis de datos realizado podemos determinar que no existe tanto trabajo para el procesamiento de los datos. Pero, esto no es tan cierto. Ya que si detallas los datos podrás observar de dos detalles.

El primero es que las columnas “familia” y “chd”, los datos son 1 y 2, esto lo podemos cambiar por 0 y 1.

A su vez si observas los valores de la columna “sbp” podrás ver que están en una escala mucho mayor a diferencia de las otras columnas. Por tal motivo debemos ajustar esta escala para obtener un mejor resultado.

De acuerdo a esto, realicemos el procesamiento de los datos.

Lo primero que haremos es corregir los valores de las columnas “familia” y “chd”. Para este propósito sklearn y, más específicamente, preprocessing importamos labelencoder. Esta función se trata de codificar los datos de una etiqueta y nos facilita enormemente el trabajo.

Importado esto procedemos a utilizarlos.

Definimos la variable “encoder” como la función “LabelEncoder” y la implementamos sobre las columnas que queremos transformar, utilizando la instrucción fit_transform.

#Cambiar los datos de Familia y CHD en digitales
from sklearn.preprocessing import LabelEncoder

encoder = LabelEncoder()
data['Familia']=encoder.fit_transform(data['Familia'])
data['chd']=encoder.fit_transform(data['chd'])
data.head()

Veamos como quedaron ambas columnas.

Donde anteriormente había un 2 ahora hay un 1 y donde había un 1 ahora ese valor es 0. Eso era justamente lo que esperábamos.

Ahora procedemos a escalar los valores de la columna “sbp”.

Para esto volvemos a utilizar la librería sklearn preprocessing e importamos MinMaxScaler. Con esta función podemos establecer un rango mínimo y máximo para los valores definidos y los transforma en ese rango.

El siguiente paso es el de definir los rangos que vamos a implementar, por lo tanto los definimos entre 0 y 100, es decir los valores dentro de la columna “sbp” estarán dentro de la escala de 0 y 100.

Ahora implementamos la función definida sobre la columna que queremos escalar e imprimimos los resultados.

#Escalamos los valores de la columna sbp
from sklearn.preprocessing import MinMaxScaler
scale = MinMaxScaler(feature_range =(0,100))
data['sbp'] = scale.fit_transform(data['sbp'].values.reshape(-1,1))
data.head()

Como puedes observar los nuevos valores ahora se encuentran entre un rango de 0 y 100 y ninguno de ellos supera estos valores.

Perfecto, ahora si tenemos nuestros datos listos para poder utilizarlos dentro de los algoritmos de Machine Learning. Pero antes de implementar este procedimiento visualizamos los datos.

Para esto realizaremos varias gráficas con los datos disponibles.

Lo primero que graficaremos será la obesidad de acuerdo a la edad. En este caso utilizaremos un código sencillo para realizar la gráfica. Simplemente indicamos el conjunto de datos punto plot y definimos los valores que se graficaran en los ejes “x” y “y”, el tipo de gráfica será de dispersión o scatter y el tamaño de la figura. Listo, con este código sencillo podemos realizar una gráfica.

#Visualizar la obesidad de acuerdo a la edad
data.plot(x='Edad',y='Obesidad',kind='scatter',figsize =(10,5))

Veamos los datos graficados.

Según esta información a medida que se aumenta de edad aumenta la obesidad en la persona. Solamente hay casos aislado cuando esto no sucede.

Grafiquemos ahora el consumo del tabaco de acuerdo a la edad. El código a utilizar será exactamente el mismo que se explico anteriormente.

#Visualizar el consumo de tabaco de acuerdo a la edad
data.plot(x='Edad',y='Tabaco',kind='scatter',figsize =(10,5))

Veamos el gráfico obtenido.

Acá podemos ver más claramente que a medida que aumenta la edad aumenta significativamente el consumo de tabaco. Datos que en ocasiones pensaríamos que es al contrario, pero con esta información podemos ver que no es así.

Finalmente grafiquemos el consumo de alcohol de acuerdo a la edad. Acá volvemos a implementar el mismo código explicado previamente.

#Visualizar el consumo de alcohol de acuerdo a la edad
data.plot(x='Edad',y='Alcohol',kind='scatter',figsize =(10,5))

El resultado obtenido se puede determinar que el consumo de alcohol se empieza a partir de los 20 años y se mantiene a lo largo de los años.

Se pueden crear muchas más gráficas con los datos que tenemos disponibles, te recomiendo que practiques esto por tu cuenta, de esta forma mejoras tus habilidades en el desarrollo de visualizaciones de datos.

Ahora si, construyamos el modelo de Machine Learning.

Lo primero será importar las librerías que utilizaremos para construir y probar el modelo.

La primera librería será train_test_split que la utilizaremos para separar los datos de entrenamiento y prueba.

Importamos el algoritmo a utilizar que será SVM o máquinas de vectores de soporte. Recuerda que este es un problema de clasificación, acá queremos predecir de que si existe alguna enfermedad de corazón o no.

Por último importamos las funciones para evaluar el modelo que obtengamos. La primera será la matriz de confusión y también importamos las funciones de exactitud y precisión del modelo.

### ANÁLISIS DE MACHINE LEARNING ###
from sklearn.model_selection import train_test_split
from sklearn import svm
from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score, precision_score

Realizado esto, procedemos a definir las variables dependientes e independientes.

Para “y” será igual a la columna “chd”, mientras que “X” será igual al resto de valores de nuestro conjunto de datos.

#Definir las variable dependiente e independientes
y = data['chd']
X = data.drop('chd', axis =1)

Separamos los datos de entrenamiento y prueba, utilizando la instrucción train_test_split.

#Separar los datos de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20, random_state=1)

Definimos el algoritmo a utilizar, que como se indicó anteriormente será el de Máquinas Vectores de Soporte, junto a un kernel lineal. En caso de que no entiendas que es un kernel te recomiendo que revises la información que tengo publicada al respecto en donde explico toda esto.

#Definir el algoritmo
algoritmo = svm.SVC(kernel ='linear')

Entrenamos el modelo junto con los datos de entrenamiento que separamos previamente.

#Entrenar el algoritmo
algoritmo.fit(X_train, y_train)

Y finalmente realizamos una predicción junto con el modelo obtenido y los datos de prueba.

#Realizar una predicción
y_test_pred = algoritmo.predict(X_test)

Veamos que tan bien es el modelo obtenido, para esto utilizamos las métricas que importamos previamente.

La primera a evaluar será la matriz de confusión.

#Se calcula la matriz de confusión
print(confusion_matrix(y_test, y_test_pred))

Los valores obtenidos es el de 67 datos correctos y 26 datos incorrectos. Recuerda que en la diagonal principal se muestran los valores predichos correctamente mientras que en la diagonal secundario están representado los datos erróneos. En caso de que no entiendas esto, puedes revisar la información de la matrices de confusión que fue publicada en el blog.

Con esto podemos ya decir que el modelo no acerto correctamente un gran número de datos. Pero veamos la precisión y la exactitud del mismo.

#Se calcula la exactitud y precisión del modelo
accuracy_score(y_test, y_test_pred)
precision_score(y_test, y_test_pred)

Implementando las funciones importadas anteriormente de la librería metrics de sklearn podemos decir que la exactitud del modelo es de 0,72 mientras que la precisión es de 0,526. Recuerda que ambos valores se refieren a dos términos completamente distintos y que fueron explicados en la información publicada de la métricas de los algoritmos de clasificación.

La información obtenida acá reafirma lo obtenido en la matriz de confusión.

Te recomiendo que por tu cuenta realices mejoras al calculo del modelo, algunos cosas que puedes hacer es probar con varios algoritmos de clasificación y ver si se mejora los datos obtenidos. También puedes probar seleccionando las características más significativa y verificar los resultados.

Recuerda que para mejorar en el área de Machine Learning debes realizar proyectos por tu cuenta o inclusive mejorar los que ya están publicados, de esta forma mejorarás las habilidades dentro de este campo.

En caso de que te haya gustado este proyecto y quieras seguir desarrollando proyectos de este tipo e inclusivo más complicado que estos, tengo un curso en donde realizo 5 ejercicios prácticos de Machine Learning en donde puedes poner en práctica tus conocimientos y desarrollar junto a mi estos ejercicios.

En todos los ejercicios se tomaron datos de la vida real y se explica paso a paso el desarrollo de ellos Si quieres más información sobre este curso puedes ingresar al link de la descripción.

Adicionalmente te recomiendo que te suscribas al blog y al canal para que no te pierdas de ningún video de esta serie, acá también podrás encontrar bastante información técnica gratis que te serán de bastante ayuda para tu aprendizaje.