APeB Personalized Candidate Selection Dataset

English (default) | 中文

License: The data and accompanying documentation of this dataset are licensed under CC BY-NC-ND 4.0. Sharing is permitted only for noncommercial purposes with attribution; commercial use and distribution of adapted versions are prohibited. See License and LICENSE in this package.

This dataset is the release and audit package for APeB. It evaluates whether a model or agent can combine a proxy history with the current query and identify the ground-truth (GT) product from a given candidate set. The package is a privacy-processed synthetic proxy benchmark, constructed with human review and model assistance from coarse task patterns and interest semantics observed in behavioral data.

Important: this package is not a real-user behavior log and contains no real-user trajectory. Its queries, candidate products, GT labels, and histories were replaced, generalized, deidentified, or numerically perturbed. The displayed actions and content were combined for evaluation and are not evidence that a real person searched for, viewed, liked, added, or purchased them. See Data authenticity and privacy processing.

1. Task definition

Each sample consists of three input components and one evaluation label:

• history: product or video interactions, such as viewing product details, liking a video, adding a product to the cart, or ordering a product;
• query: a privacy-processed approximate-semantic English search phrase expressing the current intent;
• candidates: the product list from which the model may choose;
• answer: the 1-based position of the GT in that sample's candidate list.

Formally, given a history H, a query q, and an ordered candidate set C = [c1, c2, ..., cm], the model predicts y ∈ {1, ..., m}. The label is stored as "answer": [y].

This is a closed-set candidate selection task:

• the GT is already present in the sample's candidates block;
• the model returns a candidate position rather than generating a new product;
• the value in answer refers only to the order shown inside the prompt. It is not an insertion position in a detail dictionary and is not an internal candidate ID;
• all 6,242 samples in this release have exactly one GT, and every GT index is valid for its candidate list.

A minimal evaluation looks like this:

model_input = record["prompt"]       # Give only the prompt to the model
gold_index = record["answer"][0]    # 1-based
is_correct = predicted_index == gold_index

# If the model returns a ranked Top-K list of candidate positions:
recall_at_k = gold_index in predicted_indices[:k]

2. Data authenticity and privacy processing

2.1 The displayed behaviors are not original real-world behaviors

Every history in this package is a privacy-processed synthetic proxy history constructed for personalization evaluation. Record-level combinations of query, history, candidates, and GT were constructed with human review and model assistance; they are not simply anonymized trajectories that still correspond to real individuals. Consequently:

• actions such as view product details, like video, add product to cart, and order product are benchmark signals only;
• the records must not be used to reconstruct, identify, or describe a real person's browsing, liking, cart, or purchase activity;
• action types and coarse categories may retain preference cues needed by the task, but the displayed items, videos, and anonymous IDs must not be treated as the original objects.
• the GT selected by answer is an evaluation label for candidate selection, not evidence that a real person purchased that product.

Numeric values and timestamps were also processed before release:

• Price perturbation: product prices were perturbed and are not original transaction or market prices. A small number of processed values may happen to equal their pre-processing value; this does not make them real prices.
• Timestamp shifting: timestamps for retained behaviors within one sample were shifted by a common offset and are not original calendar times. Their within-sample time differences are preserved, but the absolute timestamps must not be used for real-world event alignment, activity analysis, or inference about a person's schedule.
• ID remapping: record IDs and product/video action IDs are release identifiers, not original user, product, or video IDs.

2.2 Queries were rewritten as approximate-semantic English searches

Published queries were privacy-processed and human-reviewed, and are presented as concise approximate-semantic English search phrases. The process removes or generalizes brands, shops, person names, exact locations, accounts, contact details, and other distinctive entities while retaining product category, use, quantity, important attributes, and search intent where possible. A published phrase may be broader than its pre-processing form and must not be used to infer the original search text.

Each record's published query appears both inside the prompt's <query>...</query> block and in query_id_mapping.jsonl. The public mapping contains only release IDs and processed queries; it does not contain original queries.

2.3 Product and video content was replaced using coarse interests

Product text in histories, candidates, and GT labels, as well as video text in histories, was replaced, rewritten, or generalized according to broad interest themes. This includes fields such as:

• product names, descriptions, brands, shops, and attributes;
• video titles, descriptions, OCR, ASR, and products introduced in videos;
• readable metadata associated with that content.

