Anonymeter

https://github.com/statice/anonymeter
Admin
Anonymeter is a unified statistical framework for quantifying privacy risks in synthetic tabular...
Tokens:47,333
Snippets:386
Trust Score:8.2
License:BSD-3-Clause
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install Development Dependencies

Source: https://github.com/statice/anonymeter/blob/main/CONTRIBUTING.md

Installs all necessary dependencies for development, including build tools and testing frameworks.

```bash
pip install ".[dev]"
```

--------------------------------

### Install Package from Test PyPI

Source: https://github.com/statice/anonymeter/blob/main/CONTRIBUTING.md

Creates a new virtual environment and installs the anonymeter package from Test PyPI with a specific version.

```bash
mkdir ~/test-anonymeter # create some test directory
cd ~/test-anonymeter
python -m venv .venv # create new virtual env
source .venv/bin/activate
asdf reshim python # in case you use asdf
pip install --upgrade pip
pip install --index-url https://test.pypi.org/simple anonymeter==NEW_VERSION
```

--------------------------------

### Install Anonymeter with Notebook Dependencies

Source: https://github.com/statice/anonymeter/blob/main/README.md

Use this command to install anonymeter along with necessary libraries for running notebooks if installing from PyPI.

```shell
pip install anonymeter[notebooks]
```

--------------------------------

### Install Anonymeter from Local Source with Notebook Dependencies

Source: https://github.com/statice/anonymeter/blob/main/README.md

Use this command to install anonymeter with notebook dependencies when installing from a local source.

```shell
pip install ".[notebooks]"
```

--------------------------------

### Local Installation of Anonymeter

Source: https://github.com/statice/anonymeter/blob/main/README.md

Install Anonymeter locally after cloning the repository. Use the appropriate pip command based on your needs: basic dependencies, notebook support, or full development setup.

```shell
cd anonymeter  # if you are not there already
pip install . # Basic dependencies
pip install ".[notebooks]" # Dependencies to run example notebooks
pip install -e ".[notebooks,dev]" # Development setup
```

--------------------------------

### Install Anonymeter from PyPI

Source: https://github.com/statice/anonymeter/blob/main/README.md

Use this command to install the Anonymeter package from the Python Package Index. This is the simplest method for general use.

```shell
pip install anonymeter
```

--------------------------------

### Initialize and Use MixedTypeKNeighbors

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/mixed_types_neighbors.md

Demonstrates how to initialize the MixedTypeKNeighbors model, fit it with training data, and then find the nearest neighbors for query data. Ensure you have pandas installed and your data loaded into DataFrames.

```python
import pandas as pd
from anonymeter.neighbors.mixed_types_kneighbors import MixedTypeKNeighbors

# Load training and query data
train_df = pd.read_csv("train.csv")
test_df = pd.read_csv("test.csv")

# Create and fit model
nn = MixedTypeKNeighbors(n_neighbors=5, n_jobs=-2)
nn.fit(train_df)

# Find nearest neighbors
indices = nn.kneighbors(test_df, return_distance=False)
print(f"Neighbors shape: {indices.shape}")
```

--------------------------------

### Using MixedTypeKNeighbors.kneighbors

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/mixed_types_neighbors.md

Demonstrates how to fit the MixedTypeKNeighbors model and then use the kneighbors method to find nearest neighbors. Shows examples of retrieving only indices, retrieving both distances and indices, and overriding the default number of neighbors.

```python
import pandas as pd
from anonymeter.neighbors.mixed_types_kneighbors import MixedTypeKNeighbors

# Fit on synthetic data
synthetic_data = pd.read_csv("synthetic.csv")
nn = MixedTypeKNeighbors(n_neighbors=5).fit(synthetic_data)

# Query data
test_data = pd.read_csv("test.csv")

# Get indices only
indices = nn.kneighbors(test_data)
print(f"Indices shape: {indices.shape}")  # (n_test, 5)

# Get both distances and indices
distances, indices = nn.kneighbors(test_data, return_distance=True)
print(f"Closest neighbor distance: {distances[0, 0]:.4f}")

# Override n_neighbors
top_10 = nn.kneighbors(test_data, n_neighbors=10)
```

--------------------------------

### Instantiate and Evaluate LinkabilityEvaluator

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/linkability_evaluator.md

This example demonstrates how to instantiate the LinkabilityEvaluator with original, synthetic, and control datasets, along with defining auxiliary columns. It then proceeds to run the evaluation and retrieve the calculated linkability risk.

```python
import pandas as pd
from anonymeter.evaluators import LinkabilityEvaluator

# Load datasets
original = pd.read_csv("original.csv")
synthetic = pd.read_csv("synthetic.csv")
control = pd.read_csv("control.csv")

# Define auxiliary columns for the two dataset splits
aux_cols = (
    ["age", "zipcode"],
    ["income", "education"]
)

# Create evaluator
evaluator = LinkabilityEvaluator(
    ori=original,
    syn=synthetic,
    aux_cols=aux_cols,
    n_attacks=500,
    n_neighbors=5,
    control=control
)

# Run evaluation
evaluator.evaluate(n_jobs=-2)

# Get risk
risk = evaluator.risk()
print(f"Linkability risk: {risk.value:.4f}")
```

--------------------------------

### Example: Mixed Type Data Transformation

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/preprocessing.md

Demonstrates transforming both numerical and categorical data using mixed_types_transform for neighbor search. This prepares data for distance computation.

```python
import pandas as pd
from anonymeter.preprocessing.transformations import mixed_types_transform

# Complete example with both numerical and categorical data
original = pd.DataFrame({
    "age": [20, 30, 40, 50],
    "education": ["HS", "College", "College", "Graduate"],
    "income": [30000, 50000, 70000, 90000]
})

synthetic = pd.DataFrame({
    "age": [25, 35, 45],
    "education": ["College", "Graduate", "HS"],
    "income": [40000, 60000, 35000]
})

# Transform for neighbor search
orig_trans, syn_trans = mixed_types_transform(
    df1=original,
    df2=synthetic,
    num_cols=["age", "income"],
    cat_cols=["education"]
)

print("Original transformed:")
print(orig_trans)
print("\nSynthetic transformed:")
print(syn_trans)

# Now ready for MixedTypeKNeighbors distance computation
```

--------------------------------

