10x Model Fine-Tuning Using Synthetic Data with Unsloth on AMD GPUs

    vllm serve Unsloth/Llama-3.3-70B-Instruct   --port 8001   --max-model-len 48000   --gpu-memory-utilization 0.85

    # Logical Reasoning Training Configuration for Synthetic Data Kit

# Global paths configuration
paths:
 input: "data/input"           # Source PDFs and text files
 output:
   parsed: "data/parsed"       # Extracted text files (.txt)
   generated: "data/generated" # Generated QA pairs and CoT (.json)
   curated: "data/curated"     # Quality-filtered data (.json)
   final: "data/final"         # Training-ready format (.json)

# LLM Provider configuration
llm:
 provider: "vllm"

# vLLM server configuration
vllm:
 api_base: "http://localhost:8001/v1"
 port: 8001
 model: "meta-llama/Llama-3.3-70B-Instruct"
 max_retries: 3
 retry_delay: 1.0
 sleep_time: 0.1   # Small delay between batches to avoid rate limits

# Specialized prompts for logical reasoning domains
prompts:
 # Summary generation for logical reasoning content
 summary: |
   Summarize this logical reasoning content in 3-5 sentences, focusing on:
  1. The type of logical problems covered
  2. Key solving strategies mentioned
  3. Important concepts and principles
 
 # QA pair generation optimized for logical reasoning
 qa_generation: |
   Create {num_pairs} high-quality logical reasoning question-answer pairs from this educational content.
 
  Focus on problems that require:
  1. Step-by-step logical deduction
  2. Testing assumptions and eliminating contradictions
  3. Clear reasoning explanations
  4. Progressive difficulty (basic → intermediate → advanced)
 
  Domain Guidelines:
  - Knights & Knaves: Focus on truth-teller/liar logic, contradiction testing
  - Seating Arrangements: Focus on constraint satisfaction, systematic placement
  - Blood Relations: Focus on family tree deduction, relationship mapping
 
  Return ONLY valid JSON in this exact format:
  [
    {{
      "question": "Clear, specific logical reasoning question requiring step-by-step thinking?",
      "answer": "Complete step-by-step solution showing the reasoning process, testing assumptions, and reaching the final answer.",
      "difficulty": "basic",
      "domain": "knights_knaves"
    }},
    {{
      "question": "Another logical reasoning question with different complexity?",
      "answer": "Detailed answer showing each deduction step, how contradictions are resolved, and verification of the solution.",
      "difficulty": "intermediate",
      "domain": "seating"
    }}
  ]
 
  Text:
  {text}
  # Chain of Thought generation for complex logical reasoning
 cot_generation: |
   Create {num_pairs} complex logical reasoning problems with detailed chain-of-thought solutions from this content.
 
  Each problem should:
  1. Require multiple reasoning steps and careful analysis
  2. Show how to test different possibilities systematically
  3. Demonstrate how to identify and resolve contradictions
  4. Include verification that the solution satisfies all constraints
  5. Explain the reasoning behind each step
 
  Chain-of-Thought Structure:
  - Identify what is known and what needs to be found
  - Break down the problem into manageable steps
  - Test different cases or assumptions
  - Show how contradictions eliminate invalid options
  - Verify the final answer against all given conditions
 
  Return ONLY valid JSON:
  [
    {{
      "question": "Complex multi-step logical reasoning problem that requires systematic analysis?",
      "reasoning": "Step 1: First, let me identify what we know from the problem statement...\\nStep 2: Now I need to consider the possible cases. If we assume X is true, then...\\nStep 3: This assumption leads to a contradiction because...\\nStep 4: So X must be false. Let me try the opposite assumption...\\nStep 5: Testing this new assumption: if Y is true, then...\\nStep 6: This works! Let me verify by checking all constraints...\\nStep 7: Checking constraint 1: ✓... Checking constraint 2: ✓...",
      "answer": "Final answer with summary: The solution is [answer] because [key insight that makes this the only valid solution].",
      "domain": "knights_knaves"
    }}
  ]
 
  Text:
  {text} 

    synthetic-data-kit -c config.yaml system-check

    #create the repositories where we will use the PDF and save the examples to
mkdir -p logical_reasoning/{sources,data/{input,parsed,generated,curated,final}}

cd logical_reasoning

wget -P sources/ -q --show-progress   "https://www.csus.edu/indiv/d/dowdenb/4/logical-reasoning-archives/logical-reasoning-2017-12-02.pdf"   "https://people.cs.umass.edu/~pthomas/solutions/Liar_Truth.pdf"  

 cp sources/* data/input/ 

    synthetic-data-kit ingest ./data/input/ --verbose

    synthetic-data-kit -c config.yaml create ./data/parsed/ --type qa --num-pairs 15 --verbose

# OR

synthetic-data-kit -c config.yaml create ./data/parsed/ --type cot --num-pairs 15 --verbose

    synthetic-data-kit -c config.yaml curate ./data/generated/ --threshold 7.0 --verbose

    synthetic-data-kit save-as ./data/curated/ --format ft --verbose

    from unsloth import FastLanguageModel
from unsloth.chat_templates import get_chat_template, standardize_sharegpt, train_on_responses_only
from trl import SFTConfig, SFTTrainer
from transformers import DataCollatorForSeq2Seq, TextStreamer

    def train_model_rocm(model, tokenizer, dataset, max_seq_length):
    """Train model with ROCm-optimized settings"""

    # Setup trainer with ROCm-friendly settings and proper data handling
    trainer = SFTTrainer(
        model=model,
        tokenizer=tokenizer,
        train_dataset=dataset,
        dataset_text_field="text",
        max_seq_length=max_seq_length,
        data_collator=DataCollatorForSeq2Seq(tokenizer=tokenizer, padding=True),
        packing=False,
        args=SFTConfig(
            per_device_train_batch_size=1,
            gradient_accumulation_steps=4,
            warmup_steps=5,
            num_train_epochs=1,
            learning_rate=1e-4,
            logging_steps=1,
            optim="adamw_8bit",  # Pure torch optimizer
            weight_decay=0.01,
            lr_scheduler_type="linear",
            seed=3407,
            output_dir="logical_reasoning_rocm_outputs",
            report_to="none",
            bf16=True,
            dataloader_pin_memory=False,
            remove_unused_columns=True,  # Remove unused columns to avoid tensor issues
            gradient_checkpointing=True,
            dataloader_num_workers=0,  # Single worker for ROCm stability
        ),
    )
    
    # Train only on responses
    trainer = train_on_responses_only(
        trainer,
        instruction_part="<|start_header_id|>user<|end_header_id|>\n\n",
        response_part="<|start_header_id|>assistant<|end_header_id|>\n\n",
    )
    

    print(f"\n🔥 Starting ROCm training on {len(dataset)} examples...")
    FastLanguageModel.for_training(model)
    trainer_stats = trainer.train()

    
    return trainer_stats

    FastLanguageMode.for_training(model)
trainer_stats=trainer.train()

    def save_model_rocm(model, tokenizer):
    """Save the trained model"""
    lora_path = "logical_reasoning_rocm_lora"
    model.save_pretrained(lora_path)
    tokenizer.save_pretrained(lora_path)    
    # Save merged model
    merged_path = "logical_reasoning_rocm_merged"
    model.save_pretrained_merged(merged_path, tokenizer, save_method="merged_16bit")
    print(f"✅ Merged model saved to: {merged_path}")