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
+tool_rl.jsonl filter=lfs diff=lfs merge=lfs -text
+tool_sft.jsonl filter=lfs diff=lfs merge=lfs -text

convert_to_verl_parquet.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""Convert portable DuoChart RL JSONL data to the Parquet schema expected by VeRL."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+
+VERL_SCHEMA = pa.schema(
+    [
+        pa.field("data_source", pa.string()),
+        pa.field(
+            "prompt",
+            pa.list_(
+                pa.struct(
+                    [
+                        pa.field("content", pa.string()),
+                        pa.field("role", pa.string()),
+                    ]
+                )
+            ),
+        ),
+        pa.field("images", pa.list_(pa.struct([pa.field("image", pa.string())]))),
+        pa.field("ability", pa.string()),
+        pa.field(
+            "reward_model",
+            pa.struct(
+                [
+                    pa.field("ground_truth", pa.string()),
+                    pa.field("style", pa.string()),
+                ]
+            ),
+        ),
+        pa.field(
+            "extra_info",
+            pa.struct(
+                [
+                    pa.field("question", pa.string()),
+                    pa.field(
+                        "tools_kwargs",
+                        pa.struct(
+                            [
+                                pa.field(
+                                    "python_interpreter",
+                                    pa.struct(
+                                        [
+                                            pa.field(
+                                                "create_kwargs",
+                                                pa.struct([pa.field("image", pa.string())]),
+                                            )
+                                        ]
+                                    ),
+                                )
+                            ]
+                        ),
+                    ),
+                    pa.field("type", pa.string()),
+                ]
+            ),
+        ),
+        pa.field("agent_name", pa.string()),
+    ]
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "input",
+        nargs="?",
+        type=Path,
+        default=Path("tool_rl.jsonl"),
+        help="Portable DuoChart RL JSONL file.",
+    )
+    parser.add_argument(
+        "output",
+        nargs="?",
+        type=Path,
+        default=Path("train.parquet"),
+        help="Output VeRL Parquet file.",
+    )
+    parser.add_argument("--batch-size", type=int, default=2048)
+    parser.add_argument("--overwrite", action="store_true")
+    return parser.parse_args()
+
+
+def render_prompt(messages: list[dict[str, Any]]) -> tuple[list[dict[str, str]], list[str]]:
+    prompt: list[dict[str, str]] = []
+    image_paths: list[str] = []
+
+    for message in messages:
+        role = str(message["role"])
+        content = message.get("content", "")
+        if isinstance(content, str):
+            rendered = content
+        elif isinstance(content, list):
+            pieces: list[str] = []
+            for item in content:
+                if item.get("type") == "image":
+                    image = str(item["image"])
+                    if image.startswith(("/", "file://")):
+                        raise ValueError(f"Absolute image path remains in input: {image}")
+                    pieces.append("<image>")
+                    image_paths.append(image)
+                elif item.get("type") == "text":
+                    pieces.append(str(item.get("text", "")))
+                else:
+                    raise ValueError(f"Unsupported message content item: {item}")
+            rendered = "".join(pieces)
+        else:
+            raise ValueError(f"Unsupported message content: {type(content).__name__}")
+        prompt.append({"content": rendered, "role": role})
+
+    if not image_paths:
+        raise ValueError("RL example has no image")
+    return prompt, image_paths
+
+
+def convert_row(row: dict[str, Any]) -> dict[str, Any]:
+    metadata = row.get("metadata") or {}
+    if "qa_id" in metadata or "qa_id" in row:
+        raise ValueError("qa_id must be removed before Parquet conversion")
+
+    prompt, image_paths = render_prompt(row["messages"])
+    answer = row.get("answer")
+    ground_truth = answer if isinstance(answer, str) else str(answer)
+    first_image = image_paths[0]
+
+    return {
+        "data_source": "chartool",
+        "prompt": prompt,
+        "images": [{"image": image} for image in image_paths],
+        "ability": "chart",
+        "reward_model": {"ground_truth": ground_truth, "style": "rule"},
+        "extra_info": {
+            "question": str(metadata.get("question", "")),
+            "tools_kwargs": {
+                "python_interpreter": {"create_kwargs": {"image": first_image}}
+            },
+            "type": str(metadata.get("type", "")),
+        },
+        "agent_name": "tool_agent",
+    }
+
+
+def flush(writer: pq.ParquetWriter, rows: list[dict[str, Any]]) -> None:
+    if rows:
+        writer.write_table(pa.Table.from_pylist(rows, schema=VERL_SCHEMA))
+        rows.clear()
+
+
+def main() -> None:
+    args = parse_args()
+    input_path = args.input.resolve()
+    output_path = args.output.resolve()
+    if output_path.exists() and not args.overwrite:
+        raise FileExistsError(f"Output exists; pass --overwrite to replace it: {output_path}")
+    if args.batch_size <= 0:
+        raise ValueError("--batch-size must be positive")
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = output_path.with_suffix(output_path.suffix + ".tmp")
+    count = 0
+    batch: list[dict[str, Any]] = []
+
+    with input_path.open("r", encoding="utf-8") as src, pq.ParquetWriter(
+        temporary, VERL_SCHEMA, compression="zstd"
+    ) as writer:
+        for line_number, line in enumerate(src, 1):
+            if not line.strip():
+                continue
+            try:
+                row = json.loads(line)
+                batch.append(convert_row(row))
+            except Exception as exc:
+                raise ValueError(f"Failed to convert {input_path}:{line_number}") from exc
+            count += 1
+            if len(batch) >= args.batch_size:
+                flush(writer, batch)
+        flush(writer, batch)
+
+    os.replace(temporary, output_path)
+    print(f"Converted {count} rows to {output_path}")
+
+
+if __name__ == "__main__":
+    main()

images.zip

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

tool_rl.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:59b9cad42a9eeb914e9fd1ce28603d16ae879ad8f1bc7c4c85578c8042c555b0
+size 122872919

tool_sft.jsonl

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