silver-torch 0.1.0__tar.gz

silver_torch-0.1.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: silver-torch
+Version: 0.1.0
+Summary: Inspectable Silver dataset preprocessing and PyTorch input pipelines.
+License-Expression: Apache-2.0
+Keywords: pytorch,preprocessing,datasets,machine-learning,research
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: pytorch
+Requires-Dist: torch>=1.9.0; extra == "pytorch"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+
+# silver-torch
+
+An optional PyTorch layer for Silver. It turns a small Silver preprocessing
+program into a fitted, inspectable, reusable tensor and `DataLoader` pipeline.
+
+```bash
+pip install silver-data
+pip install 'silver-torch[pytorch]'
+```
+
+```python
+from silver_data import Dataset
+from silver_torch import compile_silver
+
+program = """
+pipeline ieee_inverse:
+  features voltage, current, phase, sensor
+  categorical sensor
+  label fault
+  architecture transformer
+  sequence_length 2
+  scaling standard
+  missing median
+  label_type classification
+  batch_size 128
+  num_workers 2
+  cache_dir .cache/ieee_inverse
+"""
+
+dataset = Dataset.from_records("ieee", [
+    {"voltage": 1.0, "current": 2.0, "phase": 0.2, "fault": 0},
+    {"voltage": 1.2, "current": 2.1, "phase": 0.3, "fault": 1},
+])
+splits = dataset.split(0.8, 0.1, 0.1)
+pipeline = compile_silver(program).fit(splits.train.records())
+loader = pipeline.dataloader(splits.validation.records(), device="cuda")
+print(pipeline.plan(device="cuda").to_dict())
+print(pipeline.benchmark(splits.validation.records(), steps=20))
+```
+
+The compiler has explicit research-safety boundaries:
+
+- statistics and vocabularies are fitted only on `splits.train`;
+- missing columns, non-finite numbers, invalid labels, and incompatible
+  sequence lengths fail loudly;
+- categorical vocabularies are sorted for reproducibility and reserve index 0
+  for unknown values;
+- classification targets are `torch.long`; regression targets use the chosen
+  floating dtype;
+- cache keys include the fitted-training fingerprint and transformed rows, and
+  cache writes are atomic;
+- loaders are seeded and tune pinning, persistent workers, prefetching, and
+  `drop_last` based on the declared runtime.
+
+The emitted shapes are `[batch, features]` for MLP, `[batch, 1, features]` for
+CNN, and `[batch, sequence_length, features_per_step]` for RNN/Transformer.
+These are layout contracts, not model implementations. Measure with
+`benchmark()` on the target machine; input speedups depend on storage, CPU,
+worker count, batch size, and accelerator.

silver_torch-0.1.0/README.md

@@ -0,0 +1,59 @@
+# silver-torch
+
+An optional PyTorch layer for Silver. It turns a small Silver preprocessing
+program into a fitted, inspectable, reusable tensor and `DataLoader` pipeline.
+
+```bash
+pip install silver-data
+pip install 'silver-torch[pytorch]'
+```
+
+```python
+from silver_data import Dataset
+from silver_torch import compile_silver
+
+program = """
+pipeline ieee_inverse:
+  features voltage, current, phase, sensor
+  categorical sensor
+  label fault
+  architecture transformer
+  sequence_length 2
+  scaling standard
+  missing median
+  label_type classification
+  batch_size 128
+  num_workers 2
+  cache_dir .cache/ieee_inverse
+"""
+
+dataset = Dataset.from_records("ieee", [
+    {"voltage": 1.0, "current": 2.0, "phase": 0.2, "fault": 0},
+    {"voltage": 1.2, "current": 2.1, "phase": 0.3, "fault": 1},
+])
+splits = dataset.split(0.8, 0.1, 0.1)
+pipeline = compile_silver(program).fit(splits.train.records())
+loader = pipeline.dataloader(splits.validation.records(), device="cuda")
+print(pipeline.plan(device="cuda").to_dict())
+print(pipeline.benchmark(splits.validation.records(), steps=20))
+```
+
+The compiler has explicit research-safety boundaries:
+
+- statistics and vocabularies are fitted only on `splits.train`;
+- missing columns, non-finite numbers, invalid labels, and incompatible
+  sequence lengths fail loudly;
+- categorical vocabularies are sorted for reproducibility and reserve index 0
+  for unknown values;
+- classification targets are `torch.long`; regression targets use the chosen
+  floating dtype;
+- cache keys include the fitted-training fingerprint and transformed rows, and
+  cache writes are atomic;
+- loaders are seeded and tune pinning, persistent workers, prefetching, and
+  `drop_last` based on the declared runtime.
+
+The emitted shapes are `[batch, features]` for MLP, `[batch, 1, features]` for
+CNN, and `[batch, sequence_length, features_per_step]` for RNN/Transformer.
+These are layout contracts, not model implementations. Measure with
+`benchmark()` on the target machine; input speedups depend on storage, CPU,
+worker count, batch size, and accelerator.

