Upload folder using huggingface_hub

MiaMotion/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

MiaMotion/README.md

@@ -0,0 +1,3 @@
+---
+license: gpl-2.0
+---

MiaMotion/best_model.pt

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

MiaMotion/config.json

@@ -0,0 +1,9 @@
+{
+    "base_model_id": "dccuchile/bert-base-spanish-wwm-cased",
+    "pretrained_encoder": "beto",
+    "max_length": 128,
+    "hidden1": 128,
+    "hidden2": 64,
+    "num_classes": 6,
+    "dropout": 0.3
+}

MiaMotion/emotion_classifier_model.py

@@ -0,0 +1,207 @@
+"""
+=== MIA · Clasificador de Emociones (Pretrained Encoder + MLP) ===
+- Mantiene compatibilidad con tu API pública.
+- Permite usar tu TextEmbedder aleatorio (emb_dim) o un encoder preentrenado (BETO) con 768D.
+- Expone freeze/unfreeze para controlar el fine-tuning desde el trainer.
+"""
+
+import torch
+import torch.nn as nn
+from typing import List, Optional
+from transformers import AutoTokenizer, AutoModel
+
+
+# ==================== MÓDULO 1A: TextEmbedder (embedding aleatorio) ====================
+class TextEmbedder(nn.Module):
+    """
+    Módulo de Embedding simple:
+    - Usa el tokenizador de BETO para sub-palabras (por conveniencia, vocab, pad_id, etc.)
+    - La representación es un embedding aleatorio + mean pooling (no contextual).
+    """
+    def __init__(
+        self,
+        model_name: str = "dccuchile/bert-base-spanish-wwm-cased",
+        emb_dim: int = 300,
+        max_length: int = 128,
+        device: Optional[torch.device] = None
+    ):
+        super().__init__()
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=True)
+        self.vocab_size = self.tokenizer.vocab_size
+        self.pad_id = self.tokenizer.pad_token_id
+        self.cls_id = self.tokenizer.cls_token_id
+        self.sep_id = self.tokenizer.sep_token_id
+        self.max_length = max_length
+
+        # Capa de embedding
+        self.embedding = nn.Embedding(self.vocab_size, emb_dim, padding_idx=self.pad_id)
+        nn.init.xavier_uniform_(self.embedding.weight)
+        with torch.no_grad():
+            if self.pad_id is not None:
+                self.embedding.weight[self.pad_id].zero_()
+
+        # Regularización opcional (ayuda contra sobreajuste)
+        self.emb_dropout = nn.Dropout(p=0.1)
+
+        self.device = device or torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.to(self.device)
+
+    def embed_batch(self, texts: List[str]) -> torch.Tensor:
+        batch = self.tokenizer(
+            texts, padding=True, truncation=True, max_length=self.max_length, return_tensors="pt"
+        )
+        input_ids = batch["input_ids"].to(self.device)           # [B, T]
+        attention_mask = batch["attention_mask"].to(self.device) # [B, T]
+
+        embeds = self.embedding(input_ids)                       # [B, T, E]
+        if self.training:
+            embeds = self.emb_dropout(embeds)
+
+        mask = attention_mask.bool()                             # [B, T]
+        if self.cls_id is not None:
+            mask = mask & (input_ids != self.cls_id)
+        if self.sep_id is not None:
+            mask = mask & (input_ids != self.sep_id)
+
+        mask_f = mask.unsqueeze(-1).float()                      # [B, T, 1]
+        summed = (embeds * mask_f).sum(dim=1)                    # [B, E]
+        counts = mask_f.sum(dim=1).clamp(min=1.0)                # [B, 1]
+        sentence_vecs = summed / counts                          # [B, E]
+        return sentence_vecs
+
+    def embed_sentence(self, text: str) -> torch.Tensor:
+        return self.embed_batch([text])[0]
+
+
+# ==================== MÓDULO 1B: BETOEmbedder (encoder preentrenado) ====================
+class BETOEmbedder(nn.Module):
+    """
+    Usa el encoder de BETO (BERT en español) para obtener embeddings contextuales.
+    Mean pooling sobre last_hidden_state.
+    Salida: [B, 768]
+    """
+    def __init__(
+        self,
+        model_name: str = "dccuchile/bert-base-spanish-wwm-cased",
+        max_length: int = 128,
+        device: Optional[torch.device] = None
+    ):
+        super().__init__()
+        self.device = device or torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=True)
+        self.encoder = AutoModel.from_pretrained(model_name)
+        self.max_length = max_length
+        self.encoder.to(self.device)
+
+    def embed_batch(self, texts: List[str]) -> torch.Tensor:
+        inputs = self.tokenizer(
+            texts, padding=True, truncation=True, max_length=self.max_length, return_tensors="pt"
+        ).to(self.device)
+        outputs = self.encoder(**inputs)  # last_hidden_state [B, T, 768]
+        last_hidden = outputs.last_hidden_state
+        mask = inputs["attention_mask"].unsqueeze(-1).float()  # [B, T, 1]
+        pooled = (last_hidden * mask).sum(dim=1) / mask.sum(dim=1).clamp(min=1e-9)  # [B, 768]
+        return pooled
+
+
+# ==================== MÓDULO 2: MLP Classifier ====================
+class MLPClassifier(nn.Module):
+    """
+    Feedforward para clasificación de emociones:
+    Input → 128 → 64 → 6 (logits)
+    """
+    def __init__(
+        self,
+        input_dim: int = 300,
+        hidden1: int = 128,
+        hidden2: int = 64,
+        num_classes: int = 6,
+        dropout: float = 0.3
+    ):
+        super().__init__()
+        self.fc1 = nn.Linear(input_dim, hidden1)
+        self.relu1 = nn.ReLU()
+        self.dropout1 = nn.Dropout(dropout)
+
+        self.fc2 = nn.Linear(hidden1, hidden2)
+        self.relu2 = nn.ReLU()
+        self.dropout2 = nn.Dropout(dropout)
+
+        self.fc3 = nn.Linear(hidden2, num_classes)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.fc1(x); x = self.relu1(x); x = self.dropout1(x)
+        x = self.fc2(x); x = self.relu2(x); x = self.dropout2(x)
+        x = self.fc3(x)
+        return x
+
+
+# ==================== MÓDULO 3: Modelo Completo ====================
+class EmotionClassifier(nn.Module):
+    """
+    Integra embedder (aleatorio o BETO) + MLP.
+    - `pretrained_encoder=None` → usa TextEmbedder (emb_dim configurable)
+    - `pretrained_encoder="beto"` → usa BETOEmbedder (salida 768D)
+    """
+    def __init__(
+        self,
+        model_name: str = "dccuchile/bert-base-spanish-wwm-cased",
+        emb_dim: int = 300,
+        max_length: int = 128,
+        hidden1: int = 128,
+        hidden2: int = 64,
+        num_classes: int = 6,
+        dropout: float = 0.3,
+        device: Optional[torch.device] = None,
+        pretrained_encoder: Optional[str] = None
+    ):
+        super().__init__()
+        self.device = device or torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+        if pretrained_encoder == "beto":
+            self.embedder = BETOEmbedder(model_name=model_name, max_length=max_length, device=self.device)
+            embed_dim = 768
+        else:
+            self.embedder = TextEmbedder(model_name=model_name, emb_dim=emb_dim, max_length=max_length, device=self.device)
+            embed_dim = emb_dim
+
+        self.classifier = MLPClassifier(
+            input_dim=embed_dim, hidden1=hidden1, hidden2=hidden2, num_classes=num_classes, dropout=dropout
+        )
+
+        self.label_map = {0: "tristeza", 1: "alegría", 2: "amor", 3: "ira", 4: "miedo", 5: "sorpresa"}
+
+        self.to(self.device)
+
+    # ---------- Forward & Utils ----------
+    def forward(self, texts: List[str]) -> torch.Tensor:
+        embeddings = self.embedder.embed_batch(texts)  # [B, D]
+        logits = self.classifier(embeddings)           # [B, C]
+        return logits
+
+    def predict(self, texts: List[str], return_probs: bool = False):
+        self.eval()
+        with torch.no_grad():
+            logits = self.forward(texts)
+            probs = torch.softmax(logits, dim=-1)
+            predictions = torch.argmax(probs, dim=-1)
+            emotions = [self.label_map[p.item()] for p in predictions]
+            if return_probs:
+                return emotions, probs.cpu().numpy()
+            return emotions
+
+    def predict_single(self, text: str, return_probs: bool = False):
+        out = self.predict([text], return_probs=return_probs)
+        if return_probs:
+            emotions, probs = out
+            return emotions[0], probs[0]
+        return out[0]
+
+    # ---------- Fine-tuning helpers ----------
+    def freeze_encoder(self):
+        for p in self.embedder.parameters():
+            p.requires_grad = False
+
+    def unfreeze_encoder(self):
+        for p in self.embedder.parameters():
+            p.requires_grad = True