The purpose is to preserve coarse interest semantics—for example beauty, apparel, or floral DIY—so that the history + query → candidate personalization task remains evaluable. The release does not preserve original item/video identity and does not assert a one-to-one correspondence between published text and real-world content.

The package is therefore suitable for candidate selection, ranking, and personalization reasoning. It is not suitable for real-user profiling, real-behavior statistics, price modeling, market analysis, real-world time-series analysis, or retrieval of original content. It is a synthetic proxy benchmark constructed from coarse behavioral patterns, not a set of real-user trajectories. This documentation also does not claim differential privacy or any formal privacy guarantee beyond the processing described above.

3. Download and dataset size

The released dataset is hosted on Hugging Face. Download it with the huggingface_hub command line:

pip install -U huggingface_hub
hf download <HF_DATASET_ID> --repo-type dataset --local-dir <dataset-directory>

Add --revision <commit> when you need to reproduce a specific snapshot.

The audited release contains:

Item	Value
Data files	43 (42 JSON + 1 JSONL)
Samples	6,242
Query IDs	4,886
File buckets	14
Total data-file size	5.694 GB (5.303 GiB)
History actions per prompt	29–60; 6,147 samples contain 60 actions
Candidates per sample	9–79

4. Directory layout and four file families

<dataset-directory>/
├── LICENSE
├── README.md
├── README_ZH.md
├── query_id_mapping.jsonl
├── simple_prompt/
│   └── enselected_encrypted_open/
│       ├── 1016_1020_prompt.json
│       ├── 1021_1025_prompt.json
│       └── ...
└── history_details/
    └── enselected_240_encrypted_open/
        ├── 1016_1020_detailed_information.json
        ├── 1016_1020_detailed_information_dict.json
        ├── 1021_1025_detailed_information.json
        ├── 1021_1025_detailed_information_dict.json
        └── ...

The three JSON families share the same <bucket> prefix; the JSONL mapping covers all buckets:

Path	Files / size	Purpose
simple_prompt/enselected_encrypted_open/<bucket>_prompt.json	14 / 77.76 MiB	Primary task entry point containing model input prompt and GT answer
history_details/enselected_240_encrypted_open/<bucket>_detailed_information.json	14 / 2.701 GiB	Expanded, human-readable details; nested values are multiline strings with <<<...>>> markers
history_details/enselected_240_encrypted_open/<bucket>_detailed_information_dict.json	14 / 2.525 GiB	Expanded, structured details; nested values are objects and this format is recommended for programmatic analysis
query_id_mapping.jsonl	1 / 0.65 MiB	Per-record mapping of record_id, bucket, query ID, and privacy-processed query

For a given <bucket>, all three JSON files use the same set of top-level record_id values. The standard task requires only *_prompt.json. The two detail files provide supplementary audit views of the same samples; they do not contain a separate label set. query_id_mapping.jsonl can be used independently to join each record to its published query. Each detail record contains 36–240 expanded history actions, and 5,543 records contain the full 240.

Bucket names come from filenames. This README treats them only as grouping labels and does not infer real calendar meaning or a train/validation/test split from them. There is no 1111_1115 bucket in this release.

Bucket	Numeric record_id range	Samples
1016_1020	0000000000000000001–0000000000000000094	94
1021_1025	0000000000000000095–0000000000000000181	87
1026_1100	0000000000000000182–0000000000000000274	93
1101_1105	0000000000000000275–0000000000000000368	94
1106_1110	0000000000000000369–0000000000000000522	154
1116_1120	0000000000000000523–0000000000000000587	65
1121_1125	0000000000000000588–0000000000000000852	265
1126_1200	0000000000000000853–0000000000000001331	479
1201_1205	0000000000000001332–0000000000000001857	526
1206_1210	0000000000000001858–0000000000000002461	604
1211_1215	0000000000000002462–0000000000000003337	876
1216_1220	0000000000000003338–0000000000000004068	731
1221_1225	0000000000000004069–0000000000000004819	751
1226_1230	0000000000000004820–0000000000000006242	1,423

5. Locating history, query, candidates, and GT

5.1 Start with a prompt file

Each *_prompt.json is a JSON object keyed by zero-padded, 19-character record IDs:

{
  "0000000000000000001": {
    "prompt": "<history>\n...\n</history>\n<query>\n...\n</query>\n<candidates>\n...\n</candidates>\n",
    "answer": [11]
  }
}

Inside the prompt string:

