Skip to content
TheChatArchiveThe Chat Archive
Grok 4.1 Fast· xaiHugging Face Frontier Reasoning Traces

Create a data anonymization library with k-anon, l-diversity, and DP.

  1. User

    Create a data anonymization library with k-anon, l-diversity, and DP.

  2. 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.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.