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

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

Depois iterar por ela no método forward não é tão claro

	
		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

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

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

Depois iterar por ela no método forward é mais claro

	
		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

Continuar lendo

Fundamentos de RAG

Esqueça o Ctrl+F! 🤯 Com RAG, seus documentos responderão às suas perguntas diretamente. 😎 Tutorial passo a passo com Hugging Face e ChromaDB. Liberte o poder da IA (e impressione seus amigos)! 💪

Conventional commits

😠 Seus commits parecem escritos em uma língua alienígena? 👽 Junte-se ao clube! 😅 Aprenda Conventional Commits em Python e pare de tortura sua equipe com mensagens enigmáticas. git-changelog e commitizen serão seus novos melhores amigos. 🤝

DoLa – Decoding by Contrasting Layers Improves Factuality in Large Language Models

Você já conversou com um LLM e ele lhe respondeu algo que parece ter bebido café de máquina a noite toda? 😂 Isso é o que chamamos de alucinação no mundo dos LLMs! Mas não se preocupe, pois não é que seu modelo de linguagem esteja louco (embora às vezes possa parecer isso 🤪). A verdade é que os LLMs podem ser um pouco... criativos quando se trata de gerar texto. Mas graças ao DoLa, um método que usa camadas de contraste para melhorar a viabilidade dos LLMs, podemos evitar que nossos modelos de linguagem se transformem em escritores de ficção científica 😂. Nesta publicação, explicarei como o DoLa funciona e mostrarei um exemplo de código para que você possa entender melhor como tornar seus LLMs mais confiáveis e menos propensos a inventar histórias. Vamos salvar nossos LLMs da loucura e torná-los mais úteis! 🚀

Últimos posts -->

Você viu esses projetos?

Subtify

GPU monitor

Alfred

Ver todos os projetos -->

Quer aplicar IA no seu projeto? Entre em contato!

Quer melhorar com essas dicas?

Memory Calculator

Espaço para calcular a memória necessária para executar um modelo

Formatador de código Black

Seu colega Filipao está escrevendo código que é difícil de ler? Compartilhe com ele este formatador de código que eu mostro neste post! Venha e aprenda a formatar o código para torná-lo mais compreensível. Não vamos resolver os problemas de Filipao, mas pelo menos você não sofrerá ao lê-lo

Obter dados de dicionários

Obter dados de dicionários em Python de forma segura

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