Upload folder using huggingface_hub

.gitattributes

@@ -58,3 +58,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+train.jsonl filter=lfs diff=lfs merge=lfs -text
+validation.jsonl filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,52 @@
+# QASPER (Chat-Format Preparation)
+
+This dataset is a chat-format preparation of QASPER for supervised fine-tuning (SFT).
+
+## Format
+
+This format is commonly referred to as:
+
+- chat-format SFT data
+- instruction-tuning conversations
+- OpenAI-style `messages` format
+
+## Included files
+
+- `train.jsonl`
+- `validation.jsonl`
+- `stats.json`
+- `prepare_qasper_unsloth.py`
+
+## Source
+
+- Base dataset: `allenai/qasper`
+
+## Preparation summary
+
+- One row per `(paper, question)` using the best available annotation.
+- Answer normalization priority:
+  1. free-form
+  2. yes/no
+  3. extractive spans
+  4. unanswerable
+- Context mode is mixed between:
+  - evidence-only
+  - full-text
+- User prompt follows a question-first structure.
+
+Assistant target is the normalized answer text.
+
+## Schema
+
+Each JSONL row contains:
+
+- `messages`
+  - `user`: text instruction + question + title + abstract + context
+  - `assistant`: text answer
+- `meta`: ids, answer type, context mode, evidence count
+
+## Reproduction
+
+```bash
+python prepare_qasper_unsloth.py
+```

prepare_qasper_unsloth.py

