Declarar redes neuronales de forma clara

22 de octubre del 2024

Declare neural networks clearly

Cuando en PyTorch se crea una red neuronal como una lista de capas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		import torch
      import torch.nn as nn
      
      class Network(nn.Module):
          def __init__(self):
              super(Network, self).__init__()
              self.layers = nn.ModuleList([
                  nn.Linear(1, 10),
                  nn.ReLU(),
                  nn.Linear(10, 1)
              ])
	
	Copied

Luego iterar por ella en el método forward no es tan claro

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		import torch
      import torch.nn as nn
      
      class Network(nn.Module):
          def __init__(self):
              super(Network, self).__init__()
              self.layers = nn.ModuleList([
                  nn.Linear(1, 10),
                  nn.ReLU(),
                  nn.Linear(10, 1)
              ])
import torch
      import torch.nn as nn
      
      class Network(nn.Module):
          def __init__(self):
              super(Network, self).__init__()
              self.layers = nn.ModuleList([
                  nn.Linear(1, 10),
                  nn.ReLU(),
                  nn.Linear(10, 1)
              ])
          
          def forward(self, x):
              for layer in self.layers:
                  x = layer(x)
              return x
	
	Copied

Sin embargo, cuando se crea una red neuronal como un diccionario de capas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		import torch
      import torch.nn as nn
      
      class Network(nn.Module):
          def __init__(self):
              super(Network, self).__init__()
              self.layers = nn.ModuleList([
                  nn.Linear(1, 10),
                  nn.ReLU(),
                  nn.Linear(10, 1)
              ])
import torch
      import torch.nn as nn
      
      class Network(nn.Module):
          def __init__(self):
              super(Network, self).__init__()
              self.layers = nn.ModuleList([
                  nn.Linear(1, 10),
                  nn.ReLU(),
                  nn.Linear(10, 1)
              ])
          
          def forward(self, x):
              for layer in self.layers:
                  x = layer(x)
              return x
import torch
      import torch.nn as nn
      
      class Network(nn.Module):
          def __init__(self):
              super(Network, self).__init__()
              self.layers = nn.ModuleList({
                  'linear': nn.Linear(1, 10),
                  'activation': nn.ReLU(),
                  'output': nn.Linear(10, 1)
              })
	
	Copied

Luego iterar por ella en el método forward es más claro

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		import torch
      import torch.nn as nn
      
      class Network(nn.Module):
          def __init__(self):
              super(Network, self).__init__()
              self.layers = nn.ModuleList([
                  nn.Linear(1, 10),
                  nn.ReLU(),
                  nn.Linear(10, 1)
              ])
import torch
      import torch.nn as nn
      
      class Network(nn.Module):
          def __init__(self):
              super(Network, self).__init__()
              self.layers = nn.ModuleList([
                  nn.Linear(1, 10),
                  nn.ReLU(),
                  nn.Linear(10, 1)
              ])
          
          def forward(self, x):
              for layer in self.layers:
                  x = layer(x)
              return x
import torch
      import torch.nn as nn
      
      class Network(nn.Module):
          def __init__(self):
              super(Network, self).__init__()
              self.layers = nn.ModuleList({
                  'linear': nn.Linear(1, 10),
                  'activation': nn.ReLU(),
                  'output': nn.Linear(10, 1)
              })
import torch
      import torch.nn as nn
      
      class Network(nn.Module):
          def __init__(self):
              super(Network, self).__init__()
              self.layers = nn.ModuleList({
                  'linear': nn.Linear(1, 10),
                  'activation': nn.ReLU(),
                  'output': nn.Linear(10, 1)
              })
          
          def forward(self, x):
              x = self.layers['linear'](x)
              x = self.layers['activation'](x)
              x = self.layers['output'](x)
              return x
	
	Copied

Preguntas frecuentes

¿Por qué se accede a las capas con self.layers['linear'](x) en vez de iterar con for layer in self.layers?

Cuando las capas se guardan como lista (nn.ModuleList con corchetes [...]), solo se puede iterar con for layer in self.layers: x = layer(x), perdiendo el nombre de cada capa. Cuando se guardan como diccionario (llaves {...} con claves como 'linear', 'activation', 'output'), el forward puede llamarlas explícitamente por nombre, x = self.layers['linear'](x), dejando mucho más claro qué transformación se aplica en cada paso.

Me da TypeError: str is not a Module subclass al pasar un diccionario a nn.ModuleList, ¿cómo lo soluciono?

nn.ModuleList espera un iterable de módulos; al pasarle un diccionario como nn.ModuleList({'linear': nn.Linear(1,10), ...}), Python itera sobre las claves (strings) y no sobre los valores, por lo que PyTorch intenta registrar el string 'linear' como si fuera una capa y lanza TypeError: str is not a Module subclass. La solución es usar nn.ModuleDict({...}) en lugar de nn.ModuleList({...}), pensado para almacenar submódulos con nombre y que sí permite indexarlos como self.layers['linear'].

Seguir leyendo

Cómo declarar tools fiables para OpenAI, Anthropic y Google

Guía práctica para diseñar tools que un LLM pueda descubrir, adaptar a cualquier proveedor de LLMs, ejecutar con seguridad y proteger con tests.

Gymnasia: arquitectura de un agente de IA que corre en el móvil

Cómo está construido el agente de IA de Gymnasia: un coach conversacional BYOK con tools locales y un estimador de comid...

Deep Research con LangGraph (3/3): agente Writer e informe final

Tercera y última parte de la serie Deep Research con LangGraph. Implementa el agente Writer que redacta el informe final...

Últimos posts -->

¿Has visto estos proyectos?

Gymnasia

LangGraph Deep Researcher

Tau

Ver todos los proyectos -->

>_ Disponible para proyectos

¿Tienes un proyecto con IA?

Hablemos.

maximofn@gmail.com

Especialista en Machine Learning e Inteligencia Artificial. Desarrollo soluciones con IA generativa, agentes inteligentes y modelos personalizados.

Escríbeme LinkedIn

¿Quieres ver alguna charla?

Agentes del Mañana: Descifrando los Enigmas de Planificación, UX y Memoria

Los agentes IA, impulsados por LLMs, prometen transformar aplicaciones. Pero, ¿son hoy simples ejecutores o futuros colaboradores inteligentes? Para a...

Crea tu propio Apple intelligence

Aprende a crear un sistema de IA para ejecutar eficientemente en un dispositivo

Últimas charlas -->

¿Quieres mejorar con estos tips?

Buenas prácticas creando agentes con Claude Code

Charla técnica: skills, subagentes, slash commands y MCPs en Claude Code

o1 prompt engineering

Crear mejores prompts para o1 siguiendo un ejemplo

Memory profiler

Ver el uso de memoria de un script

Últimos tips -->

Usa esto en local

Los espacios de Hugging Face nos permite ejecutar modelos con demos muy sencillas, pero ¿qué pasa si la demo se rompe? O si el usuario la elimina? Por ello he creado contenedores docker con algunos espacios interesantes, para poder usarlos de manera local, pase lo que pase. De hecho, es posible que si pinchas en alún botón de ver proyecto te lleve a un espacio que no funciona.