cnn-classifier-toolkit 0.1.0__py3-none-any.whl

cnn_classifier/data/adapters/synthetic.py

@@ -0,0 +1,114 @@
+"""Deterministic synthetic dataset adapter for tests and smoke runs."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from collections.abc import Sequence
+
+import numpy as np
+import torch
+
+from cnn_classifier.config.schema import DataConfig
+from cnn_classifier.core.errors import ConfigError
+from cnn_classifier.core.hashing import stable_hash
+from cnn_classifier.core.types import DatasetBundle
+from cnn_classifier.data.adapters._common import (
+    RawSample,
+    assign_split,
+    build_bundle,
+)
+from cnn_classifier.data.adapters.registry import register_dataset
+from cnn_classifier.data.splits import SplitIndices
+
+
+def _three_way_split(
+    labels: Sequence[str],
+    val_fraction: float,
+    test_fraction: float,
+    seed: int,
+) -> SplitIndices:
+    if not 0.0 <= test_fraction < 1.0:
+        raise ConfigError("synthetic test_fraction must be in [0, 1)")
+    if test_fraction + val_fraction >= 1.0:
+        raise ConfigError("synthetic test_fraction + val_fraction must be smaller than 1")
+    by_class: dict[str, list[int]] = defaultdict(list)
+    for index, label in enumerate(labels):
+        by_class[label].append(index)
+    rng = np.random.default_rng(seed)
+    train: list[int] = []
+    val: list[int] = []
+    test: list[int] = []
+    for label in sorted(by_class):
+        indices = np.array(by_class[label])
+        shuffled = indices[rng.permutation(len(indices))].tolist()
+        test_count = round(len(shuffled) * test_fraction)
+        val_count = round(len(shuffled) * val_fraction)
+        if len(shuffled) >= 3:
+            test_count = max(1, test_count)
+            val_count = max(1, val_count)
+        test.extend(shuffled[:test_count])
+        val.extend(shuffled[test_count : test_count + val_count])
+        train.extend(shuffled[test_count + val_count :])
+    return SplitIndices(tuple(sorted(train)), tuple(sorted(val)), tuple(sorted(test)))
+
+
+@register_dataset("synthetic")
+class SyntheticAdapter:
+    """Generate a tiny deterministic tensor dataset."""
+
+    @staticmethod
+    def build(config: DataConfig) -> DatasetBundle:
+        params = config.adapter_params
+        num_samples = int(params.get("num_samples", 64))
+        num_classes = int(params.get("num_classes", config.num_classes or 2))
+        if num_samples <= 0 or num_classes <= 0:
+            raise ConfigError("synthetic adapter requires positive sample and class counts")
+        image_size = tuple(params.get("image_size", config.image_size))
+        channels = 3 if config.channels == "rgb" else 1
+        generator = torch.Generator().manual_seed(config.split.seed)
+        images = torch.rand(
+            num_samples, channels, image_size[0], image_size[1], generator=generator
+        )
+        if isinstance(config.class_names, tuple):
+            class_names = config.class_names
+            if len(class_names) != num_classes:
+                raise ConfigError("data.class_names length must match synthetic num_classes")
+        else:
+            class_names = tuple(f"class_{index}" for index in range(num_classes))
+        labels = [class_names[index % num_classes] for index in range(num_samples)]
+        if config.num_classes is not None and config.num_classes != num_classes:
+            raise ConfigError("synthetic num_classes must match data.num_classes")
+        samples = [
+            RawSample(source=images[index], label=labels[index], split="train")
+            for index in range(num_samples)
+        ]
+        test_fraction = float(params.get("test_fraction", 0.0))
+        if test_fraction > 0:
+            if config.split.mode not in {"random", "random_stratified"}:
+                raise ConfigError(
+                    "synthetic test_fraction requires a random or random_stratified split"
+                )
+            split = _three_way_split(
+                labels, config.split.val_fraction, test_fraction, config.split.seed
+            )
+            mode = "random_stratified"
+        else:
+            split, mode = assign_split(samples, config)
+        fingerprint = stable_hash(
+            {
+                "adapter": "synthetic",
+                "num_samples": num_samples,
+                "num_classes": num_classes,
+                "image_size": list(image_size),
+                "seed": config.split.seed,
+                "test_fraction": test_fraction,
+            }
+        )
+        return build_bundle(
+            samples,
+            config,
+            class_names=class_names,
+            split=split,
+            mode=mode,
+            fingerprint=fingerprint,
+        )

cnn_classifier/data/adapters/torchvision.py

@@ -0,0 +1,192 @@
+"""Torchvision dataset adapter for CIFAR-10 and similar built-ins."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import torch
+import torchvision
+from torch.utils.data import Dataset, Subset
+
+from cnn_classifier.config.schema import DataConfig
+from cnn_classifier.core.errors import ConfigError, DataError
+from cnn_classifier.core.hashing import stable_hash
+from cnn_classifier.core.types import (
+    DatasetBundle,
+    ModelInputContract,
+    SampleMetadata,
+    SplitInfo,
+)
+from cnn_classifier.data.adapters._common import resolve_normalization
+from cnn_classifier.data.adapters.registry import register_dataset
+from cnn_classifier.data.splits import (
+    SplitIndices,
+    random_split_indices,
+    stratified_split_indices,
+)
+from cnn_classifier.data.transforms import EnsureTensor, build_transforms
+
+
+class _TripleDataset(Dataset[tuple[Any, int, int]]):
+    def __init__(self, base: Dataset[Any]) -> None:
+        self.base = base
+
+    def __len__(self) -> int:
+        return len(self.base)  # type: ignore[arg-type]
+
+    def __getitem__(self, index: int) -> tuple[Any, int, int]:
+        image, label = self.base[index]
+        return image, int(label), index
+
+
+class _TensorTripleDataset(Dataset[tuple[torch.Tensor, int, int]]):
+    def __init__(self, base: Dataset[Any]) -> None:
+        self.base = base
+
+    def __len__(self) -> int:
+        return len(self.base)  # type: ignore[arg-type]
+
+    def __getitem__(self, index: int) -> tuple[torch.Tensor, int, int]:
+        image, label, source_index = self.base[index]
+        return EnsureTensor()(image), int(label), int(source_index)
+
+
+class _TransformedTripleDataset(Dataset[tuple[torch.Tensor, int, int]]):
+    def __init__(self, base: Dataset[Any], transform: Any) -> None:
+        self.base = base
+        self.transform = transform
+
+    def __len__(self) -> int:
+        return len(self.base)  # type: ignore[arg-type]
+
+    def __getitem__(self, index: int) -> tuple[torch.Tensor, int, int]:
+        image, label, source_index = self.base[index]
+        return self.transform(image), int(label), int(source_index)
+
+
+def _dataset_targets(dataset: Dataset[Any]) -> list[int]:
+    targets = getattr(dataset, "targets", None)
+    if targets is None:
+        targets = getattr(dataset, "labels", None)
+    if targets is None:
+        raise DataError("torchvision dataset exposes neither targets nor labels")
+    return [int(value) for value in targets]
+
+
+def _sample_limit(config: DataConfig, key: str) -> int | None:
+    value = config.adapter_params.get(key)
+    if value is None:
+        return None
+    if not isinstance(value, int) or isinstance(value, bool) or value <= 0:
+        raise ConfigError(f"adapter_params.{key} must be a positive integer")
+    return value
+
+
+@register_dataset("torchvision")
+class TorchvisionAdapter:
+    """Wrap a torchvision classification dataset with the package contracts."""
+
+    @staticmethod
+    def build(config: DataConfig) -> DatasetBundle:
+        if config.root is None:
+            raise ConfigError("torchvision adapter requires data.root")
+        dataset_name = str(config.adapter_params.get("dataset", "CIFAR10"))
+        dataset_class = getattr(torchvision.datasets, dataset_name, None)
+        if dataset_class is None:
+            raise ConfigError(f"unknown torchvision dataset {dataset_name!r}")
+        download = bool(config.adapter_params.get("download", True))
+        try:
+            train_base = dataset_class(root=str(config.root), train=True, download=download)
+            test_base = dataset_class(root=str(config.root), train=False, download=download)
+        except (OSError, RuntimeError) as exc:
+            raise DataError(f"cannot load torchvision dataset {dataset_name}: {exc}") from exc
+        class_names = tuple(str(name) for name in train_base.classes)
+        if isinstance(config.class_names, tuple) and tuple(config.class_names) != class_names:
+            raise ConfigError("data.class_names must match the torchvision class order")
+        label_map = {name: index for index, name in enumerate(class_names)}
+        targets = _dataset_targets(train_base)
+        test_targets = _dataset_targets(test_base)[: len(test_base)]
+        test_fingerprint = stable_hash(
+            {
+                "adapter": "torchvision",
+                "dataset": dataset_name,
+                "test_size": len(test_targets),
+                "test_targets": test_targets,
+                "class_names": class_names,
+            }
+        )
+        if config.split.mode == "random":
+            split = random_split_indices(targets, config.split.val_fraction, config.split.seed)
+            mode = "random"
+        elif config.split.mode == "random_stratified":
+            split = stratified_split_indices(targets, config.split.val_fraction, config.split.seed)
+            mode = "random_stratified"
+        else:
+            raise ConfigError("torchvision adapter supports random or random_stratified splits")
+        max_train = _sample_limit(config, "max_train_samples")
+        max_val = _sample_limit(config, "max_val_samples")
+        if max_train is not None or max_val is not None:
+            split = SplitIndices(
+                split.train_indices[:max_train] if max_train is not None else split.train_indices,
+                split.val_indices[:max_val] if max_val is not None else split.val_indices,
+            )
+        train_triple = _TripleDataset(train_base)
+        stats_source = _TensorTripleDataset(train_triple)
+        normalization = resolve_normalization(config, stats_source, split.train_indices)
+        train_transform = build_transforms(config, normalization, train=True)
+        eval_transform = build_transforms(config, normalization, train=False)
+        train = Subset(
+            _TransformedTripleDataset(train_triple, train_transform), split.train_indices
+        )
+        val = Subset(_TransformedTripleDataset(train_triple, eval_transform), split.val_indices)
+        test = _TransformedTripleDataset(_TripleDataset(test_base), eval_transform)
+        fingerprint = stable_hash(
+            {
+                "adapter": "torchvision",
+                "dataset": dataset_name,
+                "train_size": len(train_base),
+                "test_size": len(test_base),
+                "train_samples": len(split.train_indices),
+                "val_samples": len(split.val_indices),
+                "seed": config.split.seed,
+            }
+        )
+        contract = ModelInputContract(
+            input_shape=(3, *config.image_size),
+            dtype="float32",
+            value_range=(0.0, 1.0),
+            normalization=normalization,
+            class_names=class_names,
+            label_map=label_map,
+            channel_policy="rgb",
+            stem_adaptation=None,
+        )
+        metadata = SampleMetadata(
+            paths=tuple(Path(f"<torchvision:{index}>") for index in range(len(train_base))),
+            labels=tuple(targets),
+            groups=tuple(None for _ in targets),
+            source_indices=tuple(range(len(train_base))),
+        )
+        return DatasetBundle(
+            train=train,
+            val=val,
+            test=test,
+            class_names=class_names,
+            in_channels=3,
+            image_size=config.image_size,
+            normalization=normalization,
+            split_info=SplitInfo(
+                mode=mode,  # type: ignore[arg-type]
+                train_indices=split.train_indices,
+                val_indices=split.val_indices,
+                test_indices=None,
+                seed=config.split.seed,
+                group_column=None,
+                fingerprint=fingerprint,
+            ),
+            fingerprint=fingerprint,
+            sample_metadata=metadata,
+            model_contract=contract,
+            test_fingerprint=test_fingerprint,
+        )

