Función torch.nn.Sequential de PyTorch
Manual de referencia de torch.nn de PyTorch
torch.nn.SequentialEs un contenedor en PyTorch para construir rápidamente modelos secuenciales.
Ejecuta cada módulo en el orden declarado, adecuado para construir redes lineales simples.
Definición de la función
torch.nn.Sequential(*args)
Descripción de parámetros:
*args: Cualquier número de módulos, se ejecutarán en el orden en que se pasen.
Ejemplo de uso
Ejemplo 1: Uso básico
Construyendo una red simple con Sequential:
Ejemplo
import torch.nn as nn
# Crear contenedor secuencial
model = nn.Sequential(
nn.Linear(10, 20),
nn.ReLU(),
nn.Linear(20, 5)
)
# Probar la propagación hacia adelante
input_tensor = torch.randn(3, 10)
output = model(input_tensor)
print("Estructura del modelo:")
print(model)
print("nForma de entrada:", input_tensor.shape)
print("Forma de salida:", output.shape)
Ejemplo 2: Nombrar capas con OrderedDict
Asigne un nombre a cada capa mediante OrderedDict:
Ejemplo
import torch.nn as nn
from collections import OrderedDict
# Nombrar capas con OrderedDict
model = nn.Sequential(OrderedDict([
('fc1', nn.Linear(784, 256)),
('relu1', nn.ReLU()),
('fc2', nn.Linear(256, 128)),
('relu2', nn.ReLU()),
('output', nn.Linear(128, 10))
]))
# Se puede acceder a las capas por nombre
print("Capa fc1:", model.fc1)
print("Capa relu1:", model.relu1)
# Prueba
x = torch.randn(32, 784)
output = model(x)
print("nForma de salida:", output.shape)
Ejemplo 3: Ejemplo de CNN
Construyendo una red neuronal convolucional:
Ejemplo
import torch.nn as nn
cnn = nn.Sequential(
# Primer bloque convolucional
nn.Conv2d(3, 32, kernel_size=3, padding=1),
nn.BatchNorm2d(32),
nn.ReLU(),
nn.MaxPool2d(2, 2),
# Segundo bloque convolucional
nn.Conv2d(32, 64, kernel_size=3, padding=1),
nn.BatchNorm2d(64),
nn.ReLU(),
nn.MaxPool2d(2, 2),
# Aplanar
nn.Flatten(),
nn.Linear(64 * 8 * 8, 256),
nn.ReLU(),
nn.Dropout(0.5),
nn.Linear(256, 10)
)
# Prueba
x = torch.randn(4, 3, 32, 32)
output = cnn(x)
print("Estructura de la CNN:")
print(cnn)
print("nForma de entrada:", x.shape)
print("Forma de salida:", output.shape)
Ejemplo 4: Acceder a la salida de capas intermedias
Usando forward hooks para acceder a capas intermedias:
Ejemplo
import torch.nn as nn
# Red simple
model = nn.Sequential(
nn.Linear(10, 20),
nn.ReLU(),
nn.Linear(20, 10)
)
# Método 1: usar hooks
feature = None
def hook_fn(module, input, output):
global feature
feature = output.clone()
# Registrar hook
model[1].register_forward_hook(hook_fn)
# Propagación hacia adelante
x = torch.randn(1, 10)
output = model(x)
print("Forma de salida de ReLU:", feature.shape)
print("Salida de ReLU:", feature.squeeze().tolist())
Sequential vs. definir forward manualmente
| Método | Ventajas | Desventajas |
|---|---|---|
nn.Sequential |
Conciso, construcción rápida | Poca flexibilidad, no se pueden compartir capas |
| Definición manual de forward | Control flexible del flujo de datos | Más código |
Preguntas frecuentes
P1: ¿Cómo obtener una capa en Sequential?
Acceda por índice o nombre:model[0]omodel.fc1
P2: ¿Es Sequential adecuado para todas las redes?
No es adecuado para redes con conexiones de salto, estructuras ramificadas o flujos de datos complejos.
P3: ¿Cómo modificar capas en Sequential?
Se puedemodel[index] = new_modulereemplazar la capa especificada.
Escenarios de uso
nn.SequentialLos principales escenarios de uso incluyen:
- Redes simples: MLP, CNN apilados linealmente
- Prototipado rápido: Validar rápidamente ideas de modelos
- Extracción de características: Estructura de red fija
Consejo: para redes complejas, se recomienda heredar de nn.Module y definir manualmente el método forward.
Otras extensiones