Verity-Train-v2

Evidence-grounded privacy policy and browser telemetry comparison training dataset

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

The dataset is designed to support language models that compare privacy policy disclosures with observed browser activity, identify disclosure discrepancies, and produce structured, evidence-grounded JSON reports.

Unlike conventional privacy policy summarization datasets, Verity-Train-v2 focuses on evidence correlation: distinguishing between what a privacy policy states, what browser telemetry establishes, and what conclusions the available evidence supports.

The dataset contains 98,304 examples, distributed across training, validation, and test splits.

Dataset Overview

Property	Value
Dataset	Verity-Train-v2
Organization	Veilance
Application	Verity Privacy Policy Comparison Engine
Total examples	98,304
Training examples	69,632
Validation examples	16,384
Test examples	12,288
Families	21
Domain identifiers	98,304
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	69,632	70.83%
Validation	16,384	16.67%
Test	12,288	12.50%
Total	98,304	100%

The dataset maintains separate training, validation, and testing partitions to support supervised fine-tuning, model selection, and evaluation.

The provided manifest reports 98,304 direct training rows, zero database-source records, and zero rows in its synthetic_rows field. These metadata fields do not independently establish that the scenarios represent real production browser observations.

Purpose

Verity-Train-v2 is intended to train models to perform evidence-based comparisons between privacy policy disclosures and browser telemetry.

Modern websites interact with browsers through network requests, cookies, local storage, browser APIs, third-party services, and other mechanisms. Privacy policies describe how organizations may collect and process information, but these disclosures do not necessarily identify every observable browser operation.

The dataset supports training models to:

• Compare observed browser activity against applicable privacy policy disclosures.
• Identify behavior that is explicitly, broadly, or implicitly disclosed.
• Identify meaningful observed activity that is not clearly disclosed.
• Recognize potential contradictions between policy statements and directly observed behavior.
• Distinguish direct telemetry evidence from inferred intent or purpose.
• Avoid unsupported claims about tracking, fingerprinting, data transmission, or server-side processing.
• Produce consistent, schema-constrained JSON reports.
• Express uncertainty when evidence is incomplete or ambiguous.

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

Dataset Structure

Verity-Train-v2 is intended for distribution through Hugging Face using sharded Parquet files.

Individual shards target approximately 250 MB, allowing more manageable storage, downloads, and dataset processing.

Repository Layout

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

The exact number of shards depends on the encoded and compressed sizes.

Sharding preserves the original train, validation, and test assignments. It does not generate new examples or alter the dataset's intended split structure.

Training Records

The dataset uses a conversation-oriented instruction format.

Each training prompt contains system-level instructions that define the evidence-correlation task and user-level instructions containing host-prepared input, mandatory output requirements, and a JSON Schema.

The expected model behavior is to analyze the provided evidence and return a JSON report conforming to the supplied schema.

Input Schema

The comparison input contains information about a website visit, the 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 browser observations and request counts
thirdPartyHosts	Third-party network destinations
trackers	Tracker classifications and associated request counts
signals	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 telemetry are treated as separate evidence sources.

Example Input

The following is a simplified 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 an evidence-correlation engine, not a general-purpose privacy policy summarizer.

The training methodology distinguishes three concepts.

1. Policy Disclosure

What the applicable privacy policy explicitly states.

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

2. Observed Browser Behavior

What the available browser telemetry directly demonstrates.

For example, an observed cookie read establishes that JavaScript accessed JavaScript-readable cookies. It does not independently establish what values were accessed, whether those values were transmitted, or how they were subsequently processed.

3. Supported Comparison

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

The resulting finding must remain limited to the available evidence.

A privacy policy disclosure does not prove that behavior occurred, and an observed browser operation does not automatically establish its ultimate purpose.

Comparison Categories

The training contract defines the following relationships:

Comparison	Description
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 is not observed, cannot be determined, or is not meaningfully testable with the available sample
indeterminate	Available evidence is insufficient for 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 prevent a model from treating missing observations as conclusive evidence that behavior never occurs.

Browser Behavior Coverage

The training contract supports multiple categories of browser activity.

Network and Tracking

• First-party and third-party requests
• Analytics-related services
• Advertising-related services
• Tracker classifications
• Third-party resource loading
• Social media tracking

Browser Storage

• Cookies
• Local storage
• Session storage
• IndexedDB
• Cache Storage
• Service workers

Browser and Device Characteristics

• User-agent access
• Navigator properties
• Browser languages
• Plugins and MIME types
• Hardware concurrency
• Device memory
• Canvas operations
• WebGL characteristics
• Fingerprinting-related activity

Additional Browser Capabilities

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

The presence of a category in the training contract does not imply that every record includes that category.

Evidence Grounding

Evidence grounding is central to the Verity training methodology.

The training instructions enforce several principles.

Policy quotations must be attributable. Evidence attributed to a privacy policy must be copied from the supplied policy sections and associated with the correct heading.

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

Network communication does not automatically establish data sharing. Observing a network destination does not reveal all request contents or downstream processing.

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

