Tutorial ScikitLearn: Introducción e instalación

¿Qué es Scikit Learn y para qué se usa en ciencia de datos?

Scikit Learn es una biblioteca de aprendizaje automático de código abierto para Python que ofrece herramientas simples y eficientes para el análisis y modelado de datos. Se integra de manera efectiva con otras bibliotecas populares como NumPy y pandas, facilitando la manipulación y el procesamiento de datos numéricos y estructurados en ciencia de datos.

En el campo de la ciencia de datos, Scikit Learn es esencial para tareas de clasificación, regresión y clustering. Proporciona implementaciones optimizadas de una amplia variedad de algoritmos, desde modelos lineales simples hasta árboles de decisión y máquinas de soporte vectorial. Esto permite a los científicos de datos construir modelos predictivos robustos y escalables para resolver problemas complejos.

Una de las ventajas clave de Scikit Learn es su enfoque en la simplicidad y la consistencia en el diseño de su API. Todos los modelos siguen una interfaz uniforme basada en los métodos fit, predict y transform, lo que facilita la experimentación y comparación entre diferentes algoritmos. Por ejemplo, ajustar y predecir con un modelo de regresión logística es tan sencillo como:

from sklearn.linear_model import LogisticRegression

# Instanciar el modelo
modelo = LogisticRegression()

# Ajustar el modelo a los datos de entrenamiento
modelo.fit(X_train, y_train)

# Realizar predicciones en datos nuevos
predicciones = modelo.predict(X_test)

Además, Scikit Learn ofrece herramientas para el preprocesamiento de datos, esenciales antes de construir cualquier modelo. Incluye transformadores para la normalización, escalado y codificación de variables categóricas. Por ejemplo, para convertir variables categóricas en representaciones numéricas se puede usar OneHotEncoder:

from sklearn.preprocessing import OneHotEncoder

encoder = OneHotEncoder()
X_categ_encoded = encoder.fit_transform(X_categ)

También soporta técnicas avanzadas como la validación cruzada y la búsqueda de hiperparámetros mediante métodos como GridSearchCV y RandomizedSearchCV, lo que ayuda a optimizar el rendimiento de los modelos. Esto es crucial para garantizar que los modelos generados sean generalizables y funcionen bien con datos no vistos.

En resumen, Scikit Learn es una herramienta fundamental en ciencia de datos que permite implementar de manera eficiente una amplia gama de algoritmos de aprendizaje automático. Su diseño orientado a la facilidad de uso y la interoperabilidad la convierte en una opción preferida para investigadores y profesionales que buscan soluciones robustas en Python.

Principales módulos de Scikit Learn

Scikit Learn está organizado en varios módulos que ofrecen una amplia variedad de algoritmos y herramientas para el aprendizaje automático en Python. A continuación, se presentan los principales módulos y sus funcionalidades más destacadas.

El módulo sklearn.datasets proporciona conjuntos de datos tanto reales como generados sintéticamente, útiles para pruebas y aprendizaje. Por ejemplo, el famoso conjunto de datos Iris puede cargarse de la siguiente manera:

from sklearn.datasets import load_iris

iris = load_iris()
X, y = iris.data, iris.target

El módulo sklearn.preprocessing contiene herramientas para el preprocesamiento de datos, como la normalización, el escalado y la codificación de variables categóricas. Estas técnicas son esenciales para preparar los datos antes de entrenar un modelo. Por ejemplo, para escalar las características se puede utilizar StandardScaler:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_escalado = scaler.fit_transform(X)

El módulo sklearn.model_selection ofrece métodos para la selección y validación de modelos, incluyendo la división de datos en conjuntos de entrenamiento y prueba, y la validación cruzada. La función train_test_split es comúnmente usada para dividir datos:

from sklearn.model_selection import train_test_split

X_entrenamiento, X_prueba, y_entrenamiento, y_prueba = train_test_split(X, y, test_size=0.2, random_state=42)

