Refactor: elimina soporte para modelo preentrenado, simplifica interfaces y agrega flake.nix

app.py

@@ -10,8 +10,8 @@ etiquetas, num_clases, codigo = cargar_etiquetas()
 test_dataloader = cargar_dataset(codigo)
 
 
-def interface_wrapper(model_file, model_type):
-    return evaluate_interface(model_file, model_type, num_clases, test_dataloader)
+def interface_wrapper(model_file):
+    return evaluate_interface(model_file, num_clases, test_dataloader)
 
 
 # Interfaz de Gradio
@@ -19,12 +19,9 @@ demo = gr.Interface(
     fn=interface_wrapper,
     inputs=[
         gr.File(label="Archivo del modelo (.safetensor)"),
-        gr.Radio(
-            ["pre_entrenado", "desde_cero"], label="Tipo de modelo", value="desde_cero"
-        ),
     ],
     outputs=gr.Textbox(label="Resultado", lines=1),
-    title="Evaluador de modelos pre-entrenado y desde cero",
+    title="Evaluador de modelos",
     description="Carga un archivo .safetensor y evalúa su precisión en el conjunto de datos de evaluación.",
 )
 

evaluation.py

@@ -1,15 +1,12 @@
 import torch
 from safetensors.torch import load_model
-from models import FromZero, PreTrained
+from models import FromZero
 from utils import multiclass_accuracy
 
 
-def cargar_evaluar_modelo(archivo, tipo_modelo, num_clases, test_dataloader):
+def cargar_evaluar_modelo(archivo, num_clases, test_dataloader):
     try:
-        if tipo_modelo == "pre_entrenado":
-            modelo = PreTrained(num_clases)
-        elif tipo_modelo == "desde_cero":
-            modelo = FromZero(num_clases)
+        modelo = FromZero(num_clases)
 
         load_model(modelo, archivo)
         modelo.eval()
@@ -30,7 +27,7 @@ def cargar_evaluar_modelo(archivo, tipo_modelo, num_clases, test_dataloader):
         return f"Error: {str(e)}"
 
 
-def evaluate_interface(model_file, model_type, num_clases, test_dataloader):
+def evaluate_interface(model_file, num_clases, test_dataloader):
     if model_file is None:
         return "Por favor, carga un archivo .safetensor"
 
@@ -41,9 +38,7 @@ def evaluate_interface(model_file, model_type, num_clases, test_dataloader):
         return "Por favor, carga un archivo con extensión .safetensor o .safetensors"
 
     # Evaluamos el modelo
-    accuracy = cargar_evaluar_modelo(
-        model_file.name, model_type, num_clases, test_dataloader
-    )
+    accuracy = cargar_evaluar_modelo(model_file.name, num_clases, test_dataloader)
 
     if isinstance(accuracy, float):
         return f"Precisión del modelo: {accuracy*100:.2f}%"

flake.lock

