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

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

Luego iterar por ella en el método forward no es tan 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

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

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

Luego iterar por ella en el método forward es más 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

Seguir leyendo

Fundamentos de RAG

¡Olvídate de Ctrl+F! 🤯 Con RAG, tus documentos responderán a tus preguntas directamente. 😎 Tutorial paso a paso con Hugging Face y ChromaDB. ¡Libera el poder de la IA (y presume con tus amigos)! 💪

Conventional commits

😠 ¿Tus commits parecen escritos en lenguaje alienígena? 👽 ¡Únete al club! 😅 Aprende Conventional Commits en Python y deja de torturar a tu equipo con mensajes crípticos. git-changelog y commitizen serán tus nuevos mejores amigos. 🤝

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

¿Alguna vez has hablado con un LLM y te ha respondido algo que suena como si hubiera estado bebiendo café de máquina durante toda la noche? 😂 ¡Eso es lo que llamamos una alucinación en el mundo de los LLMs! Pero no te preocupes, porque no es que tu modelo de lenguaje esté loco (aunque a veces puede parecerlo 🤪). La verdad es que los LLMs pueden ser un poco... creativos cuando se trata de generar texto. Pero gracias a DoLa, un método que utiliza capas de contraste para mejorar la factibilidad de los LLMs, podemos evitar que nuestros modelos de lenguaje se conviertan en escritores de ciencia ficción 😂. En este post, te explicaré cómo funciona DoLa y te mostraré un ejemplo de código para que puedas entender mejor cómo hacer que tus LLMs sean más fiables y menos propensos a inventar historias. ¡Vamos a salvar a nuestros LLMs de la locura y hacer que sean más útiles! 🚀

Últimos posts -->

¿Has visto estos proyectos?

Subtify

GPU monitor

Alfred

Ver todos los proyectos -->

¿Quieres aplicar la IA en tu proyecto? Contactame!

¿Quieres mejorar con estos tips?

Memory Calculator

Espacio para calcular la memoria necesaria para ejecutar un modelo

Formateador de código Black

Tu compañero Manolo hace código que cuesta verlo? Pásale este formateador de código que te enseño en este post! Entra y aprende cómo formatear código para dejarlo más entendible. No vamos a solucionar los problemas de Manolo, pero tu al menos no vas a sufrir al leerlo

Get data of dictionaries

Get data of dictionaries in Python safely

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