""" User Profile Dataset Anonymization Script ========================================== Applies k-anonymity (k>=5) via generalization of quasi-identifiers: - Age: 5-year bins - Location/Hometown: province-level only - Height: 5cm bins Records that cannot satisfy k>=5 after generalization are suppressed. Output: Parquet file ready for Hugging Face Datasets. """ import numpy as np import pandas as pd import re import random from collections import Counter # ============================================================ # 1. Load and Parse # ============================================================ INPUT_PATH = "/Users/qingyihuang/proj/scd/user_profile_s_text.npy" OUTPUT_PATH = "/Users/qingyihuang/proj/scd/user_profile_anonymized.parquet" # Field names in the order they appear in the text FIELDS = [ "Gender", "Age", "Marital Status", "Location", "Educational Qualifications", "Height", "Car Purchase Situation", "Monthly Salary", "House Purchase Situation", "Constellation", "Nation", "Blood Group", "Smoking Habits", "Drinking Habits", "Exercise Habits", "Daily Schedule", "Housework Level", "Pet Liking Level", "Industry", "Company Type", "Hometown", "About Children", "Living With Parents", "Ranking At Home" ] def parse_record(text: str) -> dict: """Parse a single text record into a dict of field: value.""" record = {} # Match "Field: value" patterns (value ends at next comma+space+Capital or end) pattern = r'([A-Za-z ]+?):\s*(.+?)(?=,\s+[A-Z]|\.?$)' matches = re.findall(pattern, text) for field, value in matches: field = field.strip() value = value.strip().rstrip('.') record[field] = value return record print("Loading data...") raw_data = np.load(INPUT_PATH, allow_pickle=True).item() print(f" Total records: {len(raw_data)}") # Parse all records records = [] for key in raw_data: rec = parse_record(raw_data[key]) records.append(rec) df = pd.DataFrame(records) print(f" Parsed columns: {list(df.columns)}") print(f" Shape: {df.shape}") # ============================================================ # 2. Shuffle and Re-index (remove original IDs) # ============================================================ print("\nShuffling records and removing original IDs...") df = df.sample(frac=1, random_state=42).reset_index(drop=True) # ============================================================ # 3. Generalize Quasi-identifiers # ============================================================ print("\nGeneralizing quasi-identifiers...") def generalize_age(age_str: str) -> str: """Convert exact age to 5-year bin.""" try: age = int(age_str) lower = (age // 5) * 5 upper = lower + 4 return f"{lower}-{upper}" except (ValueError, TypeError): return "Unknown" def generalize_height(height_str: str) -> str: """Convert exact height to 5cm bin.""" try: # Extract numeric part (e.g., "167cm" -> 167) h = int(re.search(r'\d+', str(height_str)).group()) lower = (h // 5) * 5 upper = lower + 4 return f"{lower}-{upper}cm" except (ValueError, TypeError, AttributeError): return "Unknown" def generalize_location(loc_str: str) -> str: """Keep only province/region level (first word of multi-word locations).""" if pd.isna(loc_str) or loc_str in ("Unlimited", "abroad", "secrecy"): return loc_str if not pd.isna(loc_str) else "Unknown" # Chinese location format: "Province City" -> keep "Province" parts = str(loc_str).strip().split() if len(parts) >= 2: return parts[0] # Province only return loc_str # Already province-level # Apply generalizations df["Age"] = df["Age"].apply(generalize_age) df["Height"] = df["Height"].apply(generalize_height) df["Location"] = df["Location"].apply(generalize_location) df["Hometown"] = df["Hometown"].apply(generalize_location) print(" Age example values:", df["Age"].value_counts().head(5).to_dict()) print(" Height example values:", df["Height"].value_counts().head(5).to_dict()) print(" Location example values:", df["Location"].value_counts().head(5).to_dict()) # ============================================================ # 4. Replace "secrecy" with "Not disclosed" # ============================================================ print("\nReplacing 'secrecy' values...") secrecy_count = (df == "secrecy").sum().sum() df = df.replace("secrecy", "Not disclosed") print(f" Replaced {secrecy_count} 'secrecy' values") # ============================================================ # 5. K-Anonymity Check and Suppression # ============================================================ QUASI_IDENTIFIERS = ["Gender", "Age", "Location", "Height"] K_THRESHOLD = 5 print(f"\nChecking k-anonymity (k>={K_THRESHOLD}) on {QUASI_IDENTIFIERS}...") def compute_k_anonymity(dataframe, qi_cols): """Compute k-anonymity statistics.""" groups = dataframe.groupby(qi_cols, dropna=False).size() return groups # First pass: check k-anonymity after generalization groups = compute_k_anonymity(df, QUASI_IDENTIFIERS) below_k = groups[groups < K_THRESHOLD] above_k = groups[groups >= K_THRESHOLD] print(f" Total equivalence classes: {len(groups)}") print(f" Classes with k>={K_THRESHOLD}: {len(above_k)} ({above_k.sum()} records)") print(f" Classes with k<{K_THRESHOLD}: {len(below_k)} ({below_k.sum()} records)") # Second pass: for groups below k, try further generalization # Strategy: widen age bins to 10 years for problematic records if len(below_k) > 0: print(f"\n Applying secondary generalization for {below_k.sum()} at-risk records...") # Identify rows in below-k groups below_k_keys = set(below_k.index.tolist()) def row_in_below_k(row): key = tuple(row[col] for col in QUASI_IDENTIFIERS) return key in below_k_keys mask = df.apply(row_in_below_k, axis=1) # For these rows, widen age to 10-year bins def widen_age_bin(age_bin: str) -> str: """Convert 5-year bin to 10-year bin.""" try: lower = int(age_bin.split("-")[0]) new_lower = (lower // 10) * 10 new_upper = new_lower + 9 return f"{new_lower}-{new_upper}" except (ValueError, IndexError): return age_bin df.loc[mask, "Age"] = df.loc[mask, "Age"].apply(widen_age_bin) # Recheck k-anonymity groups2 = compute_k_anonymity(df, QUASI_IDENTIFIERS) below_k2 = groups2[groups2 < K_THRESHOLD] print(f" After widening age bins:") print(f" Classes still below k: {len(below_k2)} ({below_k2.sum()} records)") # Third pass: for still-problematic records, also widen Height to 10cm bins if len(below_k2) > 0: print(f"\n Applying tertiary generalization: widening Height bins to 10cm...") below_k2_keys = set(below_k2.index.tolist()) def row_in_below_k2(row): key = tuple(row[col] for col in QUASI_IDENTIFIERS) return key in below_k2_keys mask2 = df.apply(row_in_below_k2, axis=1) def widen_height_bin(h_bin: str) -> str: """Convert 5cm bin to 10cm bin.""" try: lower = int(re.search(r'\d+', h_bin).group()) new_lower = (lower // 10) * 10 new_upper = new_lower + 9 return f"{new_lower}-{new_upper}cm" except (ValueError, AttributeError): return h_bin df.loc[mask2, "Height"] = df.loc[mask2, "Height"].apply(widen_height_bin) # Recheck groups3 = compute_k_anonymity(df, QUASI_IDENTIFIERS) below_k3 = groups3[groups3 < K_THRESHOLD] print(f" Classes still below k: {len(below_k3)} ({below_k3.sum()} records)") # Fourth pass: for remaining, generalize Location to region if len(below_k3) > 0: print(f"\n Applying quaternary generalization: Location -> region...") REGION_MAP = { "Beijing": "North China", "Tianjin": "North China", "Hebei": "North China", "Shanxi": "North China", "Inner Mongolia": "North China", "Liaoning": "Northeast", "Jilin": "Northeast", "Heilongjiang": "Northeast", "Shanghai": "East China", "Jiangsu": "East China", "Zhejiang": "East China", "Anhui": "East China", "Fujian": "East China", "Jiangxi": "East China", "Shandong": "East China", "Henan": "Central China", "Hubei": "Central China", "Hunan": "Central China", "Guangdong": "South China", "Guangxi": "South China", "Hainan": "South China", "Chongqing": "Southwest", "Sichuan": "Southwest", "Guizhou": "Southwest", "Yunnan": "Southwest", "Tibet": "Southwest", "Shaanxi": "Northwest", "Gansu": "Northwest", "Qinghai": "Northwest", "Ningxia": "Northwest", "Xinjiang": "Northwest", "Hong Kong": "South China", "Macao": "South China", "Taiwan": "East China", } below_k3_keys = set(below_k3.index.tolist()) def row_in_below_k3(row): key = tuple(row[col] for col in QUASI_IDENTIFIERS) return key in below_k3_keys mask3 = df.apply(row_in_below_k3, axis=1) df.loc[mask3, "Location"] = df.loc[mask3, "Location"].apply( lambda x: REGION_MAP.get(x, x) ) df.loc[mask3, "Hometown"] = df.loc[mask3, "Hometown"].apply( lambda x: REGION_MAP.get(x, x) ) # Final recheck groups4 = compute_k_anonymity(df, QUASI_IDENTIFIERS) below_k4 = groups4[groups4 < K_THRESHOLD] print(f" Classes still below k: {len(below_k4)} ({below_k4.sum()} records)") # Suppress any remaining if len(below_k4) > 0: below_k4_keys = set(below_k4.index.tolist()) def row_still_below_k(row): key = tuple(row[col] for col in QUASI_IDENTIFIERS) return key in below_k4_keys suppress_mask = df.apply(row_still_below_k, axis=1) n_suppressed = suppress_mask.sum() df = df[~suppress_mask].reset_index(drop=True) print(f" Suppressed (removed) {n_suppressed} records ({n_suppressed/len(raw_data)*100:.2f}%)") # Final k-anonymity verification print("\n=== Final k-anonymity verification ===") final_groups = compute_k_anonymity(df, QUASI_IDENTIFIERS) final_min_k = final_groups.min() final_below_k = final_groups[final_groups < K_THRESHOLD] print(f" Final dataset size: {len(df)} records") print(f" Minimum k: {final_min_k}") print(f" Groups below k={K_THRESHOLD}: {len(final_below_k)}") print(f" All groups satisfy k>={K_THRESHOLD}: {len(final_below_k) == 0}") # ============================================================ # 6. Export to Parquet # ============================================================ print(f"\nExporting to {OUTPUT_PATH}...") df.to_parquet(OUTPUT_PATH, index=False, engine="pyarrow") print(f" Done! File size: {pd.io.common.file_exists(OUTPUT_PATH)}") # ============================================================ # 7. Summary Statistics # ============================================================ print("\n" + "=" * 60) print("ANONYMIZATION SUMMARY") print("=" * 60) print(f" Original records: {len(raw_data)}") print(f" Final records: {len(df)}") print(f" Records removed: {len(raw_data) - len(df)} ({(len(raw_data)-len(df))/len(raw_data)*100:.2f}%)") print(f" Minimum k: {final_min_k}") print(f" Output format: Parquet") print(f" Output path: {OUTPUT_PATH}") print() print("Field distributions after anonymization:") print("-" * 40) for col in QUASI_IDENTIFIERS: print(f"\n {col}:") vc = df[col].value_counts().head(10) for val, cnt in vc.items(): print(f" {val}: {cnt}")