@@ -0,0 +1,353 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import random
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+
+USER_INSTRUCTION = (
+    "Answer the question using the provided scientific paper context. "
+    "Use only the given context, and if the answer is not supported, "
+    'reply with "Unanswerable".'
+)
+
+
+@dataclass
+class Example:
+    split: str
+    paper_id: str
+    title: str
+    abstract: str
+    question: str
+    question_id: str
+    answer_text: str
+    answer_type: str
+    evidence_list: List[str]
+    full_text_sections: List[Dict]
+    annotation_id: str
+    worker_id: str
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Prepare QASPER Unsloth chat-format datasets (train/validation)."
+    )
+    parser.add_argument(
+        "--train-json",
+        type=Path,
+        default=Path("/d/hpc/projects/FRI/DL/Scholar/raw_downloads/qasper/qasper-train-v0.3.json"),
+    )
+    parser.add_argument(
+        "--dev-json",
+        type=Path,
+        default=Path("/d/hpc/projects/FRI/DL/Scholar/raw_downloads/qasper/qasper-dev-v0.3.json"),
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=Path("/d/hpc/projects/FRI/DL/Scholar/prepared_datasets/qasper_unsloth"),
+    )
+    parser.add_argument(
+        "--evidence-context-ratio",
+        type=float,
+        default=0.5,
+        help="Fraction of examples using evidence-only context. Remaining use full-text context.",
+    )
+    parser.add_argument(
+        "--fulltext-max-chars",
+        type=int,
+        default=None,
+        help="Character cap for full-text context mode. Use None or <=0 for no truncation.",
+    )
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument(
+        "--max-train-examples",
+        type=int,
+        default=None,
+        help="Optional cap for smoke tests.",
+    )
+    return parser.parse_args()
+
+
+def load_json(path: Path) -> Dict:
+    with path.open("r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def normalize_answer(answer_obj: Dict) -> Optional[Tuple[str, str]]:
+    if answer_obj.get("unanswerable") is True:
+        return "Unanswerable", "unanswerable"
+
+    yes_no = answer_obj.get("yes_no")
+    if isinstance(yes_no, bool):
+        return ("Yes" if yes_no else "No"), "yes_no"
+
+    free = (answer_obj.get("free_form_answer") or "").strip()
+    if free:
+        return free, "free_form"
+
+    spans = [s.strip() for s in (answer_obj.get("extractive_spans") or []) if s and s.strip()]
+    if spans:
+        unique_spans = list(dict.fromkeys(spans))
+        return " ; ".join(unique_spans), "extractive"
+
+    return None
+
+
+def answer_rank(answer_obj: Dict, evidence_count: int) -> Tuple[int, int]:
+    normalized = normalize_answer(answer_obj)
+    if normalized is None:
+        return 100, -evidence_count
+    _, kind = normalized
+    rank_map = {
+        "free_form": 0,
+        "yes_no": 1,
+        "extractive": 2,
+        "unanswerable": 3,
+    }
+    return rank_map[kind], -evidence_count
+
+
+def pick_best_annotation(annotations: List[Dict]) -> Optional[Tuple[Dict, str, str]]:
+    best = None
+    best_key = None
+    for ann in annotations:
+        answer_obj = ann.get("answer", {})
+        evidence = answer_obj.get("evidence") or []
+        key = answer_rank(answer_obj, len([e for e in evidence if e and e.strip()]))
+        normalized = normalize_answer(answer_obj)
+        if normalized is None:
+            continue
+        if best is None or key < best_key:
+            best = ann
+            best_key = key
+    if best is None:
+        return None
+    text, kind = normalize_answer(best["answer"])
+    return best, text, kind
+
+
+def convert_float_evidence(evidence_text: str) -> str:
+    prefix = "FLOAT SELECTED:"
+    if evidence_text.startswith(prefix):
+        payload = evidence_text[len(prefix):].strip()
+        return f"[Figure/Table: {payload}]"
+    return evidence_text
+
+
+def build_fulltext_context(full_text_sections: List[Dict], max_chars: Optional[int]) -> str:
+    blocks: List[str] = []
+    for section in full_text_sections:
+        section_name = (section.get("section_name") or "").strip()
+        paragraphs = section.get("paragraphs") or []
+        cleaned = [p.strip() for p in paragraphs if isinstance(p, str) and p.strip()]
+        if not cleaned:
+            continue
+        joined = "\n".join(cleaned)
+        if section_name:
+            blocks.append(f"## {section_name}\n{joined}")
+        else:
+            blocks.append(joined)
+    context = "\n\n".join(blocks)
+    if max_chars is not None and max_chars > 0 and len(context) > max_chars:
+        context = context[:max_chars].rstrip() + "\n\n[TRUNCATED]"
+    return context
+
+
+def build_evidence_context(evidence_list: List[str]) -> str:
+    seen = set()
+    out = []
+    for raw in evidence_list:
+        if not isinstance(raw, str):
+            continue
+        text = convert_float_evidence(raw.strip())
+        if not text:
+            continue
+        if text in seen:
+            continue
+        seen.add(text)
+        out.append(text)
+    return "\n".join(f"- {e}" for e in out)
+
+
+def to_example_rows(split: str, papers: Dict) -> List[Example]:
+    rows: List[Example] = []
+    for paper_id in sorted(papers.keys()):
+        paper = papers[paper_id]
+        title = (paper.get("title") or "").strip()
+        abstract = (paper.get("abstract") or "").strip()
+        full_text_sections = paper.get("full_text") or []
+        qas = paper.get("qas") or []
+        for qa in qas:
+            question = (qa.get("question") or "").strip()
+            question_id = (qa.get("question_id") or "").strip()
+            picked = pick_best_annotation(qa.get("answers") or [])
+            if not question or not question_id or picked is None:
+                continue
+            ann, answer_text, answer_type = picked
+            answer_obj = ann.get("answer") or {}
+            evidence_list = [e for e in (answer_obj.get("evidence") or []) if isinstance(e, str)]
+            rows.append(
+                Example(
+                    split=split,
+                    paper_id=paper_id,
+                    title=title,
+                    abstract=abstract,
+                    question=question,
+                    question_id=question_id,
+                    answer_text=answer_text,
+                    answer_type=answer_type,
+                    evidence_list=evidence_list,
+                    full_text_sections=full_text_sections,
+                    annotation_id=str(ann.get("annotation_id") or ""),
+                    worker_id=str(ann.get("worker_id") or ""),
+                )
+            )
+    return rows
+
+
+def build_user_text(ex: Example, context_mode: str, fulltext_max_chars: int) -> str:
+    if context_mode == "evidence":
+        context_text = build_evidence_context(ex.evidence_list)
+        if not context_text:
+            context_text = "[No evidence provided]"
+        context_header = "Relevant passages"
+    else:
+        context_text = build_fulltext_context(ex.full_text_sections, max_chars=fulltext_max_chars)
+        context_header = "Paper context"
+
+    return (
+        f"{USER_INSTRUCTION}\n\n"
+        f"Question: {ex.question}\n\n"
+        f"Paper title: {ex.title}\n\n"
+        f"Abstract: {ex.abstract}\n\n"
+        f"{context_header}:\n{context_text}"
+    )
+
+
+def build_row(ex: Example, context_mode: str, fulltext_max_chars: int) -> Dict:
+    user_text = build_user_text(ex=ex, context_mode=context_mode, fulltext_max_chars=fulltext_max_chars)
+    return {
+        "messages": [
+            {
+                "role": "user",
+                "content": [{"type": "text", "text": user_text}],
+            },
+            {
+                "role": "assistant",
+                "content": [{"type": "text", "text": ex.answer_text}],
+            },
+        ],
+        "meta": {
+            "dataset": "qasper",
+            "split": ex.split,
+            "paper_id": ex.paper_id,
+            "question_id": ex.question_id,
+            "annotation_id": ex.annotation_id,
+            "worker_id": ex.worker_id,
+            "answer_type": ex.answer_type,
+            "context_mode": context_mode,
+            "evidence_count": len(ex.evidence_list),
+        },
+    }
+
+
+def assign_modes(examples: List[Example], evidence_ratio: float, rng: random.Random) -> Dict[str, str]:
+    ids = [f"{e.paper_id}::{e.question_id}" for e in examples]
+    shuffled = ids[:]
+    rng.shuffle(shuffled)
+    n_evidence = int(round(len(shuffled) * evidence_ratio))
+    evidence_ids = set(shuffled[:n_evidence])
+    mode_map = {}
+    for e in examples:
+        key = f"{e.paper_id}::{e.question_id}"
+        mode_map[key] = "evidence" if key in evidence_ids else "full_text"
+    return mode_map
+
+
+def write_jsonl(path: Path, rows: List[Dict]) -> None:
+    with path.open("w", encoding="utf-8") as f:
+        for row in rows:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+
+def main() -> None:
+    args = parse_args()
+    if not (0.0 <= args.evidence_context_ratio <= 1.0):
+        raise ValueError("--evidence-context-ratio must be in [0,1]")
+
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    train_data = load_json(args.train_json)
+    dev_data = load_json(args.dev_json)
+
+    train_examples = to_example_rows("train", train_data)
+    dev_examples = to_example_rows("validation", dev_data)
+    if args.max_train_examples is not None:
+        train_examples = train_examples[: args.max_train_examples]
+
+    rng = random.Random(args.seed)
+    train_modes = assign_modes(train_examples, args.evidence_context_ratio, rng)
+    dev_modes = assign_modes(dev_examples, args.evidence_context_ratio, rng)
+
+    train_rows = [
+        build_row(
+            ex,
+            context_mode=train_modes[f"{ex.paper_id}::{ex.question_id}"],
+            fulltext_max_chars=args.fulltext_max_chars,
+        )
+        for ex in train_examples
+    ]
+    dev_rows = [
+        build_row(
+            ex,
+            context_mode=dev_modes[f"{ex.paper_id}::{ex.question_id}"],
+            fulltext_max_chars=args.fulltext_max_chars,
+        )
+        for ex in dev_examples
+    ]
+
+    train_out = args.output_dir / "train.jsonl"
+    val_out = args.output_dir / "validation.jsonl"
+    stats_out = args.output_dir / "stats.json"
+    write_jsonl(train_out, train_rows)
+    write_jsonl(val_out, dev_rows)
+
+    def mode_counts(rows: List[Dict]) -> Dict[str, int]:
+        return {
+            "evidence": sum(1 for r in rows if r["meta"]["context_mode"] == "evidence"),
+            "full_text": sum(1 for r in rows if r["meta"]["context_mode"] == "full_text"),
+        }
+
+    def answer_counts(rows: List[Dict]) -> Dict[str, int]:
+        kinds = ["free_form", "extractive", "yes_no", "unanswerable"]
+        return {k: sum(1 for r in rows if r["meta"]["answer_type"] == k) for k in kinds}
+
+    stats = {
+        "seed": args.seed,
+        "evidence_context_ratio": args.evidence_context_ratio,
+        "fulltext_max_chars": args.fulltext_max_chars,
+        "train": {
+            "rows": len(train_rows),
+            "context_mode_counts": mode_counts(train_rows),
+            "answer_type_counts": answer_counts(train_rows),
+        },
+        "validation": {
+            "rows": len(dev_rows),
+            "context_mode_counts": mode_counts(dev_rows),
+            "answer_type_counts": answer_counts(dev_rows),
+        },
+        "paths": {
+            "train_jsonl": str(train_out),
+            "validation_jsonl": str(val_out),
+            "stats_json": str(stats_out),
+        },
+    }
+    with stats_out.open("w", encoding="utf-8") as f:
+        json.dump(stats, f, ensure_ascii=False, indent=2)
+    print(json.dumps(stats, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

stats.json

@@ -0,0 +1,36 @@
+{
+  "seed": 42,
+  "evidence_context_ratio": 0.5,
+  "fulltext_max_chars": null,
+  "train": {
+    "rows": 2593,
+    "context_mode_counts": {
+      "evidence": 1296,
+      "full_text": 1297
+    },
+    "answer_type_counts": {
+      "free_form": 615,
+      "extractive": 1311,
+      "yes_no": 396,
+      "unanswerable": 271
+    }
+  },
+  "validation": {
+    "rows": 1005,
+    "context_mode_counts": {
+      "evidence": 502,
+      "full_text": 503
+    },
+    "answer_type_counts": {
+      "free_form": 355,
+      "extractive": 463,
+      "yes_no": 127,
+      "unanswerable": 60
+    }
+  },
+  "paths": {
+    "train_jsonl": "/d/hpc/projects/FRI/DL/Scholar/prepared_datasets/qasper_unsloth/train.jsonl",
+    "validation_jsonl": "/d/hpc/projects/FRI/DL/Scholar/prepared_datasets/qasper_unsloth/validation.jsonl",
+    "stats_json": "/d/hpc/projects/FRI/DL/Scholar/prepared_datasets/qasper_unsloth/stats.json"
+  }
+}

train.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:91e0495cb1f747b635ef29aa08a61dcd4b04f09c3afe2484d1bf08cbb2fb3d0d
+size 37840587

validation.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8c072f49bb7d0971acac46099076dbaf4c965711ec60fe428d847eae2b7e8907
+size 13893259