• <history>...</history> is the compact history visible to the model;
• <query>...</query> is the privacy-processed current query; the same text is also stored in query_id_mapping.jsonl, while detail files have no separate query field;
• <candidates>...</candidates> is an ordered candidate list numbered from 1;
• answer[0] is the position of the GT in that list.

For standard benchmark evaluation, send the complete record["prompt"] to the model and score it against record["answer"]. There is no need to load the multi-gigabyte detail files.

5.2 Use the query ID mapping

Each line of query_id_mapping.jsonl corresponds to one prompt record, sorted by record_id:

{"record_id":"0000000000000000001","bucket":"1016_1020","query_id":"Q001834","query":"dahlia and rose satin bouquet"}

• record_id is the corresponding top-level key in a prompt JSON file, and bucket locates that file;
• query_id is an opaque release ID; the same query ID may be associated with multiple records;
• query exactly matches the corresponding prompt's <query>...</query> block;
• the mapping contains 6,242 rows and 4,886 query IDs, with no original queries.

Join on record_id and also verify that bucket matches the prompt filename. Do not interpret the numeric part of a query ID as record order, a user ID, or a real-world object ID.

5.3 Join details by bucket and record ID only when needed

For example, given the prompt path:

simple_prompt/enselected_encrypted_open/1016_1020_prompt.json

the corresponding structured detail path is:

history_details/enselected_240_encrypted_open/1016_1020_detailed_information_dict.json

Use the same top-level record_id:

{
  "0000000000000000001": {
    "history_actions_informations": {
      "0000000000000000001p": {"action_time": "...", "action_type": "..."},
      "0000000000000000002v": {"action_time": "...", "action_type": "..."}
    },
    "candidates_informations": {
      "0000000000000000241p": {"product_name": "...", "price": "..."}
    }
  }
}

In this release, records ending in p carry product fields and records ending in v carry video fields. Common fields include:

Object	Common fields
Product history	action_time, action_type, product_name, product_description, price, categories, brand_name, shop_name, attributes, extra_information
Video history	action_time, action_type, video_title, video_description, staytime, ocr_text, asr_text, product_introducted_in_this_video, product_description, price, categories, brand_name, shop_name
Candidate product	product_name, price, product_description, categories, brand_name, shop_name, attributes, extra_information

informations and product_introducted_in_this_video are the spellings used by the data. Consumers must not silently rename them while reading the raw files.

The detail view is not a positional mapping of the prompt. A full audit of this release found that:

• in all 6,242 samples, prompt candidate order differs from the insertion order of candidates_informations;
• product_name + price uniquely matches the GT to a detail entry for 6,078 samples (97.37%); the remaining 164 samples have no exact match, mainly because the two views use different replacement text;
• 473 samples do not have identical prompt/detail candidate-content multisets; 0000000000000004535 also has different candidate counts (45 in the prompt and 44 in the detail view).

Details are therefore best-effort supplementary information: use expanded fields when content matches, but never revise the GT when it does not. Task input, candidate order, and labels are always authoritative in *_prompt.json.

6. End-to-end case: from query to GT and its detailed product

The following is a synthetic proxy sample from the current release, abbreviated to the text needed to explain the task.

bucket:    1016_1020
record_id: 0000000000000000001
query_id:  Q001834

Its compact history contains 60 rows. Signals related to the current intent include:

41. like ecommerce video; Product introduced: satin floral stems ...
42. like ecommerce video; Video title: ... ribbonflowers ... bouquetideas ...
43. order product; Product name: 4cm Satin Gift Wrapping Ribbon Roll ...
49. add product to cart; Product name: 2cm Satin Ribbon Roll ...
50. order product; Product name: 4cm Satin Ribbon Roll ... Flower Crafting ...
51. order product; Product name: Green Wire Mesh for DIY Floral Crafting ...
59. like video; Video title: Satin Ribbon Floral DIY ...
60. interact with ecommerce video; Video title: ... ribbon flower creations ...

The corresponding row in query_id_mapping.jsonl is:

{"record_id":"0000000000000000001","bucket":"1016_1020","query_id":"Q001834","query":"dahlia and rose satin bouquet"}

The prompt query matches the published query in that mapping:

dahlia and rose satin bouquet

There are 12 candidates, including bouquet wrapping paper, a hot-glue gun, decorative lights, flower stems, and a floral craft kit. The label is:

"answer": [11]

The GT is therefore candidate 11 in the prompt:

