Verity-Train-v3

Evidence-grounded privacy policy and browser telemetry comparison training dataset

Verity-Train-v3 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 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-v3 focuses on evidence correlation: determining what a privacy policy explicitly states, what browser telemetry actually establishes, and what conclusions can reasonably be drawn from comparing the two.

The dataset contains 19,200 examples, organized into training, validation, and test splits across 71 reported families.

Dataset Overview

Property	Value
Dataset	Verity-Train-v3
Organization	Veilance
Application	Verity Privacy Policy Comparison Engine
Total examples	19,200
Training examples	15,360
Validation examples	1,792
Test examples	2,048
Families	71
Domain identifiers	19,200
Language	English
Distribution format	Sharded Parquet
Original export format	JSONL
Training approach	Supervised instruction tuning
Contract version	veilance.privacy-comparison-training.v2
Maximum policy characters	24,000
Generator seed	1337
License	Apache 2.0

Dataset Distribution

Split	Examples	Percentage
Train	15,360	80.00%
Validation	1,792	9.33%
Test	2,048	10.67%
Total	19,200	100%

All 19,200 examples are reported by the manifest as direct training-format records.

The manifest reports zero database-source records and zero rows in its synthetic_rows field. These metadata values alone do not establish whether every example represents real-world activity. The dataset should not be treated as independently verified production telemetry without additional provenance evidence.

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, process, retain, or share information. However, determining whether observed browser activity corresponds to those disclosures requires more than identifying matching terminology.

Verity-Train-v3 supports models capable of:

• Comparing observed browser behavior against applicable privacy policy disclosures.
• Distinguishing explicitly disclosed activity from broadly or implicitly disclosed activity.
• Identifying meaningful browser behavior that is not clearly addressed in supplied privacy policies.
• Recognizing possible contradictions when strong observations conflict with explicit policy language.
• Separating observed technical evidence from inferred intent or purpose.
• Avoiding unsupported claims about tracking, fingerprinting, data collection, or transmission.
• Producing schema-constrained, machine-readable JSON reports.
• Expressing uncertainty when policy language or telemetry evidence is insufficient.

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

Dataset Structure

Verity-Train-v3 uses the same distribution strategy as previous Verity training dataset releases.

The original JSONL files are converted into sharded Parquet files for distribution through Hugging Face.

Individual Parquet shards target approximately 250 MB, supporting manageable uploads, downloads, and data processing.

Repository Layout

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

The exact number of shards depends on the compressed size of the exported dataset.

Sharding preserves the original training, validation, and test assignments. It does not create additional examples or alter their intended classification.

Training Records

The dataset uses a conversation-oriented instruction format.

Training prompts contain system-level instructions defining the evidence-correlation task and user-level instructions containing host-prepared comparison inputs.

The user messages also specify mandatory output requirements and a JSON Schema.

Models are expected to analyze the supplied evidence and generate a structured JSON report conforming to the schema.

Input Schema

Comparison inputs provide information about a website visit, its associated privacy policy, and available browser telemetry.

Field	Description
domain_url	URL of the visited website
privacy_policy_url	Verified privacy policy URL
visit	Snapshot identifier, timestamp, duration, and extension version
seen_behavior	Recorded observations and network request counts
thirdPartyHosts	Third-party network destinations
trackers	Tracker identifiers, classifications, and request counts
signals	Observed browser API activity
page	Page-level browser and storage metadata
detections	Detection indicators and severity hints
policy_document	Retrieved privacy policy sections and applicability information

The privacy policy and browser telemetry are treated as separate evidence sources.

Example Input

The following is an illustrative input, not a complete training 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.

The training methodology distinguishes three concepts.

1. Policy Disclosure

What the applicable privacy policy actually states.

Policy evidence must originate from supplied privacy policy sections rather than assumptions, generated quotations, or external knowledge.

2. Observed Browser Behavior

What the available browser telemetry demonstrates occurred during a particular visit.

For example, a cookie-read signal indicates JavaScript accessed JavaScript-readable cookies. It does not independently establish which cookie values were accessed, whether they were transmitted, or how they were subsequently processed.

3. Supported Comparison

What conclusions can reasonably be reached by comparing policy disclosures against observed activity.

A policy disclosure does not prove that behavior occurred. Similarly, observed browser activity does not automatically establish the purpose of that activity.

Comparison Categories

The training contract defines 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, the sample was insufficient, or the behavior cannot be determined through available telemetry
indeterminate	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 classifications help prevent models from treating missing observations as conclusive evidence that an activity never occurs.

Browser Behavior Coverage

The Verity comparison training contract supports several browser activity categories.

Network and Tracking

• First-party and third-party 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
• Plugins and MIME-type enumeration
• Hardware concurrency
• Device memory
• Canvas operations
• WebGL characteristics
• Fingerprinting-related signals

Additional Browser Capabilities

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

Not every example necessarily contains every category.

Evidence Grounding

Evidence grounding is central to the Verity training methodology.

The training instructions establish several requirements.

Policy quotations must be attributable. Policy evidence must originate from the supplied policy sections and reference the corresponding section heading.

Browser API usage does not automatically establish purpose. Browser properties may be accessed for compatibility, localization, analytics, security, performance, or identification.

Network requests provide limited evidence. An observed request establishes communication with a destination but does not necessarily reveal its contents or subsequent processing.

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

Contradictions require strong evidence. Vague policy language or ambiguous browser activity is insufficient to establish a meaningful contradiction.

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

