Entrenamiento del modelo en Python

El entrenamiento de un modelo en Python implica el proceso de ajustar los parámetros de un modelo a partir de datos de entrenamiento para que pueda hacer predicciones precisas en datos nuevos o no vistos.

A continuación, se presentan ejemplos de cómo entrenar un modelo de regresión lineal utilizando Python y la biblioteca Scikit-learn paso a paso.


Pasos a seguir para entrenar modelos en Python

El entrenamiento/prueba de modelos en Python es una técnica fundamental en el aprendizaje automático y la ciencia de datos que se utiliza para evaluar y medir la precisión de un modelo predictivo. Este proceso se basa en dividir el conjunto de datos disponible en dos conjuntos distintos: un conjunto de entrenamiento y un conjunto de prueba. Aquí se explica en detalle cómo funciona:

  • División de Datos: El primer paso consiste en dividir el conjunto de datos original en dos partes: el conjunto de entrenamiento y el conjunto de prueba. La división más común es utilizar el 80% de los datos para entrenamiento y el 20% restante para prueba. Esto puede variar según el problema y el tamaño del conjunto de datos.
  • Entrenamiento del Modelo: En esta etapa, utilizamos el conjunto de entrenamiento para enseñar al modelo cómo debe realizar las predicciones. El modelo ajusta sus parámetros y características utilizando los datos de entrenamiento. Por ejemplo, en una regresión lineal, el modelo aprendería la mejor línea de ajuste que minimiza el error en el conjunto de entrenamiento.
  • Prueba del Modelo: Una vez que el modelo ha sido entrenado, lo probamos utilizando el conjunto de prueba. El modelo intentará predecir los valores de salida (o etiquetas) basándose en las características de entrada del conjunto de prueba.
  • Evaluación de la Precisión: Comparamos las predicciones del modelo con los valores reales (etiquetas conocidas) en el conjunto de prueba. La métrica que utilizamos para evaluar la precisión del modelo depende del tipo de problema. Para problemas de regresión, es común utilizar métricas como el error cuadrático medio (MSE), mientras que para problemas de clasificación, se utilizan métricas como la precisión, la exhaustividad y el F1-score.
  • Ajuste del Modelo: Si el modelo no tiene un rendimiento satisfactorio en el conjunto de prueba, es posible que necesitemos ajustarlo. Esto podría implicar la selección de un modelo diferente, la optimización de hiperparámetros o la recopilación de más datos.

El objetivo final del entrenamiento/prueba es evaluar la capacidad del modelo para generalizar patrones a nuevos datos no vistos. Un modelo que se ajusta demasiado al conjunto de entrenamiento puede tener un mal rendimiento en datos de prueba no vistos (sobreajuste), por lo que es importante medir su rendimiento en un conjunto de prueba independiente.

Esta técnica ayuda a evitar la optimización excesiva y proporciona una estimación realista de cómo se desempeñará el modelo en situaciones del mundo real. Por lo tanto, el entrenamiento/prueba es una práctica esencial para el desarrollo de modelos de aprendizaje automático confiables y precisos en Python y otras plataformas de análisis de datos.


Importar bibliotecas

Primero, debe importar las bibliotecas necesarias, que incluyen NumPy y Scikit-learn.

import numpy as np
from sklearn.linear_model import LinearRegression

Preparar los datos de entrenamiento

Supongamos que tiene datos de entrenamiento en dos listas, una para las características (variables independientes) y otra para las etiquetas (variable dependiente o objetivo).

# Datos de entrenamiento
X_train = np.array([1, 2, 3, 4, 5]).reshape(-1, 1)  # Características (reshape para convertirlo en matriz columna)
y_train = np.array([2, 4, 6, 8, 10])  # Etiquetas

Crear y entrenar el modelo

A continuación, cree una instancia del modelo que desea utilizar, en este caso, un modelo de regresión lineal. Luego, ajuste el modelo a los datos de entrenamiento utilizando el método fit().

# Crear modelo
model = LinearRegression()

# Entrenar el modelo
model.fit(X_train, y_train)

Hacer predicciones

Una vez que el modelo ha sido entrenado, puede hacer predicciones en nuevos datos usando el método predict().

# Datos de prueba (nuevos datos)
X_test = np.array([6, 7, 8]).reshape(-1, 1)

# Hacer predicciones
y_pred = model.predict(X_test)

