Saltar al contenido principal

Aprendizaje automático en Python: Tutorial de Scikit-Learn

Un tutorial de scikit-learn fácil de seguir que te ayudará a iniciarte en el aprendizaje automático con Python.
Actualizado 11 sept 2024  · 12 min de lectura

El aprendizaje automático es un subcampo de la inteligencia artificial dedicado a comprender y construir métodos para imitar la forma en que aprenden los humanos. Estos métodos incluyen el uso de algoritmos y datos para mejorar el rendimiento en algún conjunto de tareas y suelen corresponder a uno de los tres tipos más comunes de aprendizaje: 

  • Aprendizaje supervisado: un tipo de aprendizaje automático que aprende la relación entre la entrada y la salida. 
  • Aprendizaje no supervisado: un tipo de aprendizaje automático que aprende la estructura subyacente de un conjunto de datos sin etiquetar.   
  • Aprendizaje por refuerzo: método de aprendizaje automático en el que el agente informático aprende a realizar determinadas acciones en un entorno que le conducen a la máxima recompensa.

Scikit-learn, también conocido como sklearn, es una robusta biblioteca de aprendizaje automático en Python de código abierto. Se creó para ayudar a simplificar el proceso de implementación del aprendizaje automático y los modelos estadísticos en Python. 

La biblioteca permite a los profesionales implementar rápidamente una amplia gama de algoritmos de aprendizaje automático supervisados y no supervisados mediante una interfaz coherente. Sklearn se construyó sobre SciPy y funciona con todos los tipos de datos numéricos almacenados como matrices NumPy, matrices dispersas SciPy y todos los demás tipos de datos que puedan convertirse en matrices numéricas, como Pandas DataFrames.  

En este tutorial práctico de Sklearn, cubriremos varios aspectos del ciclo de vida del aprendizaje automático, como el procesamiento de datos, el entrenamiento de modelos y la evaluación de modelos.  

Consulta este espacio de trabajo de DataCamp para seguir el código. 

Datos

El primer aspecto del sklearn que exploraremos son los datos; Scikit-learn viene con algunos conjuntos de datos estándar de aprendizaje automático, lo que significa que no es necesario que los descargues de un sitio web o una base de datos externos. 

Ejemplos de los conjuntos de datos de juguete disponibles en sklearn incluyen el conjunto de datos del iris para clasificación y el conjunto de datos de la diabetes para regresión. Para nuestro ejemplo, utilizaremos el conjunto de datos del vino.

Vamos a cargarlo en memoria:

from sklearn.datasets import load_wine

wine_data = load_wine() 

Ejecutar el código anterior devuelve un objeto similar a un diccionario que contiene los datos junto con metadatos sobre los datos que contiene. 

Los datos que necesitamos están en .data del objeto tipo diccionario, pero como no es un diccionario propiamente dicho, podemos acceder a él como atributo de la instancia wine_data de la siguiente manera:

wine_data.data

Devuelve una matriz N x M, donde N es el número de muestras y M el número de características.  

Utilicemos estos conocimientos para cargar nuestros datos en un pandas DataFrameque es mucho más fácil de manipular y analizar.

import pandas as pd
from sklearn.datasets import load_wine

wine_data = load_wine()

# Convert data to pandas dataframe
wine_df = pd.DataFrame(wine_data.data, columns=wine_data.feature_names)

# Add the target label
wine_df["target"] = wine_data.target

# Take a preview
wine_df.head()

datos del vino

Ahora estás preparado para explorar los datos. 

Exploración de datos

Los DataFrames de Pandas se definen como estructuras de datos bidimensionales etiquetadas, formadas por columnas, que pueden contener diferentes pasos de datos. La forma más fácil de conceptualizar un DataFrame es pensar en él como tres componentes fusionados; esos componentes son 1) datos, 2) un índice y 3) columnas. 

La exploración de datos no es el tema principal de este artículo, pero es un paso extremadamente importante en cualquier proyecto de datos - puedes aprender más sobre ello en nuestro Tutorial Python de Análisis Exploratorio de Datos. Haremos una breve exploración para hacernos una mejor idea de lo que contiene nuestro conjunto de datos; esto nos dará una mejor idea de cómo procesar los datos. 