Confidence is separate from severity. Confidence represents the quality of the available evidence, while severity describes the significance of the disclosure discrepancy.

These constraints are intended to reduce unsupported inferences and improve generated report reliability.

Structured Output

The training contract requires models to produce schema-constrained JSON reports.

Reports contain grouped findings associating policy disclosures with browser telemetry.

A simplified finding fragment is shown below:

{
  "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 an independently verified ground-truth label.

The complete output schema supplied inside each training prompt defines the authoritative requirements.

Data Splitting and Sharding

Verity-Train-v3 maintains source-aware train, 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 strategy is intended to reduce leakage between training and evaluation partitions by grouping examples according to their source identity or synthetic family.

The dataset reports:

• 71 families.
• 19,200 domain identifiers.
• 15,360 training examples.
• 1,792 validation examples.
• 2,048 test examples.

The split assignments are preserved when converting JSONL files into Parquet shards.

Sharding Strategy

The dataset targets approximately 250 MB per Parquet shard.

Benefits include:

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

Sharding does not inherently improve model accuracy or change the underlying training examples.

The manifest does not independently establish that every example is semantically unique or that all possible evaluation leakage has been eliminated.

Loading the Dataset

Load from Hugging Face

from datasets import load_dataset

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

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

Stream the Dataset

from datasets import load_dataset

dataset = load_dataset(
    "Veilance/Verity-Train-v3",
    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 a Training Example

For records using the documented conversation-oriented prompt format:

example = dataset["train"][0]

for message in example["prompt"]:
    print(message["role"])
    print(message["content"][:500])

Before training, inspect the complete dataset schema to identify the target-response field and verify compatibility with the chosen supervised fine-tuning pipeline.

Training Considerations

Verity-Train-v3 is designed for supervised instruction-tuning workflows involving structured evidence correlation.

Training pipelines should preserve:

• System and user message boundaries.
• Policy evidence and telemetry evidence separation.
• JSON Schema requirements.
• Comparison classifications.
• Evidence attribution constraints.
• Confidence and severity semantics.
• The distinction between observed activity and inferred purpose.

Privacy policy content embedded in a prompt must be treated as untrusted evidence rather than executable instructions.

Model evaluations should consider:

• JSON validity.
• Schema compliance.
• Policy quotation accuracy.
• Telemetry evidence fidelity.
• Comparison classification consistency.
• Unsupported inference frequency.
• Confidence calibration.

Intended Use

Verity-Train-v3 is intended for:

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

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

Limitations

Dataset Provenance

The manifest does not independently establish the real-world origin of every training example.

The reported domain count should not be interpreted as proof that 19,200 independent real-world websites were observed.

Browser Visibility

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

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

Incomplete Observations

Browser telemetry represents activity observed during a particular visit.

Behavior can vary based on session length, user interaction, authentication state, browser configuration, and application state.

Model Generalization

Performance on training and evaluation examples does not guarantee equivalent performance on live websites, real privacy policies, or previously unseen browser implementations.

Independent evaluation on representative real-world data is recommended.

Evidence Quality

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

No independent claims about those properties are made here.

Legal Interpretation

Privacy disclosure comparison results 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": 19200,
  "families": 71,
  "domains": 19200,
  "train": 15360,
  "validation": 1792,
  "test": 2048,
  "split_unit": "original source domain when present, otherwise synthetic family_id or telemetry hostname",
  "max_policy_chars": 24000,
  "input_format": "training",
  "input_records": 19200,
  "direct_training_rows": 19200,
  "database_source_records": 0,
  "synthetic_rows": 0,
  "synthetic_variants_per_database_record": 0,
  "generator_seed": "1337",
  "generator_config_sha256": "a3072e4d77aefcaecce7e72bf76e3e762199b998cd9754e7a6676bea966201cf",
  "raw_rows_output": null
}

System Prompt SHA-256

d0c48b51c267964216ede85ec92c6173c4d5d1f99c3353e816a6c10874397961

Generator Configuration SHA-256

a3072e4d77aefcaecce7e72bf76e3e762199b998cd9754e7a6676bea966201cf

These hashes identify the system prompt and generator configuration associated with this export.

Exact regeneration may require additional code and configuration not included in the dataset.

Relationship to Previous Releases

Verity-Train-v3 is a separate release within the Verity training dataset series.

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

Metric	v1	v2	v3
Examples	124,032	98,304	19,200
Families	265	21	71
Train	99,864	69,632	15,360
Validation	11,856	16,384	1,792
Test	12,312	12,288	2,048
Maximum policy characters	24,000	24,000	24,000

Verity-Train-v3 shares its reported system prompt SHA-256 with Verity-Train-v1 and its generator seed with Verity-Train-v2.

All three releases report the same generator configuration SHA-256.

The datasets differ in record counts, family counts, split distributions, and generation metadata.

These differences do not independently establish differences in model accuracy, training quality, or generalization performance.

About Verity

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

It is designed to examine how the statements made in privacy policies relate to browser activity observed through Veilance's browser privacy observability technology.

Verity focuses on evidence-grounded technical comparisons rather than unsupported conclusions about how websites process information.

Verity-Train-v3 supports this work by providing structured examples for training and evaluating privacy comparison models.

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

License

Verity-Train-v3 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-v3 for research, training, or published work, please reference the dataset repository:

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

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

Disclaimer

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

The dataset and models trained using it do not provide legal advice or conclusive evidence of the privacy practices of real-world services.

Generated findings should be independently validated before use in high-stakes decisions.