Contenido del curso
Regresión Lineal con PyTorch: Creación y Partición de Datos Artificiales
¿Cómo crear un modelo de regresión lineal?
Cuando empiezas a adentrarte en el mundo del machine learning, uno de los modelos más básicos y fundamentales que aprenderás es el de regresión lineal. Este tipo de modelo te permitirá comprender mejor cómo varían dos variables y cómo predecir una con base en la otra. En este módulo, exploraremos cómo crear, entrenar y evaluar un modelo de regresión lineal utilizando un set de datos artificial.
¿Cómo generamos datos artificiales con PyTorch?
Comencemos con algo básico pero esencial: generar datos artificiales que nos ayudarán a entrenar nuestro modelo. Usaremos PyTorch, una biblioteca famosa por su versatilidad en tareas de machine learning.
import torch import matplotlib.pyplot as plt # Generar datos en X X = torch.arange(0, 1, 0.025).unsqueeze(1) # Crear función lineal para Y Y = X * 2.5 + 1.0
Al usar la función torch.arange, creamos un tensor que va de 0 a 1 en pasos de 0.025. Posteriormente, ajustamos la forma del tensor con unsqueeze para que sea compatible con nuestro modelo.
¿Cómo se define el conjunto de entrenamiento y prueba?
Para medir el rendimiento de nuestro modelo, es crucial dividir los datos en un conjunto de entrenamiento y uno de prueba. Así, podremos evaluar la capacidad del modelo para prever datos nuevos que no ha visto durante su entrenamiento.
# Determinación del tamaño de entrenamiento train_size = int(0.7 * len(X)) # Crear los conjuntos de entrenamiento y prueba X_train, Y_train = X[:train_size], Y[:train_size] X_test, Y_test = X[train_size:], Y[train_size:]
Optamos por usar el 70% de los datos para entrenamiento, marcando el límite en el índice calculado train_size. Esto nos deja el 30% restante para la validación.
¿Cómo visualizar nuestros datos?
Visualizar cómo están distribuidos nuestros datos de entrenamiento y prueba, así como las predicciones del modelo, es crucial para entender el rendimiento.
def plot_predictions(train_data, test_data): plt.scatter(train_data[0].numpy(), train_data[1].numpy(), label='Entrenamiento', color='green') plt.scatter(test_data[0].numpy(), test_data[1].numpy(), label='Prueba', color='yellow') plt.legend() plt.show() plot_predictions((X_train, Y_train), (X_test, Y_test))
Esta función plot_predictions nos brinda una representación gráfica clara de nuestros datos. Los puntos verdes indican datos de entrenamiento y los amarillos, los de prueba, permitiéndonos visualizar su distribución.
¿Qué sigue después?
Ahora que nuestros datos están listos y bien divididos, estamos en la etapa adecuada para definir la arquitectura del modelo de regresión lineal. Este proceso te permitirá darle vida al modelo y comprender cómo interactúa con los datos. ¡Mantente atento a la siguiente clase, donde profundizaremos en este emocionante paso!
Jeison Wu Mitre
Estudiante
John Alexander Ortiz Ramirez
Estudiante
Bryan Castano
Estudiante
Jhonntan Andres Castaño Rojas
Estudiante
Edgar A. Gonzalez Ambriz
Estudiante
Sebastián Franco
Estudiante
Mario Alexander Vargas Celis
Estudiante
IVAN CARAPIA BARAJAS
Estudiante
Octavio De Paula
Estudiante
Federico Arias
EstudianteLa importancia de separar los datos
Es importante mencionar que debemos separar nuestros datos para tener un grupo de entrenamiento y otro prueba, todo esto con intenciones que no se produzca el problema de sobreajuste.
El tercero muestra lo que sucede cuando no separamos los datos
Agregue aliatoriedad el generar los datos y tambien al seleccionar los indices para hacerlo mas interesante al momento de hacer la predicción
def generate_data( beta_0: float, beta_1: float, start: float, end: float, step: float ) -> List[Tensor]: x: Tensor = torch.arange(start, end, step).unsqueeze(dim=1) rand_value: Tensor = (torch.rand(len(x)) - 0.5).unsqueeze(dim=1) * 0.2 y: Tensor = beta_0 + beta_1 * x + rand_value return [x, y] beta_0 = 0.2 #Sesgo beta_1 = 0.8 #Volumen start: float = 0 end: float = 1 step: float = 0.025 x: Tensor y: Tensor x, y = generate_data(beta_0, beta_1, start, end, step) train_size: int = int(0.7 * len(x)) index_rand: Tensor = torch.randperm(len(x) - 0) index_train: Tensor = index_rand[:train_size] index_test: Tensor = index_rand[train_size:] x_train: Tensor = x[index_train] y_train: Tensor = y[index_train] x_test: Tensor = x[index_test] y_test: Tensor = y[index_test]
Hola Chicos, Yo tengo una seria observacion a esta clase, Fuese como el Profesor dividio el dataset sintetico que el mismo creo:
Siendo una liena recta creo uqe no hay pRoblema pero si es algo mas compleo como un polinomio o un dataset de cuhas features es mejor hacerlo de forma aleatoria para evitar "Bias" en nuestros modelos.
este profesor es increiblemente bueno, sus plantillas para desarrollar en clase permiten que uno se desgaste y se dedique a entender
Sí, así es. En mi caso me gustaría que sus explicaciones fueran un poco mas amplias
Por si tienen curiosidad, lo que se hace es partir el dataset en 2 subsets (train y test) y test suele dividirse en otros 2 (validation y test).
En la realidad se usa un porcentaje muy bajo de los datos para ser usados en validación y test (la validación es un test que se hace en vivo por cada época de entrenamiento mientras que el test es la determinación final del performance y solo se calcula una vez el modelo ha sido entrenado).
Si tenemos datos por el orden de millones no es raro ver que el 2% o 5% es dedicado a test, pero en valores brutos refleja cientos de miles de ejemplos, por lo que sí se puede verificar que la generalización se está logrando, sin embargo, cuando el dataset no es tan grande, se debe entregar una buena fracción de los datos para asegurar que la generalización se ha logrado.
Los datos de prueba son sagrados y no se deben adulterar ni ser vistos por el modelo en alguna etapa del entrenamiento, de esta manera aseguraremos el performance real del modelo,
La generación y el split de datos son pasos cruciales en el proceso de entrenamiento de modelos de machine learning. Aquí te explico los conceptos clave y cómo se implementan:
### Generación de Datos
La generación de datos puede referirse a varios métodos, incluyendo:
1. **Recopilación de Datos:**
- Obtener datos de fuentes existentes (bases de datos, archivos CSV, APIs, etc.).
- Generar datos sintéticos usando técnicas como la simulación o algoritmos generativos.
2. **Preprocesamiento:**
- Limpieza de datos: Eliminar duplicados, manejar valores nulos, corregir errores en los datos.
- Transformación de datos: Normalización, escalado, codificación de variables categóricas, etc.
- División en características (features) y etiquetas (labels).
### Split de Datos
Dividir el conjunto de datos en diferentes subsets es esencial para evaluar el rendimiento del modelo. Los splits más comunes son:
1. **Training Set (Conjunto de Entrenamiento):**
- Usado para entrenar el modelo. Generalmente, este conjunto representa el 70-80% de los datos.
2. **Validation Set (Conjunto de Validación):**
- Usado para ajustar los hiperparámetros del modelo y evitar el overfitting. Comúnmente representa un 10-15% de los datos.
3. **Test Set (Conjunto de Prueba):**
- Usado para evaluar el rendimiento final del modelo. Similar al conjunto de validación, representa el 10-15% de los datos.
### Implementación en Python
Aquí te muestro un ejemplo de cómo puedes dividir un conjunto de datos usando train\_test\_split de scikit-learn:
import pandas as pd from sklearn.model\_selection import train\_test\_split \# Cargar datos data = pd.read\_csv('dataset.csv') \# Separar características y etiquetas X = data.drop('target', axis=1) # Características y = data\['target'] # Etiquetas \# Dividir el conjunto de datos X\_train, X\_temp, y\_train, y\_temp = train\_test\_split(X, y, test\_size=0.3, random\_state=42) X\_val, X\_test, y\_val, y\_test = train\_test\_split(X\_temp, y\_temp, test\_size=0.5, random\_state=42) \# Tamaños de los conjuntos print(f'Tamaño del conjunto de entrenamiento: {X\_train.shape\[0]}') print(f'Tamaño del conjunto de validación: {X\_val.shape\[0]}') print(f'Tamaño del conjunto de prueba: {X\_test.shape\[0]}')
### Consideraciones
- **Aleatoriedad:** Siempre es recomendable establecer una semilla (usando random\_state) para garantizar que los splits sean reproducibles.
- **Estratificación:** Si el conjunto de datos es desequilibrado, es recomendable usar stratify en train\_test\_split para mantener la proporción de clases en los conjuntos.
import torch import matplotlib.pyplot as plt # Generar datos en X X = torch.arange(0, 1, 0.025).unsqueeze(1) # Crear función lineal para Y Y = X * 2.5 + 1.0 # Determinación del tamaño de entrenamiento train_size = int(0.7 * len(X)) # Crear los conjuntos de entrenamiento y prueba X_train, Y_train = X[:train_size], Y[:train_size] X_test, Y_test = X[train_size:], Y[train_size:] def plot_predictions(train_data, test_data): plt.scatter(train_data[0].numpy(), train_data[1].numpy(), label='Entrenamiento', color='green') plt.scatter(test_data[0].numpy(), test_data[1].numpy(), label='Prueba', color='yellow') plt.legend() plt.show() plot_predictions((X_train, Y_train), (X_test, Y_test))
La función unsqueeze agrega una dimensión en la posición especificada. Por ejemplo, si tenemos un tensor de tamaño (3×4) y aplicamos unsqueeze en la dimensión 1, el tamaño del tensor resultante será (3×4×1), es decir, se agrega una dimensión en la posición 1.
Por que no usamos test_train_split de sklearn? A fines didacticos esta bien lo que hizo, pero si fueran datos reales, no podemos partir el dataset asi, sino se debe hacer de manera aleatoria, porque si los datos fueran divididos tal que el test_set sean los ultimos n numeros, estariamos extrapolando al hacer la regresion, lo cual NO es recomendable.
