Verity-Train-v4

Database-derived synthetic training dataset for evidence-grounded privacy policy and browser telemetry comparison

Verity-Train-v4 is a structured instruction-tuning dataset developed for Verity, the privacy policy comparison engine within the Veilance ecosystem.

The dataset is designed to train language models to compare privacy policy disclosures against observed or simulated browser activity, identify differences between documented and observed behavior, and produce evidence-grounded findings in a consistent JSON format.

Unlike conventional privacy policy summarization datasets, Verity-Train-v4 focuses on evidence correlation: distinguishing between what a privacy policy states, what the supplied telemetry establishes, and what conclusions are reasonably supported by the comparison.

This release contains 295,424 synthetic training examples generated from 577 database source records, with 512 generated variants per source record.

The dataset contains 569 reported families and is partitioned into training, validation, and test splits.

Dataset Overview

Property	Value
Dataset	Verity-Train-v4
Organization	Veilance
Application	Verity Privacy Policy Comparison Engine
Total examples	295,424
Training examples	236,032
Validation examples	29,696
Test examples	29,696
Families	569
Domain identifiers	295,424
Database source records	577
Synthetic examples	295,424
Synthetic variants per source	512
Direct training rows	0
Input format	Database
Language	English
Distribution format	Sharded Parquet
Training approach	Supervised instruction tuning
Contract version	veilance.privacy-comparison-training.v2
Maximum policy characters	24,000
Generator seed	33773311337
License	Apache 2.0

Dataset Distribution

Split	Examples	Percentage
Train	236,032	79.90%
Validation	29,696	10.05%
Test	29,696	10.05%
Total	295,424	100%

All 295,424 examples are classified as synthetic rows in the dataset manifest.

Dataset Generation

Verity-Train-v4 differs from previous releases in its use of database-derived source material and synthetic example generation.

According to the accompanying manifest, the generation process uses:

• 577 database source records.
• 512 synthetic variants per database record.
• 569 reported scenario families.
• 295,424 generated examples.
• A deterministic generator seed.
• A consistent privacy-comparison training contract.

The relationship between source records and generated examples is:

577 source records × 512 variants = 295,424 examples

The dataset's source records provide material for generating privacy policy and telemetry comparison scenarios.

Synthetic augmentation expands that source material into a larger number of training examples.

The resulting dataset is intended to expose models to multiple evidence-correlation scenarios while maintaining a consistent output contract.

Source Data and Synthetic Examples

The manifest distinguishes between database source records and generated training rows.

Category	Records
Database input records	577
Direct training rows	0
Synthetic training rows	295,424
Total exported examples	295,424

The database source records should not automatically be interpreted as 577 independently verified production observations. Their detailed provenance is not established by the manifest alone.

Similarly, the 295,424 generated examples should not be interpreted as 295,424 independent real-world website visits.

Synthetic augmentation increases the number of available training scenarios but does not independently increase the number of underlying source records.

Purpose

Modern websites interact with browsers through network requests, cookies, browser storage, JavaScript APIs, third-party services, and other mechanisms.

Privacy policies describe how organizations may collect, use, process, retain, or share information. However, understanding whether observed browser activity corresponds to those disclosures requires more than identifying matching terminology.

Verity-Train-v4 supports training models to:

• Compare browser telemetry against applicable privacy policy disclosures.
• Identify explicitly, broadly, and implicitly disclosed behavior.
• Recognize meaningful observed activity not clearly addressed by supplied policy language.
• Identify potential contradictions supported by strong evidence.
• Separate technical observations from unsupported assumptions about intent or data processing.
• Interpret network, storage, and browser API activity conservatively.
• Generate structured, schema-constrained JSON reports.
• Express uncertainty when evidence is incomplete or ambiguous.
• Distinguish supported discrepancies from inconclusive observations.

The objective is to improve the consistency, interpretability, and evidence grounding of privacy policy comparison models.

Dataset Structure