11. Product name: Assorted Ribbons, Stems & Craft Supplies Kit with
    Step-by-Step Guide for DIY Flower Bouquets and Decorative Arrangements;
    Price: 0.16 usd

This case captures the task: the query expresses a current need for a satin dahlia/rose bouquet, while the history repeatedly signals ribbons, floral crafts, stems, and DIY tools. The model must choose the labeled bouquet-material kit from the fixed candidate set.

To inspect the full GT description, match its product name and price in the same bucket's _detailed_information_dict.json. This identifies:

candidate item ID: 0000000000000000247p

Crucially, this item is the seventh JSON entry in candidates_informations, not the eleventh. Do not implement the join as list(candidates_informations.values())[answer - 1].

Likewise, this sample has 240 expanded history actions in the detail file but only 60 compact history rows in its prompt. These views serve different purposes and must not be aligned position by position.

Runnable loading example

Run the code below from the dataset root; if you run it from the repository root, set DATA_ROOT to the dataset directory path.

import json
import re
from pathlib import Path

DATA_ROOT = Path(".")
bucket = "1016_1020"
record_id = "0000000000000000001"

prompt_path = (
    DATA_ROOT
    / "simple_prompt"
    / "enselected_encrypted_open"
    / f"{bucket}_prompt.json"
)
detail_path = (
    DATA_ROOT
    / "history_details"
    / "enselected_240_encrypted_open"
    / f"{bucket}_detailed_information_dict.json"
)
query_mapping_path = DATA_ROOT / "query_id_mapping.jsonl"

with prompt_path.open(encoding="utf-8") as f:
    prompt_records = json.load(f)

record = prompt_records[record_id]
match = re.fullmatch(
    r"<history>\n(?P<history>.*?)\n</history>\n"
    r"<query>\n(?P<query>.*?)\n</query>\n"
    r"<candidates>\n(?P<candidates>.*?)\n</candidates>\n?",
    record["prompt"],
    flags=re.DOTALL,
)
if match is None:
    raise ValueError("Unexpected prompt format")

history_text = match.group("history")
query = match.group("query").strip()
candidate_rows = [
    (int(m.group(1)), m.group(2))
    for m in re.finditer(
        r"^(\d+)\.\s+(.*)$",
        match.group("candidates"),
        flags=re.MULTILINE,
    )
]

with query_mapping_path.open(encoding="utf-8") as f:
    query_metadata = next(
        json.loads(line)
        for line in f
        if json.loads(line)["record_id"] == record_id
    )

assert query_metadata["bucket"] == bucket
assert query_metadata["query"] == query

answer_index = record["answer"][0]  # 1-based
candidate_by_index = dict(candidate_rows)
gt_text = candidate_by_index[answer_index]

print("query ID:", query_metadata["query_id"])
print("query:", query)
print("history actions:", len(re.findall(r"^\d+\. Action type:", history_text, re.MULTILINE)))
print("candidate count:", len(candidate_rows))
print("GT index:", answer_index)
print("GT candidate:", gt_text)

# Details are optional. Never index the detail dictionary with answer_index.
with detail_path.open(encoding="utf-8") as f:
    detail_records = json.load(f)

prefix = "Product name: "
payload = gt_text[len(prefix):] if gt_text.startswith(prefix) else gt_text
gt_name, gt_price = payload.rsplit("; Price: ", maxsplit=1)

candidate_details = detail_records[record_id]["candidates_informations"]
detail_matches = [
    (item_id, item)
    for item_id, item in candidate_details.items()
    if item.get("product_name") == gt_name and item.get("price") == gt_price
]

print("matching detail item IDs:", [item_id for item_id, _ in detail_matches])

The important output is:

query ID: Q001834
query: dahlia and rose satin bouquet
history actions: 60
candidate count: 12
GT index: 11
GT candidate: Product name: Assorted Ribbons, Stems & Craft Supplies Kit ...; Price: 0.16 usd
matching detail item IDs: ['0000000000000000247p']

Name and price uniquely identify this case, but 164 samples in the current release cannot be matched this way. If multiple entries match, add other published fields such as description or category; if none match, do not force a positional join. Standard GT evaluation always uses the candidate position in the prompt.

7. Common pitfalls