### Custom Decision Tree Predictor Example

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/inference_predictor.md

This example demonstrates how to create a custom predictor using a scikit-learn DecisionTreeClassifier that adheres to the InferencePredictor protocol. It shows how to initialize the model with synthetic data and use it within the InferenceEvaluator.

```python
import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from anonymeter.evaluators import InferenceEvaluator
from anonymeter.evaluators.inference_predictor import InferencePredictor

class CustomTreePredictor:
    """Custom decision tree wrapper implementing InferencePredictor."""
    
    def __init__(self, synthetic_data: pd.DataFrame, features: list[str], target: str):
        self.model = DecisionTreeClassifier(max_depth=10, random_state=42)
        self.model.fit(synthetic_data[features], synthetic_data[target])
        self.features = features
    
    def predict(self, x: pd.DataFrame) -> pd.Series:
        """Predict using decision tree."""
        predictions = self.model.predict(x[self.features])
        return pd.Series(predictions, index=x.index)

# Use in InferenceEvaluator
synthetic = pd.read_csv("synthetic.csv")
original = pd.read_csv("original.csv")

custom_model = CustomTreePredictor(
    synthetic_data=synthetic,
    features=["age", "education"],
    target="income"
)

evaluator = InferenceEvaluator(
    ori=original,
    syn=synthetic,
    aux_cols=["age", "education"],
    secret="income",
    inference_model=custom_model
)

evaluator.evaluate()
risk = evaluator.risk()
print(f"Risk with custom model: {risk.value:.4f}")
```

--------------------------------

### Usage Example for EvaluationResults

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/types.md

Demonstrates how to use the EvaluationResults object obtained from an evaluator to print attack and baseline success rates and compute privacy risk.

```python
from anonymeter.evaluators import SinglingOutEvaluator

evaluator = SinglingOutEvaluator(ori, syn, control)
evaluator.evaluate()
results = evaluator.results(confidence_level=0.95)

print(f"Attack success: {results.attack_rate.value:.4f}")
print(f"Baseline success: {results.baseline_rate.value:.4f}")

risk = results.risk()
```

--------------------------------

### Execute Evaluation and Get Risk Estimate

Source: https://github.com/statice/anonymeter/blob/main/README.md

Execute the evaluation pipeline by calling the evaluate method and access the estimated risk using the risk method.

```python
evaluator.evaluate()
risk = evaluator.risk()
```

--------------------------------

### Pipeline with Preprocessing for Inference

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/sklearn_inference_predictor.md

This example demonstrates wrapping a scikit-learn pipeline that includes preprocessing steps (like StandardScaler) for use with SklearnInferencePredictor. This is useful when your inference model requires data transformation before prediction.

```python
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import GradientBoostingClassifier
from anonymeter.evaluators import InferenceEvaluator, SklearnInferencePredictor

# Create preprocessing pipeline
pipeline = Pipeline([
    ("scaler", StandardScaler()),
    ("classifier", GradientBoostingClassifier(n_estimators=50, random_state=42))
])

# Fit on synthetic data
synthetic = pd.read_csv("synthetic.csv")
features = ["age", "education"]
target = "income"

pipeline.fit(synthetic[features], synthetic[target])

# Wrap for Anonymeter
predictor = SklearnInferencePredictor(model=pipeline)

# Evaluate
original = pd.read_csv("original.csv")
evaluator = InferenceEvaluator(
    ori=original,
    syn=synthetic,
    aux_cols=features,
    secret=target,
    inference_model=predictor
)

evaluator.evaluate()
risk = evaluator.risk()
print(f"Risk with preprocessing pipeline: {risk.value:.4f}")
```

--------------------------------

### PrivacyRisk NamedTuple Example

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/confidence_statistics.md

Demonstrates how to create and access attributes of the PrivacyRisk NamedTuple. This is useful for representing a privacy risk estimate along with its confidence interval.

```python
from anonymeter.stats.confidence import PrivacyRisk

risk = PrivacyRisk(value=0.25, ci=(0.18, 0.32))
print(f"Risk: {risk.value:.4f}")
print(f"95% CI: [{risk.ci[0]:.4f}, {risk.ci[1]:.4f}]")

# Unpack like a tuple
value, (lower, upper) = risk
print(f"Lower: {lower}, Upper: {upper}")
```

--------------------------------

### Handle 'Insufficient singling out queries generated' Warning

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/errors.md

Manage the warning when fewer singling out queries are generated than requested. This example demonstrates setting logging level and checking the number of generated attacks.

```python
from anonymeter.evaluators import SinglingOutEvaluator

evaluator = SinglingOutEvaluator(
    ori=ori,
    syn=syn,
    n_attacks=1000,  # Requested
    n_cols=3
)

import logging
logging.getLogger("anonymeter").setLevel(logging.WARNING)

evaluator.evaluate()
results = evaluator.results()

# Check if fewer queries were used
if results.n_attacks < 1000:
    print(f"Warning: Only {results.n_attacks} queries could be generated")
```

--------------------------------

### SinglingOutEvaluator Quick Assessment Configuration

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/configuration.md

Example for a quick assessment configuration of SinglingOutEvaluator, ideal for exploratory analysis. It uses fewer attacks and simpler queries for faster results, with a lower confidence level.

```python
evaluator = SinglingOutEvaluator(
    ori=original,
    syn=synthetic,
    n_attacks=200,       # Faster
    n_cols=2,            # Simpler queries
    seed=42
)

evaluator.evaluate(mode="univariate")
risk = evaluator.risk(confidence_level=0.90)  # Lower confidence
```

--------------------------------

### Get Raw Evaluation Results

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/inference_evaluator.md

Retrieves raw evaluation results including success counts and rates. Use this to get overall performance metrics.

```python
results = evaluator.results(confidence_level=0.95)
print(f"Attack success rate: {results.attack_rate.value:.4f}")
print(f"Attack error: ±{results.attack_rate.error:.4f}")
print(f"Baseline success rate: {results.baseline_rate.value:.4f}")
```

--------------------------------

### Get Successful Queries

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/singling_out_evaluator.md

Retrieves the successful singling out queries used in the attack. By default, it returns real attack queries. Set `baseline` to True to get baseline (random) queries for comparison.