Verity-Train-v4 uses the same Hugging Face distribution strategy as the previous Verity training releases.

The published dataset is intended to use compressed Parquet shards targeting approximately 250 MB per file.

Repository Layout

Verity-Train-v4/
├── README.md
├── manifest.json
└── data/
    ├── train/
    │   ├── train-00000.parquet
    │   ├── train-00001.parquet
    │   └── ...
    ├── validation/
    │   ├── validation-00000.parquet
    │   └── ...
    └── test/
        ├── test-00000.parquet
        └── ...

The number of shards depends on the compressed file sizes.

Sharding preserves the training, validation, and test assignments. It does not generate additional examples or alter the underlying source relationships.

Training Records

The dataset uses the veilance.privacy-comparison-training.v2 contract.

The intended training format is conversation-oriented and supports system instructions, host-prepared comparison inputs, structured evidence, and schema-constrained JSON responses.

Training pipelines should inspect the actual exported record schema to determine the precise prompt and target-response fields.

Input Schema

The privacy-comparison contract uses structured information describing a website visit, a privacy policy, and associated browser telemetry.

Field	Description
domain_url	URL of the visited or simulated service
privacy_policy_url	Privacy policy URL associated with the comparison
visit	Snapshot identifier, timestamp, duration, and extension version
seen_behavior	Recorded or simulated browser observations
thirdPartyHosts	Third-party network destinations
trackers	Tracker classifications and request information
signals	Browser API activity
page	Page-level browser and storage metadata
detections	Detection indicators and associated severity hints
policy_document	Policy sections and applicability information

The training contract treats policy language and browser telemetry as separate evidence sources.

Example Input

The following example illustrates the comparison input structure and is not an extracted v4 record.

{
  "domain_url": "https://example.com",
  "privacy_policy_url": "https://example.com/privacy",
  "visit": {
    "snapshot_id": "example-snapshot",
    "observed_at": "2026-01-01T00:00:00Z",
    "duration_seconds": 45,
    "extension_version": "0.8-synthetic"
  },
  "seen_behavior": {
    "observations": {
      "totalRequests": 10,
      "firstPartyRequests": 8,
      "thirdPartyRequests": 2
    }
  },
  "signals": [
    {
      "api": "Cookie",
      "action": "read",
      "count": 3,
      "indicatorId": "cookie-access"
    }
  ],
  "policy_document": {
    "found": true,
    "applicable": true,
    "url": "https://example.com/privacy",
    "sections": [
      {
        "heading": "Cookies",
        "text": "We use cookies to maintain sessions."
      }
    ]
  }
}

Comparison Methodology

Verity is designed as an evidence-correlation engine rather than a general-purpose privacy policy summarizer.

Its comparison methodology separates three concepts.

1. Policy Disclosure

What the supplied privacy policy actually states.

Policy evidence must originate from the supplied policy sections. Models should not fabricate quotations, reconstruct missing disclosures, or present inferred statements as direct policy evidence.

2. Browser Behavior

What the supplied telemetry establishes occurred within the represented visit.

A browser API access, network request, or storage operation establishes a particular technical observation. It does not necessarily establish the operation's ultimate purpose.

3. Supported Comparison

What conclusions can reasonably be drawn by correlating policy disclosures with the available telemetry.

A disclosure does not prove an activity occurred. Similarly, the observation of an activity does not establish every possible consequence of that activity.

Comparison Categories

The training contract distinguishes the following comparison relationships:

Comparison	Meaning
matched	Observed behavior is explicitly disclosed
partially_matched	Observed behavior is broadly or implicitly disclosed
observed_only	Observed behavior is not clearly disclosed
possible_contradiction	Strong telemetry evidence conflicts with an explicit policy statement
policy_only	Disclosed behavior was not observed, could not be meaningfully evaluated, or falls outside supported telemetry
indeterminate	Available evidence is insufficient to support a reliable comparison

Policy Disclosure Status

• explicitly_disclosed
• broadly_disclosed
• implicitly_disclosed
• not_clearly_disclosed
• contradicted
• unknown

