from datasets import load_dataset, Dataset, DatasetDict from collections import Counter from typing import Any, Dict, List, Optional, Tuple import json EXPECTED_COLUMNS = ["messages"] EXPECTED_MESSAGE_KEYS = {"role", "content"} ALLOWED_ROLES = {"user", "assistant", "system"} def check_columns(split_name: str, ds) -> List[str]: issues: List[str] = [] cols = list(ds.column_names) if cols != EXPECTED_COLUMNS: issues.append( f"[{split_name}] Unexpected columns {cols}, expected {EXPECTED_COLUMNS}" ) return issues def validate_message_structure( msg: Any, split_name: str, idx: int, msg_idx: int, ) -> List[str]: issues: List[str] = [] prefix = f"[{split_name}][example {idx}][message {msg_idx}]" if not isinstance(msg, dict): issues.append(f"{prefix} Message is not a dict. Got type={type(msg)}") return issues keys = set(msg.keys()) missing = EXPECTED_MESSAGE_KEYS - keys extra = keys - EXPECTED_MESSAGE_KEYS if missing: issues.append(f"{prefix} Missing keys: {sorted(missing)}") if extra: issues.append(f"{prefix} Extra keys: {sorted(extra)}") role = msg.get("role", None) if not isinstance(role, str): issues.append(f"{prefix} 'role' is not str. Got type={type(role)} value={role!r}") else: if role not in ALLOWED_ROLES: issues.append(f"{prefix} 'role' has unexpected value: {role!r}") content = msg.get("content", None) if not isinstance(content, str): issues.append( f"{prefix} 'content' is not str. Got type={type(content)} value={content!r}" ) else: if content.strip() == "": issues.append(f"{prefix} 'content' is empty or whitespace only") return issues def validate_conversation_level( messages: Any, split_name: str, idx: int, enforce_turn_pattern: bool = True, ) -> List[str]: issues: List[str] = [] prefix = f"[{split_name}][example {idx}]" if not isinstance(messages, list): issues.append(f"{prefix} 'messages' is not a list. Got type={type(messages)}") return issues if len(messages) == 0: issues.append(f"{prefix} 'messages' is an empty list") return issues if not enforce_turn_pattern: return issues roles = [m.get("role") for m in messages if isinstance(m, dict)] first_non_system_role: Optional[str] = None for r in roles: if r != "system": first_non_system_role = r break if first_non_system_role is None: issues.append(f"{prefix} All roles are 'system', no user or assistant") elif first_non_system_role != "user": issues.append( f"{prefix} First non system role is {first_non_system_role!r}, expected 'user'" ) if roles and roles[-1] != "assistant": issues.append( f"{prefix} Last role is {roles[-1]!r}, expected 'assistant' for training" ) roles_wo_system = [r for r in roles if r != "system"] for i in range(len(roles_wo_system) - 1): if roles_wo_system[i] == roles_wo_system[i + 1]: issues.append( f"{prefix} Non alternating roles around positions {i} and {i+1}: " f"{roles_wo_system[i]!r}, {roles_wo_system[i+1]!r}" ) break return issues def validate_split( split_name: str, ds, max_issue_examples: int = 50, enforce_turn_pattern: bool = True, ) -> Dict[str, Any]: issues: List[str] = [] role_counts: Counter = Counter() num_examples_with_issues = 0 issues.extend(check_columns(split_name, ds)) for idx, example in enumerate(ds): example_issues: List[str] = [] if not isinstance(example, dict): example_issues.append( f"[{split_name}][example {idx}] Example is not a dict. Got type={type(example)}" ) if example_issues: issues.extend(example_issues) num_examples_with_issues += 1 continue if "messages" not in example: example_issues.append( f"[{split_name}][example {idx}] Missing key 'messages' in example keys={list(example.keys())}" ) if example_issues: issues.extend(example_issues) num_examples_with_issues += 1 continue messages = example["messages"] example_issues.extend( validate_conversation_level( messages, split_name, idx, enforce_turn_pattern=enforce_turn_pattern, ) ) if isinstance(messages, list): for msg_idx, msg in enumerate(messages): example_issues.extend( validate_message_structure( msg, split_name, idx, msg_idx, ) ) if isinstance(msg, dict): role = msg.get("role", None) if isinstance(role, str): role_counts[role] += 1 if example_issues: num_examples_with_issues += 1 if num_examples_with_issues <= max_issue_examples: issues.extend(example_issues) return { "issues": issues, "role_counts": role_counts, "num_examples": len(ds), "num_examples_with_issues": num_examples_with_issues, } def try_fix_example(example: Dict[str, Any]) -> Optional[Dict[str, Any]]: """ Try generic fixes. If still structurally bad, return None so that it can be dropped. Fixes: - ensure messages is a list and non empty - drop non dict messages - ensure role and content exist and are strings - drop messages with empty content - restrict roles to allowed set with simple fallback - enforce first non system role is user - enforce last role is assistant - enforce alternation ignoring system """ if not isinstance(example, dict): return None if "messages" not in example: return None messages = example["messages"] if not isinstance(messages, list) or len(messages) == 0: return None new_messages: List[Dict[str, Any]] = [] repaired = False for msg in messages: if not isinstance(msg, dict): repaired = True continue msg = dict(msg) if "role" not in msg or not isinstance(msg["role"], str): repaired = True if not new_messages: msg["role"] = "user" else: prev_role = new_messages[-1].get("role", "user") msg["role"] = "assistant" if prev_role != "assistant" else "user" if "content" not in msg or not isinstance(msg["content"], str): repaired = True msg["content"] = str(msg.get("content", "")) msg["content"] = msg["content"].strip() if msg["content"] == "": repaired = True continue role = msg["role"] if role not in ALLOWED_ROLES: repaired = True lower = role.lower() if lower in ALLOWED_ROLES: msg["role"] = lower else: msg["role"] = "user" new_messages.append(msg) if not new_messages: return None roles = [m["role"] for m in new_messages] non_sys_indices = [i for i, r in enumerate(roles) if r != "system"] if not non_sys_indices: return None first_ns_idx = non_sys_indices[0] if new_messages[first_ns_idx]["role"] != "user": repaired = True new_messages[first_ns_idx]["role"] = "user" if new_messages[-1]["role"] != "assistant": repaired = True new_messages[-1]["role"] = "assistant" last_ns_role = None for m in new_messages: if m["role"] == "system": continue if last_ns_role is None: last_ns_role = m["role"] continue if m["role"] == last_ns_role: repaired = True m["role"] = "assistant" if last_ns_role != "assistant" else "user" last_ns_role = m["role"] if not new_messages: return None fixed_example = dict(example) fixed_example["messages"] = new_messages return fixed_example def clean_split( split_name: str, ds, enforce_turn_pattern: bool = True, ) -> Tuple[Dataset, int, int]: """ Returns: - cleaned Dataset - number of fixed examples - number of dropped examples """ cleaned_examples: List[Dict[str, Any]] = [] fixed_count = 0 dropped_count = 0 for idx, example in enumerate(ds): original_example = example fixed_example = try_fix_example(original_example) if fixed_example is None: dropped_count += 1 continue tmp_ds = Dataset.from_list([fixed_example]) result = validate_split( split_name=f"{split_name}_tmp", ds=tmp_ds, max_issue_examples=0, enforce_turn_pattern=enforce_turn_pattern, ) if result["num_examples_with_issues"] > 0: dropped_count += 1 continue if fixed_example != original_example: fixed_count += 1 cleaned_examples.append(fixed_example) cleaned_ds = Dataset.from_list(cleaned_examples) return cleaned_ds, fixed_count, dropped_count def print_validation_summary(split_name: str, result: Dict[str, Any]) -> None: total = result["num_examples"] num_with_issues = result["num_examples_with_issues"] pct = (num_with_issues / total * 100.0) if total > 0 else 0.0 print(f"Split: {split_name}") print(f" Total examples: {total}") print(f" Examples with issues: {num_with_issues} ({pct:.2f}%)") print(f" Role counts: {result['role_counts']}") if result["issues"]: print(f" Showing up to {len(result['issues'])} logged issues for {split_name}:") for issue in result["issues"]: print(" -", issue) else: print(f" No issues found in split {split_name}.") def main(): dataset = load_dataset("cemig-ceia/CemigConvo_v0") original_summary: Dict[str, Any] = {} print("Initial validation") for split_name, ds in dataset.items(): print(f"Validating split: {split_name} (num_rows={len(ds)})") result = validate_split(split_name, ds) print_validation_summary(split_name, result) original_summary[split_name] = { "num_examples": result["num_examples"], "num_examples_with_issues": result["num_examples_with_issues"], "role_counts": dict(result["role_counts"]), } cleaned_splits: Dict[str, Dataset] = {} cleaning_stats: Dict[str, Any] = {} print("\nCleaning dataset") for split_name, ds in dataset.items(): print(f"Cleaning split: {split_name}") cleaned_ds, fixed_count, dropped_count = clean_split(split_name, ds) cleaned_splits[split_name] = cleaned_ds cleaning_stats[split_name] = { "fixed_examples": fixed_count, "dropped_examples": dropped_count, "original_examples": len(ds), "cleaned_examples": len(cleaned_ds), } print( f" Fixed examples: {fixed_count}, dropped examples: {dropped_count}, " f"final size: {len(cleaned_ds)} (from {len(ds)})" ) cleaned_dataset = DatasetDict(cleaned_splits) print("\nValidation after cleaning") cleaned_summary: Dict[str, Any] = {} for split_name, ds in cleaned_dataset.items(): print(f"Validating cleaned split: {split_name} (num_rows={len(ds)})") result = validate_split(split_name, ds) print_validation_summary(split_name, result) cleaned_summary[split_name] = { "num_examples": result["num_examples"], "num_examples_with_issues": result["num_examples_with_issues"], "role_counts": dict(result["role_counts"]), } summary = { "original": original_summary, "cleaned": cleaned_summary, "cleaning_stats": cleaning_stats, } with open( "cemig_format_validation_and_cleaning_summary.json", "w", encoding="utf_8", ) as f: json.dump(summary, f, indent=2, ensure_ascii=False) print("\nWriting cleaned splits to JSONL") for split_name, ds in cleaned_dataset.items(): out_path = f"cemig_clean_{split_name}.jsonl" print(f" Writing cleaned split to JSONL: {out_path}") ds.to_json( out_path, lines=True, force_ascii=False, ) cleaned_dataset.save_to_disk("cemig_clean") print("\nSummary written to cemig_format_validation_and_cleaning_summary.json") print("Cleaned dataset saved to 'cemig_clean' and JSONL files per split") if __name__ == "__main__": main()