cnn_classifier/data/base.py

@@ -0,0 +1,17 @@
+"""Dataset adapter protocol and shared bundle types."""
+
+from __future__ import annotations
+
+from typing import Protocol
+
+from cnn_classifier.config.schema import DataConfig
+from cnn_classifier.core.types import DatasetBundle
+
+
+class DatasetAdapter(Protocol):
+    """Builds a train/val/test bundle from a data configuration."""
+
+    @staticmethod
+    def build(config: DataConfig) -> DatasetBundle:
+        """Return the resolved datasets and their contracts."""
+        ...

cnn_classifier/data/contract.py

@@ -0,0 +1,28 @@
+"""Model input contract derivation and serialization."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, replace
+from pathlib import Path
+
+from cnn_classifier.core.types import DatasetBundle, ModelInputContract
+
+
+def build_model_contract(
+    bundle: DatasetBundle,
+    *,
+    model_name: str,
+    stem_adaptation: str | None = None,
+) -> ModelInputContract:
+    """Return the exact model-input contract for a selected model."""
+    _ = model_name
+    return replace(bundle.model_contract, stem_adaptation=stem_adaptation)
+
+
+def write_model_contract(contract: ModelInputContract, path: Path) -> Path:
+    """Write the contract as deterministic JSON."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = asdict(contract)
+    path.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    return path