@@ -0,0 +1,78 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1753749649,
+        "narHash": "sha256-+jkEZxs7bfOKfBIk430K+tK9IvXlwzqQQnppC2ZKFj4=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "1f08a4df998e21f4e8be8fb6fbf61d11a1a5076a",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-25.05",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs",
+        "unstable": "unstable"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    },
+    "unstable": {
+      "locked": {
+        "lastModified": 1753694789,
+        "narHash": "sha256-cKgvtz6fKuK1Xr5LQW/zOUiAC0oSQoA9nOISB0pJZqM=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "dc9637876d0dcc8c9e5e22986b857632effeb727",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,40 @@
+{
+  description = "Flake para un entorno Jupyter + IA + Fish 💻🐟";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-25.05";
+    unstable.url = "github:NixOS/nixpkgs/nixos-unstable";
+    flake-utils.url = "github:numtide/flake-utils";
+  };
+
+  outputs = {
+    self,
+    nixpkgs,
+    unstable,
+    flake-utils,
+  }:
+    flake-utils.lib.eachDefaultSystem (system: let
+      pkgs = import nixpkgs {inherit system;};
+      unpkgs = import unstable {inherit system;};
+    in {
+      devShells.default = pkgs.mkShell {
+        name = "impurejupyterenv";
+
+        buildInputs = [
+          (pkgs.python3.withPackages (ps:
+            with ps; [
+              gradio
+              torch
+              torchvision
+              safetensors
+              torchaudio
+              datasets
+            ]))
+        ];
+
+        shellHook = ''
+          exec fish
+        '';
+      };
+    });
+}

generate_models.py

@@ -1,20 +1,19 @@
 import os
 import torch
-from models import FromZero, PreTrained
+from models import FromZero
 from safetensors.torch import save_model
 from utils import cargar_etiquetas
 
+
 def main():
     # Crear la carpeta model_test si no existe
     os.makedirs("model_test", exist_ok=True)
-    _,num_classes,_ = cargar_etiquetas()
+    _, num_classes, _ = cargar_etiquetas()
     # Crear instancias de los modelos
     from_zero_model = FromZero(num_classes=num_classes)
-    pretrained_model = PreTrained(num_classes=num_classes)
 
     # Guardar los modelos
     save_model(from_zero_model, "model_test/from_zero_model.safetensor")
-    save_model(pretrained_model, "model_test/pretrained_model.safetensor")
 
     print("Los modelos han sido creados y guardados en la carpeta 'model_test'")
 

models.py

@@ -1,4 +1,5 @@
-import torch
+
+import torch
 import torch.nn as nn
 from torchvision import models
 
@@ -15,67 +16,44 @@ class Stem(nn.Module):
         x = self.conv(x)
         return x
 
-
 class ResidualBlock(nn.Module):
     def __init__(self, in_channels, out_channels, stride=1):
-        super(ResidualBlock, self).__init__()
+        super().__init__()
         self.conv1 = nn.Sequential(
-            nn.Conv2d(in_channels, out_channels // 4, stride=1, kernel_size=1),
-            nn.BatchNorm2d(out_channels // 4),
-            nn.ReLU(inplace=True),
+            nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False),
+            nn.BatchNorm2d(out_channels),
+            nn.LeakyReLU(inplace=True),
         )
         self.conv2 = nn.Sequential(
-            nn.Conv2d(
-                out_channels // 4,
-                out_channels // 4,
-                stride=stride,
-                kernel_size=3,
-                padding=1,
-            ),
-            nn.BatchNorm2d(out_channels // 4),
-            nn.ReLU(inplace=True),
-        )
-
-        self.conv3 = nn.Sequential(
-            nn.Conv2d(out_channels // 4, out_channels, kernel_size=1, stride=1),
+            nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False),
             nn.BatchNorm2d(out_channels),
         )
 
         self.shortcut = (
             nn.Identity()
-            if in_channels == out_channels
+            if in_channels == out_channels and stride == 1
             else nn.Sequential(
-                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride),
+                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),
                 nn.BatchNorm2d(out_channels),
             )
         )
 
-        self.relu = nn.ReLU(inplace=True)
+        self.act = nn.LeakyReLU(inplace=True)
 
     def forward(self, x):
         identity = self.shortcut(x)
         x = self.conv1(x)
         x = self.conv2(x)
-        x = self.conv3(x)
         x += identity
-        x = self.relu(x)
-        return x
-
-
-def make_layer(in_channels, out_channels, block, num_blocks):
-    layers = []
-    for i in range(num_blocks):
-        layers.append(block(in_channels, out_channels))
-        in_channels = out_channels
-
-    return layers
-
+        return self.act(x)
 
 class FromZero(nn.Module):
     def __init__(self, num_classes=10):
         super(FromZero, self).__init__()
         self.stem = Stem()
-        self.layer1 = nn.Sequential(*make_layer(64, 64, ResidualBlock, 2))
+        self.layer1 = nn.Sequential(
+            ResidualBlock(64, 64), ResidualBlock(64, 64)
+        )
         self.layer2 = nn.Sequential(
             ResidualBlock(64, 128, stride=2), ResidualBlock(128, 128)
         )
@@ -84,12 +62,14 @@ class FromZero(nn.Module):
         )
         self.layer4 = nn.Sequential(
             ResidualBlock(256, 512, stride=2), ResidualBlock(512, 512)
-        )
+        ,nn.Dropout(0.2))
 
         self.flatten = nn.Flatten()
         self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
-        self.fc = nn.Linear(512, num_classes)
+        self.fc = nn.Sequential(
 
+            nn.Linear(512, num_classes),
+            )
     def forward(self, x):
         x = self.stem(x)
         x = self.layer1(x)
@@ -101,21 +81,3 @@ class FromZero(nn.Module):
         x = self.fc(x)
         return x
 
-
-class PreTrained(nn.Module):
-    def __init__(self, num_classes):
-        super().__init__()
-        self.model = models.resnet18(
-            weights=models.ResNet18_Weights.IMAGENET1K_V1, progress=True
-        )
-        for param in self.model.parameters():
-            param.requires_grad = False
-
-        self.model.fc = nn.Sequential(
-            nn.Linear(self.model.fc.in_features, 512),
-            nn.ReLU(inplace=True),
-            nn.Linear(512, num_classes),
-        )
-
-    def forward(self, x):
-        return self.model(x)

shell.nix

@@ -1,19 +0,0 @@
-{ pkgs ? import <nixpkgs> {} }:
-
-pkgs.mkShell {
-  buildInputs = [
-    (pkgs.python3.withPackages(ps: with ps; [
-		datasets
-		torch
-	torchvision
-	torchaudio
-	safetensors
-	gradio
-  ]))
-
-  ];
-
-  shellHook = ''
- exec fish
-   '';
-}