```python
# Get successful attack queries
queries = evaluator.queries()
print(f"Generated {len(queries)} successful queries")

# Get baseline queries for comparison
baseline_queries = evaluator.queries(baseline=True)
```

--------------------------------

### Clone Anonymeter Repository

Source: https://github.com/statice/anonymeter/blob/main/README.md

Clone the Anonymeter repository from GitHub to install it locally. This is useful for development or if you need to modify the source code.

```shell
git clone git@github.com:statice/anonymeter.git
```

--------------------------------

### Standard LinkabilityEvaluator Configuration

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/configuration.md

Configure the LinkabilityEvaluator with original and synthetic data, specifying the auxiliary columns for splitting, number of attacks, and nearest neighbors. This setup uses a strict linking criterion.

```python
from anonymeter.evaluators import LinkabilityEvaluator

evaluator = LinkabilityEvaluator(
    ori=original,
    syn=synthetic,
    aux_cols=(
        ["age", "education", "occupation"],  # First split
        ["income", "marital_status"]         # Second split
    ),
    n_attacks=500,
    n_neighbors=1,  # Strict linking criterion
    control=control
)

evaluator.evaluate(n_jobs=-2)
risk = evaluator.risk()
```

--------------------------------

### Get Linkability Evaluation Results

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/linkability_evaluator.md

Call the `results` method to retrieve raw evaluation results after running `evaluate()`. This snippet shows how to access the attack success rate and its confidence interval.

```python
results = evaluator.results()
print(f"Attack success rate: {results.attack_rate.value:.4f} ± {results.attack_rate.error:.4f}")
print(f"Baseline success rate: {results.baseline_rate.value:.4f}")
```

--------------------------------

### Get High-Level Privacy Risk Estimation

Source: https://github.com/statice/anonymeter/blob/main/notebooks/anonymeter_example.ipynb

Use the `risk()` method to obtain a high-level estimation of privacy risk and its confidence interval. Specify the desired confidence level.

```python
evaluator.risk(confidence_level=0.95)
```

--------------------------------

### Using SklearnInferencePredictor with RandomForestClassifier

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/sklearn_inference_predictor.md

This example demonstrates how to wrap a trained scikit-learn RandomForestClassifier using SklearnInferencePredictor and then utilize it within an Anonymeter InferenceEvaluator. Ensure you have 'synthetic.csv' and 'original.csv' available.

```python
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from anonymeter.evaluators import InferenceEvaluator, SklearnInferencePredictor

# Load data
synthetic = pd.read_csv("synthetic.csv")
original = pd.read_csv("original.csv")

# Train a random forest on synthetic data
features = ["age", "education", "zipcode"]
target = "income"

rf_model = RandomForestClassifier(n_estimators=100, random_state=42)
rf_model.fit(synthetic[features], synthetic[target])

# Wrap for Anonymeter
predictor = SklearnInferencePredictor(model=rf_model)

# Use in evaluation
evaluator = InferenceEvaluator(
    ori=original,
    syn=synthetic,
    aux_cols=features,
    secret=target,
    inference_model=predictor
)

evaluator.evaluate(n_jobs=-2)
risk = evaluator.risk()
print(f"Inference risk: {risk.value:.4f}")
```

--------------------------------

### SinglingOutEvaluator Conservative Configuration

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/configuration.md

Example demonstrating a conservative configuration for SinglingOutEvaluator, suitable for production use requiring high confidence. It uses more attacks, more attributes per query, and a stricter confidence level for risk assessment.

```python
from anonymeter.evaluators import SinglingOutEvaluator
import pandas as pd

original = pd.read_csv("original.csv")
synthetic = pd.read_csv("synthetic.csv")
control = pd.read_csv("control.csv")

evaluator = SinglingOutEvaluator(
    ori=original,
    syn=synthetic,
    control=control,
    n_attacks=5000,      # Higher for better statistical accuracy
    n_cols=4,             # More attributes per query
    max_attempts=50000000,
    seed=42               # Fixed seed for reproducibility
)

evaluator.evaluate(mode="multivariate")
risk = evaluator.risk(confidence_level=0.99)  # Stricter confidence level
```

--------------------------------

### Get Detailed Attack Success Rates

Source: https://github.com/statice/anonymeter/blob/main/notebooks/anonymeter_example.ipynb

Use the `results()` method to retrieve detailed success rates for the main, baseline, and control attacks. This provides insight into the components of the Anonymeter risk calculation.

```python
res = evaluator.results()

print("Successs rate of main attack:", res.attack_rate)
print("Successs rate of baseline attack:", res.baseline_rate)
print("Successs rate of control attack:", res.control_rate)
```

--------------------------------

### Instantiate and Evaluate SinglingOutEvaluator

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/singling_out_evaluator.md

Demonstrates how to instantiate the SinglingOutEvaluator with original, synthetic, and control datasets, and then run an evaluation using the multivariate attack mode. Shows how to retrieve and print the calculated risk and confidence interval.

```python
import pandas as pd
from anonymeter.evaluators import SinglingOutEvaluator

# Load data
original = pd.read_csv("original.csv")
synthetic = pd.read_csv("synthetic.csv")
control = pd.read_csv("control.csv")

# Create evaluator
evaluator = SinglingOutEvaluator(
    ori=original,
    syn=synthetic,
    control=control,
    n_attacks=1000,
    n_cols=3,
    seed=42
)

# Run evaluation
evaluator.evaluate(mode="multivariate")

# Get results
risk = evaluator.risk()
print(f"Singling out risk: {risk.value:.4f}")
print(f"Confidence interval: {risk.ci}")
```

--------------------------------

### Initialize and Fit MixedTypeKNeighbors

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/configuration.md

Instantiate MixedTypeKNeighbors with specified neighbors and jobs, then fit it with synthetic data. This is useful for setting up the nearest neighbors model for further analysis.

```python
from anonymeter.neighbors.mixed_types_kneighbors import MixedTypeKNeighbors

nn = MixedTypeKNeighbors(n_neighbors=5, n_jobs=-2)
nn.fit(synthetic_data)

indices = nn.kneighbors(test_data)
distances, indices = nn.kneighbors(test_data, return_distance=True)
```

--------------------------------

### Build Package Distributions

Source: https://github.com/statice/anonymeter/blob/main/CONTRIBUTING.md