MiaMotion/label_map.json

@@ -0,0 +1,8 @@
+{
+    "0": "tristeza",
+    "1": "alegría",
+    "2": "amor",
+    "3": "ira",
+    "4": "miedo",
+    "5": "sorpresa"
+}

MiaMotion/requirements.txt

@@ -0,0 +1,86 @@
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.15
+aiosignal==1.4.0
+anyio==4.10.0
+attrs==25.3.0
+beautifulsoup4==4.13.5
+certifi==2025.8.3
+charset-normalizer==3.4.3
+contourpy==1.3.3
+cycler==0.12.1
+datasets==4.1.1
+deep-translator==1.11.4
+dill==0.4.0
+filelock==3.19.1
+fonttools==4.60.1
+frozenlist==1.7.0
+fsspec==2025.9.0
+googletrans==4.0.2
+h11==0.16.0
+h2==4.3.0
+hf-xet==1.1.10
+hpack==4.1.0
+httpcore==1.0.9
+httpx==0.28.1
+huggingface-hub==0.35.0
+hyperframe==6.1.0
+idna==3.10
+ijson==3.4.0
+Jinja2==3.1.6
+joblib==1.5.2
+kiwisolver==1.4.9
+MarkupSafe==3.0.3
+matplotlib==3.10.7
+mpmath==1.3.0
+multidict==6.6.4
+multiprocess==0.70.16
+networkx==3.5
+numpy==2.3.3
+nvidia-cublas-cu12==12.8.4.1
+nvidia-cuda-cupti-cu12==12.8.90
+nvidia-cuda-nvrtc-cu12==12.8.93
+nvidia-cuda-runtime-cu12==12.8.90
+nvidia-cudnn-cu12==9.10.2.21
+nvidia-cufft-cu12==11.3.3.83
+nvidia-cufile-cu12==1.13.1.3
+nvidia-curand-cu12==10.3.9.90
+nvidia-cusolver-cu12==11.7.3.90
+nvidia-cusparse-cu12==12.5.8.93
+nvidia-cusparselt-cu12==0.7.1
+nvidia-nccl-cu12==2.27.5
+nvidia-nvjitlink-cu12==12.8.93
+nvidia-nvshmem-cu12==3.3.20
+nvidia-nvtx-cu12==12.8.90
+packaging==25.0
+pandas==2.3.2
+pillow==12.0.0
+propcache==0.3.2
+protobuf==6.33.0
+pyarrow==21.0.0
+pyparsing==3.2.5
+python-dateutil==2.9.0.post0
+pytz==2025.2
+PyYAML==6.0.2
+regex==2025.10.23
+requests==2.32.5
+safetensors==0.6.2
+scikit-learn==1.7.2
+scipy==1.16.2
+seaborn==0.13.2
+setuptools==80.9.0
+six==1.17.0
+sniffio==1.3.1
+soupsieve==2.8
+sympy==1.14.0
+threadpoolctl==3.6.0
+tiktoken==0.12.0
+tokenizers==0.22.1
+torch==2.9.0
+tqdm==4.67.1
+transformers==4.57.1
+triton==3.5.0
+typing_extensions==4.15.0
+tzdata==2025.2
+urllib3==2.5.0
+xxhash==3.5.0
+yarl==1.20.1