Para algoritmos de regresión y clasificación, el módulo sklearn.linear_model incluye una variedad de modelos lineales como la regresión lineal, regresión logística y modelos robustos. Por ejemplo, para usar una regresión logística:

from sklearn.linear_model import LogisticRegression

modelo = LogisticRegression()
modelo.fit(X_entrenamiento, y_entrenamiento)

El módulo sklearn.svm implementa máquinas de vectores de soporte para tareas de clasificación y regresión. Estos algoritmos son efectivos en espacios de alta dimensionalidad:

from sklearn.svm import SVC

svc = SVC()
svc.fit(X_entrenamiento, y_entrenamiento)

Para tareas que involucran vecinos más cercanos, sklearn.neighbors ofrece herramientas basadas en distancias, útiles en clasificación, regresión y análisis no supervisado:

from sklearn.neighbors import KNeighborsClassifier

knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_entrenamiento, y_entrenamiento)

El módulo sklearn.tree proporciona implementaciones de árboles de decisión para clasificación y regresión. Estos modelos son interpretables y pueden capturar relaciones no lineales:

from sklearn.tree import DecisionTreeClassifier

arbol = DecisionTreeClassifier()
arbol.fit(X_entrenamiento, y_entrenamiento)

Para mejorar el rendimiento de los modelos, sklearn.ensemble ofrece métodos de votación y agregación como Random Forest y Gradient Boosting, que combinan múltiples modelos débiles para crear uno fuerte:

from sklearn.ensemble import RandomForestClassifier

bosque = RandomForestClassifier(n_estimators=100)
bosque.fit(X_entrenamiento, y_entrenamiento)

En el ámbito del aprendizaje no supervisado, el módulo sklearn.cluster incluye algoritmos de clustering como K-Means y Mean Shift, que son útiles para detectar patrones en datos sin etiquetas:

from sklearn.cluster import KMeans

kmeans = KMeans(n_clusters=3)
kmeans.fit(X)

Para la reducción de la dimensionalidad, sklearn.decomposition ofrece técnicas como el Análisis de Componentes Principales (PCA), que reduce la cantidad de variables manteniendo la mayor cantidad de varianza posible:

from sklearn.decomposition import PCA

pca = PCA(n_components=2)
X_reducido = pca.fit_transform(X)

El módulo sklearn.metrics proporciona una amplia gama de métricas de evaluación para medir el rendimiento de los modelos, tanto en clasificación, regresión como en clustering. Por ejemplo, para calcular la precisión de un modelo de clasificación:

from sklearn.metrics import accuracy_score

predicciones = modelo.predict(X_prueba)
precision = accuracy_score(y_prueba, predicciones)

Para facilitar el flujo de trabajo, sklearn.pipeline permite construir pipelines que encadenan varias transformaciones y un estimador final, simplificando el proceso de entrenamiento y validación:

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC

pipeline = Pipeline([
    ('escalado', StandardScaler()),
    ('clasificador', SVC())
], memory = None)

pipeline.fit(X_entrenamiento, y_entrenamiento)

El módulo sklearn.feature_selection incluye métodos para la selección de características, ayudando a reducir el sobreajuste y mejorar la interpretabilidad del modelo:

from sklearn.feature_selection import SelectKBest, chi2

selector = SelectKBest(score_func=chi2, k=2)
X_nuevo = selector.fit_transform(X, y)

El uso adecuado de estos módulos permite abordar eficazmente diversas tareas de aprendizaje automático, optimizando el rendimiento y la eficiencia de los modelos desarrollados con Scikit Learn.

Metodología CRISP-DM con Scikit Learn

La metodología CRISP-DM (Cross Industry Standard Process for Data Mining) es un estándar ampliamente adoptado en proyectos de ciencia de datos y aprendizaje automático. Scikit Learn, como herramienta esencial en Python, se integra eficazmente en varias fases de este proceso, facilitando el desarrollo estructurado de modelos predictivos.

1. Comprensión del negocio:

En esta fase, se definen los objetivos y requisitos del proyecto desde una perspectiva comercial. Aunque Scikit Learn no se utiliza directamente aquí, entender sus capacidades permite al equipo anticipar qué algoritmos y técnicas pueden ser más apropiados para resolver el problema.

2. Comprensión de los datos:

Scikit Learn proporciona módulos como sklearn.datasets que facilitan la carga y exploración de conjuntos de datos de ejemplo. Sin embargo, para datos propios, es común utilizar bibliotecas como pandas para la carga y manipulación inicial. Aun así, las herramientas de preprocesamiento de Scikit Learn pueden ser útiles para obtener estadísticas básicas y analizar la distribución de las variables.

3. Preparación de los datos:

Esta fase es crucial y Scikit Learn ofrece una variedad de herramientas para el preprocesamiento de datos. El módulo sklearn.preprocessing incluye funciones para escalado, normalización y codificación de variables, lo cual es esencial para preparar los datos antes del modelado. Por ejemplo, para escalar las características:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

Además, el uso de transformadores personalizados mediante la clase FunctionTransformer permite aplicar funciones propias al conjunto de datos de manera consistente dentro de un pipeline.

4. Modelado:

En esta etapa, Scikit Learn demuestra su fortaleza al ofrecer una amplia gama de modelos de aprendizaje automático para tareas de clasificación, regresión y clustering. La consistencia en su API facilita el entrenamiento y la comparación de diferentes algoritmos. Por ejemplo, para entrenar un modelo de árbol de decisión:

from sklearn.tree import DecisionTreeClassifier

modelo = DecisionTreeClassifier()
modelo.fit(X_train, y_train)

Además, Scikit Learn soporta técnicas de validación cruzada mediante el módulo sklearn.model_selection, lo que permite evaluar la robustez de los modelos de manera más fiable.

5. Evaluación:

Scikit Learn ofrece métricas detalladas y herramientas para evaluar el rendimiento del modelo. El módulo sklearn.metrics incluye funciones para calcular medidas como la precisión, recall, f1-score y matriz de confusión. Por ejemplo, para evaluar la precisión de un modelo de clasificación:

from sklearn.metrics import accuracy_score

y_pred = modelo.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)

También es posible generar informes más completos con classification_report, que proporcionan una visión más profunda del desempeño del modelo en cada clase.

6. Despliegue:

Aunque Scikit Learn se centra en el desarrollo y evaluación de modelos, facilita el despliegue al permitir la serialización de modelos entrenados. Utilizando bibliotecas como joblib o pickle, es posible guardar el modelo para su uso posterior en entornos de producción:

import joblib

# Guardar el modelo
joblib.dump(modelo, 'modelo_entrenado.joblib')

# Cargar el modelo en el futuro
modelo_cargado = joblib.load('modelo_entrenado.joblib')

Este enfoque simplifica la integración del modelo en aplicaciones web, servicios de backend u otros sistemas.

Integración a través de pipelines:

Scikit Learn introduce el concepto de pipelines, que permite encadenar múltiples pasos del preprocesamiento y modelado en un solo objeto. Esto asegura que las transformaciones aplicadas durante el entrenamiento se reproduzcan exactamente en los datos nuevos. Un pipeline típico podría ser:

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

pipeline = Pipeline([
    ('escalado', StandardScaler()),
    ('clasificador', LogisticRegression())
], memory = None)

pipeline.fit(X_train, y_train)

Al predecir con el pipeline, se garantiza que los datos de entrada se procesen de manera coherente.

Optimización de hiperparámetros:

Durante el modelado y la evaluación, ajustar los hiperparámetros es esencial para mejorar el rendimiento del modelo. Scikit Learn proporciona herramientas como GridSearchCV y RandomizedSearchCV para realizar búsquedas exhaustivas o aleatorias de combinaciones de hiperparámetros utilizando validación cruzada:

from sklearn.model_selection import GridSearchCV

parametros = {
    'max_depth': [3, 5, 7],
    'min_samples_split': [2, 5, 10]
}

grid_search = GridSearchCV(DecisionTreeClassifier(), parametros, cv=5)
grid_search.fit(X_train, y_train)