Cleans the build directory and creates source and wheel distributions for the package.

```bash
rm -rf ./dist # clean the build directory if necessary
python -m build
```

--------------------------------

### Configure Twine for PyPI

Source: https://github.com/statice/anonymeter/blob/main/CONTRIBUTING.md

Sets up the .pypirc file to authenticate with the official PyPI repository using an API token.

```toml
[pypi]
  username = "__token__"
  password = "YOUR_TOKEN_HERE"
```

--------------------------------

### Configure Twine for Test PyPI

Source: https://github.com/statice/anonymeter/blob/main/CONTRIBUTING.md

Sets up the .pypirc file to authenticate with Test PyPI using an API token.

```toml
[testpypi]
  username = "__token__"
  password = "YOUR_TOKEN_HERE"
```

--------------------------------

### Get InferenceEvaluator Results

Source: https://github.com/statice/anonymeter/blob/main/notebooks/attribute_inference_custom_model_and_group_wise_risk.ipynb

Retrieve the evaluation results from the InferenceEvaluator. The .results() method returns an object containing various metrics, including the overall privacy risk.

```python
result = evaluator.results()
print(f"Privacy risk for secret=[{secret}]: {result.risk()}")
```

--------------------------------

### Calculate and Use SuccessRate

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/types.md

Shows how to calculate a SuccessRate using the success_rate function and how to format the output. It also demonstrates converting a SuccessRate to a PrivacyRisk object.

```python
from anonymeter.stats.confidence import success_rate

rate = success_rate(n_total=500, n_success=125, confidence_level=0.95)
print(f"Rate: {rate.value:.4f} ± {rate.error:.4f}")

# Convert to PrivacyRisk
risk = rate.to_risk()
```

--------------------------------

### MixedTypeKNeighbors Constructor

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/mixed_types_neighbors.md

Initializes the MixedTypeKNeighbors algorithm. It allows configuration of the number of neighbors to find and the number of parallel jobs to use for computation.

```APIDOC
## Class: MixedTypeKNeighbors

### Description
Nearest neighbor algorithm for mixed type data. Uses L1 distance for normalized numerical columns and exact matching for categorical columns.

### Signature
```python
__init__(self, n_neighbors: int = 5, n_jobs: int = -2) -> None
```

### Parameters
#### Parameters
- **n_neighbors** (int) - Optional - Default: 5 - Number of nearest neighbors to return per query.
- **n_jobs** (int) - Optional - Default: -2 - Number of parallel jobs. -1 uses all CPUs, -2 uses all except one.

### Returns
MixedTypeKNeighbors instance

### Example
```python
import pandas as pd
from anonymeter.neighbors.mixed_types_kneighbors import MixedTypeKNeighbors

# Load training and query data
train_df = pd.read_csv("train.csv")
test_df = pd.read_csv("test.csv")

# Create and fit model
nn = MixedTypeKNeighbors(n_neighbors=5, n_jobs=-2)
nn.fit(train_df)

# Find nearest neighbors
indices = nn.kneighbors(test_df, return_distance=False)
print(f"Neighbors shape: {indices.shape}")
```
```

--------------------------------

### Run Tests with Pytest

Source: https://github.com/statice/anonymeter/blob/main/CONTRIBUTING.md

Sets up a symbolic link to the tests directory and runs the package tests using pytest.

```bash
ln -s ~/code/anonymeter/tests ~/test-anonymeter/tests
pip install pytest
python -m pytest
```

--------------------------------

### Estimate Singling Out Privacy Risk

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/singling_out_evaluator.md

Use the `risk` method to estimate the privacy risk. You can specify a confidence level and choose to get the baseline risk from a random guessing attack.

```python
# Get attack risk
attack_risk = evaluator.risk(confidence_level=0.95)
print(f"Attack risk: {attack_risk.value:.4f} ± {attack_risk.ci}")

# Get baseline risk
baseline_risk = evaluator.risk(baseline=True)
```

--------------------------------

### Display first few rows of the original dataset

Source: https://github.com/statice/anonymeter/blob/main/notebooks/attribute_inference_custom_model_and_group_wise_risk.ipynb

Shows the initial rows of the original dataset to understand its structure and content.

```python
ori.head()
```

--------------------------------

### Get Linkability Risk

Source: https://github.com/statice/anonymeter/blob/main/notebooks/anonymeter_example.ipynb

Retrieve the calculated linkability risk from the evaluator. The `risk()` method can also take `n_neighbors` as an argument to re-evaluate risk with different indirect link tolerances.

```python
evaluator.risk()
```

--------------------------------

### Upload to PyPI

Source: https://github.com/statice/anonymeter/blob/main/CONTRIBUTING.md

Uploads the built package artifacts to the official PyPI repository.

```bash
twine upload dist/*
```

--------------------------------

### Get Evaluation Results

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/singling_out_evaluator.md

Retrieves raw evaluation results including success counts and rates for all attacks. Specify a confidence level for statistical calculations. Ensure `evaluate()` has been called prior to this method.

```python
results = evaluator.results(confidence_level=0.95)
print(f"Main attack success rate: {results.attack_rate.value:.4f}")
print(f"Baseline success rate: {results.baseline_rate.value:.4f}")
if results.control_rate:
    print(f"Control success rate: {results.control_rate.value:.4f}")
```

--------------------------------

### Prepare data and train a custom Decision Tree model for inference

Source: https://github.com/statice/anonymeter/blob/main/notebooks/attribute_inference_custom_model_and_group_wise_risk.ipynb

Sets up a preprocessing pipeline with OneHotEncoder for categorical features and passthrough for numerical features. Then, it trains a DecisionTreeClassifier on the original data to predict the 'income' column using other attributes as input.

```python
# Choose a target (the secret) column for the inference model
secret = "income"
# Select the input colums - aux_cols to train the inference model on
aux_cols = [col for col in ori.columns if col != secret]

# Data Preprocessing requirements
categorical_cols = ori[aux_cols].select_dtypes(include=["object"]).columns
numeric_cols = ori[aux_cols].select_dtypes(include=["number"]).columns

preprocess = ColumnTransformer(
    transformers=[
        ("cat", OneHotEncoder(handle_unknown="ignore"), categorical_cols),
        ("num", "passthrough", numeric_cols)
    ]
)

# The inference model
tree = DecisionTreeClassifier(
    criterion="gini",
    max_depth=5,
    min_samples_split=10,
    min_samples_leaf=5,
    max_features="sqrt",
    random_state=42,
)

# Build the pipeline out of the preprocessing step and inference model
model = Pipeline(steps=[
    ("preprocess", preprocess),
    ("tree", tree)
])

# Fit the model
model.fit(ori[aux_cols], ori[secret])

# Wrap the model in an InferencePredictor (anonymeter.evaluators.inference_predictor::InferencePredictor)

```