Contradictions require direct support. A vague disclosure or an ambiguous browser operation is insufficient to establish a meaningful contradiction.

Single visits provide limited visibility. The absence of an event during one visit does not demonstrate that it never occurs.

Confidence is separate from severity. Confidence indicates the strength of evidence, while severity describes the significance of the disclosure discrepancy.

The objective is to discourage overconfident conclusions and unsupported assertions.

Structured Output

Verity models are expected to generate schema-constrained JSON reports.

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

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 fragment illustrates the finding-level structure. It is not a complete report and does not constitute an independently verified reference label.

The complete JSON Schema in each training prompt defines the authoritative output requirements.

Data Splitting and Sharding

The dataset uses source-aware train, validation, and test assignments.

According to the manifest, the split unit is:

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

This strategy is intended to reduce leakage between training and evaluation partitions.

The dataset includes 21 reported families and 98,304 domain identifiers.

The split assignments are preserved during conversion from JSONL to Parquet.

Sharding Strategy

The published dataset targets approximately 250 MB per Parquet shard.

Sharding provides several operational advantages:

• More manageable downloads and uploads.
• Improved compatibility with data streaming.
• Easier processing of individual dataset partitions.
• More efficient distribution through Hugging Face.
• Reduced need to manage multi-gigabyte individual files.

Sharding does not change the semantic content of the examples or the original train, validation, and test assignments.

The manifest's splitting metadata does not independently prove the absence of all semantic duplication or evaluation leakage.

Loading the Dataset

Load Directly from Hugging Face

from datasets import load_dataset

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

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

Stream the Dataset

For workflows that do not require downloading the complete dataset:

from datasets import load_dataset

dataset = load_dataset(
    "Veilance/Verity-Train-v2",
    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 Prompt

For records with the documented prompt message structure:

example = dataset["train"][0]

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

Training pipelines should inspect the complete record schema to identify the target response field before configuring supervised loss computation.

Training Considerations

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

Training systems should preserve:

• System and user message boundaries.
• Policy evidence and telemetry evidence separation.
• The supplied JSON Schema.
• Required output fields and classification values.
• Evidence attribution requirements.
• Confidence and severity semantics.

Policy content embedded in the prompt is untrusted evidence, not an instruction source.

Models trained on this dataset should be evaluated for schema validity, correct policy quotations, evidence fidelity, classification consistency, and unsupported inference rates.

Intended Use

Verity-Train-v2 is intended for:

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

The dataset is particularly relevant to systems that correlate documented organizational practices with client-side browser observations.

Limitations

Dataset Provenance

The manifest reports zero database-source records and zero synthetic rows, but does not independently document the real-world provenance of every example.

The dataset should not be assumed to contain independently verified production telemetry or authentic website privacy policies without separate provenance documentation.

Limited Browser Visibility

Client-side telemetry cannot establish all server-side or downstream processing behavior.

Data retention, offline processing, internal access, and server-to-server transfers may remain unobservable.

Observation Scope

Browser telemetry represents activity recorded during a particular visit.

Results may vary according to session duration, authentication, user interaction, browser configuration, and application state.

Model Generalization

Performance on dataset examples does not guarantee equivalent accuracy on production websites or previously unseen privacy policies.

Independent real-world evaluation is recommended.

Evidence Quality

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

No claims about those properties are made here.

Legal Interpretation

Privacy disclosure comparisons are not determinations of legal compliance, deception, malicious intent, or regulatory violations.

Reproducibility

The accompanying manifest.json provides information about the dataset's generation configuration.

{
  "contract_version": "veilance.privacy-comparison-training.v2",
  "rows": 98304,
  "families": 21,
  "domains": 98304,
  "train": 69632,
  "validation": 16384,
  "test": 12288,
  "split_unit": "original source domain when present, otherwise synthetic family_id or telemetry hostname",
  "max_policy_chars": 24000,
  "input_format": "training",
  "input_records": 98304,
  "direct_training_rows": 98304,
  "database_source_records": 0,
  "synthetic_rows": 0,
  "synthetic_variants_per_database_record": 0,
  "generator_seed": "1337",
  "raw_rows_output": null
}

System Prompt SHA-256

c5ed33d774540748634c93ba181d2e3f64d8692a903c227b9da9a532cc044a77

Generator Configuration SHA-256

a3072e4d77aefcaecce7e72bf76e3e762199b998cd9754e7a6676bea966201cf

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

Exact regeneration may require additional source code or configuration files that are not included in the published dataset.

Relationship to Verity-Train-v1

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

Both releases use the veilance.privacy-comparison-training.v2 contract and focus on privacy policy evidence correlation.

Verity-Train-v2 contains 98,304 records across 21 reported families, compared with 124,032 records across 265 families in Verity-Train-v1.

The releases also differ in generator seed and system prompt hash.

These metadata differences do not, by themselves, establish that one dataset is more accurate, more diverse, or produces better model 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.

Verity focuses on grounded technical comparisons rather than unsupported claims about how websites process information.

Verity-Train-v2 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

License

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

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

Citation

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

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

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

Disclaimer

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

The dataset and any 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 being relied upon for high-stakes decisions.