synthgen/PtPersonaIFGen/main_ifeval_code/phase4_postprocess.py

"""
Phase 4: Post-Processing

Reuses logic from filter_ifeval_data.py to:
1. Restructure kwargs (flat dict -> per-instruction list)
2. Filter conflicting constraints
3. Validate responses with lm-eval IFEval checker
4. Keep only samples where prompt_level_strict_acc == True

Key Functions from filter_ifeval_data.py:
- build_instruction_kwargs() (lines 257-285)
- filter_not_valid_rows() (lines 288-305)
- get_ifeval_results() (lines 308-321)

Key Data Structures from filter_ifeval_data.py:
- INSTRUCTION_ARGS (lines 11-41)
- LANGUAGE_TO_CODE (lines 223-254)
- IFEVAL_INSTRUCTION_CONFLICTS (lines 70-221)
"""

import argparse
import json

from tqdm import tqdm

from main_ifeval_code.filter_ifeval_data_pt import (
    INSTRUCTION_ARGS,
    LANGUAGE_TO_CODE,
    IFEVAL_INSTRUCTION_CONFLICTS,
    build_instruction_kwargs,
    filter_not_valid_rows,
    get_ifeval_results,
)

from main_ifeval_code.config import (
    PHASE3_OUTPUT,
    PHASE4_OUTPUT,
)
from main_ifeval_code.utils import (
    iter_jsonl_batches,
    write_jsonl_line,
    count_jsonl_lines,
)


# -----------------------------------------------------------------------
# STEP 4.1: RESTRUCTURE KWARGS
# Reuses build_instruction_kwargs() from filter_ifeval_data.py (lines 257-285)
# -----------------------------------------------------------------------
def restructure_kwargs(item: dict) -> dict:
    """
    Transform flat kwargs dict into per-instruction kwargs list.
    Wraps build_instruction_kwargs() from filter_ifeval_data.py.
    """
    result = build_instruction_kwargs(item)
    item["kwargs"] = result.get("kwargs", item.get("kwargs"))
    item["valid_kwargs_json"] = result.get("valid_kwargs_json", False)
    return item


# -----------------------------------------------------------------------
# STEP 4.2: FILTER CONFLICTING CONSTRAINTS
# Reuses filter_not_valid_rows() from filter_ifeval_data.py (lines 288-305)
# -----------------------------------------------------------------------
def is_valid_row(item: dict) -> bool:
    """
    Check if a row has valid kwargs and no conflicting constraints.
    Wraps filter_not_valid_rows() from filter_ifeval_data.py.
    """
    return filter_not_valid_rows(item)


# -----------------------------------------------------------------------
# STEP 4.3: VALIDATE WITH LM-EVAL
# Reuses get_ifeval_results() from filter_ifeval_data.py (lines 308-321)
# -----------------------------------------------------------------------
def validate_response(item: dict) -> dict:
    """
    Validate response against constraints using lm-eval IFEval checker.
    Wraps get_ifeval_results() from filter_ifeval_data.py.
    """
    # Rename instruction to prompt (as done in filter_ifeval_data.py line 329)
    item["prompt"] = item.pop("instruction", item.get("prompt"))

    # Add 'key' field required by lm-eval process_results
    if "key" not in item:
        item["key"] = item.get("id", 0)
    
    results = get_ifeval_results(item)
    item.update(results)
    return item


# -----------------------------------------------------------------------
# MAIN PROCESSING
# -----------------------------------------------------------------------
def process_item(item: dict) -> dict | None:
    """
    Process a single item through all post-processing steps.
    Returns None if the item should be filtered out.
    """
    # Step 4.1: Restructure kwargs
    item = restructure_kwargs(item)
    
    # Step 4.2: Filter invalid/conflicting
    if not is_valid_row(item):
        return None
    
    # Step 4.3: Validate with lm-eval
    item = validate_response(item)
    
    # Step 4.4: Filter by strict accuracy
    if not item.get("prompt_level_strict_acc", False):
        return None
    
    # Clean up intermediate fields
    if "valid_kwargs_json" in item:
        del item["valid_kwargs_json"]
    
    return item