En este ejemplo, hemos entrenado un modelo de regresión lineal para predecir valores en función de una sola característica (X) y luego hemos usado el modelo para hacer predicciones en datos de prueba (X_test).

El proceso de entrenamiento de otros modelos (por ejemplo, regresión logística, máquinas de soporte vectorial, árboles de decisión, etc.) sigue un enfoque similar, donde se importan las bibliotecas adecuadas, se preparan los datos de entrenamiento, se crea y se entrena el modelo, y finalmente se hacen predicciones en nuevos datos.


Ejemplo de Entrenamiento del modelo en Python

En este ejemplo, vamos a entrenar un modelo de regresión lineal para predecir el precio de las casas en función del tamaño (área) de las casas. Utilizaremos la biblioteca Scikit-learn para crear y entrenar el modelo.

import numpy as np
from sklearn.linear_model import LinearRegression

# Datos de entrenamiento
# Área de las casas en metros cuadrados
X_train = np.array([60, 80, 100, 120, 150, 180, 200, 220, 250]).reshape(-1, 1)

# Precio de las casas en miles de dólares
y_train = np.array([100, 150, 200, 230, 280, 320, 350, 400, 450])

# Crear modelo de regresión lineal
model = LinearRegression()

# Entrenar el modelo con los datos de entrenamiento
model.fit(X_train, y_train)

# Hacer predicciones en nuevos datos
# Supongamos que queremos predecir el precio de una casa de 180 metros cuadrados
X_new = np.array([180]).reshape(-1, 1)
y_pred = model.predict(X_new)

print("Precio predicho para una casa de 180 metros cuadrados:", y_pred[0])

En este ejemplo, hemos utilizado el tamaño (área) de las casas como la característica (X) y el precio de las casas como la etiqueta (y). Hemos creado un modelo de regresión lineal y lo hemos entrenado con los datos de entrenamiento. Luego, hemos utilizado el modelo entrenado para hacer una predicción del precio de una casa de 180 metros cuadrados.

Es importante destacar que este es solo un ejemplo sencillo para ilustrar el proceso de entrenamiento de un modelo de regresión lineal. En la práctica, se suelen utilizar conjuntos de datos más grandes y complejos, y se pueden utilizar diferentes algoritmos de aprendizaje automático según el tipo de problema que se esté abordando.


Comenzar con un conjunto de datos

En este caso, simularemos una métrica de clics en anuncios en función del gasto en publicidad en línea. Utilizaremos datos generados aleatoriamente para ilustrar esta relación. Aquí tienes el código y la descripción:

import numpy as np
import matplotlib.pyplot as plt

# Configuración de la generación de números aleatorios para reproducibilidad
np.random.seed(3)

# Generar datos aleatorios para el gasto en publicidad (en dólares)
gasto_publicidad = np.random.normal(5000, 1500, 100)

# Generar datos aleatorios para el número de clics en anuncios
clics_anuncios = np.random.normal(1000, 300, 100) - (gasto_publicidad / 1000)

# Crear un diagrama de dispersión (scatter plot) para visualizar los datos
plt.scatter(gasto_publicidad, clics_anuncios)

# Etiquetas de ejes y título
plt.xlabel('Gasto en Publicidad (USD)')
plt.ylabel('Clics en Anuncios')
plt.title('Relación entre Gasto en Publicidad y Clics en Anuncios')

# Mostrar el diagrama de dispersión
plt.show()

Explicación del código:

  1. Importamos las bibliotecas numpy y matplotlib.pyplot como antes.
  2. Establecemos una semilla de generación de números aleatorios para reproducibilidad (np.random.seed(3)).
  3. Generamos datos aleatorios para el gasto en publicidad en línea utilizando np.random.normal(). Los valores tienen una media de $5000 y una desviación estándar de $1500, y se generan 100 valores.
  4. Generamos datos aleatorios para el número de clics en anuncios en función del gasto en publicidad. Utilizamos una media de 1000 clics y una desviación estándar de 300, pero restamos una fracción del gasto en publicidad (dividido por 1000) para simular una posible relación inversa entre el gasto y los clics.
  5. Creamos un diagrama de dispersión (scatter plot) para visualizar los datos. Los valores de gasto en publicidad se representan en el eje horizontal y los valores de clics en anuncios en el eje vertical.
  6. Agregamos etiquetas a los ejes y un título al gráfico.
  7. Finalmente, mostramos el diagrama de dispersión con plt.show().