--------------------------------

### Configure Anonymeter to Log to a File

Source: https://github.com/statice/anonymeter/blob/main/README.md

Set up a file handler to direct anonymeter logs to a file named 'anonymeter.log' with DEBUG level.

```python
import logging

# create a file handler
file_handler = logging.FileHandler("anonymeter.log")

# set the logging level for the file handler
file_handler.setLevel(logging.DEBUG)

# add the file handler to the logger
logger = logging.getLogger("anonymeter")
logger.addHandler(file_handler)
logger.setLevel(logging.DEBUG)
```

--------------------------------

### Initialize and Evaluate LinkabilityEvaluator

Source: https://github.com/statice/anonymeter/blob/main/notebooks/anonymeter_example.ipynb

Configure and run the LinkabilityEvaluator with specified auxiliary columns and attack parameters. The `n_jobs` parameter follows joblib conventions.

```python
aux_cols = [
    ['type_employer', 'education', 'hr_per_week', 'capital_loss', 'capital_gain'],
    [ 'race', 'sex', 'fnlwgt', 'age', 'country']
]

evaluator = LinkabilityEvaluator(ori=ori, 
                                 syn=syn, 
                                 control=control,
                                 n_attacks=2000,
                                 aux_cols=aux_cols,
                                 n_neighbors=10)

evaluator.evaluate(n_jobs=-2)  # n_jobs follow joblib convention. -1 = all cores, -2 = all execept one
```

--------------------------------

### Load datasets

Source: https://github.com/statice/anonymeter/blob/main/notebooks/measure_time_singling_out.ipynb

Loads the original, synthetic, and control datasets using pandas. Ensure the 'datasets' directory exists and contains the specified CSV files.

```python
dataset_dir = "./datasets/"

ori = pd.read_csv(os.path.join(dataset_dir, "adults_train.csv"))
syn = pd.read_csv(os.path.join(dataset_dir, "adults_syn_ctgan.csv"))
control = pd.read_csv(os.path.join(dataset_dir, "adults_control.csv"))
```

--------------------------------

### Upload to Test PyPI

Source: https://github.com/statice/anonymeter/blob/main/CONTRIBUTING.md

Uploads the built package artifacts to the Test PyPI repository for testing.

```bash
twine upload --repository testpypi dist/*
```

--------------------------------

### LinkabilityEvaluator Evaluate Method Parallelization

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/configuration.md

Demonstrates how to control parallelization for the evaluate method using the n_jobs parameter. Options range from using all CPU cores to serial execution for debugging.

```python
# For large datasets, use all cores
evaluator.evaluate(n_jobs=-1)

# For shared systems, leave one core free
evaluator.evaluate(n_jobs=-2)

# For debugging, run serially
evaluator.evaluate(n_jobs=1)
```

--------------------------------

### Plot Overall Risk Scores per Secret

Source: https://github.com/statice/anonymeter/blob/main/notebooks/attribute_inference_custom_model_and_group_wise_risk.ipynb

Generate a bar chart to visualize the overall privacy risk scores for each secret column evaluated in the end-to-end example. This provides a comparative overview of the inference risk across different attributes.

```python
fig, ax = plt.subplots()

risks = [res[1].risk().value for res in results]
columns = [res[0] for res in results]

ax.bar(x=columns, height=risks, alpha=0.5, ecolor='black', capsize=10)

plt.xticks(rotation=45, ha='right')
plt.title("Risk scores per secret")
ax.set_ylabel("Measured inference risk")
_ = ax.set_xlabel("Secret column")
```

--------------------------------

### Importing Anonymeter Preprocessing Utilities

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/README.md

Import utility functions for data preprocessing, such as mixed_types_transform, detect_col_types, and detect_consistent_col_types. These are essential for preparing data for Anonymeter analysis.

```python
from anonymeter.preprocessing import (
    mixed_types_transform,
    detect_col_types,
    detect_consistent_col_types,
)
```

--------------------------------

### Generate Univariate Singling Out Queries

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/singling_out_evaluator.md

Generates singling out queries based on rare individual attribute values from a Polars DataFrame. This function is useful for creating privacy-preserving queries that target individuals with unique attribute combinations. Ensure you have Polars and NumPy installed and a DataFrame with relevant data.

```python
import polars as pl
import numpy as np

def univariate_singling_out_queries(
    df: pl.DataFrame,
    n_queries: int,
    rng: np.random.Generator
) -> list[pl.Expr]:
    # Generates singling out queries from rare individual attribute values.
    pass

df = pl.read_csv("data.csv")
rng = np.random.default_rng(seed=42)

queries = univariate_singling_out_queries(df=df, n_queries=100, rng=rng)
print(f"Generated {len(queries)} univariate queries")
```

--------------------------------

### Fit MixedTypeKNeighbors with Auto-detected or Explicit Types

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/mixed_types_neighbors.md

Shows how to fit the MixedTypeKNeighbors model to a dataset. You can either let the model auto-detect column types or explicitly specify them using the 'ctypes' parameter.

```python
import pandas as pd
from anonymeter.neighbors.mixed_types_kneighbors import MixedTypeKNeighbors

synthetic_data = pd.read_csv("synthetic.csv")

# Auto-detect types
nn = MixedTypeKNeighbors(n_neighbors=5).fit(synthetic_data)

# Or explicitly specify types
nn = MixedTypeKNeighbors(n_neighbors=5).fit(
    synthetic_data,
    ctypes={'num': ['age', 'income'], 'cat': ['education', 'zipcode']}
)
```

--------------------------------

### Initialize SinglingOutEvaluator

Source: https://github.com/statice/anonymeter/blob/main/notebooks/measure_time_singling_out.ipynb

Initializes the SinglingOutEvaluator with loaded datasets and specifies parameters for the number of attacks and columns.

