Declare neural networks clearly

22 of october of 2024

Declarar redes neuronales claramente

Disclaimer: This post has been translated to English using a machine translation model. Please, let me know if you find any mistakes.

When in PyTorch a neural network is created as a list of layers

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

Then iterating through it in the forward method is not so clear

	
		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

However, when creating a neural network as a dictionary of layers

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

Then iterating through it in the forward method is clearer

	
		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

Continue reading

RAG fundamentals

Forget about Ctrl+F! 🤯 With RAG, your documents will answer your questions directly. 😎 Step-by-step tutorial with Hugging Face and ChromaDB. Unleash the power of AI (and show off to your friends)! 💪

Conventional commits

😠 Are your commits written in alien language? 👽 Join the club! 😅 Learn Conventional Commits in Python and stop torturing your team with cryptic messages. git-changelog and commitizen will be your new best friends. 🤝

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

Have you ever talked to an LLM and they answered you something that sounds like they've been drinking machine coffee all night long 😂 That's what we call a hallucination in the LLM world! But don't worry, because it's not that your language model is crazy (although it can sometimes seem that way 🤪). The truth is that LLMs can be a bit... creative when it comes to generating text. But thanks to DoLa, a method that uses contrast layers to improve the feasibility of LLMs, we can keep our language models from turning into science fiction writers 😂. In this post, I'll explain how DoLa works and show you a code example so you can better understand how to make your LLMs more reliable and less prone to making up stories. Let's save our LLMs from insanity and make them more useful! 🚀

Last posts -->

Have you seen these projects?

Subtify

GPU monitor

Alfred

View all projects -->

Do you want to apply AI in your project? Contact me!

Do you want to improve with these tips?

Memory Calculator

Space to calculate the memory needed to run a model

Code formatter Black

Your colleague Patric is writing code that is hard to read? Share with him this code formatter that I show you in this post! Come in and learn how to format code to make it more understandable. We are not going to solve Patric's problems, but at least you won't suffer when reading it

Obtener datos de diccionarios

Obtener datos de diccionarios en Python de forma segura

Last tips -->

Use this locally

Hugging Face spaces allow us to run models with very simple demos, but what if the demo breaks? Or if the user deletes it? That's why I've created docker containers with some interesting spaces, to be able to use them locally, whatever happens. In fact, if you click on any project view button, it may take you to a space that doesn't work.