Lo primero que vamos a hacer es llamar a la función info() en nuestro DataFrame pandas; esto imprimirá un resumen conciso de los datos del vino contenidos en el DataFrame.

wine_df.info()

"""

RangeIndex: 178 entries, 0 to 177
Data columns (total 14 columns):
 #   Column                        Non-Null Count  Dtype  
---  ------                        --------------  -----  
 0   alcohol                       178 non-null    float64
 1   malic_acid                    178 non-null    float64
 2   ash                           178 non-null    float64
 3   alcalinity_of_ash             178 non-null    float64
 4   magnesium                     178 non-null    float64
 5   total_phenols                 178 non-null    float64
 6   flavanoids                    178 non-null    float64
 7   nonflavanoid_phenols          178 non-null    float64
 8   proanthocyanins               178 non-null    float64
 9   color_intensity               178 non-null    float64
 10  hue                           178 non-null    float64
 11  od280/od315_of_diluted_wines  178 non-null    float64
 12  proline                       178 non-null    float64
 13  target                        178 non-null    int64  
dtypes: float64(13), int64(1)
memory usage: 19.6 KB
"""

Después de ejecutar esta célula, aprenderás: 

  • Los datos contienen 178 muestras de datos
  • Hay 14 columnas en total, incluida la columna objetivo (lo que queremos predecir)
  • Hay 0 columnas con valores perdidos; puedes deducirlo de la columna "Recuento de no nulos". 
  • Todas las características son de tipo de datos float64mientras que la etiqueta de destino es de tipo int64.
  • Los datos utilizan 19,6 KB de memoria. 

También podemos llamar al método describe() en nuestro DataFrame para obtener estadísticas descriptivas sobre cada característica del conjunto de datos. 

Por ejemplo: 

wine_df.describe() 

datos del vino

También querrás tener una idea del tipo de valores que se guardan en cada función. La forma más rápida de aprenderlo es utilizar el método head() para ver las cinco primeras filas de datos o el método tail() para ver las cinco últimas filas de datos. 

wine_df.tail()

datos del vino

La ejecución de este código nos muestra que nuestras características están en escalas diferentes, lo que puede causar problemas al tratar con algoritmos basados en el Descenso Gradiente, como la regresión logística, y al tratar con algoritmos basados en la distancia, como las máquinas de vectores soporte. Esto se debe a que son sensibles al rango de puntos de datos. 

En un flujo de trabajo normal de aprendizaje automático, este proceso será mucho más largo, pero vamos a saltarnos el procesamiento de datos para volver al tema principal de este tutorial, Scikit-learn. 

Puedes obtener más información sobre Pandas en Tutorial sobre Pandas en Python: La guía definitiva para principiantes. 

Ejemplo de Scikit-learn: Preprocesamiento de datos

Tenemos una comprensión decente del aspecto de nuestros datos. Cuando has llegado a este punto, suele significar que estás listo para empezar a preparar los datos que se introducirán en un modelo de aprendizaje automático. 

El procesamiento de datos es un paso vital en el flujo de trabajo del aprendizaje automático, porque los datos del mundo real son desordenados. Puede contener: 

  • Valores perdidos,
  • Valores redundantes
  • Outliers
  • Errores
  • Ruido

Debes ocuparte de todo esto antes de alimentar los datos a un modelo de aprendizaje automático; de lo contrario, el modelo incorporará estos errores a su función de aproximación: aprenderá a cometer errores en nuevas instancias. Esto es lo que formó el famoso dicho del aprendizaje automático: "Basura dentro, basura fuera". 

Otra razón es que los modelos de aprendizaje automático suelen requerir datos numéricos.  

Aparte de que nuestros datos están en escalas diferentes, a primera vista no hay mucho más malo en nuestros datos. Para combatir este problema, normalicemos las características utilizando laclase StandardScaler de sklearn; esto garantizará que la media de cada característica sea aproximadamente igual a cero .

Aquí tienes el código: 

from sklearn.preprocessing import StandardScaler