```python
evaluator = SinglingOutEvaluator(ori=ori, 
                                 syn=syn, 
                                 control=control,
                                 n_attacks=2000,
                                 n_cols=12)
```

--------------------------------

### Initialize and Evaluate InferenceEvaluator

Source: https://github.com/statice/anonymeter/blob/main/notebooks/attribute_inference_custom_model_and_group_wise_risk.ipynb

Initialize the InferenceEvaluator with original, synthetic, and control data, along with auxiliary columns, a secret column, and a pre-trained inference model. Evaluate the privacy risk using the .evaluate() method.

```python
evaluator = InferenceEvaluator(ori=ori, 
syn=syn, 
control=control,
aux_cols=aux_cols,
secret=secret,
n_attacks=ori.shape[0], # the min value of n_attacks and ori.shape[0] is considered
regression = False,
inference_model=inference_model) # We pass the inference_model here
# Evaluate
evaluator.evaluate(n_jobs=-2)
```

--------------------------------

### Execute Linkability Attack with LinkabilityEvaluator

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/linkability_evaluator.md

Use the `evaluate` method to run the linkability attack. You can control the number of parallel jobs for performance. Default settings use most available CPUs.

```python
evaluator.evaluate()
```

```python
evaluator.evaluate(n_jobs=4)
```

```python
evaluator.evaluate(n_jobs=1)
```

--------------------------------

### Fit MixedTypeKNeighbors with Explicit Type Specification

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/configuration.md

Configure MixedTypeKNeighbors with explicit column types for numerical and categorical features. This allows for more precise control over how the model handles different data types during fitting and querying.

```python
from anonymeter.neighbors.mixed_types_kneighbors import MixedTypeKNeighbors

nn = MixedTypeKNeighbors(n_neighbors=10)
nn.fit(
    candidates=synthetic_data,
    ctypes={
        'num': ['age', 'income', 'years_employed'],
        'cat': ['education', 'occupation', 'region']
    }
)

neighbors = nn.kneighbors(test_data, n_neighbors=3)  # Override n_neighbors
```

--------------------------------

### Detecting Column Types with pandas

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/types.md

Demonstrates how to use the detect_col_types function to identify numerical and categorical columns in a pandas DataFrame. Ensure pandas is imported as pd.

```python
from anonymeter.preprocessing.type_detection import detect_col_types

df = pd.read_csv("data.csv")
types = detect_col_types(df)

# types['num'] contains numerical column names
# types['cat'] contains categorical column names
```

--------------------------------

### Initialize EvaluationResults

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/confidence_statistics.md

Create an EvaluationResults object to aggregate attack results and compute success rates and privacy risk. Specify the number of attacks, successes, baselines, and optionally control attacks and confidence level.

```python
from anonymeter.stats.confidence import EvaluationResults

# Create results object
results = EvaluationResults(
    n_attacks=500,
    n_success=150,
    n_baseline=50,
    n_control=60,
    confidence_level=0.95
)

print(f"Attack success: {results.attack_rate.value:.4f}")
print(f"Baseline success: {results.baseline_rate.value:.4f}")
if results.control_rate:
    print(f"Control success: {results.control_rate.value:.4f}")
```

--------------------------------

### MixedTypeKNeighbors.fit Method

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/mixed_types_neighbors.md

Prepares the data for nearest neighbor search by fitting the model to the provided candidate records. It can optionally accept explicit column type specifications.

```APIDOC
## Method: fit

### Description
Prepares data for nearest neighbor search.

### Signature
```python
def fit(self, candidates: pd.DataFrame, ctypes: Optional[dict[str, list[str]]] = None) -> MixedTypeKNeighbors
```

### Parameters
#### Parameters
- **candidates** (pd.DataFrame) - Required - Dataset containing records to search within. Becomes the reference set for kneighbors().
- **ctypes** (dict or None) - Optional - Default: None - Column type specification. Dictionary with keys 'num' and 'cat' mapping to lists of column names. If None, auto-detected.

### Returns
Self for method chaining

### Example
```python
import pandas as pd
from anonymeter.neighbors.mixed_types_kneighbors import MixedTypeKNeighbors

synthetic_data = pd.read_csv("synthetic.csv")

# Auto-detect types
nn = MixedTypeKNeighbors(n_neighbors=5).fit(synthetic_data)

# Or explicitly specify types
nn = MixedTypeKNeighbors(n_neighbors=5).fit(
    synthetic_data,
    ctypes={'num': ['age', 'income'], 'cat': ['education', 'zipcode']}
)
```
```

--------------------------------

### Retrieve Singling Out Queries

Source: https://github.com/statice/anonymeter/blob/main/notebooks/anonymeter_example.ipynb

Retrieves and displays the first three singling out queries generated by the attacker. This helps understand which attributes are being used for singling out.

```python
evaluator.queries()[:3]
```

--------------------------------

### kneighbors Method

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/mixed_types_neighbors.md

Finds the k-nearest neighbors for query points using a brute-force search. This method allows specifying the number of neighbors and whether to return distances along with the neighbor indices.

```APIDOC
## Method: kneighbors

### Description
Finds nearest neighbors for query points using brute-force search.

### Signature
```python
def kneighbors(
    self,
    queries: pd.DataFrame,
    n_neighbors: Optional[int] = None,
    return_distance: bool = False
) -> Union[tuple[np.ndarray, np.ndarray], np.ndarray]
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **queries** (pd.DataFrame) - Required - Query points for which to find neighbors. Must have same columns as fitted candidates.
- **n_neighbors** (int or None) - Optional - Default: None - Number of neighbors per query. If None, uses value from constructor.
- **return_distance** (bool) - Optional - Default: False - If True, returns both distances and indices as tuple; if False, returns indices only.

### Returns
If `return_distance=False`: np.ndarray of shape (n_queries, n_neighbors) with neighbor indices

If `return_distance=True`: Tuple of two arrays:
- distances: np.ndarray of shape (n_queries, n_neighbors)
- indices: np.ndarray of shape (n_queries, n_neighbors)

