llm-finetuning-dataset-synthesis

name	llm-finetuning-dataset-synthesis
title	Easy Dataset: A Unified and Extensible Framework for Synthesizing LLM Fine-Tuning Data
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2507.04009
keywords	["Dataset Synthesis","Document Processing","QA Generation","Fine-tuning Data","Domain Adaptation"]
description	Automatically generate high-quality domain-specific fine-tuning datasets from raw documents using adaptive processing and persona-driven synthesis, preserving general capabilities while specializing models.

Easy Dataset: Automated Fine-Tuning Data Synthesis from Documents

Building high-quality fine-tuning datasets from domain-specific documents typically requires significant manual effort. This work introduces a unified framework that automates the entire pipeline: processing heterogeneous document formats (PDF, DOCX, Markdown, text) with format-aware extraction, then synthesizing diverse question-answer pairs through a persona-driven approach. The system creates stylistically varied training examples that improve domain performance while maintaining general language understanding.

The key insight is that diversity in fine-tuning data comes from both content variation and stylistic variation. Rather than generating a single Q&A pair per passage, the framework creates multiple personas (different audiences and genres) that condition answer generation, producing diverse acceptable answers to the same question. This diversity improves generalization and reduces overfitting to specific formulations.

Core Concept

Easy Dataset operates on two principles: (1) adaptive document processing that respects format structure while handling heterogeneity robustly, and (2) persona-driven synthesis that generates diverse training examples from single passages. Instead of manual annotation, domain experts specify documents, and the system extracts information reliably (handling complex PDFs with vision-language models when needed) and synthesizes high-quality training examples.

The persona-driven approach combats a subtle problem with synthetic data: if all examples follow identical patterns, fine-tuned models may overfit to those patterns. By varying the audience (technical vs lay, formal vs casual) and genre (instruction manual, FAQ, tutorial), the framework ensures models learn robust generalizations rather than superficial correlations.

Architecture Overview

The system comprises two main components:

• Adaptive Document Processing Pipeline: Handles multi-format inputs (PDF, DOCX, Markdown, plain text) with specialized extractors, leveraging vision-language models for complex PDFs, followed by hybrid chunking that balances semantic structure with flexible user control
• Persona-Driven Data Synthesis: Automatically generates diverse persona pairs, conditions question and answer generation on personas, and produces semantically grounded yet stylistically varied training pairs

Supporting infrastructure includes a graphical configuration interface, human-in-the-loop refinement for intermediate outputs, flexible model integration (API and local), and export to multiple formats including LlamaFactory integration.

Implementation

Start with document extraction from heterogeneous formats:

import json
from typing  , , 
 pathlib  Path
 PyPDF2
 docx  Document

 :
    

     ():
        .use_vision_model = use_vision_model_for_pdf
         .use_vision_model:
            
             transformers  AutoProcessor, AutoModelForVision2Seq
            .vlm_processor = AutoProcessor.from_pretrained()
            .vlm_model = AutoModelForVision2Seq.from_pretrained()

     () -> :
        
        text_content = []

        :
            
             (pdf_path, )  f:
                reader = PyPDF2.PdfReader(f)
                 page_num, page  (reader.pages):
                    text = page.extract_text()
                     text.strip():
                        text_content.append()
                     use_vision  .use_vision_model:
                        
                         pdf2image  convert_from_path
                        images = convert_from_path(pdf_path, first_page=page_num+,
                                                   last_page=page_num+)
                         images:
                            vlm_text = ._extract_via_vlm(images[])
                            text_content.append()

         Exception  e:
            ()
             use_vision  .use_vision_model:
                 ._extract_pdf_via_vision(pdf_path)

         .join(text_content)

     () -> :
        
        doc = Document(docx_path)
        paragraphs = []
         para  doc.paragraphs:
             para.text.strip():
                paragraphs.append(para.text)
         .join(paragraphs)

     () -> :
        
        path = Path(file_path)
        suffix = path.suffix.lower()

         suffix == :
             .extract_pdf(file_path, use_vision=.use_vision_model)
         suffix == :
             .extract_docx(file_path)
         suffix  [, ]:
             path.read_text(encoding=)
        :
             ValueError()

     ():