cnn_classifier/data/image_io.py

@@ -0,0 +1,116 @@
+"""Explicit 8-bit and 16-bit image readers with a documented value range."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Literal
+
+import numpy as np
+import tifffile
+import torch
+from PIL import Image
+
+from cnn_classifier.config.schema import ValueRangeConfig
+from cnn_classifier.core.errors import DataError
+
+ChannelPolicy = Literal["rgb", "gray", "as_is"]
+_PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"
+_INTEGER_MAX = {
+    np.dtype("uint8"): 255.0,
+    np.dtype("uint16"): 65535.0,
+    np.dtype("uint32"): float(2**32 - 1),
+    np.dtype("int16"): 32767.0,
+    np.dtype("int32"): float(2**31 - 1),
+}
+
+
+def _reject_unsupported_png(path: Path) -> None:
+    """Reject 16-bit multichannel PNGs that Pillow would silently downcast."""
+    with path.open("rb") as handle:
+        header = handle.read(26)
+    if len(header) < 26 or header[:8] != _PNG_SIGNATURE:
+        return
+    if header[12:16] != b"IHDR" or int.from_bytes(header[8:12], "big") != 13:
+        return
+    bit_depth = header[24]
+    color_type = header[25]
+    if bit_depth == 16 and color_type in {2, 4, 6}:
+        raise DataError(
+            f"cannot read {path}: 16-bit RGB PNG is not supported without "
+            "truncation; use a 16-bit TIFF or an 8-bit PNG"
+        )
+
+
+def _read_array(path: Path) -> np.ndarray:
+    suffix = path.suffix.lower()
+    try:
+        if suffix in {".tif", ".tiff"}:
+            return np.asarray(tifffile.imread(path))
+        if suffix == ".png":
+            _reject_unsupported_png(path)
+        with Image.open(path) as image:
+            return np.asarray(image)
+    except DataError:
+        raise
+    except (OSError, ValueError) as exc:
+        raise DataError(f"cannot read image {path}: {exc}") from exc
+
+
+def _to_channels(array: np.ndarray, channels: ChannelPolicy) -> np.ndarray:
+    if array.ndim == 2:
+        array = array[:, :, None]
+    if array.ndim != 3:
+        raise DataError(f"image must be 2-D or 3-D; got shape {array.shape}")
+    if channels == "as_is":
+        return array
+    if channels == "gray":
+        if array.shape[2] == 1:
+            return array
+        if array.dtype == np.uint8:
+            return np.asarray(Image.fromarray(array).convert("L"), dtype=np.uint8)[:, :, None]
+        result: np.ndarray = array.astype(np.float64).mean(axis=2, keepdims=True)
+        return result
+    if array.shape[2] == 1:
+        return np.repeat(array, 3, axis=2)
+    if array.shape[2] < 3:
+        raise DataError(f"RGB image needs at least 3 channels; got {array.shape[2]}")
+    return array[:, :, :3]
+
+
+def _scale(array: np.ndarray, value_range: ValueRangeConfig | None) -> np.ndarray:
+    original_dtype = array.dtype
+    data = array.astype(np.float64)
+    if value_range is not None and value_range.mode == "fixed":
+        if value_range.min is None or value_range.max is None:
+            raise DataError("fixed value_range requires min and max")
+        low, high = float(value_range.min), float(value_range.max)
+        if low >= high:
+            raise DataError("fixed value_range min must be smaller than max")
+        return np.clip((data - low) / (high - low), 0.0, 1.0)
+    if np.issubdtype(original_dtype, np.integer):
+        maximum = _INTEGER_MAX.get(original_dtype)
+        if maximum is None:
+            maximum = float(np.iinfo(original_dtype).max)
+        return data / maximum
+    return np.clip(data, 0.0, 1.0)
+
+
+def read_image(
+    path: Path,
+    channels: ChannelPolicy = "rgb",
+    value_range: ValueRangeConfig | None = None,
+) -> torch.Tensor:
+    """Read an image as ``float32 [C,H,W]`` in ``[0,1]``.
+
+    The reader never silently converts a 16-bit source to 8 bits. TIFF files use
+    ``tifffile``; other formats use Pillow, including 16-bit PNG mode ``I;16``.
+    """
+    if not path.is_file():
+        raise DataError(f"image does not exist: {path}")
+    array = _read_array(path)
+    array = _to_channels(array, channels)
+    scaled = _scale(array, value_range)
+    tensor = torch.from_numpy(np.ascontiguousarray(scaled.transpose(2, 0, 1))).to(torch.float32)
+    if tensor.ndim != 3:
+        raise DataError(f"unexpected image shape after conversion: {tuple(tensor.shape)}")
+    return tensor

cnn_classifier/data/inspection.py

@@ -0,0 +1,111 @@
+"""Dataset inspection for class balance, duplicates, and leakage."""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass, field
+
+import torch
+
+from cnn_classifier.core.errors import DataError
+from cnn_classifier.core.types import DatasetBundle
+
+
+@dataclass(frozen=True)
+class DataInspectionReport:
+    class_counts: dict[str, dict[str, int]] = field(default_factory=dict)
+    duplicates: dict[str, int] = field(default_factory=dict)
+    corrupt: list[str] = field(default_factory=list)
+    sizes: dict[str, int] = field(default_factory=dict)
+    split_overlap: list[str] = field(default_factory=list)
+    group_leakage: list[str] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+
+
+def _content_hash(image: torch.Tensor) -> str:
+    data = image.detach().cpu().contiguous().numpy().tobytes()
+    return hashlib.sha256(data).hexdigest()
+
+
+def inspect_dataset(bundle: DatasetBundle, max_samples: int | None = None) -> DataInspectionReport:
+    """Inspect split class balance, duplicate content, and group leakage."""
+    class_counts: dict[str, dict[str, int]] = {}
+    content_hashes: dict[str, int] = {}
+    corrupt: list[str] = []
+    sizes: dict[str, int] = {}
+    path_sets: dict[str, set[str]] = {}
+    group_sets: dict[str, set[str]] = {}
+
+    splits = {"train": bundle.train, "val": bundle.val}
+    if bundle.test is not None:
+        splits["test"] = bundle.test
+    for split_name, dataset in splits.items():
+        counts: dict[str, int] = dict.fromkeys(bundle.class_names, 0)
+        path_sets[split_name] = set()
+        group_sets[split_name] = set()
+        limit = len(dataset) if max_samples is None else min(len(dataset), max_samples)  # type: ignore[arg-type]
+        for index in range(limit):
+            source_index = -1
+            try:
+                image, label, source_index = dataset[index]
+            except (DataError, OSError, ValueError) as exc:
+                path = (
+                    bundle.sample_metadata.paths[source_index]
+                    if 0 <= source_index < len(bundle.sample_metadata.paths)
+                    else f"<sample:{index}>"
+                )
+                corrupt.append(f"{path}: {exc}")
+                continue
+            class_name = bundle.class_names[int(label)]
+            counts[class_name] += 1
+            digest = _content_hash(image)
+            content_hashes[digest] = content_hashes.get(digest, 0) + 1
+            _, height, width = image.shape
+            sizes[f"{height}x{width}x{image.shape[0]}"] = (
+                sizes.get(f"{height}x{width}x{image.shape[0]}", 0) + 1
+            )
+            source_path = (
+                bundle.sample_metadata.paths[source_index]
+                if 0 <= source_index < len(bundle.sample_metadata.paths)
+                else None
+            )
+            if source_path is not None:
+                path_sets[split_name].add(str(source_path))
+            group = (
+                bundle.sample_metadata.groups[source_index]
+                if 0 <= source_index < len(bundle.sample_metadata.groups)
+                else None
+            )
+            if group is not None:
+                group_sets[split_name].add(group)
+        class_counts[split_name] = counts
+
+    duplicates = {digest: count for digest, count in content_hashes.items() if count > 1}
+    split_overlap: list[str] = []
+    if "train" in path_sets and "val" in path_sets:
+        overlap = path_sets["train"] & path_sets["val"]
+        split_overlap = sorted(overlap)
+    group_leakage = sorted(group_sets.get("train", set()) & group_sets.get("val", set()))
+    warnings: list[str] = []
+    if split_overlap:
+        warnings.append(f"{len(split_overlap)} path(s) appear in both train and val")
+    if group_leakage:
+        warnings.append(f"group leakage across train and val: {', '.join(group_leakage)}")
+    if duplicates:
+        warnings.append(f"{len(duplicates)} duplicate content hash(es) found")
+    if corrupt:
+        warnings.append(f"{len(corrupt)} unreadable sample(s) found")
+    for split_name, counts in class_counts.items():
+        nonzero = [count for count in counts.values() if count > 0]
+        if nonzero and max(nonzero) > 2 * max(1, min(nonzero)):
+            warnings.append(f"{split_name} classes are imbalanced: {counts}")
+
+    return DataInspectionReport(
+        class_counts=class_counts,
+        duplicates=duplicates,
+        corrupt=corrupt,
+        sizes=sizes,
+        split_overlap=split_overlap,
+        group_leakage=group_leakage,
+        warnings=warnings,
+    )

cnn_classifier/data/loaders.py

@@ -0,0 +1,79 @@
+"""DataLoader construction with device-aware worker defaults."""
+
+from __future__ import annotations
+
+import platform
+from dataclasses import dataclass
+from typing import Any
+
+import torch
+from torch.utils.data import DataLoader
+
+from cnn_classifier.config.schema import RuntimeConfig, TrainingConfig
+from cnn_classifier.core.seeding import make_generator
+from cnn_classifier.core.types import DatasetBundle
+
+
+@dataclass(frozen=True)
+class DataLoaderBundle:
+    train: DataLoader[Any]
+    val: DataLoader[Any]
+    test: DataLoader[Any] | None
+
+
+def _worker_count(runtime: RuntimeConfig, device: torch.device) -> int:
+    if isinstance(runtime.num_workers, int):
+        return runtime.num_workers
+    if device.type == "mps":
+        return 0
+    if device.type == "cuda" and platform.system() == "Linux":
+        return 4
+    return 2
+
+
+def _pin_memory(runtime: RuntimeConfig, device: torch.device) -> bool:
+    if isinstance(runtime.pin_memory, bool):
+        return runtime.pin_memory
+    return device.type == "cuda"
+
+
+def build_loaders(
+    bundle: DatasetBundle,
+    training: TrainingConfig,
+    runtime: RuntimeConfig,
+    device: torch.device,
+) -> DataLoaderBundle:
+    """Build train/val/test loaders with seeded shuffling and worker policy."""
+    workers = _worker_count(runtime, device)
+    pin_memory = _pin_memory(runtime, device)
+    persistent = runtime.persistent_workers and workers > 0
+    train = DataLoader(
+        bundle.train,
+        batch_size=training.batch_size,
+        shuffle=True,
+        num_workers=workers,
+        pin_memory=pin_memory,
+        persistent_workers=persistent,
+        generator=make_generator(bundle.split_info.seed),
+    )
+    val = DataLoader(
+        bundle.val,
+        batch_size=training.batch_size,
+        shuffle=False,
+        num_workers=workers,
+        pin_memory=pin_memory,
+        persistent_workers=persistent,
+    )
+    test = (
+        DataLoader(
+            bundle.test,
+            batch_size=training.batch_size,
+            shuffle=False,
+            num_workers=workers,
+            pin_memory=pin_memory,
+            persistent_workers=persistent,
+        )
+        if bundle.test is not None
+        else None
+    )
+    return DataLoaderBundle(train=train, val=val, test=test)