tracebloc 1.2.87__tar.gz → 1.2.89__tar.gz

{tracebloc-1.2.87 → tracebloc-1.2.89}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tracebloc
-Version: 1.2.87
+Version: 1.2.89
 Summary: Build AI with anyone. On data that can't move. SDK for the tracebloc collaborative AI workspace.
 Author-email: tracebloc <lukas@tracebloc.io>
 License-Expression: MIT

{tracebloc-1.2.87 → tracebloc-1.2.89}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tracebloc"
-version = "1.2.87"
+version = "1.2.89"
 description = "Build AI with anyone. On data that can't move. SDK for the tracebloc collaborative AI workspace."
 license = "MIT"
 license-files = ["license.txt"]

{tracebloc-1.2.87 → tracebloc-1.2.89}/tracebloc/_link_regeneration.py

@@ -35,7 +35,7 @@ from tracebloc.convert.heads import NAMED_AT_LINK
 from tracebloc.convert.package import SEED_EXCLUDED_PREFIXES, write_package
 from tracebloc.convert.report import report_document, write_report
 from tracebloc.utils.constants import TaskCategory
-from tracebloc.validation.header_rules import NO_OUTPUT_CLASSES
+from tracebloc.validation.header_rules import NO_OUTPUT_CLASSES, SINGLE_OUTPUT
 
 #: The package values naming, once a head is aligned, the order its rows follow
 #: and the prefixes it was declared under before it stopped starting fresh.
@@ -57,7 +57,10 @@ def _positive_int(value: Any) -> int | None:
 
 
 def _class_count(category: str, content: Mapping[str, Any]) -> int | None:
-    """The head width the dataset needs: distinct BIO tags for token classification."""
+    """The head width the dataset needs: one for a single-output task, distinct
+    BIO tags for token classification."""
+    if category in SINGLE_OUTPUT:
+        return 1
     if category == TaskCategory.TOKEN_CLASSIFICATION:
         names = content.get("class_names") or ()
         tags = {tag for sequence in names for tag in str(sequence).split()}

{tracebloc-1.2.87 → tracebloc-1.2.89}/tracebloc/_linking.py