# Split data into features and label 
X = wine_df[wine_data.feature_names].copy()
y = wine_df["target"].copy() 

# Instantiate scaler and fit on features
scaler = StandardScaler()
scaler.fit(X)

# Transform features
X_scaled = scaler.transform(X.values)

# View first instance
print(X_scaled[0])

"""
[ 1.51861254 -0.5622498   0.23205254 -1.16959318  1.91390522  0.80899739
  1.03481896 -0.65956311  1.22488398  0.25171685  0.36217728  1.84791957
  1.01300893]
"""

Pasemos al entrenamiento del modelo. 

Ejemplo de Scikit-learn: Formación de modelos

Antes de que un modelo de aprendizaje automático pueda hacer predicciones, debe entrenarse con un conjunto de datos para aprender una función de aproximación. 

Pero, ¿cómo sabremos si el modelo funciona bien con datos que no ha visto antes? No lo sabremos a menos que lo probemos. 

Una forma de probar un modelo de aprendizaje automático antes de colocarlo en un entorno en el que repercuta en otros es dividir los datos de entrenamiento en un conjunto de entrenamiento y otro de prueba, y utilizar el conjunto de prueba para evaluar lo que ha aprendido el modelo; esto se conoce como evaluación fuera de línea. 

Hay varias formas de dividir los datos en conjuntos de entrenamiento y de prueba, pero scikit-learn tiene una función incorporada para hacerlo por nosotros llamada train_test_split().

Utilizaremos esta función para dividir nuestros datos de forma que el 70% se utilice para entrenar el modelo y el 30% para evaluar la capacidad de generalización del modelo a instancias no vistas. 

from sklearn.model_selection import train_test_split

# Split data into train and test
X_train_scaled, X_test_scaled, y_train, y_test = train_test_split(X_scaled,
                                                                  y,
                                                             train_size=.7,
                                                           random_state=25)

# Check the splits are correct
print(f"Train size: {round(len(X_train_scaled) / len(X) * 100)}% \n\
Test size: {round(len(X_test_scaled) / len(X) * 100)}%")

"""
Train size: 70% 
Test size: 30%

Ahora vamos a construir algunos modelos. 

Construir el modelo

Gracias a sklearn, construir un modelo de aprendizaje automático es extremadamente sencillo. 

Vamos a construir tres modelos para predecir la clase de vino: 

  1. Regresión logística
  2. Máquina de vectores soporte 
  3. Clasificador de árbol de decisión
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier

# Instnatiating the models 
logistic_regression = LogisticRegression()
svm = SVC()
tree = DecisionTreeClassifier()

# Training the models 
logistic_regression.fit(X_train_scaled, y_train)
svm.fit(X_train_scaled, y_train)
tree.fit(X_train_scaled, y_train)

# Making predictions with each model
log_reg_preds = logistic_regression.predict(X_test_scaled)
svm_preds = svm.predict(X_test_scaled)
tree_preds = tree.predict(X_test_scaled)

El siguiente paso es evaluar cómo generalizan los modelos en instancias no vistas. 

Ejemplo de Scikit-learn: Evaluación del modelo

La evaluación del modelo se realiza para comprobar lo bien que el modelo generaliza a instancias no vistas. Scikit-learn proporciona una serie de métricas de clasificación y regresión para evaluar el rendimiento de un modelo entrenado. 

Para nuestro caso de uso, vamos a utilizar informe_de_clasificación() de la función métricas para crear un informe de texto que muestre las principales métricas de clasificación, como la precisión, la recuperación, la puntuación f1, la exactitud, etc.

Así es como se ve en código:

from sklearn.metrics import classification_report

# Store model predictions in a dictionary
# this makes it's easier to iterate through each model
# and print the results. 
model_preds = {
    "Logistic Regression": log_reg_preds,
    "Support Vector Machine": svm_preds,
    "Decision Tree": tree_preds
}

for model, preds in model_preds.items():
    print(f"{model} Results:\n{classification_report(y_test, preds)}", sep="\n\n")

"""
Logistic Regression Results:
              precision    recall  f1-score   support

           0       1.00      1.00      1.00        17
           1       1.00      0.92      0.96        25
           2       0.86      1.00      0.92        12

    accuracy                           0.96        54
   macro avg       0.95      0.97      0.96        54
