Welcome! This is the official repository for our paper "Privasis: Synthesizing the Largest 'Public' Private Dataset from Scratch". Please visit our website for an overview of the project. We will soon release our dataset and models. Stay tuned!

conda env create -f environment.yml; conda activate privasis
huggingface-cli login

You can use one of the shell scripts for easy launch

./run_generate.sh  # builds Privasis
./run_sanitize.sh  # builds Privasis-Sanitization on top of the generated Privasis. You first need to generate some Privasis data

This section covers the two main ways to run models for the Privasis pipeline:

1. OpenAI API - simplest setup, pay-per-use
2. vLLM Server (local models) - run models on your own GPUs

Set your API key and run directly:

export OPENAI_API_KEY="your-api-key"

# Generate Privasis with GPT-4.1
python generate.py \
    --run-id my-run \
    --n_seeds 100 \
    --generator-model gpt-4.1

# Generate Privasis-Sanitization with GPT-4.1 on the generated Privasis data
python sanitize.py \
    --privasis-data-id my-run \
    --run-id my-run-sanitized \
    --sanitization-model gpt-4.1

For local models, start a vLLM server and use parallel workers for optimal throughput.

Step 1: Start the vLLM server

# Basic usage (1 GPU, port 8000)
./start_vllm_server.sh openai/gpt-oss-120b

# With 4 GPUs on port 8080
./start_vllm_server.sh openai/gpt-oss-120b 4 8080

# With custom memory utilization
./start_vllm_server.sh openai/gpt-oss-120b 1 8000 0.95

Step 2: Run generation with parallel workers

python generate.py \
    --generator-model openai/gpt-oss-120b \
    --vllm-server-url http://localhost:8000/v1 \
    --num-workers 8 \
    --n_seeds 1000 \
    --run-id parallel-generation

Step 3: Run sanitization with parallel workers

python sanitize.py \
    --privasis-data-id parallel-generation \
    --sanitization-model openai/gpt-oss-120b \
    --vllm-server-url http://localhost:8000/v1 \
    --num-workers 8 \
    --run-id parallel-sanitization

┌─────────────────────────────────────────────────────────┐
│  vLLM Server (single instance, holds model in GPU)      │
│  http://localhost:8000/v1                               │
└───────────────────────────┬─────────────────────────────┘
                            │ HTTP requests
        ┌───────────────────┼───────────────────┐
        ▼                   ▼                   ▼
   ┌─────────┐         ┌─────────┐         ┌─────────┐
   │ Thread 1│         │ Thread 2│         │ Thread N│
   └─────────┘         └─────────┘         └─────────┘
                            │
                    ┌───────▼───────┐
                    │ Single output │
                    │ file (locked) │
                    └───────────────┘

• Number of workers: Start with 4-8 workers and adjust based on GPU utilization
• Memory: Reduce --gpu_memory_utilization if you see OOM errors
• Model name consistency: Use the same model name for both the server and client scripts
• Monitoring: Watch the vLLM server output for request queuing and throughput metrics

The pipeline has two stages:

1. Generate Privasis (generate.py) - Generate synthetic records with PII
2. Sanitize Privasis (sanitize.py) - Abstract or remove target information

Generates synthetic records containing rich privacy-sensitive information

Note: The embedding model is used for computing diversity scores (Vendi score) during Metropolis-Hastings sampling. Supported models include HuggingFace models (e.g., Qwen/Qwen3-Embedding-0.6B, Qwen/Qwen3-Embedding-4B) or OpenAI models (e.g., text-embedding-3-small).

Results are saved to outputs/privasis/{run-id}/:

• {run-id}.jsonl - Generated records with PII

Sanitizes (abstracts or removes) the target information in the generated records.

Results are saved to outputs/sanitized_privasis/:

• {privasis-data-id}_{run-id}.jsonl - Sanitized records
• {privasis-data-id}_{run-id}_errors.jsonl - Failed instances (if any)

The evaluation pipeline measures how effectively a sanitization model removes or abstracts private information. It uses a two-phase approach: (1) the testee model sanitizes benchmark texts, then (2) an evaluator model attempts to infer the original PII from the sanitized output via string matching and LLM-based inference attacks.

Use the provided shell scripts to run the full test-and-evaluate pipeline on the Privasis-Zero benchmark:

# Test on the vanilla benchmark
./run_vanilla_benchmark.sh

# Test on the hard benchmark
./run_hard_benchmark.sh

# Override defaults via environment variables
MODEL=my-model NUM_GPUS=4 ./run_vanilla_benchmark.sh

These scripts automatically handle vLLM server lifecycle (start/stop) for both the testee and evaluator models. API models (e.g., gpt-4*) are detected automatically and skip the vLLM server.

python run_benchmark.py \
    --model_path openai/gpt-oss-120b \
    --hf_subset vanilla \
    --hf_split test \
    --sanitized_output_filename my_model_vanilla_test.jsonl \
    --evaluation_output_filename my_model_vanilla_test_eval.jsonl \
    --vllm-server-url http://localhost:8000/v1 \
    --batch_size 16 \
    --skip-evaluation

python evaluate.py \
    --input-file outputs/benchmark_predictions/my_model_vanilla_test.jsonl \
    --output-file my_model_vanilla_test_eval.jsonl \
    --evaluator-model-name gpt-4.1

Both run_vanilla_benchmark.sh and run_hard_benchmark.sh accept the following environment variables:

Please cite our work if you find this repo useful.

@article{kim2026privasis,
    title={Privasis: Synthesizing the Largest 'Public' Private Dataset from Scratch},
    author={Kim, Hyunwoo and Mireshghallah, Niloofar and Duan, Michael and Xin, Rui and Li, Shuyue Stella and Jung, Jaehun and Acuna, David and Pang, Qi and Xiao, Hanshen and Suh, G. Edward and Oh, Sewoong and Tsvetkov, Yulia and Koh, Pang Wei and Choi, Yejin},
    booktitle ={arXiv preprint arXiv:2602.03183},
    year=2026
}