Añadir implementación de un entorno de desarrollo y carga de modelos con evaluación de precisión

.gitignore

@@ -0,0 +1,177 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Model test directory
+model_test/

app.py

@@ -7,229 +7,26 @@ from torch.utils.data import Dataset, DataLoader
 from torchvision import transforms
 from safetensors.torch import load_model
 from datasets import load_dataset
+from models import FromZero, PreTrained
 
+from utils import cargar_etiquetas
+from dataset import cargar_dataset
+from evaluation import evaluate_interface
 
-# modelos
-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.MaxPool2d(kernel_size=3, stride=2),
-        )
+# Cargar etiquetas
+etiquetas, num_clases, codigo = cargar_etiquetas()
 
-    def forward(self, x):
-        x = self.conv(x)
-        return x
+# Cargar dataset
+test_dataloader = cargar_dataset(codigo)
 
 
-class ResidualBlock(nn.Module):
-    def __init__(self, in_channels, out_channels, stride=1):
-        super(ResidualBlock, self).__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),
-        )
-        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.BatchNorm2d(out_channels),
-        )
-
-        self.shortcut = (
-            nn.Identity()
-            if in_channels == out_channels
-            else nn.Sequential(
-                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride),
-                nn.BatchNorm2d(out_channels),
-            )
-        )
-
-        self.relu = nn.ReLU(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
-
-
-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.layer2 = nn.Sequential(
-            ResidualBlock(64, 128, stride=2), ResidualBlock(128, 128)
-        )
-        self.layer3 = nn.Sequential(
-            ResidualBlock(128, 256, stride=2), ResidualBlock(256, 256)
-        )
-        self.layer4 = nn.Sequential(
-            ResidualBlock(256, 512, stride=2), ResidualBlock(512, 512)
-        )
-
-        self.flatten = nn.Flatten()
-        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
-        self.fc = nn.Linear(512, num_classes)
-
-    def forward(self, x):
-        x = self.stem(x)
-        x = self.layer1(x)
-        x = self.layer2(x)
-        x = self.layer3(x)
-        x = self.layer4(x)
-        x = self.avgpool(x)
-        x = self.flatten(x)
-        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)
-
-
-with open("etiquetas.txt", "r") as f:
-    etiquetas = f.read().splitlines()[1:]
-num_clases = len(etiquetas)
-codigo = {etiqueta.lower(): i for i, etiqueta in enumerate(etiquetas)}
-
-
-def codificar_etiqueta(etiqueta):
-    return codigo[etiqueta]
-
-import os
-
-key = os.environ.get("HFKEY")
-dataset = load_dataset(
-    "minoruskore/elementosparaevaluarclases", split="train",
-    token=key
-)
-
-
-class imagenDataset(Dataset):
-    def __init__(self, dt, transform):
-        self.dt = dt
-        self.tr = transform
-
-    def __len__(self):
-        return len(self.dt)
-
-    def __getitem__(self, idx):
-        row = self.dt[idx]
-        imagen = row["image"].convert("RGB")
-        label = row["etiqueta"].lower()
-        label = codificar_etiqueta(label)
-        imagen = self.tr(imagen)
-        return imagen, label
-
-
-tr = transforms.Compose([transforms.Resize([256, 256]), transforms.ToTensor()])
-test_dataset = imagenDataset(dataset, transform=tr)
-cpus = os.cpu_count()
-test_dataloader = DataLoader(test_dataset, batch_size=500, num_workers=cpus)
-
-
-def multiclass_accuracy(predictions, labels):
-
-    # Obtén las clases predichas (la clase con la mayor probabilidad)
-    _, predicted_classes = torch.max(predictions, 1)
-
-    # Compara las clases predichas con las etiquetas verdaderas
-    correct_predictions = (predicted_classes == labels).sum().item()
-
-    # Calcula la precisión
-    accuracy = correct_predictions / labels.size(0)
-
-    return accuracy
-
-
-def cargar_evaluar_modelo(archivo, tipo_modelo):
-    try:
-        if tipo_modelo == "tarea_7":
-            modelo = FromZero(num_clases)
-
-        elif tipo_modelo == "tarea_8":
-            modelo = PreTrained(num_clases)
-
-        load_model(modelo, archivo)
-        modelo.eval()
-        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        modelo.to(device)
-        accuracy = 0
-        with torch.no_grad():
-            for imagenes, etiquetas in test_dataloader:
-                imagenes = imagenes.to(device)
-                etiquetas = etiquetas.to(device)
-                predictions = modelo(imagenes)
-                accuracy += multiclass_accuracy(predictions, etiquetas)
-        accuracy = accuracy / len(test_dataloader)
-        return accuracy
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-
-def evaluate_interface(model_file, model_type):
-    if model_file is None:
-        return "Por favor, carga un archivo .safetensor"
-
-    # Verificamos que el archivo sea .safetensor
-    if not model_file.name.endswith(".safetensor"):
-        return "Por favor, carga un archivo con extensión .safetensor"
-
-    # Evaluamos el modelo
-    accuracy = cargar_evaluar_modelo(
-        model_file.name,
-        model_type,
-    )
-
-    if isinstance(accuracy, float):
-        return f"Precisión del modelo: {accuracy*100:.2f}%"
-    else:
-        return accuracy
+def interface_wrapper(model_file, model_type):
+    return evaluate_interface(model_file, model_type, num_clases, test_dataloader)
 
 
+# Interfaz de Gradio
 demo = gr.Interface(
-    fn=evaluate_interface,
+    fn=interface_wrapper,
     inputs=[
         gr.File(label="Archivo del modelo (.safetensor)"),
         gr.Radio(["tarea_7", "tarea_8"], label="Tipo de modelo", value="tarea_7"),
@@ -239,4 +36,5 @@ demo = gr.Interface(
     description="Carga un archivo .safetensor de la tarea 7 o 8 y evalúa su precisión en el conjunto de datos de evaluación.",
 )
 
-demo.launch()
+if __name__ == "__main__":
+    demo.launch()

dataset.py

@@ -0,0 +1,39 @@
+import os
+import torch
+from torch.utils.data import Dataset, DataLoader
+from torchvision import transforms
+from datasets import load_dataset
+
+
+class ImagenDataset(Dataset):
+    def __init__(self, dt, transform, codigo_etiquetas):
+        self.dt = dt
+        self.tr = transform
+        self.codigo = codigo_etiquetas
+
+    def __len__(self):
+        return len(self.dt)
+
+    def __getitem__(self, idx):
+        row = self.dt[idx]
+        imagen = row["image"].convert("RGB")
+        label = row["etiqueta"].lower()
+        label = self.codigo[label]
+        imagen = self.tr(imagen)
+        return imagen, label
+
+
+def cargar_dataset(codigo_etiquetas):
+    key = os.environ.get("HFKEY")
+    dataset = load_dataset(
+        "minoruskore/elementosparaevaluarclases", split="train", token=key
+    )
+
+    tr = transforms.Compose([transforms.Resize([256, 256]), transforms.ToTensor()])
+    test_dataset = ImagenDataset(
+        dataset, transform=tr, codigo_etiquetas=codigo_etiquetas
+    )
+    cpus = os.cpu_count()
+    test_dataloader = DataLoader(test_dataset, batch_size=500, num_workers=cpus)
+
+    return test_dataloader

evaluation.py

@@ -0,0 +1,49 @@
+import torch
+from safetensors.torch import load_model
+from models import FromZero, PreTrained
+from utils import multiclass_accuracy
+
+
+def cargar_evaluar_modelo(archivo, tipo_modelo, num_clases, test_dataloader):
+    try:
+        if tipo_modelo == "tarea_7":
+            modelo = PreTrained(num_clases)
+        elif tipo_modelo == "tarea_8":
+            modelo = FromZero(num_clases)
+
+        load_model(modelo, archivo)
+        modelo.eval()
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        modelo.to(device)
+        accuracy = 0
+
+        with torch.no_grad():
+            for imagenes, etiquetas in test_dataloader:
+                imagenes = imagenes.to(device)
+                etiquetas = etiquetas.to(device)
+                predictions = modelo(imagenes)
+                accuracy += multiclass_accuracy(predictions, etiquetas)
+
+        accuracy = accuracy / len(test_dataloader)
+        return accuracy
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+def evaluate_interface(model_file, model_type, num_clases, test_dataloader):
+    if model_file is None:
+        return "Por favor, carga un archivo .safetensor"
+
+    # Verificamos que el archivo sea .safetensor
+    if not model_file.name.endswith(".safetensor"):
+        return "Por favor, carga un archivo con extensión .safetensor"
+
+    # Evaluamos el modelo
+    accuracy = cargar_evaluar_modelo(
+        model_file.name, model_type, num_clases, test_dataloader
+    )
+
+    if isinstance(accuracy, float):
+        return f"Precisión del modelo: {accuracy*100:.2f}%"
+    else:
+        return accuracy

generate_models.py

@@ -0,0 +1,23 @@
+import os
+import torch
+from models import FromZero, PreTrained
+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()
+    # 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'")
+
+
+if __name__ == "__main__":
+    main()

models.py

@@ -0,0 +1,121 @@
+import torch
+import torch.nn as nn
+from torchvision import models
+
+
+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.MaxPool2d(kernel_size=3, stride=2),
+        )
+
+    def forward(self, x):
+        x = self.conv(x)
+        return x
+
+
+class ResidualBlock(nn.Module):
+    def __init__(self, in_channels, out_channels, stride=1):
+        super(ResidualBlock, self).__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),
+        )
+        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.BatchNorm2d(out_channels),
+        )
+
+        self.shortcut = (
+            nn.Identity()
+            if in_channels == out_channels
+            else nn.Sequential(
+                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride),
+                nn.BatchNorm2d(out_channels),
+            )
+        )
+
+        self.relu = nn.ReLU(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
+
+
+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.layer2 = nn.Sequential(
+            ResidualBlock(64, 128, stride=2), ResidualBlock(128, 128)
+        )
+        self.layer3 = nn.Sequential(
+            ResidualBlock(128, 256, stride=2), ResidualBlock(256, 256)
+        )
+        self.layer4 = nn.Sequential(
+            ResidualBlock(256, 512, stride=2), ResidualBlock(512, 512)
+        )
+
+        self.flatten = nn.Flatten()
+        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+        self.fc = nn.Linear(512, num_classes)
+
+    def forward(self, x):
+        x = self.stem(x)
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)
+        x = self.avgpool(x)
+        x = self.flatten(x)
+        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

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

utils.py

@@ -0,0 +1,23 @@
+import torch
+
+
+def cargar_etiquetas():
+    with open("etiquetas.txt", "r") as f:
+        etiquetas = f.read().splitlines()[1:]
+    num_clases = len(etiquetas)
+    codigo = {etiqueta.lower(): i for i, etiqueta in enumerate(etiquetas)}
+
+    return etiquetas, num_clases, codigo
+
+
+def multiclass_accuracy(predictions, labels):
+    # Obtén las clases predichas (la clase con la mayor probabilidad)
+    _, predicted_classes = torch.max(predictions, 1)
+
+    # Compara las clases predichas con las etiquetas verdaderas
+    correct_predictions = (predicted_classes == labels).sum().item()
+
+    # Calcula la precisión
+    accuracy = correct_predictions / labels.size(0)
+
+    return accuracy