### Example
```python
import pandas as pd
from anonymeter.neighbors.mixed_types_kneighbors import MixedTypeKNeighbors

# Fit on synthetic data
synthetic_data = pd.read_csv("synthetic.csv")
nn = MixedTypeKNeighbors(n_neighbors=5).fit(synthetic_data)

# Query data
test_data = pd.read_csv("test.csv")

# Get indices only
indices = nn.kneighbors(test_data)
print(f"Indices shape: {indices.shape}")  # (n_test, 5)

# Get both distances and indices
distances, indices = nn.kneighbors(test_data, return_distance=True)
print(f"Closest neighbor distance: {distances[0, 0]:.4f}")

# Override n_neighbors
top_10 = nn.kneighbors(test_data, n_neighbors=10)
```
```

--------------------------------

### Import necessary libraries

Source: https://github.com/statice/anonymeter/blob/main/notebooks/singling_out.ipynb

Imports all required libraries for data manipulation, evaluation, and plotting.

```python
import pandas as pd
import os

from pathlib import Path
from datetime import datetime
from anonymeter.evaluators import SinglingOutEvaluator
from matplotlib import pyplot as plt
import time

import seaborn as sns
from collections import defaultdict
```

--------------------------------

### Print timing results (n_cols=12)

Source: https://github.com/statice/anonymeter/blob/main/notebooks/measure_time_singling_out.ipynb

Prints the average and standard deviation of the execution time measured by %%timeit for constructing and running queries.

```python
print(f"mean  : {_.average:.2f} s")
print(f"std   : {_.stdev:.2f} s")
```

--------------------------------

### Initialize and Evaluate InferenceEvaluator

Source: https://github.com/statice/anonymeter/blob/main/notebooks/anonymeter_example.ipynb

Set up and run the InferenceEvaluator to measure the risk of inferring secret attributes. Auxiliary columns are defined to model an attacker's knowledge, and a specific 'secret' column is targeted.

```python
columns = ori.columns
results = []

for secret in columns:
    
    aux_cols = [col for col in columns if col != secret]
    
    evaluator = InferenceEvaluator(ori=ori, 
                                   syn=syn, 
                                   control=control,
                                   aux_cols=aux_cols,
                                   secret=secret,
                                   n_attacks=1000)
    evaluator.evaluate(n_jobs=-2)
    results.append((secret, evaluator.results()))
```

--------------------------------

### Regression Model Inference

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/sklearn_inference_predictor.md

Demonstrates how to use SklearnInferencePredictor with a RandomForestRegressor for a regression task. Ensure your data is loaded and the model is trained before wrapping.

```python
import pandas as pd
from sklearn.ensemble import RandomForestRegressor
from anonymeter.evaluators import InferenceEvaluator, SklearnInferencePredictor

# Train regressor on synthetic data
synthetic = pd.read_csv("synthetic.csv")
features = ["age", "education", "experience"]
target = "salary"

regressor = RandomForestRegressor(n_estimators=100, random_state=42)
regressor.fit(synthetic[features], synthetic[target])

# Wrap
predictor = SklearnInferencePredictor(model=regressor)

# Evaluate continuous target
original = pd.read_csv("original.csv")
evaluator = InferenceEvaluator(
    ori=original,
    syn=synthetic,
    aux_cols=features,
    secret=target,
    regression=True,  # Specify regression task
    inference_model=predictor
)

evaluator.evaluate()
results = evaluator.results()
print(f"Regression attack success rate: {results.attack_rate.value:.4f}")
```

--------------------------------

### evaluate

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/linkability_evaluator.md

Executes the linkability attack using k-nearest neighbors search. This method can be configured with the number of parallel jobs to run.

```APIDOC
## Method: evaluate

### Description
Executes the linkability attack using k-nearest neighbors search.

### Signature
```python
def evaluate(self, n_jobs: int = -2) -> LinkabilityEvaluator
```

### Parameters
#### Path Parameters
* None

#### Query Parameters
* None

#### Request Body
* None

### Parameters
- **n_jobs** (int) - Optional - Default: -2 - Number of parallel jobs. -2 uses all CPUs except one. -1 uses all CPUs.

### Returns
Self for method chaining

### Example
```python
# Run with default parallel settings
evaluator.evaluate()

# Run with specific number of jobs
evaluator.evaluate(n_jobs=4)

# Run serially (single process)
evaluator.evaluate(n_jobs=1)
```
```

--------------------------------

### Detect Column Types and Transform Data

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/preprocessing.md

This snippet demonstrates loading data, automatically detecting numerical and categorical column types using `detect_consistent_col_types`, and then applying transformations with `mixed_types_transform` to prepare data for distance calculations.

```python
import pandas as pd
from anonymeter.preprocessing.type_detection import detect_consistent_col_types
from anonymeter.preprocessing.transformations import mixed_types_transform

# Load raw data
synthetic = pd.read_csv("synthetic.csv")
test = pd.read_csv("test.csv")

# Auto-detect types
types = detect_consistent_col_types(synthetic, test)
print(f"Numerical columns: {types['num']}")
print(f"Categorical columns: {types['cat']}")

# Transform for downstream processing
syn_transformed, test_transformed = mixed_types_transform(
    df1=synthetic,
    df2=test,
    num_cols=types["num"],
    cat_cols=types["cat"]
)

# Now both dataframes are scaled/encoded and ready for distance calculations
print(syn_transformed.dtypes)
```

--------------------------------

### Complete Workflow for Confidence Statistics

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/confidence_statistics.md

This snippet demonstrates a full workflow for calculating confidence statistics, including success rates for attacks, baselines, and controls, residual success, and the final privacy risk with confidence intervals. It uses the `success_rate`, `residual_success`, and `EvaluationResults` classes from `anonymeter.stats.confidence`.

```python
from anonymeter.stats.confidence import (
    success_rate,
    residual_success,
    EvaluationResults,
    PrivacyRisk
)

# Scenario: Singling out attack results
n_attacks = 500
n_success_attack = 125
n_success_baseline = 25
n_success_control = 30

# Compute success rates
attack_rate = success_rate(
    n_total=n_attacks,
    n_success=n_success_attack,
    confidence_level=0.95
)
baseline_rate = success_rate(
    n_total=n_attacks,
    n_success=n_success_baseline,
    confidence_level=0.95
)
control_rate = success_rate(
    n_total=n_attacks,
    n_success=n_success_control,
    confidence_level=0.95
)