inference_emotion_classifier.py

@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+"""
+Inferencia para MIA (RustyLinux/MiaMotion)
+- Carga el modelo desde archivos locales si existen (best_model.pt, config.json).
+- Si no están en local, los descarga desde el Hugging Face Hub.
+- Expone `predict(text: str)` para usar desde scripts, Spaces (Gradio) o servicios.
+"""
+
+import os
+import json
+from pathlib import Path
+from typing import Any, Dict
+
+import torch
+
+try:
+    from huggingface_hub import hf_hub_download
+except Exception:
+    hf_hub_download = None  # si no está instalado, funcionará en local con archivos presentes
+
+from emotion_classifier_model import EmotionClassifier
+
+# ---------------- Config ----------------
+REPO_ID = "RustyLinux/MiaMotion"  # tu repo en el Hub
+
+LOCAL_CKPT = Path("best_model.pt")
+LOCAL_CFG  = Path("config.json")
+
+_device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+_model = None  # cache global
+
+
+def _resolve_paths() -> (str, str):
+    """
+    Retorna (ckpt_path, cfg_path). Busca primero local, si no, descarga del Hub.
+    """
+    if LOCAL_CKPT.exists() and LOCAL_CFG.exists():
+        return str(LOCAL_CKPT.resolve()), str(LOCAL_CFG.resolve())
+
+    if hf_hub_download is None:
+        raise RuntimeError(
+            "No se encontraron 'best_model.pt' y 'config.json' en local, "
+            "y 'huggingface_hub' no está instalado para descargarlos."
+        )
+
+    ckpt_path = hf_hub_download(repo_id=REPO_ID, filename="best_model.pt")
+    cfg_path  = hf_hub_download(repo_id=REPO_ID, filename="config.json")
+    return ckpt_path, cfg_path
+
+
+def _load_model() -> EmotionClassifier:
+    global _model
+    if _model is not None:
+        return _model
+
+    ckpt_path, cfg_path = _resolve_paths()
+
+    with open(cfg_path, "r", encoding="utf-8") as f:
+        cfg = json.load(f)
+
+    model = EmotionClassifier(
+        model_name=cfg.get("base_model_id", "dccuchile/bert-base-spanish-wwm-cased"),
+        max_length=cfg.get("max_length", 128),
+        hidden1=cfg.get("hidden1", 128),
+        hidden2=cfg.get("hidden2", 64),
+        num_classes=cfg.get("num_classes", 6),
+        dropout=cfg.get("dropout", 0.3),
+        device=_device,
+        pretrained_encoder=cfg.get("pretrained_encoder", "beto"),
+    )
+
+    state = torch.load(ckpt_path, map_location=_device)
+    if isinstance(state, dict) and "model_state_dict" in state:
+        model.load_state_dict(state["model_state_dict"])
+    else:
+        # por si guardaste el state_dict directo
+        model.load_state_dict(state)
+
+    model.eval()
+    _model = model
+    return _model
+
+
+def predict(text: str, return_probs: bool = False) -> Any:
+    """
+    Predice la emoción para un texto.
+    - return_probs=True: devuelve (label:str, probs:list[float]) en el orden de model.label_map
+    - return_probs=False: devuelve solo label:str
+    """
+    model = _load_model()
+    if return_probs:
+        label, probs = model.predict_single(text, return_probs=True)
+        return label, probs.tolist()
+    return model.predict_single(text)
+
+
+if __name__ == "__main__":
+    # Pruebas rápidas
+    print(predict("Estoy muy contento con los resultados", return_probs=True))
+    print(predict("Tengo miedo de lo que pueda pasar", return_probs=True))