Upload alea/gen_kaggle_reg.py with huggingface_hub

alea/gen_kaggle_reg.py

@@ -0,0 +1,332 @@
+"""Real-data REGRESSION families — empirical conditional quantile targets.
+
+Each row is a real record from a Kaggle tabular regression dataset
+serialized WITHOUT its label (compact feature JSON). The regress target
+is the empirical conditional distribution of the label given the record's
+strongest covariates, estimated by grouped binning: the 19 quantiles at
+taus .05-.95 come from the bin's own sample (linear interpolation). Bins
+with < MIN_N members fall back along a coarsening chain — drop the weakest
+conditioning feature, then the next, ending at the global marginal — so
+targets are always honest empirical conditionals, never fabricated.
+
+~30% of rows add a noul "is y above X?" with X a round number near the bin
+median (target = exact P(y>X|bin) off the empirical CDF); ~20% add a
+choice over value bands (target = empirical conditional over the bands).
+
+CSV files are loaded once each and cached at module level (lazy on first
+family call so `gen_all --list` stays cheap).
+"""
+import json
+import random
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+from alea.genbase import (generate, emit, q_choice, q_noul, q_score,
+                          q_regress, validate_row, write_jsonl)
+
+rng = random.Random()
+
+KAGGLE = Path(__file__).resolve().parents[1] / "data" / "kaggle"
+TAUS = [0.05 * (i + 1) for i in range(19)]
+MIN_N = 20      # smallest trusted bin; below -> coarser conditioning
+P_NOUL = 0.30   # share of rows that also carry a threshold noul
+P_BAND = 0.20   # share of rows that also carry a band choice
+
+
+# ---------- empirical-conditional machinery ----------
+def _build(df, bin_cols, y_col):
+    """Return (keys, levels): keys[i] is the full bin tuple of row i;
+    levels[L] maps a length-L key prefix to the sorted label sample of
+    that bin. levels[0][()] is the global marginal."""
+    y = df[y_col].to_numpy(dtype=float)
+    keys = list(zip(*[df[c].tolist() for c in bin_cols]))
+    levels = {0: {(): np.sort(y)}}
+    for L in range(1, len(bin_cols) + 1):
+        d = {}
+        for k, v in zip(keys, y):
+            d.setdefault(k[:L], []).append(v)
+        levels[L] = {k: np.sort(np.asarray(v)) for k, v in d.items()}
+    return keys, levels
+
+
+def _sample(levels, key, min_n=MIN_N):
+    """Sorted label sample of the finest trusted bin along key's prefix
+    chain: full key -> drop weakest feature -> ... -> global marginal."""
+    for L in range(len(key), 0, -1):
+        arr = levels[L].get(tuple(key[:L]))
+        if arr is not None and len(arr) >= min_n:
+            return arr
+    return levels[0][()]
+
+
+def _q19(arr):
+    """19 empirical quantiles at TAUS, linear interpolation, 3 decimals."""
+    return [round(float(v), 3) for v in np.quantile(arr, TAUS)]
+
+
+def _cdf_gt(arr, x):
+    """Empirical P(y > x): one minus the sample fraction <= x."""
+    return float(1.0 - np.searchsorted(arr, x, side="right") / len(arr))
+
+
+def _band_probs(arr, edges):
+    """Empirical P(y in band) over (-inf,e0),[e0,e1),...,[eK,+inf)."""
+    c = [float(np.searchsorted(arr, e, side="right")) / len(arr)
+         for e in edges]
+    ps, prev = [], 0.0
+    for x in c + [1.0]:
+        ps.append(max(0.0, x - prev))
+        prev = x
+    s = sum(ps) or 1.0
+    ps = [round(p / s, 4) for p in ps]
+    ps[-1] = round(max(0.0, 1.0 - sum(ps[:-1])), 4)
+    return ps
+
+
+def _near(x, step):
+    """Round number within about one step of x."""
+    return int(round(x / step)) * step + rng.choice([-1, 0, 0, 0, 1]) * step
+
+
+def _num(v, nd=1):
+    """Compact float for state JSON: drop trailing .0, cap decimals."""
+    f = round(float(v), nd)
+    i = int(f)
+    return i if f == i else f
+
+
+# ---------- dataset loaders (module-level cache) ----------
+_CACHE = {}
+
+
+def _house_data():
+    if "house" not in _CACHE:
+        df = pd.read_csv(KAGGLE / "house" / "kc_house_data.csv")
+        df["_sqft"] = pd.qcut(df["sqft_living"], 10, labels=False,
+                              duplicates="drop")
+        df["_grade"] = pd.cut(df["grade"], [0, 6, 8, 10, 13], labels=False)
+        keys, lv = _build(df, ["_sqft", "_grade"], "price")
+        _CACHE["house"] = (df, keys, lv)
+    return _CACHE["house"]
+
+
+def _ins_data():
+    if "ins" not in _CACHE:
+        df = pd.read_csv(KAGGLE / "insurance" / "insurance.csv")
+        df["_bmi"] = pd.cut(df["bmi"], [0, 25, 30, np.inf], labels=False)
+        df["_age"] = pd.cut(df["age"], [0, 30, 45, np.inf], labels=False)
+        keys, lv = _build(df, ["smoker", "_bmi", "_age"], "charges")
+        _CACHE["ins"] = (df, keys, lv)
+    return _CACHE["ins"]
+
+
+def _housing_data():
+    if "housing" not in _CACHE:
+        df = pd.read_csv(KAGGLE / "housing" / "Housing.csv")
+        df["_area"] = pd.qcut(df["area"], 5, labels=False,
+                              duplicates="drop")
+        keys, lv = _build(df, ["_area", "furnishingstatus"], "price")
+        _CACHE["housing"] = (df, keys, lv)
+    return _CACHE["housing"]
+
+
+LIFE_FEATS = ["Adult Mortality", "infant deaths", "Alcohol", "BMI",
+              "under-five deaths", "Polio", "Diphtheria", "HIV/AIDS", "GDP",
+              "Income composition of resources", "Schooling"]
+
+
+def _life_data():
+    if "life" not in _CACHE:
+        df = pd.read_csv(KAGGLE / "life_exp" / "Life Expectancy Data.csv")
+        df.columns = [c.strip() for c in df.columns]  # stray spaces
+        df = df.dropna(subset=["Life expectancy"]).reset_index(drop=True)
+        for c in LIFE_FEATS:
+            df[c] = df[c].fillna(df[c].median())
+        df["_am"] = pd.qcut(df["Adult Mortality"], 4, labels=False,
+                            duplicates="drop")
+        df["_sch"] = pd.qcut(df["Schooling"], 4, labels=False,
+                             duplicates="drop")
+        keys, lv = _build(df, ["Status", "_am", "_sch"], "Life expectancy")
+        _CACHE["life"] = (df, keys, lv)
+    return _CACHE["life"]
+
+
+# ---------- families ----------
+HOUSE_INSTR = [
+    "Estimate the distribution of this home's sale price.",
+    "What sale price will this King County property fetch?",
+    "Predict the final selling price of this house.",
+]
+HOUSE_NOUL = ["Is the sale price above ${x:,}?",
+              "Will the home sell for more than ${x:,}?"]
+
+
+def gen_kc_house_price():
+    df, keys, lv = _house_data()
+    i = rng.randrange(len(df))
+    r = df.iloc[i]
+    arr = _sample(lv, keys[i])
+    state = json.dumps({
+        "bedrooms": int(r["bedrooms"]),
+        "bathrooms": float(r["bathrooms"]),
+        "sqft_living": int(r["sqft_living"]),
+        "sqft_lot": int(r["sqft_lot"]),
+        "floors": float(r["floors"]),
+        "waterfront": int(r["waterfront"]),
+        "view": int(r["view"]),
+        "condition": int(r["condition"]),
+        "grade": int(r["grade"]),
+        "yr_built": int(r["yr_built"]),
+        "zipcode": str(r["zipcode"])}, separators=(",", ":"))
+    qs = [q_regress("price", rng.choice(HOUSE_INSTR), _q19(arr),
+                    unit="dollars")]
+    if rng.random() < P_NOUL:
+        thr = _near(arr[len(arr) // 2], 50000)
+        qs.append(q_noul("above", rng.choice(HOUSE_NOUL).format(x=thr),
+                         _cdf_gt(arr, thr)))
+    if rng.random() < P_BAND:
+        qs.append(q_choice(
+            "band", "Which band does the sale price fall in?",
+            ["under $200k", "$200k-$400k", "$400k-$800k", "over $800k"],
+            _band_probs(arr, [200000, 400000, 800000])))
+    return state, qs
+
+
+INS_INSTR = [
+    "Estimate the distribution of annual medical charges for this person.",
+    "What will this policyholder's medical insurance charges be?",
+    "Predict the yearly insurance charges for this individual.",
+]
+INS_NOUL = ["Are the charges above ${x:,}?",
+            "Will the medical charges exceed ${x:,}?"]
+
+
+def gen_insurance_charges():
+    df, keys, lv = _ins_data()
+    i = rng.randrange(len(df))
+    r = df.iloc[i]
+    arr = _sample(lv, keys[i])
+    state = json.dumps({
+        "age": int(r["age"]), "sex": r["sex"], "bmi": _num(r["bmi"]),
+        "children": int(r["children"]), "smoker": r["smoker"],
+        "region": r["region"]}, separators=(",", ":"))
+    qs = [q_regress("charges", rng.choice(INS_INSTR), _q19(arr),
+                    unit="dollars")]
+    if rng.random() < P_NOUL:
+        thr = _near(arr[len(arr) // 2], 5000)
+        qs.append(q_noul("above", rng.choice(INS_NOUL).format(x=thr),
+                         _cdf_gt(arr, thr)))
+    if rng.random() < P_BAND:
+        qs.append(q_choice(
+            "band", "Which band do the annual charges fall in?",
+            ["under $5k", "$5k-$15k", "$15k-$30k", "over $30k"],
+            _band_probs(arr, [5000, 15000, 30000])))
+    return state, qs
+
+
+HOUSING_INSTR = [
+    "Estimate the distribution of this home's asking price.",
+    "What price will this house sell for?",
+    "Predict the sale price of this property.",
+]
+HOUSING_NOUL = ["Is the asking price above ${x:,}?",
+                "Will the price exceed ${x:,}?"]
+
+
+def gen_housing_price():
+    df, keys, lv = _housing_data()
+    i = rng.randrange(len(df))
+    r = df.iloc[i]
+    arr = _sample(lv, keys[i])
+    state = json.dumps({
+        "area": int(r["area"]), "bedrooms": int(r["bedrooms"]),
+        "bathrooms": int(r["bathrooms"]), "stories": int(r["stories"]),
+        "mainroad": r["mainroad"], "guestroom": r["guestroom"],
+        "basement": r["basement"],
+        "hotwaterheating": r["hotwaterheating"],
+        "airconditioning": r["airconditioning"],
+        "parking": int(r["parking"]), "prefarea": r["prefarea"],
+        "furnishingstatus": r["furnishingstatus"]},
+        separators=(",", ":"))
+    qs = [q_regress("price", rng.choice(HOUSING_INSTR), _q19(arr),
+                    unit="dollars")]
+    if rng.random() < P_NOUL:
+        thr = _near(arr[len(arr) // 2], 500000)
+        qs.append(q_noul("above", rng.choice(HOUSING_NOUL).format(x=thr),
+                         _cdf_gt(arr, thr)))
+    if rng.random() < P_BAND:
+        qs.append(q_choice(
+            "band", "Which price band does this home fall in?",
+            ["under $3.5M", "$3.5M-$5M", "$5M-$7M", "over $7M"],
+            _band_probs(arr, [3500000, 5000000, 7000000])))
+    return state, qs
+
+
+LIFE_INSTR = [
+    "Estimate the distribution of life expectancy for this country-year.",
+    "What life expectancy at birth would you predict under these "
+    "conditions?",
+    "Predict the life expectancy for this country and year.",
+]
+LIFE_NOUL = ["Is life expectancy above {x} years?",
+             "Will life expectancy exceed {x} years?"]
+
+
+def gen_life_expectancy():
+    df, keys, lv = _life_data()
+    i = rng.randrange(len(df))
+    r = df.iloc[i]
+    arr = _sample(lv, keys[i])
+    state = json.dumps({
+        "Country": r["Country"], "Year": int(r["Year"]),
+        "Status": r["Status"],
+        "Adult Mortality": _num(r["Adult Mortality"], 0),
+        "infant deaths": _num(r["infant deaths"], 0),
+        "Alcohol": _num(r["Alcohol"], 2),
+        "BMI": _num(r["BMI"]),
+        "under-five deaths": _num(r["under-five deaths"], 0),
+        "Polio": _num(r["Polio"]),
+        "Diphtheria": _num(r["Diphtheria"]),
+        "HIV/AIDS": _num(r["HIV/AIDS"]),
+        "GDP": _num(r["GDP"], 0),
+        "Income composition": _num(r["Income composition of resources"], 2),
+        "Schooling": _num(r["Schooling"])}, separators=(",", ":"))
+    qs = [q_regress("lifexp", rng.choice(LIFE_INSTR), _q19(arr),
+                    unit="years")]
+    if rng.random() < P_NOUL:
+        thr = _near(arr[len(arr) // 2], 5)
+        qs.append(q_noul("above", rng.choice(LIFE_NOUL).format(x=thr),
+                         _cdf_gt(arr, thr)))
+    if rng.random() < P_BAND:
+        qs.append(q_choice(
+            "band", "Which life-expectancy band applies?",
+            ["under 60 years", "60-70 years", "70-77 years",
+             "over 77 years"],
+            _band_probs(arr, [60, 70, 77])))
+    return state, qs
+
+
+FAMILIES = {"kc_house_price": gen_kc_house_price,
+            "insurance_charges": gen_insurance_charges,
+            "housing_price": gen_housing_price,
+            "life_expectancy": gen_life_expectancy}
+WEIGHTS = {"kc_house_price": 0.30, "insurance_charges": 0.25,
+           "housing_price": 0.15, "life_expectancy": 0.30}
+
+
+def make_rows(n, seed):
+    return generate(FAMILIES, WEIGHTS, n, seed, rng)
+
+
+if __name__ == "__main__":
+    rows = make_rows(10, 0)
+    for r in rows:
+        validate_row(r)
+    for r in rows[:3]:
+        print(r["id"], "|", r["state"][:120])
+        for qid, t in r["targets"].items():
+            print("   ", qid, r["questions"][qid]["type"],
+                  t[:6] if isinstance(t, list) else t)
+    print(f"{len(rows)} rows OK")