print(f"Attack success: {attack_rate.value:.4f} ± {attack_rate.error:.4f}")
print(f"Baseline success: {baseline_rate.value:.4f} ± {baseline_rate.error:.4f}")
print(f"Control success: {control_rate.value:.4f} ± {control_rate.error:.4f}")

# Compute residual success
residual = residual_success(attack_rate, control_rate)
print(f"Residual success: {residual.value:.4f} ± {residual.error:.4f}")

# Use EvaluationResults class (what evaluators actually return)
results = EvaluationResults(
    n_attacks=n_attacks,
    n_success=n_success_attack,
    n_baseline=n_success_baseline,
    n_control=n_success_control,
    confidence_level=0.95
)

privacy_risk = results.risk()
print(f"\nPrivacy risk: {privacy_risk.value:.4f}")
print(f"Confidence interval: [{privacy_risk.ci[0]:.4f}, {privacy_risk.ci[1]:.4f}]")
```

--------------------------------

### Instantiate Anonymeter Evaluator

Source: https://github.com/statice/anonymeter/blob/main/notebooks/anonymeter_example.ipynb

Instantiate an Anonymeter evaluator by providing the original, synthetic, and control datasets, along with the number of attacks to perform. The number of attacks influences the statistical uncertainty and computation time.

```python
evaluator = *Evaluator(ori: pd.DataFrame, 
                       syn: pd.DataFrame, 
                       control: pd.DataFrame,
                       n_attacks: int)
```

--------------------------------

### Combine original and control datasets

Source: https://github.com/statice/anonymeter/blob/main/notebooks/singling_out.ipynb

Concatenates the original training data and the control dataset for use in splitting.

```python
adult_combined = pd.concat([ori, control], axis=0)
```

--------------------------------

### Support Vector Machine Inference

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/sklearn_inference_predictor.md

Shows how to integrate a scikit-learn Support Vector Machine (SVC) pipeline with SklearnInferencePredictor for inference risk assessment. Scaling is crucial for SVM performance.

```python
import pandas as pd
from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from anonymeter.evaluators import InferenceEvaluator, SklearnInferencePredictor

# Create SVM pipeline (scaling is essential for SVM)
pipeline = Pipeline([
    ("scaler", StandardScaler()),
    ("svm", SVC(kernel="rbf", C=1.0))
])

# Fit on synthetic data
synthetic = pd.read_csv("synthetic.csv")
features = ["age", "zipcode"]
target = "has_credit"

pipeline.fit(synthetic[features], synthetic[target])

# Use in evaluation
original = pd.read_csv("original.csv")
predictor = SklearnInferencePredictor(model=pipeline)

evaluator = InferenceEvaluator(
    ori=original,
    syn=synthetic,
    aux_cols=features,
    secret=target,
    inference_model=predictor
)

evaluator.evaluate(n_jobs=1)  # SVM scales to single-threaded
risk = evaluator.risk()
print(f"SVM-based inference risk: {risk.value:.4f}")
```

--------------------------------

### Importing Anonymeter Statistics Components

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/README.md

Import statistical components for privacy risk analysis, including PrivacyRisk, SuccessRate, and EvaluationResults. These are used to quantify and report privacy guarantees.

```python
from anonymeter.stats.confidence import (
    PrivacyRisk,
    SuccessRate,
    EvaluationResults,
)
```

--------------------------------

### Compare Actual vs. Baseline Inference Risk

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/inference_evaluator.md

Calculate and print the improvement of the inference attack over random guessing. This helps quantify the effectiveness of the attack.

```python
# Compare actual vs random
improvement = risk.value - baseline_risk.value
print(f"Attack improvement: {improvement:.4f}")
```

--------------------------------

### Scikit-learn Regression Model Wrapper

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/inference_predictor.md

Shows how to wrap a scikit-learn GradientBoostingRegressor for regression tasks within Anonymeter. Ensure to set `regression=True` in the InferenceEvaluator.

```python
import pandas as pd
import numpy as np
from sklearn.ensemble import GradientBoostingRegressor
from anonymeter.evaluators import InferenceEvaluator, SklearnInferencePredictor

# Create regression model
synthetic = pd.read_csv("synthetic.csv")
model = GradientBoostingRegressor(n_estimators=100, random_state=42)
model.fit(synthetic[["age", "education"]], synthetic["salary"])

# Wrap for Anonymeter
predictor = SklearnInferencePredictor(model=model)

# Evaluate inference risk for continuous target
original = pd.read_csv("original.csv")
evaluator = InferenceEvaluator(
    ori=original,
    syn=synthetic,
    aux_cols=["age", "education"],
    secret="salary",
    regression=True,  # Specify regression task
    inference_model=predictor
)

evaluator.evaluate()
results = evaluator.results()
print(f"Success rate: {results.attack_rate.value:.4f}")
```

--------------------------------

### Execute Inference Attack with Default Parallelization

Source: https://github.com/statice/anonymeter/blob/main/_autodocs/api-reference/inference_evaluator.md

Use this snippet to run the inference attack using the default number of parallel jobs. The default setting utilizes all available CPUs except one for neighbor search.

```python
evaluator.evaluate()
```

--------------------------------

### Split data into train, release, and control sets

Source: https://github.com/statice/anonymeter/blob/main/notebooks/singling_out.ipynb

Calls the defined function to split the combined dataset into the respective sets.

```python
df_train, df_release, df_control = split_train_control_release()
```

--------------------------------

### Import Anonymeter Evaluators and Utilities

Source: https://github.com/statice/anonymeter/blob/main/notebooks/anonymeter_example.ipynb

Import necessary libraries including pandas for data manipulation, matplotlib and seaborn for plotting, and the specific evaluator classes from Anonymeter. Ensure these are available in your environment.

```python
import os
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

from anonymeter.evaluators import SinglingOutEvaluator
from anonymeter.evaluators import LinkabilityEvaluator
from anonymeter.evaluators import InferenceEvaluator
```

--------------------------------

### Re-evaluate Linkability Risk with Different Neighbors

Source: https://github.com/statice/anonymeter/blob/main/notebooks/anonymeter_example.ipynb

Check the measured linkability risk for different values of `n_neighbor` without re-running the entire evaluation. This allows for quick analysis of how indirect links affect the risk.

```python
print(evaluator.risk(n_neighbors=7))
```
Tokens:
Raw