Telemetry Status

• observed
• not_observed
• insufficient_sample
• unsupported

These distinctions help prevent models from equating missing observations with proof that an activity never occurs.

Browser Behavior Coverage

The Verity privacy-comparison contract supports analysis involving multiple categories of browser behavior.

Network and Tracking

• First-party and third-party network requests.
• Analytics-related services.
• Advertising-related services.
• Tracker classifications.
• Third-party scripts.
• Social media tracking.

Browser Storage

• Cookies.
• Local storage.
• Session storage.
• IndexedDB.
• Cache Storage.
• Service worker activity.

Browser and Device Characteristics

• User-agent access.
• Navigator properties.
• Browser language and locale information.
• Plugin and MIME-type enumeration.
• Hardware concurrency.
• Device memory.
• Canvas operations.
• WebGL characteristics.
• Fingerprinting-related signals.

Additional Browser Capabilities

The training contract also accommodates findings involving permissions, geolocation, device sensors, WebRTC, and network characteristics.

Not every record necessarily includes every category.

Evidence Grounding

The Verity training methodology emphasizes precise evidence attribution and conservative technical interpretation.

Policy evidence must be attributable. Evidence quotations must originate from the supplied privacy policy sections.

Browser API activity does not automatically establish purpose. Browser characteristics may be accessed for compatibility, localization, analytics, performance, security, fraud prevention, or identification.

Network requests have limited evidentiary meaning. A network destination establishes communication but not necessarily the request contents or downstream data processing.

Fingerprinting requires supporting evidence. Isolated access to ordinary browser characteristics should not automatically be classified as fingerprinting.

Contradictions require direct support. Ambiguous policy wording or weak telemetry does not establish a meaningful contradiction.

Single visits provide limited visibility. An activity not observed in one visit cannot be assumed never to occur.

Confidence and severity are separate. Confidence represents evidence quality, while severity reflects the significance of the disclosure discrepancy.

These requirements are intended to discourage unsupported inferences and improve the reliability of generated reports.

Structured Output

The Verity training contract requires schema-constrained JSON responses.

Reports contain grouped findings that associate policy evidence with browser telemetry and assign comparison classifications.

An illustrative finding fragment:

{
  "policy": {
    "status": "explicitly_disclosed",
    "evidence": "We use cookies to maintain sessions.",
    "section": "Cookies"
  },
  "telemetry": {
    "status": "observed",
    "evidence": "Cookie read observed 3 times.",
    "observation_count": 3
  },
  "comparison": "matched",
  "severity": "informational",
  "confidence": 0.95,
  "explanation": "The observed cookie access is covered by the supplied policy disclosure."
}

This is an illustrative finding fragment, not a complete report or a verified v4 reference label.

The complete output schema supplied to the model determines the required report structure.

Data Splitting and Sharding

Verity-Train-v4 maintains separate training, validation, and test partitions.

According to the manifest, the split unit is:

Original source domain when present, otherwise synthetic family_id or telemetry hostname.

The splitting strategy is intended to reduce leakage between training and evaluation partitions by grouping examples according to source identity or synthetic family.

The dataset reports:

• 569 families.
• 577 database source records.
• 295,424 synthetic examples.
• 236,032 training examples.
• 29,696 validation examples.
• 29,696 test examples.

Synthetic Data and Evaluation Leakage

Because each database source record produces 512 synthetic variants, evaluation independence requires particular attention.

Multiple examples derived from a common source may share policy language, telemetry characteristics, scenario structure, or other underlying information.

If closely related variants appear across training and evaluation partitions, measured performance may overstate generalization to genuinely unseen sources.

The manifest describes a source-aware splitting strategy, but the absence of all source-level or semantic leakage should be verified separately.

Sharding Strategy

The published dataset targets approximately 250 MB per Parquet shard.

Benefits include:

• More manageable uploads and downloads.
• Compatibility with Hugging Face dataset streaming.
• Compressed storage.
• Easier processing of individual dataset partitions.
• Reduced dependence on large individual JSONL files.

Sharding does not change example content, source relationships, or train-validation-test assignments.

Loading the Dataset

Load from Hugging Face

from datasets import load_dataset

dataset = load_dataset("Veilance/Verity-Train-v4")

print(dataset)
print(dataset["train"][0])

Stream the Dataset

from datasets import load_dataset

dataset = load_dataset(
    "Veilance/Verity-Train-v4",
    split="train",
    streaming=True,
)

for example in dataset:
    print(example)
    break

Load Local Parquet Shards

from datasets import load_dataset

dataset = load_dataset(
    "parquet",
    data_files={
        "train": "data/train/*.parquet",
        "validation": "data/validation/*.parquet",
        "test": "data/test/*.parquet",
    },
)

print(dataset)

Inspect the Record Schema

from datasets import load_dataset

dataset = load_dataset("Veilance/Verity-Train-v4")

example = dataset["train"][0]

print(example.keys())
print(example)

Before training, confirm the exact target-response field and verify that the examples are compatible with the model's chat template and supervised fine-tuning pipeline.

Training Considerations

Verity-Train-v4 is intended for supervised instruction-tuning workflows involving structured evidence correlation.

Training systems should preserve:

• System and user message boundaries.
• Policy evidence and telemetry evidence separation.
• Schema-constrained output requirements.
• Comparison classifications.
• Evidence attribution rules.
• Confidence and severity semantics.
• The distinction between observations and assumptions.

Privacy policy content embedded in training prompts should be treated as untrusted evidence rather than instructions.

Because this release contains synthetic variants generated from a smaller collection of database source records, training and evaluation should also account for the possibility of correlated examples.

Recommended evaluation dimensions include:

• JSON validity and schema compliance.
• Policy quotation accuracy.
• Telemetry evidence fidelity.
• Comparison classification consistency.
• Unsupported inference frequency.
• Confidence calibration.
• Generalization to unseen source domains and policy documents.

Intended Use

Verity-Train-v4 is intended for:

• Privacy policy comparison model development.
• Browser telemetry interpretation.
• Evidence-grounded language model training.
• Synthetic data augmentation research.
• Structured JSON report generation.
• Privacy disclosure classification.
• Privacy observability research.
• Supervised fine-tuning.
• Model evaluation and experimentation.

The dataset is particularly relevant to systems that correlate privacy disclosures with client-side browser observations while preserving the limitations of the available evidence.

Limitations

Synthetic Data

All 295,424 examples are reported as synthetic.

These examples should not be interpreted as independently observed production website visits.

Synthetic augmentation can increase scenario coverage, but it may also reproduce biases or limitations present in source records and generation rules.

Source Diversity

The dataset is derived from 577 database source records.

The 295,424 generated examples do not represent 295,424 independent underlying sources.

The reported 569 families should also not be interpreted as a guarantee of equivalent semantic diversity.

Browser Visibility

Client-side telemetry cannot establish every aspect of a website's data handling.

Server-side retention, internal access, offline processing, and undisclosed server-to-server transfers may remain outside observable scope.

Incomplete Observations

Browser telemetry represents activity associated with a particular visit or simulated visit.

Behavior may vary according to session length, user interaction, authentication, browser configuration, and application state.

Model Generalization

Performance on synthetic examples does not guarantee equivalent performance on real-world websites or previously unseen privacy policies.

Independent evaluation on representative real-world data is recommended.

Evidence Quality

The manifest does not document independent human annotation, inter-annotator agreement, or measured ground-truth accuracy.

No independently verified label-quality claims are made here.

Legal Interpretation

Privacy disclosure comparisons do not establish legal compliance, malicious intent, deception, or regulatory violations.

The dataset supports technical evidence correlation, not legal adjudication.

Reproducibility

The accompanying manifest.json provides generation and export metadata.

