nreHieW/longwriter-sentences-paraphrased-binned

There are 200 samples in each of the 5 bins:

• > 4096
• > 8192
• > 16384
• > 32768
• > 65546

This was created using the following script:

import json
import os
import random

from datasets import Dataset, load_dataset
import tiktoken


def test_dataset(dataset: list, tokenizer, bin_edges):
    # Expect bin_edges of length N+1 describing N bins: [e0, e1, ..., eN]
    counts = [0 for _ in range(len(bin_edges) - 1)]
    for sample in dataset:
        assert sample["answer"] in sample["text"], f"Answer: {sample['answer']}\n\nText: {sample['text']}"
        tokens = len(tokenizer.encode(sample["text"]))
        bin_idx = None
        for i in range(len(bin_edges) - 1):
            lo = bin_edges[i]
            hi = bin_edges[i + 1]
            if (i == 0 and lo <= tokens <= hi) or (i > 0 and lo < tokens <= hi):
                bin_idx = i
                break
        assert bin_idx is not None, f"Token count {tokens} fell outside defined bins"
        counts[bin_idx] += 1
    print(counts)
    assert sum(counts) == len(dataset)
    assert max(counts) - min(counts) <= 2, f"Counts: {counts}"


def main():
    tokenizer = tiktoken.get_encoding("cl100k_base")
    # Token count of the separator used when concatenating items
    separator_tokens = len(tokenizer.encode("\n\n"))
    # Define bins
    bin_edges = [4096, 8192, 16384, 32768, 65536, 128000]
    bin_labels = [
        "[4096, 8192]",
        "(8192, 16384]",
        "(16384, 32768]",
        "(32768, 65536]",
        "(65536, 128k]",
    ]
    num_bins = len(bin_labels)

    # Load dataset
    ds = load_dataset("nreHieW/longwriter-sentences-paraphrased", split="train")
    ds = ds.filter(lambda x: not x["answer"].startswith(("#", "\n", "*", ">", "-", "_", "`", "="))).filter(lambda x: x["answer"] in x["text"])
    items = [ds[i] for i in range(len(ds))]

    # Pre-tokenize each item once and use prefix sums for fast window counts
    tokens_per_item = [len(tokenizer.encode(item["text"])) for item in items]
    prefix = [0]
    for t in tokens_per_item:
        prefix.append(prefix[-1] + t)

    # Helper to compute exact text token count for a window [s, e)
    def window_tokens(s: int, e: int) -> int:
        if e <= s:
            return 0
        gaps_local = e - s - 1
        return (prefix[e] - prefix[s]) + gaps_local * separator_tokens

    # Target candidate count per bin
    target_per_bin = 200
    counts = [0 for _ in range(num_bins)]
    windows_per_bin: list[list[dict]] = [[] for _ in range(num_bins)]

    attempts = 0
    max_attempts = target_per_bin * num_bins * 20
    n_items = len(items)

    while attempts < max_attempts:
        attempts += 1
        if n_items == 0:
            break

        # Choose the bin with the fewest collected samples so far
        target_bin_idx = min(range(num_bins), key=lambda i: counts[i])
        if counts[target_bin_idx] >= target_per_bin:
            if all(c >= target_per_bin for c in counts):
                break
            else:
                continue

        lo = bin_edges[target_bin_idx]
        hi = bin_edges[target_bin_idx + 1]

        # Try multiple random starts to find a window in [lo, hi]
        found_window = False
        for _ in range(20):
            start = random.randint(0, n_items - 1)

            # Exponential growth to find upper bound where tokens >= lo
            low_end = start + 1
            high_end = start + 1
            while high_end < n_items and window_tokens(start, high_end) < lo:
                low_end = high_end
                high_end = min(n_items, start + (high_end - start) * 2)

            if high_end >= n_items and window_tokens(start, high_end) < lo:
                continue

            # Binary search to find minimal end with tokens >= lo
            left = max(low_end, start + 1)
            right = high_end
            while left < right:
                mid = (left + right) // 2
                t = window_tokens(start, mid)
                if t >= lo:
                    right = mid
                else:
                    left = mid + 1
            end = left
            n_tokens = window_tokens(start, end)

            if lo <= n_tokens <= hi:
                found_window = True
                break

        if not found_window:
            continue

        # Record this window for the target bin (store text token count)
        counts[target_bin_idx] += 1
        windows_per_bin[target_bin_idx].append(
            {
                "start": start,
                "end": end,  # exclusive
                "tokens": int(n_tokens),
            }
        )

        # Early stop when all bins reached target
        if all(c >= target_per_bin for c in counts):
            break

    # Fallback: ensure every bin has at least one window by deterministic search
    for i in range(num_bins):
        if windows_per_bin[i]:
            continue
        lo = bin_edges[i]
        hi = bin_edges[i + 1]
        found = False
        for start in range(n_items):
            # Exponential growth to find upper bound where tokens >= lo
            low_end = start + 1
            high_end = start + 1
            while high_end < n_items and window_tokens(start, high_end) < lo:
                low_end = high_end
                high_end = min(n_items, start + (high_end - start) * 2)

            if high_end >= n_items and window_tokens(start, high_end) < lo:
                continue

            # Binary search to find minimal end with tokens >= lo
            left = max(low_end, start + 1)
            right = high_end
            while left < right:
                mid = (left + right) // 2
                t = window_tokens(start, mid)
                if t >= lo:
                    right = mid
                else:
                    left = mid + 1
            end = left
            n_tokens = window_tokens(start, end)

            if lo <= n_tokens <= hi:
                windows_per_bin[i].append(
                    {
                        "start": start,
                        "end": end,
                        "tokens": int(n_tokens),
                    }
                )
                counts[i] += 1
                found = True
                break
        # If still not found, leave empty; downstream capping will handle but tests may fail

    # Uniformly cap to the smallest non-empty count
    non_empty_sizes = [len(w) for w in windows_per_bin if len(w) > 0]
    if not non_empty_sizes:
        # Nothing reached any bin; print zeros
        result = {label: 0 for label in bin_labels}
        print(json.dumps(result, indent=2))
        return

    min_bin_size = min(non_empty_sizes)

    # Build JSONL of selected windows, balanced across bins
    selected_counts = {}
    out_path = os.path.join(os.getcwd(), "binned_samples.jsonl")
    out = []
    uid = 0
    counts = []
    for bin_idx, (label, windows) in enumerate(zip(bin_labels, windows_per_bin)):
        if not windows:
            selected_counts[label] = 0
            continue
        take = min(min_bin_size, len(windows))
        selected = windows[:take]
        selected_counts[label] = take
        for w in selected:
            s = w["start"]
            e = w["end"]
            combined_text = "\n\n".join(item["text"] for item in items[s:e])
            items_in_window = items[s:e]
            items_clean = [item for item in items_in_window if not any(item["answer"].startswith(c) for c in ["#", "\n", "*", ">", "-", "_", "`", "="])]
            if len(items_clean) == 0:
                print([x["answer"] for x in items_in_window])
                exit()
            selected_answer_item = random.sample(items_clean, 1)[0]

            rec = {
                "n_tokens": w["tokens"],
                "text": combined_text,
                "answer": selected_answer_item["answer"],
                "original_sentence": selected_answer_item["original_sentence"],
                "paraphrased_sentence": selected_answer_item["paraphrased_sentence"],
                "idx_paraphrased": selected_answer_item["idx_paraphrased"],
                "idx_to_answer": selected_answer_item["idx_to_answer"],
                "location": selected_answer_item["location"],
            }
            uid += 1
            out.append(rec)
            counts.append(w["tokens"])
    test_dataset(out, tokenizer, bin_edges)

    dataset = Dataset.from_list(out)
    dataset.push_to_hub("nreHieW/longwriter-sentences-paraphrased-binned")


if __name__ == "__main__":
    main()