Clase 8 de 24 • Curso de Redes Neuronales con PyTorch
Contenido del curso
Jhonntan Andres Castaño Rojas
Jhonntan Andres Castaño Rojas
Mario Alexander Vargas Celis
Nydia Mejía Zavala
Juan Acevedo
IVAN CARAPIA BARAJAS
Alejandro Giraldo Londoño
Gracias profe sus clases son las que mas me han gustado
es buenisimo que tenga las plantillas para que uno desarrolle la clase
Claro, la estructura de un modelo en PyTorch se define comúnmente utilizando el módulo torch.nn, que proporciona herramientas para construir redes neuronales de manera eficiente. A continuación, te explico cómo se construye un modelo y te doy un ejemplo.
### Estructura de un Modelo en PyTorch
1. **Definición de la Clase del Modelo:**
- Se crea una clase que hereda de torch.nn.Module.
- En el constructor \_\_init\_\_, se definen las capas de la red neuronal (como Linear, Conv2d, etc.).
- En el método forward, se definen las operaciones que se aplican a las entradas a través de las capas.
2. **Método forward:**
- Este método toma la entrada y la pasa a través de las diferentes capas de la red en el orden que se definieron en \_\_init\_\_.
3. **Instanciación y Uso:**
- Una vez definido el modelo, se puede instanciar y utilizar para realizar predicciones o entrenarlo con datos.
### Ejemplo de un Modelo Simple
Aquí tienes un ejemplo de un modelo de red neuronal simple con una capa oculta:
import torch import torch.nn as nn import torch.optim as optim \# Definición del modelo class SimpleNN(nn.Module):   def \_\_init\_\_(self, input\_size, hidden\_size, output\_size):   super(SimpleNN, self).\_\_init\_\_()   \# Definir las capas   self.fc1 = nn.Linear(input\_size, hidden\_size) # Capa oculta   self.fc2 = nn.Linear(hidden\_size, output\_size) # Capa de salida   self.relu = nn.ReLU() # Función de activación ReLU   def forward(self, x):   \# Pasar la entrada a través de las capas   x = self.fc1(x) # Capa oculta   x = self.relu(x) # Activación   x = self.fc2(x) # Capa de salida   return x \# Parámetros del modelo input\_size = 10 # Número de características de entrada hidden\_size = 5 # Número de neuronas en la capa oculta output\_size = 1 # Número de neuronas en la capa de salida (por ejemplo, para regresión) \# Crear una instancia del modelo model = SimpleNN(input\_size, hidden\_size, output\_size) \# Ver la arquitectura del modelo print(model) \# Ejemplo de uso \# Crear un tensor de entrada aleatorio input\_tensor = torch.randn(1, input\_size) # Tamaño del batch = 1 output\_tensor = model(input\_tensor) # Pasar la entrada a través del modelo print("Output:", output\_tensor)
### Explicación del Ejemplo
1. **Definición de la Clase SimpleNN:**
- La clase SimpleNN hereda de nn.Module.
- Se definen dos capas lineales (fc1 y fc2) y una función de activación ReLU.
2. **Método forward:**
- En este método, la entrada se pasa primero a través de la capa oculta y luego se aplica la activación, seguida de la capa de salida.
3. **Instanciación y Uso:**
- Se crea una instancia del modelo y se imprime su arquitectura.
- Un tensor de entrada aleatorio se crea y se pasa a través del modelo para obtener la salida.
### Compilación y Entrenamiento
Para entrenar el modelo, deberás definir una función de pérdida y un optimizador, y luego ejecutar un bucle de entrenamiento que actualice los pesos del modelo en función de los datos.
¿Por qué se usa el valor 42 en torch.manual_seed?
Por lo que he indagado, el número 42 se usa en muchos ejemplos y tutoriales, principalmente por razones culturales y de popularidad, ya que es conocido como "la respuesta a la vida, el universo y todo" en la obra Guía del autoestopista galáctico de Douglas Adams.
En términos técnicos, cualquier valor puede ser usado como seed, pero utilizar uno constante como 42 ayuda a garantizar que los resultados sean reproducibles en experimentos, lo que es crucial en entrenamiento de modelos en PyTorch.
Sin embargo, ¿también puede implicar sesgo? Usar el mismo valor en todos los experimentos puede llevar a un sobreajuste a una configuración específica, limitando la variabilidad en los resultados. Puede que no siempre sea el mejor valor para todos los modelos o datasets, y otros valores pueden ofrecer mejores resultados.
¿Podría usarse otro número? Cualquier número entero serviría. Lo importante es:
torch, numpy, random).Les dejo un código por si quieren calcular de manera casi manual la perdida
with torch.inference_mode(): #Probamos el modelo con los pesos aleatorios resultado = model_lr.forward(X_test) #Calculamos la precisión del modelo resutlado_ = torch.mean((Y_test - resultado)** 2) print(resultado_) #output -> tensor(0.2125)
Devuelve un tensor en 0.213 lo cual en la regresión lineal el valor tiene que estar ≈ 0 de esa manera podemos ver que tan mal el modelo está
Luego si les interesa saber pueden buscar como funciona el proceso del backpropagation ya que en este punto hicimos forward que consiste en mirar con los pesos que hay , como se comporta el modelo usando la función de costo mostrada, pero luego en el back , tenemos que se deriva esa función respecto a los pesos el w1 y w0 que acá conocemos como volumen y sesgo, esto para calcular el gradiente que indica la dirección del error, luego con el descenso del gradiente se encarga de iterar constantemente una n cantidad de veces hasta que este error disminuye, eso gráficamente se puede ver como. Tenemos una grafica , iniciamos en un punto pero tenemos que estar abajo de del todo , el gradiente nos dice donde estamos ubicados, para poder definir hacia donde ir , luego damos paso x pasos (lr - α) hasta llegar a el ≈ 0
import torch from torch import nn class ModeloRegresion(nn.Module): def __init__(self): super().__init__() self.volumen = nn.Parameter(torch.rand(1)) self.sesgo = nn.Parameter(torch.rand(1)) def forward(self, x): return self.volumen * x + self.sesgo torch.manual_seed(42) modelo1 = ModeloRegresion() loss_fn = nn.MSELoss() opt = torch.optim.SGD(modelo1.parameters(), lr=0.1) # Entrenamiento epochs = 500 for epoch in range(epochs): modelo1.train() y_pred = modelo1(X_train) loss = loss_fn(y_pred, Y_train) opt.zero_grad() loss.backward() opt.step() if epoch % 100 == 0: modelo1.eval() with torch.inference_mode(): test_pred = modelo1(X_test) test_loss = loss_fn(test_pred, Y_test) print(f"epoch {epoch} | train_loss {loss.item():.6f} | test_loss {test_loss.item():.6f}") # Resultado final modelo1.eval() with torch.inference_mode(): test_pred = modelo1(X_test) test_loss = loss_fn(test_pred, Y_test) print("Final test loss:", test_loss) print("w (volumen):", modelo1.volumen.item(), "b (sesgo):", modelo1.sesgo.item())
import matplotlib.pyplot as plt import torch modelo1.eval() with torch.inference_mode(): pred_test = modelo1(X_test) # si están en GPU los bajamos x = X_test.detach().cpu().numpy() y_real = Y_test.detach().cpu().numpy() y_pred = pred_test.detach().cpu().numpy() plt.figure() plt.scatter(x, y_real, label="Real") plt.scatter(x, y_pred, label="Predicción") plt.legend() plt.title("Modelo de Regresión Lineal") plt.xlabel("X") plt.ylabel("Y") plt.show()
■ Resumen:
nnModule. La idea central es validar las etapas pre-entrenamiento, post-entrenamiento y su desempeño en cada etapa, así podremos apreciar paso a paso la importancia de los pasos en el proceso.