| --- |
| dataset_info: |
| features: |
| - name: id |
| dtype: string |
| - name: gid |
| dtype: string |
| - name: state |
| dtype: string |
| - name: common_question |
| dtype: string |
| - name: qno-target |
| list: |
| - name: kind |
| dtype: string |
| - name: metadata |
| dtype: string |
| - name: options |
| list: string |
| - name: question |
| dtype: string |
| - name: question_id |
| dtype: string |
| - name: target |
| list: float64 |
| splits: |
| - name: train |
| num_bytes: 89607430 |
| num_examples: 7256 |
| - name: validation |
| num_bytes: 4296681 |
| num_examples: 452 |
| - name: test |
| num_bytes: 11883647 |
| num_examples: 893 |
| download_size: 100359264 |
| dataset_size: 105787758 |
| configs: |
| - config_name: default |
| data_files: |
| - split: train |
| path: data/train-* |
| - split: test |
| path: data/test-* |
| - split: validation |
| path: data/validation-* |
| language: |
| - en |
| pretty_name: open-jev-refactored |
| task_categories: |
| - text-classification |
| tags: |
| - Jev |
| - Decision-modelling |
| - Curated-Dataset |
| --- |
| |
| ### Sample script to tokenize the dataset: |
| ``` |
| import datasets |
| from nltk.tokenize import wordpunct_tokenize |
| |
| hf_openjev_dataset_id = "Man1103/OpenJev-Refactored" |
| hf_openjev_dataset = datasets.load_dataset(path=hf_openjev_dataset_id, cache_dir="/content/data/jev/curated") |
| |
| def get_corpus(dataset): |
| total_corpus_list = [] |
| for data in dataset: |
| state = data["state"] |
| for qno_target in data["qno-target"]: |
| question = qno_target["question"] |
| options = ",".join([option for option in qno_target["options"]]) |
| total_corpus_list.append(question + options + state) |
| return total_corpus_list |
| |
| curated_dataset_train = hf_openjev_dataset["train"] |
| train_list = get_corpus(curated_dataset_train) |
| |
| curated_dataset_test = hf_openjev_dataset["test"] |
| test_list = get_corpus(curated_dataset_test) |
| |
| curated_dataset_val = hf_openjev_dataset["validation"] |
| val_list = get_corpus(curated_dataset_val) |
| |
| total_corpus = train_list + test_list + val_list |
| total_corpus = ",".join(total_corpus) |
| |
| tokens = wordpunct_tokenize(total_corpus) |
| vocab = set(tokens) |
| |
| token2idx = {token: idx for idx, token in enumerate(vocab)} |
| idx2token = {idx: token for idx, token in enumerate(vocab)} |
| |
| print(f"Token count: {len(tokens)}, Vocab size: {len(vocab)}") |
| ``` |
|
|
| ### Sample script to build training dataloader from the dataset: |
| ``` |
| import numpy as np |
| import torch |
| from torch.utils.data import DataLoader |
| from nltk.tokenize import wordpunct_tokenize |
| from datasets import Dataset |
| |
| padding_token_id = token2idx["[PAD]"] |
| unk_token_id = token2idx["[UNK]"] |
| |
| context_window = 1024 |
| target_window = 20 |
| |
| def preprocess_function(batch): |
| # Lists to store batch outputs |
| all_states = [] |
| all_qnos = [] |
| all_targets = [] |
| |
| # Process multiple samples in the batch efficiently |
| for i in range(len(batch["state"])): |
| state_str = batch["state"][i] |
| |
| # Look up key safely if naming changed slightly (e.g., options vs qno-target) |
| qno_targets = batch.get("qno-target", batch.get("options", []))[i] |
| |
| for qno_target in qno_targets: |
| question = qno_target["question"] |
| options = ",".join([option for option in qno_target["options"]]) |
| qno_str = question + options |
| target = qno_target["target"] |
| |
| # 1. Tokenize into raw strings first |
| state_tokens = wordpunct_tokenize(state_str) |
| qno_tokens = wordpunct_tokenize(qno_str) |
| |
| # 2. Convert to integer IDs FIRST (safely using UNK) |
| state_ids = [token2idx.get(t, unk_token_id) for t in state_tokens] |
| qno_ids = [token2idx.get(t, unk_token_id) for t in qno_tokens] |
| |
| # 3. NOW apply numerical truncation or padding safely |
| if len(state_ids) < context_window: |
| state_ids += [padding_token_id] * (context_window - len(state_ids)) |
| else: |
| state_ids = state_ids[:context_window] |
| |
| if len(qno_ids) < context_window: |
| qno_ids += [padding_token_id] * (context_window - len(qno_ids)) |
| else: |
| qno_ids = qno_ids[:context_window] |
| |
| if len(target) < target_window: |
| target = list(target) + [0] * (target_window - len(target)) |
| else: |
| target = list(target)[:target_window] |
| |
| all_states.append(state_ids) |
| all_qnos.append(qno_ids) |
| all_targets.append(target) |
| |
| return {"state_ids": all_states, "qno_ids": all_qnos, "target_ids": all_targets} |
| |
| # NATIVE HUGGING FACE PIPELINE |
| # Map your curated dataset over your preprocessing function (batched is fast!) |
| curated_dataset_train = hf_openjev_dataset["train"] |
| processed_dataset = curated_dataset_train.map( |
| preprocess_function, |
| batched=True, |
| remove_columns=curated_dataset_train.column_names |
| ) |
| |
| # Set format directly to PyTorch tensors so it mimics a TensorDataset |
| processed_dataset.set_format(type="torch", columns=["state_ids", "qno_ids", "target_ids"]) |
| |
| # Use the native PyTorch DataLoader directly with the HF Dataset |
| training_dataloader = DataLoader( |
| dataset=processed_dataset, |
| batch_size=32, |
| shuffle=True, |
| num_workers=2 |
| ) |
| |
| print(f"Total processed samples: {len(processed_dataset)}") |
| print(f"Total batches: {len(training_dataloader)}") |
| ``` |
|
|
| ### For researchers only - this is the script used to clone and curate this dataset from original dataset `TypeSafeAI/Open-Jev`: |
| ``` |
| def create_curated_dataset(dataset, max_samples: int): |
| selected_dataset = dataset.select(range(max_sample)) if hasattr(dataset, "select") else dataset.select(range(min(max_sample, len(dataset)))) |
| |
| # 2. OPTIMIZATION: Group by 'group_id' in O(N) time instead of using .filter() in a loop |
| grouped_data = defaultdict(list) |
| for row in selected_dataset: |
| grouped_data[row["group_id"]].append(row) |
| |
| curated_list = [] |
| |
| # 3. Process grouped data |
| for gid, rows in grouped_data.items(): |
| full_gid_sample = {} |
| options_list = [] |
| |
| for data in rows: |
| id = data["id"] |
| sample_kind = data["kind"] |
| state = data["state_json"].strip('"').strip("'") |
| question_id = data["id"] |
| question = data["question"].strip('"').strip("'") |
| options = [option.strip('"').strip("'") for option in data["options"]] |
| target = data["target"] |
| metadata = data["metadata_json"] |
| |
| qno_dict = { |
| "question_id": question_id, |
| "kind": sample_kind, |
| "question": question, |
| "options": options, |
| "target": target, |
| "metadata": metadata |
| } |
| |
| full_gid_sample["id"] = id |
| full_gid_sample["gid"] = gid |
| full_gid_sample["state"] = state |
| full_gid_sample["common_question"] = question |
| options_list.append(qno_dict) |
| |
| full_gid_sample["qno-target"] = options_list |
| curated_list.append(full_gid_sample) |
| |
| # 4. FINAL CONVERSION: Cast your curated list back to a Hugging Face Dataset |
| curated_dataset = Dataset.from_list(curated_list) |
| return curated_dataset |
| |
| # 1. FIX: Grab the first 10 elements consistently using select |
| train_set = jev_dataset["train"] |
| max_sample = len(train_set) |
| curated_dataset_train = create_curated_dataset(train_set, max_sample) |
| |
| val_set = jev_dataset["validation"] |
| max_sample = len(val_set) |
| curated_dataset_val = create_curated_dataset(val_set, max_sample) |
| |
| test_set = jev_dataset["test"] |
| max_sample = len(test_set) |
| curated_dataset_test = create_curated_dataset(test_set, max_sample) |
| |
| hf_curated_dataset = datasets.DatasetDict({ |
| "train": curated_dataset_train, |
| "validation": curated_dataset_val, |
| "test": curated_dataset_test |
| }) |
| |
| # Inspect your new standard Hugging Face dataset |
| print(hf_curated_dataset) |
| ``` |