silver_torch-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "silver-torch"
+version = "0.1.0"
+description = "Inspectable Silver dataset preprocessing and PyTorch input pipelines."
+readme = "README.md"
+requires-python = ">=3.8"
+license = "Apache-2.0"
+keywords = ["pytorch", "preprocessing", "datasets", "machine-learning", "research"]
+dependencies = []
+
+[project.optional-dependencies]
+pytorch = ["torch>=1.9.0"]
+dev = ["pytest>=7.0.0"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-dir]
+"" = "src"

silver_torch-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

silver_torch-0.1.0/src/silver_torch/__init__.py

@@ -0,0 +1,6 @@
+"""Silver's optional, inspectable PyTorch preprocessing layer."""
+
+from .pipeline import SilverTorchPipeline, compile_silver, parse_silver
+from .spec import SilverPreprocessSpec
+
+__all__ = ["SilverPreprocessSpec", "SilverTorchPipeline", "compile_silver", "parse_silver"]

silver_torch-0.1.0/src/silver_torch/pipeline.py

@@ -0,0 +1,302 @@
+"""Compile Silver preprocessing intent into a leakage-safe PyTorch pipeline."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import os
+import re
+import tempfile
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Mapping, Optional, Sequence, Tuple
+
+from .spec import SilverPreprocessSpec
+
+
+def parse_silver(source: str) -> SilverPreprocessSpec:
+    """Parse the data-pipeline subset of Silver with strict field handling."""
+    values: Dict[str, Any] = {}
+    supported = {"features", "categorical", "label", "architecture", "scaling", "missing",
+                 "label_type", "dtype", "batch_size", "shuffle", "num_workers",
+                 "prefetch_factor", "drop_last", "sequence_length", "seed", "cache_dir"}
+    for raw in source.splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#"):
+            continue
+        if line.startswith("pipeline "):
+            match = re.fullmatch(r"pipeline\s+([A-Za-z_]\w*)\s*:", line)
+            if not match:
+                raise ValueError("pipeline declaration must look like 'pipeline name:'")
+            values["name"] = match.group(1)
+            continue
+        parts = line.split(None, 1)
+        if len(parts) != 2:
+            raise ValueError("Silver pipeline fields must look like 'field value'")
+        key, raw_value = parts
+        if key not in supported:
+            raise ValueError("unsupported Silver preprocessing field: %s" % key)
+        raw_value = raw_value.strip().strip('"')
+        if key in ("features", "categorical"):
+            values[key] = tuple(x.strip() for x in raw_value.split(",") if x.strip())
+        elif raw_value.lower() in ("true", "false"):
+            values[key] = raw_value.lower() == "true"
+        elif re.fullmatch(r"\d+", raw_value):
+            values[key] = int(raw_value)
+        else:
+            values[key] = raw_value
+    values.setdefault("name", "silver_pipeline")
+    if "features" not in values or "label" not in values:
+        raise ValueError("Silver pipeline requires 'features' and 'label'")
+    return SilverPreprocessSpec(**values)
+
+
+@dataclass(frozen=True)
+class ColumnState:
+    kind: str
+    location: float = 0.0
+    scale: float = 1.0
+    categories: Tuple[str, ...] = ()
+
+
+@dataclass(frozen=True)
+class CompiledPlan:
+    spec: SilverPreprocessSpec
+    feature_count: int
+    input_shape: Tuple[int, ...]
+    loader_options: Dict[str, Any]
+    fitted_rows: int
+    fingerprint: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"schema": "silver.torch/plan-2", "name": self.spec.name,
+                "architecture": self.spec.architecture, "feature_count": self.feature_count,
+                "input_shape": list(self.input_shape), "label_type": self.spec.label_type,
+                "loader_options": dict(self.loader_options), "fitted_rows": self.fitted_rows,
+                "fingerprint": self.fingerprint}
+
+
+class SilverTorchPipeline:
+    """Fit transforms on training rows, then reuse them without data leakage."""
+
+    def __init__(self, spec: SilverPreprocessSpec):
+        self.spec = spec
+        self._states: Dict[str, ColumnState] = {}
+        self._label_mapping: Dict[str, int] = {}
+        self._fitted_rows = 0
+        self._fingerprint = ""
+
+    @property
+    def fitted(self) -> bool:
+        return bool(self._states)
+
+    @property
+    def statistics(self) -> Dict[str, Dict[str, Any]]:
+        """Return fitted state without exposing mutable internal objects."""
+        self._require_fit()
+        return {name: {"kind": state.kind, "location": state.location,
+                       "scale": state.scale, "categories": list(state.categories)}
+                for name, state in self._states.items()}
+
+    def fit(self, rows: Iterable[Mapping[str, Any]]) -> "SilverTorchPipeline":
+        materialized = list(rows)
+        if not materialized:
+            raise ValueError("cannot fit an empty dataset")
+        missing_columns = [c for c in self.spec.features + (self.spec.label,)
+                           if c not in materialized[0]]
+        if missing_columns:
+            raise ValueError("missing dataset columns: %s" % ", ".join(missing_columns))
+        states: Dict[str, ColumnState] = {}
+        for column in self.spec.features:
+            if column in self.spec.categorical:
+                categories = sorted({self._as_category(row.get(column)) for row in materialized
+                                     if row.get(column) not in (None, "")})
+                states[column] = ColumnState("categorical", categories=tuple(categories))
+                continue
+            numbers = [self._number(row.get(column), column) for row in materialized]
+            observed = [v for v in numbers if v is not None]
+            if not observed and self.spec.missing == "error":
+                raise ValueError("feature %r has no observed values" % column)
+            location = self._impute_location(observed)
+            clean = [v if v is not None else location for v in numbers]
+            if self.spec.scaling == "standard":
+                location = sum(clean) / len(clean)
+                scale = math.sqrt(sum((v - location) ** 2 for v in clean) / len(clean)) or 1.0
+            elif self.spec.scaling == "minmax":
+                location = min(clean)
+                scale = (max(clean) - location) or 1.0
+            else:
+                scale = 1.0
+            states[column] = ColumnState("numeric", location, scale)
+        if self.spec.label_type == "classification":
+            labels = sorted({self._as_category(row.get(self.spec.label)) for row in materialized})
+            self._label_mapping = {value: index for index, value in enumerate(labels)}
+        self._states = states
+        self._fitted_rows = len(materialized)
+        self._fingerprint = self._hash_rows(materialized)
+        return self
+
+    def plan(self, device: str = "cpu") -> CompiledPlan:
+        self._require_fit()
+        feature_count = len(self.spec.features)
+        if self.spec.architecture == "mlp":
+            shape = (feature_count,)
+        elif self.spec.architecture == "cnn":
+            shape = (1, feature_count)
+        else:
+            if feature_count % self.spec.sequence_length:
+                raise ValueError("feature count must divide sequence_length for sequential models")
+            shape = (self.spec.sequence_length, feature_count // self.spec.sequence_length)
+        options: Dict[str, Any] = {"batch_size": self.spec.batch_size, "shuffle": self.spec.shuffle,
+                                    "num_workers": self.spec.num_workers,
+                                    "pin_memory": device.startswith("cuda"),
+                                    "persistent_workers": self.spec.num_workers > 0,
+                                    "drop_last": self.spec.drop_last}
+        if self.spec.num_workers > 0:
+            options["prefetch_factor"] = self.spec.prefetch_factor
+        return CompiledPlan(self.spec, feature_count, shape, options, self._fitted_rows, self._fingerprint)
+
+    def transform(self, rows: Iterable[Mapping[str, Any]]) -> Tuple[Any, Any]:
+        """Materialize a feature tensor and correctly typed target tensor."""
+        self._require_fit()
+        torch = _torch()
+        features: List[List[float]] = []
+        labels: List[Any] = []
+        for row in rows:
+            features.append([self._transform_value(row.get(column), column) for column in self.spec.features])
+            labels.append(self._transform_label(row.get(self.spec.label)))
+        x = torch.tensor(features, dtype=getattr(torch, self.spec.dtype)).contiguous()
+        label_dtype = torch.long if self.spec.label_type == "classification" else getattr(torch, self.spec.dtype)
+        y = torch.tensor(labels, dtype=label_dtype).contiguous()
+        if self.spec.architecture == "cnn":
+            x = x.unsqueeze(1)
+        elif self.spec.architecture in ("rnn", "transformer"):
+            x = x.reshape(len(features), self.spec.sequence_length, -1)
+        return x, y
+
+    def tensors(self, rows: Iterable[Mapping[str, Any]]) -> Tuple[Any, Any]:
+        """Backward-compatible alias for :meth:`transform`."""
+        return self.transform(rows)
+
+    def dataloader(self, rows: Iterable[Mapping[str, Any]], device: str = "cpu") -> Any:
+        torch = _torch()
+        from torch.utils.data import DataLoader, TensorDataset
+        x, y = self._cached_or_transform(rows)
+        options = self.plan(device).loader_options
+        generator = torch.Generator()
+        generator.manual_seed(self.spec.seed)
+        options["generator"] = generator
+        return DataLoader(TensorDataset(x, y), **options)
+
+    def benchmark(self, rows: Iterable[Mapping[str, Any]], steps: int = 50,
+                  device: str = "cpu") -> Dict[str, float]:
+        """Measure input throughput, including host-to-device transfer when requested."""
+        if steps < 1:
+            raise ValueError("steps must be positive")
+        loader = self.dataloader(rows, device=device)
+        start = time.perf_counter()
+        seen = 0
+        for index, (features, labels) in enumerate(loader):
+            if device.startswith("cuda"):
+                features = features.to(device, non_blocking=True)
+                labels = labels.to(device, non_blocking=True)
+                _torch().cuda.synchronize()
+            seen += len(labels)
+            if index + 1 >= steps:
+                break
+        elapsed = max(time.perf_counter() - start, 1e-9)
+        return {"samples": float(seen), "seconds": elapsed, "samples_per_second": seen / elapsed}
+
+    def _cached_or_transform(self, rows: Iterable[Mapping[str, Any]]) -> Tuple[Any, Any]:
+        materialized = list(rows)
+        if not self.spec.cache_dir:
+            return self.transform(materialized)
+        torch = _torch()
+        cache_root = Path(self.spec.cache_dir)
+        cache_root.mkdir(parents=True, exist_ok=True)
+        key = hashlib.sha256((self._fingerprint + json.dumps(materialized, sort_keys=True, default=str)).encode()).hexdigest()[:24]
+        path = cache_root / (self.spec.name + "-" + key + ".pt")
+        if path.exists():
+            payload = torch.load(str(path), map_location="cpu")
+            return payload["features"], payload["labels"]
+        x, y = self.transform(materialized)
+        fd, temp_name = tempfile.mkstemp(prefix="silver-", suffix=".pt", dir=str(cache_root))
+        os.close(fd)
+        try:
+            torch.save({"features": x, "labels": y}, temp_name)
+            os.replace(temp_name, str(path))
+        finally:
+            if os.path.exists(temp_name):
+                os.unlink(temp_name)
+        return x, y
+
+    def _transform_value(self, value: Any, column: str) -> float:
+        state = self._states[column]
+        if state.kind == "categorical":
+            category = self._as_category(value)
+            return float(state.categories.index(category) + 1) if category in state.categories else 0.0
+        number = self._number(value, column)
+        if number is None:
+            if self.spec.missing == "error":
+                raise ValueError("missing value in feature %r" % column)
+            number = state.location
+        return (number - state.location) / state.scale
+
+    def _transform_label(self, value: Any) -> Any:
+        if self.spec.label_type == "classification":
+            category = self._as_category(value)
+            if category not in self._label_mapping:
+                raise ValueError("unknown label %r after fitting" % value)
+            return self._label_mapping[category]
+        number = self._number(value, self.spec.label)
+        if number is None:
+            raise ValueError("regression label cannot be missing")
+        return number
+
+    def _impute_location(self, observed: Sequence[float]) -> float:
+        if self.spec.missing in ("mean", "unknown") and observed:
+            return sum(observed) / len(observed)
+        if self.spec.missing == "median" and observed:
+            values = sorted(observed)
+            middle = len(values) // 2
+            return values[middle] if len(values) % 2 else (values[middle - 1] + values[middle]) / 2
+        return 0.0
+
+    def _require_fit(self) -> None:
+        if not self.fitted:
+            raise RuntimeError("fit the pipeline on the training split before transform")
+
+    @staticmethod
+    def _as_category(value: Any) -> str:
+        return "<missing>" if value in (None, "") else str(value)
+
+    @staticmethod
+    def _number(value: Any, column: str) -> Optional[float]:
+        if value is None or value == "":
+            return None
+        try:
+            result = float(value)
+        except (TypeError, ValueError) as error:
+            raise ValueError("feature %r must be numeric" % column) from error
+        if not math.isfinite(result):
+            raise ValueError("feature %r must be finite" % column)
+        return result
+
+    @staticmethod
+    def _hash_rows(rows: Sequence[Mapping[str, Any]]) -> str:
+        encoded = json.dumps(rows, sort_keys=True, separators=(",", ":"), default=str)
+        return hashlib.sha256(encoded.encode()).hexdigest()[:16]
+
+
+def compile_silver(source: str) -> SilverTorchPipeline:
+    return SilverTorchPipeline(parse_silver(source))
+
+
+def _torch() -> Any:
+    try:
+        import torch
+    except ImportError as error:
+        raise ImportError("install silver-torch[pytorch] to materialize PyTorch tensors") from error
+    return torch

silver_torch-0.1.0/src/silver_torch/spec.py

@@ -0,0 +1,50 @@
+"""Validated, serialisable configuration for Silver's PyTorch compiler."""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, Tuple
+
+
+@dataclass(frozen=True)
+class SilverPreprocessSpec:
+    name: str
+    features: Tuple[str, ...]
+    label: str
+    architecture: str = "mlp"
+    categorical: Tuple[str, ...] = ()
+    scaling: str = "standard"
+    missing: str = "error"
+    label_type: str = "classification"
+    dtype: str = "float32"
+    batch_size: int = 64
+    shuffle: bool = True
+    num_workers: int = 0
+    prefetch_factor: int = 2
+    drop_last: bool = False
+    sequence_length: int = 1
+    seed: int = 17
+    cache_dir: str = ""
+    options: Dict[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if not self.name or not self.features or not self.label:
+            raise ValueError("name, features, and label are required")
+        if len(set(self.features)) != len(self.features):
+            raise ValueError("features must not contain duplicates")
+        unknown = set(self.categorical) - set(self.features)
+        if unknown:
+            raise ValueError("categorical columns must be listed in features: %s" % sorted(unknown))
+        if self.architecture not in ("mlp", "cnn", "rnn", "transformer"):
+            raise ValueError("architecture must be mlp, cnn, rnn, or transformer")
+        if self.scaling not in ("none", "standard", "minmax"):
+            raise ValueError("scaling must be none, standard, or minmax")
+        if self.missing not in ("error", "zero", "mean", "median", "unknown"):
+            raise ValueError("missing must be error, zero, mean, median, or unknown")
+        if self.label_type not in ("classification", "regression"):
+            raise ValueError("label_type must be classification or regression")
+        if self.dtype not in ("float16", "float32", "float64", "bfloat16"):
+            raise ValueError("dtype must be a floating PyTorch dtype")
+        if self.batch_size < 1 or self.num_workers < 0 or self.prefetch_factor < 1:
+            raise ValueError("batch_size, workers, and prefetch_factor are invalid")
+        if self.sequence_length < 1 or self.seed < 0:
+            raise ValueError("sequence_length must be positive and seed non-negative")
+

silver_torch-0.1.0/src/silver_torch.egg-info/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: silver-torch
+Version: 0.1.0
+Summary: Inspectable Silver dataset preprocessing and PyTorch input pipelines.
+License-Expression: Apache-2.0
+Keywords: pytorch,preprocessing,datasets,machine-learning,research
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: pytorch
+Requires-Dist: torch>=1.9.0; extra == "pytorch"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+
+# silver-torch
+
+An optional PyTorch layer for Silver. It turns a small Silver preprocessing
+program into a fitted, inspectable, reusable tensor and `DataLoader` pipeline.
+
+```bash
+pip install silver-data
+pip install 'silver-torch[pytorch]'
+```
+
+```python
+from silver_data import Dataset
+from silver_torch import compile_silver
+
+program = """
+pipeline ieee_inverse:
+  features voltage, current, phase, sensor
+  categorical sensor
+  label fault
+  architecture transformer
+  sequence_length 2
+  scaling standard
+  missing median
+  label_type classification
+  batch_size 128
+  num_workers 2
+  cache_dir .cache/ieee_inverse
+"""
+
+dataset = Dataset.from_records("ieee", [
+    {"voltage": 1.0, "current": 2.0, "phase": 0.2, "fault": 0},
+    {"voltage": 1.2, "current": 2.1, "phase": 0.3, "fault": 1},
+])
+splits = dataset.split(0.8, 0.1, 0.1)
+pipeline = compile_silver(program).fit(splits.train.records())
+loader = pipeline.dataloader(splits.validation.records(), device="cuda")
+print(pipeline.plan(device="cuda").to_dict())
+print(pipeline.benchmark(splits.validation.records(), steps=20))
+```
+
+The compiler has explicit research-safety boundaries:
+
+- statistics and vocabularies are fitted only on `splits.train`;
+- missing columns, non-finite numbers, invalid labels, and incompatible
+  sequence lengths fail loudly;
+- categorical vocabularies are sorted for reproducibility and reserve index 0
+  for unknown values;
+- classification targets are `torch.long`; regression targets use the chosen
+  floating dtype;
+- cache keys include the fitted-training fingerprint and transformed rows, and
+  cache writes are atomic;
+- loaders are seeded and tune pinning, persistent workers, prefetching, and
+  `drop_last` based on the declared runtime.
+
+The emitted shapes are `[batch, features]` for MLP, `[batch, 1, features]` for
+CNN, and `[batch, sequence_length, features_per_step]` for RNN/Transformer.
+These are layout contracts, not model implementations. Measure with
+`benchmark()` on the target machine; input speedups depend on storage, CPU,
+worker count, batch size, and accelerator.

silver_torch-0.1.0/src/silver_torch.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/silver_torch/__init__.py
+src/silver_torch/pipeline.py
+src/silver_torch/spec.py
+src/silver_torch.egg-info/PKG-INFO
+src/silver_torch.egg-info/SOURCES.txt
+src/silver_torch.egg-info/dependency_links.txt
+src/silver_torch.egg-info/requires.txt
+src/silver_torch.egg-info/top_level.txt
+tests/test_pipeline.py

silver_torch-0.1.0/src/silver_torch.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

silver_torch-0.1.0/src/silver_torch.egg-info/requires.txt

@@ -0,0 +1,6 @@
+
+[dev]
+pytest>=7.0.0
+
+[pytorch]
+torch>=1.9.0

silver_torch-0.1.0/src/silver_torch.egg-info/top_level.txt

@@ -0,0 +1 @@
+silver_torch

silver_torch-0.1.0/tests/test_pipeline.py

@@ -0,0 +1,141 @@
+import pytest
+
+from silver_torch import compile_silver, parse_silver
+
+
+PROGRAM = """
+pipeline ieee_inverse:
+  features voltage, current
+  label fault
+  architecture transformer
+  scaling standard
+  missing median
+  batch_size 8
+  num_workers 2
+"""
+
+
+def test_parse_and_plan_are_inspectable():
+    spec = parse_silver(PROGRAM)
+    assert spec.name == "ieee_inverse"
+    assert spec.features == ("voltage", "current")
+    pipeline = compile_silver(PROGRAM).fit(
+        [
+            {"voltage": 1, "current": 10, "fault": 0},
+            {"voltage": 3, "current": 30, "fault": 1},
+        ]
+    )
+    plan = pipeline.plan(device="cuda").to_dict()
+    assert plan["schema"] == "silver.torch/plan-2"
+    assert plan["input_shape"] == [1, 2]
+    assert plan["loader_options"]["pin_memory"] is True
+    assert plan["loader_options"]["prefetch_factor"] == 2
+
+
+def test_fit_uses_training_statistics_and_handles_median():
+    pipeline = compile_silver(
+        PROGRAM.replace("architecture transformer", "architecture mlp")
+    ).fit(
+        [
+            {"voltage": 1, "current": 10, "fault": 0},
+            {"voltage": None, "current": 20, "fault": 1},
+            {"voltage": 3, "current": 30, "fault": 1},
+        ]
+    )
+    assert pipeline.statistics["voltage"]["location"] == 2
+    assert pipeline.statistics["current"]["location"] == 20
+
+
+def test_tensors_are_contiguous_when_torch_is_available():
+    torch = pytest.importorskip("torch")
+    pipeline = compile_silver(PROGRAM).fit(
+        [
+            {"voltage": 1, "current": 10, "fault": 0},
+            {"voltage": 3, "current": 30, "fault": 1},
+        ]
+    )
+    features, labels = pipeline.tensors(
+        [{"voltage": 2, "current": 20, "fault": 1}]
+    )
+    assert features.is_contiguous()
+    assert features.dtype == torch.float32
+    assert tuple(features.shape) == (1, 1, 2)
+    assert tuple(labels.shape) == (1,)
+
+
+def test_missing_error_is_not_silently_imputed():
+    program = PROGRAM.replace("missing median", "missing error")
+    pipeline = compile_silver(program).fit(
+        [{"voltage": 1, "current": 10, "fault": 0}]
+    )
+    with pytest.raises(ValueError, match="missing value"):
+        pipeline.tensors([{"voltage": None, "current": 10, "fault": 0}])
+
+
+def test_categorical_features_and_classification_labels_are_encoded():
+    program = """
+pipeline categorical:
+  features sensor, voltage
+  categorical sensor
+  label fault
+  scaling none
+  missing unknown
+"""
+    torch = pytest.importorskip("torch")
+    pipeline = compile_silver(program).fit([
+        {"sensor": "a", "voltage": 1, "fault": "healthy"},
+        {"sensor": "b", "voltage": 2, "fault": "fault"},
+    ])
+    features, labels = pipeline.transform([
+        {"sensor": "unseen", "voltage": 3, "fault": "fault"}
+    ])
+    assert features[0, 0].item() == 0.0
+    assert labels.dtype == torch.long
+
+
+def test_regression_and_sequence_layout():
+    program = """
+pipeline sequence:
+  features x1, x2, x3, x4
+  label target
+  architecture rnn
+  label_type regression
+  sequence_length 2
+"""
+    torch = pytest.importorskip("torch")
+    pipeline = compile_silver(program).fit([
+        {"x1": 1, "x2": 2, "x3": 3, "x4": 4, "target": 0.5}
+    ])
+    features, labels = pipeline.transform([
+        {"x1": 1, "x2": 2, "x3": 3, "x4": 4, "target": 0.5}
+    ])
+    assert tuple(features.shape) == (1, 2, 2)
+    assert labels.dtype == torch.float32
+
+
+def test_invalid_sequence_layout_fails_before_materialization():
+    program = PROGRAM.replace("architecture transformer", "architecture transformer").replace(
+        "features voltage, current", "features voltage, current, phase"
+    ) + "  sequence_length 2\n"
+    pipeline = compile_silver(program).fit([
+        {"voltage": 1, "current": 10, "phase": 2, "fault": 0},
+        {"voltage": 3, "current": 30, "phase": 4, "fault": 1},
+    ])
+    with pytest.raises(ValueError, match="feature count"):
+        pipeline.plan()
+
+
+def test_cache_and_benchmark(tmp_path):
+    pytest.importorskip("torch")
+    program = PROGRAM.replace("num_workers 2", "num_workers 0") + "  cache_dir %s\n" % tmp_path
+    pipeline = compile_silver(program).fit([
+        {"voltage": 1, "current": 10, "fault": 0},
+        {"voltage": 3, "current": 30, "fault": 1},
+    ])
+    rows = [{"voltage": 2, "current": 20, "fault": 1}]
+    first = pipeline.dataloader(rows)
+    second = pipeline.dataloader(rows)
+    assert len(list(first)) == len(list(second)) == 1
+    result = pipeline.benchmark(rows, steps=1)
+    assert result["samples"] == 1.0
+    assert result["samples_per_second"] > 0