Remove tests directory and refresh README references

Remove BioMod/tests/test_training_utils.py as requested. Remove the test command, links and tree entries from both project READMEs while retaining pretraining requirements. Runtime training utilities, task code, model weights, paired configuration and all data files remain unchanged.

BioMod/README.md

@@ -60,8 +60,6 @@ BioMod/                                                        # Task code: trai
 │   ├── README.md
 │   ├── train.py
 │   └── tutorial.ipynb
-├── tests/                                                     # CPU tests for shared training utilities
-│   └── test_training_utils.py
 ├── zero_shot_batch/                                           # Zero-shot integration and evaluation
 │   ├── tools/                                                 # Optional visualization and evaluation tools
 │   │   ├── sequencing_depth/                                  # Low-depth expression generation and evaluation
@@ -113,25 +111,9 @@ jupyter lab tutorial.ipynb
 Use `drug_response`, `drug_combination`, `gene_perturbation`, or `zero_shot_batch`
 in place of `cell_annotation` to open another task.
 
-### Training utility checks
+### Pretraining requirements
 
-The pretraining entry point imports `training_utils.py` explicitly. This local
-module supplies random seeding, a sequential distributed validation sampler,
-cosine learning-rate scheduling with warmup and restarts, scalar metric
-reduction, and resumable checkpoint saving. It does not depend on a separate
-package named `utils` or on a downstream task's utility module.
-
-From this source directory, run the CPU utility tests and check entry-point
-imports after installing the dependencies:
-
-```bash
-python -B -m unittest discover -s tests -p test_training_utils.py -v
-python -B biomod.py --help
-```
-
-The utility tests use synthetic tensors and temporary checkpoints; they do not
-load the supplied pretrained weights. Passing these checks does not validate a
-full training run. The pretraining entry point requires CUDA and an NCCL
+The pretraining entry point requires CUDA and an NCCL
 process group. Supply `--data_path` explicitly: the pretraining corpus is not
 bundled. Configure module inputs with `--biomod_data_dir` or `--biomod_data_path`.
 Generated checkpoints default to `tutorial_runs/pretraining/` under the outer

BioMod/tests/test_training_utils.py