1. GT is 1-based. answer: [11] means candidate 11; in a Python list that is candidates[10].
2. Do not interpret answer using detail dictionary order. Prompt candidate order differs from the insertion order of candidates_informations in all 6,242 samples.
3. Do not align the two history views by position. Detail files usually expose a larger history set, while the prompt contains the compact selection actually shown to the model. Their counts and order may differ.
4. Keep IDs as strings. Top-level IDs have 19 characters with leading zeros; nested IDs also have a p or v suffix.
5. Fields are not fully normalized. A missing value may be the literal string "None"; attributes is often a stringified dictionary; and a price is a currency-bearing string such as "0.16 usd".
6. Do not rely on JSON object order. Even record insertion order in the final bucket does not equal numeric record_id order. Look up keys directly or sort them explicitly.
7. The query appears in both the prompt and the standalone mapping. They must agree by record_id; detail files have no separate query field.
8. Plan for memory use. The largest individual detail files are hundreds of MiB. Process one bucket at a time or use a streaming JSON parser in memory-constrained environments.
9. encrypted_open is a release directory name. The files contain readable plaintext JSON. The relevant privacy processing is query rewriting, content substitution, price perturbation, timestamp shifting, and ID remapping; the directory name does not mean that the files remain cryptographically encrypted.

8. Recommended experimental boundaries

• Give the model only prompt, so that answer or supplementary detail fields cannot leak into its input.
• State whether evaluation uses exact match, Recall@K, or another metric, and document how model output is parsed into candidate positions.
• Retain bucket and record_id in experiment outputs for reproducibility and error analysis.
• Interpret this dataset only as a human-reviewed, model-assisted synthetic proxy benchmark. Do not treat its queries, histories, candidates, GT labels, prices, timestamps, anonymous IDs, or replacement content as facts about real users.

9. Brand, shop, and query privacy-processing derivative

This release is a privacy-processed derivative of the audited package. Brands, shops, and queries were processed as follows:

• values of the structured brand_name field use globally consistent placeholders such as [BRAND_000001];
• values of the structured shop_name field use globally consistent placeholders such as [SHOP_000001];
• missing-value sentinels in structured fields (for example None, null, N/A, and nan) are preserved and are not treated as names;
• the same normalized name (Unicode NFC, trimmed and collapsed whitespace, case-insensitive) receives the same number across all buckets, histories, and candidate records;
• in other string fields, an exact occurrence of a brand or shop name found in the current record's structured fields is replaced with its corresponding placeholder; when the same literal is active as both a brand and a shop, ambiguous free text uses [ENTITY_000001] placeholders;
• prices, timestamps, actions, categories, and other non-brand/shop fields are not intentionally changed, except that recognized brand/shop occurrences inside their text are replaced;
• no raw-name-to-placeholder mapping file is written; mappings exist only in process memory while the transformation runs.
• queries in all 14 prompt files were replaced with reviewed approximate-semantic English search phrases; the same query ID always uses the same published text across records;
• query_id_mapping.jsonl publishes only per-record query IDs and processed text, never original queries, model candidates, or review artifacts.

Placeholders and query IDs preserve only the cross-record consistency needed for evaluation. They do not represent real brands, shops, products, or user identities. Evaluation can continue to use prompt and answer from *_prompt.json; detail files and the query mapping remain joinable by the same record_id. The complete audit package is a manually reviewed synthetic dataset inspired by coarse patterns in real behavior, not a real-user trajectory.

10. License

10.1 Scope and attribution

The data files and accompanying documentation of this dataset are made available by APeB Benchmark Authors under the Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International license (CC BY-NC-ND 4.0). The LICENSE file in this package carries the license notice; the full legal code and other language versions are available on the Creative Commons license page.

Use the following attribution when redistributing the licensed material:

APeB Benchmark Authors. APeB Personalization Dataset
Source: []
Licensed under CC BY-NC-ND 4.0: https://creativecommons.org/licenses/by-nc-nd/4.0/

10.2 Permitted and prohibited uses

Subject to the full legal code:

• You may copy and share dataset copies or extracts that do not constitute Adapted Material for noncommercial purposes, provided that the attribution, source, and license link are retained.
• You may not use the dataset for purposes primarily intended for commercial advantage or monetary compensation.
• You may produce and retain Adapted Material privately for noncommercial purposes, but you may not publish, upload, or otherwise Share that Adapted Material.
• Technical format changes necessary to read, store, or use the data do not by themselves create Adapted Material.
• Fair use, fair dealing, and other applicable exceptions and limitations that do not require the licensor's permission are not restricted by this license.