@@ -44,7 +44,7 @@ from .validation.scikit_survival_checks import (
 from .validation.lifelines_checks import (
     non_averageable_lifelines_estimator_reason,
 )
-from .validation.header_rules import NO_OUTPUT_CLASSES
+from .validation.header_rules import NO_OUTPUT_CLASSES, SINGLE_OUTPUT
 from tracebloc.utils.constants import (
     SKLEARN_FRAMEWORK,
     SCIKIT_SURVIVAL_FRAMEWORK,
@@ -446,6 +446,19 @@ def _apply_link_success(
                 f"model file."
             )
 
+    # Hard-fail: a one-output head (text regression) has no class names to count.
+    if category in SINGLE_OUTPUT:
+        try:
+            declared_outputs = int(classes)
+        except (TypeError, ValueError):
+            declared_outputs = None
+        if declared_outputs is not None and declared_outputs != 1:
+            raise DatasetLinkingError(
+                f"Model declares output_classes={declared_outputs} but a "
+                f"text regression model predicts one number per text. Set "
+                f"output_classes = 1 and give the model a 1-wide head."
+            )
+
     # OPTIONAL soft check: warn (do NOT block) if the model likely
     # won't fit the compute the backend assigned to this dataset.
     # No-op until the backend returns a "resources" object in the

{tracebloc-1.2.87 → tracebloc-1.2.89}/tracebloc/convert/families/hf/__init__.py

@@ -83,6 +83,10 @@ TASK_CLASSES: dict[TaskCategory, tuple[str, str]] = {
         "AutoModelForSequenceClassification",
         "MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING_NAMES",
     ),
+    TaskCategory.TEXT_REGRESSION: (
+        "AutoModelForSequenceClassification",
+        "MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING_NAMES",
+    ),
     TaskCategory.TOKEN_CLASSIFICATION: (
         "AutoModelForTokenClassification",
         "MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING_NAMES",

{tracebloc-1.2.87 → tracebloc-1.2.89}/tracebloc/convert/heads.py

@@ -15,6 +15,7 @@ from tracebloc.utils.constants import TaskCategory
 #: from the checkpoint.
 PROBLEM_TYPES: Mapping[TaskCategory, str] = {
     TaskCategory.MULTI_LABEL_TEXT_CLASSIFICATION: "multi_label_classification",
+    TaskCategory.TEXT_REGRESSION: "regression",
 }
 #: Tasks whose Hugging Face head is named for the use case's classes once the
 #: link gives them; until then transformers' ``LABEL_<n>``.

{tracebloc-1.2.87 → tracebloc-1.2.89}/tracebloc/convert/interfaces.py

@@ -24,6 +24,7 @@ from typing import Any, Callable, Mapping, Protocol
 
 from tracebloc.exceptions import ModelValidationError, TraceblocError
 from tracebloc.utils.constants import Framework, TaskCategory, _StringEnum
+from tracebloc.validation.header_rules import SINGLE_OUTPUT
 
 #: The package whose modules are the shipped families.
 FAMILIES_PACKAGE = "tracebloc.convert.families"
@@ -135,6 +136,7 @@ class UseCaseTask:
     where ``category`` is the checkpoint's declared head and the package is
     regenerated at link. ``counts`` are keyed by :data:`COUNT_NAMES`;
     ``class_names`` are the dataset's, which the head's rows are aligned to.
+    A :data:`SINGLE_OUTPUT` task's ``output_classes`` is 1, whatever is counted.
     """
 
     category: TaskCategory
@@ -149,6 +151,8 @@ class UseCaseTask:
         for name, count in self.counts.items():
             if isinstance(count, bool) or not isinstance(count, int) or count < 1:
                 raise ValueError(f"count {name} must be a positive int, got {count!r}")
+        if self.category in SINGLE_OUTPUT:
+            object.__setattr__(self, "counts", {**self.counts, "output_classes": 1})
         object.__setattr__(self, "counts", _frozen(self.counts))
         object.__setattr__(self, "class_names", tuple(self.class_names))
 

{tracebloc-1.2.87 → tracebloc-1.2.89}/tracebloc/convert/owncode/head.py

@@ -20,12 +20,14 @@ from tracebloc.convert.interfaces import (
 )
 from tracebloc.utils.constants import TaskCategory
 
-#: Tasks whose class head is one linear layer with a row per class.
+#: Tasks whose head is one linear layer with a row per class (one row: a
+#: regression's predicted number).
 CLASSIFICATION_HEADS = (
     TaskCategory.IMAGE_CLASSIFICATION,
     TaskCategory.TEXT_CLASSIFICATION,
     TaskCategory.SENTENCE_PAIR_CLASSIFICATION,
     TaskCategory.MULTI_LABEL_TEXT_CLASSIFICATION,
+    TaskCategory.TEXT_REGRESSION,
     TaskCategory.TOKEN_CLASSIFICATION,
     TaskCategory.TABULAR_CLASSIFICATION,
     TaskCategory.TIME_SERIES_CLASSIFICATION,

{tracebloc-1.2.87 → tracebloc-1.2.89}/tracebloc/convert/owncode/remote.py

@@ -44,6 +44,7 @@ AUTO_CLASS = {
     TaskCategory.TEXT_CLASSIFICATION: "AutoModelForSequenceClassification",
     TaskCategory.SENTENCE_PAIR_CLASSIFICATION: "AutoModelForSequenceClassification",
     TaskCategory.MULTI_LABEL_TEXT_CLASSIFICATION: "AutoModelForSequenceClassification",
+    TaskCategory.TEXT_REGRESSION: "AutoModelForSequenceClassification",
     TaskCategory.TOKEN_CLASSIFICATION: "AutoModelForTokenClassification",
     TaskCategory.MASKED_LANGUAGE_MODELING: "AutoModelForMaskedLM",
     TaskCategory.CAUSAL_LANGUAGE_MODELING: "AutoModelForCausalLM",

tracebloc-1.2.89/tracebloc/datasets/__init__.py

@@ -0,0 +1,6 @@
+"""Synthetic datasets used by the SDK's upload-time functional checks.
+
+RFC-0348 A.2 moved these classes here from ``tracebloc/utils/*_utils.py``;
+the old import paths keep working through re-exports. Submodules import
+torch, so this package stays import-light and does not import them eagerly.
+"""

tracebloc-1.2.89/tracebloc/datasets/base.py

@@ -0,0 +1,55 @@
+"""Shared bases for the synthetic datasets (RFC-0348 A.2)."""
+
+import torch
+from torch.utils.data import Dataset
+
+
+class SyntheticDataset(Dataset):
+    """Dataset whose length comes from one attribute.
+
+    ``_size_attr`` names the attribute. When ``_size_is_count`` is true the
+    attribute already holds the count (e.g. ``num_samples``); otherwise the
+    length of the attribute is used, indexing ``_size_key`` first when set
+    (e.g. ``encodings["input_ids"]``).
+    """
+
+    _size_attr = "num_samples"
+    _size_is_count = True
+    _size_key = None
+
+    def __len__(self):
+        size = getattr(self, self._size_attr)
+        if self._size_is_count:
+            return size
+        if self._size_key is not None:
+            size = size[self._size_key]
+        return len(size)
+
+
+class EncodedDataset(SyntheticDataset):
+    """Dataset over tokenizer ``encodings``; length is the number of input_ids rows."""
+
+    _size_attr = "encodings"
+    _size_is_count = False
+    _size_key = "input_ids"
+
+
+class UnshiftedLabelsDataset(EncodedDataset):
+    """Encoded dataset whose labels are the unshifted input_ids, padding -> -100."""
+
+    def __init__(self, encodings, pad_token_id):
+        self.encodings = encodings
+        self.pad_token_id = pad_token_id
+
+    def __getitem__(self, idx):
+        input_ids = list(self.encodings["input_ids"][idx])
+        attention_mask = list(self.encodings["attention_mask"][idx])
+        labels = [
+            -100 if token_id == self.pad_token_id else token_id
+            for token_id in input_ids
+        ]
+        return {
+            "input_ids": torch.tensor(input_ids, dtype=torch.long),
+            "attention_mask": torch.tensor(attention_mask, dtype=torch.long),
+            "labels": torch.tensor(labels, dtype=torch.long),
+        }

tracebloc-1.2.89/tracebloc/datasets/detection.py

@@ -0,0 +1,51 @@
+"""Synthetic object-detection data for the upload check (RFC-0348 A.2)."""
+
+import random
+
+import torch
+
+from tracebloc.datasets.base import SyntheticDataset
+from tracebloc.utils.declared_classes import declared_classes
+
+
+class FakeObjectDetectionDataset(SyntheticDataset):
+    def __init__(
+        self, num_samples, num_classes=None, data_shape=(256, 256), num_channels=3
+    ):
+        self.num_samples = num_samples
+        self.num_classes = num_classes if num_classes else random.randint(1, 10)
+        self.classes = [self._generate_class_name() for _ in range(self.num_classes)]
+        self.data_shape = data_shape
+        self.num_channels = num_channels
+        self.data = self._generate_fake_data()
+
+    def _generate_class_name(self):
+        # Generate a random class name
+        return "".join(random.choice("ABCDEFGHIJKLMNOPQRSTUVWXYZ") for _ in range(5))
+
+    def _generate_fake_data(self):
+        data = []
+        for _ in range(self.num_samples):
+            # Match the model's native input-channel count (1 for grayscale,
+            # 3 for RGB) so grayscale detectors aren't false-rejected by
+            # hardcoded 3-channel dummy data.
+            image = torch.rand((self.num_channels, *self.data_shape))  # Fake image
+            num_objects = random.randint(1, 5)
+            labels = [
+                random.randint(0, self.num_classes - 1) for _ in range(num_objects)
+            ]
+            boxes = [
+                (random.random(), random.random(), random.random(), random.random())
+                for _ in range(num_objects)
+            ]
+            target = {"boxes": boxes, "labels": labels}
+            data.append((image, target))
+        return data
+
+    def __getitem__(self, idx):
+        return self.data[idx]
+
+    def __iter__(self):
+        return iter(self.data)
+
+    get_classes = declared_classes

tracebloc-1.2.87/tracebloc/utils/key_point_detection_utils.py → tracebloc-1.2.89/tracebloc/datasets/keypoint_detection.py

@@ -1,10 +1,15 @@
+"""Synthetic keypoint-detection data for the upload check (RFC-0348 A.2)."""
+
+import numpy as np
 import torch
-from torch.utils.data import Dataset
 from PIL import Image
-import numpy as np
+
+from tracebloc.datasets.base import SyntheticDataset
 
 
-class FakeKeypointDetectionDataset(Dataset):
+class FakeKeypointDetectionDataset(SyntheticDataset):
+    _size_attr = "num_images"
+
     def __init__(
         self,
         num_images,
@@ -21,9 +26,6 @@ class FakeKeypointDetectionDataset(Dataset):
         self.transform = transform
         self.num_channels = num_channels
 
-    def __len__(self):
-        return self.num_images
-
     def __getitem__(self, idx):
         # Create a blank image with the model's native channel count
         # ("L" => 1-channel grayscale, "RGB" => 3-channel). ToTensor in
@@ -79,8 +81,6 @@ class FakeKeypointDetectionDataset(Dataset):
                 xx, yy = np.meshgrid(
                     np.arange(self.data_shape[1]), np.arange(self.data_shape[0])
                 )
-                heatmaps[i] = np.exp(
-                    -((xx - x) ** 2 + (yy - y) ** 2) / (2 * sigma**2)
-                )
+                heatmaps[i] = np.exp(-((xx - x) ** 2 + (yy - y) ** 2) / (2 * sigma**2))
 
         return torch.tensor(heatmaps, dtype=torch.float32)

tracebloc-1.2.87/tracebloc/utils/semantic_segmentation_utils.py → tracebloc-1.2.89/tracebloc/datasets/semantic_segmentation.py

@@ -1,15 +1,19 @@
-import torch
-import torchvision.transforms as transforms
-from torch.utils.data import Dataset
+"""Synthetic semantic-segmentation data for the upload check (RFC-0348 A.2)."""
+
 import numpy as np
+import torch
+
+from tracebloc.datasets.base import SyntheticDataset
 
 
-class FakeSemanticSegmentationDataset(Dataset):
+class FakeSemanticSegmentationDataset(SyntheticDataset):
     """
     A fake dataset for semantic segmentation testing.
     Creates random images and corresponding segmentation masks.
     """
 
+    _size_attr = "num_images"
+
     def __init__(
         self, data_shape, num_images=10, num_classes=2, transform=None, num_channels=3
     ):
@@ -28,13 +32,13 @@ class FakeSemanticSegmentationDataset(Dataset):
             # (1 for grayscale models, 3 for RGB). Channels-last HWC here;
             # __getitem__ / ToTensor moves it to CHW.
             if isinstance(data_shape, int):
-                img = np.random.rand(
-                    data_shape, data_shape, num_channels
-                ).astype(np.float32)
+                img = np.random.rand(data_shape, data_shape, num_channels).astype(
+                    np.float32
+                )
             else:
-                img = np.random.rand(
-                    data_shape[0], data_shape[1], num_channels
-                ).astype(np.float32)
+                img = np.random.rand(data_shape[0], data_shape[1], num_channels).astype(
+                    np.float32
+                )
 
             # Create random segmentation mask
             if isinstance(data_shape, int):
@@ -49,9 +53,6 @@ class FakeSemanticSegmentationDataset(Dataset):
             self.images.append(img)
             self.masks.append(mask)
 
-    def __len__(self):
-        return self.num_images
-
     def __getitem__(self, idx):
         image = self.images[idx]
         mask = self.masks[idx]

tracebloc-1.2.89/tracebloc/datasets/tabular.py

@@ -0,0 +1,34 @@
+"""Tabular datasets for the upload check (RFC-0348 A.2)."""
+
+import numpy as np
+import torch
+
+from tracebloc.datasets.base import SyntheticDataset
+
+
+# Custom dataset for regression
+class TabularRegressionDataset(SyntheticDataset):
+    _size_attr = "targets"
+    _size_is_count = False
+
+    def __init__(self, features, targets):
+        self.features = features.astype(np.float32)
+        self.targets = targets.astype(np.float32)  # Continuous values, not classes
+
+    def __getitem__(self, idx):
+        return torch.tensor(self.features[idx]), torch.tensor(self.targets[idx])
+
+
+class TabularClassificationDataset(SyntheticDataset):
+    """Tabular classification rows; was the nested ``TabularDataset`` in
+    ``tabular_classification_utils.get_dataloader``."""
+
+    _size_attr = "labels"
+    _size_is_count = False
+
+    def __init__(self, features, labels):
+        self.features = features.astype(np.float32)
+        self.labels = labels.astype(np.float32)
+
+    def __getitem__(self, idx):
+        return torch.tensor(self.features[idx]), torch.tensor(self.labels[idx])

tracebloc-1.2.89/tracebloc/datasets/text.py

@@ -0,0 +1,189 @@
+"""Synthetic NLP datasets for the upload check (RFC-0348 A.2).
+
+The builders that tokenize text and return these stay in
+tracebloc.utils.text_classification_utils.
+"""
+
+import torch
+
+from tracebloc.datasets.base import (
+    EncodedDataset,
+    SyntheticDataset,
+    UnshiftedLabelsDataset,
+)
+
+
+# Dataset
+class TextDataset(SyntheticDataset):
+    _size_attr = "labels"
+    _size_is_count = False
+
+    def __init__(self, encodings, labels):
+        self.encodings = encodings
+        self.labels = labels
+
+    def __getitem__(self, idx):
+        item = {key: torch.tensor(val[idx]) for key, val in self.encodings.items()}
+        item["labels"] = torch.tensor(self.labels[idx])
+        return item
+
+
+class MaskedLanguageModelingDataset(EncodedDataset):
+    """Synthetic MLM dataset: applies 80/10/10 masking on-the-fly.
+
+    Used only for the SDK-side functional check (small training loop) so
+    the upload pipeline can validate that the user's model accepts MLM
+    inputs and produces a per-token logits tensor.
+    """
+
+    def __init__(
+        self,
+        encodings,
+        mask_token_id,
+        pad_token_id,
+        vocab_size,
+        mask_prob=0.15,
+        seed=42,
+    ):
+        import numpy as np
+
+        self.encodings = encodings
+        self.mask_token_id = mask_token_id
+        self.pad_token_id = pad_token_id
+        self.vocab_size = vocab_size
+        self.mask_prob = mask_prob
+        self._rng = np.random.default_rng(seed)
+
+    def __getitem__(self, idx):
+        input_ids = list(self.encodings["input_ids"][idx])
+        attention_mask = list(self.encodings["attention_mask"][idx])
+        labels = [-100] * len(input_ids)
+
+        for i, token_id in enumerate(input_ids):
+            # Don't mask padding tokens.
+            if token_id == self.pad_token_id:
+                continue
+            if self._rng.random() < self.mask_prob:
+                labels[i] = token_id
+                rand = self._rng.random()
+                if rand < 0.8:
+                    input_ids[i] = self.mask_token_id
+                elif rand < 0.9:
+                    input_ids[i] = int(self._rng.integers(0, self.vocab_size))
+                # else: keep original — model still predicts it.
+
+        return {
+            "input_ids": torch.tensor(input_ids, dtype=torch.long),
+            "attention_mask": torch.tensor(attention_mask, dtype=torch.long),
+            "labels": torch.tensor(labels, dtype=torch.long),
+        }
+
+
+class TokenClassificationDummyDataset(EncodedDataset):
+    """Synthetic token-classification dataset: random per-token tag ids.
+
+    Used only for the SDK-side functional check (small training loop) so
+    the upload pipeline can validate that the user's model accepts token
+    inputs and produces ``(batch, seq_len, num_classes)`` logits.
+    """
+
+    def __init__(self, encodings, num_classes, pad_token_id, seed=42):
+        import numpy as np
+
+        self.encodings = encodings
+        self.num_classes = num_classes
+        self.pad_token_id = pad_token_id
+        self._rng = np.random.default_rng(seed)
+
+    def __getitem__(self, idx):
+        # Return EVERY tokenizer output key (e.g. token_type_ids for
+        # BERT-family tokenizers), not just input_ids/attention_mask: the
+        # client's dataset does the same and its HF path forwards
+        # ``model(**batch)``, so the upload-time validation batch must
+        # carry the same keys the model will see at training time.
+        item = {
+            key: torch.tensor(values[idx], dtype=torch.long)
+            for key, values in self.encodings.items()
+        }
+        input_ids = list(self.encodings["input_ids"][idx])
+        labels = [
+            (
+                -100
+                if token_id == self.pad_token_id
+                else int(self._rng.integers(0, self.num_classes))
+            )
+            for token_id in input_ids
+        ]
+        item["labels"] = torch.tensor(labels, dtype=torch.long)
+        return item
+
+
+class CausalLanguageModelingDataset(UnshiftedLabelsDataset):
+    """Synthetic causal-LM dataset: labels are the (unshifted) input_ids.
+
+    Used only for the SDK-side functional check (small training loop) so the
+    upload pipeline can validate that the user's decoder-only model accepts
+    causal-LM inputs and produces ``(batch, seq_len, vocab_size)`` logits.
+
+    Following the Hugging Face convention (and the client's
+    ``CausalLanguageModelingDataset``), ``labels[i] == input_ids[i]`` on real
+    tokens — NOT pre-shifted. The one-position next-token shift is applied
+    exactly once downstream (HF models shift internally when given ``labels``;
+    the non-HF training branch shifts explicitly). Padding positions carry
+    ``-100`` so they are ignored by the loss.
+    """
+
+
+class EmbeddingsDummyDataset(SyntheticDataset):
+    """Synthetic contrastive-embeddings dataset: anchor / positive text pairs.
+
+    Used only for the SDK-side functional check (small training loop) so the
+    upload pipeline can validate that the user's text encoder accepts a
+    tokenized batch, exposes ``last_hidden_state``, mean-pools to one embedding
+    per example, and trains under the in-batch contrastive (InfoNCE) objective.
+
+    Each item carries the anchor / positive ``input_ids`` and ``attention_mask``
+    (the keys the backend ``EmbeddingsDataset`` produces). There are no labels —
+    embeddings is self-supervised; the target for anchor ``i`` is positive ``i``,
+    derived from the pairing at loss time.
+    """
+
+    _size_attr = "anchor_encodings"
+    _size_is_count = False
+    _size_key = "input_ids"
+
+    def __init__(self, anchor_encodings, positive_encodings):
+        self.anchor_encodings = anchor_encodings
+        self.positive_encodings = positive_encodings
+
+    def __getitem__(self, idx):
+        return {
+            "anchor_input_ids": torch.tensor(
+                self.anchor_encodings["input_ids"][idx], dtype=torch.long
+            ),
+            "anchor_attention_mask": torch.tensor(
+                self.anchor_encodings["attention_mask"][idx], dtype=torch.long
+            ),
+            "positive_input_ids": torch.tensor(
+                self.positive_encodings["input_ids"][idx], dtype=torch.long
+            ),
+            "positive_attention_mask": torch.tensor(
+                self.positive_encodings["attention_mask"][idx], dtype=torch.long
+            ),
+        }
+
+
+class Seq2SeqDummyDataset(UnshiftedLabelsDataset):
+    """Synthetic seq2seq dataset: labels are the (unshifted) input_ids.
+
+    Used only for the SDK-side functional check (small training loop) so the
+    upload pipeline can validate that the user's encoder-decoder model accepts
+    seq2seq inputs and produces ``(batch, target_seq_len, vocab_size)`` logits.
+
+    The target sequence equals the source (a copy/denoise smoke objective), so
+    ``labels[i] == input_ids[i]`` on real tokens — NOT pre-shifted. HF seq2seq
+    models build ``decoder_input_ids`` from ``labels`` internally; the non-HF
+    training branch teacher-forces on the source and compares logits to labels
+    directly (no external shift). Padding positions carry ``-100`` so they are
+    ignored by the loss.
+    """