| from __future__ import annotations |
|
|
| import json |
| import unittest |
| from collections import Counter |
| from pathlib import Path |
|
|
| from barbet_bgd.generation import GenerationPlan, PRIMITIVES, _long_bucket, generate_record |
| from barbet_bgd.serializers import build_messages, serialize_target |
|
|
|
|
| ROOT = Path(__file__).resolve().parents[1] |
|
|
|
|
| class GenerationTests(unittest.TestCase): |
| @classmethod |
| def setUpClass(cls): |
| cls.config = json.loads((ROOT / "configs/selected_sft_1m.json").read_text(encoding="utf-8")) |
| cls.plan = GenerationPlan(cls.config) |
|
|
| def test_one_cycle_has_exact_configured_mixture(self): |
| counts = Counter(self.plan.position(i).primitive for i in range(100)) |
| self.assertEqual(counts, Counter(self.config["primitive_percent"])) |
| mixtures = Counter(self.plan.position(i).mixture_category for i in range(100)) |
| self.assertEqual(mixtures, Counter(self.config["mixture_percent"])) |
| serializers = Counter(self.plan.position(i).serializer for i in range(100)) |
| self.assertEqual(serializers, Counter(self.config["serializer_percent"])) |
| self.assertEqual(sum(self.plan.position(i).is_long_context for i in range(100)), 5) |
|
|
| def test_generation_is_deterministic(self): |
| for index in (0, 1, 19, 20, 99, 100, 979_999, 980_000, 989_999, 990_000): |
| self.assertEqual( |
| generate_record(self.config, self.plan, index), |
| generate_record(self.config, self.plan, index), |
| ) |
|
|
| def test_generation_does_not_depend_on_json_key_order(self): |
| sorted_config = json.loads( |
| json.dumps(self.config, ensure_ascii=False, sort_keys=True) |
| ) |
| sorted_plan = GenerationPlan(sorted_config) |
| for index in (0, 1, 99, 100, 500_000, 990_000): |
| self.assertEqual(self.plan.position(index), sorted_plan.position(index)) |
| self.assertEqual( |
| generate_record(self.config, self.plan, index), |
| generate_record(sorted_config, sorted_plan, index), |
| ) |
|
|
| def test_split_boundaries_do_not_break_source_group(self): |
| self.assertEqual(self.plan.position(979_999).split, "train") |
| self.assertEqual(self.plan.position(980_000).split, "validation") |
| self.assertEqual(self.plan.position(989_999).split, "validation") |
| self.assertEqual(self.plan.position(990_000).split, "test") |
| before = generate_record(self.config, self.plan, 979_999)["source_group"] |
| after = generate_record(self.config, self.plan, 980_000)["source_group"] |
| self.assertNotEqual(before, after) |
|
|
| def test_all_primitives_build_structured_targets(self): |
| seen = set() |
| for index in range(300): |
| record = generate_record(self.config, self.plan, index) |
| seen.add(record["primitive"]) |
| self.assertIn("decision", record["target"]) |
| self.assertIn("evidence", record["target"]) |
| self.assertIn("confidence_target", record["target"]) |
| self.assertIn("action", record["target"]) |
| self.assertEqual(record["language"][0], "zh-TW") |
| self.assertEqual(record["locale"], "zh-TW") |
| self.assertEqual(seen, set(PRIMITIVES)) |
|
|
| def test_each_hundred_long_records_has_exact_length_mix(self): |
| counts = Counter(_long_bucket(i, 50_000)[0] for i in range(100)) |
| self.assertEqual( |
| counts, |
| Counter({"0.5K-4K": 75, "4K-16K": 18, "16K-64K": 6, "64K-128K": 1}), |
| ) |
|
|
| def test_serializers_are_controlled_views(self): |
| target = generate_record(self.config, self.plan, 0)["target"] |
| for serializer in ("JSON", "FUNCTION_CALL", "COMPACT_TAGS", "KEY_VALUE"): |
| rendered = serialize_target(target, serializer) |
| self.assertIn("decision", rendered) |
| self.assertIn(str(target["decision"]), rendered) |
| messages = build_messages(generate_record(self.config, self.plan, 0)) |
| self.assertEqual([item["role"] for item in messages], ["system", "user", "assistant"]) |
|
|
|
|
| if __name__ == "__main__": |
| unittest.main() |
|
|