weighted avg       0.97      0.96      0.96        54

Support Vector Machine Results:
              precision    recall  f1-score   support

           0       1.00      1.00      1.00        17
           1       1.00      1.00      1.00        25
           2       1.00      1.00      1.00        12

    accuracy                           1.00        54
   macro avg       1.00      1.00      1.00        54
weighted avg       1.00      1.00      1.00        54

Decision Tree Results:
              precision    recall  f1-score   support

           0       0.94      0.94      0.94        17
           1       0.96      0.88      0.92        25
           2       0.86      1.00      0.92        12

    accuracy                           0.93        54
   macro avg       0.92      0.94      0.93        54
weighted avg       0.93      0.93      0.93        54
"""

A primera vista, parece que la máquina de vectores de soporte es el mejor modelo. En un flujo de trabajo típico, esto despertaría la curiosidad sobre el modelo: ¿es realmente tan bueno como se muestra, o hemos cometido algún error en alguna parte? Deberías estar intrigado por saber más sobre tus modelos y lo que están aprendiendo, ya que esto te permitirá conocer mejor sus puntos fuertes y débiles. 

Conocer esta información es muy útil para las partes interesadas, ya que les permite encontrar soluciones para compensar las deficiencias del modelo. 

Conclusión

La biblioteca scikit-learn consta de varios módulos que facilitan la implementación de modelos de aprendizaje automático. Estos módulos abarcan desde herramientas de preprocesamiento que te ayudarán a preparar tu modelo para introducirlo en un modelo de aprendizaje automático, hasta modelos que puedes utilizar para encontrar patrones en tus datos, y métricas de evaluación que puedes utilizar para valorar el rendimiento de tu modelo. 

En este tutorial, sólo hemos arañado la superficie de las capacidades de sklearn. Para profundizar en lo que puedes hacer con la biblioteca, tenemos varios recursos para ponerte en marcha. Aquí tienes algunas para empezar: 

Temas

Más información sobre Python y el Aprendizaje Automático

curso

Supervised Learning with scikit-learn

4 hr
162.7K
Grow your machine learning skills with scikit-learn in Python. Use real-world datasets in this interactive course and learn how to make powerful predictions!
Ver detallesRight Arrow
Comienza el curso
Ver másRight Arrow
Relacionado

tutorial

Aprendizaje automático de datos categóricos con el tutorial de Python

Aprenda los trucos más comunes para manejar datos categóricos y preprocesarlos para construir modelos de aprendizaje automático.
Moez Ali's photo

Moez Ali

28 min

tutorial

Introducción al Q-Learning: Tutorial para principiantes

Conozca el algoritmo de aprendizaje por refuerzo sin modelos más popular con un tutorial de Python.
Abid Ali Awan's photo

Abid Ali Awan

16 min

tutorial

Introducción a k-Means Clustering con scikit-learn en Python

En este tutorial, aprenda a aplicar k-Means Clustering con scikit-learn en Python

Kevin Babitz

21 min

tutorial

Tutorial de clasificación Naive Bayes con Scikit-learn

Aprende a construir y evaluar un Clasificador Naive Bayes utilizando el paquete Scikit-learn de Python.
Abid Ali Awan's photo

Abid Ali Awan

13 min

tutorial

Tutorial de Clasificación en Árbol de Decisión en Python

En este tutorial, aprenderás Clasificación en Árbol de Decisión, medidas de selección de atributos y cómo construir y optimizar el Clasificador en Árbol de Decisión utilizando el paquete Python Scikit-learn.
Avinash Navlani's photo

Avinash Navlani

12 min

tutorial

Tutorial sobre el uso de XGBoost en Python

Descubre la potencia de XGBoost, uno de los marcos de machine learning más populares entre los científicos de datos, con este tutorial paso a paso en Python.
Bekhruz Tuychiev's photo

Bekhruz Tuychiev

16 min

Ver másVer más