acp-classifier 1.0.0__py3-none-any.whl

acp_classifier/__init__.py

@@ -0,0 +1,20 @@
+"""acp-classifier — clasificación de péptidos anticancerígenos.
+
+Universidad Industrial de Santander
+Escuela de Ingeniería de Sistemas e Informática
+Trabajo de grado, 2026
+"""
+
+__version__ = "1.0.0"
+
+from .fasta import ErrorFasta, Peptido, leer_fasta
+from .predictor import AcpClassifier, Prediccion
+
+__all__ = [
+    "AcpClassifier",
+    "Prediccion",
+    "Peptido",
+    "leer_fasta",
+    "ErrorFasta",
+    "__version__",
+]

acp_classifier/cli.py

@@ -0,0 +1,92 @@
+"""Interfaz de línea de comandos de acp-classifier."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import sys
+from pathlib import Path
+
+from . import __version__
+from .fasta import ErrorFasta
+
+CAMPOS = ["identificador", "secuencia", "longitud", "probabilidad_acp", "prediccion"]
+
+
+def construir_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="acp-classifier",
+        description="Clasificación de péptidos anticancerígenos (ACPs) a partir de "
+        "secuencias en formato FASTA, mediante embeddings de ESM-2 y "
+        "Regresión Logística.",
+        epilog="Ejemplo:  acp-classifier -i peptidos.fasta -o resultados.csv",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    p.add_argument("-i", "--input", required=True, metavar="FASTA",
+                   help="archivo FASTA de entrada con una o varias secuencias")
+    p.add_argument("-o", "--output", metavar="CSV",
+                   help="archivo CSV de salida (por defecto se imprime en pantalla)")
+    p.add_argument("-u", "--umbral", type=float, default=0.5, metavar="P",
+                   help="probabilidad mínima para clasificar como ACP")
+    p.add_argument("-b", "--batch-size", type=int, default=32, metavar="N",
+                   help="secuencias procesadas por lote")
+    p.add_argument("-m", "--modelo", metavar="RUTA",
+                   help="artefacto .joblib alternativo (por defecto, el incluido)")
+    p.add_argument("-q", "--quiet", action="store_true",
+                   help="suprime los mensajes de progreso")
+    p.add_argument("--version", action="version", version=f"acp-classifier {__version__}")
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = construir_parser().parse_args(argv)
+
+    if not 0.0 < args.umbral < 1.0:
+        print("Error: el umbral debe estar entre 0 y 1 (exclusivos).", file=sys.stderr)
+        return 2
+
+    def log(mensaje: str) -> None:
+        if not args.quiet:
+            print(mensaje, file=sys.stderr)
+
+    try:
+        from .predictor import AcpClassifier
+
+        log("Cargando modelo...")
+        clf = AcpClassifier(args.modelo)
+
+        log(f"Leyendo {args.input}...")
+        predicciones = clf.predecir_fasta(args.input, args.umbral, args.batch_size)
+
+    except ErrorFasta as e:
+        print(f"Error de lectura: {e}", file=sys.stderr)
+        return 1
+    except FileNotFoundError as e:
+        print(f"Archivo no encontrado: {e}", file=sys.stderr)
+        return 1
+    except Exception as e:  # noqa: BLE001 - la CLI no debe volcar trazas al usuario
+        print(f"Error: {type(e).__name__}: {e}", file=sys.stderr)
+        return 1
+
+    filas = [p.como_dict() for p in predicciones]
+
+    if args.output:
+        destino = Path(args.output)
+        destino.parent.mkdir(parents=True, exist_ok=True)
+        with destino.open("w", newline="", encoding="utf-8") as fh:
+            escritor = csv.DictWriter(fh, fieldnames=CAMPOS)
+            escritor.writeheader()
+            escritor.writerows(filas)
+        log(f"Resultados guardados en {destino}")
+    else:
+        escritor = csv.DictWriter(sys.stdout, fieldnames=CAMPOS)
+        escritor.writeheader()
+        escritor.writerows(filas)
+
+    n_acp = sum(f["prediccion"] == "ACP" for f in filas)
+    log(f"\n{len(filas)} secuencias analizadas: {n_acp} ACP, {len(filas) - n_acp} no-ACP")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

acp_classifier/embedder.py

@@ -0,0 +1,90 @@
+"""Generación de embeddings con ESM-2 8M (esm2_t6_8M_UR50D).
+
+El modelo se descarga de HuggingFace la primera vez (~31 MB) y queda en caché
+local. No requiere GPU: sobre CPU procesa varios cientos de secuencias por minuto.
+"""
+
+from __future__ import annotations
+
+from typing import Iterable, Literal
+
+import numpy as np
+
+MODELO = "facebook/esm2_t6_8M_UR50D"
+DIMENSIONES = 320
+
+Pooling = Literal["tesis", "estricto"]
+
+
+def _mascara_tesis(attention_mask):
+    """Enmascarado empleado para obtener los resultados reportados en el trabajo.
+
+    Excluye el token <cls> y la ÚLTIMA POSICIÓN CON ATENCIÓN CONTADA TRAS ANULAR <cls>,
+    que corresponde al último aminoácido y no al token <eos>. Se conserva tal cual
+    porque es el procedimiento con el que se entrenó y evaluó el modelo distribuido
+    (AUC-ROC de 0.8745 sobre el conjunto de prueba independiente de mACPpred 2.0).
+    """
+    mask = attention_mask.clone()
+    mask[:, 0] = 0
+    for j, longitud in enumerate(mask.sum(dim=1)):
+        if longitud > 1:
+            mask[j, longitud - 1] = 0
+    return mask
+
+
+def _mascara_estricta(attention_mask):
+    """Excluye exactamente <cls> y <eos>, dejando solo los aminoácidos reales."""
+    mask = attention_mask.clone()
+    mask[:, 0] = 0
+    longitudes = attention_mask.sum(dim=1)
+    for j, longitud in enumerate(longitudes):
+        if longitud > 1:
+            mask[j, longitud - 1] = 0
+    return mask
+
+
+class Esm2Embedder:
+    """Convierte secuencias peptídicas en vectores de 320 dimensiones."""
+
+    def __init__(self, pooling: Pooling = "tesis", dispositivo: str | None = None):
+        import torch
+        from transformers import AutoModel, AutoTokenizer
+
+        if pooling not in ("tesis", "estricto"):
+            raise ValueError(f"pooling debe ser 'tesis' o 'estricto', no {pooling!r}")
+
+        self._torch = torch
+        self.pooling = pooling
+        self.dispositivo = dispositivo or ("cuda" if torch.cuda.is_available() else "cpu")
+
+        self.tokenizer = AutoTokenizer.from_pretrained(MODELO)
+        self.model = AutoModel.from_pretrained(MODELO).to(self.dispositivo).eval()
+
+    def __call__(self, secuencias: Iterable[str], tamano_lote: int = 32) -> np.ndarray:
+        secuencias = list(secuencias)
+        if not secuencias:
+            return np.empty((0, DIMENSIONES), dtype=np.float32)
+
+        torch = self._torch
+        lotes: list[np.ndarray] = []
+
+        for i in range(0, len(secuencias), tamano_lote):
+            lote = secuencias[i : i + tamano_lote]
+            entradas = self.tokenizer(
+                lote, return_tensors="pt", padding=True, truncation=True, max_length=512
+            )
+            entradas = {k: v.to(self.dispositivo) for k, v in entradas.items()}
+
+            with torch.no_grad():
+                salidas = self.model(**entradas)
+
+            oculto = salidas.last_hidden_state
+            construir = _mascara_tesis if self.pooling == "tesis" else _mascara_estricta
+            mask = construir(entradas["attention_mask"])
+
+            expandida = mask.unsqueeze(-1).float()
+            suma = (oculto * expandida).sum(dim=1)
+            cuenta = expandida.sum(dim=1).clamp(min=1e-9)
+            lotes.append((suma / cuenta).cpu().numpy())
+
+        return np.vstack(lotes).astype(np.float32)

acp_classifier/fasta.py

@@ -0,0 +1,96 @@
+"""Lectura y validación de archivos FASTA."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+AMINOACIDOS = frozenset("ACDEFGHIKLMNPQRSTVWY")
+
+
+@dataclass(frozen=True)
+class Peptido:
+    """Una secuencia peptídica leída de un archivo FASTA."""
+
+    identificador: str
+    secuencia: str
+
+    @property
+    def longitud(self) -> int:
+        return len(self.secuencia)
+
+
+class ErrorFasta(ValueError):
+    """El archivo FASTA no pudo interpretarse."""
+
+
+def limpiar(secuencia: str) -> str:
+    """Deja únicamente los 20 aminoácidos estándar, en mayúsculas.
+
+    Los residuos no estándar (X, B, Z, U, O y cualquier otro carácter) se descartan.
+    Es el mismo preprocesamiento aplicado durante el entrenamiento del modelo.
+    """
+    return "".join(aa for aa in secuencia.upper() if aa in AMINOACIDOS)
+
+
+def leer_fasta(ruta: str | Path, longitud_minima: int = 2) -> list[Peptido]:
+    """Lee un archivo FASTA y devuelve sus secuencias.
+
+    Admite registros repartidos en varias líneas. Las secuencias que quedan por
+    debajo de `longitud_minima` tras la limpieza se descartan con un aviso.
+
+    Raises
+    ------
+    ErrorFasta
+        Si el archivo no existe, está vacío o no contiene ninguna cabecera '>'.
+    """
+    ruta = Path(ruta)
+    if not ruta.is_file():
+        raise ErrorFasta(f"No existe el archivo: {ruta}")
+
+    peptidos: list[Peptido] = []
+    descartados: list[str] = []
+    identificador: str | None = None
+    partes: list[str] = []
+
+    def cerrar() -> None:
+        if identificador is None:
+            return
+        limpia = limpiar("".join(partes))
+        if len(limpia) >= longitud_minima:
+            peptidos.append(Peptido(identificador, limpia))
+        else:
+            descartados.append(identificador)
+
+    with ruta.open(encoding="utf-8", errors="replace") as fh:
+        for linea in fh:
+            linea = linea.strip()
+            if not linea:
+                continue
+            if linea.startswith(">"):
+                cerrar()
+                identificador = linea[1:].strip() or f"secuencia_{len(peptidos) + 1}"
+                partes = []
+            else:
+                partes.append(linea)
+    cerrar()
+
+    if identificador is None:
+        raise ErrorFasta(
+            f"{ruta} no contiene ninguna cabecera FASTA ('>'). "
+            "Verifique que el archivo esté en formato FASTA."
+        )
+    if not peptidos:
+        raise ErrorFasta(
+            f"{ruta} no contiene ninguna secuencia válida de al menos "
+            f"{longitud_minima} aminoácidos estándar."
+        )
+    if descartados:
+        print(
+            f"  Aviso: {len(descartados)} secuencia(s) descartada(s) por quedar "
+            f"con menos de {longitud_minima} aminoácidos estándar: "
+            + ", ".join(descartados[:5])
+            + (" ..." if len(descartados) > 5 else "")
+        )
+
+    return peptidos

