teste1

README.md

@@ -0,0 +1,39 @@
+---
+license: mit
+tags:
+- qsar
+- cheminformatics
+- drug-discovery
+- machine-learning
+---
+
+# 🧬 About this Model
+
+This model was generated and shared through **QSAR IA**, an open-source platform designed to support QSAR studies, machine learning workflows, and scientific collaboration in cheminformatics and pharmaceutical research.
+
+## 👤 Researcher Information
+
+- **Researcher:** Ana Julia Velasque
+- **ORCID:** 0009-0006-4627-958X
+
+## 📖 Description
+
+This repository contains a predictive model developed using the QSAR IA platform.
+
+The model has been published to facilitate scientific reproducibility, collaboration, and reuse by the research community.
+
+## 📚 Citation
+
+If you use this model in your research, please cite the associated researcher and/or any related scientific publication.
+
+## 🔬 Scientific Reproducibility
+
+This repository is part of the QSAR IA ecosystem, which aims to promote transparent and reproducible computational research in drug discovery and cheminformatics.
+
+## 🚀 About QSAR IA
+
+QSAR IA is an open-source platform developed to support the complete lifecycle of QSAR and machine learning projects.
+
+Project repository:
+
+https://github.com/altobellibm/qsar_ia_project

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/dataset/dataset.json

@@ -0,0 +1,43 @@
+{
+    "location": "projects/02d37d373e/dataset/base.xlsx",
+    "type": "local_file",
+    "data_type": "default",
+    "size": 0,
+    "dataset_id": "b47c8290-51e4-49a3-86f5-a2d4aede765e",
+    "name": "",
+    "config": {
+        "config_id": "c30aceca-d507-477c-a03c-d41620af73cb",
+        "filename": "base.xlsx",
+        "file_type": "xlsx",
+        "total_records": 768,
+        "source": "teste",
+        "target_column": "Outcome",
+        "features": [
+            "Pregnancies",
+            "Glucose",
+            "BloodPressure",
+            "SkinThickness",
+            "Insulin",
+            "BMI",
+            "DiabetesPedigreeFunction",
+            "Age"
+        ],
+        "classes": [
+            1,
+            0
+        ],
+        "problem_type": "classification",
+        "columns": [
+            "Pregnancies",
+            "Glucose",
+            "BloodPressure",
+            "SkinThickness",
+            "Insulin",
+            "BMI",
+            "DiabetesPedigreeFunction",
+            "Age",
+            "Outcome"
+        ],
+        "is_saved": true
+    }
+}

projects/dataset/metadata.json

@@ -0,0 +1,35 @@
+{
+    "config_id": "c30aceca-d507-477c-a03c-d41620af73cb",
+    "filename": "base.xlsx",
+    "file_type": "xlsx",
+    "total_records": 768,
+    "source": "teste",
+    "target_column": "Outcome",
+    "features": [
+        "Pregnancies",
+        "Glucose",
+        "BloodPressure",
+        "SkinThickness",
+        "Insulin",
+        "BMI",
+        "DiabetesPedigreeFunction",
+        "Age"
+    ],
+    "classes": [
+        1,
+        0
+    ],
+    "problem_type": "classification",
+    "columns": [
+        "Pregnancies",
+        "Glucose",
+        "BloodPressure",
+        "SkinThickness",
+        "Insulin",
+        "BMI",
+        "DiabetesPedigreeFunction",
+        "Age",
+        "Outcome"
+    ],
+    "is_saved": true
+}

projects/project.json

@@ -0,0 +1,9 @@
+{
+    "name": "testando",
+    "description": "teste",
+    "models": [
+        "mpl_pequeno_torch"
+    ],
+    "created_at": "2026-10-28T21:41:45.427718",
+    "project_id": "02d37d37-3e4c-4407-90ff-e3a71bb7e33a"
+}

projects/trains/1/config.json

@@ -0,0 +1,19 @@
+{
+    "name": "teste2",
+    "created_at": "2026-10-28T21:42:30.149694",
+    "model": "mpl_pequeno_torch",
+    "split": {
+        "type": "holdout",
+        "ratio": "80/0/20",
+        "stratify": false,
+        "random_state": 42
+    },
+    "hyperparameters": {
+        "batch_size": 32,
+        "epochs": 10,
+        "learning_rate": 0.001,
+        "weight_decay": 0.0001,
+        "optimizer": "adam",
+        "dropout": 0.0
+    }
+}

projects/trains/1/history.json

