Download annotations/annotation_32/test.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 11.6 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_32/test.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_32/test.py
-
curl -L -o test.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_32/test.py
11.6 kB
| import unittest | |
| import pandas as pd | |
| import numpy as np | |
| import numpy.testing as npt | |
| import os | |
| import itertools as it | |
| # Canonical impl | |
| from canonical import find_fair_ranking as canonical_find_fair_ranking | |
| from canonical import query as canonical_query | |
| # Generated impl | |
| from ranking_2d import find_fair_ranking as generated_find_fair_ranking | |
| from ranking_2d import query as generated_query | |
| # Utils provided in your project | |
| from utils import read_file, score, polartoscalar | |
| class TestRankingImplementations(unittest.TestCase): | |
| def setUpClass(cls): | |
| # A few reusable mini datasets to hit different code paths | |
| cls.datasets = {} | |
| # Balanced two-group dataset (n divisible by buckets) | |
| cls.datasets["balanced"] = pd.DataFrame({ | |
| "feature1": [10, 20, 30, 40, 50, 60, 70, 80], | |
| "feature2": [1, 2, 3, 4, 5, 6, 7, 8], | |
| "sensitive_attr": [0, 1, 0, 1, 0, 1, 0, 1] | |
| }) | |
| # Imbalanced two-group dataset (to test minority logic, ratios) | |
| cls.datasets["imbalanced"] = pd.DataFrame({ | |
| "feature1": [5, 7, 9, 11, 13, 15, 17, 19, 21], | |
| "feature2": [1, 1, 2, 3, 5, 8, 13, 21, 34], | |
| "sensitive_attr": [0, 0, 0, 0, 0, 1, 1, 1, 1] | |
| }) | |
| # Single-group dataset (forces comb(|g|, 2) path; 0 collisions if buckets=1) | |
| cls.datasets["single_group"] = pd.DataFrame({ | |
| "feature1": [1, 2, 3, 4, 5, 6], | |
| "feature2": [6, 5, 4, 3, 2, 1], | |
| "sensitive_attr": [1, 1, 1, 1, 1, 1] | |
| }) | |
| # Non-divisible bucket case (n % m != 0) — tail elements ignored by bucket_size | |
| cls.datasets["non_divisible"] = pd.DataFrame({ | |
| "feature1": [2, 4, 6, 8, 10, 12, 14], | |
| "feature2": [3, 1, 4, 1, 5, 9, 2], | |
| "sensitive_attr": [0, 1, 0, 1, 0, 1, 0] | |
| }) | |
| # String sensitive attribute values (exercise mapping) | |
| cls.datasets["string_group"] = pd.DataFrame({ | |
| "feature1": [100, 90, 80, 70, 60, 50], | |
| "feature2": [0, 1, 1, 2, 3, 5], | |
| "sensitive_attr": ["A", "A", "B", "B", "B", "A"] | |
| }) | |
| # Persist CSVs for path-based tests | |
| cls.csv_paths = {} | |
| for name, df in cls.datasets.items(): | |
| p = f"__tmp_{name}.csv" | |
| df.to_csv(p, index=False) | |
| cls.csv_paths[name] = p | |
| def tearDownClass(cls): | |
| for p in cls.csv_paths.values(): | |
| if os.path.exists(p): | |
| os.remove(p) | |
| # ---------- Helpers ---------- | |
| def _run_both_find(self, source, columns, sens, m): | |
| """Run find_fair_ranking in both impls and return tuples.""" | |
| c = canonical_find_fair_ranking(source, columns, sens, m) | |
| g = generated_find_fair_ranking(source, columns, sens, m) | |
| return c, g | |
| def _assert_find_equivalence(self, ctup, gtup, decimal=5): | |
| (c_disp, c_disp0, c_rank, c_theta, c_dur) = ctup | |
| (g_disp, g_disp0, g_rank, g_theta, g_dur) = gtup | |
| # Core numeric comparisons | |
| npt.assert_almost_equal(c_disp, c_disp, decimal) | |
| npt.assert_almost_equal(c_disp, g_disp, decimal, | |
| err_msg="Disparity mismatch") | |
| npt.assert_almost_equal(c_disp0, g_disp0, decimal, | |
| err_msg="Original disparity mismatch") | |
| npt.assert_almost_equal(c_theta, g_theta, decimal, | |
| err_msg="Theta mismatch") | |
| # Rankings: length and set equality (permutation) | |
| self.assertEqual(len(c_rank), len(g_rank), "Ranking length mismatch") | |
| self.assertEqual(set(c_rank), set(range(len(c_rank))), | |
| "Canonical ranking is not a permutation of 0..n-1") | |
| self.assertEqual(set(g_rank), set(range(len(g_rank))), | |
| "Generated ranking is not a permutation of 0..n-1") | |
| # Duration sanity (don’t require equality due to noise) | |
| self.assertIsInstance(c_dur, float) | |
| self.assertIsInstance(g_dur, float) | |
| self.assertGreaterEqual(c_dur, 0.0) | |
| self.assertGreaterEqual(g_dur, 0.0) | |
| def _prepare_query_inputs(self, source, columns, d, m): | |
| # Compute theta via canonical impl to build f and scores | |
| _, _, _, theta, _ = canonical_find_fair_ranking(source, columns, "sensitive_attr", m) | |
| dataset = read_file(source, columns) if isinstance(source, str) else source[columns].values.tolist() | |
| f = polartoscalar([theta], d) | |
| scores = sorted([score(dataset[i], f, d) for i in range(len(dataset))]) | |
| return f, scores, theta | |
| # ---------- Tests: find_fair_ranking parity across many shapes ---------- | |
| def test_find_fair_ranking_divisible_balanced(self): | |
| df = self.datasets["balanced"] | |
| columns = ["feature1", "feature2"] | |
| m = 4 # n=8, bucket_size=2 | |
| ctup, gtup = self._run_both_find(df, columns, "sensitive_attr", m) | |
| self._assert_find_equivalence(ctup, gtup) | |
| def test_find_fair_ranking_divisible_balanced_path(self): | |
| path = self.csv_paths["balanced"] | |
| columns = ["feature1", "feature2"] | |
| m = 4 | |
| ctup, gtup = self._run_both_find(path, columns, "sensitive_attr", m) | |
| self._assert_find_equivalence(ctup, gtup) | |
| def test_find_fair_ranking_imbalanced(self): | |
| df = self.datasets["imbalanced"] | |
| columns = ["feature1", "feature2"] | |
| # Try different bucket counts (including 1 and n) | |
| for m in [1, 3, len(df)]: | |
| with self.subTest(m=m): | |
| ctup, gtup = self._run_both_find(df, columns, "sensitive_attr", m) | |
| self._assert_find_equivalence(ctup, gtup) | |
| def test_find_fair_ranking_single_group(self): | |
| df = self.datasets["single_group"] | |
| columns = ["feature1", "feature2"] | |
| # Buckets=1 => trivial / all in one bucket | |
| for m in [1, 2, len(df)]: | |
| with self.subTest(m=m): | |
| ctup, gtup = self._run_both_find(df, columns, "sensitive_attr", m) | |
| self._assert_find_equivalence(ctup, gtup) | |
| def test_find_fair_ranking_non_divisible(self): | |
| df = self.datasets["non_divisible"] # n=7 | |
| columns = ["feature1", "feature2"] | |
| # m=3 => bucket_size=2, tail ignored in distribution loops | |
| for m in [3, 5]: | |
| with self.subTest(m=m): | |
| ctup, gtup = self._run_both_find(df, columns, "sensitive_attr", m) | |
| self._assert_find_equivalence(ctup, gtup) | |
| def test_find_fair_ranking_string_sensitive(self): | |
| df = self.datasets["string_group"] | |
| columns = ["feature1", "feature2"] | |
| for m in [2, 3, len(df)]: | |
| with self.subTest(m=m): | |
| ctup, gtup = self._run_both_find(df, columns, "sensitive_attr", m) | |
| self._assert_find_equivalence(ctup, gtup) | |
| # ---------- Tests: query parity and behaviors ---------- | |
| def test_query_parity_across_datasets(self): | |
| combos = [ | |
| ("balanced", 4), | |
| ("imbalanced", 3), | |
| ("single_group", 2), | |
| ("non_divisible", 3), | |
| ("string_group", 3), | |
| ] | |
| for name, m in combos: | |
| with self.subTest(dataset=name, buckets=m): | |
| source = self.datasets[name] | |
| columns = ["feature1", "feature2"] | |
| d = 2 | |
| f, scores, _ = self._prepare_query_inputs(source, columns, d, m) | |
| # Build a grid of queries around the data ranges | |
| df = source | |
| f1min, f1max = df["feature1"].min(), df["feature1"].max() | |
| f2min, f2max = df["feature2"].min(), df["feature2"].max() | |
| queries = [ | |
| [f1min, f2min], [f1max, f2max], | |
| [(f1min + f1max) / 2, (f2min + f2max) / 2], | |
| [f1min - 10, f2min - 10], # below range | |
| [f1max + 10, f2max + 10], # above range | |
| ] | |
| for q in queries: | |
| c_res = canonical_query(q, f, scores, d, m) | |
| g_res = generated_query(q, f, scores, d, m) | |
| npt.assert_equal(c_res, g_res, | |
| err_msg=f"Query mismatch for dataset={name}, q={q}, m={m}") | |
| def test_query_monotonicity_by_projection(self): | |
| # Larger projection should not map to a lower bucket | |
| name, m = "balanced", 4 | |
| source = self.datasets[name] | |
| columns = ["feature1", "feature2"] | |
| d = 2 | |
| f, scores, _ = self._prepare_query_inputs(source, columns, d, m) | |
| # Create pairs with increasing projection c | |
| pairs = [ | |
| ([10, 1], [80, 8]), | |
| ([15, 2], [60, 7]), | |
| ([20, 3], [50, 6]), | |
| ] | |
| for q_low, q_high in pairs: | |
| with self.subTest(low=q_low, high=q_high): | |
| # Compute projection explicitly to sanity check the ordering | |
| c_low = sum(f[j] * q_low[j] for j in range(d)) | |
| c_high = sum(f[j] * q_high[j] for j in range(d)) | |
| self.assertLessEqual(c_low, c_high, "Test data must have increasing projection") | |
| c_bucket_low = canonical_query(q_low, f, scores, d, m) | |
| c_bucket_high = canonical_query(q_high, f, scores, d, m) | |
| g_bucket_low = generated_query(q_low, f, scores, d, m) | |
| g_bucket_high = generated_query(q_high, f, scores, d, m) | |
| # Parity | |
| self.assertEqual(c_bucket_low, g_bucket_low) | |
| self.assertEqual(c_bucket_high, g_bucket_high) | |
| # Monotonicity (non-decreasing) | |
| self.assertLessEqual(c_bucket_low, c_bucket_high) | |
| def test_query_bucket_bounds_extremes(self): | |
| # Ensure extreme projections land in first/last bucket consistently | |
| name, m = "imbalanced", 3 | |
| source = self.datasets[name] | |
| columns = ["feature1", "feature2"] | |
| d = 2 | |
| f, scores, _ = self._prepare_query_inputs(source, columns, d, m) | |
| # Far below and above the data range along the same direction | |
| q_lo = [-1e6, -1e6] | |
| q_hi = [1e6, 1e6] | |
| c_lo = canonical_query(q_lo, f, scores, d, m) | |
| g_lo = generated_query(q_lo, f, scores, d, m) | |
| c_hi = canonical_query(q_hi, f, scores, d, m) | |
| g_hi = generated_query(q_hi, f, scores, d, m) | |
| self.assertEqual(c_lo, g_lo) | |
| self.assertEqual(c_hi, g_hi) | |
| # Buckets are 1-indexed in the canonical code | |
| self.assertGreaterEqual(c_lo, 1) | |
| self.assertIn(c_hi, [m, m+1]) | |
| # ---------- Robustness / sanity on output structure ---------- | |
| def test_find_returns_expected_tuple_shapes(self): | |
| for name, df in self.datasets.items(): | |
| with self.subTest(dataset=name): | |
| columns = ["feature1", "feature2"] | |
| m = max(1, min(5, len(df))) # keep it sane | |
| res = canonical_find_fair_ranking(df, columns, "sensitive_attr", m) | |
| self.assertIsInstance(res, tuple) | |
| self.assertEqual(len(res), 5) | |
| disp, disp0, ranking, theta, duration = res | |
| self.assertIsInstance(disp, (float, np.floating)) | |
| self.assertIsInstance(disp0, (float, np.floating, np.ndarray)) | |
| self.assertIsInstance(ranking, list) | |
| self.assertIsInstance(theta, (int, float, np.integer, np.floating)) | |
| self.assertIsInstance(duration, (float, np.floating)) | |
| if __name__ == "__main__": | |
| unittest.main(argv=["first-arg-is-ignored"], exit=False) | |