Resultado:

diagrama de dispersión entrenamiento del modelo en python

Este gráfico de dispersión muestra la relación entre el gasto en publicidad en línea y el número de clics en anuncios. Cada punto representa una observación que muestra cuánto se gastó en publicidad y cuántos clics se obtuvieron como resultado. La simulación incluye una posible relación inversa entre el gasto y los clics, lo que significa que a medida que aumenta el gasto, los clics pueden disminuir. Esta visualización podría ayudar a los profesionales del marketing digital a comprender mejor cómo sus estrategias de gasto afectan el rendimiento de los anuncios en línea.


Dividir datos en entrenamiento/prueba

Para dividir tus datos en conjuntos de entrenamiento y prueba en Python, puedes usar rebanadas (slices) de arreglos de NumPy. Asegúrate de que tus datos estén previamente mezclados aleatoriamente para evitar sesgos. Aquí tienes el código correspondiente:

import numpy as np
import matplotlib.pyplot as plt

# Datos de ejemplo
x = np.array([1, 2, 3, 4, 5])
y = np.array([2, 3, 2.5, 4, 3.5])

# Resto del código (mezcla aleatoria y división en conjuntos de entrenamiento/prueba)
indices_mezclados = np.random.permutation(len(x))
x_mezclado = x[indices_mezclados]
y_mezclado = y[indices_mezclados]

tamanio_entrenamiento = int(0.8 * len(x_mezclado))
tamanio_prueba = len(x_mezclado) - tamanio_entrenamiento

tren_x = x_mezclado[:tamanio_entrenamiento]
tren_y = y_mezclado[:tamanio_entrenamiento]

prueba_x = x_mezclado[tamanio_entrenamiento:]
prueba_y = y_mezclado[tamanio_entrenamiento:]

Este código asegura que tus datos estén mezclados aleatoriamente antes de dividirlos en conjuntos de entrenamiento y prueba. Luego, utiliza el 80% de los datos para entrenamiento y el 20% restante para pruebas, como lo habías mencionado en tu pregunta.


Mostrar el conjunto de entrenamiento

Muestre el mismo diagrama de dispersión con el conjunto de entrenamiento:

# Mostrar el diagrama de dispersión con el conjunto de entrenamiento
plt.scatter(tren_x, tren_y)
plt.show()

Resultado:

diagrama de dispersion resultado de dividir en entrenamiento prueba

Mostrar el conjunto de Prueba

Muestre el mismo diagrama de dispersión con el conjunto de prueba:

# Mostrar el diagrama de dispersión con el conjunto de prueba
plt.scatter(prueba_x, prueba_y)
plt.show()

Resultado:

entrenamiento modelo en python prueba

Ajustar el conjunto de datos

Dado que los datos parecen seguir una tendencia no lineal, podría ser más apropiado considerar modelos de regresión no lineales, como regresión polinómica, regresión exponencial, regresión logarítmica, entre otros. En este caso probaremos con una regresión polinomica.

Vamos a utilizar el método plot() del módulo matplotlib para trazar la línea entre los puntos. Primero ajustaremos un modelo polinomico a los datos y luego utilizaremos matplotlib para trazar la curva polinómica resultante.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures

# Datos de ejemplo
x = np.array([1, 2, 3, 4, 5])
y = np.array([2, 3, 2.5, 4, 3.5])

# Resto del código (mezcla aleatoria y división en conjuntos de entrenamiento/prueba)
indices_mezclados = np.random.permutation(len(x))
x_mezclado = x[indices_mezclados]
y_mezclado = y[indices_mezclados]

tamanio_entrenamiento = int(0.8 * len(x_mezclado))
tamanio_prueba = len(x_mezclado) - tamanio_entrenamiento

tren_x = x_mezclado[:tamanio_entrenamiento]
tren_y = y_mezclado[:tamanio_entrenamiento]

prueba_x = x_mezclado[tamanio_entrenamiento:]
prueba_y = y_mezclado[tamanio_entrenamiento:]

# Crear un objeto PolynomialFeatures para generar características polinómicas
grado_del_polinomio = 2  # Puedes ajustar el grado del polinomio según tu elección
poly_features = PolynomialFeatures(degree=grado_del_polinomio)