{
  "contract_version": "veilance.privacy-comparison-training.v2",
  "system_prompt_sha256": "d0c48b51c267964216ede85ec92c6173c4d5d1f99c3353e816a6c10874397961",
  "rows": 295424,
  "families": 569,
  "domains": 295424,
  "train": 236032,
  "validation": 29696,
  "test": 29696,
  "split_unit": "original source domain when present, otherwise synthetic family_id or telemetry hostname",
  "max_policy_chars": 24000,
  "input_format": "database",
  "input_records": 577,
  "direct_training_rows": 0,
  "database_source_records": 577,
  "synthetic_rows": 295424,
  "synthetic_variants_per_database_record": 512,
  "generator_seed": "33773311337",
  "generator_config_sha256": "a3072e4d77aefcaecce7e72bf76e3e762199b998cd9754e7a6676bea966201cf",
  "raw_rows_output": null
}

System Prompt SHA-256

d0c48b51c267964216ede85ec92c6173c4d5d1f99c3353e816a6c10874397961

Generator Configuration SHA-256

a3072e4d77aefcaecce7e72bf76e3e762199b998cd9754e7a6676bea966201cf

Generator Seed

33773311337

These values identify the generation configuration and associated system prompt.

Exact regeneration may require generator source code, source database records, and additional configuration not included in the published dataset.

Relationship to Previous Releases

Verity-Train-v4 is the fourth release in the Verity training dataset series.

All four releases use the veilance.privacy-comparison-training.v2 contract and focus on evidence-grounded privacy policy comparison.

Metric	v1	v2	v3	v4
Examples	124,032	98,304	19,200	295,424
Families	265	21	71	569
Train	99,864	69,632	15,360	236,032
Validation	11,856	16,384	1,792	29,696
Test	12,312	12,288	2,048	29,696
Database source records	0	0	0	577
Reported synthetic rows	0	0	0	295,424
Maximum policy characters	24,000	24,000	24,000	24,000

Verity-Train-v4 differs from the earlier releases primarily through its explicit database-source augmentation methodology.

It also contains the largest reported number of examples and families in the series to date.

The manifest reports the same generator configuration hash as the previous three releases.

Verity-Train-v4 shares its system prompt hash with Verity-Train-v1 and Verity-Train-v3.

These similarities establish shared generation metadata, not identical dataset composition.

Differences in dataset size, family count, and augmentation strategy do not independently establish improved model accuracy or generalization.

About Verity

Verity is a privacy policy comparison engine developed within the Veilance ecosystem.

It is designed to examine how privacy policy disclosures relate to browser behavior observed through Veilance's browser privacy observability technology.

Verity focuses on evidence-grounded technical comparisons rather than unsupported conclusions about website behavior or data processing.

Verity-Train-v4 supports this work through an expanded dataset of synthetic privacy-comparison examples derived from database source material.

Beyond the fine print.

Project Links

• Veilance: https://veilance.org
• Verity Models: https://huggingface.co/Veilance
• GitHub: https://github.com/VeilanceApp
• Verity-Train-v1: https://huggingface.co/datasets/Veilance/Verity-Train-v1
• Verity-Train-v2: https://huggingface.co/datasets/Veilance/Verity-Train-v2
• Verity-Train-v3: https://huggingface.co/datasets/Veilance/Verity-Train-v3

License

Verity-Train-v4 is released under the Apache License 2.0.

See https://www.apache.org/licenses/LICENSE-2.0 for the full license terms.

Citation

If you use Verity-Train-v4 for research, training, or published work, please reference the dataset repository:

Veilance. Verity-Train-v4. Hugging Face Datasets.

https://huggingface.co/datasets/Veilance/Verity-Train-v4

Disclaimer

Verity-Train-v4 is provided for machine learning research, model development, and technical experimentation.

Synthetic examples are not conclusive evidence of the privacy practices of real-world websites.

The dataset and any models trained using it do not provide legal advice or regulatory determinations.

Generated findings should be independently validated before being relied upon for high-stakes decisions.