| from __future__ import annotations | |
| import argparse | |
| import tempfile | |
| from collections import Counter | |
| from pathlib import Path | |
| import unittest | |
| from unittest.mock import patch | |
| MISSING_DEPENDENCY: str | None = None | |
| try: | |
| import numpy as np | |
| import pandas as pd | |
| import torch | |
| from PIL import Image | |
| from milk10k_effb2_metadata.data import ( | |
| HybridEpochSampler, | |
| PairedMilk10kMetadataDataset, | |
| hybrid_target_counts, | |
| ) | |
| from milk10k_effb2_metadata.training import validate_balance_args | |
| from milk10k_effb2_metadata.runner import append_augmented_train_rows | |
| except ModuleNotFoundError as exc: # pragma: no cover - local minimal env may omit ML deps. | |
| MISSING_DEPENDENCY = exc.name | |
| def balance_args(**overrides): | |
| values = { | |
| "balance_mode": "hybrid", | |
| "weighted_sampler": False, | |
| "balance_head_ratio": 2.0, | |
| "balance_tail_floor": 100, | |
| "balance_min_source_count": 20, | |
| } | |
| values.update(overrides) | |
| return argparse.Namespace(**values) | |
| class HybridBalanceTest(unittest.TestCase): | |
| def setUp(self) -> None: | |
| # BCC=250, NV=100, INF=40, MAL_OTH=9. | |
| self.labels = [0] * 250 + [1] * 100 + [2] * 40 + [3] * 9 | |
| self.targets, self.strong_labels = hybrid_target_counts(self.labels, balance_args()) | |
| def test_targets_cap_head_oversample_tail_and_leave_ultra_rare_alone(self) -> None: | |
| self.assertEqual(self.targets.tolist(), [200, 100, 100, 9]) | |
| self.assertEqual(self.strong_labels, {2}) | |
| def test_sampler_has_expected_counts_and_only_tail_duplicates(self) -> None: | |
| sampler = HybridEpochSampler(self.labels, self.targets, seed=42) | |
| indices = list(sampler) | |
| sampled_labels = Counter(self.labels[index] for index in indices) | |
| self.assertEqual(sampled_labels, Counter({0: 200, 1: 100, 2: 100, 3: 9})) | |
| bcc_indices = [index for index in indices if self.labels[index] == 0] | |
| inf_indices = [index for index in indices if self.labels[index] == 2] | |
| self.assertEqual(len(bcc_indices), len(set(bcc_indices))) | |
| self.assertLess(len(set(inf_indices)), len(inf_indices)) | |
| def test_sampler_is_reproducible_and_changes_head_subset_by_epoch(self) -> None: | |
| first = HybridEpochSampler(self.labels, self.targets, seed=7) | |
| second = HybridEpochSampler(self.labels, self.targets, seed=7) | |
| first.set_epoch(3) | |
| second.set_epoch(3) | |
| self.assertEqual(list(first), list(second)) | |
| epoch_three = set(index for index in first if self.labels[index] == 0) | |
| first.set_epoch(4) | |
| epoch_four = set(index for index in first if self.labels[index] == 0) | |
| self.assertNotEqual(epoch_three, epoch_four) | |
| def test_dataset_routes_only_tail_to_strong_transform(self) -> None: | |
| with tempfile.TemporaryDirectory() as tmp: | |
| image_path = Path(tmp) / "image.png" | |
| Image.new("RGB", (4, 4), color=(10, 20, 30)).save(image_path) | |
| rows = [] | |
| for label in ("BCC", "INF"): | |
| rows.append( | |
| { | |
| "lesion_id": label, | |
| "label": label, | |
| "clinical_path": str(image_path), | |
| "dermoscopic_path": str(image_path), | |
| "clinical_age_approx": 50, | |
| "dermoscopic_age_approx": 50, | |
| "clinical_skin_tone_class": 2, | |
| "dermoscopic_skin_tone_class": 2, | |
| "clinical_sex": "unknown", | |
| "dermoscopic_sex": "unknown", | |
| "clinical_site": "unknown", | |
| "dermoscopic_site": "unknown", | |
| } | |
| ) | |
| spec = {"sex_values": ["unknown"], "site_values": ["unknown"], "monet_columns": []} | |
| regular = lambda image: torch.zeros(3, image.height, image.width) | |
| strong = lambda image: torch.ones(3, image.height, image.width) | |
| dataset = PairedMilk10kMetadataDataset( | |
| pd.DataFrame(rows), | |
| {"BCC": 0, "INF": 1}, | |
| spec, | |
| regular, | |
| strong_transform=strong, | |
| strong_augment_labels={1}, | |
| ) | |
| self.assertTrue(torch.equal(dataset[0]["clinical"], torch.zeros(3, 4, 4))) | |
| self.assertTrue(torch.equal(dataset[1]["clinical"], torch.ones(3, 4, 4))) | |
| self.assertTrue(torch.equal(dataset[1]["dermoscopic"], torch.ones(3, 4, 4))) | |
| def test_balance_argument_validation(self) -> None: | |
| validate_balance_args(balance_args()) | |
| with self.assertRaisesRegex(ValueError, "weighted-sampler"): | |
| validate_balance_args(balance_args(weighted_sampler=True)) | |
| with self.assertRaisesRegex(ValueError, "head-ratio"): | |
| validate_balance_args(balance_args(balance_head_ratio=0)) | |
| with self.assertRaisesRegex(ValueError, "tail-floor"): | |
| validate_balance_args(balance_args(balance_tail_floor=-1)) | |
| with self.assertRaisesRegex(ValueError, "min-source-count"): | |
| validate_balance_args(balance_args(balance_min_source_count=0)) | |
| def test_augmented_rows_are_filtered_by_original_train_source(self) -> None: | |
| base = pd.DataFrame({"lesion_id": ["TRAIN", "VAL"], "label": ["A", "A"]}) | |
| train = base.iloc[[0]].copy() | |
| val = base.iloc[[1]].copy() | |
| augmented = pd.DataFrame( | |
| { | |
| "lesion_id": ["TRAIN__sdpair_000", "VAL__sdpair_000"], | |
| "label": ["A", "A"], | |
| "is_augmented": [True, True], | |
| "ignore_metadata": [False, False], | |
| } | |
| ) | |
| args = argparse.Namespace( | |
| augmented_data_dir=Path("augmented"), | |
| augmented_max_per_class=0, | |
| zero_augmented_metadata=False, | |
| seed=42, | |
| ) | |
| with patch("milk10k_effb2_metadata.runner.load_augmented_subset", return_value=augmented): | |
| result = append_augmented_train_rows(base, train, val, ["A"], args) | |
| self.assertEqual(result["lesion_id"].tolist(), ["TRAIN", "TRAIN__sdpair_000"]) | |
| if __name__ == "__main__": | |
| unittest.main() | |