commit to RepoB

model/mpl_pequeno_torch/dataset.py

@@ -0,0 +1,108 @@
+"""
+Dataset concreto do pipeline ``atualizado`` — dados tabulares + PyTorch.
+
+A maior parte da lógica está em :class:`base_dataset.BaseDataset`
+(``docker/base_dataset.py``). Aqui só fica o que é específico:
+
+  - :py:meth:`build_features` — seleciona colunas numéricas do DataFrame,
+    descartando colunas de identificação (``id``, ``image_path``, ...).
+  - :py:meth:`get_data_loader` — devolve ``DataLoader`` do PyTorch
+    montado em cima dos arrays preparados pela base.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import Optional, Tuple
+
+import numpy as np
+import pandas as pd
+
+try:
+    import torch
+    from torch.utils.data import DataLoader, TensorDataset
+    _TORCH_AVAILABLE = True
+except ImportError:  # pragma: no cover
+    _TORCH_AVAILABLE = False
+
+# Importa BaseDataset de ../base_dataset.py
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+from base_dataset import BaseDataset  # noqa: E402
+
+
+class TrainingDataset(BaseDataset):
+    """Dataset tabular para o pipeline em ``docker/atualizado``."""
+
+    # ------------------------------------------------------------------
+    # Hooks da base
+    # ------------------------------------------------------------------
+    def build_features(self) -> None:
+        if self.df is None:
+            raise RuntimeError("self.df está vazio; load_raw_data() não rodou.")
+
+        # Prioridade: lista explícita no metadata.json
+        explicit = self.metadata.get("features")
+        if explicit:
+            missing = [c for c in explicit if c not in self.df.columns]
+            if missing:
+                raise ValueError(
+                    f"Colunas declaradas em metadata['features'] não encontradas no DataFrame: {missing}"
+                )
+            self.feature_columns = list(explicit)
+            self.X = self.df[self.feature_columns].to_numpy(dtype=np.float32)
+            return
+
+        # Fallback: inferência automática de colunas numéricas
+        feats = []
+        for col in self.df.columns:
+            if col == self.target_column:
+                continue
+            if col.lower() in self.NON_FEATURE_COLS:
+                continue
+            if not pd.api.types.is_numeric_dtype(self.df[col]):
+                continue
+            feats.append(col)
+
+        if not feats:
+            raise ValueError(
+                "Nenhuma coluna numérica encontrada para usar como feature."
+            )
+
+            self.feature_columns = feats
+            self.X = self.df[feats].to_numpy(dtype=np.float32)
+
+    def get_data_loader(
+        self,
+        batch_size: int = 32,
+        train_ratio: Optional[float] = None,
+        seed: Optional[int] = None,
+    ) -> Tuple["DataLoader", "DataLoader"]:
+        if not _TORCH_AVAILABLE:
+            raise RuntimeError(
+                "PyTorch não está instalado; instale-o ou use get_arrays()."
+            )
+
+        train_ratio, seed = self._resolve_split_params(train_ratio, seed)
+        idx_train, idx_val = self._split_indices(train_ratio, seed)
+
+        assert self.X is not None and self.y is not None  # pra mypy
+
+        X_train = torch.from_numpy(self.X[idx_train])
+        y_train = torch.from_numpy(self.y[idx_train]).long()
+        X_val = torch.from_numpy(self.X[idx_val])
+        y_val = torch.from_numpy(self.y[idx_val]).long()
+
+        bs = self._resolve_batch_size(batch_size)
+        train_loader = DataLoader(
+            TensorDataset(X_train, y_train), batch_size=bs, shuffle=True
+        )
+        val_loader = DataLoader(
+            TensorDataset(X_val, y_val), batch_size=bs, shuffle=False
+        )
+
+        print(
+            f"  - Train samples: {len(X_train)} | Val samples: {len(X_val)}"
+            f" | Batch size: {bs}"
+        )
+        return train_loader, val_loader

model/mpl_pequeno_torch/help.md

@@ -0,0 +1,34 @@
+# RNNs / LSTMs for Sequences
+
+## Resume
+Recurrent Neural Networks (RNNs) and Long Short-Term Memory (LSTM) networks are sequential neural architectures designed to map time-series data or sequential text structures. LSTMs introduce explicit gating mechanisms to regulate internal information persistence, successfully resolving the vanishing gradient flaws of traditional RNN blocks.
+
+### Common Use Cases:
+* **SMILES Generation:** Autoregressively printing valid chemical strings token by token.
+* **Biosignal Analysis:** Evaluating chronological streaming signals from patient telemetry or ECG readouts.
+* **Clinical Notes Sequence Modeling:** Tracking medical event timelines over long EHR spans.
+
+## Content
+
+### 1. Core Architecture & Gated Memory
+Standard RNNs maintain a recurring hidden state vector $h_t$ that gets updated with every timestamp token input. However, backpropagating through long sequences causes gradients to rapidly disappear or explode.
+
+LSTMs solve this by introducing an internal **Cell State** ($c_t$) alongside three specialized gating mechanisms:
+* **Forget Gate ($f_t$):** Controls how much historical context from the cell state should be discarded.
+* **Input Gate ($i_t$):** Regulates what new contextual state information should be infused into the current cell vector.
+* **Output Gate ($o_t$):** Determines what subset of internal hidden cell states should be exposed as the final output block.
+
+### 2. Operational Execution Sequence
+As a sequence executes, the architecture reads the token input at step $t$, merges it with the prior step's hidden vector $h_{t-1}$, adjusts cell memories through the gating parameters, and pushes forward the updated state vectors. This linear memory highway allows the architecture to carry context across extended sequence matrices.
+
+### 3. Advantages and Disadvantages
+* **Advantages:**
+  * Natural alignment with arbitrary, variable-length chronological or textual stream structures.
+  * O(L) computational complexity scaling linearly with sequence length.
+* **Disadvantages:**
+  * Strict step-by-step dependency makes parallel sequence acceleration impossible during training.
+  * Susceptible to information decay over extremely long sequences compared to attention structures.
+
+### References
+* Hochreiter, S., & Schmidhuber, J. (1997). *Long short-term memory*. Neural Computation.
+* Segler, M. H., et al. (2018). *Generating focused molecule libraries for drug discovery with recurrent neural networks*. ACS Central Science.

model/mpl_pequeno_torch/hyperparameters.json

@@ -0,0 +1,133 @@
+{
+  "setting": {
+    "name": {
+      "text": "Nome do modelo",
+      "value": "mpl_pequeno_torch",
+      "Help": "Identificação do modelo PyTorch tabular. Pode ser usado para salvar checkpoints ou registros.",
+      "default": "mpl_pequeno_torch",
+      "type": "string",
+      "required": true
+    },
+    "architecture": {
+      "text": "Arquitetura do modelo",
+      "value": "MLP tabular",
+      "Help": "Arquitetura da rede neural para dados tabulares usando PyTorch.",
+      "default": "MLP tabular",
+      "type": "string",
+      "required": true
+    },
+    "tipo": {
+      "text": "Tipo do modelo",
+      "value": "classification",
+      "Help": "Define o tipo de tarefa do modelo.",
+      "default": "classification",
+      "type": "string",
+      "required": true
+    },
+      "learning_type": {
+      "text": "Tipo de aprendizado",
+      "value": "deep_learning",
+      "Help": "Indica se o modelo é de machine learning clássico ou deep learning.",
+      "default": "deep_learning",
+      "type": "string",
+      "required": true
+    }
+  },
+  "train": {
+    "batch_size": {
+      "text": "Tamanho do batch",
+      "Help": "Tamanho do batch usado durante o treinamento.",
+      "default": 32,
+      "range": {
+        "min": 1,
+        "max": null
+      },
+      "type": "integer",
+      "required": true
+    },
+    "epochs": {
+      "text": "Número de épocas",
+      "Help": "Quantidade de épocas de treinamento.",
+      "default": 10,
+      "range": {
+        "min": 1,
+        "max": 1000
+      },
+      "type": "integer",
+      "required": true
+    },
+    "learning_rate": {
+      "text": "Taxa de aprendizado",
+      "Help": "Taxa usada pelo otimizador.",
+      "default": 0.001,
+      "range": {
+        "min": 0.000001,
+        "max": 1.0
+      },
+      "type": "float",
+      "required": true
+    },
+    "weight_decay": {
+      "text": "Decaimento de peso",
+      "Help": "Regularização L2 usada pelo otimizador.",
+      "default": 0.0001,
+      "range": {
+        "min": 0.0,
+        "max": 0.1
+      },
+      "type": "float",
+      "required": false
+    },
+    "optimizer": {
+      "text": "Otimizador",
+      "Help": "Otimizador usado no treinamento.",
+      "default": "adam",
+      "type": "string",
+      "required": true
+    },
+    "hidden_dims": {
+      "text": "Dimensões ocultas",
+      "Help": "Lista de camadas ocultas do MLP.",
+      "default": [32, 16],
+      "type": "list",
+      "required": false
+    },
+    "dropout": {
+      "text": "Dropout",
+      "Help": "Taxa de dropout aplicada entre camadas.",
+      "default": 0.0,
+      "range": {
+        "min": 0.0,
+        "max": 1.0
+      },
+      "type": "float",
+      "required": false
+    }
+  },
+  "test": {
+    "batch_size": {
+      "text": "Tamanho do batch",
+      "Help": "Tamanho do batch usado na avaliação.",
+      "default": 64,
+      "range": {
+        "min": 1,
+        "max": null
+      },
+      "type": "integer",
+      "required": true
+    }
+  },
+  "predict": {
+    "batch_size": {
+      "text": "Tamanho do batch",
+      "Help": "Tamanho do batch usado na predição.",
+      "default": 64,
+      "range": {
+        "min": 1,
+        "max": null
+      },
+      "type": "integer",
+      "required": true
+    }
+  }
+}

model/mpl_pequeno_torch/main.py

@@ -0,0 +1,36 @@
+"""
+Entrypoint do pipeline ``atualizado`` (MLP tabular em PyTorch).
+
+Toda a orquestração (modos train/test/predict, leitura de config,
+escrita dos artefatos) vive em ``docker/base_main.py``. Aqui só
+registramos as peças concretas desta arquitetura:
+
+  - ``TrainingDataset`` (de :mod:`dataset`)
+  - ``create_model``    (de :mod:`model`)
+
+Como o input é tabular, o ``predict_input_loader`` default do
+``base_main`` (que lê CSV/XLSX) já serve — não precisa passar nada.
+Arquiteturas futuras (ex.: CNN para imagem) podem passar um loader
+próprio na chamada de ``run_pipeline``.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+# Permite importar base_main.py de ../
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+from base_main import run_pipeline  # noqa: E402
+from dataset import TrainingDataset  # noqa: E402
+from model import create_model  # noqa: E402
+
+
+if __name__ == "__main__":
+    sys.exit(
+        run_pipeline(
+            dataset_cls=TrainingDataset,
+            model_factory=create_model,
+        )
+    )

