Regresión Lineal con PyTorch: Creación y Partición de Datos Artificiales

Contenido del curso

Fundamentos de PyTorch

Estructura de modelo de deep learning en PyTorch

Redes neuronales con PyTorch

Cierre del curso

24
Qué aprendiste en el curso de PyTorch
01:13 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:008:13

Regresión Lineal con PyTorch: Creación y Partición de Datos Artificiales

Curso de Redes Neuronales con PyTorch

Clase 7 de 24

Clase 7 / 24

Comentarios (9)9 comentarios

Jeison Wu Mitre

Hace 3 años

La 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

John Alexander Ortiz Ramirez

Hace un año•editado

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]

Bryan Castano

Hace 9 meses•editado

Hola Chicos, Yo tengo una seria observacion a esta clase, Fuese como el Profesor dividio el dataset sintetico que el mismo creo:

El ejemplo es muy basico y sencillo.
. para partir el dataset de los <vectors> X, y, huibera usado la uncion train_test_split de sklearn que es mucho mas recomendable que hacerl o manualmente.
LO que hizo es realmente Terrible en el ML, esta entreando el modelo con los primeros 28 elementos de X con los priemros 28 de y, y dejando lso ultimo 12 para test de validation, esto rompe con la aleatoriedad que se debe tener para hacer este proceso.
Yo supongo que es por fines didacticos, tal vez proque se esta entrenado un modelo de regresion lineal para una simple linea recta de pendiente cosntante, pero Nunca se debe hacer esto en un dataset real, jamas, ya que estamos sesgando el modelo a entrenar,
Siempre hay que barajar "Shuffle " los datos para luego partirlos, No es recomendable partir un dataset de esta forma, siempre debe hacerse de forma aleatoria para lograr una buena generalizacion, mas si ya sabesmos que el modelo no-lineal.
para este caso ,"Nosostros" sabemos que es una lienal recta l oque se pretende modelar, por l oque n ocreo que haya probolema,
En casos reales , ees mejor usar test_train_split de sklearn, para no provocar Overfitting a neustros modelos.

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.

Jhonntan Andres Castaño Rojas

Hace 3 años

este profesor es increiblemente bueno, sus plantillas para desarrollar en clase permiten que uno se desgaste y se dedique a entender

Edgar A. Gonzalez Ambriz

Hace 3 años

Sí, así es. En mi caso me gustaría que sus explicaciones fueran un poco mas amplias

Sebastián Franco

Hace 3 años

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,

Mario Alexander Vargas Celis

Hace 2 años

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.

IVAN CARAPIA BARAJAS

Hace 8 meses

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))

Octavio De Paula

Hace 2 años

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.

Federico Arias

Hace 3 años

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.

Recursos

¿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!

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]

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]}')

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))

Resumen

¿Cómo crear un modelo de regresión lineal?

¿Cómo generamos datos artificiales con PyTorch?

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?

# 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))

¿Qué sigue después?

Fundamentos de PyTorch

Clasificación de Texto con PyTorch y TorchText en Google Colab

Introducción a PyTorch: Ventajas y Comparación con Otros Frameworks

Clasificador de texto con nn.Module en PyTorch

Tensores en PyTorch desde cero

Debuguea tensores en PyTorch sin errores

Operaciones con tensores y conversión NumPy-PyTorch

Estructura de modelo de deep learning en PyTorch

Regresión Lineal con PyTorch: Creación y Partición de Datos Artificiales

Regresión lineal desde cero en PyTorch

Bucle de entrenamiento con SGD en PyTorch

Entrenamiento y Visualización de Modelos de Regresión Lineal en PyTorch

Inferencia y predicciones con PyTorch

Redes neuronales con PyTorch

Clasificación de texto con TorchText y DBpedia

Tokenización y Vocabulario en TorchText para DBpedia

DataLoader y collate function en PyTorch

Arquitectura de clasificación de texto en PyTorch

Entrenamiento de Modelos de Clasificación con DBpedia Dataset

Evaluación de Modelos de Aprendizaje Automático en PyTorch

Optimizador y splits de datos en PyTorch

Entrenamiento y Evaluación de Modelos en PyTorch

Inferencia con torch.compile en PyTorch 2.0

Guardado y carga de modelos en PyTorch con checkpoints

Subir modelos al Hub de Hugging Face

Cómo cargar pesos desde Hugging Face en PyTorch

Cierre del curso

Qué aprendiste en el curso de PyTorch

Regresión Lineal con PyTorch: Creación y Partición de Datos Artificiales

Progreso del curso

Fundamentos de PyTorch

Estructura de modelo de deep learning en PyTorch

Redes neuronales con PyTorch

Cierre del curso

Recursos

Recursos