Grok 4.1 Fast· xai
Frontier Reasoning Traces
Create a data anonymization library with k-anon, l-diversity, and DP.
- User
Create a data anonymization library with k-anon, l-diversity, and DP.
- Assistant
import pandas as pd import numpy as np import pandas.api.types as pd_types from typing import List, Optional import warnings class DataAnonymizer: """ A simple data anonymization library supporting k-Anonymity (via sorted microaggregation), l-Diversity (via suppression), and Differential Privacy (Laplace/Gaussian mechanisms). Usage: anonymizer = DataAnonymizer(df) anonymizer.apply_k_anonymity(['age', 'zipcode'], k=5) anonymizer.apply_l_diversity(['age', 'zipcode'], sensitive='disease', l=2) anonymizer.apply_differential_privacy(['salary'], epsilon=1.0, sensitivity=1000.0) print(anonymizer.df) print("K-Anon satisfied:", anonymizer.is_k_anonymous(['age', 'zipcode'], 5)) """ def __init__(self, df: pd.DataFrame): self.original_df = df.copy() self.df = df.copy() def _mode_transform(self, x): """Safe mode transformation.""" if x.empty or x.isna().all(): return np.nan modes = x.mode() return modes.iloc[0] if len(modes) > 0 else x.dropna().iloc[0] if len(x.dropna()) > 0 else np.nan def apply_k_anonymity(self, quasi_identifiers: List[str], k: int) -> 'DataAnonymizer': """ Applies k-anonymity using sorted microaggregation (sorting by QIs, grouping into chunks of k, replacing QI values with group aggregates: mean for numeric, mode for categorical). Suppresses QIs in incomplete final groups (<k). """ if k <= 1: warnings.warn("k=1 provides no anonymity.") return self df = self.df[quasi_identifiers + [col for col in self.df.columns if col not in quasi_identifiers]].sort_values(quasi_identifiers).reset_index(drop=True) n = len(df) df['__group_id'] = np.arange(n) // k group_sizes = df.groupby('__group_id').size() small_groups = group_sizes[group_sizes < k].index.tolist() # Apply aggregation to QIs for qi in quasi_identifiers: if pd_types.is_numeric_dtype(df[qi]): df[qi] = df.groupby('__group_id')[qi].transform('mean') else: df[qi] = df.groupby('__group_id')[qi].transform(self._mode_transform) # Suppress small groups suppression_mask = df['__group_id'].isin(small_groups) for qi in quasi_identifiers: if pd_types.is_numeric_dtype(df[qi]): df.loc[suppression_mask, qi] = np.nan else: df.loc[suppression_mask, qi] = '*' # Drop temp column and update df = df.drop(columns=['__group_id']) # Align columns with original (in case order changed) df = df[self.original_df.columns] self.df = df return self def apply_l_diversity(self, quasi_identifiers: List[str], sensitive: str, l: int) -> 'DataAnonymizer': """ Applies l-diversity by suppressing the sensitive attribute in equivalence classes (groups defined by quasi_identifiers) with fewer than l distinct sensitive values. """ if l <= 1: warnings.warn("l=1 provides no additional diversity.") return self if sensitive not in self.df.columns: raise ValueError(f"Sensitive attribute '{sensitive}' not in dataframe.") # Assign equivalence class ids eq_classes = self.df.groupby(quasi_identifiers).ngroup() self.df['__eq_class'] = eq_classes # Compute diversity per class diversity = self.df.groupby('__eq_class')[sensitive].nunique() bad_classes = diversity[diversity < l].index.tolist() # Suppress mask = self.df['__eq_class'].isin(bad_classes) suppress_val = '*' if not pd_types.is_numeric_dtype(self.df[sensitive]) else np.nan self.df.loc[mask, sensitive] = suppress_val # Clean up self.df = self.df.drop(columns=['__eq_class']) return self def apply_differential_privacy(self, columns: List[str], epsilon: float, delta: Optional[float] = None, sensitivity: float = 1.0, mechanism: str = 'laplace') -> 'DataAnonymizer': """ Applies differential privacy noise to specified numeric columns. - Laplace: scale = sensitivity / epsilon - Gaussian: sigma ≈ sensitivity * sqrt(2*ln(1.25/delta)) / epsilon (analytic Gaussian) """ if epsilon <= 0: raise ValueError("Epsilon must be positive.") for col in columns: if col not in self.df.columns: warnings.warn(f"Column '{col}' not in dataframe.") continue if not pd_types.is_numeric_dtype(self.df[col]): warnings.warn(f"Skipping non-numeric column '{col}'.") continue if mechanism == 'laplace': scale = sensitivity / epsilon noise = np.random.laplace(0, scale, size=len(self.df)) elif mechanism == 'gaussian': if delta is None or delta <= 0: raise ValueError("Delta must be positive for Gaussian mechanism.") sigma = sensitivity * np.sqrt(2 * np.log(1.25 / delta)) / epsilon noise = np.random.normal(0, sigma, size=len(self.df)) else: raise ValueError(f"Unsupported mechanism: {mechanism}") self.df[col] += noise return self def is_k_anonymous(self, quasi_identifiers: List[str], k: int) -> bool: """Checks if the current data satisfies k-anonymity for given QIs.""" if not all(qi in self.df.columns for qi in quasi_identifiers): return False group_sizes = self.df.groupby(quasi_identifiers).size() return (group_sizes >= k).all() def is_l_diverse(self, quasi_identifiers: List[str], sensitive: str, l: int) -> bool: """Checks if the current data satisfies l-diversity for given QIs and sensitive attribute.""" if sensitive not in self.df.columns or not all(qi in self.df.columns for qi in quasi_identifiers): return False diversity = self.df.groupby(quasi_identifiers)[sensitive].nunique() return (diversity >= l).all() def reset(self) -> 'DataAnonymizer': """Resets to original data.""" self.df = self.original_df.copy() return self def get_anonymized_data(self) -> pd.DataFrame: """Returns the current anonymized dataframe.""" return self.df.copy()Example Usage
import pandas as pd import numpy as np # Sample data data = { 'age': [22, 22, 25, 27, 30, 32, 35, 35, 40, 42], 'zipcode': ['12340', '12341', '12345', '12346', '12350', '12351', '12360', '12361', '12370', '12371'], 'disease': ['flu', 'flu', 'cancer', 'cancer', 'flu', 'cancer', 'heart', 'heart', 'flu', 'heart'], 'salary': np.random.randint(30000, 100000, 10) } df = pd.DataFrame(data) # Anonymize anonymizer = DataAnonymizer(df) anonymizer.apply_k_anonymity(['age', 'zipcode'], k=3) # Note: 10 rows, last group size 1 -> suppressed anonymizer.apply_l_diversity(['age', 'zipcode'], 'disease', l=2) anonymizer.apply_differential_privacy(['salary'], epsilon=1.0, sensitivity=1000.0) print(anonymizer.df) print("K-Anon:", anonymizer.is_k_anonymous(['age', 'zipcode'], 3)) print("L-Div:", anonymizer.is_l_diverse(['age', 'zipcode'], 'disease', 2))This library provides practical implementations with good utility preservation (via sorting/microagg for k-anon) and handles mixed data types. For production, consider more advanced methods like full Mondrian or ARX integration.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.