Merge branch 'main' of hf.co:datasets/philipphager/baidu-ultr_tencent-mlm-ctr

README.md

@@ -1,3 +1,105 @@
 ---
 license: cc-by-nc-4.0
+viewer: false
 ---
+# Baidu ULTR Dataset - Tencent BERT-12l-12h
+Query-document vectors and clicks for a subset of the [Baidu Unbiased Learning to Rank](https://arxiv.org/abs/2207.03051) dataset.
+This dataset uses the pretrained [BERT cross-encoder (Bert_Layer12_Head12) from Tencent](https://github.com/lixsh6/Tencent_wsdm_cup2023/tree/main/pytorch_unbias) published as part of the WSDM cup 2023 to compute query-document vectors (768 dims).
+
+## Setup
+1. Install huggingface [datasets](https://huggingface.co/docs/datasets/installation)
+2. Install [pandas](https://github.com/pandas-dev/pandas) and [pyarrow](https://arrow.apache.org/docs/python/index.html): `pip install pandas pyarrow`
+3. Optionally, you might need to install a [pyarrow-hotfix](https://github.com/pitrou/pyarrow-hotfix) if you cannot install `pyarrow >= 14.0.1` 
+4. You can now use the dataset as described below.
+
+## Load train / test click dataset:
+```Python
+from datasets import load_dataset
+
+dataset = load_dataset(
+    "philipphager/baidu-ultr_tencent-mlm-ctr",
+    name="clicks",
+    split="train", # ["train", "test"]
+    cache_dir="~/.cache/huggingface",
+)
+
+dataset.set_format("torch") #  [None, "numpy", "torch", "tensorflow", "pandas", "arrow"]
+```
+
+## Load expert annotations:
+```Python
+from datasets import load_dataset
+
+dataset = load_dataset(
+    "philipphager/baidu-ultr_tencent-mlm-ctr",
+    name="annotations",
+    split="test",
+    cache_dir="~/.cache/huggingface",
+)
+
+dataset.set_format("torch") #  [None, "numpy", "torch", "tensorflow", "pandas", "arrow"]
+```
+
+## Available features
+Each row of the click / annotation dataset contains the following attributes. Use a custom `collate_fn` to select specific features (see below):
+
+### Click dataset
+| name                         | dtype          | description |
+|------------------------------|----------------|-------------|
+| query_id                     | string         | Baidu query_id |
+| query_md5                    | string         | MD5 hash of query text |
+| url_md5                      | List[string]   | MD5 hash of document url, most reliable document identifier |
+| text_md5                     | List[string]   | MD5 hash of document title and abstract |
+| query_document_embedding     | Tensor[float16]| BERT CLS token |
+| click                        | Tensor[int32]  | Click / no click on a document |
+| n                            | int32          | Number of documents for current query, useful for padding |
+| position                     | Tensor[int32]  | Position in ranking (does not always match original item position) |
+| media_type                   | Tensor[int32]  | Document type (label encoding recommended as ids do not occupy a continous integer range) |
+| displayed_time               | Tensor[float32]| Seconds a document was displayed on screen |
+| serp_height                  | Tensor[int32]  | Pixel height of a document on screen |
+| slipoff_count_after_click    | Tensor[int32]  | Number of times a document was scrolled off screen after previously clicking on it |
+
+
+### Expert annotation dataset
+| name                         | dtype          | description |
+|------------------------------|----------------|-------------|
+| query_id                     | string         | Baidu query_id |
+| query_md5                    | string         | MD5 hash of query text |
+| text_md5                     | List[string]   | MD5 hash of document title and abstract |
+| query_document_embedding     | Tensor[float16]| BERT CLS token |
+| label                        | Tensor[int32]  | Relevance judgment on a scale from 0 (bad) to 4 (excellent) |
+| n                            | int32          | Number of documents for current query, useful for padding |
+| frequency_bucket             | int32          | Monthly frequency of query (bucket) from 0 (high frequency) to 9 (low frequency) |
+
+## Example PyTorch collate function
+Each sample in the dataset is a single query with multiple documents.
+The following example demonstrates how to create a batch containing multiple queries with varying numbers of documents by applying padding: 
+
+```Python
+import torch
+from typing import List
+from collections import defaultdict
+from torch.nn.utils.rnn import pad_sequence
+from torch.utils.data import DataLoader
+
+
+def collate_clicks(samples: List):
+    batch = defaultdict(lambda: [])
+
+    for sample in samples:
+        batch["query_document_embedding"].append(sample["query_document_embedding"])
+        batch["position"].append(sample["position"])
+        batch["click"].append(sample["click"])
+        batch["n"].append(sample["n"])
+
+    return {
+        "query_document_embedding": pad_sequence(
+            batch["query_document_embedding"], batch_first=True
+        ),
+        "position": pad_sequence(batch["position"], batch_first=True),
+        "click": pad_sequence(batch["click"], batch_first=True),
+        "n": torch.tensor(batch["n"]),
+    }
+
+loader = DataLoader(dataset, collate_fn=collate_clicks, batch_size=16)
+```

baidu-ultr_tencent-mlm-ctr.py

@@ -0,0 +1,221 @@
+from enum import Enum
+from typing import List
+
+import datasets
+import pandas as pd
+
+from datasets import Features, Value, Array2D, Sequence, SplitGenerator, Split
+
+
+_CITATION = """\
+@InProceedings{huggingface:dataset,
+    title = {philipphager/baidu-ultr_tencent-mlm-ctr},
+    author={Philipp Hager, Romain Deffayet},
+    year={2023}
+}
+"""
+
+_DESCRIPTION = """\
+Query-document vectors and clicks for a subset of the Baidu Unbiased Learning to Rank
+dataset: https://arxiv.org/abs/2207.03051
+
+This dataset uses the pretrained BERT cross-encoder (Bert_Layer12_Head12) from Tencent published
+as part of the WSDM cup 2023 to compute query-document vectors (768 dims):
+https://github.com/lixsh6/Tencent_wsdm_cup2023/tree/main/pytorch_unbias
+
+We link the model checkpoint also under `model/`. 
+"""
+
+_HOMEPAGE = "https://huggingface.co/datasets/philipphager/baidu-ultr_tencent-mlm-ctr/"
+_LICENSE = "cc-by-nc-4.0"
+_VERSION = "0.1.0"
+
+
+class Config(str, Enum):
+    ANNOTATIONS = "annotations"
+    CLICKS = "clicks"
+
+
+class BaiduUltrBuilder(datasets.GeneratorBasedBuilder):
+    VERSION = datasets.Version(_VERSION)
+    BUILDER_CONFIGS = [
+        datasets.BuilderConfig(
+            name=Config.CLICKS,
+            version=VERSION,
+            description="Load train/val/test clicks from the Baidu ULTR dataset",
+        ),
+        datasets.BuilderConfig(
+            name=Config.ANNOTATIONS,
+            version=VERSION,
+            description="Load expert annotations from the Baidu ULTR dataset",
+        ),
+    ]
+
+    CLICK_FEATURES = Features(
+        {
+            "query_id": Value("string"),
+            "query_md5": Value("string"),
+            "url_md5": Sequence(Value("string")),
+            "text_md5": Sequence(Value("string")),
+            "query_document_embedding": Array2D((None, 768), "float16"),
+            "click": Sequence(Value("int32")),
+            "n": Value("int32"),
+            "position": Sequence(Value("int32")),
+            "media_type": Sequence(Value("int32")),
+            "displayed_time": Sequence(Value("float32")),
+            "serp_height": Sequence(Value("int32")),
+            "slipoff_count_after_click": Sequence(Value("int32")),
+        }
+    )
+
+    ANNOTATION_FEATURES = Features(
+        {
+            "query_id": Value("string"),
+            "query_md5": Value("string"),
+            "text_md5": Value("string"),
+            "query_document_embedding": Array2D((None, 768), "float16"),
+            "label": Sequence(Value("int32")),
+            "n": Value("int32"),
+            "frequency_bucket": Value("int32"),
+        }
+    )
+
+    DEFAULT_CONFIG_NAME = Config.CLICKS
+
+    def _info(self):
+        if self.config.name == Config.CLICKS:
+            features = self.CLICK_FEATURES
+        elif self.config.name == Config.ANNOTATIONS:
+            features = self.ANNOTATION_FEATURES
+        else:
+            raise ValueError(
+                f"Config {self.config.name} must be in ['clicks', 'annotations']"
+            )
+
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+            homepage=_HOMEPAGE,
+            license=_LICENSE,
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager):
+        if self.config.name == Config.CLICKS:
+            train_files = self.download_clicks(dl_manager, parts=[1, 2, 3])
+            test_files = self.download_clicks(dl_manager, parts=[0])
+
+            query_columns = [
+                "query_id",
+                "query_md5",
+            ]
+
+            agg_columns = [
+                "query_md5",
+                "url_md5",
+                "text_md5",
+                "position",
+                "click",
+                "query_document_embedding",
+                "media_type",
+                "displayed_time",
+                "serp_height",
+                "slipoff_count_after_click",
+            ]
+
+            return [
+                SplitGenerator(
+                    name=Split.TRAIN,
+                    gen_kwargs={
+                        "files": train_files,
+                        "query_columns": query_columns,
+                        "agg_columns": agg_columns,
+                    },
+                ),
+                SplitGenerator(
+                    name=Split.TEST,
+                    gen_kwargs={
+                        "files": test_files,
+                        "query_columns": query_columns,
+                        "agg_columns": agg_columns,
+                    },
+                ),
+            ]
+        elif self.config.name == Config.ANNOTATIONS:
+            test_files = dl_manager.download(["parts/validation.feather"])
+            query_columns = [
+                "query_id",
+                "query_md5",
+                "frequency_bucket",
+            ]
+            agg_columns = [
+                "text_md5",
+                "label",
+                "query_document_embedding",
+            ]
+
+            return [
+                SplitGenerator(
+                    name=Split.TEST,
+                    gen_kwargs={
+                        "files": test_files,
+                        "query_columns": query_columns,
+                        "agg_columns": agg_columns,
+                    },
+                )
+            ]
+        else:
+            raise ValueError("Config name must be in ['clicks', 'annotations']")
+
+    def download_clicks(self, dl_manager, parts: List[int], splits_per_part: int = 10):
+        urls = [
+            f"parts/part-{p}_split-{s}.feather"
+            for p in parts
+            for s in range(splits_per_part)
+        ]
+
+        return dl_manager.download(urls)
+
+    def _generate_examples(
+        self,
+        files: List[str],
+        query_columns: List[str],
+        agg_columns: List[str],
+    ):
+        """
+        Reads dataset partitions and aggregates document features per query.
+        :param files: List of .feather files to load from disk.
+        :param query_columns: Columns with one value per query. E.g., query_id,
+        frequency bucket, etc.
+        :param agg_columns: Columns with one value per document that should be
+        aggregated per query. E.g., click, position, query_document_embeddings, etc.
+        :return:
+        """
+        for file in files:
+            df = pd.read_feather(file)
+            current_query_id = None
+            sample_key = None
+            sample = None
+
+            for i in range(len(df)):
+                row = df.iloc[i]
+
+                if current_query_id != row["query_id"]:
+                    if current_query_id is not None:
+                        yield sample_key, sample
+
+                    current_query_id = row["query_id"]
+                    sample_key = f"{file}-{current_query_id}"
+                    sample = {"n": 0}
+
+                    for column in query_columns:
+                        sample[column] = row[column]
+                    for column in agg_columns:
+                        sample[column] = []
+
+                for column in agg_columns:
+                    sample[column].append(row[column])
+
+                sample["n"] += 1
+
+            yield sample_key, sample