Declare redes neurais de forma clara

22 de outubro de 2024

Declare redes neurais de maneira clara

Aviso: Este post foi traduzido para o português usando um modelo de tradução automática. Por favor, me avise se encontrar algum erro.

Quando em PyTorch se cria uma rede neural como uma lista de camadas

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

Depois iterar por ela no método forward não é tão 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

No entanto, quando se cria uma rede neural como um dicionário de camadas

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

Depois iterar por ela no método forward é mais 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

Perguntas frequentes

Por que o método forward acessa as camadas com self.layers['linear'](x) em vez de iterar com for layer in self.layers?

Quando as camadas são armazenadas como lista (nn.ModuleList com colchetes [...]), só é possível iterar com for layer in self.layers: x = layer(x), perdendo o nome de cada camada. Quando são armazenadas como dicionário (chaves {...} com nomes como 'linear', 'activation', 'output'), o forward pode chamá-las explicitamente pelo nome — x = self.layers['linear'](x) —, deixando muito mais claro qual transformação é aplicada em cada etapa.

Recebo TypeError: str is not a Module subclass ao passar um dicionário para nn.ModuleList — como corrijo isso?

O nn.ModuleList espera um iterável de módulos; ao passar um dicionário como nn.ModuleList({'linear': nn.Linear(1,10), ...}), o Python itera sobre as chaves do dicionário (strings), não sobre os valores, então o PyTorch tenta registrar a string 'linear' como uma camada e lança TypeError: str is not a Module subclass. A solução é usar nn.ModuleDict({...}) em vez de nn.ModuleList({...}) — ele foi feito para guardar submódulos nomeados e permite indexá-los como self.layers['linear'].

Continuar lendo

Como parsear tool calls da OpenAI, Anthropic e Google

Como transformar chamadas de tools de diferentes provedores de LLMs em uma interface comum sem perder os identificadores que correlacionam cada resultado.

Como declarar tools confiáveis para OpenAI, Anthropic e Google

Guia prático para criar tools que um LLM consiga descobrir, adaptar para qualquer provedor de LLMs, executar com seguran...

Gymnasia: arquitetura de um agente de IA que roda no celular

Como o agente de IA do Gymnasia foi construído: um coach conversacional BYOK com tools locais e um estimador de refeiçõe...

Últimos posts -->

Você viu esses projetos?

Gymnasia

LangGraph Deep Researcher

Tau

Ver todos os projetos -->

>_ Disponível para projetos

Tem um projeto com IA?

Vamos conversar.

maximofn@gmail.com

Especialista em Machine Learning e Inteligência Artificial. Desenvolvo soluções com IA generativa, agentes inteligentes e modelos personalizados.

Escreva-me LinkedIn

Quer assistir alguma palestra?

Agentes do Amanhã: Descifrando os Mistérios da Planificação, UX e Memória

Agentes de IA, impulsionados por LLMs, prometem transformar aplicações. Mas eles são meros executores hoje ou futuros colaboradores inteligentes? Para...

Crie sua própria inteligência Apple

Aprenda a criar um sistema de IA para executar eficientemente em um dispositivo

Últimas palestras -->

Quer melhorar com essas dicas?

Boas práticas criando agentes com Claude Code

Palestra técnica: skills, subagentes, slash commands e MCPs no Claude Code

o1 prompt engineering

Criar prompts melhores para o1 seguindo um exemplo

Memory profiler

Ver o uso de memória de um script

Últimos tips -->

Use isso localmente

Os espaços do Hugging Face nos permitem executar modelos com demos muito simples, mas e se a demo quebrar? Ou se o usuário a deletar? Por isso, criei contêineres docker com alguns espaços interessantes, para poder usá-los localmente, aconteça o que acontecer. Na verdade, se você clicar em qualquer botão de visualização de projeto, ele pode levá-lo a um espaço que não funciona.