Esta estrategia ayuda a encontrar la configuración óptima del modelo de manera eficiente.

Documentación y reproducibilidad:

Mantener un registro claro de los pasos es fundamental en la metodología CRISP-DM. Scikit Learn, al seguir una API consistente, facilita la escritura de código limpio y reproducible. Además, combinar Scikit Learn con herramientas como Jupyter Notebooks permite documentar el proceso de manera interactiva y visual.

Instalar paquete de Scikit learn y comprobar versión

Para trabajar con Scikit Learn 1.5.2, es necesario instalarlo en el entorno de desarrollo. La instalación se realiza fácilmente utilizando pip, el gestor de paquetes de Python. Antes de proceder, es recomendable actualizar pip a su última versión:

pip install --upgrade pip

Con pip actualizado, se puede instalar Scikit Learn especificando la versión deseada. Para instalar la versión 1.5.2, se ejecuta el siguiente comando en la terminal:

pip install scikit-learn==1.5.2

Este comando descarga e instala la versión especificada de Scikit Learn junto con sus dependencias. Es importante asegurarse de que el entorno de Python cumple con los requisitos de la biblioteca, especialmente en términos de versión y paquetes instalados previamente.

Si se está trabajando en un entorno virtual, como venv o conda, es recomendable activar el entorno antes de instalar paquetes. Por ejemplo, para activar un entorno virtual llamado "entorno_scikit":

source entorno_scikit/bin/activate

Una vez completada la instalación, es necesario comprobar que Scikit Learn se ha instalado correctamente y que la versión es la esperada. Para verificar la versión instalada, se puede ejecutar el siguiente código en una sesión de Python interactiva o en un script:

import sklearn
print(sklearn.__version__)

Al ejecutar este código, debería mostrarse en pantalla '1.5.2', confirmando que la versión instalada es la correcta. Es fundamental comprobar la versión, especialmente cuando se trabaja con funcionalidades específicas de versiones recientes que podrían no estar presentes en versiones anteriores.

En caso de que la versión mostrada no sea la esperada, puede ser necesario revisar las versiones de Python instaladas y asegurarse de que pip está instalando los paquetes en el entorno adecuado. Una práctica común es utilizar pip3 para instalaciones en Python 3:

pip3 install scikit-learn==1.5.2

Además, si se tienen múltiples versiones de Python, es útil especificar la versión al iniciar la sesión interactiva:

python3

Para gestionar las dependencias y mantener el entorno organizado, se puede utilizar un archivo requirements.txt donde se especifiquen las versiones de los paquetes necesarios:

scikit-learn==1.5.2

Luego, se instalan todas las dependencias con:

pip install -r requirements.txt

Esto garantiza que todos los colaboradores del proyecto utilicen las mismas versiones de los paquetes, evitando conflictos y asegurando la reproducibilidad.

En algunos casos, es posible que se necesite compilar Scikit Learn desde el código fuente, especialmente si se desea contribuir al desarrollo de la biblioteca o utilizar características en desarrollo. Para ello, se clona el repositorio oficial y se instala:

git clone https://github.com/scikit-learn/scikit-learn.git
cd scikit-learn
pip install .

Es importante destacar que esta opción es para usuarios avanzados y que, en general, la instalación mediante pip es suficiente para la mayoría de los casos de uso.

Finalmente, para confirmar que Scikit Learn está funcionando correctamente, se puede ejecutar un pequeño script de prueba que importe algunos de los módulos principales y ejecute una tarea sencilla:

from sklearn.linear_model import LinearRegression
import numpy as np

# Datos de ejemplo
X = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])

# Crear y entrenar el modelo
modelo = LinearRegression()
modelo.fit(X, y)

# Realizar una predicción
prediccion = modelo.predict([[6]])
print(prediccion)

Si el script se ejecuta sin errores y muestra el resultado esperado, se puede concluir que Scikit Learn está correctamente instalado y listo para usarse en proyectos de aprendizaje automático.