Versión final lista para Hugging Face Space

.dockerignore

@@ -0,0 +1,11 @@
+.venv/
+__pycache__/
+resources/logs/
+resources/outputs/
+resources/uploads/
+*.log
+*.csv
+*.jpg
+*.jpeg
+*.png
+*.mp4

Dockerfile

@@ -0,0 +1,27 @@
+# Imagen base con soporte CUDA + PyTorch
+FROM pytorch/pytorch:2.4.0-cuda12.1-cudnn9-runtime
+
+# Establecer directorio de trabajo
+WORKDIR /app
+
+# Instalar utilidades necesarias (git para clonar repos incluidos en requirements)
+RUN apt-get update && apt-get install -y git ffmpeg libsm6 libxext6 && rm -rf /var/lib/apt/lists/*
+
+# Copiar requirements y dependencias
+COPY requirements.txt /app/
+RUN pip install --upgrade pip && pip install -r requirements.txt
+
+# Copiar todo el proyecto
+COPY . /app/
+
+# Crear directorios necesarios en caso de que no existan
+RUN mkdir -p resources/uploads resources/outputs resources/logs
+
+# Exponer puerto para Gradio
+EXPOSE 7860
+
+# Variable obligatoria para Gradio en Spaces
+ENV GRADIO_SERVER_NAME="0.0.0.0"
+
+# Comando de ejecución
+CMD ["python", "app.py"]

HerdNet

@@ -0,0 +1 @@
+Subproject commit 7e25f482d875522c59c446dc0c78c8f6f2dd448d

app.py

@@ -0,0 +1,217 @@
+import warnings
+import gradio as gr
+from PIL import Image
+import pandas as pd
+import os
+
+from inference.herdnet_infer import HerdNetInference
+from inference.utils_io import load_yaml_config, mkdir
+from animaloc.utils.seed import set_seed
+
+# Ignorar advertencias no críticas
+warnings.filterwarnings(
+    "ignore",
+    message="Got processor for keypoints, but no transform to process it",
+)
+
+# Fijar semilla para reproducibilidad
+set_seed(9292)
+
+# ===============================================================
+# Configuración inicial
+# ===============================================================
+CONFIG_PATH = "resources/configs/default.yaml"
+cfg = load_yaml_config(CONFIG_PATH)
+mkdir(cfg["paths"]["uploads_dir"])
+
+print("[INIT] Cargando modelo HerdNet... esto puede tardar unos segundos.")
+infer_engine = HerdNetInference(CONFIG_PATH)
+print("[READY] Modelo cargado y listo para inferencia.")
+
+# Información del modelo (actualizada con tablas)
+MODEL_INFO = """
+### Arquitectura y datos
+- **Modelo:** HerdNet (FPN + Density Maps)
+- **Dataset:** ULiège-AIR (6 especies + background)
+- **Última actualización:** 07 Nov 2025
+
+### Desempeño general (Fine-Tuning oficial)
+
+| Métrica     | Valor   |
+|--------------|---------|
+| F1-score     | 0.8405  |
+| Precision    | 0.8407  |
+| Recall       | 0.8404  |
+| MAE          | 1.8023  |
+| RMSE         | 3.4892  |
+
+### Matriz de confusión (normalizada)
+
+| Real \\ Predicha | buffalo | elephant | kob | topi | warthog | waterbuck |
+|------------------|----------|-----------|------|------|----------|-------------|
+| **buffalo**      | 0.94 | 0.00 | 0.05 | 0.01 | 0.00 | 0.00 |
+| **elephant**     | 0.01 | 0.91 | 0.00 | 0.07 | 0.01 | 0.00 |
+| **kob**          | 0.08 | 0.00 | 0.92 | 0.00 | 0.00 | 0.00 |
+| **topi**         | 0.03 | 0.00 | 0.00 | 0.94 | 0.03 | 0.00 |
+| **warthog**      | 0.06 | 0.06 | 0.06 | 0.00 | 0.81 | 0.00 |
+| **waterbuck**    | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 1.00 |
+"""
+
+
+def run_inference(image: Image.Image):
+    """
+    Ejecuta la inferencia sobre una imagen PIL y devuelve los resultados.
+    """
+    if image is None:
+        return None, pd.DataFrame(), None, None
+
+    annotated_img, counts = infer_engine.infer_single(image)
+
+    # Construir tabla completa de especies
+    all_species = list(infer_engine.classes.values())
+    df_counts = pd.DataFrame({
+        "Especie": all_species,
+        "Conteo": [counts.get(sp, 0) for sp in all_species],
+    })
+    df_counts.loc[len(df_counts)] = ["Total", df_counts["Conteo"].sum()]
+
+    # Guardar conteos
+    csv_counts_path = os.path.join(infer_engine.output_dir, "species_counts.csv")
+    df_counts.to_csv(csv_counts_path, index=False)
+
+    # Comprobar existencia de detecciones
+    detections_csv = os.path.join(infer_engine.output_dir, "detections.csv")
+    if not os.path.exists(detections_csv):
+        detections_csv = None
+
+    return annotated_img, df_counts, csv_counts_path, detections_csv
+
+
+# ===============================================================
+# Interfaz de Gradio (versión estética mejorada)
+# ===============================================================
+custom_css = """
+#main-title h1 {
+    font-size: 2.2em !important;
+    color: #e0f2fe !important;
+    font-weight: 700 !important;
+    margin-bottom: 0.3em;
+}
+
+h2 {
+    color: #93c5fd !important;
+    font-weight: 600 !important;
+    margin-top: 1em;
+    margin-bottom: 0.3em;
+}
+
+.block-section {
+    background-color: #0f172a;
+    border-radius: 10px;
+    padding: 15px 20px;
+    margin-bottom: 25px;
+    box-shadow: 0 0 10px #00000040;
+}
+
+.img-bordered img {
+    border-radius: 10px;
+    box-shadow: 0 0 10px #00000040;
+}
+
+.data-table table {
+    font-size: 15px !important;
+}
+
+.download-btn {
+    background-color: #1e3a8a !important;
+    color: #f8fafc !important;
+    font-weight: 600 !important;
+    border-radius: 8px !important;
+    padding: 8px 14px !important;
+    border: 1px solid #3b82f6 !important;
+    transition: all 0.2s ease-in-out;
+}
+
+.download-btn:hover {
+    background-color: #2563eb !important;
+    transform: scale(1.05);
+}
+
+.big-button button {
+    background-color: #1d4ed8 !important;
+    color: #f8fafc !important;
+    font-weight: 700 !important;
+    font-size: 20px !important;
+    padding: 16px 28px !important;
+    border-radius: 10px !important;
+    width: 100% !important;
+    transition: all 0.25s ease-in-out;
+}
+
+.big-button button:hover {
+    background-color: #2563eb !important;
+    transform: scale(1.03);
+}
+"""
+
+with gr.Blocks(
+    theme=gr.themes.Soft(primary_hue="blue", neutral_hue="slate"),
+    css=custom_css,
+) as demo:
+    # Encabezado principal
+    gr.Markdown("# Detección y Conteo de Mamíferos Africanos", elem_id="main-title")
+
+    # Información del modelo (colapsable con tablas)
+    with gr.Accordion("Información del modelo", open=False):
+        gr.Markdown(MODEL_INFO)
+
+    # Bloque: resultados visuales
+    gr.Markdown("## Resultados de inferencia")
+    with gr.Row(elem_classes=["block-section"]):
+        image_input = gr.Image(
+            type="pil",
+            label="Subir imagen aérea",
+            height=380,
+            elem_classes=["img-bordered"],
+        )
+        image_output = gr.Image(
+            label="Detecciones (puntos resaltados)",
+            height=380,
+            elem_classes=["img-bordered"],
+        )
+
+    # Botón principal más grande y visible
+    btn = gr.Button(
+        "Ejecutar detección y conteo",
+        variant="primary",
+        elem_classes=["big-button"],
+    )
+
+    # Bloque: conteo detallado
+    gr.Markdown("## Conteo detallado por especie")
+    with gr.Column(elem_classes=["block-section"]):
+        counts_output = gr.Dataframe(
+            headers=["Especie", "Conteo"],
+            label="Resultados de detección",
+            interactive=False,
+            elem_classes=["data-table"],
+        )
+
+        with gr.Row():
+            download_counts = gr.File(
+                label="Descargar conteos (CSV)",
+                elem_classes=["download-btn"],
+            )
+            download_detections = gr.File(
+                label="Descargar anotaciones (detections.csv)",
+                elem_classes=["download-btn"],
+            )
+
+    btn.click(
+        fn=run_inference,
+        inputs=image_input,
+        outputs=[image_output, counts_output, download_counts, download_detections],
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=False, server_port=7860)

inference/herdnet_infer.py

@@ -0,0 +1,152 @@
+import os
+import torch
+import pandas as pd
+import numpy as np
+from torch.utils.data import DataLoader
+from animaloc.models import HerdNet, LossWrapper
+from animaloc.eval import HerdNetEvaluator, HerdNetStitcher
+from animaloc.eval.metrics import PointsMetrics
+
+from inference.preprocessing import (
+    build_normalize_transform,
+    build_end_transforms,
+    create_single_image_dataset,
+)
+from inference.postprocessing import (
+    compute_species_counts,
+    draw_detections_on_image,
+    generate_thumbnails,
+    save_detections,
+)
+from inference.utils_io import (
+    mkdir,
+    get_timestamp_dir,
+    init_logger,
+    load_yaml_config,
+)
+
+
+class HerdNetInference:
+    """
+    Clase envoltoria para cargar un modelo HerdNet entrenado y ejecutar
+    inferencias sobre imágenes individuales o carpetas completas,
+    incluyendo posprocesamiento y exportación de resultados.
+    """
+
+    def __init__(self, config_path: str = "resources/configs/default.yaml"):
+        self.cfg = load_yaml_config(config_path)
+        self.logger = init_logger(self.cfg["paths"]["logs_dir"])
+
+        # Parámetros principales
+        self.device = torch.device(
+            self.cfg["model"]["device"] if torch.cuda.is_available() else "cpu"
+        )
+        self.patch_size = self.cfg["model"]["patch_size"]
+        self.overlap = self.cfg["model"]["overlap"]
+        self.down_ratio = self.cfg["model"]["down_ratio"]
+        self.save_plots = self.cfg["inference"]["save_plots"]
+        self.save_csv = self.cfg["inference"]["save_csv"]
+        self.save_thumbnails = self.cfg["inference"]["save_thumbnails"]
+
+        # Directorio de salida
+        self.outputs_base = self.cfg["paths"]["outputs_dir"]
+        mkdir(self.outputs_base)
+        self.output_dir = get_timestamp_dir(self.outputs_base)
+        self.logger.info(f"[INIT] Directorio de salida: {self.output_dir}")
+
+        self._load_model()
+
+    # -----------------------------------------------------------
+    def _load_model(self):
+        """
+        Carga el modelo HerdNet desde el archivo .pth y lo prepara para inferencia.
+        """
+        pth_path = self.cfg["model"]["path"]
+        if not os.path.exists(pth_path):
+            raise FileNotFoundError(f"[ERROR] No se encontró el modelo → {pth_path}")
+
+        checkpoint = torch.load(pth_path, map_location=self.device)
+        self.classes = checkpoint["classes"]
+        self.num_classes = len(self.classes) + 1
+        self.mean = checkpoint["mean"]
+        self.std = checkpoint["std"]
+
+        model = HerdNet(num_classes=self.num_classes, pretrained=False)
+        self.model = LossWrapper(model, [])
+        self.model.load_state_dict(checkpoint["model_state_dict"])
+        self.model.to(self.device)
+        self.model.eval()
+
+        self.logger.info(
+            f"[MODEL] Modelo HerdNet cargado ({self.num_classes} clases) desde {pth_path}"
+        )
+
+    # -----------------------------------------------------------
+    def infer_single(self, image_pil):
+        """
+        Ejecuta la inferencia sobre una imagen PIL.
+
+        Retorna
+        -------
+        annotated_image : PIL.Image
+            Imagen anotada con las detecciones.
+        counts_per_species : dict
+            Diccionario con el conteo por especie.
+        """
+        dataset, dataloader, temp_path = create_single_image_dataset(
+            image_pil, mean=self.mean, std=self.std, down_ratio=self.down_ratio
+        )
+
+        stitcher = HerdNetStitcher(
+            model=self.model,
+            size=(self.patch_size, self.patch_size),
+            overlap=self.overlap,
+            down_ratio=self.down_ratio,
+            up=True,
+            reduction="mean",
+            device_name=self.device,
+        )
+
+        metrics = PointsMetrics(5, num_classes=self.num_classes)
+        evaluator = HerdNetEvaluator(
+            model=self.model,
+            dataloader=dataloader,
+            metrics=metrics,
+            device_name=self.device,
+            stitcher=stitcher,
+            work_dir=self.output_dir,
+            header="[INFERENCE]",
+        )
+
+        self.logger.info("[RUN] Iniciando inferencia sobre imagen individual...")
+        evaluator.evaluate(wandb_flag=False, viz=False, log_meters=False)
+
+        detections = evaluator.detections.dropna().copy()
+        detections["species"] = detections["labels"].map(self.classes)
+
+        # Guardar CSV con detecciones
+        if self.save_csv:
+            save_detections(detections, self.output_dir, self.logger)
+
+        counts = compute_species_counts(detections)
+        self.logger.info(f"[COUNTS] {counts}")
+
+        # Dibujar detecciones sobre la imagen original
+        annotated_image = draw_detections_on_image(
+            image_path=temp_path,
+            detections_df=detections,
+        )
+
+        # Generar miniaturas si está habilitado
+        if self.save_thumbnails:
+            thumbs_dir = os.path.join(self.output_dir, "thumbnails")
+            generate_thumbnails(temp_path, detections, thumbs_dir)
+
+        # Limpieza del archivo temporal
+        try:
+            os.remove(temp_path)
+            self.logger.info(f"[CLEANUP] Archivo temporal eliminado: {temp_path}")
+        except Exception as e:
+            self.logger.warning(f"[CLEANUP] No se pudo eliminar el archivo temporal: {e}")
+
+        return annotated_image, counts

inference/postprocessing.py

@@ -0,0 +1,153 @@
+import os
+import pandas as pd
+from PIL import Image
+from animaloc.vizual import draw_points, draw_text
+from inference.utils_io import mkdir, save_csv
+
+
+def draw_detections_on_image(
+    image_path: str,
+    detections_df: pd.DataFrame,
+    output_path: str = None
+) -> Image.Image:
+    """
+    Dibuja puntos visibles sobre una imagen y añade una leyenda
+    con el total de detecciones y el desglose por especie.
+
+    Parámetros
+    ----------
+    image_path : str
+        Ruta de la imagen original.
+    detections_df : pd.DataFrame
+        DataFrame con las detecciones (columnas: x, y, species, scores, etc.).
+    output_path : str, opcional
+        Ruta donde se guardará la imagen anotada.
+
+    Retorna
+    -------
+    Image.Image
+        Imagen con los puntos y leyenda dibujados.
+    """
+    img = Image.open(image_path)
+    img_cpy = img.copy()
+
+    # Extraer coordenadas (y, x)
+    pts = list(detections_df[["y", "x"]].to_records(index=False))
+    pts = [(y, x) for y, x in pts]
+
+    # Dibujar puntos sobre la imagen
+    output = draw_points(img_cpy, pts, color=(255, 0, 0), size=60)
+
+    # Construir texto de leyenda
+    species_counts = detections_df["species"].value_counts().to_dict()
+    total = sum(species_counts.values())
+    legend = f"Detecciones: {total} | " + ", ".join(
+        [f"{sp}: {n}" for sp, n in species_counts.items()]
+    )
+
+    # Posicionar texto en parte inferior
+    overlay_y = img_cpy.height - int(0.08 * img_cpy.height)
+    output = draw_text(
+        output,
+        text=legend,
+        position=(20, overlay_y),
+        font_size=int(0.04 * img_cpy.height),
+    )
+
+    # Guardar imagen si se especifica ruta de salida
+    if output_path:
+        mkdir(os.path.dirname(output_path))
+        output.save(output_path, quality=95)
+
+    return output
+
+
+def compute_species_counts(detections_df: pd.DataFrame) -> dict:
+    """
+    Calcula el número de detecciones por especie.
+
+    Retorna
+    -------
+    dict
+        Diccionario con las especies y sus conteos.
+        Retorna un diccionario vacío si no hay detecciones.
+    """
+    if detections_df.empty:
+        return {}
+    return detections_df["species"].value_counts().to_dict()
+
+
+def generate_thumbnails(
+    image_path: str,
+    detections_df: pd.DataFrame,
+    output_dir: str,
+    thumb_size: int = 256
+) -> None:
+    """
+    Genera miniaturas recortadas alrededor de cada detección,
+    con el nombre de la especie y su puntaje de confianza.
+
+    Parámetros
+    ----------
+    image_path : str
+        Ruta de la imagen original.
+    detections_df : pd.DataFrame
+        DataFrame con las detecciones.
+    output_dir : str
+        Directorio donde se guardarán las miniaturas.
+    thumb_size : int
+        Tamaño (en píxeles) de cada miniatura cuadrada.
+    """
+    mkdir(output_dir)
+    img = Image.open(image_path)
+    img_cpy = img.copy()
+
+    sp_score = list(detections_df[["species", "scores"]].to_records(index=False))
+    pts = list(detections_df[["y", "x"]].to_records(index=False))
+
+    for i, ((y, x), (sp, score)) in enumerate(zip(pts, sp_score)):
+        off = thumb_size // 2
+        coords = (x - off, y - off, x + off, y + off)
+
+        # Recortar miniatura
+        thumbnail = img_cpy.crop(coords)
+
+        # Dibujar texto con especie y score
+        score = round(score * 100, 1)
+        thumbnail = draw_text(
+            thumbnail,
+            f"{sp} | {score}%",
+            position=(10, 5),
+            font_size=int(0.08 * thumb_size),
+        )
+
+        filename = os.path.basename(image_path)[:-4] + f"_{i}.JPG"
+        thumbnail.save(os.path.join(output_dir, filename))
+
+
+def save_detections(
+    detections_df: pd.DataFrame,
+    output_dir: str,
+    logger=None
+) -> str:
+    """
+    Guarda las detecciones en formato CSV dentro del directorio de salida.
+
+    Parámetros
+    ----------
+    detections_df : pd.DataFrame
+        DataFrame con las detecciones.
+    output_dir : str
+        Directorio de salida.
+    logger : logging.Logger, opcional
+        Logger para registrar el proceso.
+
+    Retorna
+    -------
+    str
+        Ruta del archivo CSV guardado.
+    """
+    mkdir(output_dir)
+    csv_path = os.path.join(output_dir, "detections.csv")
+    save_csv(detections_df, csv_path, logger)
+    return csv_path

inference/preprocessing.py

@@ -0,0 +1,74 @@
+import os
+import numpy as np
+import pandas as pd
+import albumentations as A
+from torch.utils.data import DataLoader
+from animaloc.datasets import CSVDataset
+from animaloc.data.transforms import DownSample
+from inference.utils_io import mkdir, get_temp_image_path
+
+
+def build_normalize_transform(mean: list, std: list) -> A.Normalize:
+    """
+    Construye una transformación de normalización idéntica
+    a la utilizada durante el entrenamiento.
+    """
+    return A.Normalize(mean=mean, std=std, p=1.0)
+
+
+def build_end_transforms(down_ratio: int = 2):
+    """
+    Construye el conjunto de transformaciones finales utilizadas
+    durante la inferencia.
+    """
+    return [DownSample(down_ratio=down_ratio, anno_type="point")]
+
+
+def create_single_image_dataset(
+    image_pil,
+    mean: list,
+    std: list,
+    down_ratio: int = 2
+):
+    """
+    Crea un CSVDataset temporal y su DataLoader a partir de una única imagen PIL.
+    Guarda la imagen temporalmente en disco (resources/uploads) para la API de HerdNet.
+
+    Retorna
+    -------
+    dataset : CSVDataset
+        Dataset temporal con una sola imagen.
+    dataloader : DataLoader
+        Cargador de datos correspondiente.
+    temp_path : str
+        Ruta absoluta de la imagen guardada temporalmente.
+    """
+    # Crear directorio y archivo temporal
+    upload_dir = "resources/uploads"
+    mkdir(upload_dir)
+    temp_path = get_temp_image_path(upload_dir)
+    image_pil.save(temp_path, format="JPEG")
+
+    # Construir DataFrame para CSVDataset
+    df = pd.DataFrame({
+        "images": [os.path.basename(temp_path)],
+        "x": [0],
+        "y": [0],
+        "labels": [1],
+    })
+
+    # Normalización Albumentations
+    normalize = A.Normalize(mean=mean, std=std, p=1.0)
+    end_transforms = [DownSample(down_ratio=down_ratio, anno_type="point")]
+
+    # Crear dataset y dataloader
+    dataset = CSVDataset(
+        csv_file=df,
+        root_dir=os.path.dirname(temp_path),
+        albu_transforms=[normalize],
+        end_transforms=end_transforms,
+    )
+
+    dataloader = DataLoader(dataset, batch_size=1, shuffle=False)
+
+    return dataset, dataloader, temp_path

inference/utils_io.py

@@ -0,0 +1,115 @@
+import os
+import yaml
+import logging
+from datetime import datetime
+
+# ===============================================================
+#  Utility Functions for I/O, Config, and Logging
+# ===============================================================
+
+def mkdir(path: str) -> None:
+    """
+    Creates a directory if it doesn't exist.
+    """
+    os.makedirs(path, exist_ok=True)
+
+
+def load_yaml_config(path: str) -> dict:
+    """
+    Loads a YAML configuration file and returns it as a dictionary.
+    """
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"[CONFIG] File not found: {path}")
+
+    with open(path, "r", encoding="utf-8") as file:
+        config = yaml.safe_load(file)
+
+    return config
+
+
+def get_timestamp() -> str:
+    """
+    Returns a timestamp string for naming logs and output folders.
+    """
+    return datetime.now().strftime("%Y%m%d_%H%M%S")
+
+
+def get_timestamp_dir(base_dir: str) -> str:
+    """
+    Creates a timestamped subdirectory inside the given base directory.
+    Example: resources/outputs/infer_20251106_233000/
+    """
+    timestamp = get_timestamp()
+    new_dir = os.path.join(base_dir, f"infer_{timestamp}")
+    mkdir(new_dir)
+    return new_dir
+
+
+def init_logger(log_dir: str, name: str = "herdnet_infer") -> logging.Logger:
+    """
+    Initializes a logger that writes both to console and to a file.
+    """
+    mkdir(log_dir)
+    timestamp = get_timestamp()
+    log_path = os.path.join(log_dir, f"{name}_{timestamp}.log")
+
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.INFO)
+    logger.propagate = False
+
+    # Avoid duplicate handlers if reloaded
+    if not logger.handlers:
+        fmt = logging.Formatter("[%(asctime)s] %(levelname)s - %(message)s")
+
+        # File handler
+        fh = logging.FileHandler(log_path, encoding="utf-8")
+        fh.setFormatter(fmt)
+        logger.addHandler(fh)
+
+        # Console handler
+        ch = logging.StreamHandler()
+        ch.setFormatter(fmt)
+        logger.addHandler(ch)
+
+    logger.info(f"[LOGGER] Initialized → {log_path}")
+    return logger
+
+
+def save_csv(df, path: str, logger: logging.Logger = None) -> None:
+    """
+    Saves a DataFrame as CSV, logging the event.
+    """
+    df.to_csv(path, index=False)
+    if logger:
+        logger.info(f"[OUTPUT] Saved CSV → {path}")
+    else:
+        print(f"[OUTPUT] Saved CSV → {path}")
+
+
+def clean_uploads(upload_dir: str, logger: logging.Logger = None) -> None:
+    """
+    Cleans temporary uploaded files in the uploads directory.
+    """
+    if not os.path.exists(upload_dir):
+        return
+
+    files = [f for f in os.listdir(upload_dir) if os.path.isfile(os.path.join(upload_dir, f))]
+    for f in files:
+        try:
+            os.remove(os.path.join(upload_dir, f))
+        except Exception as e:
+            if logger:
+                logger.warning(f"[CLEANUP] Could not remove {f}: {e}")
+
+    if logger:
+        logger.info(f"[CLEANUP] Cleared {len(files)} files from {upload_dir}")
+
+
+def get_temp_image_path(upload_dir: str, filename: str = None) -> str:
+    """
+    Generates a unique temporary image path inside the uploads directory.
+    """
+    mkdir(upload_dir)
+    if filename is None:
+        filename = f"tmp_{get_timestamp()}.jpg"
+    return os.path.join(upload_dir, filename)

requirements.txt

@@ -0,0 +1,87 @@
+aiofiles==24.1.0
+albucore==0.0.24
+albumentations==2.0.8
+git+https://github.com/Alexandre-Delplanque/HerdNet.git@7e25f482d875522c59c446dc0c78c8f6f2dd448d#egg=animaloc
+annotated-doc==0.0.3
+annotated-types==0.7.0
+anyio==4.11.0
+brotli==1.2.0
+certifi==2025.10.5
+charset-normalizer==3.4.4
+click==8.3.0
+colorama==0.4.6
+contourpy==1.3.3
+cycler==0.12.1
+fastapi==0.121.0
+ffmpy==0.6.4
+filelock==3.20.0
+fonttools==4.60.1
+fsspec==2025.10.0
+gitdb==4.0.12
+GitPython==3.1.45
+gradio==5.49.1
+gradio_client==1.13.3
+groovy==0.1.2
+h11==0.16.0
+hf-xet==1.2.0
+httpcore==1.0.9
+httpx==0.28.1
+huggingface_hub==1.1.2
+idna==3.11
+Jinja2==3.1.6
+joblib==1.5.2
+kiwisolver==1.4.9
+markdown-it-py==4.0.0
+MarkupSafe==3.0.3
+matplotlib==3.10.7
+mdurl==0.1.2
+mpmath==1.3.0
+networkx==3.5
+numpy==2.2.6
+opencv-python-headless==4.12.0.88
+orjson==3.11.4
+packaging==25.0
+pandas==2.3.3
+pillow==11.3.0
+platformdirs==4.5.0
+protobuf==6.33.0
+pydantic==2.11.10
+pydantic_core==2.33.2
+pydub==0.25.1
+Pygments==2.19.2
+pyparsing==3.2.5
+python-dateutil==2.9.0.post0
+python-multipart==0.0.20
+pytz==2025.2
+PyYAML==6.0.3
+requests==2.32.5
+rich==14.2.0
+ruff==0.14.4
+safehttpx==0.1.7
+scikit-learn==1.7.2
+scipy==1.16.3
+semantic-version==2.10.0
+sentry-sdk==2.43.0
+setuptools==80.9.0
+shellingham==1.5.4
+simsimd==6.5.3
+six==1.17.0
+smmap==5.0.2
+sniffio==1.3.1
+starlette==0.49.3
+stringzilla==4.2.3
+sympy==1.14.0
+threadpoolctl==3.6.0
+tomlkit==0.13.3
+torch==2.9.0
+torchvision==0.24.0
+tqdm==4.67.1
+typer==0.20.0
+typer-slim==0.20.0
+typing-inspection==0.4.2
+typing_extensions==4.15.0
+tzdata==2025.2
+urllib3==2.5.0
+uvicorn==0.38.0
+wandb==0.22.3
+websockets==15.0.1

resources/configs/default.yaml

@@ -0,0 +1,22 @@
+# ===========================================
+# Default Configuration for HerdNet Inference
+# ===========================================
+
+model:
+  name: "herdnet_fase1_best"
+  path: "resources/models/herdnet_best.pth"
+  device: "cuda"           # "cuda" o "cpu"
+  patch_size: 512
+  overlap: 160
+  down_ratio: 2
+
+paths:
+  uploads_dir: "resources/uploads"
+  outputs_dir: "resources/outputs"
+  logs_dir: "resources/logs"
+
+inference:
+  save_plots: true
+  save_csv: true
+  save_thumbnails: false
+  verbose: true

resources/models/herdnet_best.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bad3367c0c0b26a5392b9f654b0eae25ef205c15334108603e7085ec54905c05
+size 78678824