Aquí tenemos la primera lección del curso práctico de IA sin prerrequisitos. El vídeo en el que se sustenta la lección dura media hora. Es poco, pero yo recomiendo que no solo lo mireis, sino que vayáis siguiendo los pasos, replicándose y que por lo tanto lo pareis tantas veces como sea necesario. Posiblemente os lleve entre dos o tres horas el finalizar todo lo que aparece en el curso.
Tipo de proyecto: Machine Learning / Supervised Learning / Clasificación.
Crearemos un modelo capaz de diagnosticar diabetes basándose en los datos de pacientes que tenemos en un .csv.
Instalar el entorno de Machine Learning y solucionar nuestro primer problema de clasificación con supervised learning.
Empezamos con la instalación de Miniconda. Es un gestor de paquetes de software de IA y de entornos. Nos permite instalar las librerías o herramientas necesarias. Empezamos instalando Jupyter, scikit-learn, numpy, pandas y matplotlib. Pero antes expliquemos un poco qué pasa con Conda. Tenemos Anaconda y Miniconda. La principal diferencia es que Anaconda viene con TODO! Mientras que Miniconda trae python, y después debemos instalar las herramientas necesarias. Tanto Anaconda, como Miniconda están basados en Conda. Es verdad que esta explicación es muy simple, ya que Anaconda contiene muchos más servicios, pero que empiezan a tener sentido dentro de un escenario empresarial, y no he usado nunca. Resumiendo, usaremos Miniconda.
Una vez descargado y instalado Conda, qué es tan sencillo como hacer un download y hacer una instalación standard, hay que crear un entorno. Un entorno es un espacio virtual que va a contener las librería y herramientas que instalemos con Conda. Cada entorno puede tener unas librerías diferentes. Yo suelo crear un entorno para proyectos parecidos que comparten librerías, pero también se puede crear un entorno para cada proyecto. No debemos confundir el entorno con el directorio del proyecto. Es totalmente independiente.
La creación del entorno se debe hacer desde un terminal en MAC o Linux, o un command prompt en windows.
conda create -n SciKitEnv pandas scikit-learn numpy
Con esta linea creamos un entorno llamado SciKitEnv, que usaremos para todos los proyectos con SciKit-learn, y instalamos las librerías Pandas, Numpy y el framework scikit-learn.
Como me he olvidado algunas librerías hay que activar el framework y instalar las librerías.
conda activate SciKitEnv conda install jupyter matplotlib
Hemos activado el entorno y instalado Jupyter y Martplotlib. Para ver un listado de entorno de Conda tenemos que ejecutar conda env list. Ahora ya con el entorno instalado y activo podemos ir al directorio donde queremos guardar los proyectos y ejecutar jupyter notebook.
Esto nos abrirá el entorno de trabajo Júpiter en nuestro navegador por defecto, y si, vamos a trabajar en el navegador. Lo primero que hay que hacer es crear un proyecto, pulsado el botón new que vemos en la parte superior derecha y seleccionar la opción de python que tenemos instalada. Que esperamos que sea la versión 3 🙂
Los proyectos creados se van guardando en el directorio con la extensión .ipynb si queremos abrir cualquiera de ellos tan solo tenemos que seleccionarlo y se nos abrirá.
Para trabajar en el proyecto del vídeo he recuperado los datos de Kaggle, os podéis bajar el mismo dataset de aquí: https://www.kaggle.com/datasets/alexteboul/diabetes-health-indicators-dataset. Si os sentiis valientes, podéis descargar un dataset diferente y adaptar el ejemplo a vuestro dataset. Pero tened en cuenta que estamos ante un problema de clasificación, y recomendaría que fuera una clasificación en dos grupos, como en el ejemplo, los que padecen diabetes y los que no.
Con los datos disponibles y el bok de jupyter creado es hora de cargar las librerías y cargar el dataset usando Pandas.
import pandas as pd
diabetes = pd.read_csv("data/diabetes.csv")
Con la primera línea importamos Pandas, que es la librería que usaremos para trabajar con datos. La importamos como pd para que al usarla no tengamos que escribir tanto, y es un estándar de facto que se usa en la industria al trabajar con Pandas.
La segunda línea carga el contenido del .csv en el datasheet diabetes.
El siguiente paso seria cargar el modelo que escojamos dentro de scikit, ya veremos cuantos hay y cómo escoger cada uno de ellos. En este ejemplo usaremos el RandomForestClassifier, que podríamos usarlo en todos los problemas de clasificación. Es decir aquellos que a partir de unos datos se deba decidir si se pertenece a un grupo u a otro.
#cargar el modelo from sklearn.ensemble import RandomForestClassifier modelo = RandomForestClassifier()
Una vez cargado el modelo se debe preparar los datos para que puedan usarse para entrenar el modelo. No podemos pasarle directamente los datos. Hay que indicar qué datos son independientes y cuales son dependientes. Los datos independientes tiene un valor que no varía, mientras que los dependientes son los que pueden variar su valor dependiendo de los independientes.
#Separar en dos la tabla, por un lado los datos y por otro lado los resultados.
datos = diabetis.drop("Diabetes_binary", axis=1)
resultados = diabetis["Diabetes_binary"]
En el ejemplo todas las columnas a excepción de Diabetes_binary son datos independientes. Es decir, que se usan para decidir el valor del dato dependiente, la columna Diabetes_binary. Con este código tenemos todos los datos dependientes en datos, y la columna Diabetes_binary (el dato dependiente) en resultados.
Pero tener los datos en dos no es suficiente, por qué no tan solo queremos entrenar el modelo. También tenemos que probarlo, y no podemos probarlo con datos que hayamos usado para entrenarlo. Simplemente porque ya los conoce y posiblemente nos dé unos resultados demasiado buenos.
Por lo que vamos a dividir los arrays en dos para tener cuatro arrays de datos. Dos para entrenar el modelo y dos para probar su eficiencia.
#Obtener juegos de datos para entrenar el modelo. from sklearn.model_selection import train_test_split #Nos devuelve 4 juegos de datos, dos de entreno y dos de test. Indicamos 20% test. datos_entreno, datos_test, resultados_entreno, resultados_test = train_test_split(datos, resultados, test_size=0.2)
Ahora que ya tenemos cuatro juegos de datos podemos entrenar el modelo, obtener unos resultados y comprobar cómo funciona.
#entrenamos el modelo modelo.fit(datos_entreno, resultados_entreno) #Usando el modelo crearemos unas predicciones con los datos de test. predicciones = modelo.predict(datos_test) #Obtener la fiabilidad del modelo, comparando los datos de test conocidos. exactitud = modelo.score(datos_test, resultados_test) #Obtener otra metrica. Recall / Exhaustividad. Tasa de aciertos en positivos. from sklearn.metrics import recall_score recall = recall_score(resultados_test, predicciones) recall, exactitud
Hemos entrenado el modelo, obtenido predicciones y dos KPI’s. En exactitud o accuracy hemos obtenido un 73%. La exactitud mide los aciertos del modelo, tanto en positivos como en negativos.
En recall se ha obtenido un 78%. Esta metrica nos indica como de bien funciona el modelo previendo resultados positivos. Es decir que cantidad de positivos reales son detectados. En casos de fraude o diagnosis médica es una métrica muy importante.
Ahora que ya tenemos el modelo entrenado tocará intentar mejorarlo. Hay muchas formas de hacerlo, pero vamos a ver una muy sencilla, que se trata en crear un bucle con Python y en cada iteración modificar una de los parámetros de configuración del modelo.
#creamos un bucle para que evalue el modelo
for i in range (200, 601, 100):
print(f"n_estimator: {i}")
modelo = RandomForestClassifier(n_estimators=i)
modelo.fit(datos_entreno, resultados_entreno)
print(f"Exactitud / Accuracy {modelo.score(datos_test, resultados_test)}")
predicciones = modelo.predict(datos_test)
print(f"Exhaustividad / Recall: {recall_score(resultados_test, predicciones)}")
print("---------")
En el código se crea un bucle for que va de 200 a 601 a pasos de 100. El valor lo pone en la variable i. Al crear el modelo con RandomForestClassifier(n_estimators=i), le estamos diciendo que tome el valor de i para su parámetro n_estimators. Este parámetro indica cuantos árboles tendrá el bosque de decisión. En un principio, y resumiendo mucho, cuantos más, mejor funcionará el modelo, pero tardará más.
En cada iteración obtenemos unas nuevas predicciones y imprimimos los dos KPI’s. Con lo que podríamos ver las diferencias de funcionamiento y tomar una decisión sobre con que valor de n_estimators funciona mejor el modelo.
n_estimator: 200 Exactitud / Accuracy 0.7368979418629323 Exhaustividad / Recall: 0.7840780542986425 --------- n_estimator: 300 Exactitud / Accuracy 0.7373223000212179 Exhaustividad / Recall: 0.7828054298642534 --------- n_estimator: 400 Exactitud / Accuracy 0.7388075535752174 Exhaustividad / Recall: 0.7845022624434389 ---------
En la imagen vemos los valores por 200, 300 y 400. Los KPI’s van aumentando, pero no demasiado. Se debe tener en cuenta el aumento de tiempo en las predicciones y de entreno del modelo, ya que puede no valer la pena el aumento residual que se produce en los KPI’s. Seguramente tendríamos que buscar otra forma de mejorar el modelo….. pero este ha sido nuestro primer trabajo! Hace unas horas ni teníamos instalado el entorno. Ahora toca hacer repaso de todo lo aprendido.
¿Que hemos aprendido?
Lo más importante es que hemos visto cómo trabajar con proyectos en los que tengamos que clasificar registros en categorías dependiendo de otras variables. Vale, el ejemplo era muy concreto, personas que podian tener o no diabetes. Pero si lo generalizamos seguro que podemos encontrar muchos problemas que tienen la misma forma, y ahora ya sabemos cómo afrontarlos.
Ahora vayamos paso a paso, por que realmente hemos aprendido bastantes cosas:
Conda.
Sabemos lo que es Conda, hemos descargado miniconda y hemos creado un entorno.
conda create -n SciKitEnv pandas scikit-learn numpy
Sabemos listar los entornos con.
conda env list.
Hemos activado el entorno e instalado mas librerias.
conda activate SciKitEnv
conda install jupyter matplotlib
Jupyter.
Aparte de arrancar Jupyter con Jupyter notebook. Hemos trabajado bastante con él y aprendido algunos trucos como el de completar las frases con TAB. Consultar los parámetros de una función con shift + TAB. Pero sobretodo hemos trabajado de una forma normal con Jupyter hemos ido ejecutando las órdenes y visto el resultado.
Pandas.
Hemos importado la librería y leído un CSV. Pero no tan solo eso, sino que hemos trabajado con el CSV para recuperar todas las columnas menos una.
datos = diabetis.drop(“Diabetes_binary”, axis=1)
Y recuperado el valor de una sola columna:
resultados = diabetis[“Diabetes_binary”]
scikit-learn.
Hemos usado uno de sus modelos, que en realidad se llaman Estimators. Ya sabemos que el modelo / estimator RandomForestClassifier se usa en problemas de clasificación.
Hemos preparado los datos para dividirlos entre datos de entreno y datos de test. Usando train_test_split.
Hemos conocido dos KPI’s. Recall y Accuracy y ya sabemos que miden cosas diferentes. Que no podemos basar la decisión de si un modelo es correcto o no con un solo KPI. Que los KPI’s tienen importancias diferentes dependiendo del problema que queramos solucionar.
Finalmente hemos construido un bucle con Python! Que hemos usado para ir probando diferentes configuraciones del estimator.
Continuaremos.
¿qué será lo siguiente? Por ahora creo que lo más probable es que estudiemos un poco los diferentes estimators que nos ofrece scikit-learn y tratemos diferentes problemas y sepamos cómo y porqué escoger uno u otro. También hay mucho trabajo que hacer en el tratamiento de datos con Pandas. El csv escogido ya estaba muy trabajado, pero normalmente no es así. Se tiene que adaptar los datos antes de que sean aptos para entrenar a un modelo. Realmente es una de las partes que más trabajo suele llevar. También la tocaremos en breve.
Mientras tanto os dejo un enlace donde se explican más los KPIs en ML.
Introducción al apasionante mundo de la I.A. mediante Machine Learning, sin necesidad de tener conocimientos previos de Python o Algrebra. Read more