Refactor: reorganiza etiquetas y corrige validación de archivos en la interfaz de evaluación

etiquetas.txt

@@ -1,10 +1,10 @@
 dummy
+Gato
+Perro
 Ilustración
-Mujer joven
-Mujer mayor
-Niña
+Niño
 Hombre joven
 Hombre mayor
-Niño
-Perro
-Gato
+Niña
+Mujer joven
+Mujer mayor

evaluation.py

@@ -32,7 +32,7 @@ def evaluate_interface(model_file, num_clases, test_dataloader):
         return "Por favor, carga un archivo .safetensor"
 
     # Verificamos que el archivo sea .safetensor
-    if not model_file.name.endswith(".safetensor") or not model_file.name.endswith(
+    if not model_file.name.endswith(".safetensor") and not model_file.name.endswith(
         ".safetensors"
     ):
         return "Por favor, carga un archivo con extensión .safetensor o .safetensors"

models.py

@@ -1,5 +1,4 @@
-
-import torch
+import torch
 import torch.nn as nn
 from torchvision import models
 
@@ -8,7 +7,7 @@ class Stem(nn.Module):
     def __init__(self):
         super(Stem, self).__init__()
         self.conv = nn.Sequential(
-            nn.Conv2d(3, 64, kernel_size=7, stride=2),
+            nn.Conv2d(3, 64, kernel_size=3, stride=2),
             nn.MaxPool2d(kernel_size=3, stride=2),
         )
 
@@ -16,16 +15,31 @@ class Stem(nn.Module):
         x = self.conv(x)
         return x
 
+
 class ResidualBlock(nn.Module):
     def __init__(self, in_channels, out_channels, stride=1):
         super().__init__()
         self.conv1 = nn.Sequential(
-            nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False),
+            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, out_channels, kernel_size=3, stride=1, padding=1, bias=False),
+            nn.Conv2d(
+                out_channels,
+                out_channels,
+                kernel_size=3,
+                stride=1,
+                padding=1,
+                bias=False,
+            ),
             nn.BatchNorm2d(out_channels),
         )
 
@@ -33,7 +47,9 @@ class ResidualBlock(nn.Module):
             nn.Identity()
             if in_channels == out_channels and stride == 1
             else nn.Sequential(
-                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),
+                nn.Conv2d(
+                    in_channels, out_channels, kernel_size=1, stride=stride, bias=False
+                ),
                 nn.BatchNorm2d(out_channels),
             )
         )
@@ -47,13 +63,12 @@ class ResidualBlock(nn.Module):
         x += identity
         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(
-            ResidualBlock(64, 64), ResidualBlock(64, 64)
-        )
+        self.stem = nn.Sequential(Stem())
+        self.layer1 = nn.Sequential(ResidualBlock(64, 64), ResidualBlock(64, 64))
         self.layer2 = nn.Sequential(
             ResidualBlock(64, 128, stride=2), ResidualBlock(128, 128)
         )
@@ -61,15 +76,15 @@ class FromZero(nn.Module):
             ResidualBlock(128, 256, stride=2), ResidualBlock(256, 256)
         )
         self.layer4 = nn.Sequential(
-            ResidualBlock(256, 512, stride=2), ResidualBlock(512, 512)
-        ,nn.Dropout(0.2))
+            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.Sequential(
-
             nn.Linear(512, num_classes),
-            )
+        )
+
     def forward(self, x):
         x = self.stem(x)
         x = self.layer1(x)
@@ -80,4 +95,3 @@ class FromZero(nn.Module):
         x = self.flatten(x)
         x = self.fc(x)
         return x
-