@@ -0,0 +1,52 @@
+{
+  "train_loss": [
+    3.750382,
+    0.987682,
+    0.829776,
+    0.739012,
+    0.802033,
+    0.729789,
+    0.723826,
+    0.700537,
+    0.648181,
+    0.632008
+  ],
+  "train_acc": [
+    0.47557,
+    0.630293,
+    0.586319,
+    0.625407,
+    0.628664,
+    0.638436,
+    0.620521,
+    0.65798,
+    0.667752,
+    0.684039
+  ],
+  "val_loss": [
+    0.918344,
+    0.9168,
+    0.680144,
+    0.655112,
+    0.62473,
+    0.655485,
+    0.692047,
+    0.614565,
+    0.605267,
+    0.618784
+  ],
+  "val_acc": [
+    0.519481,
+    0.62987,
+    0.642857,
+    0.655844,
+    0.701299,
+    0.662338,
+    0.675325,
+    0.694805,
+    0.701299,
+    0.688312
+  ],
+  "best_epoch": 5,
+  "best_val_acc": 0.701299
+}

projects/trains/1/model.pt

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

projects/trains/1/predict/predict_config.json

@@ -0,0 +1,3 @@
+{
+  "input_file": "predict_dataset.xlsx"
+}

projects/trains/1/predict/predict_result.json

@@ -0,0 +1,492 @@
+[
+  {
+    "index": 0,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 1,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 2,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 3,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 4,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 5,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 6,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 7,
+    "pred_idx": 0,
+    "pred_label": "1"
+  },
+  {
+    "index": 8,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 9,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 10,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 11,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 12,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 13,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 14,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 15,
+    "pred_idx": 0,
+    "pred_label": "1"
+  },
+  {
+    "index": 16,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 17,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 18,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 19,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 20,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 21,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 22,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 23,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 24,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 25,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 26,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 27,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 28,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 29,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 30,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 31,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 32,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 33,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 34,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 35,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 36,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 37,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 38,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 39,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 40,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 41,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 42,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 43,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 44,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 45,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 46,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 47,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 48,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 49,
+    "pred_idx": 0,
+    "pred_label": "1"
+  },
+  {
+    "index": 50,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 51,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 52,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 53,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 54,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 55,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 56,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 57,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 58,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 59,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 60,
+    "pred_idx": 0,
+    "pred_label": "1"
+  },
+  {
+    "index": 61,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 62,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 63,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 64,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 65,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 66,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 67,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 68,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 69,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 70,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 71,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 72,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 73,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 74,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 75,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 76,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 77,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 78,
+    "pred_idx": 0,
+    "pred_label": "1"
+  },
+  {
+    "index": 79,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 80,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 81,
+    "pred_idx": 0,
+    "pred_label": "1"
+  },
+  {
+    "index": 82,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 83,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 84,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 85,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 86,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 87,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 88,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 89,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 90,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 91,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 92,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 93,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 94,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 95,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 96,
+    "pred_idx": 1,
+    "pred_label": "0"
+  },
+  {
+    "index": 97,
+    "pred_idx": 1,
+    "pred_label": "0"
+  }
+]

projects/trains/1/test/acuracia.json

@@ -0,0 +1,4 @@
+{
+  "accuracy": 0.688312,
+  "n": 154
+}

projects/trains/1/test/matriz_confusao.json

@@ -0,0 +1,17 @@
+{
+  "classes": [
+    "1",
+    "0"
+  ],
+  "matrix": [
+    [
+      9,
+      42
+    ],
+    [
+      6,
+      97
+    ]
+  ],
+  "description": "linha=real, coluna=predito"
+}

projects/trains/1/test/precisao.json

@@ -0,0 +1,23 @@
+{
+  "per_class": [
+    {
+      "class": "1",
+      "precision": 0.6,
+      "recall": 0.176471,
+      "f1_score": 0.272727,
+      "support": 51
+    },
+    {
+      "class": "0",
+      "precision": 0.697842,
+      "recall": 0.941748,
+      "f1_score": 0.801653,
+      "support": 103
+    }
+  ],
+  "macro_avg": {
+    "precision": 0.648921,
+    "recall": 0.559109,
+    "f1_score": 0.53719
+  }
+}

projects/trains/1/train_result.json

@@ -0,0 +1,11 @@
+{
+  "status": "concluido",
+  "epochs_run": 10,
+  "best_epoch": 5,
+  "train_loss": 0.632008,
+  "val_loss": 0.618784,
+  "val_accuracy": 0.701299,
+  "started_at": "2026-10-29T00:42:36Z",
+  "finished_at": "2026-10-29T00:42:37Z",
+  "duration_seconds": 1
+}