acp_classifier/modelos/__init__.py

@@ -0,0 +1 @@
+"""Artefactos serializados del modelo entrenado."""

acp_classifier/predictor.py

@@ -0,0 +1,121 @@
+"""Clasificador de péptidos anticancerígenos."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, asdict
+from importlib import resources
+from pathlib import Path
+
+import joblib
+import numpy as np
+
+from .embedder import Esm2Embedder
+from .fasta import Peptido, leer_fasta
+
+UMBRAL_POR_DEFECTO = 0.5
+
+
+@dataclass(frozen=True)
+class Prediccion:
+    identificador: str
+    secuencia: str
+    longitud: int
+    probabilidad_acp: float
+    prediccion: str
+
+    def como_dict(self) -> dict:
+        return asdict(self)
+
+
+def _probabilidades_desde_pesos(X: np.ndarray, pesos: dict) -> np.ndarray:
+    """Estandariza y aplica la regresión logística a partir de los pesos.
+
+    Equivale a `LogisticRegression.predict_proba` sobre `StandardScaler.transform`,
+    pero sin instanciar objetos de scikit-learn, de modo que la predicción no
+    depende de la versión de la biblioteca que haya instalada.
+    """
+    Z = (np.asarray(X, dtype=np.float64) - pesos["media"]) / pesos["escala"]
+    z = Z @ pesos["coef"] + pesos["intercepto"]
+    return 1.0 / (1.0 + np.exp(-z))
+
+
+class AcpClassifier:
+    """Predice actividad anticancerígena a partir de secuencias peptídicas.
+
+    Combina embeddings de ESM-2 8M con un clasificador de Regresión Logística,
+    seleccionado por obtener el mayor AUC-ROC sobre el conjunto de prueba
+    independiente de mACPpred 2.0 (Sangaraju et al., 2024).
+
+    Ejemplo
+    -------
+    >>> from acp_classifier import AcpClassifier
+    >>> clf = AcpClassifier()
+    >>> clf.predecir_secuencias(["KWKLFKKIEKVGQNIRDGIIKAGPAVAVVGQATQIAK"])
+    """
+
+    def __init__(self, ruta_modelo: str | Path | None = None):
+        artefacto = self._cargar_artefacto(ruta_modelo)
+        self.metadatos = artefacto["metadatos"]
+        self._pesos = artefacto.get("pesos")
+        # Compatibilidad con artefactos del formato antiguo, que guardaban los
+        # objetos de scikit-learn serializados.
+        self._modelo = artefacto.get("modelo")
+        self._scaler = artefacto.get("scaler")
+        if self._pesos is None and self._modelo is None:
+            raise ValueError(
+                "El artefacto no contiene ni 'pesos' ni 'modelo'; no es un modelo "
+                "de acp-classifier."
+            )
+        self._embedder: Esm2Embedder | None = None
+
+    @staticmethod
+    def _cargar_artefacto(ruta_modelo):
+        if ruta_modelo is not None:
+            return joblib.load(Path(ruta_modelo))
+        with resources.as_file(
+            resources.files("acp_classifier.modelos") / "acp_esm2_8m_lr.joblib"
+        ) as p:
+            return joblib.load(p)
+
+    @property
+    def embedder(self) -> Esm2Embedder:
+        """El modelo de lenguaje se carga de forma diferida, en el primer uso."""
+        if self._embedder is None:
+            self._embedder = Esm2Embedder(pooling=self.metadatos["pooling"])
+        return self._embedder
+
+    def probabilidades(self, secuencias, tamano_lote: int = 32) -> np.ndarray:
+        X = self.embedder(secuencias, tamano_lote=tamano_lote)
+        if self._pesos is not None:
+            return _probabilidades_desde_pesos(X, self._pesos)
+        return self._modelo.predict_proba(self._scaler.transform(X))[:, 1]
+
+    def predecir_secuencias(
+        self,
+        secuencias,
+        umbral: float = UMBRAL_POR_DEFECTO,
+        tamano_lote: int = 32,
+    ) -> list[Prediccion]:
+        peptidos = [
+            p if isinstance(p, Peptido) else Peptido(f"secuencia_{i + 1}", p)
+            for i, p in enumerate(secuencias)
+        ]
+        probas = self.probabilidades([p.secuencia for p in peptidos], tamano_lote)
+        return [
+            Prediccion(
+                identificador=p.identificador,
+                secuencia=p.secuencia,
+                longitud=p.longitud,
+                probabilidad_acp=round(float(pr), 4),
+                prediccion="ACP" if pr >= umbral else "no-ACP",
+            )
+            for p, pr in zip(peptidos, probas)
+        ]
+
+    def predecir_fasta(
+        self,
+        ruta_fasta: str | Path,
+        umbral: float = UMBRAL_POR_DEFECTO,
+        tamano_lote: int = 32,
+    ) -> list[Prediccion]:
+        return self.predecir_secuencias(leer_fasta(ruta_fasta), umbral, tamano_lote)

acp_classifier-1.0.0.dist-info/METADATA

@@ -0,0 +1,245 @@
+Metadata-Version: 2.4
+Name: acp-classifier
+Version: 1.0.0
+Summary: Clasificación de péptidos anticancerígenos (ACPs) mediante modelos de lenguaje proteico
+Author: Brayan Arturo Navarro Sinuco, Ivan Andres Mendoza Oñate
+Maintainer: Escuela de Ingeniería de Sistemas e Informática, Universidad Industrial de Santander
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ivan2171977/acp-classifier
+Project-URL: Repository, https://github.com/ivan2171977/acp-classifier
+Project-URL: Issues, https://github.com/ivan2171977/acp-classifier/issues
+Keywords: bioinformatics,anticancer-peptides,acp,protein-language-model,esm2,peptide-classification,machine-learning
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Requires-Dist: joblib>=1.1
+Requires-Dist: torch>=1.11
+Requires-Dist: transformers>=4.20
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: scikit-learn>=1.0; extra == "dev"
+Dynamic: license-file
+
+# acp-classifier
+
+Clasificación de péptidos anticancerígenos (ACPs) a partir de secuencias en formato FASTA,
+mediante representaciones contextuales generadas por el modelo de lenguaje proteico
+**ESM-2** y un clasificador de **Regresión Logística**.
+
+Desarrollado como trabajo de grado en la Escuela de Ingeniería de Sistemas e Informática de
+la **Universidad Industrial de Santander**.
+
+---
+
+## Por qué existe
+
+Las herramientas de referencia para predicción de ACPs —AntiCP 2.0, MLACP 2.0, mACPpred 2.0,
+ACP-EPC— están disponibles únicamente como servidores web, o como repositorios sin empaquetar.
+Ninguna se instala mediante gestores estándar, lo que dificulta su integración en flujos de
+trabajo bioinformáticos automatizados.
+
+`acp-classifier` se instala con `pip`, se ejecuta desde consola y no requiere GPU.
+
+## Desempeño
+
+Evaluado sobre el **conjunto de prueba independiente oficial** de mACPpred 2.0
+(610 ACPs y 2.760 no-ACPs), sin haber visto ninguna de esas secuencias durante el entrenamiento:
+
+| Métrica | Valor |
+|---|---|
+| AUC-ROC | **0.8745** |
+| F1-score | 0.6230 |
+| Exactitud | 0.8362 |
+| MCC | 0.5341 |
+
+Como referencia, sobre ese mismo conjunto mACPpred 2.0 reporta un AUC-ROC de 0.887 y
+MLACP 2.0 uno de 0.893. Este paquete no supera a ninguna de las dos, pero sí a las otras
+nueve herramientas con AUC-ROC publicado sobre el conjunto —entre ellas mACPpred (0.842),
+iDACP (0.852) y AntiCP 2.0 en su variante alterna (0.835)—, y lo hace con un modelo de ocho
+millones de parámetros y un clasificador lineal, sin GPU en inferencia.
+
+> El conjunto de evaluación está desbalanceado (18,1 % de positivos). Por ese motivo se
+> reporta AUC-ROC como métrica principal, junto con F1 y MCC, y no la exactitud: un
+> clasificador que asignara siempre la clase mayoritaria obtendría un 81,9 % de exactitud
+> sin haber aprendido nada.
+
+## Instalación
+
+```bash
+pip install acp-classifier
+```
+
+Desde el código fuente:
+
+```bash
+git clone https://github.com/ivan2171977/acp-classifier.git
+cd acp-classifier
+pip install -e .
+```
+
+Con Conda:
+
+```bash
+conda env create -f environment.yml
+conda activate acp-classifier
+```
+
+Requiere Python 3.9 o superior. La primera ejecución descarga el modelo ESM-2 8M
+(~31 MB) desde HuggingFace y lo deja en caché local.
+
+## Uso desde consola
+
+```bash
+# Resultados por pantalla
+acp-classifier -i peptidos.fasta
+
+# Resultados a un archivo CSV
+acp-classifier -i peptidos.fasta -o resultados.csv
+
+# Umbral de decisión más exigente
+acp-classifier -i peptidos.fasta -o resultados.csv --umbral 0.8
+```
+
+Opciones:
+
+| Opción | Descripción | Por defecto |
+|---|---|---|
+| `-i`, `--input` | Archivo FASTA de entrada (obligatorio) | — |
+| `-o`, `--output` | Archivo CSV de salida | pantalla |
+| `-u`, `--umbral` | Probabilidad mínima para clasificar como ACP | `0.5` |
+| `-b`, `--batch-size` | Secuencias procesadas por lote | `32` |
+| `-m`, `--modelo` | Artefacto `.joblib` alternativo | el incluido |
+| `-q`, `--quiet` | Suprime los mensajes de progreso | — |
+
+### Entrada
+
+Un archivo FASTA estándar, con una o varias secuencias. Se admiten registros repartidos en
+varias líneas. Los residuos no estándar (`X`, `B`, `Z`, `U`, `O`) se descartan, igual que
+durante el entrenamiento.
+
+```fasta
+>peptido_1
+GLFSVVTGVLKAVGKNVAKNVGGSLLEQLKCKKISGGC
+>peptido_2
+NNEQIRRFSQVLLDAGIVTTIRKTRGDDIDA
+```
+
+### Salida
+
+```csv
+identificador,secuencia,longitud,probabilidad_acp,prediccion
+peptido_1,GLFSVVTGVLKAVGKNVAKNVGGSLLEQLKCKKISGGC,38,0.7350,ACP
+peptido_2,NNEQIRRFSQVLLDAGIVTTIRKTRGDDIDA,31,0.0643,no-ACP
+```
+
+## Uso desde Python
+
+```python
+from acp_classifier import AcpClassifier
+
+clf = AcpClassifier()
+
+# Desde secuencias
+for p in clf.predecir_secuencias(["GIGKFLHSAKKFGKAFVGEIMNS"]):
+    print(p.identificador, p.probabilidad_acp, p.prediccion)
+
+# Desde un archivo FASTA
+predicciones = clf.predecir_fasta("peptidos.fasta", umbral=0.7)
+
+# Solo las probabilidades, como arreglo de NumPy
+probas = clf.probabilidades(["GIGKFLHSAKKFGKAFVGEIMNS", "AAAAAAAAAA"])
+```
+
+## Cómo funciona
+
+```
+FASTA → limpieza → ESM-2 8M → mean pooling → StandardScaler → Regresión Logística → CSV
+        (20 aa)    (320 dim)                                    (C=0.01, saga)
+```
+
+1. **Lectura y limpieza.** Se conservan únicamente los 20 aminoácidos estándar.
+2. **Embeddings.** `esm2_t6_8M_UR50D` genera un vector de 320 dimensiones por secuencia,
+   promediando los estados ocultos de la última capa.
+3. **Normalización.** `StandardScaler` ajustado sobre el conjunto de entrenamiento.
+4. **Clasificación.** Regresión Logística (`C=0.01`, solver `saga`), entrenada sobre las
+   2.352 secuencias de `Training.fasta` de mACPpred 2.0.
+
+### Por qué el modelo más pequeño
+
+Durante el trabajo se evaluaron ESM-2 8M, ESM-2 150M y ProtBERT. **ESM-2 8M obtuvo el mejor
+desempeño**, pese a ser el de menor capacidad. Los péptidos del conjunto de evaluación tienen
+una longitud mediana de 9 residuos: sobre secuencias tan cortas, las representaciones de mayor
+dimensionalidad no aportan poder discriminante y favorecen el sobreajuste.
+
+Esto tiene una consecuencia práctica: el modelo con mejor desempeño es también el de menores
+requisitos (31 MB frente a los 1,7 GB de ProtBERT), lo que permite ejecutarlo sin GPU.
+
+## Reproducir el entrenamiento
+
+```bash
+python entrenar_modelo.py
+```
+
+Regenera el artefacto desde los FASTA de mACPpred 2.0, compara las dos estrategias de
+agregación implementadas e imprime las métricas sobre el conjunto de prueba independiente.
+Toma alrededor de un minuto sobre CPU.
+
+## Pruebas
+
+```bash
+pip install -e ".[dev]"
+pytest -q
+```
+
+## Limitaciones
+
+- La validación es **exclusivamente computacional** (TRL 4). Una predicción positiva es una
+  hipótesis a verificar experimentalmente, no una afirmación de actividad biológica.
+- El modelo fue entrenado sobre péptidos de entre 6 y 50 residuos. Su comportamiento fuera de
+  ese rango no ha sido caracterizado.
+- Existe un desplazamiento de distribución conocido entre los conjuntos de entrenamiento y
+  prueba del benchmark: los ACPs de entrenamiento tienen una longitud mediana de 20 residuos
+  frente a 9 en el conjunto de prueba.
+- El desempeño está caracterizado sobre un único benchmark (mACPpred 2.0).
+
+## Datos
+
+Conjunto de referencia de **mACPpred 2.0** (Sangaraju et al., 2024): 1.176 ACPs y 1.176
+no-ACPs para entrenamiento; 610 ACPs y 2.760 no-ACPs para prueba independiente.
+
+## Citación
+
+```bibtex
+@software{acp_classifier_2026,
+  title  = {acp-classifier: clasificación de péptidos anticancerígenos
+            mediante modelos de lenguaje proteico},
+  author = {Navarro Sinuco, Brayan Arturo and Mendoza Oñate, Ivan Andres},
+  year   = {2026},
+  school = {Universidad Industrial de Santander},
+  url    = {https://github.com/ivan2171977/acp-classifier}
+}
+```
+
+### Referencias
+
+- Lin, Z. et al. (2023). Evolutionary-scale prediction of atomic level protein structure with
+  a language model. *Science*, 379(6637), 1123–1130.
+- Sangaraju, V. K. et al. (2024). mACPpred 2.0: Stacked deep learning for anticancer peptide
+  prediction. *Journal of Molecular Biology*, 436(17), 168687.
+- Pedregosa, F. et al. (2011). Scikit-learn: Machine learning in Python. *JMLR*, 12, 2825–2830.
+- Wolf, T. et al. (2020). Transformers: State-of-the-art natural language processing. *EMNLP:
+  System Demonstrations*, 38–45.
+
+## Licencia
+
+MIT. Véase [LICENSE](LICENSE).

acp_classifier-1.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+acp_classifier/__init__.py,sha256=Oi-_37SVHkJ6VuQpMRr-A5QCAnxJ9W33Myk-ZYTjb4o,431
+acp_classifier/cli.py,sha256=oU0MPWHmwu2cK9uYoU3-afDWCKZjgGLtKfic12NcZxw,3450
+acp_classifier/embedder.py,sha256=LEQW9sG4ApIckzE4vfrWzsZUzghWb7CYR1wsxTOUrtk,3279
+acp_classifier/fasta.py,sha256=HeXl_4Q6fJXP0VLVEAD0ObN_-vwyhX9541-QsilEqgs,2915
+acp_classifier/predictor.py,sha256=ud24i2N8eMOfXRL-T8Xr5GHgUscs0sqWPZTmOybYE9I,4215
+acp_classifier/modelos/__init__.py,sha256=VPux3gRT8nFEnrYPwgaGxgICm1-m2RGXlKhi_WTIE3o,53
+acp_classifier/modelos/acp_esm2_8m_lr.joblib,sha256=R8JO0rcBcHrnuwip2jXzoU0rQgswFXsID8GlVIj5yXI,7490
+acp_classifier-1.0.0.dist-info/licenses/LICENSE,sha256=oGK-94ZeLM9pMXaJDOfOz_RuPtvzLtt6VEutMKKCGME,1203
+acp_classifier-1.0.0.dist-info/METADATA,sha256=68ya-vv9t7Gcs94lCxpBSTdB0fL9yj-yOFig3Xgali8,9139
+acp_classifier-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+acp_classifier-1.0.0.dist-info/entry_points.txt,sha256=mX3u0390RnTaGWYNUoltRVzsVggYKPynIWeXcRgQP-Y,59
+acp_classifier-1.0.0.dist-info/top_level.txt,sha256=iFfnZHoL3SW6mGOLqPhZG72J54MwwP4zW74H3Esqs5A,15
+acp_classifier-1.0.0.dist-info/RECORD,,

acp_classifier-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

acp_classifier-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+acp-classifier = acp_classifier.cli:main

acp_classifier-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Brayan Arturo Navarro Sinuco, Ivan Andres Mendoza Oñate
+Universidad Industrial de Santander — Escuela de Ingeniería de Sistemas e Informática
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

acp_classifier-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+acp_classifier