README.md

---
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)
```