mysphinx-forge 0.2.0__tar.gz → 0.2.1__tar.gz

{mysphinx_forge-0.2.0 → mysphinx_forge-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mysphinx-forge
-Version: 0.2.0
+Version: 0.2.1
 Summary: Data and model workflow toolkit for cleaning, clustering, generation, and evaluation
 Keywords: data-cleaning,deduplication,clustering,nlp,cli
 Classifier: Development Status :: 3 - Alpha
@@ -65,7 +65,7 @@ Requires-Dist: transformers>=4.55.0; extra == "all"
 | `cluster` | 文本聚类，并导出汇总、投影和 HTML 报告 | `*_clustered.*` |
 | `split` | 切分 train / valid / test | `*_split_train.*` 等 |
 | `model-test` | 批量执行模型推理或单条烟雾测试，含预期结果列时自动输出评估报告 | `*_model_tested.*` 或终端输出 |
-| `convert-sft` | 转换表格数据为 LLaMA-Factory 可用的 SFT 数据 | `*_alpaca.json` |
+| `convert-sft` | 转换表格数据为 SFT 数据（`alpaca` / `pa` 格式） | `*_alpaca.json` / `*_pa.jsonl`（超 10000 条自动切分） |
 
 ## 项目结构
 
@@ -174,10 +174,10 @@ uv run python main.py ...
 - `mysphinx-forge.yaml`
 - 程序内置默认值
 
-配置文件中的**相对路径**（`input_file`、`output`、`system_prompt_file`、`sft_instruction_file`、`embedding_model_path`、`test_model_path` 等）以**执行时的当前工作目录**为基准展开，与命令行参数行为一致。因此推荐从项目根目录运行工具，配置文件中的路径直接写相对于项目根目录的路径即可：
+配置文件中的**相对路径**（`input_file`、`output`、`system_prompt_file`、`sft_system_prompt_file`、`embedding_model_path`、`test_model_path` 等）以**执行时的当前工作目录**为基准展开，与命令行参数行为一致。因此推荐从项目根目录运行工具，配置文件中的路径直接写相对于项目根目录的路径即可：
 
 ```yaml
-# configs/05_model_test.yaml
+# configs/06_model_test.yaml
 action: model-test
 input_file: data/raw_deduplicated_split_test.xlsx   # 相对于运行时 cwd（项目根目录）
 model-test:
@@ -186,7 +186,7 @@ model-test:
 
 ```bash
 # 从项目根目录运行，路径正确展开
-mysphinx-forge --config configs/05_model_test.yaml
+mysphinx-forge --config configs/06_model_test.yaml
 ```
 
 配置文件支持三种层级：
@@ -332,19 +332,23 @@ mysphinx-forge --action clean-deduplicate --input-file data/input.xlsx
 mysphinx-forge --action clean-deduplicate --input-file data/input.xlsx --dedupe-mode semantic
 ```
 
-### 导出 LLaMA-Factory SFT 数据
+### 导出 SFT 数据
 
-`convert-sft` 目前支持将表格转换为 `alpaca` 格式 JSON，可直接给 `LLaMA-Factory` 做 `SFT` 训练。
-
-> **关于命名**：这里的 `sft` 指**训练阶段**（Supervised Fine-Tuning，监督微调），而非训练方法。`alpaca` 的 `instruction / input / output` 结构正是 SFT 阶段的标准监督数据，无法用于 `pt`（纯文本预训练）或 `dpo` / `rm`（需要 `chosen` / `rejected` 偏好对）等其它阶段。
->
-> **与训练方法无关**：训练方法（`LoRA` / 全参数 / freeze）和数据格式是两个正交的维度。本命令产出的这份 `alpaca` JSON，无论你用 `LoRA` 还是全参数微调都**通用，一个字都不用改**——只需在 `LLaMA-Factory` 的训练配置里切换 `finetuning_type` 即可。
+`convert-sft` 支持将表格转换为多种 SFT 格式，通过 `--sft-format` 参数选择，默认为 `alpaca`。
 
 默认会自动探测：
 
 - 输入列：`text` / `用户问题` / `客户问题` / `用户输入`
 - 输出列：`category` / `label` / `intent` / `output` / `response` / `answer` / `target`
 
+#### alpaca 格式（默认）
+
+可直接给 `LLaMA-Factory` 做 `SFT` 训练。
+
+> **关于命名**：这里的 `sft` 指**训练阶段**（Supervised Fine-Tuning，监督微调），而非训练方法。`alpaca` 的 `instruction / input / output` 结构正是 SFT 阶段的标准监督数据，无法用于 `pt`（纯文本预训练）或 `dpo` / `rm`（需要 `chosen` / `rejected` 偏好对）等其它阶段。
+>
+> **与训练方法无关**：训练方法（`LoRA` / 全参数 / freeze）和数据格式是两个正交的维度。本命令产出的这份 `alpaca` JSON，无论你用 `LoRA` 还是全参数微调都**通用，一个字都不用改**——只需在 `LLaMA-Factory` 的训练配置里切换 `finetuning_type` 即可。
+
 基础示例：
 
 ```bash
@@ -369,7 +373,7 @@ mysphinx-forge --action convert-sft --input-file data/input.xlsx --sft-output-co
 mysphinx-forge --action convert-sft --input-file data/input.xlsx --sft-output-column category --sft-instruction "请判断用户问题所属分类，只输出分类标签。" --sft-system-prompt "你是一个证券问答分类助手。"
 ```
 
-#### `instruction` 与 `input` 字段的两种模式
+##### `instruction` 与 `input` 字段的两种模式
 
 **默认模式（`--sft-user-query-as-instruction`，默认开启）**
 
@@ -412,9 +416,49 @@ convert-sft:
 
 > 注意：如果同时传入了显式 `--sft-instruction`，则该固定文本始终作为 `instruction`，`input` 照常存放用户输入，`--sft-user-query-as-instruction` 不影响此情形。
 
+#### pa 格式
+
+企业内部自定义格式，输出为 JSONL 文件，每行一条 JSON 数据，结构如下：
+
+```json
+{"conversations": [{"context": "系统提示（可选）", "role": "system"}, {"context": "用户输入", "role": "human"}, {"context": "模型回复", "role": "assistant"}], "id": "1"}
+```
+
+字段说明：
+
+- `id`：数据编号，从 1 开始累计
+- `conversations`：对话内容列表
+  - `role`：`system`（可选，对应 `--sft-system-prompt` / `--sft-system-column`）、`human`（用户输入）、`assistant`（模型回复）
+  - `context`：会话内容
+
+基础示例：
+
+```bash
+mysphinx-forge --action convert-sft --sft-format pa --input-file data/input_deduplicated_split_train.xlsx
+```
+
+默认输出：
+
+```bash
+data/input_deduplicated_split_train_pa.jsonl
+```
+
+带 system prompt：
+
+```bash
+mysphinx-forge --action convert-sft --sft-format pa --input-file data/input.xlsx --sft-system-prompt "你是证券领域用户意图识别专家。"
+```
+
+**自动切分**：当转换结果超过 10000 条时，自动按 10000 条一份切分为多个 JSONL 文件，文件名末尾追加序号。例如输入文件 `input_deduplicated_split_train.xlsx` 包含 12000 条数据，输出为：
+
+```
+input_deduplicated_split_train_pa_1.jsonl   # 前 10000 条
+input_deduplicated_split_train_pa_2.jsonl   # 后 2000 条
+```
+
 说明：
 
-- 当前仅实现 `alpaca` 格式
+- 支持 `alpaca`（默认）和 `pa` 两种格式，通过 `--sft-format` 切换
 - 空输入行和空输出行会自动跳过
 - 会同时生成日志文件和 `*.meta.json` 元数据文件
 

{mysphinx_forge-0.2.0 → mysphinx_forge-0.2.1}/README.md

@@ -28,7 +28,7 @@
 | `cluster` | 文本聚类，并导出汇总、投影和 HTML 报告 | `*_clustered.*` |
 | `split` | 切分 train / valid / test | `*_split_train.*` 等 |
 | `model-test` | 批量执行模型推理或单条烟雾测试，含预期结果列时自动输出评估报告 | `*_model_tested.*` 或终端输出 |
-| `convert-sft` | 转换表格数据为 LLaMA-Factory 可用的 SFT 数据 | `*_alpaca.json` |
+| `convert-sft` | 转换表格数据为 SFT 数据（`alpaca` / `pa` 格式） | `*_alpaca.json` / `*_pa.jsonl`（超 10000 条自动切分） |
 
 ## 项目结构
 
@@ -137,10 +137,10 @@ uv run python main.py ...
 - `mysphinx-forge.yaml`
 - 程序内置默认值
 
-配置文件中的**相对路径**（`input_file`、`output`、`system_prompt_file`、`sft_instruction_file`、`embedding_model_path`、`test_model_path` 等）以**执行时的当前工作目录**为基准展开，与命令行参数行为一致。因此推荐从项目根目录运行工具，配置文件中的路径直接写相对于项目根目录的路径即可：
+配置文件中的**相对路径**（`input_file`、`output`、`system_prompt_file`、`sft_system_prompt_file`、`embedding_model_path`、`test_model_path` 等）以**执行时的当前工作目录**为基准展开，与命令行参数行为一致。因此推荐从项目根目录运行工具，配置文件中的路径直接写相对于项目根目录的路径即可：
 
 ```yaml
-# configs/05_model_test.yaml
+# configs/06_model_test.yaml
 action: model-test
 input_file: data/raw_deduplicated_split_test.xlsx   # 相对于运行时 cwd（项目根目录）
 model-test:
@@ -149,7 +149,7 @@ model-test:
 
 ```bash
 # 从项目根目录运行，路径正确展开
-mysphinx-forge --config configs/05_model_test.yaml
+mysphinx-forge --config configs/06_model_test.yaml
 ```
 
 配置文件支持三种层级：
@@ -295,19 +295,23 @@ mysphinx-forge --action clean-deduplicate --input-file data/input.xlsx
 mysphinx-forge --action clean-deduplicate --input-file data/input.xlsx --dedupe-mode semantic
 ```
 
-### 导出 LLaMA-Factory SFT 数据
+### 导出 SFT 数据
 
-`convert-sft` 目前支持将表格转换为 `alpaca` 格式 JSON，可直接给 `LLaMA-Factory` 做 `SFT` 训练。
-
-> **关于命名**：这里的 `sft` 指**训练阶段**（Supervised Fine-Tuning，监督微调），而非训练方法。`alpaca` 的 `instruction / input / output` 结构正是 SFT 阶段的标准监督数据，无法用于 `pt`（纯文本预训练）或 `dpo` / `rm`（需要 `chosen` / `rejected` 偏好对）等其它阶段。
->
-> **与训练方法无关**：训练方法（`LoRA` / 全参数 / freeze）和数据格式是两个正交的维度。本命令产出的这份 `alpaca` JSON，无论你用 `LoRA` 还是全参数微调都**通用，一个字都不用改**——只需在 `LLaMA-Factory` 的训练配置里切换 `finetuning_type` 即可。
+`convert-sft` 支持将表格转换为多种 SFT 格式，通过 `--sft-format` 参数选择，默认为 `alpaca`。
 
 默认会自动探测：
 
 - 输入列：`text` / `用户问题` / `客户问题` / `用户输入`
 - 输出列：`category` / `label` / `intent` / `output` / `response` / `answer` / `target`
 
+#### alpaca 格式（默认）
+
+可直接给 `LLaMA-Factory` 做 `SFT` 训练。
+
+> **关于命名**：这里的 `sft` 指**训练阶段**（Supervised Fine-Tuning，监督微调），而非训练方法。`alpaca` 的 `instruction / input / output` 结构正是 SFT 阶段的标准监督数据，无法用于 `pt`（纯文本预训练）或 `dpo` / `rm`（需要 `chosen` / `rejected` 偏好对）等其它阶段。
+>
+> **与训练方法无关**：训练方法（`LoRA` / 全参数 / freeze）和数据格式是两个正交的维度。本命令产出的这份 `alpaca` JSON，无论你用 `LoRA` 还是全参数微调都**通用，一个字都不用改**——只需在 `LLaMA-Factory` 的训练配置里切换 `finetuning_type` 即可。
+
 基础示例：
 
 ```bash
@@ -332,7 +336,7 @@ mysphinx-forge --action convert-sft --input-file data/input.xlsx --sft-output-co
 mysphinx-forge --action convert-sft --input-file data/input.xlsx --sft-output-column category --sft-instruction "请判断用户问题所属分类，只输出分类标签。" --sft-system-prompt "你是一个证券问答分类助手。"
 ```
 
-#### `instruction` 与 `input` 字段的两种模式
+##### `instruction` 与 `input` 字段的两种模式
 
 **默认模式（`--sft-user-query-as-instruction`，默认开启）**
 
@@ -375,9 +379,49 @@ convert-sft:
 
 > 注意：如果同时传入了显式 `--sft-instruction`，则该固定文本始终作为 `instruction`，`input` 照常存放用户输入，`--sft-user-query-as-instruction` 不影响此情形。
 
+#### pa 格式
+
+企业内部自定义格式，输出为 JSONL 文件，每行一条 JSON 数据，结构如下：
+
+```json
+{"conversations": [{"context": "系统提示（可选）", "role": "system"}, {"context": "用户输入", "role": "human"}, {"context": "模型回复", "role": "assistant"}], "id": "1"}
+```
+
+字段说明：
+
+- `id`：数据编号，从 1 开始累计
+- `conversations`：对话内容列表
+  - `role`：`system`（可选，对应 `--sft-system-prompt` / `--sft-system-column`）、`human`（用户输入）、`assistant`（模型回复）
+  - `context`：会话内容
+
+基础示例：
+
+```bash
+mysphinx-forge --action convert-sft --sft-format pa --input-file data/input_deduplicated_split_train.xlsx
+```
+
+默认输出：
+
+```bash
+data/input_deduplicated_split_train_pa.jsonl
+```
+
+带 system prompt：
+
+```bash
+mysphinx-forge --action convert-sft --sft-format pa --input-file data/input.xlsx --sft-system-prompt "你是证券领域用户意图识别专家。"
+```
+
+**自动切分**：当转换结果超过 10000 条时，自动按 10000 条一份切分为多个 JSONL 文件，文件名末尾追加序号。例如输入文件 `input_deduplicated_split_train.xlsx` 包含 12000 条数据，输出为：
+
+```
+input_deduplicated_split_train_pa_1.jsonl   # 前 10000 条
+input_deduplicated_split_train_pa_2.jsonl   # 后 2000 条
+```
+
 说明：
 
-- 当前仅实现 `alpaca` 格式
+- 支持 `alpaca`（默认）和 `pa` 两种格式，通过 `--sft-format` 切换
 - 空输入行和空输出行会自动跳过
 - 会同时生成日志文件和 `*.meta.json` 元数据文件
 

{mysphinx_forge-0.2.0 → mysphinx_forge-0.2.1}/mysphinx_forge/cli.py

@@ -61,9 +61,12 @@ from mysphinx_forge.semantic_deduplication import (
 )
 from mysphinx_forge.sft_dataset import (
     DEFAULT_SFT_FORMAT,
+    PA_SFT_FORMAT,
     SftConversionStats,
     convert_dataframe_to_alpaca,
+    convert_dataframe_to_pa,
     write_alpaca_dataset,
+    write_pa_dataset,
 )
 from mysphinx_forge.splitting import (
     DEFAULT_SPLIT_RANDOM_SEED,
@@ -286,8 +289,8 @@ def main() -> int:
         )
     if args.action == "convert-sft":
         try:
-            resolved_sft_instruction = _resolve_sft_instruction(
-                args.sft_instruction_file, args.sft_instruction
+            resolved_sft_system_prompt = _resolve_sft_system_prompt(
+                args.sft_system_prompt_file, args.sft_system_prompt
             )
         except ValueError as exc:
             print(str(exc))
@@ -298,8 +301,8 @@ def main() -> int:
             args.target_column,
             args.sft_format,
             args.sft_output_column,
-            resolved_sft_instruction,
-            args.sft_system_prompt,
+            args.sft_instruction,
+            resolved_sft_system_prompt,
             args.sft_system_column,
             args.sft_user_query_as_instruction,
         )
@@ -616,9 +619,9 @@ def _build_parser(
     )
     parser.add_argument(
         "--sft-format",
-        choices=[DEFAULT_SFT_FORMAT],
+        choices=[DEFAULT_SFT_FORMAT, PA_SFT_FORMAT],
         default=config_defaults.get("sft_format", DEFAULT_SFT_FORMAT),
-        help=f"SFT 导出格式，当前仅支持 {DEFAULT_SFT_FORMAT}。",
+        help=f"SFT 导出格式，支持 {DEFAULT_SFT_FORMAT}（默认）和 {PA_SFT_FORMAT}。",
     )
     parser.add_argument(
         "--sft-output-column",
@@ -630,16 +633,16 @@ def _build_parser(
         default=config_defaults.get("sft_instruction", ""),
         help="SFT Alpaca 样本中的 instruction。未指定时根据输出列自动生成。",
     )
-    parser.add_argument(
-        "--sft-instruction-file",
-        dest="sft_instruction_file",
-        default=config_defaults.get("sft_instruction_file", ""),
-        help="SFT instruction 文件路径。文件内容优先于 --sft-instruction；两者都未指定时根据输出列自动生成。",
-    )
     parser.add_argument(
         "--sft-system-prompt",
         default=config_defaults.get("sft_system_prompt", ""),
-        help="SFT Alpaca 样本中的固定 system 字段。未指定则不写入。",
+        help="SFT 样本中的固定 system 字段（行内文本）。未指定则不写入。",
+    )
+    parser.add_argument(
+        "--sft-system-prompt-file",
+        dest="sft_system_prompt_file",
+        default=config_defaults.get("sft_system_prompt_file", ""),
+        help="SFT system prompt 文件路径（支持 .md 等文本文件）。文件内容优先于 --sft-system-prompt；两者都未指定则不写入 system 字段。",
     )
     parser.add_argument(
         "--sft-system-column",
@@ -1491,23 +1494,20 @@ def _resolve_system_prompt(system_prompt_file: str) -> str:
     return system_prompt
 
 
-def _resolve_sft_instruction(instruction_file: str, instruction_inline: str) -> str:
-    # 优先级：显式 inline 文本 > 文件 > 空字符串（调用方按需 fallback 到自动生成）
-    # 这样 CLI --sft-instruction "xxx" 始终能覆盖 yaml 里配置的 sft_instruction_file
-    if instruction_inline:
-        return instruction_inline
-    if instruction_file:
-        file_path = Path(instruction_file)
+def _resolve_sft_system_prompt(system_prompt_file: str, system_prompt_inline: str) -> str:
+    # 优先级：文件 > 行内文本 > 空字符串（不写入 system 字段）
+    if system_prompt_file:
+        file_path = Path(system_prompt_file)
         try:
             content = file_path.read_text(encoding="utf-8").strip()
         except OSError as exc:
             raise ValueError(
-                f"读取 sft-instruction 文件失败：{file_path}，{type(exc).__name__}: {exc}"
+                f"读取 sft-system-prompt 文件失败：{file_path}，{type(exc).__name__}: {exc}"
             ) from exc
         if not content:
-            raise ValueError(f"sft-instruction 文件内容为空：{file_path}")
+            raise ValueError(f"sft-system-prompt 文件内容为空：{file_path}")
         return content
-    return ""
+    return system_prompt_inline
 
 
 def _run_clean_csv_stream(
@@ -1759,24 +1759,37 @@ def _run_convert_sft(
         run_stage("读取文件", logger=logger)
         dataframe = load_dataframe(input_file)
         run_stage("转换 SFT 数据", logger=logger)
-        if sft_format != DEFAULT_SFT_FORMAT:
+        if sft_format == PA_SFT_FORMAT:
+            records, stats = convert_dataframe_to_pa(
+                dataframe,
+                target_column=target_column,
+                output_column=sft_output_column,
+                system_prompt=sft_system_prompt,
+                system_column=sft_system_column,
+            )
+        elif sft_format == DEFAULT_SFT_FORMAT:
+            records, stats = convert_dataframe_to_alpaca(
+                dataframe,
+                target_column=target_column,
+                output_column=sft_output_column,
+                instruction=sft_instruction,
+                system_prompt=sft_system_prompt,
+                system_column=sft_system_column,
+                user_query_as_instruction=sft_user_query_as_instruction,
+            )
+        else:
             raise ValueError(f"暂不支持的 SFT 格式：{sft_format}")
-        records, stats = convert_dataframe_to_alpaca(
-            dataframe,
-            target_column=target_column,
-            output_column=sft_output_column,
-            instruction=sft_instruction,
-            system_prompt=sft_system_prompt,
-            system_column=sft_system_column,
-            user_query_as_instruction=sft_user_query_as_instruction,
-        )
     except ValueError as exc:
         _emit_error(str(exc), logger)
         close_logger()
         return 1
 
     run_stage("写出结果", logger=logger)
-    write_alpaca_dataset(records, output_path)
+    if sft_format == PA_SFT_FORMAT:
+        written_paths = write_pa_dataset(records, output_path)
+    else:
+        write_alpaca_dataset(records, output_path)
+        written_paths = [output_path]
     _write_meta(
         output_path=output_path,
         action="convert-sft",
@@ -1791,8 +1804,11 @@ def _run_convert_sft(
             "sft_user_query_as_instruction": sft_user_query_as_instruction,
         },
         sft_conversion_stats=stats,
+        extra_output_files={f"output_file_{i + 1}": p for i, p in enumerate(written_paths)}
+        if len(written_paths) > 1
+        else None,
     )
-    _print_sft_conversion_stats(stats, output_path, logger)
+    _print_sft_conversion_stats(stats, written_paths, logger)
     close_logger()
     return 0
 
@@ -1841,7 +1857,8 @@ def _resolve_split_part_output_paths(base_output_path: Path) -> tuple[Path, Path
 def _resolve_sft_output_path(input_path: Path, output_arg: str | None, sft_format: str) -> Path:
     if output_arg:
         return Path(output_arg)
-    return input_path.with_name(f"{input_path.stem}_{sft_format}.json")
+    ext = ".jsonl" if sft_format == PA_SFT_FORMAT else ".json"
+    return input_path.with_name(f"{input_path.stem}_{sft_format}{ext}")
 
 
 def _resolve_match_output_path(output_path: Path) -> Path:
@@ -2014,10 +2031,15 @@ def _print_split_stats(
 
 def _print_sft_conversion_stats(
     stats: SftConversionStats,
-    output_path: Path,
+    output_paths: list[Path],
     logger: Logger,
 ) -> None:
-    _emit_message(f"SFT 数据转换完成，输出文件：{output_path}", logger)
+    if len(output_paths) == 1:
+        _emit_message(f"SFT 数据转换完成，输出文件：{output_paths[0]}", logger)
+    else:
+        _emit_message(f"SFT 数据转换完成，共生成 {len(output_paths)} 个文件：", logger)
+        for p in output_paths:
+            _emit_message(f"  {p}", logger)
     _emit_message(f"SFT 格式：{stats.format_name}", logger)
     _emit_message(f"输入列：{stats.input_column}", logger)
     _emit_message(f"输出列：{stats.output_column}", logger)

{mysphinx_forge-0.2.0 → mysphinx_forge-0.2.1}/mysphinx_forge/config.py

@@ -23,7 +23,7 @@ _PATH_LIKE_KEYS = {
     "train_model_path",
     "test_model_path",
     "system_prompt_file",
-    "sft_instruction_file",
+    "sft_system_prompt_file",
 }
 
 

{mysphinx_forge-0.2.0 → mysphinx_forge-0.2.1}/mysphinx_forge/sft_dataset.py

@@ -9,6 +9,8 @@ import pandas as pd
 from mysphinx_forge.cleaning import resolve_target_column
 
 DEFAULT_SFT_FORMAT = "alpaca"
+PA_SFT_FORMAT = "pa"
+PA_MAX_RECORDS_PER_FILE = 10_000
 DEFAULT_SFT_OUTPUT_COLUMNS = (
     "category",
     "label",
@@ -107,6 +109,90 @@ def write_alpaca_dataset(records: list[dict[str, str]], output_path: str | Path)
     )
 
 
+def convert_dataframe_to_pa(
+    dataframe: pd.DataFrame,
+    *,
+    target_column: str = "text",
+    output_column: str = "",
+    system_prompt: str = "",
+    system_column: str = "",
+) -> tuple[list[dict], SftConversionStats]:
+    resolved_input_column = resolve_target_column(dataframe, target_column)
+    resolved_output_column = resolve_sft_output_column(dataframe, output_column)
+    resolved_system_column = _resolve_optional_column(dataframe, system_column)
+
+    final_system_prompt = system_prompt.strip()
+    records: list[dict] = []
+    skipped_blank_input_rows = 0
+    skipped_blank_output_rows = 0
+
+    for _, row in dataframe.iterrows():
+        input_text = _cell_to_text(row[resolved_input_column])
+        output_text = _cell_to_text(row[resolved_output_column])
+        if not input_text:
+            skipped_blank_input_rows += 1
+            continue
+        if not output_text:
+            skipped_blank_output_rows += 1
+            continue
+
+        conversations: list[dict[str, str]] = []
+
+        system_text = final_system_prompt
+        if resolved_system_column is not None:
+            row_system = _cell_to_text(row[resolved_system_column])
+            if row_system:
+                system_text = row_system
+        if system_text:
+            conversations.append({"context": system_text, "role": "system"})
+
+        conversations.append({"context": input_text, "role": "human"})
+        conversations.append({"context": output_text, "role": "assistant"})
+
+        records.append({"conversations": conversations, "id": str(len(records) + 1)})
+
+    stats = SftConversionStats(
+        format_name=PA_SFT_FORMAT,
+        input_column=resolved_input_column,
+        output_column=resolved_output_column,
+        total_rows=len(dataframe),
+        converted_rows=len(records),
+        skipped_blank_input_rows=skipped_blank_input_rows,
+        skipped_blank_output_rows=skipped_blank_output_rows,
+    )
+    return records, stats
+
+
+def write_pa_dataset(records: list[dict], output_path: str | Path) -> list[Path]:
+    """Write PA-format records as one or more JSONL files split at PA_MAX_RECORDS_PER_FILE.
+
+    Returns the list of paths written.
+    """
+    output_path = Path(output_path)
+    total = len(records)
+    if total <= PA_MAX_RECORDS_PER_FILE:
+        _write_pa_jsonl(records, output_path)
+        return [output_path]
+
+    stem = output_path.stem
+    suffix = output_path.suffix
+    parent = output_path.parent
+    written: list[Path] = []
+    chunk_index = 1
+    for start in range(0, total, PA_MAX_RECORDS_PER_FILE):
+        chunk = records[start : start + PA_MAX_RECORDS_PER_FILE]
+        chunk_path = parent / f"{stem}_{chunk_index}{suffix}"
+        _write_pa_jsonl(chunk, chunk_path)
+        written.append(chunk_path)
+        chunk_index += 1
+    return written
+
+
+def _write_pa_jsonl(records: list[dict], path: Path) -> None:
+    lines = [json.dumps(record, ensure_ascii=False) for record in records]
+    path.write_text("\n".join(lines) + "\n" if lines else "", encoding="utf-8")
+
+
 def resolve_sft_output_column(dataframe: pd.DataFrame, output_column: str) -> str:
     if output_column:
         if output_column in dataframe.columns:

{mysphinx_forge-0.2.0 → mysphinx_forge-0.2.1}/mysphinx_forge.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mysphinx-forge
-Version: 0.2.0
+Version: 0.2.1
 Summary: Data and model workflow toolkit for cleaning, clustering, generation, and evaluation
 Keywords: data-cleaning,deduplication,clustering,nlp,cli
 Classifier: Development Status :: 3 - Alpha
@@ -65,7 +65,7 @@ Requires-Dist: transformers>=4.55.0; extra == "all"
 | `cluster` | 文本聚类，并导出汇总、投影和 HTML 报告 | `*_clustered.*` |
 | `split` | 切分 train / valid / test | `*_split_train.*` 等 |
 | `model-test` | 批量执行模型推理或单条烟雾测试，含预期结果列时自动输出评估报告 | `*_model_tested.*` 或终端输出 |
-| `convert-sft` | 转换表格数据为 LLaMA-Factory 可用的 SFT 数据 | `*_alpaca.json` |
+| `convert-sft` | 转换表格数据为 SFT 数据（`alpaca` / `pa` 格式） | `*_alpaca.json` / `*_pa.jsonl`（超 10000 条自动切分） |
 
 ## 项目结构
 
@@ -174,10 +174,10 @@ uv run python main.py ...
 - `mysphinx-forge.yaml`
 - 程序内置默认值
 
-配置文件中的**相对路径**（`input_file`、`output`、`system_prompt_file`、`sft_instruction_file`、`embedding_model_path`、`test_model_path` 等）以**执行时的当前工作目录**为基准展开，与命令行参数行为一致。因此推荐从项目根目录运行工具，配置文件中的路径直接写相对于项目根目录的路径即可：
+配置文件中的**相对路径**（`input_file`、`output`、`system_prompt_file`、`sft_system_prompt_file`、`embedding_model_path`、`test_model_path` 等）以**执行时的当前工作目录**为基准展开，与命令行参数行为一致。因此推荐从项目根目录运行工具，配置文件中的路径直接写相对于项目根目录的路径即可：
 
 ```yaml
-# configs/05_model_test.yaml
+# configs/06_model_test.yaml
 action: model-test
 input_file: data/raw_deduplicated_split_test.xlsx   # 相对于运行时 cwd（项目根目录）
 model-test:
@@ -186,7 +186,7 @@ model-test:
 
 ```bash
 # 从项目根目录运行，路径正确展开
-mysphinx-forge --config configs/05_model_test.yaml
+mysphinx-forge --config configs/06_model_test.yaml
 ```
 
 配置文件支持三种层级：
@@ -332,19 +332,23 @@ mysphinx-forge --action clean-deduplicate --input-file data/input.xlsx
 mysphinx-forge --action clean-deduplicate --input-file data/input.xlsx --dedupe-mode semantic
 ```
 
-### 导出 LLaMA-Factory SFT 数据
+### 导出 SFT 数据
 
-`convert-sft` 目前支持将表格转换为 `alpaca` 格式 JSON，可直接给 `LLaMA-Factory` 做 `SFT` 训练。
-
-> **关于命名**：这里的 `sft` 指**训练阶段**（Supervised Fine-Tuning，监督微调），而非训练方法。`alpaca` 的 `instruction / input / output` 结构正是 SFT 阶段的标准监督数据，无法用于 `pt`（纯文本预训练）或 `dpo` / `rm`（需要 `chosen` / `rejected` 偏好对）等其它阶段。
->
-> **与训练方法无关**：训练方法（`LoRA` / 全参数 / freeze）和数据格式是两个正交的维度。本命令产出的这份 `alpaca` JSON，无论你用 `LoRA` 还是全参数微调都**通用，一个字都不用改**——只需在 `LLaMA-Factory` 的训练配置里切换 `finetuning_type` 即可。
+`convert-sft` 支持将表格转换为多种 SFT 格式，通过 `--sft-format` 参数选择，默认为 `alpaca`。
 
 默认会自动探测：
 
 - 输入列：`text` / `用户问题` / `客户问题` / `用户输入`
 - 输出列：`category` / `label` / `intent` / `output` / `response` / `answer` / `target`
 
+#### alpaca 格式（默认）
+
+可直接给 `LLaMA-Factory` 做 `SFT` 训练。
+
+> **关于命名**：这里的 `sft` 指**训练阶段**（Supervised Fine-Tuning，监督微调），而非训练方法。`alpaca` 的 `instruction / input / output` 结构正是 SFT 阶段的标准监督数据，无法用于 `pt`（纯文本预训练）或 `dpo` / `rm`（需要 `chosen` / `rejected` 偏好对）等其它阶段。
+>
+> **与训练方法无关**：训练方法（`LoRA` / 全参数 / freeze）和数据格式是两个正交的维度。本命令产出的这份 `alpaca` JSON，无论你用 `LoRA` 还是全参数微调都**通用，一个字都不用改**——只需在 `LLaMA-Factory` 的训练配置里切换 `finetuning_type` 即可。
+
 基础示例：
 
 ```bash
@@ -369,7 +373,7 @@ mysphinx-forge --action convert-sft --input-file data/input.xlsx --sft-output-co
 mysphinx-forge --action convert-sft --input-file data/input.xlsx --sft-output-column category --sft-instruction "请判断用户问题所属分类，只输出分类标签。" --sft-system-prompt "你是一个证券问答分类助手。"
 ```
 
-#### `instruction` 与 `input` 字段的两种模式
+##### `instruction` 与 `input` 字段的两种模式
 
 **默认模式（`--sft-user-query-as-instruction`，默认开启）**
 
@@ -412,9 +416,49 @@ convert-sft:
 
 > 注意：如果同时传入了显式 `--sft-instruction`，则该固定文本始终作为 `instruction`，`input` 照常存放用户输入，`--sft-user-query-as-instruction` 不影响此情形。
 
+#### pa 格式
+
+企业内部自定义格式，输出为 JSONL 文件，每行一条 JSON 数据，结构如下：
+
+```json
+{"conversations": [{"context": "系统提示（可选）", "role": "system"}, {"context": "用户输入", "role": "human"}, {"context": "模型回复", "role": "assistant"}], "id": "1"}
+```
+
+字段说明：
+
+- `id`：数据编号，从 1 开始累计
+- `conversations`：对话内容列表
+  - `role`：`system`（可选，对应 `--sft-system-prompt` / `--sft-system-column`）、`human`（用户输入）、`assistant`（模型回复）
+  - `context`：会话内容
+
+基础示例：
+
+```bash
+mysphinx-forge --action convert-sft --sft-format pa --input-file data/input_deduplicated_split_train.xlsx
+```
+
+默认输出：
+
+```bash
+data/input_deduplicated_split_train_pa.jsonl
+```
+
+带 system prompt：
+
+```bash
+mysphinx-forge --action convert-sft --sft-format pa --input-file data/input.xlsx --sft-system-prompt "你是证券领域用户意图识别专家。"
+```
+
+**自动切分**：当转换结果超过 10000 条时，自动按 10000 条一份切分为多个 JSONL 文件，文件名末尾追加序号。例如输入文件 `input_deduplicated_split_train.xlsx` 包含 12000 条数据，输出为：
+
+```
+input_deduplicated_split_train_pa_1.jsonl   # 前 10000 条
+input_deduplicated_split_train_pa_2.jsonl   # 后 2000 条
+```
+
 说明：
 
-- 当前仅实现 `alpaca` 格式
+- 支持 `alpaca`（默认）和 `pa` 两种格式，通过 `--sft-format` 切换
 - 空输入行和空输出行会自动跳过
 - 会同时生成日志文件和 `*.meta.json` 元数据文件
 

{mysphinx_forge-0.2.0 → mysphinx_forge-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mysphinx-forge"
-version = "0.2.0"
+version = "0.2.1"
 description = "Data and model workflow toolkit for cleaning, clustering, generation, and evaluation"
 readme = "README.md"
 requires-python = ">=3.12"

mysphinx_forge-0.2.1/tests/test_sft_dataset.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+import pandas as pd
+import pytest
+
+from mysphinx_forge.sft_dataset import (
+    PA_MAX_RECORDS_PER_FILE,
+    convert_dataframe_to_alpaca,
+    convert_dataframe_to_pa,
+    resolve_sft_output_column,
+    write_pa_dataset,
+)
+
+
+def test_convert_dataframe_to_alpaca_user_query_as_instruction_default() -> None:
+    dataframe = pd.DataFrame(
+        {
+            "用户输入": ["怎么买基金", "", "港股通怎么开"],
+            "category": ["基金", "股票", ""],
+        }
+    )
+
+    records, stats = convert_dataframe_to_alpaca(dataframe)
+
+    assert records == [
+        {
+            "instruction": "怎么买基金",
+            "input": "",
+            "output": "基金",
+        }
+    ]
+    assert stats.input_column == "用户输入"
+    assert stats.output_column == "category"
+    assert stats.total_rows == 3
+    assert stats.converted_rows == 1
+    assert stats.skipped_blank_input_rows == 1
+    assert stats.skipped_blank_output_rows == 1
+
+
+def test_convert_dataframe_to_alpaca_user_query_as_input_when_disabled() -> None:
+    dataframe = pd.DataFrame(
+        {
+            "用户输入": ["怎么买基金", "", "港股通怎么开"],
+            "category": ["基金", "股票", ""],
+        }
+    )
+
+    records, stats = convert_dataframe_to_alpaca(dataframe, user_query_as_instruction=False)
+
+    assert records == [
+        {
+            "instruction": "请根据用户输入判断其category，只输出category。",
+            "input": "怎么买基金",
+            "output": "基金",
+        }
+    ]
+    assert stats.converted_rows == 1
+
+
+def test_convert_dataframe_to_alpaca_prefers_system_column_over_fixed_prompt() -> None:
+    dataframe = pd.DataFrame(
+        {
+            "text": ["基金赎回多久到账"],
+            "label": ["基金"],
+            "system_text": ["你是证券分类助手，只输出标签。"],
+        }
+    )
+
+    records, stats = convert_dataframe_to_alpaca(
+        dataframe,
+        output_column="label",
+        system_prompt="固定 system",
+        system_column="system_text",
+        instruction="请分类。",
+    )
+
+    assert records == [
+        {
+            "instruction": "请分类。",
+            "input": "基金赎回多久到账",
+            "output": "基金",
+            "system": "你是证券分类助手，只输出标签。",
+        }
+    ]
+    assert stats.output_column == "label"
+
+
+def test_convert_dataframe_to_pa_basic() -> None:
+    dataframe = pd.DataFrame(
+        {
+            "用户输入": ["怎么查询持仓", "", "怎么买基金"],
+            "category": ["查持仓", "股票", ""],
+        }
+    )
+
+    records, stats = convert_dataframe_to_pa(dataframe)
+
+    assert len(records) == 1
+    record = records[0]
+    assert record["id"] == "1"
+    conversations = record["conversations"]
+    assert len(conversations) == 2
+    assert conversations[0] == {"context": "怎么查询持仓", "role": "human"}
+    assert conversations[1] == {"context": "查持仓", "role": "assistant"}
+    assert stats.format_name == "pa"
+    assert stats.converted_rows == 1
+    assert stats.skipped_blank_input_rows == 1
+    assert stats.skipped_blank_output_rows == 1
+
+
+def test_convert_dataframe_to_pa_with_system_prompt() -> None:
+    dataframe = pd.DataFrame(
+        {
+            "text": ["怎么查询持仓"],
+            "label": ["查持仓"],
+        }
+    )
+
+    records, _ = convert_dataframe_to_pa(dataframe, system_prompt="你是证券助手。")
+
+    conversations = records[0]["conversations"]
+    assert len(conversations) == 3
+    assert conversations[0] == {"context": "你是证券助手。", "role": "system"}
+    assert conversations[1] == {"context": "怎么查询持仓", "role": "human"}
+    assert conversations[2] == {"context": "查持仓", "role": "assistant"}
+
+
+def test_convert_dataframe_to_pa_with_system_column_overrides_prompt() -> None:
+    dataframe = pd.DataFrame(
+        {
+            "text": ["怎么查询持仓"],
+            "label": ["查持仓"],
+            "sys": ["每行不同系统提示"],
+        }
+    )
+
+    records, _ = convert_dataframe_to_pa(
+        dataframe, system_prompt="固定提示", system_column="sys"
+    )
+
+    conversations = records[0]["conversations"]
+    assert conversations[0] == {"context": "每行不同系统提示", "role": "system"}
+
+
+def test_write_pa_dataset_single_file(tmp_path) -> None:
+    records = [{"conversations": [], "id": str(i + 1)} for i in range(5)]
+    out = tmp_path / "output_pa.jsonl"
+    written = write_pa_dataset(records, out)
+    assert written == [out]
+    lines = out.read_text(encoding="utf-8").strip().splitlines()
+    assert len(lines) == 5
+
+
+def test_write_pa_dataset_splits_when_exceeds_limit(tmp_path, monkeypatch) -> None:
+    import mysphinx_forge.sft_dataset as sft_mod
+
+    monkeypatch.setattr(sft_mod, "PA_MAX_RECORDS_PER_FILE", 3)
+    records = [{"conversations": [], "id": str(i + 1)} for i in range(7)]
+    out = tmp_path / "output_pa.jsonl"
+    written = write_pa_dataset(records, out)
+    assert len(written) == 3
+    assert written[0].name == "output_pa_1.jsonl"
+    assert written[1].name == "output_pa_2.jsonl"
+    assert written[2].name == "output_pa_3.jsonl"
+    lines1 = written[0].read_text(encoding="utf-8").strip().splitlines()
+    lines2 = written[1].read_text(encoding="utf-8").strip().splitlines()
+    lines3 = written[2].read_text(encoding="utf-8").strip().splitlines()
+    assert len(lines1) == 3
+    assert len(lines2) == 3
+    assert len(lines3) == 1
+
+
+def test_resolve_sft_output_column_requires_supported_or_explicit_column() -> None:
+    dataframe = pd.DataFrame({"text": ["a"], "other": ["b"]})
+
+    with pytest.raises(ValueError, match="未找到 SFT 输出列"):
+        resolve_sft_output_column(dataframe, "")

mysphinx_forge-0.2.0/tests/test_sft_dataset.py

@@ -1,86 +0,0 @@
-from __future__ import annotations
-
-import pandas as pd
-import pytest
-
-from mysphinx_forge.sft_dataset import convert_dataframe_to_alpaca, resolve_sft_output_column
-
-
-def test_convert_dataframe_to_alpaca_user_query_as_instruction_default() -> None:
-    dataframe = pd.DataFrame(
-        {
-            "用户输入": ["怎么买基金", "", "港股通怎么开"],
-            "category": ["基金", "股票", ""],
-        }
-    )
-
-    records, stats = convert_dataframe_to_alpaca(dataframe)
-
-    assert records == [
-        {
-            "instruction": "怎么买基金",
-            "input": "",
-            "output": "基金",
-        }
-    ]
-    assert stats.input_column == "用户输入"
-    assert stats.output_column == "category"
-    assert stats.total_rows == 3
-    assert stats.converted_rows == 1
-    assert stats.skipped_blank_input_rows == 1
-    assert stats.skipped_blank_output_rows == 1
-
-
-def test_convert_dataframe_to_alpaca_user_query_as_input_when_disabled() -> None:
-    dataframe = pd.DataFrame(
-        {
-            "用户输入": ["怎么买基金", "", "港股通怎么开"],
-            "category": ["基金", "股票", ""],
-        }
-    )
-
-    records, stats = convert_dataframe_to_alpaca(dataframe, user_query_as_instruction=False)
-
-    assert records == [
-        {
-            "instruction": "请根据用户输入判断其category，只输出category。",
-            "input": "怎么买基金",
-            "output": "基金",
-        }
-    ]
-    assert stats.converted_rows == 1
-
-
-def test_convert_dataframe_to_alpaca_prefers_system_column_over_fixed_prompt() -> None:
-    dataframe = pd.DataFrame(
-        {
-            "text": ["基金赎回多久到账"],
-            "label": ["基金"],
-            "system_text": ["你是证券分类助手，只输出标签。"],
-        }
-    )
-
-    records, stats = convert_dataframe_to_alpaca(
-        dataframe,
-        output_column="label",
-        system_prompt="固定 system",
-        system_column="system_text",
-        instruction="请分类。",
-    )
-
-    assert records == [
-        {
-            "instruction": "请分类。",
-            "input": "基金赎回多久到账",
-            "output": "基金",
-            "system": "你是证券分类助手，只输出标签。",
-        }
-    ]
-    assert stats.output_column == "label"
-
-
-def test_resolve_sft_output_column_requires_supported_or_explicit_column() -> None:
-    dataframe = pd.DataFrame({"text": ["a"], "other": ["b"]})
-
-    with pytest.raises(ValueError, match="未找到 SFT 输出列"):
-        resolve_sft_output_column(dataframe, "")