@@ -1,262 +0,0 @@
-"""CPU-only checks for the utilities used by the pretraining entry point.
-
-Run from the source directory with:
-    python -m unittest discover -s tests -p "test_training_utils.py" -v
-"""
-
-import copy
-import math
-import random
-import sys
-import tempfile
-import unittest
-from pathlib import Path
-
-import numpy as np
-import torch
-
-sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
-
-from training_utils import (
-    CosineAnnealingWarmupRestarts,
-    SequentialDistributedSampler,
-    get_reduced,
-    save_scaler_ckpt,
-    seed_all,
-)
-
-
-class SeedTests(unittest.TestCase):
-    def test_seed_reproduces_python_numpy_and_torch_sequences(self):
-        original_deterministic = torch.backends.cudnn.deterministic
-        original_benchmark = torch.backends.cudnn.benchmark
-        try:
-            seed_all(1234, cuda_deterministic=True)
-            first = (random.random(), np.random.random(4), torch.rand(4))
-            seed_all(1234, cuda_deterministic=True)
-            second = (random.random(), np.random.random(4), torch.rand(4))
-            self.assertEqual(first[0], second[0])
-            np.testing.assert_array_equal(first[1], second[1])
-            torch.testing.assert_close(first[2], second[2], rtol=0, atol=0)
-            self.assertTrue(torch.backends.cudnn.deterministic)
-            self.assertFalse(torch.backends.cudnn.benchmark)
-
-            seed_all(4321, cuda_deterministic=False)
-            self.assertNotEqual(first[0], random.random())
-            self.assertFalse(torch.backends.cudnn.deterministic)
-            self.assertTrue(torch.backends.cudnn.benchmark)
-        finally:
-            torch.backends.cudnn.deterministic = original_deterministic
-            torch.backends.cudnn.benchmark = original_benchmark
-
-
-class SequentialSamplerTests(unittest.TestCase):
-    def test_rank_chunks_recover_input_order_then_last_item_padding(self):
-        for size, batch_size, world_size in [(11, 2, 3), (2, 4, 3), (12, 2, 3)]:
-            with self.subTest(size=size, batch_size=batch_size, world_size=world_size):
-                shards = []
-                expected_length = math.ceil(size / (batch_size * world_size)) * batch_size
-                for rank in range(world_size):
-                    sampler = SequentialDistributedSampler(
-                        range(size), batch_size, world_size, rank=rank
-                    )
-                    shard = list(sampler)
-                    self.assertEqual(len(sampler), expected_length)
-                    self.assertEqual(len(shard), expected_length)
-                    self.assertEqual(len(shard) % batch_size, 0)
-                    self.assertEqual(shard, sorted(shard))
-                    shards.extend(shard)
-                self.assertEqual(shards[:size], list(range(size)))
-                self.assertEqual(shards[size:], [size - 1] * (len(shards) - size))
-
-    def test_empty_dataset_has_empty_shards(self):
-        for rank in range(3):
-            sampler = SequentialDistributedSampler([], 2, 3, rank=rank)
-            self.assertEqual(len(sampler), 0)
-            self.assertEqual(list(sampler), [])
-
-    def test_single_process_can_infer_rank_without_process_group(self):
-        sampler = SequentialDistributedSampler(range(3), 2, 1)
-        self.assertEqual(list(sampler), [0, 1, 2, 2])
-
-    def test_invalid_batch_world_size_and_rank_are_rejected(self):
-        for batch_size, world_size, rank in [(0, 1, 0), (-1, 1, 0), (2, 0, 0),
-                                              (2, -1, 0), (2, 2, -1), (2, 2, 2)]:
-            with self.subTest(batch_size=batch_size, world_size=world_size, rank=rank):
-                with self.assertRaises(ValueError):
-                    SequentialDistributedSampler(range(5), batch_size, world_size, rank=rank)
-
-
-class ReductionTests(unittest.TestCase):
-    def test_scalar_reduction_without_process_group(self):
-        self.assertAlmostEqual(get_reduced(2.75, "cpu", 0, 1), 2.75)
-        self.assertAlmostEqual(get_reduced(3, "cpu", 0, 1), 3.0)
-
-    def test_tensor_input_is_not_modified_or_attached_to_autograd(self):
-        value = torch.tensor(3.25, requires_grad=True)
-        original = value.detach().clone()
-        result = get_reduced(value, "cpu", 0, 1)
-        self.assertIsInstance(result, float)
-        self.assertEqual(result, 3.25)
-        torch.testing.assert_close(value.detach(), original, rtol=0, atol=0)
-        self.assertTrue(value.requires_grad)
-        self.assertIsNone(value.grad)
-
-
-class SchedulerTests(unittest.TestCase):
-    @staticmethod
-    def make_scheduler(**overrides):
-        parameter = torch.nn.Parameter(torch.tensor([1.0]))
-        optimizer = torch.optim.SGD([parameter], lr=0.02, momentum=0.9)
-        options = dict(first_cycle_steps=6, cycle_mult=2.0, max_lr=1.0,
-                       min_lr=0.0, warmup_steps=2, gamma=0.5)
-        options.update(overrides)
-        scheduler = CosineAnnealingWarmupRestarts(optimizer, **options)
-        return parameter, optimizer, scheduler
-
-    def assert_lr(self, optimizer, scheduler, expected):
-        for group in optimizer.param_groups:
-            self.assertAlmostEqual(group["lr"], expected, places=12)
-        self.assertEqual(scheduler.get_last_lr(), [group["lr"] for group in optimizer.param_groups])
-
-    def test_zero_warmup_starts_at_max_and_decays_before_restart(self):
-        _, optimizer, scheduler = self.make_scheduler(
-            first_cycle_steps=4, cycle_mult=1.0, warmup_steps=0
-        )
-        expected = [1.0, (1 + math.cos(math.pi / 4)) / 2, 0.5,
-                    (1 + math.cos(3 * math.pi / 4)) / 2, 0.5]
-        self.assert_lr(optimizer, scheduler, expected[0])
-        for target in expected[1:]:
-            optimizer.step()
-            scheduler.step()
-            self.assert_lr(optimizer, scheduler, target)
-
-    def test_warmup_and_restart_use_decayed_peak_and_longer_cycle(self):
-        _, optimizer, scheduler = self.make_scheduler()
-        expected = [0.0, 0.5, 1.0, (1 + math.cos(math.pi / 4)) / 2,
-                    0.5, (1 + math.cos(3 * math.pi / 4)) / 2, 0.0, 0.25, 0.5]
-        self.assert_lr(optimizer, scheduler, expected[0])
-        for target in expected[1:]:
-            optimizer.step()
-            scheduler.step()
-            self.assert_lr(optimizer, scheduler, target)
-        scheduler.step(16)
-        self.assert_lr(optimizer, scheduler, 0.0)
-        scheduler.step(18)
-        self.assert_lr(optimizer, scheduler, 0.25)
-
-    def test_explicit_epoch_and_incremental_steps_match_across_cycles(self):
-        for cycle_mult in (1.0, 1.5, 2.0):
-            for warmup_steps in (0, 2):
-                with self.subTest(cycle_mult=cycle_mult, warmup_steps=warmup_steps):
-                    options = dict(first_cycle_steps=5, cycle_mult=cycle_mult,
-                                   warmup_steps=warmup_steps)
-                    _, sequential_optimizer, sequential = self.make_scheduler(**options)
-                    _, explicit_optimizer, explicit = self.make_scheduler(**options)
-                    for step in range(41):
-                        if step:
-                            sequential_optimizer.step()
-                            sequential.step()
-                        explicit.step(step)
-                        self.assertAlmostEqual(
-                            sequential_optimizer.param_groups[0]["lr"],
-                            explicit_optimizer.param_groups[0]["lr"], places=12,
-                            msg=f"Schedules differ at step {step}",
-                        )
-                        self.assertEqual(sequential.get_last_lr(), explicit.get_last_lr())
-
-    def test_resume_restores_learning_rates_and_optimizer_trajectory(self):
-        options = dict(max_lr=0.1, min_lr=0.001, gamma=0.7)
-        parameter, optimizer, scheduler = self.make_scheduler(**options)
-
-        def update(parameter, optimizer, scheduler):
-            parameter.grad = torch.ones_like(parameter)
-            optimizer.step()
-            optimizer.zero_grad()
-            scheduler.step()
-            return optimizer.param_groups[0]["lr"], parameter.detach().clone()
-
-        for _ in range(13):
-            update(parameter, optimizer, scheduler)
-        saved_parameter = parameter.detach().clone()
-        optimizer_state = copy.deepcopy(optimizer.state_dict())
-        scheduler_state = copy.deepcopy(scheduler.state_dict())
-        expected = [update(parameter, optimizer, scheduler) for _ in range(12)]
-
-        resumed_parameter, resumed_optimizer, resumed_scheduler = self.make_scheduler(**options)
-        with torch.no_grad():
-            resumed_parameter.copy_(saved_parameter)
-        resumed_optimizer.load_state_dict(optimizer_state)
-        resumed_scheduler.load_state_dict(scheduler_state)
-        self.assertEqual(resumed_scheduler.get_last_lr(),
-                         [group["lr"] for group in resumed_optimizer.param_groups])
-        for expected_lr, expected_parameter in expected:
-            actual_lr, actual_parameter = update(resumed_parameter, resumed_optimizer, resumed_scheduler)
-            self.assertAlmostEqual(actual_lr, expected_lr, places=12)
-            torch.testing.assert_close(actual_parameter, expected_parameter, rtol=0, atol=0)
-
-
-class _CompiledLike(torch.nn.Module):
-    """Model the wrapper attribute exposed by torch.compile without compiling."""
-
-    def __init__(self, module):
-        super().__init__()
-        self._orig_mod = module
-
-
-class _ScalerState:
-    def state_dict(self):
-        return {"scale": 1024.0, "_growth_tracker": 7}
-
-
-class CheckpointTests(unittest.TestCase):
-    def test_checkpoint_schema_paths_and_unwrapped_model_parameters(self):
-        for use_wrappers in (False, True):
-            with self.subTest(use_wrappers=use_wrappers), tempfile.TemporaryDirectory() as temp_dir:
-                model = torch.nn.Linear(2, 1)
-                wrapped = _CompiledLike(torch.nn.DataParallel(model)) if use_wrappers else model
-                optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
-                scheduler = CosineAnnealingWarmupRestarts(
-                    optimizer, first_cycle_steps=4, max_lr=0.1, min_lr=0.001,
-                    warmup_steps=0,
-                )
-                optimizer.zero_grad()
-                model(torch.ones(1, 2)).sum().backward()
-                optimizer.step()
-                scheduler.step()
-                scaler = _ScalerState()
-                destination = Path(temp_dir) / "nested" / "checkpoints"
-                saved_path = save_scaler_ckpt(
-                    "epoch3", wrapped, optimizer, scheduler, scaler, 0.125,
-                    "tiny", str(destination),
-                )
-                self.assertIsInstance(saved_path, Path)
-                self.assertEqual(saved_path, destination / "tiny_epoch3.pth")
-                self.assertTrue(saved_path.is_file())
-                checkpoint = torch.load(saved_path, map_location="cpu", weights_only=True)
-                self.assertEqual(set(checkpoint), {
-                    "epoch", "model_state_dict", "optimizer_state_dict",
-                    "scheduler_state_dict", "scaler_state_dict", "losses",
-                })
-                self.assertEqual(checkpoint["epoch"], "epoch3")
-                self.assertEqual(checkpoint["losses"], 0.125)
-                self.assertEqual(checkpoint["scaler_state_dict"], scaler.state_dict())
-                self.assertEqual(checkpoint["scheduler_state_dict"], scheduler.state_dict())
-                self.assertEqual(checkpoint["optimizer_state_dict"]["param_groups"],
-                                 optimizer.state_dict()["param_groups"])
-                self.assertEqual(set(checkpoint["model_state_dict"]), {"weight", "bias"})
-                for name, expected in model.state_dict().items():
-                    torch.testing.assert_close(checkpoint["model_state_dict"][name], expected, rtol=0, atol=0)
-                loaded_model = torch.nn.Linear(2, 1)
-                loaded_model.load_state_dict(checkpoint["model_state_dict"], strict=True)
-                loaded_optimizer = torch.optim.SGD(loaded_model.parameters(), lr=0.9, momentum=0.9)
-                loaded_optimizer.load_state_dict(checkpoint["optimizer_state_dict"])
-                for original_parameter, loaded_parameter in zip(model.parameters(), loaded_model.parameters()):
-                    torch.testing.assert_close(
-                        loaded_optimizer.state[loaded_parameter]["momentum_buffer"],
-                        optimizer.state[original_parameter]["momentum_buffer"], rtol=0, atol=0,
-                    )
-
-
-if __name__ == "__main__":
-    unittest.main()

README.md

@@ -203,9 +203,6 @@ The drug-response and drug-combination workflows use validation metrics for
 checkpoint selection. Their validation results should not be presented as
 performance on an independent final test set.
 
-For checks of the shared training utilities, see
-[Training utility checks](BioMod/README.md#training-utility-checks).
-
 ## Repository layout
 
 The tree below includes source files, model dependencies, and the pretrained
@@ -243,8 +240,6 @@ BioMod/                                                        # Project root: s
 │   │   ├── README.md
 │   │   ├── train.py
 │   │   └── tutorial.ipynb
-│   ├── tests/                                                 # CPU tests for shared training utilities
-│   │   └── test_training_utils.py
 │   ├── zero_shot_batch/                                       # Zero-shot integration and evaluation
 │   │   ├── tools/                                             # Optional visualization and evaluation tools
 │   │   │   ├── sequencing_depth/                              # Low-depth expression generation and evaluation