Update README.md

README.md

@@ -1,68 +1,268 @@
----
-license: apache-2.0
-dataset_info:
-- config_name: derived-split
-  features:
-  - name: question
-    dtype: string
-  - name: answer
-    dtype: string
-  splits:
-  - name: train
-    num_bytes: 5284
-    num_examples: 120
-  - name: valid
-    num_bytes: 4808
-    num_examples: 104
-  download_size: 6274
-  dataset_size: 10092
-- config_name: direct-split
-  features:
-  - name: question
-    dtype: string
-  - name: answer
-    dtype: string
-  splits:
-  - name: train
-    num_bytes: 9726
-    num_examples: 216
-  - name: valid
-    num_bytes: 366
-    num_examples: 8
-  download_size: 5842
-  dataset_size: 10092
-- config_name: random-split
-  features:
-  - name: question
-    dtype: string
-  - name: answer
-    dtype: string
-  splits:
-  - name: train
-    num_bytes: 11497
-    num_examples: 240
-  - name: valid
-    num_bytes: 11158
-    num_examples: 240
-  download_size: 38532
-  dataset_size: 22655
-configs:
-- config_name: derived-split
-  data_files:
-  - split: train
-    path: derived-split/train-*
-  - split: valid
-    path: derived-split/valid-*
-- config_name: direct-split
-  data_files:
-  - split: train
-    path: direct-split/train-*
-  - split: valid
-    path: direct-split/valid-*
-- config_name: random-split
-  data_files:
-  - split: train
-    path: random-split/train-*
-  - split: valid
-    path: random-split/valid-*
----
+---
+license: apache-2.0
+dataset_info:
+- config_name: derived-split
+  features:
+  - name: question
+    dtype: string
+  - name: answer
+    dtype: string
+  splits:
+  - name: train
+    num_bytes: 5284
+    num_examples: 120
+  - name: valid
+    num_bytes: 4808
+    num_examples: 104
+  download_size: 6274
+  dataset_size: 10092
+- config_name: direct-split
+  features:
+  - name: question
+    dtype: string
+  - name: answer
+    dtype: string
+  splits:
+  - name: train
+    num_bytes: 9726
+    num_examples: 216
+  - name: valid
+    num_bytes: 366
+    num_examples: 8
+  download_size: 5842
+  dataset_size: 10092
+- config_name: random-split
+  features:
+  - name: question
+    dtype: string
+  - name: answer
+    dtype: string
+  splits:
+  - name: train
+    num_bytes: 11497
+    num_examples: 240
+  - name: valid
+    num_bytes: 11158
+    num_examples: 240
+  download_size: 38532
+  dataset_size: 22655
+configs:
+- config_name: derived-split
+  data_files:
+  - split: train
+    path: derived-split/train-*
+  - split: valid
+    path: derived-split/valid-*
+- config_name: direct-split
+  data_files:
+  - split: train
+    path: direct-split/train-*
+  - split: valid
+    path: direct-split/valid-*
+- config_name: random-split
+  data_files:
+  - split: train
+    path: random-split/train-*
+  - split: valid
+    path: random-split/valid-*
+---
+
+A synthetic dataset to test memorization capabilities of an LLM.
+
+Code used to create the dataset:
+
+```python
+import argparse
+import random
+
+import pandas as pd
+from datasets import Dataset
+
+kv_templates = [
+    "What is the value of {key}?",
+    "What number is assigned to {key}?",
+    "In this dataset, what does {key} represent?",
+]
+
+rel_templates = [
+    "What is the relationship between {key1} and {key2}?",
+    "How does {key1} compare to {key2}?",
+    "Is {key1} greater than, less than, or equal to {key2}?",
+]
+
+arithmetic_templates = [
+    "What is {key1} {operation} {key2}?",
+    "If you {operation_word} {key1} and {key2}, what do you get?",
+    "Calculate {key1} {operation} {key2}.",
+    "What's the result when you {operation_word} the values of {key1} and {key2}?",
+]
+
+op_dict = {"+": "add", "-": "subtract", "*": "multiply"}
+
+
+def generate_key_value_pairs(num_pairs, amax=32, offset=0):
+    pairs = {}
+    for i in range(num_pairs):
+        key = f"x{i + offset}"
+        value = random.randint(-amax, amax)
+        pairs[key] = value
+    return pairs
+
+
+def generate_relations(kv_pairs, num_gen_relations=None):
+    relations = []
+    keys = list(kv_pairs.keys())
+
+    if num_gen_relations is None:
+        relation_fraction = 1.0  # 0.5
+        max_num_relations = len(keys) * (len(keys) - 1) // 2 - len(keys)
+        num_gen_relations = int(relation_fraction * max_num_relations)
+
+    visited = set()
+    while len(visited) < num_gen_relations:
+        key1, key2 = random.sample(keys, 2)
+        if key1 == key2:
+            continue
+        pair = tuple(sorted([key1, key2]))
+        if pair in visited:
+            continue
+        visited.add(pair)
+
+        if kv_pairs[key1] > kv_pairs[key2]:
+            relation = ">"
+        elif kv_pairs[key1] < kv_pairs[key2]:
+            relation = "<"
+        else:
+            relation = "="
+
+        relations.append(f"{key1} {relation} {key2}")
+    return relations
+
+
+def generate_compositions(kv_pairs, num_gen_compositions=None):
+    combined_facts = []
+    operator_set = ["+", "-", "*"]
+    keys = list(kv_pairs.keys())
+
+    if num_gen_compositions is None:
+        composition_fraction = 1.0  # 0.5
+        max_num_compositions = len(keys) * (len(keys) - 1) // 2 * len(operator_set)
+        num_gen_compositions = int(composition_fraction * max_num_compositions)
+
+    visited = set()
+    while len(visited) < num_gen_compositions:
+        key1, key2 = random.sample(keys, 2)
+        operation = random.choice(operator_set)
+
+        instance = tuple(sorted([key1, key2, operation]))
+        if instance in visited:
+            continue
+        visited.add(instance)
+
+        if operation == "+":
+            result = kv_pairs[key1] + kv_pairs[key2]
+            fact = f"{key1} + {key2} = {result}"
+        elif operation == "-":
+            result = kv_pairs[key1] - kv_pairs[key2]
+            fact = f"{key1} - {key2} = {result}"
+        elif operation == "*":
+            result = kv_pairs[key1] * kv_pairs[key2]
+            fact = f"{key1} * {key2} = {result}"
+
+        combined_facts.append(fact)
+
+    return combined_facts
+
+
+def create_examples(kv_size=8):
+    num_pairs = kv_size
+
+    kv_pairs = generate_key_value_pairs(num_pairs)
+    relations = generate_relations(kv_pairs)
+    compositions = generate_compositions(kv_pairs)
+
+    example_dict = {}
+
+    examples = []
+    for key, value in kv_pairs.items():
+        template = random.choice(kv_templates)
+        examples.append(
+            {
+                "question": template.format(key=key),
+                "answer": f"{value}",
+            }
+        )
+    example_dict["direct"] = examples
+
+    examples = []
+    for relation in relations:
+        key1, rel, key2 = relation.split()
+        template = random.choice(rel_templates)
+        examples.append({"question": template.format(key1=key1, key2=key2), "answer": relation})
+    example_dict["relations"] = examples
+
+    examples = []
+    for ex in compositions:
+        lhs, rhs = ex.split("=")
+        answer = rhs.strip()
+        key1, op, key2 = lhs.split()
+        operation_word = op_dict[op]
+
+        template = random.choice(arithmetic_templates)
+
+        examples.append(
+            {
+                "question": template.format(key1=key1, key2=key2, operation=op, operation_word=operation_word),
+                "answer": answer,
+            }
+        )
+    example_dict["compositions"] = examples
+    return example_dict
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--kv_size", type=int, default=8, help="Number of key-value pairs")
+    ap.add_argument("--split_strategy", type=str, default="random", help="Split strategy for training and evaluation data")
+    ap.add_argument("--seed", type=int, default=42, help="Random seed for reproducibility")
+    args = ap.parse_args()
+
+    # set seed
+    random.seed(args.seed)
+
+    if args.split_strategy == "random":
+        example_dict = create_examples(kv_size=args.kv_size)
+        all_examples = example_dict["direct"] + example_dict["relations"] + example_dict["compositions"]
+        # 50-50 split
+        random.shuffle(all_examples)
+        split_idx = len(all_examples) // 2
+        train_examples = all_examples[:split_idx]
+        eval_examples = all_examples[split_idx:]
+
+    else:
+        example_dict_part_a = create_examples(kv_size=args.kv_size // 2)
+        example_dict_part_b = create_examples(kv_size=args.kv_size // 2)
+
+        part_a_examples = example_dict_part_a["direct"] + example_dict_part_a["relations"] + example_dict_part_a["compositions"]
+        part_b_direct_examples = example_dict_part_b["direct"]
+        part_b_derived_examples = example_dict_part_b["relations"] + example_dict_part_b["compositions"]
+
+        if args.split_strategy == "direct":
+            train_examples = part_a_examples + part_b_derived_examples
+            eval_examples = part_b_direct_examples
+
+        elif args.split_strategy == "derived":
+            train_examples = part_a_examples + part_b_direct_examples
+            eval_examples = part_b_derived_examples
+
+    # push to HF
+    train_ds = Dataset.from_pandas(pd.DataFrame(train_examples), preserve_index=False)
+    eval_ds = Dataset.from_pandas(pd.DataFrame(eval_examples), preserve_index=False)
+
+    train_ds.push_to_hub("rbiswasfc/synthetic-kv", f"{args.split_strategy}-split", split="train")
+    eval_ds.push_to_hub("rbiswasfc/synthetic-kv", f"{args.split_strategy}-split", split="valid")
+
+
+# python generate_datasets.py --kv_size 16 --split_strategy derived --seed 42
+
+```