def main(
    input_file: str = PHASE3_OUTPUT,
    output_file: str = PHASE4_OUTPUT,
    batch_size: int = 100,
):
    """
    Run post-processing on Phase 3 output.
    
    Note: This is CPU-bound (no LLM calls), so we process sequentially.
    The main bottleneck is the lm-eval validation.
    """
    # Count total items
    total_items = count_jsonl_lines(input_file)
    print(f"Processing {total_items} items from {input_file}...")
    
    # Track stats
    stats = {
        "total": 0,
        "invalid_kwargs": 0,
        "conflicts": 0,
        "failed_validation": 0,
        "passed": 0,
    }
    
    # Debug: track first few failures of each type
    DEBUG_LIMIT = 10
    debug_samples = {
        "invalid_kwargs": [],
        "conflicts": [],
        "failed_validation": [],
    }
    
    # Process items
    pbar = tqdm(total=total_items, desc="Post-processing")
    
    for batch in iter_jsonl_batches(
        input_file,
        batch_size,
        start_from_id=0,
        required_fields=["instruction", "response", "instruction_id_list", "kwargs"],
    ):
        for item in batch:
            stats["total"] += 1
            item_id = item.get("id", stats["total"])
            
            # Step 4.1: Restructure kwargs
            item = restructure_kwargs(item)
            if not item.get("valid_kwargs_json", False):
                stats["invalid_kwargs"] += 1
                if len(debug_samples["invalid_kwargs"]) < DEBUG_LIMIT:
                    debug_samples["invalid_kwargs"].append({
                        "id": item_id,
                        "raw_kwargs": item.get("kwargs"),
                        "instruction_id_list": item.get("instruction_id_list"),
                    })
                pbar.update(1)
                continue
            
            # Step 4.2: Filter invalid/conflicting
            if not is_valid_row(item):
                stats["conflicts"] += 1
                if len(debug_samples["conflicts"]) < DEBUG_LIMIT:
                    debug_samples["conflicts"].append({
                        "id": item_id,
                        "instruction_id_list": item.get("instruction_id_list"),
                    })
                pbar.update(1)
                continue
            
            # Step 4.3: Validate with lm-eval
            item = validate_response(item)
            
            # Step 4.4: Filter by strict accuracy
            if not item.get("prompt_level_strict_acc", False):
                stats["failed_validation"] += 1
                if len(debug_samples["failed_validation"]) < DEBUG_LIMIT:
                    debug_samples["failed_validation"].append({
                        "id": item_id,
                        "instruction_id_list": item.get("instruction_id_list"),
                        "kwargs": item.get("kwargs"),
                        "inst_level_strict_acc": item.get("inst_level_strict_acc"),
                        "validation_error": item.get("validation_error"),  # Capture exception
                        "response_preview": item.get("response", "")[:500],
                    })
                pbar.update(1)
                continue
            
            # Clean up intermediate fields
            if "valid_kwargs_json" in item:
                del item["valid_kwargs_json"]
            
            # Write passing item
            write_jsonl_line(output_file, item)
            stats["passed"] += 1
            pbar.update(1)
    
    pbar.close()
    
    # Print summary
    print("\n" + "=" * 50)
    print("Post-processing Summary")
    print("=" * 50)
    print(f"Total processed:      {stats['total']:,}")
    print(f"Invalid kwargs:       {stats['invalid_kwargs']:,}")
    print(f"Conflicting:          {stats['conflicts']:,}")
    print(f"Failed validation:    {stats['failed_validation']:,}")
    print(f"Passed (final):       {stats['passed']:,}")
    print(f"Pass rate:            {stats['passed']/max(stats['total'],1)*100:.1f}%")
    print("=" * 50)
    print(f"Output: {output_file}")
    
    # Print debug samples
    if debug_samples["invalid_kwargs"]:
        print("\n" + "=" * 50)
        print(f"DEBUG: Sample INVALID KWARGS failures (first {DEBUG_LIMIT}):")
        print("=" * 50)
        for sample in debug_samples["invalid_kwargs"]:
            print(f"\n--- ID: {sample['id']} ---")
            print(f"instruction_id_list: {sample['instruction_id_list']}")
            print(f"raw_kwargs: {sample['raw_kwargs'][:500] if sample['raw_kwargs'] else 'None'}...")
    
    if debug_samples["conflicts"]:
        print("\n" + "=" * 50)
        print(f"DEBUG: Sample CONFLICT failures (first {DEBUG_LIMIT}):")
        print("=" * 50)
        for sample in debug_samples["conflicts"]:
            print(f"\n--- ID: {sample['id']} ---")
            print(f"instruction_id_list: {sample['instruction_id_list']}")
    
    if debug_samples["failed_validation"]:
        print("\n" + "=" * 50)
        print(f"DEBUG: Sample VALIDATION failures (first {DEBUG_LIMIT}):")
        print("=" * 50)
        for sample in debug_samples["failed_validation"]:
            print(f"\n--- ID: {sample['id']} ---")
            print(f"instruction_id_list: {sample['instruction_id_list']}")
            print(f"kwargs: {sample['kwargs']}")
            print(f"inst_level_strict_acc: {sample['inst_level_strict_acc']}")
            if sample.get('validation_error'):
                print(f"EXCEPTION: {sample['validation_error']}")
            print(f"response_preview: {sample['response_preview']}...")


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Phase 4: Post-Processing")
    parser.add_argument("--input", default=PHASE3_OUTPUT, help="Input JSONL file from Phase 3")
    parser.add_argument("--output", default=PHASE4_OUTPUT, help="Output JSONL file")
    parser.add_argument("--batch-size", type=int, default=100, help="Batch size for reading")
    args = parser.parse_args()
    
    main(
        input_file=args.input,
        output_file=args.output,
        batch_size=args.batch_size,
    )