# Transformar las características originales en características polinómicas
tren_x_poly = poly_features.fit_transform(tren_x.reshape(-1, 1))

# Crear y entrenar el modelo de regresión lineal con características polinómicas
modelo = LinearRegression()
modelo.fit(tren_x_poly, tren_y)

# Generar valores para la curva de regresión polinómica
x_valores = np.linspace(min(x), max(x), 100)  # Valores de x para la curva
x_valores_poly = poly_features.transform(x_valores.reshape(-1, 1))  # Transformar para el modelo
y_pred = modelo.predict(x_valores_poly)  # Predicciones

# Visualizar los datos de entrenamiento y la curva de regresión polinómica
plt.scatter(tren_x, tren_y, label='Datos de entrenamiento')
plt.plot(x_valores, y_pred, color='red', linewidth=2, label='Regresión Polinómica')
plt.xlabel('Variable Independiente')
plt.ylabel('Variable Dependiente')
plt.legend()
plt.show()

Resultado:

regresion polinomica metodo plot python

El resultado es un gráfico que muestra los datos de entrenamiento y la curva de regresión polinómica que se ajusta a esos datos. Esta es una forma de modelar relaciones no lineales entre variables independientes y dependientes utilizando una regresión polinómica.

Asegúrate de tener scikit-learn instalado para poder utilizar PolynomialFeatures y LinearRegression. Puedes ajustar el grado del polinomio cambiando el valor de la variable grado_polinomio.


Coeficiente de determinación R cuadrado

El coeficiente de determinación R cuadrado es una métrica estadística que se utiliza para medir la bondad del ajuste de un modelo de regresión a los datos observados. En otras palabras, R^2 indica qué porcentaje de la variación en la variable dependiente puede explicarse por el modelo de regresión.

  • R^2 tiene un rango de 0 a 1.
  • R^2 = 0 significa que el modelo no explica ninguna variación en los datos, lo que indica que el modelo no es útil para hacer predicciones.
  • R^2 = 1 significa que el modelo explica toda la variación en los datos y se ajusta perfectamente a los puntos de datos.

En el contexto de medir la relación entre los minutos que un cliente permanece en la tienda y cuánto dinero gasta, puedes utilizar el método r2_score() de scikit-learn para calcular el coeficiente de determinación R^2. Aquí tienes un ejemplo de cómo hacerlo:

import numpy as np
from sklearn.metrics import r2_score
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression

# Datos de ejemplo
minutos_en_tienda = np.array([10, 20, 30, 40, 50])
dinero_gastado = np.array([50, 100, 150, 200, 250])

# Crear un objeto PolynomialFeatures para generar características polinómicas de grado 2
poly_features = PolynomialFeatures(degree=2)
minutos_en_tienda_poly = poly_features.fit_transform(minutos_en_tienda.reshape(-1, 1))

# Crear y entrenar el modelo de regresión lineal con características polinómicas
modelo = LinearRegression()
modelo.fit(minutos_en_tienda_poly, dinero_gastado)

# Hacer predicciones en los mismos datos de entrada para el gráfico
predicciones = modelo.predict(minutos_en_tienda_poly)

# Calcular R^2
r_cuadrado = r2_score(dinero_gastado, predicciones)

print("Coeficiente de determinación (R^2):", r_cuadrado)

Resultado:

Coeficiente de determinación (R^2): 1.0
  • R^2 = 1: El modelo explica perfectamente la variabilidad en los datos.

Un R^2 más cercano a 1 indica que el modelo se ajusta bien a los datos y puede hacer buenas predicciones. Un valor más cercano a 0 indica que el modelo no se ajusta bien a los datos y no es útil para hacer predicciones precisas.

Para obtener el resultado específico del código que proporcionaste, necesitas ejecutarlo con los datos de entrada minutos_en_tienda y dinero_gastado. El resultado se imprimirá en la consola como «Coeficiente de determinación (R^2):» seguido del valor R^2 calculado para ese conjunto de datos y modelo en particular.

En este código, debes ajustar un modelo de regresión apropiado a tus datos (en lugar de predicciones, deberías usar las predicciones reales del modelo). Luego, utilizas r2_score() para calcular R^2 y determinar cuánta variación en el dinero gastado puede explicarse por los minutos en la tienda. Un valor más cercano a 1 indica una relación más fuerte entre las dos variables.