model/mpl_pequeno_torch/model.py

@@ -0,0 +1,275 @@
+"""
+Implementação concreta (PyTorch) do modelo treinado pelo pipeline.
+
+Arquitetura: MLP simples para dados tabulares. A configuração de
+camadas, dropout, otimizador, etc. vem de ``config`` (lido do
+``config.json`` do treino) ou de defaults razoáveis.
+
+A classe ``TabularMLP`` herda de ``BaseModel`` (em ``docker/base_model.py``)
+para manter a API uniforme entre frameworks. Uma função ``create_model``
+fábrica é exposta no fim do arquivo para que ``main.py`` continue
+funcionando sem mudanças.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import DataLoader
+
+# Permite importar base_model.py de ../
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+from base_model import BaseModel  # noqa: E402
+from utils import emit_progress  # noqa: E402
+
+
+# ---------------------------------------------------------------------------
+# Arquitetura MLP
+# ---------------------------------------------------------------------------
+class _MLP(nn.Module):
+    def __init__(
+        self,
+        input_size: int,
+        hidden_dims: List[int],
+        num_classes: int,
+        dropout: float = 0.0,
+    ) -> None:
+        super().__init__()
+        layers: List[nn.Module] = []
+        prev = input_size
+        for h in hidden_dims:
+            layers.append(nn.Linear(prev, h))
+            layers.append(nn.ReLU())
+            if dropout and dropout > 0:
+                layers.append(nn.Dropout(dropout))
+            prev = h
+        layers.append(nn.Linear(prev, num_classes))
+        self.net = nn.Sequential(*layers)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:  # noqa: D401
+        return self.net(x)
+
+
+# ---------------------------------------------------------------------------
+# Wrapper que implementa a API de BaseModel
+# ---------------------------------------------------------------------------
+class TabularMLP(BaseModel):
+    """MLP tabular em PyTorch, plugável no pipeline."""
+
+    def build_model(self) -> nn.Module:
+        hp = self.config.get("hyperparameters", {})
+        hidden_dims = self.config.get("hidden_dims") or hp.get("hidden_dims") or [
+            self.config.get("hidden_dim1", 32),
+            self.config.get("hidden_dim2", 16),
+        ]
+        dropout = float(hp.get("dropout", self.config.get("dropout", 0.0)))
+
+        # device
+        self.device = torch.device(
+            "cuda"
+            if torch.cuda.is_available() and self.config.get("use_cuda", True)
+            else "cpu"
+        )
+
+        model = _MLP(
+            input_size=self.input_size,
+            hidden_dims=list(hidden_dims),
+            num_classes=self.num_classes,
+            dropout=dropout,
+        ).to(self.device)
+
+        self.criterion = nn.CrossEntropyLoss()
+        self._hidden_dims = list(hidden_dims)
+        self._dropout = dropout
+        return model
+
+    # ---------------- treinamento ----------------
+    def train_model(
+        self,
+        train_loader: DataLoader,
+        val_loader: Optional[DataLoader],
+        epochs: int,
+        lr: float,
+        **kwargs: Any,
+    ) -> Dict[str, list]:
+        hp = self.config.get("hyperparameters", {})
+        epochs = int(hp.get("epochs", epochs))
+        lr = float(hp.get("learning_rate", lr))
+        weight_decay = float(hp.get("weight_decay", 0.0))
+        optimizer_name = str(hp.get("optimizer", "adam")).lower()
+
+        optimizer = self._build_optimizer(optimizer_name, lr, weight_decay)
+
+        history = {
+            "train_loss": [], "train_acc": [],
+            "val_loss": [],   "val_acc": [],
+        }
+
+        n_batches = max(len(train_loader), 1)
+        total_train_steps = max(epochs * n_batches, 1)
+        best_val_acc = -float("inf")
+        best_epoch = -1
+        for epoch in range(1, epochs + 1):
+            self.model.train()
+            run_loss = 0.0
+            correct = 0
+            total = 0
+            for batch_idx, (X, y) in enumerate(train_loader, start=1):
+                X = X.to(self.device)
+                y = y.to(self.device)
+
+                optimizer.zero_grad()
+                logits = self.model(X)
+                loss = self.criterion(logits, y)
+                loss.backward()
+                optimizer.step()
+
+                run_loss += float(loss.item()) * X.size(0)
+                preds = logits.argmax(dim=1)
+                correct += int((preds == y).sum().item())
+                total += int(y.size(0))
+
+            global_step = (epoch - 1) * n_batches
+            inner_pct = int(global_step * 100 / total_train_steps)
+            emit_progress(inner_pct, total_train_steps)
+
+            train_loss = run_loss / max(total, 1)
+            train_acc = correct / max(total, 1)
+            history["train_loss"].append(round(train_loss, 6))
+            history["train_acc"].append(round(train_acc, 6))
+
+            val_loss, val_acc = (float("nan"), float("nan"))
+            if val_loader is not None:
+                val_metrics = self.evaluate(val_loader)
+                val_loss = val_metrics["loss"]
+                val_acc = val_metrics["accuracy"]
+                if val_acc > best_val_acc:
+                    best_val_acc = val_acc
+                    best_epoch = epoch
+            history["val_loss"].append(round(val_loss, 6))
+            history["val_acc"].append(round(val_acc, 6))
+
+            print(
+                f"Epoch [{epoch:>3}/{epochs}] "
+                f"train_loss={train_loss:.4f} train_acc={train_acc:.4f} "
+                f"val_loss={val_loss:.4f} val_acc={val_acc:.4f}"
+            )
+
+        history["best_epoch"] = best_epoch
+        history["best_val_acc"] = round(best_val_acc, 6) if best_epoch > 0 else None
+        self.history = history
+        return history
+
+    # ---------------- avaliação ----------------
+    def evaluate(self, data_loader: DataLoader) -> Dict[str, float]:
+        self.model.eval()
+        loss_sum = 0.0
+        correct = 0
+        total = 0
+        with torch.no_grad():
+            for X, y in data_loader:
+                X = X.to(self.device)
+                y = y.to(self.device)
+                logits = self.model(X)
+                loss = self.criterion(logits, y)
+                loss_sum += float(loss.item()) * X.size(0)
+                preds = logits.argmax(dim=1)
+                correct += int((preds == y).sum().item())
+                total += int(y.size(0))
+        return {
+            "loss": loss_sum / max(total, 1),
+            "accuracy": correct / max(total, 1),
+            "n": total,
+        }
+
+    # ---------------- inferência ----------------
+    def predict(self, inputs: Any) -> np.ndarray:
+        self.model.eval()
+        with torch.no_grad():
+            if isinstance(inputs, DataLoader):
+                outs: List[np.ndarray] = []
+                for batch in inputs:
+                    X = batch[0] if isinstance(batch, (tuple, list)) else batch
+                    X = X.to(self.device)
+                    outs.append(self.model(X).argmax(dim=1).cpu().numpy())
+                return np.concatenate(outs, axis=0)
+            if isinstance(inputs, np.ndarray):
+                X = torch.from_numpy(inputs.astype(np.float32)).to(self.device)
+            elif isinstance(inputs, torch.Tensor):
+                X = inputs.to(self.device)
+            else:
+                X = torch.tensor(inputs, dtype=torch.float32).to(self.device)
+            if X.ndim == 1:
+                X = X.unsqueeze(0)
+            return self.model(X).argmax(dim=1).cpu().numpy()
+
+    # ---------------- persistência ----------------
+    def save_model(self, filename: str) -> str:
+        path = os.path.join(self.model_dir, filename)
+        torch.save(
+            {
+                "state_dict": self.model.state_dict(),
+                "input_size": self.input_size,
+                "num_classes": self.num_classes,
+                "hidden_dims": self._hidden_dims,
+                "dropout": self._dropout,
+                "project_name": self.project_name,
+            },
+            path,
+        )
+        print(f"✓ Model saved to {path}")
+        return path
+
+    def load_model(self, filename: str) -> None:
+        path = filename if os.path.isabs(filename) else os.path.join(
+            self.model_dir, filename
+        )
+        ckpt = torch.load(path, map_location=self.device)
+        self._hidden_dims = ckpt.get("hidden_dims", self._hidden_dims)
+        self._dropout = ckpt.get("dropout", self._dropout)
+        self.model = _MLP(
+            input_size=ckpt["input_size"],
+            hidden_dims=self._hidden_dims,
+            num_classes=ckpt["num_classes"],
+            dropout=self._dropout,
+        ).to(self.device)
+        self.model.load_state_dict(ckpt["state_dict"])
+
+    # ---------------- helpers ----------------
+    def _build_optimizer(
+        self, name: str, lr: float, weight_decay: float
+    ) -> optim.Optimizer:
+        params = self.model.parameters()
+        if name == "sgd":
+            return optim.SGD(params, lr=lr, momentum=0.9, weight_decay=weight_decay)
+        if name == "rmsprop":
+            return optim.RMSprop(params, lr=lr, weight_decay=weight_decay)
+        # default: adam
+        return optim.Adam(params, lr=lr, weight_decay=weight_decay)
+
+
+# ---------------------------------------------------------------------------
+# Fábrica usada pelo main.py
+# ---------------------------------------------------------------------------
+def create_model(
+    input_size: int,
+    num_classes: int,
+    project_name: str,
+    base_path: str,
+    config: Optional[Dict[str, Any]] = None,
+) -> TabularMLP:
+    """Cria um ``TabularMLP`` pronto pra uso pelo main.py."""
+    return TabularMLP(
+        input_size=input_size,
+        num_classes=num_classes,
+        project_name=project_name,
+        base_path=base_path,
+        framework="pytorch",
+        config=config or {},
+    )

model/mpl_pequeno_torch/python_version.txt

@@ -0,0 +1 @@
+3.10

model/mpl_pequeno_torch/requirements.txt

@@ -0,0 +1,8 @@
+--extra-index-url https://download.pytorch.org/whl/cpu
+
+pandas
+scikit-learn
+joblib
+torch
+openpyxl
+numpy

projects/project.json

@@ -0,0 +1,9 @@
+{
+    "name": "TestMultipleRepos2",
+    "description": "Test RepoB",
+    "models": [
+        "mpl_pequeno_torch"
+    ],
+    "created_at": "2026-06-16T21:13:29.475614",
+    "project_id": "6993006e-b380-4834-b536-77105fc3e1a7"
+}