| |
| """ |
| quickstart.py -- Download GeoRSCT and verify you have good data. |
| |
| Run this once after cloning or downloading the dataset. It checks file |
| integrity, prints a summary of what you have, and runs a toy baseline |
| so you know the splits work end-to-end. |
| |
| Usage: |
| python quickstart.py # if files are in current dir |
| python quickstart.py --data-dir /path/to/dir # point to parquet location |
| |
| Prerequisites: |
| pip install pandas pyarrow scikit-learn |
| """ |
|
|
| import argparse |
| import hashlib |
| import sys |
| from pathlib import Path |
|
|
| import pandas as pd |
|
|
|
|
| def sha256_file(path: Path) -> str: |
| h = hashlib.sha256() |
| with open(path, "rb") as f: |
| for chunk in iter(lambda: f.read(8192), b""): |
| h.update(chunk) |
| return h.hexdigest() |
|
|
|
|
| def section(title: str) -> None: |
| print() |
| print(f"{'=' * 60}") |
| print(f" {title}") |
| print(f"{'=' * 60}") |
| print() |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description="GeoRSCT quickstart: verify and summarize") |
| parser.add_argument("--data-dir", type=str, default=".", |
| help="Directory containing geocert parquet files") |
| args = parser.parse_args() |
|
|
| data = Path(args.data_dir) |
| table_path = data / "georsct_table.parquet" |
| checksum_path = data / "georsct_checksums.sha256" |
| errors = [] |
|
|
| |
| section("1. FILE CHECK") |
| |
|
|
| expected_files = [ |
| "georsct_table.parquet", |
| "georsct_simplified_001.geoparquet", |
| "georsct_schema.json", |
| "build_manifest.json", |
| "georsct_checksums.sha256", |
| "load_georsct.py", |
| ] |
|
|
| for f in expected_files: |
| p = data / f |
| if p.exists(): |
| size = p.stat().st_size / (1024 * 1024) |
| print(f" [OK] {f:50s} {size:8.1f} MB") |
| else: |
| print(f" [MISS] {f}") |
| if f == "geocert_table.parquet": |
| errors.append(f"Missing required file: {f}") |
|
|
| |
| section("2. CHECKSUM VERIFICATION") |
| |
|
|
| if checksum_path.exists(): |
| expected = {} |
| for line in checksum_path.read_text().strip().split("\n"): |
| h, name = line.split(" ", 1) |
| expected[name] = h |
|
|
| for name, expect_hash in sorted(expected.items()): |
| p = data / name |
| if not p.exists(): |
| print(f" [SKIP] {name} (not found)") |
| continue |
| actual = sha256_file(p) |
| if actual == expect_hash: |
| print(f" [OK] {name}") |
| else: |
| print(f" [FAIL] {name}") |
| print(f" expected: {expect_hash[:24]}...") |
| print(f" got: {actual[:24]}...") |
| errors.append(f"Checksum mismatch: {name}") |
| else: |
| print(" [SKIP] No checksums file found") |
|
|
| |
| section("3. DATA SUMMARY") |
| |
|
|
| if not table_path.exists(): |
| print(" Cannot load data -- geocert_table.parquet not found.") |
| print() |
| print("ERRORS:", errors) |
| sys.exit(1) |
|
|
| df = pd.read_parquet(table_path) |
| df["zcta_id"] = df["zcta_id"].astype(str).str.zfill(5) |
|
|
| feat_cols = sorted(c for c in df.columns if c.startswith("acs_")) |
| tgt_cols = sorted(c for c in df.columns if c.startswith("target_")) |
|
|
| print(f" Rows: {len(df):,}") |
| print(f" Columns: {len(df.columns)}") |
| print(f" Features: {len(feat_cols)} (acs_*)") |
| print(f" Targets: {len(tgt_cols)} (target_*)") |
| print() |
|
|
| |
| if len(df) != 31789: |
| errors.append(f"Expected 31,789 rows, got {len(df)}") |
| print(f" [FAIL] Row count: {len(df)} (expected 31,789)") |
| else: |
| print(f" [OK] Row count: 31,789") |
|
|
| |
| if df["zcta_id"].is_unique: |
| print(f" [OK] ZCTA IDs: unique") |
| else: |
| errors.append("Duplicate ZCTA IDs") |
| print(f" [FAIL] ZCTA IDs: duplicates found") |
|
|
| |
| bad_acs = {} |
| for col in feat_cols: |
| if pd.api.types.is_numeric_dtype(df[col]): |
| n_neg = int((df[col] < 0).sum()) |
| if n_neg > 0: |
| bad_acs[col] = n_neg |
| if bad_acs: |
| print(f" [FAIL] ACS features: {sum(bad_acs.values())} bogus negatives in {len(bad_acs)} columns") |
| for col, n in bad_acs.items(): |
| print(f" {col}: {n}") |
| errors.append("Bogus negative ACS values -- run clean_acs_negatives.py") |
| else: |
| print(f" [OK] ACS features: no bogus negatives") |
|
|
| |
| section("4. COVERAGE") |
| |
|
|
| flags = ["has_cdc_places", "has_income", "has_home_value"] |
| for flag in flags: |
| n_true = int(df[flag].sum()) |
| n_false = len(df) - n_true |
| pct = n_true / len(df) * 100 |
| print(f" {flag:20s} True: {n_true:,} ({pct:.1f}%) False: {n_false:,}") |
|
|
| |
| section("5. TARGET SUMMARY") |
| |
|
|
| print(f" {'Target':<45s} {'NaN':>6s} {'Min':>10s} {'Max':>10s} {'Mean':>10s}") |
| print(f" {'-'*45} {'-'*6} {'-'*10} {'-'*10} {'-'*10}") |
| for col in tgt_cols: |
| n_nan = int(df[col].isna().sum()) |
| vals = df[col].dropna() |
| print(f" {col:<45s} {n_nan:>6d} {vals.min():>10.2f} {vals.max():>10.2f} {vals.mean():>10.2f}") |
|
|
| |
| section("6. SPLIT SANITY CHECK") |
| |
|
|
| protocols = { |
| "split_imputation": {"folds": ["valid1", "valid2", "valid3", "valid4", "valid5", "test"]}, |
| "split_extrapolation": {"folds": ["valid1", "valid2", "valid3", "valid4", "test"]}, |
| "split_superres": {"folds": ["valid", "test"]}, |
| } |
|
|
| for col, info in protocols.items(): |
| print(f" {col}:") |
| vc = df[col].value_counts().sort_index() |
| for val, cnt in vc.items(): |
| marker = "*" if val in info["folds"] else " " |
| print(f" {marker} {val:12s} {cnt:,} ZCTAs") |
|
|
| |
| n_nan = int(df[col].isna().sum()) |
| if n_nan > 0: |
| errors.append(f"{col} has {n_nan} NaN values") |
| print(f" [FAIL] {n_nan} NaN values") |
| print() |
|
|
| |
| section("7. TOY BASELINE (Ridge Regression)") |
| |
|
|
| try: |
| from sklearn.linear_model import Ridge |
| from sklearn.metrics import r2_score |
| import numpy as np |
|
|
| |
| target = "target_diabetes" |
| split_col = "split_imputation" |
|
|
| complete = df[df["has_cdc_places"] & df[feat_cols].notna().all(axis=1)].copy() |
|
|
| train = complete[~complete[split_col].isin(["valid1", "test"])] |
| val = complete[complete[split_col] == "valid1"] |
| test = complete[complete[split_col] == "test"] |
|
|
| X_train = train[feat_cols].values |
| y_train = train[target].values |
| X_val = val[feat_cols].values |
| y_val = val[target].values |
| X_test = test[feat_cols].values |
| y_test = test[target].values |
|
|
| |
| col_means = np.nanmean(X_train, axis=0) |
| for X in [X_train, X_val, X_test]: |
| for i in range(X.shape[1]): |
| mask = np.isnan(X[:, i]) |
| X[mask, i] = col_means[i] |
|
|
| model = Ridge(alpha=1.0) |
| model.fit(X_train, y_train) |
|
|
| r2_val = r2_score(y_val, model.predict(X_val)) |
| r2_test = r2_score(y_test, model.predict(X_test)) |
|
|
| print(f" Task: {target}") |
| print(f" Protocol: imputation (fold 1)") |
| print(f" Model: Ridge(alpha=1.0)") |
| print(f" Train: {len(train):,} ZCTAs") |
| print(f" Val: {len(val):,} ZCTAs -> R2 = {r2_val:.4f}") |
| print(f" Test: {len(test):,} ZCTAs -> R2 = {r2_test:.4f}") |
| print() |
|
|
| if r2_val > 0.3: |
| print(f" [OK] Baseline R2 > 0.3 -- data, splits, and features work end-to-end") |
| else: |
| print(f" [WARN] Low R2 -- expected > 0.3 for ridge on diabetes") |
|
|
| except ImportError: |
| print(" [SKIP] scikit-learn not installed (pip install scikit-learn)") |
| print(" Skipping toy baseline -- data checks above are sufficient.") |
|
|
| |
| section("RESULT") |
| |
|
|
| if errors: |
| print(f" ISSUES FOUND: {len(errors)}") |
| for e in errors: |
| print(f" - {e}") |
| print() |
| print(" Fix the issues above before using this data.") |
| sys.exit(1) |
| else: |
| print(" ALL CHECKS PASSED") |
| print() |
| print(" You're ready to go. Quick start:") |
| print() |
| print(" from load_geocert import load_geocert, get_split") |
| print() |
| print(' df = load_geocert("geocert_table.parquet")') |
| print(' train, val, test = get_split(df, protocol="imputation", fold=1)') |
| print() |
| print(' X_train = train[[c for c in train.columns if c.startswith("acs_")]]') |
| print(' y_train = train["target_diabetes"]') |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
