diff --git a/pyproject.toml b/pyproject.toml index 7b0dceb..1fa1020 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -22,6 +22,8 @@ dependencies = [ "datasets>=3.0.0", "tinker", "matplotlib>=3.8.0", + "dagshub", + "mlflow", ] [project.optional-dependencies] diff --git a/scripts/analysis_data.py b/scripts/analysis_data.py new file mode 100644 index 0000000..da642cc --- /dev/null +++ b/scripts/analysis_data.py @@ -0,0 +1,664 @@ +#!/usr/bin/env python3 +""" +Logical Compression Analysis +Analyzes symbol usage, logical coherence, and pattern quality in compression training data. +Based on propositional logic principles: scope, precedence, ambiguity detection. +""" + +import json +import re +import statistics +from collections import Counter, defaultdict +from datetime import datetime +from pathlib import Path + +# ============================================================================ +# SYMBOL DEFINITIONS +# ============================================================================ + +SYMBOLS = { + "→": "implication", # if-then, leads to, results in (\u2192) + "|": "separator", # separates facts/alternatives + "@": "location", # at, located at + "∵": "causation", # because, due to (\u2235) + ":": "assignment", # label, definition +} + +# Logical operators from propositional logic +LOGICAL_CONNECTIVES = { + "&": "conjunction", # and + "|": "disjunction", # or (if used logically) + "→": "implication", # if-then + "⇔": "biconditional", # if and only if + "¬": "negation", # not + "~": "negation_alt", # not (alternative) +} + + +# ============================================================================ +# PATTERN ANALYSIS FUNCTIONS +# ============================================================================ + + +def extract_verbose_compressed(sample: dict) -> tuple[str, str]: + """Extract input (verbose) and output (compressed) from message structure.""" + messages = sample.get("messages", []) + + verbose = "" + compressed = "" + + for msg in messages: + role = msg.get("role", "") + content = msg.get("content", "") + + if role == "user" and "Compress:" in content: + # Extract text after "Compress:" + verbose = content.split("Compress:", 1)[1].strip() + elif role == "assistant": + compressed = content.strip() + + return verbose, compressed + + +def tokenize_compression(compressed: str) -> list[str]: + """Break compression into tokens: symbols and text chunks.""" + tokens = [] + current = [] + + for char in compressed: + if char in SYMBOLS or char in LOGICAL_CONNECTIVES: + if current: + tokens.append("".join(current).strip()) + current = [] + tokens.append(char) + else: + current.append(char) + + if current: + tokens.append("".join(current).strip()) + + return [t for t in tokens if t] + + +def extract_symbol_sequence(compressed: str) -> str: + """Extract just the symbol sequence (X for content, symbols as-is).""" + result = [] + for char in compressed: + if char in SYMBOLS or char in LOGICAL_CONNECTIVES: + result.append(char) + elif result and result[-1] != "X": + result.append("X") + + return "".join(result) + + +def detect_scope_ambiguity(compressed: str) -> list[str]: + """ + Detect scope ambiguities based on propositional logic. + E.g., A → B | C could mean (A → B) | C or A → (B | C) + """ + issues = [] + + # Pattern: multiple implications with separator, no parentheses + # A → B | C → D is ambiguous + # Check if there are parentheses to disambiguate + if ( + compressed.count("→") > 1 + and ("|" in compressed or "&" in compressed) + and "(" not in compressed + ): + issues.append("SCOPE_AMBIGUITY: Multiple → with | or & but no grouping") + + # Pattern: A | B → C (which binds first?) + if "|" in compressed and "→" in compressed: + parts = re.split(r"[()]", compressed) + for part in parts: + if "|" in part and "→" in part: + # Check order + pipe_idx = part.find("|") + arrow_idx = part.find("→") + if pipe_idx < arrow_idx: + issues.append("PRECEDENCE_UNCLEAR: | before → without grouping") + + return issues + + +def detect_orphaned_symbols(compressed: str) -> list[str]: + """Detect symbols at start/end or consecutive symbols.""" + issues = [] + + # Symbol at start + if compressed and compressed[0] in SYMBOLS: + issues.append(f"ORPHAN_START: {compressed[0]} at beginning") + + # Symbol at end + if compressed and compressed[-1] in SYMBOLS: + issues.append(f"ORPHAN_END: {compressed[-1]} at end") + + # Consecutive symbols + for i in range(len(compressed) - 1): + if compressed[i] in SYMBOLS and compressed[i + 1] in SYMBOLS: + issues.append(f"CONSECUTIVE: {compressed[i]}{compressed[i + 1]}") + break + + return issues + + +def analyze_symbol_context(verbose: str, compressed: str, symbol: str) -> dict: + """ + Analyze when a symbol is used vs when it could/should be used. + """ + result = { + "symbol": symbol, + "used": symbol in compressed, + "context_present": False, + "context_keywords": [], + } + + verbose_lower = verbose.lower() + + if symbol == "→": + # Implication keywords + keywords = ["if", "then", "therefore", "thus", "hence", "leads to", "results in", "causes"] + for kw in keywords: + if kw in verbose_lower: + result["context_present"] = True + result["context_keywords"].append(kw) + + elif symbol == "∵": + # Causation keywords + keywords = ["because", "since", "due to", "caused by", "reason", "as a result"] + for kw in keywords: + if kw in verbose_lower: + result["context_present"] = True + result["context_keywords"].append(kw) + + elif symbol == "@": + # Location keywords + keywords = ["at", "in", "located", "place", "where", "location", "based"] + for kw in keywords: + if kw in verbose_lower: + result["context_present"] = True + result["context_keywords"].append(kw) + + elif symbol == "|": + # Separator - lists, alternatives + keywords = ["and", "or", ",", ";"] + for kw in keywords: + if kw in verbose_lower: + result["context_present"] = True + result["context_keywords"].append(kw) + + elif symbol == ":": + # Assignment/definition + keywords = ["is", "are", "means", "defined as", "represents"] + for kw in keywords: + if kw in verbose_lower: + result["context_present"] = True + result["context_keywords"].append(kw) + + return result + + +def extract_logical_pattern(compressed: str) -> str: + """ + Extract logical structure pattern. + Similar to propositional logic form but for compression. + """ + # Replace content with P, Q, R... but keep symbols + pattern = compressed + + # Remove parentheses content but keep structure + pattern = re.sub(r"\([^)]+\)", "(P)", pattern) + + # Replace text chunks with P + pattern = re.sub(r"[^→|@∵:()]+", "P", pattern) + + # Collapse consecutive P's + pattern = re.sub(r"P+", "P", pattern) + + return pattern.strip() + + +def check_negation_preservation(verbose: str, compressed: str) -> dict: + """Check if negations are preserved.""" + # Words safe for word-boundary matching + negation_words = ["not", "no", "never", "neither", "nor", "without", "none"] + + verbose_lower = verbose.lower() + compressed_lower = compressed.lower() + + # Whole-word negations + verbose_has_word_neg = any( + re.search(r"\b" + word + r"\b", verbose_lower) for word in negation_words + ) + compressed_has_word_neg = any( + re.search(r"\b" + word + r"\b", compressed_lower) for word in negation_words + ) + + # Contracted negation (handles don't / can’t / isn’t) + verbose_has_contraction = bool(re.search(r"n[’']t\b", verbose_lower)) + compressed_has_contraction = bool(re.search(r"n[’']t\b", compressed_lower)) + + # Negation symbols in compressed form + has_neg_symbol = "¬" in compressed or "~" in compressed or "!" in compressed + + verbose_has_negation = verbose_has_word_neg or verbose_has_contraction + compressed_has_negation = ( + compressed_has_word_neg or compressed_has_contraction or has_neg_symbol + ) + + return { + "verbose_has_negation": verbose_has_negation, + "compressed_has_negation": compressed_has_negation, + "negation_lost": verbose_has_negation and not compressed_has_negation, + } + + +def analyze_symbol_combinations(compressed: str) -> list[tuple[str, str]]: + """Extract symbol pairs (bigrams) to find common combinations.""" + symbols_only = [char for char in compressed if char in SYMBOLS] + bigrams = [] + for i in range(len(symbols_only) - 1): + bigrams.append((symbols_only[i], symbols_only[i + 1])) + return bigrams + + +# ============================================================================ +# MAIN ANALYSIS +# ============================================================================ + + +def analyze_dataset(data: list[dict]) -> dict: + """Run comprehensive logical analysis on compression data.""" + + results = { + "total_samples": len(data), + "symbol_usage": defaultdict(int), + "symbol_context_analysis": defaultdict( + lambda: { + "used_when_context_present": 0, + "not_used_when_context_present": 0, + "used_without_context": 0, + } + ), + "scope_ambiguities": [], + "orphaned_symbols": [], + "logical_patterns": Counter(), + "symbol_combinations": Counter(), + "negation_analysis": { + "total_with_negation": 0, + "negation_preserved": 0, + "negation_lost": 0, + }, + "compression_ratios": [], + "problematic_samples": [], + "good_samples": [], + } + + for idx, sample in enumerate(data): + verbose, compressed = extract_verbose_compressed(sample) + + if not verbose or not compressed: + continue + + # Compression ratio + v_tokens = len(verbose.split()) + c_tokens = len(compressed.split()) + ratio = v_tokens / c_tokens if c_tokens > 0 else 0 + results["compression_ratios"].append(ratio) + + # Symbol usage + for symbol in SYMBOLS: + if symbol in compressed: + results["symbol_usage"][symbol] += 1 + + # Symbol context analysis + for symbol in SYMBOLS: + ctx = analyze_symbol_context(verbose, compressed, symbol) + + if ctx["context_present"] and ctx["used"]: + results["symbol_context_analysis"][symbol]["used_when_context_present"] += 1 + elif ctx["context_present"] and not ctx["used"]: + results["symbol_context_analysis"][symbol]["not_used_when_context_present"] += 1 + elif not ctx["context_present"] and ctx["used"]: + results["symbol_context_analysis"][symbol]["used_without_context"] += 1 + + # Scope ambiguity detection + scope_issues = detect_scope_ambiguity(compressed) + if scope_issues: + results["scope_ambiguities"].append( + {"id": idx, "issues": scope_issues, "compressed": compressed[:150]} + ) + + # Orphaned symbols + orphan_issues = detect_orphaned_symbols(compressed) + if orphan_issues: + results["orphaned_symbols"].append( + {"id": idx, "issues": orphan_issues, "compressed": compressed[:150]} + ) + + # Logical patterns + pattern = extract_logical_pattern(compressed) + results["logical_patterns"][pattern] += 1 + + # Symbol combinations + bigrams = analyze_symbol_combinations(compressed) + for bg in bigrams: + results["symbol_combinations"][bg] += 1 + + # Negation analysis + neg_check = check_negation_preservation(verbose, compressed) + if neg_check["verbose_has_negation"]: + results["negation_analysis"]["total_with_negation"] += 1 + if neg_check["compressed_has_negation"]: + results["negation_analysis"]["negation_preserved"] += 1 + else: + results["negation_analysis"]["negation_lost"] += 1 + + # Flag problematic samples + if ratio < 1.0 or scope_issues or orphan_issues: + results["problematic_samples"].append( + { + "id": idx, + "ratio": ratio, + "scope_issues": scope_issues, + "orphan_issues": orphan_issues, + "verbose": verbose[:100], + "compressed": compressed[:100], + } + ) + + # Flag good samples + if ratio > 3.0 and not scope_issues and not orphan_issues: + results["good_samples"].append( + {"id": idx, "ratio": ratio, "compressed": compressed[:150]} + ) + + return results + + +def generate_report(results: dict) -> str: + """Generate analysis report.""" + + lines = [] + lines.append("=" * 80) + lines.append("LOGICAL COMPRESSION ANALYSIS REPORT") + lines.append("=" * 80) + lines.append("") + + # Dataset overview + lines.append("DATASET OVERVIEW") + lines.append("-" * 80) + lines.append(f"Total samples analyzed: {results['total_samples']}") + lines.append("") + + # Compression quality + lines.append("COMPRESSION QUALITY") + lines.append("-" * 80) + ratios = results["compression_ratios"] + if ratios: + lines.append(f"Mean ratio: {statistics.mean(ratios):.2f}x") + lines.append(f"Median ratio: {statistics.median(ratios):.2f}x") + lines.append(f"Min: {min(ratios):.2f}x | Max: {max(ratios):.2f}x") + lines.append( + f"Samples with ratio < 1.0: {sum(1 for r in ratios if r < 1.0)} (WORSE than input)" + ) + lines.append( + f"Samples with ratio > 3.0: {sum(1 for r in ratios if r > 3.0)} (GOOD compression)" + ) + lines.append("") + + # Symbol usage + lines.append("SYMBOL USAGE") + lines.append("-" * 80) + total = results["total_samples"] + for symbol, name in SYMBOLS.items(): + count = results["symbol_usage"][symbol] + pct = (count / total * 100) if total > 0 else 0 + lines.append(f"{symbol} ({name:12s}): {count:4d} / {total} ({pct:5.1f}%)") + lines.append("") + + # Symbol context analysis (KEY INSIGHT) + lines.append("SYMBOL CONTEXT ANALYSIS (When should symbol be used?)") + lines.append("-" * 80) + for symbol in SYMBOLS: + ctx = results["symbol_context_analysis"][symbol] + used_when_should = ctx["used_when_context_present"] + missed_when_should = ctx["not_used_when_context_present"] + used_wrongly = ctx["used_without_context"] + + total_opportunities = used_when_should + missed_when_should + if total_opportunities > 0: + accuracy = used_when_should / total_opportunities * 100 + lines.append(f"\n{symbol} ({SYMBOLS[symbol]}):") + lines.append( + f" Correctly used when context present: {used_when_should} / {total_opportunities} ({accuracy:.1f}%)" + ) + lines.append(f" Missed opportunities: {missed_when_should}") + lines.append(f" Used without clear context: {used_wrongly}") + lines.append("") + + # Symbol combinations (PATTERN DISCOVERY) + lines.append("SYMBOL COMBINATIONS (Bigrams)") + lines.append("-" * 80) + lines.append("Most common symbol sequences:") + for (s1, s2), count in results["symbol_combinations"].most_common(15): + lines.append(f" {s1}{s2} : {count:3d} times") + lines.append("") + + # Logical patterns + lines.append("TOP LOGICAL PATTERNS") + lines.append("-" * 80) + for pattern, count in results["logical_patterns"].most_common(20): + pct = (count / total * 100) if total > 0 else 0 + lines.append(f"{pattern:50s} : {count:3d} ({pct:4.1f}%)") + lines.append("") + + # Scope ambiguities (CRITICAL ISSUE) + lines.append("SCOPE AMBIGUITIES (Propositional Logic Issues)") + lines.append("-" * 80) + if results["scope_ambiguities"]: + lines.append(f"Total samples with scope ambiguity: {len(results['scope_ambiguities'])}") + lines.append("\nFirst 5 examples:") + for item in results["scope_ambiguities"][:5]: + lines.append(f"\n ID {item['id']}:") + for issue in item["issues"]: + lines.append(f" - {issue}") + lines.append(f" Sample: {item['compressed'][:100]}...") + else: + lines.append("No scope ambiguities detected.") + lines.append("") + + # Orphaned symbols + lines.append("ORPHANED SYMBOLS (Syntax Errors)") + lines.append("-" * 80) + if results["orphaned_symbols"]: + lines.append(f"Total samples with orphaned symbols: {len(results['orphaned_symbols'])}") + lines.append("\nFirst 5 examples:") + for item in results["orphaned_symbols"][:5]: + lines.append(f"\n ID {item['id']}:") + for issue in item["issues"]: + lines.append(f" - {issue}") + lines.append(f" Sample: {item['compressed'][:100]}...") + else: + lines.append("No orphaned symbols detected.") + lines.append("") + + # Negation analysis + lines.append("NEGATION PRESERVATION") + lines.append("-" * 80) + neg = results["negation_analysis"] + if neg["total_with_negation"] > 0: + preservation_rate = neg["negation_preserved"] / neg["total_with_negation"] * 100 + lines.append(f"Samples with negation in input: {neg['total_with_negation']}") + lines.append(f"Negation preserved: {neg['negation_preserved']} ({preservation_rate:.1f}%)") + lines.append(f"Negation LOST: {neg['negation_lost']} ({100 - preservation_rate:.1f}%)") + else: + lines.append("No negations detected in inputs.") + lines.append("") + + # Problematic samples + lines.append("PROBLEMATIC SAMPLES (First 10)") + lines.append("-" * 80) + for item in results["problematic_samples"][:10]: + lines.append(f"\nID {item['id']}: Ratio {item['ratio']:.2f}x") + if item["scope_issues"]: + lines.append(f" Scope issues: {', '.join(item['scope_issues'])}") + if item["orphan_issues"]: + lines.append(f" Orphan issues: {', '.join(item['orphan_issues'])}") + lines.append(f" Input: {item['verbose']}...") + lines.append(f" Output: {item['compressed']}...") + lines.append("") + + # Good samples + lines.append("GOOD SAMPLES (High quality compressions, first 5)") + lines.append("-" * 80) + for item in sorted(results["good_samples"], key=lambda x: x["ratio"], reverse=True)[:5]: + lines.append(f"\nID {item['id']}: Ratio {item['ratio']:.2f}x") + lines.append(f" {item['compressed']}") + lines.append("") + + # RECOMMENDATIONS + lines.append("RECOMMENDATIONS") + lines.append("=" * 80) + + rec_num = 1 + + # Symbol usage recommendations + for symbol in ["@", "∵"]: + ctx = results["symbol_context_analysis"][symbol] + total_opportunities = ( + ctx["used_when_context_present"] + ctx["not_used_when_context_present"] + ) + if total_opportunities > 0: + accuracy = ctx["used_when_context_present"] / total_opportunities * 100 + if accuracy < 50: + lines.append( + f"{rec_num}. UNDERUSED SYMBOL {symbol}: Only used {accuracy:.1f}% when context present." + ) + lines.append( + f" Action: Add training examples explicitly using {symbol} or filter samples missing it." + ) + rec_num += 1 + + # Scope ambiguity + if len(results["scope_ambiguities"]) > total * 0.1: + lines.append( + f"{rec_num}. SCOPE AMBIGUITY: {len(results['scope_ambiguities'])} samples have unclear precedence." + ) + lines.append( + " Action: Define operator precedence (e.g., | binds tighter than →) or require parentheses." + ) + rec_num += 1 + + # Negation loss + if neg["total_with_negation"] > 0: + loss_rate = neg["negation_lost"] / neg["total_with_negation"] * 100 + if loss_rate > 30: + lines.append(f"{rec_num}. NEGATION LOST: {loss_rate:.1f}% of negations are dropped.") + lines.append(" Action: Add negation symbol (¬ or ~) to preserve meaning.") + rec_num += 1 + + # Bad compressions + bad_count = sum(1 for r in ratios if r < 1.0) + if bad_count > 0: + lines.append( + f"{rec_num}. FILTER BAD SAMPLES: {bad_count} samples are LONGER than input (ratio < 1.0)." + ) + lines.append(" Action: Remove these from training data.") + rec_num += 1 + + # Symbol combinations insight + top_combo = results["symbol_combinations"].most_common(1) + if top_combo: + (s1, s2), count = top_combo[0] + lines.append(f"{rec_num}. DOMINANT PATTERN: {s1}{s2} appears {count} times.") + lines.append( + " Insight: This is your model's most common structure. Ensure it's logically sound." + ) + rec_num += 1 + + lines.append("") + lines.append("=" * 80) + lines.append("END OF REPORT") + lines.append("=" * 80) + + return "\n".join(lines) + + +# ============================================================================ +# MAIN +# ============================================================================ + + +def main(): + # EDIT THESE PATHS + INPUT_FILE = "data/training/train.jsonl" # <-- PUT YOUR FILE PATH HERE + OUTPUT_DIR = Path("reports/logical_analysis") + OUTPUT_DIR.mkdir(parents=True, exist_ok=True) + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + OUTPUT_REPORT = OUTPUT_DIR / f"logical_analysis_report_{timestamp}.txt" + OUTPUT_JSON = OUTPUT_DIR / f"logical_analysis_data_{timestamp}.json" + + print(f"Loading data from {INPUT_FILE}...") + + try: + with open(INPUT_FILE, encoding="utf-8") as f: + data = [json.loads(line) for line in f if line.strip()] + except FileNotFoundError: + print(f"ERROR: File '{INPUT_FILE}' not found.") + print("Please edit the INPUT_FILE path in the script.") + return + + print(f"Loaded {len(data)} samples.") + print("Running logical analysis...") + + results = analyze_dataset(data) + + print("Generating report...") + report = generate_report(results) + + # Print to console + print("\n" + report) + + # Save report + with open(OUTPUT_REPORT, "w", encoding="utf-8") as f: + f.write(report) + print(f"\nReport saved to {OUTPUT_REPORT}") + + # Save raw data + serializable = { + "total_samples": results["total_samples"], + "symbol_usage": dict(results["symbol_usage"]), + "symbol_context_analysis": { + k: dict(v) for k, v in results["symbol_context_analysis"].items() + }, + "compression_ratios": { + "mean": statistics.mean(results["compression_ratios"]) + if results["compression_ratios"] + else 0, + "median": statistics.median(results["compression_ratios"]) + if results["compression_ratios"] + else 0, + "min": min(results["compression_ratios"]) if results["compression_ratios"] else 0, + "max": max(results["compression_ratios"]) if results["compression_ratios"] else 0, + }, + "logical_patterns": dict(results["logical_patterns"].most_common(50)), + "symbol_combinations": { + f"{s1}{s2}": count for (s1, s2), count in results["symbol_combinations"].most_common(30) + }, + "negation_analysis": results["negation_analysis"], + "scope_ambiguities_count": len(results["scope_ambiguities"]), + "orphaned_symbols_count": len(results["orphaned_symbols"]), + "problematic_count": len(results["problematic_samples"]), + "good_samples_count": len(results["good_samples"]), + } + + with open(OUTPUT_JSON, "w", encoding="utf-8") as f: + json.dump(serializable, f, indent=2) + print(f"Raw data saved to {OUTPUT_JSON}") + + +if __name__ == "__main__": + main() diff --git a/scripts/data_sanitization.py b/scripts/data_sanitization.py new file mode 100644 index 0000000..bfad34c --- /dev/null +++ b/scripts/data_sanitization.py @@ -0,0 +1,837 @@ +#!/usr/bin/env python3 +""" +Data Sanitization for Compression Training + +SCOPE: This script is designed specifically for data/training/train.jsonl + with chat-message format (system/user/assistant roles). + +Usage: + # Default paths + python data_sanitization.py + + # Custom paths + python data_sanitization.py \ + --input data/training/train.jsonl \ + --sanitized data/training/sanitized_train.jsonl \ + --unsanitized data/training/unsanitized_train.jsonl + +CHANGES FROM V3: +- Rule B now code-aware: allows leading @ for code samples (decorators) +- Token-based compression ratio aligned with src/utils/tokenizers.py +- Explicit format validation with parse error logging +- Guards for unexpected message structures +- CLI arguments for flexible path configuration + +Extracts BOTH sanitized and unsanitized samples in one pass. +Unsanitized samples are saved for recovery analysis. +""" + +import argparse +import json +import re +import sys +from pathlib import Path + +# Import tokenizer for token-based ratios +sys.path.insert(0, str(Path(__file__).parent.parent)) +from src.utils.tokenizers import compression_ratio + +# ============================================================================ +# SYMBOL DEFINITIONS +# ============================================================================ + +SYMBOLS = {"→", "|", "@", "∵", ":"} + +# Strict keywords for natural language only +LOCATION_KEYWORDS_NL = [ + "located in", + "located at", + "based in", + "situated in", + "found in", + "positioned at", + "positioned in", + "place is", + "place was", + "city of", + "town of", + "on the shores of", + "near the", + "by the", +] + +CAUSATION_KEYWORDS_NL = [ + "because of", + "due to", + "caused by", + "as a result of", + "leads to", + "results in", + "led to", + "resulted in", + "owing to", + "on account of", + "thanks to", + "consequently", + "therefore", + "thus", +] + +# Code detection indicators +CODE_INDICATORS = [ + "def ", + "class ", + "import ", + "return ", + "yield ", + "async ", + "await ", + "self.", + "__init__", + "__", + "lambda ", + "isinstance(", + "raise ", + "@classmethod", + "@staticmethod", + "@property", + "function ", + "const ", + "let ", + "var ", + "=>", + "async function", + "fn:", + "->", + "fn(", + "void ", + "int ", + "string ", + "bool ", + "```", + "```python", + "```javascript", + "```java", + " def ", + " class ", +] + + +# ============================================================================ +# HELPER FUNCTIONS +# ============================================================================ + + +def is_code_sample(verbose: str) -> bool: + """ + Detect if sample is code-related. + + Uses multiple signals to avoid misclassifying brace-heavy text (JSON, etc.) as code. + Requires at least 2 strong signals OR 1 very strong signal. + """ + verbose_lower = verbose.lower() + + # Very strong signals (definitive code indicators) + very_strong_indicators = [ + "def ", + "class ", + "function ", + "import ", + "return ", + "async ", + "await ", + "yield ", + "@property", + "@staticmethod", + "@classmethod", + "fn:", + "lambda ", + "isinstance(", + "raise ", + ] + + for indicator in very_strong_indicators: + if indicator.lower() in verbose_lower: + return True # Single very strong signal is enough + + # Strong signals (likely code) + strong_signals = 0 + + # Check for code-specific keywords + code_keywords = [ + "self.", + "__init__", + "const ", + "let ", + "var ", + "void ", + "int ", + "string ", + "bool ", + ] + for keyword in code_keywords: + if keyword.lower() in verbose_lower: + strong_signals += 1 + break # Count once + + # Check for indentation pattern (multiple indented lines) + lines = verbose.split("\n") + indented_lines = sum(1 for line in lines if line.startswith(" ") or line.startswith("\t")) + if indented_lines >= 3: # Increased threshold from 2 to 3 + strong_signals += 1 + + # Check for code block markers + if ( + "```python" in verbose_lower + or "```javascript" in verbose_lower + or "```java" in verbose_lower + ): + strong_signals += 1 + + # Tightened code patterns - require more context + code_patterns = [ + r"\bdef\s+\w+\s*\(", + r"\bclass\s+\w+\s*[\(:]", + r"\bfunction\s+\w+\s*\(", + r"\w+\s*=\s*function\s*\(", + # Tightened type annotation pattern - require multiple + r"(\w+\s*:\s*\w+.*){2,}", # At least 2 type annotations + ] + + for pattern in code_patterns: + if re.search(pattern, verbose): + strong_signals += 1 + break # Count once + + # Tightened {...} check - only count if it looks like actual code block + # Must have semicolons, return statements, or assignment inside braces + brace_code_pattern = r"\{[^}]*(;|return\s|=\s)[^}]*\}" + if re.search(brace_code_pattern, verbose): + strong_signals += 1 + + # Require at least 2 strong signals to classify as code + return strong_signals >= 2 + + +def extract_verbose_compressed( + sample: dict, sample_id: int +) -> tuple[str | None, str | None, str | None]: + """ + Extract input (verbose) and output (compressed) from chat message structure. + + EXPECTED FORMAT for data/training/train.jsonl: + { + "messages": [ + {"role": "system", "content": "..."}, + {"role": "user", "content": "Compress:\n"}, + {"role": "assistant", "content": ""} + ] + } + + Returns: + (verbose, compressed, error_message) + error_message is None if parsing succeeded + """ + # Validate top-level structure + if not isinstance(sample, dict): + return None, None, f"Sample {sample_id}: Not a dict" + + if "messages" not in sample: + return None, None, f"Sample {sample_id}: Missing 'messages' key" + + messages = sample.get("messages", []) + + if not isinstance(messages, list): + return None, None, f"Sample {sample_id}: 'messages' is not a list" + + if len(messages) < 2: + return ( + None, + None, + f"Sample {sample_id}: Expected at least 2 messages (user + assistant), got {len(messages)}", + ) + + verbose = "" + compressed = "" + found_user = False + found_assistant = False + + for msg in messages: + if not isinstance(msg, dict): + continue + + role = msg.get("role", "") + content = msg.get("content", "") + + if role == "user": + found_user = True + if "Compress:" in content: + verbose = content.split("Compress:", 1)[1].strip() + else: + return ( + None, + None, + f"Sample {sample_id}: User message doesn't contain 'Compress:' marker", + ) + + elif role == "assistant": + found_assistant = True + compressed = content.strip() + + # Validate we found expected roles + if not found_user: + return None, None, f"Sample {sample_id}: No user message found" + + if not found_assistant: + return None, None, f"Sample {sample_id}: No assistant message found" + + if not verbose: + return None, None, f"Sample {sample_id}: Empty verbose text after 'Compress:'" + + if not compressed: + return None, None, f"Sample {sample_id}: Empty compressed text" + + return verbose, compressed, None + + +def compute_compression_ratio_tokens(verbose: str, compressed: str) -> float: + """ + Compute token-based compression ratio aligned with src/utils/tokenizers.py. + + Returns compression_ratio where ratio > 1.0 means expansion (bad). + For Rule A, we want ratio <= 1.0 (compressed <= verbose in tokens). + """ + return compression_ratio(verbose, compressed) + + +# ============================================================================ +# VALIDATION RULES +# ============================================================================ + + +def rule_a_ratio_check(verbose: str, compressed: str) -> tuple[bool, str]: + """ + Rule A: Remove samples with compression ratio > 1.0 (expansion). + + Uses token-based ratio from src/utils/tokenizers.py. + Ratio > 1.0 means compressed text is longer than input (bad compression). + """ + ratio = compute_compression_ratio_tokens(verbose, compressed) + + # compression_ratio returns compressed/verbose + # We want compressed <= verbose, so ratio <= 1.0 + if ratio > 1.0: + return False, f"Ratio {ratio:.2f} > 1.0 (expansion)" + return True, "" + + +def rule_b_orphaned_symbols(compressed: str, is_code: bool) -> tuple[bool, str]: + """ + Rule B: Remove samples with orphaned symbols. + + CODE-AWARE: Allows leading @ for code samples (Python decorators). + """ + if not compressed: + return False, "Empty compression" + + # Check leading symbol - allow @ for code samples (decorators) + if compressed[0] in SYMBOLS: + if is_code and compressed[0] == "@": + # Valid decorator pattern + pass + else: + return False, f"Orphaned symbol at start: '{compressed[0]}'" + + # Check trailing symbol (: is allowed at end) + if compressed[-1] in SYMBOLS and compressed[-1] != ":": + return False, f"Orphaned symbol at end: '{compressed[-1]}'" + + # Check consecutive symbols (except ::) + for i in range(len(compressed) - 1): + if compressed[i] in SYMBOLS and compressed[i + 1] in SYMBOLS: + if compressed[i] == ":" and compressed[i + 1] == ":": + continue # :: is allowed (namespace separator) + return False, f"Consecutive symbols: '{compressed[i]}{compressed[i + 1]}'" + + return True, "" + + +""" +RULE C FIX: Drop-in replacement for rule_c_negation_preservation + +Replace the existing rule_c_negation_preservation function in your +sanitization script with these functions. + +FIXES: +1. Unicode apostrophes (can't vs can't) - CRITICAL +2. Flexible whitespace in multi-word phrases +3. Reduced false positives from symbols (~, !) +4. Proper contraction handling as suffix, not standalone word +""" + +import re +from typing import Tuple + + +def _normalize_apostrophes(text: str) -> str: + """Normalize Unicode apostrophes to ASCII.""" + unicode_apostrophes = ['\u2019', '\u2018', '\u02BC', '\u0060'] + normalized = text + for unicode_apos in unicode_apostrophes: + normalized = normalized.replace(unicode_apos, "'") + return normalized + + +def _normalize_whitespace(text: str) -> str: + """Normalize whitespace for consistent matching.""" + normalized = text.replace('\n', ' ').replace('\t', ' ').replace('\r', ' ') + normalized = re.sub(r'\s+', ' ', normalized) + return normalized.strip() + + +def _has_contractions(text: str) -> bool: + """Detect negation contractions (don't, can't, won't, etc.).""" + normalized = _normalize_apostrophes(text.lower()) + return bool(re.search(r"\w+n't\b", normalized)) + + +def _has_standalone_negation(text: str) -> bool: + """Detect standalone negation words.""" + normalized = _normalize_whitespace(text.lower()) + words = ["not", "no", "never", "neither", "nor", + "without", "none", "nothing", "nobody", "nowhere"] + + for word in words: + if re.search(r'\b' + re.escape(word) + r'\b', normalized): + return True + return False + + +def _has_multiword_negation(text: str) -> bool: + """Detect multi-word negation phrases with flexible whitespace.""" + normalized = _normalize_whitespace(text.lower()) + patterns = [r'\bno\s+longer\b', r'\bno\s+more\b', r'\bnot\s+anymore\b'] + + return any(re.search(pattern, normalized) for pattern in patterns) + + +def _has_negation_symbols(text: str, strict: bool = True) -> bool: + """ + Detect negation symbols with reduced false positives. + + Args: + strict: If True, only check ¬ (unambiguous) + If False, also check ~ and ! (more permissive) + """ + if '¬' in text: + return True + + if not strict: + # Check for ! but avoid != and !! + if re.search(r'![^=!]', text): + return True + # Check for ~ but avoid ~/ and ~digits + if re.search(r'~(?![/\d])', text): + return True + + return False + + +def rule_c_negation_preservation(verbose: str, compressed: str) -> Tuple[bool, str]: + """ + Rule C: Remove samples that lost negation (NL only). + + FIXED VERSION addressing: + - Unicode apostrophes in contractions (can't vs can't) + - Flexible whitespace in multi-word phrases + - Reduced false positives from symbols + - Proper contraction detection + + Returns: + (passed, reason) - passed=False if negation was lost + """ + # Check if input has any form of negation + has_input_negation = ( + _has_contractions(verbose) or + _has_standalone_negation(verbose) or + _has_multiword_negation(verbose) + ) + + if not has_input_negation: + return True, "" # No negation to preserve + + # Input has negation - check if output preserved it + has_output_negation = ( + _has_contractions(compressed) or + _has_standalone_negation(compressed) or + _has_multiword_negation(compressed) or + _has_negation_symbols(compressed, strict=False) # Allow symbols in compressed + ) + + if not has_output_negation: + return False, "Negation lost" + + return True, "" + + +def rule_d_semantic_symbol_usage_nl(verbose: str, compressed: str) -> tuple[bool, str]: + """Rule D: Remove samples that should use @ or ∵ but don't (NL only)""" + verbose_lower = verbose.lower() + + has_location_context = any(kw in verbose_lower for kw in LOCATION_KEYWORDS_NL) + if has_location_context and "@" not in compressed: + return False, "Location context but no '@'" + + has_causation_context = any(kw in verbose_lower for kw in CAUSATION_KEYWORDS_NL) + if has_causation_context and "∵" not in compressed: + return False, "Causation context but no '∵'" + + return True, "" + + +# ============================================================================ +# MAIN SANITIZATION + EXTRACTION +# ============================================================================ + + +def sanitize_and_extract(input_path: Path, sanitized_path: Path, unsanitized_path: Path) -> dict: + """ + Single-pass processing: sanitize AND extract unsanitized samples. + Both outputs maintain original JSON structure. + + SCOPE: Designed for data/training/train.jsonl with chat-message format. + """ + # Validate input file exists + if not input_path.exists(): + raise FileNotFoundError(f"Input file not found: {input_path}") + + # Validate expected location + if input_path.name != "train.jsonl": + print(f"⚠ WARNING: Expected train.jsonl, got {input_path.name}") + print(" This script is designed for data/training/train.jsonl format") + + print(f"Loading data from {input_path}...") + + data = [] + + with open(input_path, encoding="utf-8") as f: + for idx, line in enumerate(f): + if not line.strip(): + continue + + try: + sample = json.loads(line) + data.append(sample) + except json.JSONDecodeError as e: + stats["parse_errors"] += 1 + stats["failed_all"] += 1 + + error_msg = f"Sample {idx}: JSON decode error ({e.msg})" + unsanitized_data.append({"raw_line": line.strip()}) + + stats["parse_error_samples"].append( + { + "id": idx, + "error": error_msg, + "raw_line": line.strip(), + } + ) + + print(f"⚠ {error_msg}") + continue + + + print(f"✓ Loaded {len(data)} samples\n") + + stats = { + "total_input": len(data), + "code_samples": 0, + "nl_samples": 0, + "code_passed": 0, + "nl_passed": 0, + "rule_a_failed": 0, + "rule_b_failed": 0, + "rule_c_failed": 0, + "rule_d_failed": 0, + "parse_errors": 0, + "passed_all": 0, + "failed_all": 0, + "failed_samples": [], + "passed_samples": [], + "parse_error_samples": [], + } + + sanitized_data = [] + unsanitized_data = [] + + print("Processing samples...\n") + + for idx, sample in enumerate(data): + # Extract with format validation + verbose, compressed, parse_error = extract_verbose_compressed(sample, idx) + + # Handle parse errors - tracked separately from rule failures + # Parse errors are NOT counted as Rule A failures + if parse_error: + stats["parse_errors"] += 1 + stats["failed_all"] += 1 + unsanitized_data.append(sample) + stats["parse_error_samples"].append({"id": idx, "error": parse_error, "sample": sample}) + print(f"⚠ {parse_error}") + continue # Skip rule validation for malformed samples + + is_code = is_code_sample(verbose) + content_type = "code" if is_code else "nl" + + if is_code: + stats["code_samples"] += 1 + else: + stats["nl_samples"] += 1 + + # Apply all rules + passed = True + failure_reason = "" + failed_rules = [] + + # Rule A (universal) - token-based ratio + rule_a_pass, reason = rule_a_ratio_check(verbose, compressed) + if not rule_a_pass: + stats["rule_a_failed"] += 1 + passed = False + failure_reason = f"Rule A: {reason}" + failed_rules.append("A") + + # Rule B (universal, code-aware) + if passed: + rule_b_pass, reason = rule_b_orphaned_symbols(compressed, is_code) + if not rule_b_pass: + stats["rule_b_failed"] += 1 + passed = False + failure_reason = f"Rule B: {reason}" + failed_rules.append("B") + + # Rule C (NL only) + if passed and not is_code: + rule_c_pass, reason = rule_c_negation_preservation(verbose, compressed) + if not rule_c_pass: + stats["rule_c_failed"] += 1 + passed = False + failure_reason = f"Rule C: {reason}" + failed_rules.append("C") + + # Rule D (NL only) + if passed and not is_code: + rule_d_pass, reason = rule_d_semantic_symbol_usage_nl(verbose, compressed) + if not rule_d_pass: + stats["rule_d_failed"] += 1 + passed = False + failure_reason = f"Rule D: {reason}" + failed_rules.append("D") + + # Sort into sanitized or unsanitized + if passed: + stats["passed_all"] += 1 + if is_code: + stats["code_passed"] += 1 + else: + stats["nl_passed"] += 1 + + sanitized_data.append(sample) + stats["passed_samples"].append( + { + "id": idx, + "type": content_type, + "ratio": compute_compression_ratio_tokens(verbose, compressed), + } + ) + else: + stats["failed_all"] += 1 + unsanitized_data.append(sample) + stats["failed_samples"].append( + { + "id": idx, + "type": content_type, + "reason": failure_reason, + "failed_rules": failed_rules, + "sample": sample, + } + ) + + # Save sanitized + print(f"\nSaving sanitized data to {sanitized_path}...") + sanitized_path.parent.mkdir(parents=True, exist_ok=True) + with open(sanitized_path, "w", encoding="utf-8") as f: + for sample in sanitized_data: + f.write(json.dumps(sample, ensure_ascii=False) + "\n") + print(f"✓ Saved {len(sanitized_data)} sanitized samples") + + # Save unsanitized + print(f"Saving unsanitized data to {unsanitized_path}...") + unsanitized_path.parent.mkdir(parents=True, exist_ok=True) + with open(unsanitized_path, "w", encoding="utf-8") as f: + for sample in unsanitized_data: + f.write(json.dumps(sample, ensure_ascii=False) + "\n") + print(f"✓ Saved {len(unsanitized_data)} unsanitized samples\n") + + return stats + + +def print_statistics(stats: dict): + """Print statistics.""" + total = stats["total_input"] + code = stats["code_samples"] + nl = stats["nl_samples"] + + def pct(n: int, d: int) -> float: + return (n / d * 100.0) if d > 0 else 0.0 + + print("=" * 80) + print("PROCESSING STATISTICS") + print("=" * 80) + print() + + print(f"Total input: {total:5d}") + print(f" Code samples: {code:5d} ({pct(code, total):5.1f}%)") + print(f" NL samples: {nl:5d} ({pct(nl, total):5.1f}%)") + print() + + print(f"✓ SANITIZED (passed): {stats['passed_all']:5d} ({pct(stats['passed_all'], total):5.1f}%)") + print(f" Code: {stats['code_passed']:5d} ({pct(stats['code_passed'], code):5.1f}%)") + print(f" NL: {stats['nl_passed']:5d} ({pct(stats['nl_passed'], nl):5.1f}%)") + print() + + print(f"✗ UNSANITIZED (failed): {stats['failed_all']:5d} ({pct(stats['failed_all'], total):5.1f}%)") + print() + + print("Failed by rule:") + print(f" Rule A (ratio > 1.0): {stats['rule_a_failed']:5d}") + print(f" Rule B (orphaned symbols):{stats['rule_b_failed']:5d}") + print(f" Rule C (lost negation): {stats['rule_c_failed']:5d}") + print(f" Rule D (missing @ or ∵): {stats['rule_d_failed']:5d}") + print(f" Parse errors: {stats['parse_errors']:5d}") + print() + + if stats["parse_errors"] > 0: + print("=" * 80) + print("PARSE ERRORS (First 5)") + print("=" * 80) + print() + for item in stats["parse_error_samples"][:5]: + print(f"Sample {item['id']}:") + print(f" Error: {item['error']}") + print() + + print("=" * 80) + print("UNSANITIZED SAMPLES (First 5)") + print("=" * 80) + print() + + for item in stats["failed_samples"][:5]: + print(f"Sample {item['id']} ({item.get('type', 'unknown').upper()}):") + print(f" Reason: {item['reason']}") + print(f" Failed rules: {', '.join(item.get('failed_rules', []))}") + print() + + + +# ============================================================================ +# CLI +# ============================================================================ + + +def main(): + parser = argparse.ArgumentParser( + description="Sanitize compression training data with validation rules", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=""" +Examples: + # Use default paths + python data_sanitization.py + + # Custom paths + python data_sanitization.py \\ + --input data/training/train.jsonl \\ + --sanitized data/training/sanitized_train.jsonl \\ + --unsanitized data/training/unsanitized_train.jsonl + + # Different dataset location + python data_sanitization.py \\ + --input data/experiments/custom_train.jsonl \\ + --sanitized data/experiments/custom_sanitized.jsonl \\ + --unsanitized data/experiments/custom_unsanitized.jsonl + +Validation Rules: + Rule A: Compression ratio > 1.0 (expansion) + Rule B: Orphaned symbols (code-aware for @ decorators) + Rule C: Lost negation (NL only) + Rule D: Missing semantic symbols @ or ∵ (NL only) + """, + ) + + parser.add_argument( + "--input", + type=str, + default="data/training/train.jsonl", + help="Path to input training file (default: data/training/train.jsonl)", + ) + parser.add_argument( + "--sanitized", + type=str, + default="data/training/sanitized_train.jsonl", + help="Path to output sanitized file (default: data/training/sanitized_train.jsonl)", + ) + parser.add_argument( + "--unsanitized", + type=str, + default="data/training/unsanitized_train.jsonl", + help="Path to output unsanitized file (default: data/training/unsanitized_train.jsonl)", + ) + + args = parser.parse_args() + + # Convert to Path objects + input_path = Path(args.input) + sanitized_path = Path(args.sanitized) + unsanitized_path = Path(args.unsanitized) + + print("\n" + "=" * 80) + print("DATA SANITIZATION + EXTRACTION (Single Pass)") + print("SCOPE: data/training/train.jsonl with chat-message format") + print("=" * 80) + print() + print(f"Input: {input_path}") + print(f"Sanitized: {sanitized_path}") + print(f"Unsanitized: {unsanitized_path}") + print("=" * 80) + print() + + # Process + stats = sanitize_and_extract(input_path, sanitized_path, unsanitized_path) + + # Print stats + print_statistics(stats) + + print("=" * 80) + print("OUTPUT FILES") + print("=" * 80) + print() + print(f"1. {sanitized_path}") + print(f" → {stats['passed_all']} samples (clean, ready for training)") + print() + print(f"2. {unsanitized_path}") + print(f" → {stats['failed_all']} samples (for recovery analysis)") + print() + print("=" * 80) + print("NEXT STEPS") + print("=" * 80) + print() + print("1. Train on sanitized data:") + print(f" Use {sanitized_path} ({stats['passed_all']} samples)") + print() + print("2. Analyze unsanitized samples for recovery:") + print(f" Use {unsanitized_path} ({stats['failed_all']} samples)") + print() + + +if __name__ == "__main__": + main() diff --git a/scripts/dataset_manager.py b/scripts/dataset_manager.py new file mode 100644 index 0000000..616fb7e --- /dev/null +++ b/scripts/dataset_manager.py @@ -0,0 +1,486 @@ +#!/usr/bin/env python3 +""" +Dataset Manager +Manages swapping between sanitized and original training datasets. + +Usage: + python dataset_manager.py --update # Switch to sanitized dataset + python dataset_manager.py --revert # Switch back to original dataset + python dataset_manager.py --status # Check current state + python dataset_manager.py --log # View change history + + # With custom paths + python dataset_manager.py --update \ + --train-file data/training/train.jsonl \ + --sanitized data/training/sanitized_train.jsonl +""" + +import argparse +import json +import shutil +from datetime import datetime +from pathlib import Path + +# ============================================================================ +# CONFIGURATION +# ============================================================================ + + +def get_config(args) -> dict: + """Build configuration from CLI arguments with sensible defaults.""" + + # Use CLI args if provided, otherwise use defaults + train_file = Path(args.train_file) if args.train_file else Path("data/training/train.jsonl") + sanitized_file = ( + Path(args.sanitized) if args.sanitized else Path("data/training/sanitized_train.jsonl") + ) + + # Derive backup path from train file + backup_file = train_file.parent / f"{train_file.stem}.original{train_file.suffix}" + + # State files in same directory as train file + state_dir = train_file.parent + + return { + # Main training file (the one used by training scripts) + "active_train": train_file, + # Backup of original data + "original_backup": backup_file, + # Sanitized data + "sanitized_data": sanitized_file, + # State and log files + "state_file": state_dir / ".dataset_state.json", + "log_file": state_dir / ".dataset_changes.log", + } + + +# ============================================================================ +# STATE MANAGEMENT +# ============================================================================ + + +def load_state(config: dict) -> dict: + """Load current dataset state.""" + if config["state_file"].exists(): + with open(config["state_file"]) as f: + return json.load(f) + + return { + "current": "original", # 'original' or 'sanitized' + "last_action": None, # 'update' or 'revert' + "last_change": None, + "change_count": 0, + } + + +def save_state(config: dict, state: dict): + """Save dataset state.""" + config["state_file"].parent.mkdir(parents=True, exist_ok=True) + with open(config["state_file"], "w") as f: + json.dump(state, f, indent=2) + + +def log_change(config: dict, action: str, from_state: str, to_state: str, details: str = ""): + """Log a dataset change.""" + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + + log_entry = f"[{timestamp}] {action}: {from_state} → {to_state}" + if details: + log_entry += f" | {details}" + log_entry += "\n" + + config["log_file"].parent.mkdir(parents=True, exist_ok=True) + with open(config["log_file"], "a") as f: + f.write(log_entry) + + print(f"✓ Logged: {log_entry.strip()}") + + +# ============================================================================ +# FILE OPERATIONS +# ============================================================================ + + +def count_samples(path): + """ + Count number of JSON objects in a JSONL file. + """ + path = Path(path) + + if not path.exists(): + return 0 + + count = 0 + with path.open("r", encoding="utf-8") as f: + for line in f: + line = line.strip() + if not line: + continue + try: + json.loads(line) + count += 1 + except json.JSONDecodeError: + continue # skip malformed lines safely + + return count + + +def verify_files_exist(config: dict) -> bool: + """Verify required files exist.""" + errors = [] + + if not config["active_train"].exists(): + errors.append(f"❌ Active training file not found: {config['active_train']}") + + if not config["sanitized_data"].exists(): + errors.append(f"❌ Sanitized data not found: {config['sanitized_data']}") + + if errors: + print("\n".join(errors)) + print("\nPlease ensure sanitized data exists before updating.") + return False + + return True + + +def backup_original(config: dict): + """Create backup of original data if it doesn't exist.""" + if not config["original_backup"].exists() and config["active_train"].exists(): + print("Creating backup of original data...") + shutil.copy2(config["active_train"], config["original_backup"]) + print(f"✓ Backup created: {config['original_backup']}") + return True + return False + + +# ============================================================================ +# MAIN OPERATIONS +# ============================================================================ + + +def update_to_sanitized(config: dict) -> bool: + """Switch to sanitized dataset.""" + state = load_state(config) + + # Safety check: if last action was update, only allow revert + if state.get("last_action") == "update": + print("❌ Last action was already UPDATE.") + print(" You can only REVERT after an update.") + print() + print("To revert to original dataset, run:") + print(f" python dataset_manager.py --revert --train-file {config['active_train']}") + return False + + if state["current"] == "sanitized": + print("⚠ Already using sanitized dataset. No changes made.") + return False + + if not verify_files_exist(config): + return False + + # Create backup of original if needed + backup_original(config) + + # Get sample counts + original_count = count_samples(config["active_train"]) + sanitized_count = count_samples(config["sanitized_data"]) + + print("\nSwitching to sanitized dataset...") + print(f" Original samples: {original_count}") + print(f" Sanitized samples: {sanitized_count}") + print(f" Removed samples: {original_count - sanitized_count}") + + # Perform swap + try: + shutil.copy2(config["sanitized_data"], config["active_train"]) + + # Update state + state["current"] = "sanitized" + state["last_action"] = "update" + state["last_change"] = datetime.now().isoformat() + state["change_count"] += 1 + save_state(config, state) + + # Log change + log_change( + config, + action="UPDATE", + from_state="original", + to_state="sanitized", + details=f"{original_count} → {sanitized_count} samples", + ) + + print("\n✓ Successfully switched to sanitized dataset") + print(f"✓ {config['active_train']} now contains {sanitized_count} samples") + print() + print("⚠ To undo this change, run:") + print(f" python dataset_manager.py --revert --train-file {config['active_train']}") + return True + + except Exception as e: + print(f"\n❌ Error during update: {e}") + return False + + +def revert_to_original(config: dict) -> bool: + """Revert to original dataset.""" + state = load_state(config) + + # Safety check: if last action was revert, only allow update + if state.get("last_action") == "revert": + print("❌ Last action was already REVERT.") + print(" You can only UPDATE after a revert.") + print() + print("To switch to sanitized dataset, run:") + print(f" python dataset_manager.py --update --train-file {config['active_train']}") + return False + + if state["current"] == "original": + print("⚠ Already using original dataset. No changes made.") + return False + + if not config["original_backup"].exists(): + print(f"❌ Original backup not found: {config['original_backup']}") + print("Cannot revert without backup.") + return False + + # Get sample counts + sanitized_count = count_samples(config["active_train"]) + original_count = count_samples(config["original_backup"]) + + print("\nReverting to original dataset...") + print(f" Sanitized samples: {sanitized_count}") + print(f" Original samples: {original_count}") + + # Perform swap + try: + shutil.copy2(config["original_backup"], config["active_train"]) + + # Update state + state["current"] = "original" + state["last_action"] = "revert" + state["last_change"] = datetime.now().isoformat() + state["change_count"] += 1 + save_state(config, state) + + # Log change + log_change( + config, + action="REVERT", + from_state="sanitized", + to_state="original", + details=f"{sanitized_count} → {original_count} samples", + ) + + print("\n✓ Successfully reverted to original dataset") + print(f"✓ {config['active_train']} now contains {original_count} samples") + print() + print("⚠ To switch back to sanitized, run:") + print(f" python dataset_manager.py --update --train-file {config['active_train']}") + return True + + except Exception as e: + print(f"\n❌ Error during revert: {e}") + return False + + +def show_status(config: dict): + """Show current dataset status.""" + state = load_state(config) + + print("\n" + "=" * 80) + print("DATASET STATUS") + print("=" * 80) + print() + + # Configuration + print("Configuration:") + print(f" Train file: {config['active_train']}") + print(f" Sanitized file: {config['sanitized_data']}") + print(f" Backup file: {config['original_backup']}") + print() + + # Current state + current = state["current"].upper() + last_action = state.get("last_action", "None") + print(f"Current dataset: {current}") + print(f"Last action: {last_action.upper() if last_action else 'None'}") + print(f"Total changes: {state['change_count']}") + + if state["last_change"]: + last_change = datetime.fromisoformat(state["last_change"]) + print(f"Last change: {last_change.strftime('%Y-%m-%d %H:%M:%S')}") + else: + print("Last change: Never") + + print() + + # File information + print("Files:") + + if config["active_train"].exists(): + active_count = count_samples(config["active_train"]) + print(f" ✓ {config['active_train'].name:25s} {active_count:4d} samples (ACTIVE)") + else: + print(f" ❌ {config['active_train'].name:25s} Not found") + + if config["original_backup"].exists(): + original_count = count_samples(config["original_backup"]) + print(f" ✓ {config['original_backup'].name:25s} {original_count:4d} samples (backup)") + else: + print( + f" ⚠ {config['original_backup'].name:25s} Not found (will be created on first update)" + ) + + if config["sanitized_data"].exists(): + sanitized_count = count_samples(config["sanitized_data"]) + print(f" ✓ {config['sanitized_data'].name:25s} {sanitized_count:4d} samples") + else: + print(f" ❌ {config['sanitized_data'].name:25s} Not found") + + print() + + # Recommendations + print("=" * 80) + print("AVAILABLE ACTIONS") + print("=" * 80) + print() + + # Show only the allowed action based on last action + if last_action == "update": + print("✓ You can REVERT (last action was UPDATE):") + print(f" python dataset_manager.py --revert --train-file {config['active_train']}") + print() + print("✗ You cannot UPDATE again (already updated)") + elif last_action == "revert": + print("✓ You can UPDATE (last action was REVERT):") + print(f" python dataset_manager.py --update --train-file {config['active_train']}") + print() + print("✗ You cannot REVERT again (already reverted)") + else: + # No previous action - allow either + if state["current"] == "original": + print("✓ You can UPDATE to sanitized dataset:") + print(f" python dataset_manager.py --update --train-file {config['active_train']}") + else: + print("✓ You can REVERT to original dataset:") + print(f" python dataset_manager.py --revert --train-file {config['active_train']}") + + print() + print("To view change history:") + print(" python dataset_manager.py --log") + print() + + +def show_log(config: dict, lines: int | None = None): + """Show change log.""" + if not config["log_file"].exists(): + print("No changes logged yet.") + return + + print("\n" + "=" * 80) + print("DATASET CHANGE LOG") + print("=" * 80) + print() + + with open(config["log_file"]) as f: + log_lines = f.readlines() + + # Show last N lines if specified + if lines: + log_lines = log_lines[-lines:] + + if not log_lines: + print("No changes logged yet.") + return + + for line in log_lines: + print(line.rstrip()) + + print() + print(f"Total entries: {len(log_lines)}") + print() + + +# ============================================================================ +# CLI +# ============================================================================ + + +def main(): + parser = argparse.ArgumentParser( + description="Manage dataset switching between sanitized and original training data", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=""" +Examples: + # Switch to sanitized dataset (default paths) + python dataset_manager.py --update + + # Switch with custom paths + python dataset_manager.py --update \\ + --train-file data/training/train.jsonl \\ + --sanitized data/training/sanitized_train.jsonl + + # Revert to original dataset + python dataset_manager.py --revert --train-file data/training/train.jsonl + + # Check current status + python dataset_manager.py --status + + # View full change log + python dataset_manager.py --log + + # View last 10 changes + python dataset_manager.py --log --lines 10 + +Safety: + - After UPDATE, you can only REVERT + - After REVERT, you can only UPDATE + - This prevents accidental double-operations + """, + ) + + # Actions + parser.add_argument("--update", action="store_true", help="Switch to sanitized dataset") + parser.add_argument("--revert", action="store_true", help="Revert to original dataset") + parser.add_argument("--status", action="store_true", help="Show current dataset status") + parser.add_argument("--log", action="store_true", help="Show change log") + parser.add_argument( + "--lines", type=int, metavar="N", help="Show last N log entries (use with --log)" + ) + + # Path configuration + parser.add_argument( + "--train-file", + type=str, + default=None, + help="Path to training file to manage (default: data/training/train.jsonl)", + ) + parser.add_argument( + "--sanitized", + type=str, + default=None, + help="Path to sanitized data file (default: data/training/sanitized_train.jsonl)", + ) + + args = parser.parse_args() + + # Build configuration from args + config = get_config(args) + + # Execute requested action + if args.update: + update_to_sanitized(config) + elif args.revert: + revert_to_original(config) + elif args.log: + show_log(config, args.lines) + elif args.status: + show_status(config) + else: + # Default: show status + show_status(config) + + +if __name__ == "__main__": + main() diff --git a/scripts/mlflow_logger.py b/scripts/mlflow_logger.py new file mode 100644 index 0000000..10580be --- /dev/null +++ b/scripts/mlflow_logger.py @@ -0,0 +1,252 @@ +#!/usr/bin/env python3 +""" +Post-training MLflow logger for existing runs. + +Behavior: +- If --run-dir is provided → use it +- If --run-dir is omitted → auto-detect latest run in models/runs/mlx/ +- DagsHub/MLflow destination can be configured via CLI or env vars. + +Env vars: +- DAGSHUB_OWNER +- DAGSHUB_REPO +- MLFLOW_TRACKING_URI +""" + +from __future__ import annotations + +import argparse +import json +import os +import re +from pathlib import Path + +import dagshub +import matplotlib.pyplot as plt +import mlflow + + +# =============================== +# ARGUMENTS +# =============================== +def parse_args() -> argparse.Namespace: + p = argparse.ArgumentParser() + + p.add_argument( + "--run-dir", + type=Path, + default=None, + help="Path to a specific run directory. If omitted, latest run is used.", + ) + p.add_argument( + "--runs-root", + type=Path, + default=Path("models/runs/mlx"), + help="Root directory containing run folders (default: models/runs/mlx)", + ) + p.add_argument("--experiment-name", required=True, type=str) + + # Remote / tracking config + p.add_argument( + "--dagshub-owner", + type=str, + default=os.getenv("DAGSHUB_OWNER", "Gautam-Galada"), + help="DagsHub repo owner (env: DAGSHUB_OWNER). Default: Gautam-Galada", + ) + p.add_argument( + "--dagshub-repo", + type=str, + default=os.getenv("DAGSHUB_REPO", "compression-layer"), + help="DagsHub repo name (env: DAGSHUB_REPO). Default: compression-layer", + ) + p.add_argument( + "--mlflow-tracking-uri", + type=str, + default=os.getenv("MLFLOW_TRACKING_URI", ""), + help=( + "MLflow tracking URI (env: MLFLOW_TRACKING_URI). " + "If omitted, derived from DagsHub owner/repo." + ), + ) + p.add_argument( + "--no-dagshub-init", + action="store_true", + help="Skip dagshub.init() (useful if tracking is configured elsewhere).", + ) + + return p.parse_args() + + +# =============================== +# RUN DISCOVERY +# =============================== +def find_latest_run(runs_root: Path) -> Path: + if not runs_root.exists(): + raise FileNotFoundError(f"Runs root not found: {runs_root}") + + candidates = [p for p in runs_root.iterdir() if p.is_dir() and p.name != "latest"] + if not candidates: + raise RuntimeError(f"No runs found in {runs_root}") + + # Pick newest by mtime (most reliable in practice) + return max(candidates, key=lambda p: p.stat().st_mtime) + + +# =============================== +# CORE LOGIC +# =============================== +def _derive_dagshub_tracking_uri(owner: str, repo: str) -> str: + # Matches your existing hardcoded pattern + return f"https://dagshub.com/{owner}/{repo}.mlflow" + + +def log_run_dir_to_mlflow( + run_dir: Path, + experiment_name: str, + dagshub_owner: str, + dagshub_repo: str, + mlflow_tracking_uri: str, + no_dagshub_init: bool, +) -> None: + if not run_dir.exists(): + raise FileNotFoundError(f"Run dir not found: {run_dir}") + + # =============================== + # INIT DAGSHUB + MLFLOW + # =============================== + tracking_uri = mlflow_tracking_uri.strip() or _derive_dagshub_tracking_uri( + dagshub_owner, dagshub_repo + ) + + if not no_dagshub_init: + dagshub.init( + repo_owner=dagshub_owner, + repo_name=dagshub_repo, + mlflow=True, + ) + + mlflow.set_tracking_uri(tracking_uri) + mlflow.set_experiment(experiment_name) + + # =============================== + # LOAD FILES + # =============================== + run_json = run_dir / "run.json" + train_log = run_dir / "train.log" + + if not run_json.exists(): + raise FileNotFoundError(f"Missing run.json in {run_dir}") + if not train_log.exists(): + raise FileNotFoundError(f"Missing train.log in {run_dir}") + + with run_json.open("r", encoding="utf-8") as f: + run_cfg = json.load(f) + + log_text = train_log.read_text(encoding="utf-8", errors="replace") + + # =============================== + # REGEX PARSERS + # =============================== + train_pat = re.compile( + r"Iter (\d+): Train loss ([0-9.]+).*Tokens/sec ([0-9.]+).*Peak mem ([0-9.]+) GB" + ) + val_pat = re.compile(r"Iter (\d+): Val loss ([0-9.]+)") + + train_steps, train_loss, tokens_sec, peak_mem = [], [], [], [] + for m in train_pat.finditer(log_text): + train_steps.append(int(m.group(1))) + train_loss.append(float(m.group(2))) + tokens_sec.append(float(m.group(3))) + peak_mem.append(float(m.group(4))) + + val_steps, val_loss = [], [] + for m in val_pat.finditer(log_text): + val_steps.append(int(m.group(1))) + val_loss.append(float(m.group(2))) + + # =============================== + # MLFLOW RUN + # =============================== + run_name = run_cfg.get("started_at", run_dir.name) + + with mlflow.start_run(run_name=run_name): + # --------------------------- + # PARAMS + # --------------------------- + mlflow.log_params( + { + "model": run_cfg.get("model"), + "git_sha": run_cfg.get("git_sha"), + "data_dir": run_cfg.get("data_dir"), + "lora_rank": run_cfg.get("lora_rank"), + "lora_alpha": run_cfg.get("lora_alpha"), + "batch_size": run_cfg.get("batch_size"), + "learning_rate": run_cfg.get("learning_rate"), + "iters": run_cfg.get("iters"), + } + ) + + # --------------------------- + # METRICS + # --------------------------- + for i, step in enumerate(train_steps): + mlflow.log_metric("train_loss", train_loss[i], step=step) + mlflow.log_metric("tokens_per_sec", tokens_sec[i], step=step) + mlflow.log_metric("peak_mem_gb", peak_mem[i], step=step) + + for i, step in enumerate(val_steps): + mlflow.log_metric("val_loss", val_loss[i], step=step) + + # --------------------------- + # ARTIFACTS + # --------------------------- + mlflow.log_artifact(run_json) + mlflow.log_artifact(train_log) + + adapter_dir = run_dir / "adapter" + if adapter_dir.exists() and adapter_dir.is_dir(): + mlflow.log_artifacts(adapter_dir, artifact_path="weights") + + # --------------------------- + # PLOTS + # --------------------------- + if train_steps and val_steps: + plt.figure() + plt.plot(train_steps, train_loss, label="Train Loss") + plt.plot(val_steps, val_loss, label="Val Loss") + plt.xlabel("Iteration") + plt.ylabel("Loss") + plt.legend() + plt.title("Training vs Validation Loss") + + plot_path = run_dir / "loss_curve.png" + plt.savefig(plot_path) + plt.close() + + mlflow.log_artifact(plot_path) + + +# =============================== +# CLI ENTRYPOINT +# =============================== +def main() -> None: + args = parse_args() + + run_dir: Path | None = args.run_dir + if run_dir is None: + run_dir = find_latest_run(args.runs_root) + print(f"📌 Auto-selected latest run: {run_dir}") + + log_run_dir_to_mlflow( + run_dir=run_dir, + experiment_name=args.experiment_name, + dagshub_owner=args.dagshub_owner, + dagshub_repo=args.dagshub_repo, + mlflow_tracking_uri=args.mlflow_tracking_uri, + no_dagshub_init=args.no_dagshub_init, + ) + print("✅ Existing training run successfully logged to MLflow") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/src/utils/tokenizers.py b/src/utils/tokenizers.py index b463cf3..cb7d84b 100644 --- a/src/utils/tokenizers.py +++ b/src/utils/tokenizers.py @@ -33,7 +33,7 @@ def count_tokens(text: str, tokenizer_type: TokenizerType = TokenizerType.OPENAI Number of tokens """ enc = get_tokenizer(tokenizer_type) - return len(enc.encode(text)) + return len(enc.encode(text, disallowed_special=())) def count_tokens_multi(text: str) -> dict[str, int]: diff --git a/tests/test_analysis_data.py b/tests/test_analysis_data.py new file mode 100644 index 0000000..6678c27 --- /dev/null +++ b/tests/test_analysis_data.py @@ -0,0 +1,191 @@ +# tests/test_analysis_data.py +from __future__ import annotations + +import re + +import pytest + +# Adjust this import to match where you place the script/module. +# If the file is, e.g., scripts/analysis_data.py: +# import scripts.analysis_data as m +# +# Run with: PYTHONPATH=. python -m pytest -q +import scripts.analysis_data as m + + +def _sample(verbose: str, compressed: str) -> dict: + return { + "messages": [ + {"role": "user", "content": f"Compress: {verbose}"}, + {"role": "assistant", "content": compressed}, + ] + } + + +def test_extract_verbose_compressed_parses_message_structure(): + s = _sample("If A then B.", "A → B") + verbose, compressed = m.extract_verbose_compressed(s) + assert verbose == "If A then B." + assert compressed == "A → B" + + +def test_tokenize_compression_splits_symbols_and_text(): + tokens = m.tokenize_compression("A → B | C") + # Expect symbols as standalone tokens + assert "→" in tokens + assert "|" in tokens + # And content chunks + assert "A" in tokens + assert "B" in tokens + assert "C" in tokens + + +def test_extract_symbol_sequence_basic(): + # X for content, symbols preserved; adjacent content should collapse to single X + seq = m.extract_symbol_sequence("A → B | C") + # Leading "A " content is omitted, then "→", " B " -> X, "|", " C" -> X + assert seq == "→X|X" + + +def test_detect_scope_ambiguity_multiple_implications_without_grouping(): + issues = m.detect_scope_ambiguity("A → B | C → D") + assert any(i.startswith("SCOPE_AMBIGUITY") for i in issues) + + +def test_detect_scope_ambiguity_precedence_unclear_pipe_before_arrow(): + issues = m.detect_scope_ambiguity("A | B → C") + assert any(i.startswith("PRECEDENCE_UNCLEAR") for i in issues) + + +def test_detect_orphaned_symbols_start_end_and_consecutive(): + assert any("ORPHAN_START" in x for x in m.detect_orphaned_symbols("| A")) + assert any("ORPHAN_END" in x for x in m.detect_orphaned_symbols("A |")) + assert any("CONSECUTIVE" in x for x in m.detect_orphaned_symbols("A||B")) + + +def test_analyze_symbol_context_implication_detects_keywords_and_usage(): + verbose = "If the alarm triggers then evacuate. Therefore leave." + compressed = "alarm → evacuate" + ctx = m.analyze_symbol_context(verbose, compressed, "→") + assert ctx["context_present"] + assert ctx["used"] + assert any(k in ctx["context_keywords"] for k in ["if", "then", "therefore"]) + + +def test_check_negation_preservation_detects_lost_negation(): + verbose = "Do not open the door." + compressed = "open door" # negation lost + out = m.check_negation_preservation(verbose, compressed) + assert out["verbose_has_negation"] + assert out["negation_lost"] + assert not out["compressed_has_negation"] + + +def test_check_negation_preservation_accepts_negation_symbol(): + verbose = "Do not open the door." + compressed = "¬ open door" + out = m.check_negation_preservation(verbose, compressed) + assert out["verbose_has_negation"] + assert out["compressed_has_negation"] + assert not out["negation_lost"] + + +def test_extract_logical_pattern_normalizes_structure(): + # Parentheses content becomes (P), text becomes P, symbols preserved + pat = m.extract_logical_pattern("(foo bar) → baz | qux") + assert "(P)" in pat + assert "→" in pat + assert "|" in pat + # Should be only P and symbols + parentheses + assert re.fullmatch(r"[P→|@∵:() ]+", pat) is not None + + +def test_analyze_symbol_combinations_bigrams_only_from_SYMBOLS_not_LOGICAL_CONNECTIVES(): + # Note: analyze_symbol_combinations uses SYMBOLS only (not LOGICAL_CONNECTIVES) + bigrams = m.analyze_symbol_combinations("A → B | C : D") + # SYMBOLS include →, |, : so we should see bigrams among these (order preserved) + assert ("→", "|") in bigrams + assert ("|", ":") in bigrams + + +def test_analyze_dataset_aggregates_core_fields_and_flags_problematic_and_good(): + data = [ + # Good: high ratio, no orphan/scope issues + _sample( + "This is a long verbose description with many words because it explains details clearly.", + "desc: details", + ), + # Problematic: ratio < 1 (compressed longer than verbose) + _sample("short", "this is longer than short"), + # Scope ambiguity + _sample("If A then B or if C then D", "A → B | C → D"), + # Orphaned symbol + _sample("List items A and B", "| A | B"), + # Negation lost + _sample("Do not proceed", "proceed"), + ] + + results = m.analyze_dataset(data) + + assert results["total_samples"] == len(data) + assert isinstance(results["compression_ratios"], list) + assert results["symbol_usage"]["|"] >= 1 # used in at least one sample + assert "logical_patterns" in results and len(results["logical_patterns"]) > 0 + assert "symbol_combinations" in results + + # We created at least one problematic (ratio < 1), plus scope and orphan cases + assert len(results["problematic_samples"]) >= 3 + + # Negation analysis: one verbose with negation, and it is lost in compressed + neg = results["negation_analysis"] + assert neg["total_with_negation"] >= 1 + assert neg["negation_lost"] >= 1 + + # Good samples: first sample likely yields ratio > 3.0 depending on tokenization + # Make the assertion robust by checking at least one good sample exists OR ratio > 3 appears. + if results["good_samples"]: + assert all(x["ratio"] > 3.0 for x in results["good_samples"]) + + +def test_generate_report_contains_key_sections(): + # Minimal results skeleton for report generation + results = { + "total_samples": 2, + "symbol_usage": {"→": 1, "|": 1, "@": 0, "∵": 0, ":": 1}, + "symbol_context_analysis": { + s: { + "used_when_context_present": 0, + "not_used_when_context_present": 0, + "used_without_context": 0, + } + for s in m.SYMBOLS + }, + "scope_ambiguities": [], + "orphaned_symbols": [], + "logical_patterns": m.Counter({"P→P": 1}), + "symbol_combinations": m.Counter({("→", "|"): 2}), + "negation_analysis": { + "total_with_negation": 0, + "negation_preserved": 0, + "negation_lost": 0, + }, + "compression_ratios": [2.0, 3.5], + "problematic_samples": [], + "good_samples": [{"id": 1, "ratio": 3.5, "compressed": "x"}], + } + + report = m.generate_report(results) + assert "LOGICAL COMPRESSION ANALYSIS REPORT" in report + assert "DATASET OVERVIEW" in report + assert "COMPRESSION QUALITY" in report + assert "SYMBOL USAGE" in report + assert "SCOPE AMBIGUITIES" in report + assert "ORPHANED SYMBOLS" in report + assert "NEGATION PRESERVATION" in report + assert "RECOMMENDATIONS" in report + + +if __name__ == "__main__": + import pytest + + raise SystemExit(pytest.main([__file__, "-v"])) diff --git a/tests/test_mlflow_logger.py b/tests/test_mlflow_logger.py new file mode 100644 index 0000000..26e58da --- /dev/null +++ b/tests/test_mlflow_logger.py @@ -0,0 +1,473 @@ +# tests/test_mlflow_logger.py +""" +Comprehensive tests for mlflow_logger.py + +Coverage: +- Params/metrics/artifacts logging +- Adapter directory handling +- Log parsing (matching/non-matching) +- Latest run discovery +- CLI argument parsing +- Error handling +- DagsHub URI derivation +""" + +from __future__ import annotations + +import json +from contextlib import contextmanager +from pathlib import Path + +import pytest + + +class MlflowRecorder: + """Mock MLflow client that records all operations.""" + + def __init__(self): + self.tracking_uri = None + self.experiment = None + self.run_name = None + self.params = {} + self.metrics = [] # (key, value, step) + self.artifacts = [] # (path, artifact_path) + self.log_artifacts_calls = [] # (dir_path, artifact_path) + + def set_tracking_uri(self, uri: str): + self.tracking_uri = uri + + def set_experiment(self, name: str): + self.experiment = name + + @contextmanager + def start_run(self, run_name: str = None, **_kwargs): + self.run_name = run_name + yield + + def log_params(self, d: dict): + self.params.update(d) + + def log_metric(self, key: str, value: float, step: int | None = None): + self.metrics.append((key, value, step)) + + def log_artifact(self, path: Path, artifact_path: str | None = None): + self.artifacts.append((Path(path), artifact_path)) + + def log_artifacts(self, dir_path: Path, artifact_path: str | None = None): + self.log_artifacts_calls.append((Path(dir_path), artifact_path)) + + +def _write_run_dir( + base: Path, + name: str, + *, + with_adapter: bool = True, + with_matching_logs: bool = True, + with_run_json: bool = True, + with_train_log: bool = True, +) -> Path: + """Helper to create a run directory with configurable content.""" + run_dir = base / name + run_dir.mkdir(parents=True, exist_ok=True) + + if with_run_json: + (run_dir / "run.json").write_text( + json.dumps( + { + "started_at": name, + "model": "mistral", + "git_sha": "abc123", + "data_dir": "data/x", + "lora_rank": 8, + "lora_alpha": 16, + "batch_size": 4, + "learning_rate": 1e-4, + "iters": 100, + } + ), + encoding="utf-8", + ) + + if with_train_log: + if with_matching_logs: + # Must match regex patterns in mlflow_logger.py + (run_dir / "train.log").write_text( + "\n".join( + [ + "Iter 10: Train loss 1.23 | Tokens/sec 456.7 | Peak mem 12.3 GB", + "Iter 20: Train loss 1.10 | Tokens/sec 470.0 | Peak mem 12.4 GB", + "Iter 10: Val loss 1.50", + "Iter 20: Val loss 1.40", + ] + ) + + "\n", + encoding="utf-8", + ) + else: + (run_dir / "train.log").write_text("no matching lines\n", encoding="utf-8") + + if with_adapter: + adapter = run_dir / "adapter" + adapter.mkdir() + (adapter / "adapter.safetensors").write_bytes(b"fake") + (adapter / "config.json").write_text("{}", encoding="utf-8") + + return run_dir + + +@pytest.fixture +def mlflow_recorder(monkeypatch) -> MlflowRecorder: + """ + Patch mlflow_logger.py's `mlflow` and `dagshub.init` to avoid real tracking. + """ + rec = MlflowRecorder() + + import scripts.mlflow_logger as m + + # Patch mlflow and dagshub + monkeypatch.setattr(m, "mlflow", rec, raising=True) + monkeypatch.setattr(m.dagshub, "init", lambda **kwargs: None, raising=True) + + # Non-interactive matplotlib + monkeypatch.setenv("MPLBACKEND", "Agg") + + return rec + + +# ============================================================================ +# CORE FUNCTIONALITY TESTS +# ============================================================================ + + +def test_logs_params_metrics_and_artifacts(tmp_path: Path, mlflow_recorder: MlflowRecorder): + """Test that all params, metrics, and artifacts are logged correctly.""" + import scripts.mlflow_logger as m + + runs_root = tmp_path / "runs" / "mlx" + run_dir = _write_run_dir(runs_root, "2026-02-05_21-59-37", with_adapter=True) + + m.log_run_dir_to_mlflow( + run_dir=run_dir, + experiment_name="exp_test", + dagshub_owner="test-owner", + dagshub_repo="test-repo", + mlflow_tracking_uri="", + no_dagshub_init=False, + ) + + # Check experiment and tracking URI set + assert mlflow_recorder.experiment == "exp_test" + assert mlflow_recorder.tracking_uri is not None + + # Check params + assert mlflow_recorder.params["model"] == "mistral" + assert mlflow_recorder.params["lora_rank"] == 8 + assert mlflow_recorder.params["iters"] == 100 + assert mlflow_recorder.params["git_sha"] == "abc123" + + # Check metrics (2 train steps * 3 metrics + 2 val steps = 8) + assert len(mlflow_recorder.metrics) == 8 + assert ("train_loss", 1.23, 10) in mlflow_recorder.metrics + assert ("tokens_per_sec", 470.0, 20) in mlflow_recorder.metrics + assert ("val_loss", 1.40, 20) in mlflow_recorder.metrics + assert ("peak_mem_gb", 12.3, 10) in mlflow_recorder.metrics + + # Check artifacts + artifact_names = {p.name for (p, _) in mlflow_recorder.artifacts} + assert "run.json" in artifact_names + assert "train.log" in artifact_names + assert "loss_curve.png" in artifact_names + + # Check adapter logged + assert mlflow_recorder.log_artifacts_calls == [(run_dir / "adapter", "weights")] + + +def test_no_adapter_dir_does_not_log_weights(tmp_path: Path, mlflow_recorder: MlflowRecorder): + """Test that missing adapter directory doesn't cause errors.""" + import scripts.mlflow_logger as m + + runs_root = tmp_path / "runs" / "mlx" + run_dir = _write_run_dir(runs_root, "2026-02-05_21-59-37", with_adapter=False) + + m.log_run_dir_to_mlflow( + run_dir=run_dir, + experiment_name="exp_test", + dagshub_owner="test-owner", + dagshub_repo="test-repo", + mlflow_tracking_uri="", + no_dagshub_init=False, + ) + + # No adapter artifacts should be logged + assert mlflow_recorder.log_artifacts_calls == [] + + +def test_nonmatching_log_produces_no_loss_plot(tmp_path: Path, mlflow_recorder: MlflowRecorder): + """Test that non-matching logs don't generate loss plot.""" + import scripts.mlflow_logger as m + + runs_root = tmp_path / "runs" / "mlx" + run_dir = _write_run_dir( + runs_root, + "2026-02-05_21-59-37", + with_adapter=False, + with_matching_logs=False, + ) + + m.log_run_dir_to_mlflow( + run_dir=run_dir, + experiment_name="exp_test", + dagshub_owner="test-owner", + dagshub_repo="test-repo", + mlflow_tracking_uri="", + no_dagshub_init=False, + ) + + artifact_names = {p.name for (p, _) in mlflow_recorder.artifacts} + assert "run.json" in artifact_names + assert "train.log" in artifact_names + assert "loss_curve.png" not in artifact_names # No plot without metrics + + +# ============================================================================ +# RUN DISCOVERY TESTS +# ============================================================================ + + +def test_find_latest_run_ignores_latest_and_uses_mtime(tmp_path: Path): + """Test that find_latest_run() ignores 'latest' symlink and uses mtime.""" + import scripts.mlflow_logger as m + + runs_root = tmp_path / "runs" / "mlx" + runs_root.mkdir(parents=True, exist_ok=True) + + # Create two runs + older = _write_run_dir(runs_root, "2026-02-04_00-39-58", with_adapter=False) + newer = _write_run_dir(runs_root, "2026-02-06_11-52-46", with_adapter=False) + + # Create 'latest' directory that should be ignored + (runs_root / "latest").mkdir() + + # Set mtimes explicitly + import os + + older_ts = 1_000_000_000 + newer_ts = 1_000_000_100 + os.utime(older, (older_ts, older_ts)) + os.utime(newer, (newer_ts, newer_ts)) + + latest = m.find_latest_run(runs_root) + assert latest.name == newer.name + + +def test_find_latest_run_raises_if_no_runs(tmp_path: Path): + """Test that find_latest_run raises error when no runs found.""" + import scripts.mlflow_logger as m + + runs_root = tmp_path / "runs" / "mlx" + runs_root.mkdir(parents=True, exist_ok=True) + + # Only create 'latest' directory (should be ignored) + (runs_root / "latest").mkdir() + + with pytest.raises(RuntimeError, match="No runs found"): + m.find_latest_run(runs_root) + + +def test_find_latest_run_raises_if_root_missing(tmp_path: Path): + """Test that find_latest_run raises error when root doesn't exist.""" + import scripts.mlflow_logger as m + + runs_root = tmp_path / "nonexistent" / "runs" + + with pytest.raises(FileNotFoundError, match="Runs root not found"): + m.find_latest_run(runs_root) + + +# ============================================================================ +# ERROR HANDLING TESTS +# ============================================================================ + + +def test_missing_run_json_raises_error(tmp_path: Path, mlflow_recorder: MlflowRecorder): + """Test that missing run.json raises FileNotFoundError.""" + import scripts.mlflow_logger as m + + runs_root = tmp_path / "runs" / "mlx" + run_dir = _write_run_dir( + runs_root, + "2026-02-05_21-59-37", + with_run_json=False, # Don't create run.json + with_adapter=False, + ) + + with pytest.raises(FileNotFoundError, match="Missing run.json"): + m.log_run_dir_to_mlflow( + run_dir=run_dir, + experiment_name="exp_test", + dagshub_owner="test-owner", + dagshub_repo="test-repo", + mlflow_tracking_uri="", + no_dagshub_init=False, + ) + + +def test_missing_train_log_raises_error(tmp_path: Path, mlflow_recorder: MlflowRecorder): + """Test that missing train.log raises FileNotFoundError.""" + import scripts.mlflow_logger as m + + runs_root = tmp_path / "runs" / "mlx" + run_dir = _write_run_dir( + runs_root, + "2026-02-05_21-59-37", + with_train_log=False, # Don't create train.log + with_adapter=False, + ) + + with pytest.raises(FileNotFoundError, match="Missing train.log"): + m.log_run_dir_to_mlflow( + run_dir=run_dir, + experiment_name="exp_test", + dagshub_owner="test-owner", + dagshub_repo="test-repo", + mlflow_tracking_uri="", + no_dagshub_init=False, + ) + + +def test_nonexistent_run_dir_raises_error(tmp_path: Path, mlflow_recorder: MlflowRecorder): + """Test that nonexistent run directory raises FileNotFoundError.""" + import scripts.mlflow_logger as m + + run_dir = tmp_path / "nonexistent_run" + + with pytest.raises(FileNotFoundError, match="Run dir not found"): + m.log_run_dir_to_mlflow( + run_dir=run_dir, + experiment_name="exp_test", + dagshub_owner="test-owner", + dagshub_repo="test-repo", + mlflow_tracking_uri="", + no_dagshub_init=False, + ) + + +# ============================================================================ +# DAGSHUB URI DERIVATION TESTS +# ============================================================================ + + +def test_derive_dagshub_tracking_uri(): + """Test DagsHub tracking URI derivation.""" + import scripts.mlflow_logger as m + + uri = m._derive_dagshub_tracking_uri("my-owner", "my-repo") + assert uri == "https://dagshub.com/my-owner/my-repo.mlflow" + + +def test_custom_tracking_uri_used_when_provided(tmp_path: Path, mlflow_recorder: MlflowRecorder): + """Test that custom tracking URI is used when provided.""" + import scripts.mlflow_logger as m + + runs_root = tmp_path / "runs" / "mlx" + run_dir = _write_run_dir(runs_root, "2026-02-05_21-59-37", with_adapter=False) + + custom_uri = "https://custom.mlflow.server/tracking" + + m.log_run_dir_to_mlflow( + run_dir=run_dir, + experiment_name="exp_test", + dagshub_owner="test-owner", + dagshub_repo="test-repo", + mlflow_tracking_uri=custom_uri, + no_dagshub_init=False, + ) + + assert mlflow_recorder.tracking_uri == custom_uri + + +def test_derived_uri_used_when_not_provided(tmp_path: Path, mlflow_recorder: MlflowRecorder): + """Test that URI is derived from DagsHub owner/repo when not provided.""" + import scripts.mlflow_logger as m + + runs_root = tmp_path / "runs" / "mlx" + run_dir = _write_run_dir(runs_root, "2026-02-05_21-59-37", with_adapter=False) + + m.log_run_dir_to_mlflow( + run_dir=run_dir, + experiment_name="exp_test", + dagshub_owner="my-owner", + dagshub_repo="my-repo", + mlflow_tracking_uri="", # Empty string triggers derivation + no_dagshub_init=False, + ) + + assert mlflow_recorder.tracking_uri == "https://dagshub.com/my-owner/my-repo.mlflow" + + +# ============================================================================ +# CLI INTEGRATION TESTS +# ============================================================================ + + +def test_main_with_explicit_run_dir(tmp_path: Path, mlflow_recorder: MlflowRecorder, monkeypatch): + """Test main() with explicit --run-dir argument.""" + import scripts.mlflow_logger as m + + runs_root = tmp_path / "runs" / "mlx" + run_dir = _write_run_dir(runs_root, "2026-02-05_21-59-37", with_adapter=False) + + # Mock sys.argv + monkeypatch.setattr( + "sys.argv", + [ + "mlflow_logger.py", + "--run-dir", + str(run_dir), + "--experiment-name", + "test-exp", + ], + ) + + m.main() + + assert mlflow_recorder.experiment == "test-exp" + assert mlflow_recorder.params["model"] == "mistral" + + +def test_main_auto_detects_latest_run(tmp_path: Path, mlflow_recorder: MlflowRecorder, monkeypatch): + """Test main() auto-detects latest run when --run-dir omitted.""" + import scripts.mlflow_logger as m + + runs_root = tmp_path / "runs" / "mlx" + + # Create two runs + _write_run_dir(runs_root, "2026-02-04_older", with_adapter=False) + newer = _write_run_dir(runs_root, "2026-02-06_newer", with_adapter=False) + + # Force mtime + import os + + os.utime(runs_root / "2026-02-04_older", (1_000_000_000, 1_000_000_000)) + os.utime(newer, (1_000_000_100, 1_000_000_100)) + + # Mock sys.argv without --run-dir + monkeypatch.setattr( + "sys.argv", + [ + "mlflow_logger.py", + "--runs-root", + str(runs_root), + "--experiment-name", + "test-exp", + ], + ) + + m.main() + + # Should use newer run + assert mlflow_recorder.run_name == "2026-02-06_newer" + + +if __name__ == "__main__": + pytest.main([__file__, "-v"]) diff --git a/tests/test_sanitization_manager.py b/tests/test_sanitization_manager.py new file mode 100644 index 0000000..74c80e0 --- /dev/null +++ b/tests/test_sanitization_manager.py @@ -0,0 +1,503 @@ +""" +Unit Tests for Sanitization and Dataset Manager +Run with: python -m pytest tests/test_sanitization_manager.py -v +""" + +import json +import shutil +import tempfile +from pathlib import Path + +import pytest + +# ============================================================================ +# IMPORTS - Fixed to match actual function signatures +# ============================================================================ + +try: + from scripts.data_sanitization import ( + compute_compression_ratio_tokens, # ✓ Fixed: was compute_compression_ratio + extract_verbose_compressed, + is_code_sample, + rule_a_ratio_check, + rule_b_orphaned_symbols, + rule_c_negation_preservation, + rule_d_semantic_symbol_usage_nl, + sanitize_and_extract, # ✓ Added: for integration tests + ) + + HAS_SANITIZE = True +except ImportError: + HAS_SANITIZE = False + +try: + from scripts.dataset_manager import ( + count_samples, + # get_config, # ✓ Added: to create config objects + load_state, + # log_change, # ✓ Added: for log tests + revert_to_original, # ✓ Added: for integration tests + save_state, + update_to_sanitized, # ✓ Added: for integration tests + ) + + HAS_DATASET_MANAGER = True +except ImportError: + HAS_DATASET_MANAGER = False + + +# ============================================================================ +# FIXTURES +# ============================================================================ + + +@pytest.fixture +def temp_dir(): + """Create temp directory, cleanup after test.""" + tmp = tempfile.mkdtemp() + yield Path(tmp) + shutil.rmtree(tmp) + + +@pytest.fixture +def mock_config(temp_dir): + """Create a mock config for testing.""" + return { + "active_train": temp_dir / "train.jsonl", + "original_backup": temp_dir / "train.original.jsonl", + "sanitized_data": temp_dir / "sanitized_train.jsonl", + "state_file": temp_dir / ".dataset_state.json", + "log_file": temp_dir / ".dataset_changes.log", + } + + +# ============================================================================ +# TESTS: SANITIZATION - Helper Functions +# ============================================================================ + + +@pytest.mark.skipif(not HAS_SANITIZE, reason="data_sanitization not available") +class TestCodeDetection: + """Test code vs natural language detection.""" + + def test_detects_python_code(self): + assert is_code_sample("def hello():\n return 'hi'") + + def test_detects_natural_language(self): + assert not is_code_sample("The cat sat on the mat.") + + def test_detects_javascript(self): + # Multi-line with multiple code signals + js_code = """ + const x = () => { + return true; + } + function test() { + let y = 5; + } + """ + assert is_code_sample(js_code) + + +@pytest.mark.skipif(not HAS_SANITIZE, reason="data_sanitization not available") +class TestExtraction: + """Test extracting verbose and compressed text.""" + + def test_extracts_correctly(self): + sample = { + "messages": [ + {"role": "user", "content": "Compress: Hello world"}, + {"role": "assistant", "content": "hi world"}, + ] + } + verbose, compressed, error = extract_verbose_compressed( + sample, 0 + ) # ✓ Fixed: added sample_id + assert verbose == "Hello world" + assert compressed == "hi world" + assert error is None + + def test_handles_missing_messages(self): + sample = {"messages": []} + verbose, compressed, error = extract_verbose_compressed( + sample, 0 + ) # ✓ Fixed: added sample_id + assert verbose is None + assert compressed is None + assert error is not None + + +@pytest.mark.skipif(not HAS_SANITIZE, reason="data_sanitization not available") +class TestCompressionRatio: + """Test compression ratio calculation.""" + + def test_basic_ratio(self): + # Note: compute_compression_ratio_tokens uses actual tokenizer + # This test assumes ratio > 1.0 means expansion + ratio = compute_compression_ratio_tokens("one two three four", "1 2") + assert ratio < 1.0 # Good compression + + +@pytest.mark.skipif(not HAS_SANITIZE, reason="data_sanitization not available") +class TestRuleA: + """Test Rule A: compression ratio validation.""" + + def test_passes_good_ratio(self): + passed, _ = rule_a_ratio_check("one two three", "1 2") + assert passed + + def test_fails_bad_ratio(self): + passed, _ = rule_a_ratio_check("hi", "hello there friend") + assert not passed + + +@pytest.mark.skipif(not HAS_SANITIZE, reason="data_sanitization not available") +class TestRuleB: + """Test Rule B: orphaned symbols.""" + + def test_passes_clean_text(self): + passed, _ = rule_b_orphaned_symbols( + "Paris @ France", is_code=False + ) # ✓ Fixed: added is_code + assert passed + + def test_fails_symbol_at_start(self): + passed, _ = rule_b_orphaned_symbols("→ bad start", is_code=False) # ✓ Fixed: added is_code + assert not passed + + def test_allows_colon_at_end(self): + passed, _ = rule_b_orphaned_symbols("function:", is_code=False) # ✓ Fixed: added is_code + assert passed + + def test_allows_decorator_for_code(self): + passed, _ = rule_b_orphaned_symbols( + "@classmethod", is_code=True + ) # ✓ New: test code-aware behavior + assert passed + + +@pytest.mark.skipif(not HAS_SANITIZE, reason="data_sanitization not available") +class TestRuleC: + """Test Rule C: negation preservation.""" + + def test_passes_no_negation(self): + passed, _ = rule_c_negation_preservation("I like it", "like") + assert passed + + def test_passes_preserved_negation(self): + passed, _ = rule_c_negation_preservation("I do not like it", "not like") + assert passed + + def test_fails_lost_negation(self): + passed, _ = rule_c_negation_preservation("I never eat meat", "eat meat") + assert not passed + + +@pytest.mark.skipif(not HAS_SANITIZE, reason="data_sanitization not available") +class TestRuleD: + """Test Rule D: semantic symbol usage.""" + + def test_passes_location_with_at(self): + passed, _ = rule_d_semantic_symbol_usage_nl("Paris is located in France", "Paris @ France") + assert passed + + def test_fails_location_without_at(self): + passed, _ = rule_d_semantic_symbol_usage_nl("Tokyo is located in Japan", "Tokyo Japan") + assert not passed + + +# ============================================================================ +# TESTS: SANITIZATION - Integration (Main Flow) +# ============================================================================ + + +@pytest.mark.skipif(not HAS_SANITIZE, reason="data_sanitization not available") +class TestSanitizeDataset: + """Test main sanitization flow.""" + + def test_sanitize_dataset_splits_correctly(self, temp_dir): + """Test that sanitize_and_extract splits good/bad samples correctly.""" + + # Create input file with 2 good + 2 bad samples + input_file = temp_dir / "train.jsonl" + sanitized_file = temp_dir / "sanitized.jsonl" + unsanitized_file = temp_dir / "unsanitized.jsonl" + + good_sample_1 = { + "messages": [ + {"role": "user", "content": "Compress: one two three four"}, + {"role": "assistant", "content": "1 2"}, + ] + } + + good_sample_2 = { + "messages": [ + {"role": "user", "content": "Compress: hello world"}, + {"role": "assistant", "content": "hi"}, + ] + } + + # Bad sample: expansion (ratio > 1.0) + bad_sample_1 = { + "messages": [ + {"role": "user", "content": "Compress: hi"}, + {"role": "assistant", "content": "hello there my friend"}, + ] + } + + # Bad sample: orphaned symbol + bad_sample_2 = { + "messages": [ + {"role": "user", "content": "Compress: test"}, + {"role": "assistant", "content": "→ bad"}, + ] + } + + with open(input_file, "w", encoding="utf-8") as f: + for sample in [good_sample_1, good_sample_2, bad_sample_1, bad_sample_2]: + f.write(json.dumps(sample, ensure_ascii=False) + "\n") + + # Run sanitization + stats = sanitize_and_extract(input_file, sanitized_file, unsanitized_file) + + # Assert + assert stats["total_input"] == 4 + assert stats["passed_all"] == 2 + assert stats["failed_all"] == 2 + assert sanitized_file.exists() + assert unsanitized_file.exists() + + def test_unicode_symbols_preserved(self, temp_dir): + """Test that → ∵ @ symbols are NOT escaped in sanitized output.""" + + input_file = temp_dir / "train.jsonl" + sanitized_file = temp_dir / "sanitized.jsonl" + unsanitized_file = temp_dir / "unsanitized.jsonl" + + # Sample that PASSES all validation rules + # (avoid causation/location keywords to prevent Rule D failures) + sample = { + "messages": [ + {"role": "user", "content": "Compress: This implies that result"}, + {"role": "assistant", "content": "this → that"}, + ] + } + + with open(input_file, "w", encoding="utf-8") as f: + f.write(json.dumps(sample, ensure_ascii=False) + "\n") + + # Run sanitization + stats = sanitize_and_extract(input_file, sanitized_file, unsanitized_file) + + # Verify it passed validation + assert stats["passed_all"] == 1, f"Sample failed: {stats['failed_samples']}" + + # Read back from sanitized file + with open(sanitized_file, encoding="utf-8") as f: + result_text = f.read() + + # Assert NOT escaped + assert "→" in result_text, "Arrow symbol should be preserved, not escaped" + assert "\\u2192" not in result_text, "Arrow should not be escaped as \\u2192" + + +# ============================================================================ +# TESTS: DATASET MANAGER - File Operations +# ============================================================================ + + +@pytest.mark.skipif(not HAS_DATASET_MANAGER, reason="dataset_manager not available") +class TestFileOperations: + """Test file utilities.""" + + def test_count_samples(self, temp_dir): + test_file = temp_dir / "test.jsonl" + with open(test_file, "w", encoding="utf-8") as f: + f.write('{"test": 1}\n') + f.write('{"test": 2}\n') + f.write('{"test": 3}\n') + + assert count_samples(test_file) == 3 + + def test_count_nonexistent_file(self, temp_dir): + count = count_samples(temp_dir / "missing.jsonl") + assert count == 0 + + def test_count_empty_file(self, temp_dir): + test_file = temp_dir / "empty.jsonl" + test_file.touch() + assert count_samples(test_file) == 0 + + +# ============================================================================ +# TESTS: DATASET MANAGER - State Management +# ============================================================================ + + +@pytest.mark.skipif(not HAS_DATASET_MANAGER, reason="dataset_manager not available") +class TestState: + """Test state management.""" + + def test_load_default_state(self, mock_config): + state = load_state(mock_config) # ✓ Fixed: pass config + assert state["current"] == "original" + assert state["change_count"] == 0 + assert state["last_action"] is None + + def test_save_and_load(self, mock_config): + test_state = { + "current": "sanitized", + "last_action": "update", + "last_change": "2024-01-01T00:00:00", + "change_count": 1, + } + save_state(mock_config, test_state) # ✓ Fixed: pass config + loaded = load_state(mock_config) # ✓ Fixed: pass config + assert loaded == test_state + + +# ============================================================================ +# TESTS: DATASET MANAGER - Integration (Main Flows) +# ============================================================================ + + +@pytest.mark.skipif(not HAS_DATASET_MANAGER, reason="dataset_manager not available") +class TestUpdateToSanitized: + """Test update_to_sanitized flow.""" + + def test_update_creates_backup_first_time(self, mock_config): + """Test that first update creates backup.""" + + # Create original and sanitized files + with open(mock_config["active_train"], "w") as f: + f.write('{"original": 1}\n') + f.write('{"original": 2}\n') + + with open(mock_config["sanitized_data"], "w") as f: + f.write('{"sanitized": 1}\n') + + # Execute update + result = update_to_sanitized(mock_config) + + # Assert + assert result + assert mock_config["original_backup"].exists() # Backup created + + state = load_state(mock_config) + assert state["current"] == "sanitized" + assert state["last_action"] == "update" + + def test_update_blocks_consecutive_updates(self, mock_config): + """Test that you can't update twice in a row.""" + + # Setup files + with open(mock_config["active_train"], "w") as f: + f.write('{"original": 1}\n') + + with open(mock_config["sanitized_data"], "w") as f: + f.write('{"sanitized": 1}\n') + + # First update + update_to_sanitized(mock_config) + + # Second update (should be blocked) + result = update_to_sanitized(mock_config) + + # Assert + assert not result + + +@pytest.mark.skipif(not HAS_DATASET_MANAGER, reason="dataset_manager not available") +class TestRevertToOriginal: + """Test revert_to_original flow.""" + + def test_revert_restores_from_backup(self, mock_config): + """Test that revert copies backup to active.""" + + # Setup: Update first (creates backup) + with open(mock_config["active_train"], "w") as f: + f.write('{"original": 1}\n') + + with open(mock_config["sanitized_data"], "w") as f: + f.write('{"sanitized": 1}\n') + + update_to_sanitized(mock_config) + + # Execute: Revert + result = revert_to_original(mock_config) + + # Assert + assert result + + state = load_state(mock_config) + assert state["current"] == "original" + assert state["last_action"] == "revert" + + def test_revert_blocks_consecutive_reverts(self, mock_config): + """Test that you can't revert twice in a row.""" + + # Setup: Update then revert + with open(mock_config["active_train"], "w") as f: + f.write('{"original": 1}\n') + + with open(mock_config["sanitized_data"], "w") as f: + f.write('{"sanitized": 1}\n') + + update_to_sanitized(mock_config) + revert_to_original(mock_config) # First revert + + # Execute: Try again + result = revert_to_original(mock_config) # Second revert + + # Assert + assert not result + + +@pytest.mark.skipif(not HAS_DATASET_MANAGER, reason="dataset_manager not available") +class TestLogUpdates: + """Test log file updates.""" + + def test_operations_append_to_log(self, mock_config): + """Test that update/revert write to log file.""" + + # Setup files + with open(mock_config["active_train"], "w") as f: + f.write('{"test": 1}\n') + + with open(mock_config["sanitized_data"], "w") as f: + f.write('{"test": 1}\n') + + # Execute operations + update_to_sanitized(mock_config) + revert_to_original(mock_config) + + # Assert + assert mock_config["log_file"].exists() + log_lines = mock_config["log_file"].read_text().strip().split("\n") + assert len(log_lines) == 2 + assert "UPDATE" in log_lines[0] + assert "REVERT" in log_lines[1] + + +# ============================================================================ +# EDGE CASES +# ============================================================================ + + +@pytest.mark.skipif(not HAS_SANITIZE, reason="data_sanitization not available") +class TestEdgeCases: + """Test edge cases and safety.""" + + def test_empty_symbol_check(self): + passed, _ = rule_b_orphaned_symbols("", is_code=False) # ✓ Fixed: added is_code + assert not passed + + def test_unicode_handling(self): + passed, _ = rule_b_orphaned_symbols( + "test → result", is_code=False + ) # ✓ Fixed: added is_code + assert passed + + +if __name__ == "__main__": + pytest.main([__file__, "-v"]) diff --git a/tests/test_tokenizer.py b/tests/test_tokenizer.py new file mode 100644 index 0000000..eb0a4a4 --- /dev/null +++ b/tests/test_tokenizer.py @@ -0,0 +1,323 @@ +""" +Unit tests for tokenizer utilities with special token handling. + +Tests cover: +- Basic token counting +- Special token handling (<|endoftext|>, <|im_start|>, etc.) +- Compression ratio calculations +- Edge cases (empty strings, zero tokens, etc.) +- Regression test for tiktoken version changes +""" + +import sys +from pathlib import Path + +import pytest + +# Add src to path +sys.path.insert(0, str(Path(__file__).parent.parent)) + +from src.utils.tokenizers import compression_ratio, count_tokens + + +class TestTokenCounting: + """Test basic token counting functionality.""" + + def test_simple_text(self): + """Test counting tokens in simple text.""" + text = "Hello, world!" + count = count_tokens(text) + assert count > 0, "Should count tokens in simple text" + assert isinstance(count, int), "Token count should be integer" + + def test_empty_string(self): + """Test empty string returns 0 tokens.""" + assert count_tokens("") == 0 + + def test_whitespace_only(self): + """Test whitespace-only string.""" + count = count_tokens(" ") + assert count >= 0, "Whitespace should have non-negative token count" + + def test_longer_text(self): + """Test longer text has more tokens.""" + short = "Hi" + long = "This is a much longer piece of text with many more words." + + short_count = count_tokens(short) + long_count = count_tokens(long) + + assert long_count > short_count, "Longer text should have more tokens" + + +class TestSpecialTokens: + """Test handling of special tokens in text.""" + + def test_endoftext_token(self): + """ + REGRESSION TEST: Verify <|endoftext|> is handled as normal text. + + This is the token that caused the original error. We now encode it + as normal text rather than treating it as a special control token. + """ + text_with_special = "This is text with <|endoftext|> in it." + text_without_special = "This is text with PLACEHOLDER in it." + + # Should not raise ValueError + count_with = count_tokens(text_with_special) + count_without = count_tokens(text_without_special) + + assert count_with > 0, "Should count tokens with <|endoftext|>" + assert isinstance(count_with, int), "Token count should be integer" + + # The counts may differ, but both should work + assert count_with >= count_without - 5, "Token counts should be similar" + + def test_multiple_special_tokens(self): + """Test text with multiple special tokens.""" + text = "Start <|endoftext|> middle <|im_start|> end <|im_end|>" + + # Should not raise ValueError + count = count_tokens(text) + assert count > 0, "Should handle multiple special tokens" + + def test_only_special_token(self): + """Test text that is only a special token.""" + text = "<|endoftext|>" + + # Should not raise ValueError + count = count_tokens(text) + assert count > 0, "Should count special token as text" + + def test_special_token_variations(self): + """Test various special token formats.""" + special_tokens = [ + "<|endoftext|>", + "<|im_start|>", + "<|im_end|>", + "<|im_sep|>", + ] + + for token in special_tokens: + # Should not raise ValueError for any special token + count = count_tokens(token) + assert count > 0, f"Should handle {token}" + + +class TestCompressionRatio: + """Test compression ratio calculations.""" + + def test_perfect_compression(self): + """Test ratio when compressed is much shorter.""" + original = "This is a very long piece of text that should compress well." + compressed = "Short" + + ratio = compression_ratio(original, compressed) + assert ratio < 1.0, "Good compression should have ratio < 1.0" + + def test_no_compression(self): + """Test ratio when text is unchanged.""" + text = "Same text" + ratio = compression_ratio(text, text) + + assert ratio == 1.0, "Identical text should have ratio of 1.0" + + def test_expansion(self): + """Test ratio when compressed is longer (bad compression).""" + original = "Short" + compressed = "This is actually much longer than the original text." + + ratio = compression_ratio(original, compressed) + assert ratio > 1.0, "Expansion should have ratio > 1.0" + + def test_empty_original(self): + """Test ratio with empty original string.""" + ratio = compression_ratio("", "something") + assert ratio == 1.0, "Empty original should return 1.0" + + def test_both_empty(self): + """Test ratio when both strings are empty.""" + ratio = compression_ratio("", "") + assert ratio == 1.0, "Both empty should return 1.0" + + def test_ratio_with_special_tokens(self): + """ + REGRESSION TEST: Verify compression ratio works with special tokens. + + This ensures the special token handling doesn't break ratio calculations. + """ + original = "This text has <|endoftext|> special tokens in it." + compressed = "Text with <|endoftext|> tokens." + + # Should not raise ValueError + ratio = compression_ratio(original, compressed) + + assert 0 < ratio <= 1.0, "Compression should have ratio between 0 and 1" + assert isinstance(ratio, float), "Ratio should be float" + + +class TestTokenizerConsistency: + """Test consistency across different inputs and edge cases.""" + + def test_unicode_characters(self): + """Test counting tokens in text with unicode characters.""" + text = "Hello 世界 🌍 café" + count = count_tokens(text) + assert count > 0, "Should handle unicode characters" + + def test_code_text(self): + """Test counting tokens in code snippets.""" + code = """ + def hello(): + return "world" + """ + count = count_tokens(code) + assert count > 0, "Should count tokens in code" + + def test_newlines_and_whitespace(self): + """Test text with various whitespace.""" + text = "Line 1\nLine 2\n\nLine 3\t\tTabbed" + count = count_tokens(text) + assert count > 0, "Should handle newlines and tabs" + + def test_repeated_counting(self): + """Test that counting is consistent across calls.""" + text = "Consistency test" + count1 = count_tokens(text) + count2 = count_tokens(text) + count3 = count_tokens(text) + + assert count1 == count2 == count3, "Token counting should be consistent" + + +class TestTiktokenVersionRegression: + """ + Regression tests to catch tiktoken version changes. + + These tests will fail if tiktoken's behavior changes significantly, + alerting us to review and update our special token handling. + """ + + def test_known_token_counts(self): + """Test known strings have expected token counts (±1 for version tolerance).""" + test_cases = { + "Hello": (1, 2), # Expected range: 1-2 tokens + "Hello, world!": (3, 5), # Expected range: 3-5 tokens + "The quick brown fox": (4, 6), # Expected range: 4-6 tokens + } + + for text, (min_expected, max_expected) in test_cases.items(): + count = count_tokens(text) + assert min_expected <= count <= max_expected, ( + f"Token count for '{text}' outside expected range: {count} not in [{min_expected}, {max_expected}]" + ) + + def test_special_token_encoding_behavior(self): + """ + CRITICAL REGRESSION TEST: Verify special tokens are encoded as text. + + If this fails after a tiktoken update, it means: + 1. Our disallowed_special=() parameter may have changed behavior + 2. We need to review our special token handling strategy + """ + text_with_special = "Text <|endoftext|> here" + + # This should NOT raise ValueError + try: + count = count_tokens(text_with_special) + assert count > 0, "Should successfully count with special tokens" + except ValueError as e: + if "special token" in str(e).lower(): + pytest.fail( + "Special token handling broken! " + "disallowed_special=() may no longer work. " + "Review tokenizer implementation and tiktoken version." + ) + else: + raise + + def test_tokenizer_caching(self): + """Test that tokenizer caching works (via consistent token counts).""" + # Instead of testing internal caching mechanism, test that + # repeated calls give consistent results (which implies caching works) + text = "Test tokenizer caching" + + counts = [count_tokens(text) for _ in range(5)] + + # All counts should be identical (proves caching works) + assert len(set(counts)) == 1, "Token counts should be consistent across calls" + assert counts[0] > 0, "Should count tokens" + + +class TestDataSanitizationIntegration: + """Integration tests for data sanitization use cases.""" + + def test_compression_ratio_threshold(self): + """Test that ratio threshold logic works correctly.""" + # Good compression (should pass) + original = "This is a long verbose sentence with many unnecessary words." + compressed = "Long verbose sentence." + ratio = compression_ratio(original, compressed) + assert ratio <= 1.0, "Good compression should pass <= 1.0 threshold" + + # Bad compression / expansion (should fail) + original = "Short" + compressed = "This became very long and verbose." + ratio = compression_ratio(original, compressed) + assert ratio > 1.0, "Expansion should fail > 1.0 threshold" + + def test_real_world_training_sample(self): + """Test with realistic training data format.""" + verbose = """ + def validate(function: AnyCallableT) -> AnyCallableT: + _check_function_type(function) + validate_call_wrapper = _validate_call.ValidateCallWrapper( + cast(_generate_schema.ValidateCallSupportedTypes, function), + config, validate_return, parent_namespace + ) + return _validate_call.update_wrapper_attributes(function, validate_call_wrapper.__call__) + """ + + compressed = """fn:validate(function:AnyCallableT)->AnyCallableT = + _check_function_type(function) |> + _validate_call.ValidateCallWrapper(cast(...), config, validate_return, parent_namespace) |> + λwrapper: _validate_call.update_wrapper_attributes(function, wrapper.__call__)""" + + ratio = compression_ratio(verbose, compressed) + + # Should be valid compression + assert 0 < ratio < 1.0, f"Real training sample should compress well, got ratio: {ratio}" + + def test_sample_with_special_tokens_in_training_data(self): + """ + CRITICAL: Test that training data with special tokens works. + + This is the actual bug that was reported - training data contained + <|endoftext|> and caused ValueError during sanitization. + """ + verbose = "This is training data with <|endoftext|> token." + compressed = "Training data with <|endoftext|>" + + # Should not raise ValueError + ratio = compression_ratio(verbose, compressed) + + assert 0 < ratio <= 1.0, "Should handle special tokens in training data" + + +# Pytest fixtures +@pytest.fixture +def sample_texts(): + """Fixture providing various text samples for testing.""" + return { + "simple": "Hello, world!", + "empty": "", + "with_special": "Text <|endoftext|> here", + "code": "def foo(): return 42", + "unicode": "café 世界 🌍", + "long": " ".join(["word"] * 100), + } + + +# Run tests with: pytest test_tokenizers.py -v +if __name__ == "__main__": + pytest.main([__file__, "-v"]) diff --git a/visualization/corpus.ipynb b/visualization/corpus.ipynb new file mode 100644 index 0000000..1f20b92 --- /dev/null +++ b/visualization/corpus.ipynb @@ -0,0 +1,1213 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "7d2d49d2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Analyzing: Natural Language\n", + "Dataset: ../nl_v2.jsonl\n", + "================================================================================\n", + "\n", + "✓ Loaded 8256 samples\n", + " Sample keys: ['verbose', 'compressed', 'domain', 'language', 'metadata']\n", + "\n", + "Example sample:\n", + " Verbose (first 100 chars): Artificial intelligence (AI) is revolutionizing quality control in rocket manufacturing by enhancing...\n", + " Compressed (first 100 chars): AI revolutionizing rocket manufacturing QC: +precision | +automated inspections | +failure predictio...\n", + "\n", + "✓ Computed metrics for 8256 samples\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "================================================================================\n", + "NATURAL LANGUAGE COMPRESSION STATISTICS\n", + "================================================================================\n", + "\n", + "Dataset Size: 8256 samples\n", + "\n", + "COMPRESSION RATIO (compressed/verbose):\n", + " Mean: 1.399\n", + " Median: 0.650\n", + " Std Dev: 2.084\n", + " Min: 0.016\n", + " Max: 41.250\n", + " 25th %ile: 0.506\n", + " 75th %ile: 1.419\n", + "\n", + "TOKEN REDUCTION:\n", + " Mean reduction: -39.9%\n", + " Median reduction: 35.0%\n", + " Best reduction: 98.4%\n", + " Worst reduction: -4025.0%\n", + "\n", + "AVERAGE TOKEN COUNTS:\n", + " Verbose: 130 tokens\n", + " Compressed: 130 tokens\n", + " Saved: 0 tokens per sample\n", + "\n", + "TOTAL TOKEN SAVINGS:\n", + " Total verbose tokens: 1,076,104\n", + " Total compressed tokens: 1,072,110\n", + " Total tokens saved: 3,994\n", + " Overall reduction: 0.4%\n", + "\n", + "================================================================================\n", + "QUALITY CHECKS\n", + "================================================================================\n", + "\n", + "🚨 EXPANSION DETECTED: 2541 samples (30.8%)\n", + " These samples got LONGER after compression (BAD)\n", + " Worst expansion: 41.250 ratio\n", + " → ACTION: Investigate these samples manually\n", + "\n", + "⚠️ WEAK COMPRESSION: 2761 samples (33.4%)\n", + " Ratio > 0.9 means <10% token reduction\n", + " → ACTION: These samples may not be worth compressing\n", + "\n", + "COMPRESSION QUALITY BREAKDOWN:\n", + " Strong (>50% reduction): 1935 samples ( 23.4%)\n", + " Moderate (30-50% reduction): 2637 samples ( 31.9%)\n", + " Weak (<30% reduction): 1108 samples ( 13.4%)\n", + "\n", + "SAMPLE LENGTH DISTRIBUTION:\n", + " Verbose tokens:\n", + " Short (<100): 4113 samples\n", + " Medium (100-500): 4137 samples\n", + " Long (500-1000): 6 samples\n", + " Very long (>1000): 0 samples\n", + "\n", + "================================================================================\n", + "KEY INSIGHTS & RECOMMENDATIONS\n", + "================================================================================\n", + "\n", + "📊 COMPRESSION EFFECTIVENESS:\n", + " 🚨 WEAK: -39.9% average reduction\n", + " Compression needs significant improvement\n", + "\n", + "💰 TOKEN SAVINGS (Cost Impact):\n", + " Total tokens saved: 3,994\n", + " At $3/1M tokens (Claude Sonnet input):\n", + " Cost with verbose: $3.23\n", + " Cost with compressed: $3.22\n", + " 💵 Savings: $0.01\n", + "\n", + "🎯 REALISTIC TARGET:\n", + " Based on this dataset, expect:\n", + " • Average ratio: 1.40x\n", + " • Average reduction: -39.9%\n", + " • Tokens saved per sample: 0\n", + "\n", + "================================================================================\n", + "NEXT STEPS\n", + "================================================================================\n", + "1. ✅ NL analysis complete\n", + "2. ⏭️ Change DATASET_PATH to 'code_dataset.jsonl' and re-run\n", + "3. ⏭️ Compare NL vs Code compression effectiveness\n", + "4. ⏭️ Move to Analysis #2: Symbol Usage Patterns\n", + "================================================================================\n" + ] + } + ], + "source": [ + "# Analysis #1: Compression Ratio Distribution\n", + "# Single domain analysis (NL)\n", + "\n", + "import json\n", + "from pathlib import Path\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import tiktoken\n", + "\n", + "# Set style\n", + "sns.set_style(\"whitegrid\")\n", + "plt.rcParams[\"figure.figsize\"] = (12, 6)\n", + "\n", + "# ============================================================================\n", + "# CONFIGURATION - CHANGE THIS FOR EACH RUN\n", + "# ============================================================================\n", + "\n", + "# Choose which dataset to analyze\n", + "DATASET_PATH = \"../nl_v2.jsonl\" # OR \"data/raw/code_dataset.jsonl\"\n", + "DOMAIN_NAME = \"Natural Language\" # OR \"Code\"\n", + "DOMAIN_TYPE = \"nl\" # OR \"code\"\n", + "\n", + "print(f\"Analyzing: {DOMAIN_NAME}\")\n", + "print(f\"Dataset: {DATASET_PATH}\")\n", + "print(\"=\" * 80 + \"\\n\")\n", + "\n", + "# ============================================================================\n", + "# 1. LOAD DATA\n", + "# ============================================================================\n", + "\n", + "\n", + "def load_dataset(filepath: str) -> list[dict]:\n", + " \"\"\"Load dataset with verbose/compressed pairs\"\"\"\n", + " data = []\n", + " with open(filepath, encoding=\"utf-8\") as f:\n", + " for line in f:\n", + " if line.strip():\n", + " data.append(json.loads(line))\n", + " return data\n", + "\n", + "\n", + "data = load_dataset(DATASET_PATH)\n", + "\n", + "print(f\"✓ Loaded {len(data)} samples\")\n", + "print(f\" Sample keys: {list(data[0].keys())}\")\n", + "\n", + "# Show one example\n", + "print(\"\\nExample sample:\")\n", + "print(f\" Verbose (first 100 chars): {data[0]['verbose'][:100]}...\")\n", + "print(f\" Compressed (first 100 chars): {data[0]['compressed'][:100]}...\")\n", + "\n", + "# ============================================================================\n", + "# 2. CALCULATE COMPRESSION RATIOS\n", + "# ============================================================================\n", + "\n", + "\n", + "def count_tokens(text: str) -> int:\n", + " \"\"\"Count tokens using tiktoken (same as your tokenizer.py)\"\"\"\n", + " enc = tiktoken.get_encoding(\"cl100k_base\")\n", + " return len(enc.encode(text, disallowed_special=()))\n", + "\n", + "\n", + "def compute_metrics(sample: dict) -> dict:\n", + " \"\"\"Compute compression metrics for a sample\"\"\"\n", + " verbose = sample[\"verbose\"]\n", + " compressed = sample[\"compressed\"]\n", + "\n", + " verbose_tokens = count_tokens(verbose)\n", + " compressed_tokens = count_tokens(compressed)\n", + "\n", + " # Compression ratio (compressed/verbose)\n", + " # Ratio < 1.0 = compression (good)\n", + " # Ratio > 1.0 = expansion (bad)\n", + " ratio = compressed_tokens / verbose_tokens if verbose_tokens > 0 else 1.0\n", + "\n", + " # Token reduction percentage\n", + " reduction_pct = (1 - ratio) * 100\n", + "\n", + " # Token savings\n", + " tokens_saved = verbose_tokens - compressed_tokens\n", + "\n", + " return {\n", + " \"verbose_tokens\": verbose_tokens,\n", + " \"compressed_tokens\": compressed_tokens,\n", + " \"compression_ratio\": ratio,\n", + " \"reduction_pct\": reduction_pct,\n", + " \"tokens_saved\": tokens_saved,\n", + " \"verbose_chars\": len(verbose),\n", + " \"compressed_chars\": len(compressed),\n", + " }\n", + "\n", + "\n", + "# Compute metrics for all samples\n", + "metrics = [compute_metrics(sample) for sample in data]\n", + "df = pd.DataFrame(metrics)\n", + "\n", + "print(f\"\\n✓ Computed metrics for {len(df)} samples\\n\")\n", + "\n", + "# ============================================================================\n", + "# 3. VISUALIZATION: COMPRESSION RATIO DISTRIBUTION\n", + "# ============================================================================\n", + "\n", + "fig, axes = plt.subplots(1, 3, figsize=(16, 5))\n", + "\n", + "# Color scheme\n", + "color = \"#3498db\" if DOMAIN_TYPE == \"nl\" else \"#e74c3c\"\n", + "\n", + "# Plot 1: Histogram of compression ratios\n", + "axes[0].hist(df[\"compression_ratio\"], bins=30, alpha=0.7, color=color, edgecolor=\"black\")\n", + "axes[0].axvline(\n", + " x=df[\"compression_ratio\"].mean(),\n", + " color=\"darkgreen\",\n", + " linestyle=\"--\",\n", + " linewidth=2,\n", + " label=f\"Mean: {df['compression_ratio'].mean():.3f}\",\n", + ")\n", + "axes[0].axvline(\n", + " x=df[\"compression_ratio\"].median(),\n", + " color=\"orange\",\n", + " linestyle=\"--\",\n", + " linewidth=2,\n", + " label=f\"Median: {df['compression_ratio'].median():.3f}\",\n", + ")\n", + "axes[0].axvline(x=1.0, color=\"red\", linestyle=\":\", alpha=0.5, label=\"No compression (1.0)\")\n", + "axes[0].set_xlabel(\"Compression Ratio (compressed/verbose)\")\n", + "axes[0].set_ylabel(\"Frequency\")\n", + "axes[0].set_title(f\"{DOMAIN_NAME}: Compression Ratio Distribution\")\n", + "axes[0].legend()\n", + "axes[0].grid(True, alpha=0.3)\n", + "\n", + "# Plot 2: Box plot\n", + "bp = axes[1].boxplot(df[\"compression_ratio\"], vert=True, patch_artist=True, widths=0.5)\n", + "bp[\"boxes\"][0].set_facecolor(color)\n", + "bp[\"boxes\"][0].set_alpha(0.7)\n", + "axes[1].axhline(y=1.0, color=\"red\", linestyle=\":\", alpha=0.5, label=\"No compression\")\n", + "axes[1].set_ylabel(\"Compression Ratio\")\n", + "axes[1].set_title(f\"{DOMAIN_NAME}: Ratio Box Plot\")\n", + "axes[1].set_xticklabels([DOMAIN_NAME])\n", + "axes[1].grid(True, alpha=0.3)\n", + "\n", + "# Add outlier annotations\n", + "q1 = df[\"compression_ratio\"].quantile(0.25)\n", + "q3 = df[\"compression_ratio\"].quantile(0.75)\n", + "iqr = q3 - q1\n", + "outliers = df[\n", + " (df[\"compression_ratio\"] < q1 - 1.5 * iqr) | (df[\"compression_ratio\"] > q3 + 1.5 * iqr)\n", + "]\n", + "if len(outliers) > 0:\n", + " axes[1].text(\n", + " 1,\n", + " q3 + 1.5 * iqr + 0.1,\n", + " f\"{len(outliers)} outliers\",\n", + " ha=\"center\",\n", + " fontsize=9,\n", + " bbox=dict(boxstyle=\"round\", facecolor=\"yellow\", alpha=0.3),\n", + " )\n", + "\n", + "# Plot 3: Scatter plot (verbose vs compressed tokens)\n", + "axes[2].scatter(\n", + " df[\"verbose_tokens\"],\n", + " df[\"compressed_tokens\"],\n", + " alpha=0.5,\n", + " c=df[\"compression_ratio\"],\n", + " cmap=\"RdYlGn_r\", # Red = bad (high ratio), Green = good (low ratio)\n", + " s=50,\n", + " edgecolor=\"black\",\n", + " linewidth=0.5,\n", + ")\n", + "\n", + "# Add diagonal line (ratio = 1.0)\n", + "max_tokens = max(df[\"verbose_tokens\"].max(), df[\"compressed_tokens\"].max())\n", + "axes[2].plot([0, max_tokens], [0, max_tokens], \"r--\", alpha=0.5, label=\"No compression (1:1)\")\n", + "\n", + "# Add reference lines for common ratios\n", + "for ratio, label in [(0.5, \"50%\"), (0.3, \"70%\"), (0.7, \"30%\")]:\n", + " axes[2].plot([0, max_tokens], [0, max_tokens * ratio], linestyle=\":\", alpha=0.3, color=\"gray\")\n", + " axes[2].text(\n", + " max_tokens * 0.9, max_tokens * ratio * 0.9, f\"{label} reduction\", fontsize=8, alpha=0.5\n", + " )\n", + "\n", + "axes[2].set_xlabel(\"Verbose Tokens\")\n", + "axes[2].set_ylabel(\"Compressed Tokens\")\n", + "axes[2].set_title(f\"{DOMAIN_NAME}: Token Count Relationship\")\n", + "axes[2].legend()\n", + "axes[2].grid(True, alpha=0.3)\n", + "\n", + "# Add colorbar for ratio\n", + "cbar = plt.colorbar(axes[2].collections[0], ax=axes[2])\n", + "cbar.set_label(\"Compression Ratio\", rotation=270, labelpad=15)\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig(f\"analysis_01_{DOMAIN_TYPE}_compression_ratio.png\", dpi=300, bbox_inches=\"tight\")\n", + "plt.show()\n", + "\n", + "# ============================================================================\n", + "# 4. SUMMARY STATISTICS\n", + "# ============================================================================\n", + "\n", + "print(\"\\n\" + \"=\" * 80)\n", + "print(f\"{DOMAIN_NAME.upper()} COMPRESSION STATISTICS\")\n", + "print(\"=\" * 80)\n", + "\n", + "print(f\"\\nDataset Size: {len(df)} samples\")\n", + "\n", + "print(\"\\nCOMPRESSION RATIO (compressed/verbose):\")\n", + "print(f\" Mean: {df['compression_ratio'].mean():.3f}\")\n", + "print(f\" Median: {df['compression_ratio'].median():.3f}\")\n", + "print(f\" Std Dev: {df['compression_ratio'].std():.3f}\")\n", + "print(f\" Min: {df['compression_ratio'].min():.3f}\")\n", + "print(f\" Max: {df['compression_ratio'].max():.3f}\")\n", + "print(f\" 25th %ile: {df['compression_ratio'].quantile(0.25):.3f}\")\n", + "print(f\" 75th %ile: {df['compression_ratio'].quantile(0.75):.3f}\")\n", + "\n", + "print(\"\\nTOKEN REDUCTION:\")\n", + "print(f\" Mean reduction: {df['reduction_pct'].mean():.1f}%\")\n", + "print(f\" Median reduction: {df['reduction_pct'].median():.1f}%\")\n", + "print(f\" Best reduction: {df['reduction_pct'].max():.1f}%\")\n", + "print(f\" Worst reduction: {df['reduction_pct'].min():.1f}%\")\n", + "\n", + "print(\"\\nAVERAGE TOKEN COUNTS:\")\n", + "print(f\" Verbose: {df['verbose_tokens'].mean():.0f} tokens\")\n", + "print(f\" Compressed: {df['compressed_tokens'].mean():.0f} tokens\")\n", + "print(f\" Saved: {df['tokens_saved'].mean():.0f} tokens per sample\")\n", + "\n", + "print(\"\\nTOTAL TOKEN SAVINGS:\")\n", + "print(f\" Total verbose tokens: {df['verbose_tokens'].sum():,}\")\n", + "print(f\" Total compressed tokens: {df['compressed_tokens'].sum():,}\")\n", + "print(f\" Total tokens saved: {df['tokens_saved'].sum():,}\")\n", + "print(\n", + " f\" Overall reduction: {(1 - df['compressed_tokens'].sum() / df['verbose_tokens'].sum()) * 100:.1f}%\"\n", + ")\n", + "\n", + "# ============================================================================\n", + "# 5. QUALITY CHECKS & INSIGHTS\n", + "# ============================================================================\n", + "\n", + "print(\"\\n\" + \"=\" * 80)\n", + "print(\"QUALITY CHECKS\")\n", + "print(\"=\" * 80)\n", + "\n", + "# Check for expansion (ratio > 1.0) - RED FLAG\n", + "expansions = df[df[\"compression_ratio\"] > 1.0]\n", + "if len(expansions) > 0:\n", + " print(\n", + " f\"\\n🚨 EXPANSION DETECTED: {len(expansions)} samples ({len(expansions) / len(df) * 100:.1f}%)\"\n", + " )\n", + " print(\" These samples got LONGER after compression (BAD)\")\n", + " print(f\" Worst expansion: {expansions['compression_ratio'].max():.3f} ratio\")\n", + " print(\" → ACTION: Investigate these samples manually\")\n", + "else:\n", + " print(\"\\n✅ NO EXPANSION: All samples compressed successfully\")\n", + "\n", + "# Check for very weak compression (ratio > 0.9) - WARNING\n", + "weak = df[df[\"compression_ratio\"] > 0.9]\n", + "if len(weak) > 0:\n", + " print(f\"\\n⚠️ WEAK COMPRESSION: {len(weak)} samples ({len(weak) / len(df) * 100:.1f}%)\")\n", + " print(\" Ratio > 0.9 means <10% token reduction\")\n", + " print(\" → ACTION: These samples may not be worth compressing\")\n", + "\n", + "# Distribution of compression quality\n", + "strong = df[df[\"compression_ratio\"] < 0.5] # >50% reduction\n", + "moderate = df[(df[\"compression_ratio\"] >= 0.5) & (df[\"compression_ratio\"] < 0.7)] # 30-50%\n", + "weak = df[(df[\"compression_ratio\"] >= 0.7) & (df[\"compression_ratio\"] < 1.0)] # <30%\n", + "\n", + "print(\"\\nCOMPRESSION QUALITY BREAKDOWN:\")\n", + "print(\n", + " f\" Strong (>50% reduction): {len(strong):4d} samples ({len(strong) / len(df) * 100:5.1f}%)\"\n", + ")\n", + "print(\n", + " f\" Moderate (30-50% reduction): {len(moderate):4d} samples ({len(moderate) / len(df) * 100:5.1f}%)\"\n", + ")\n", + "print(f\" Weak (<30% reduction): {len(weak):4d} samples ({len(weak) / len(df) * 100:5.1f}%)\")\n", + "\n", + "# Sample length distribution\n", + "print(\"\\nSAMPLE LENGTH DISTRIBUTION:\")\n", + "print(\" Verbose tokens:\")\n", + "print(f\" Short (<100): {len(df[df['verbose_tokens'] < 100])} samples\")\n", + "print(\n", + " f\" Medium (100-500): {len(df[(df['verbose_tokens'] >= 100) & (df['verbose_tokens'] < 500)])} samples\"\n", + ")\n", + "print(\n", + " f\" Long (500-1000): {len(df[(df['verbose_tokens'] >= 500) & (df['verbose_tokens'] < 1000)])} samples\"\n", + ")\n", + "print(f\" Very long (>1000): {len(df[df['verbose_tokens'] >= 1000])} samples\")\n", + "\n", + "# ============================================================================\n", + "# 6. KEY INSIGHTS & RECOMMENDATIONS\n", + "# ============================================================================\n", + "\n", + "print(\"\\n\" + \"=\" * 80)\n", + "print(\"KEY INSIGHTS & RECOMMENDATIONS\")\n", + "print(\"=\" * 80)\n", + "\n", + "mean_ratio = df[\"compression_ratio\"].mean()\n", + "mean_reduction = df[\"reduction_pct\"].mean()\n", + "\n", + "print(\"\\n📊 COMPRESSION EFFECTIVENESS:\")\n", + "if mean_reduction > 60:\n", + " print(f\" ✅ EXCELLENT: {mean_reduction:.1f}% average reduction\")\n", + " print(\" Your compression is highly effective\")\n", + "elif mean_reduction > 40:\n", + " print(f\" ✅ GOOD: {mean_reduction:.1f}% average reduction\")\n", + " print(\" Solid compression performance\")\n", + "elif mean_reduction > 20:\n", + " print(f\" ⚠️ MODERATE: {mean_reduction:.1f}% average reduction\")\n", + " print(\" Room for improvement in compression strategy\")\n", + "else:\n", + " print(f\" 🚨 WEAK: {mean_reduction:.1f}% average reduction\")\n", + " print(\" Compression needs significant improvement\")\n", + "\n", + "print(\"\\n💰 TOKEN SAVINGS (Cost Impact):\")\n", + "tokens_saved = df[\"tokens_saved\"].sum()\n", + "print(f\" Total tokens saved: {tokens_saved:,}\")\n", + "print(\" At $3/1M tokens (Claude Sonnet input):\")\n", + "print(f\" Cost with verbose: ${df['verbose_tokens'].sum() / 1_000_000 * 3:.2f}\")\n", + "print(f\" Cost with compressed: ${df['compressed_tokens'].sum() / 1_000_000 * 3:.2f}\")\n", + "print(f\" 💵 Savings: ${tokens_saved / 1_000_000 * 3:.2f}\")\n", + "\n", + "print(\"\\n🎯 REALISTIC TARGET:\")\n", + "print(\" Based on this dataset, expect:\")\n", + "print(f\" • Average ratio: {mean_ratio:.2f}x\")\n", + "print(f\" • Average reduction: {mean_reduction:.1f}%\")\n", + "print(f\" • Tokens saved per sample: {df['tokens_saved'].mean():.0f}\")\n", + "\n", + "print(\"\\n\" + \"=\" * 80)\n", + "print(\"NEXT STEPS\")\n", + "print(\"=\" * 80)\n", + "if DOMAIN_TYPE == \"nl\":\n", + " print(\"1. ✅ NL analysis complete\")\n", + " print(\"2. ⏭️ Change DATASET_PATH to 'code_dataset.jsonl' and re-run\")\n", + " print(\"3. ⏭️ Compare NL vs Code compression effectiveness\")\n", + " print(\"4. ⏭️ Move to Analysis #2: Symbol Usage Patterns\")\n", + "else:\n", + " print(\"1. ✅ Code analysis complete\")\n", + " print(\"2. 📊 Compare with NL results\")\n", + " print(\"3. ⏭️ Move to Analysis #2: Symbol Usage Patterns\")\n", + "print(\"=\" * 80)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b0d54ac1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Analyzing: Natural Language\n", + "Dataset: ../nl_v2.jsonl\n", + "================================================================================\n", + "\n", + "Tracking symbols:\n", + " → - Arrow (implies/leads to)\n", + " | - Pipe (separator/or)\n", + " @ - At (location/decorator)\n", + " ∵ - Because (causation)\n", + " : - Colon (assignment/type)\n", + "\n", + "✓ Loaded 8256 samples\n", + "\n", + "✓ Analyzed symbol usage in 8256 samples\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/gautamgalada/compression-layer/.venv/lib/python3.14/site-packages/seaborn/utils.py:61: UserWarning: Glyph 8757 (\\N{BECAUSE}) missing from font(s) Arial.\n", + " fig.canvas.draw()\n", + "/var/folders/kz/qrlwnxhd4pg9q70k5m2_zw700000gp/T/ipykernel_48241/1961506372.py:237: UserWarning: Glyph 8757 (\\N{BECAUSE}) missing from font(s) Arial.\n", + " plt.savefig(f'analysis_02_{DOMAIN_TYPE}_symbol_usage.png', dpi=300, bbox_inches='tight')\n", + "/Users/gautamgalada/compression-layer/.venv/lib/python3.14/site-packages/IPython/core/pylabtools.py:170: UserWarning: Glyph 8757 (\\N{BECAUSE}) missing from font(s) Arial.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "================================================================================\n", + "NATURAL LANGUAGE SYMBOL USAGE STATISTICS\n", + "================================================================================\n", + "\n", + "Dataset Size: 8256 samples\n", + "\n", + "SYMBOL PRESENCE RATES:\n", + "Symbol Description Samples Rate \n", + "------------------------------------------------------------\n", + "→ Arrow 3223 39.0%\n", + "| Pipe 7532 91.2%\n", + "@ At 2048 24.8%\n", + "∵ Because 1052 12.7%\n", + ": Colon 7513 91.0%\n", + "\n", + "AVERAGE COUNTS (ALL SAMPLES):\n", + "Symbol Avg Count Total Uses \n", + "---------------------------------------------\n", + "→ 1.35 11150 \n", + "| 8.38 69168 \n", + "@ 0.44 3629 \n", + "∵ 0.17 1429 \n", + ": 5.97 49313 \n", + "\n", + "AVERAGE COUNTS (WHEN PRESENT):\n", + "Symbol Avg When Used \n", + "------------------------------\n", + "→ 3.46 \n", + "| 9.18 \n", + "@ 1.77 \n", + "∵ 1.36 \n", + ": 6.56 \n", + "\n", + "SYMBOL DIVERSITY:\n", + " Average unique symbols per sample: 2.59\n", + " Median unique symbols per sample: 2\n", + " Max unique symbols in one sample: 5\n", + " Samples using all 5 symbols: 261 (3.2%)\n", + " Samples using 0 symbols: 75 (0.9%)\n", + "\n", + "================================================================================\n", + "INSIGHTS & VALIDATION\n", + "================================================================================\n", + "\n", + "📋 EXPECTED PATTERNS FOR NATURAL LANGUAGE:\n", + " • @ symbol: Moderate usage (15-30%) for location contexts\n", + " • ∵ symbol: Moderate-High usage (20-40%) for causation\n", + " • → symbol: Moderate usage (20-40%) for implications\n", + " • | symbol: Low-Moderate usage for separators\n", + " • : symbol: High usage (60-90%) for definitions/assignments\n", + "\n", + "📊 ACTUAL RESULTS:\n", + " ✅ @ symbol usage normal (24.8%)\n", + " ⚠️ ∵ symbol underutilized (12.7%) - expected 20-40%\n", + " → ACTION: Review if causation contexts are being compressed\n", + " ✅ : symbol usage strong (91.0%)\n", + "\n", + "⚠️ SYMBOL COVERAGE ISSUE:\n", + " 75 samples (0.9%) use NO symbols\n", + " → ACTION: These samples may be poorly compressed\n", + " → Investigate: Are they very short? Failed compression?\n", + "\n", + "📊 HIGH SYMBOL USAGE:\n", + " Top 5% of samples use 55+ symbols\n", + " Max symbols in one sample: 220\n", + "\n", + "================================================================================\n", + "SYMBOL CO-OCCURRENCE INSIGHTS\n", + "================================================================================\n", + "\n", + "Most common symbol pairs (co-occur in same sample):\n", + " | + :: 83.6% of samples\n", + " → + |: 37.3% of samples\n", + " → + :: 37.2% of samples\n", + " | + @: 24.1% of samples\n", + " @ + :: 23.7% of samples\n", + "\n", + "================================================================================\n", + "NEXT STEPS\n", + "================================================================================\n", + "1. ✅ NL symbol analysis complete\n", + "2. ⏭️ Change to 'code_dataset.jsonl' and re-run\n", + "3. ⏭️ Compare NL vs Code symbol usage patterns\n", + "4. ⏭️ Move to Analysis #3: Token Length Distribution\n", + "================================================================================\n" + ] + } + ], + "source": [ + "# Analysis #2: Symbol Usage Patterns\n", + "# Analyze how compression symbols are used (NL)\n", + "\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "\n", + "# Set style\n", + "sns.set_style(\"whitegrid\")\n", + "plt.rcParams[\"figure.figsize\"] = (14, 10)\n", + "\n", + "# ============================================================================\n", + "# CONFIGURATION - CHANGE THIS FOR EACH RUN\n", + "# ============================================================================\n", + "\n", + "DATASET_PATH = \"../nl_v2.jsonl\" # OR \"data/raw/code_dataset.jsonl\"\n", + "DOMAIN_NAME = \"Natural Language\" # OR \"Code\"\n", + "DOMAIN_TYPE = \"nl\" # OR \"code\"\n", + "\n", + "print(f\"Analyzing: {DOMAIN_NAME}\")\n", + "print(f\"Dataset: {DATASET_PATH}\")\n", + "print(\"=\" * 80 + \"\\n\")\n", + "\n", + "# ============================================================================\n", + "# SYMBOL DEFINITIONS\n", + "# ============================================================================\n", + "\n", + "# Your compression symbols\n", + "SYMBOLS = {\n", + " \"→\": \"Arrow (implies/leads to)\",\n", + " \"|\": \"Pipe (separator/or)\",\n", + " \"@\": \"At (location/decorator)\",\n", + " \"∵\": \"Because (causation)\",\n", + " \":\": \"Colon (assignment/type)\",\n", + "}\n", + "\n", + "SYMBOL_CHARS = list(SYMBOLS.keys())\n", + "\n", + "print(\"Tracking symbols:\")\n", + "for sym, desc in SYMBOLS.items():\n", + " print(f\" {sym} - {desc}\")\n", + "print()\n", + "\n", + "# ============================================================================\n", + "# 1. LOAD DATA\n", + "# ============================================================================\n", + "\n", + "\n", + "def load_dataset(filepath: str) -> list[dict]:\n", + " \"\"\"Load dataset with verbose/compressed pairs\"\"\"\n", + " data = []\n", + " with open(filepath, encoding=\"utf-8\") as f:\n", + " for line in f:\n", + " if line.strip():\n", + " data.append(json.loads(line))\n", + " return data\n", + "\n", + "\n", + "data = load_dataset(DATASET_PATH)\n", + "print(f\"✓ Loaded {len(data)} samples\\n\")\n", + "\n", + "# ============================================================================\n", + "# 2. SYMBOL ANALYSIS FUNCTIONS\n", + "# ============================================================================\n", + "\n", + "\n", + "def count_symbols(text: str) -> dict:\n", + " \"\"\"Count occurrences of each symbol in text\"\"\"\n", + " counts = {sym: text.count(sym) for sym in SYMBOL_CHARS}\n", + " return counts\n", + "\n", + "\n", + "def analyze_sample(sample: dict) -> dict:\n", + " \"\"\"Analyze symbol usage in a single sample\"\"\"\n", + " compressed = sample[\"compressed\"]\n", + "\n", + " symbol_counts = count_symbols(compressed)\n", + "\n", + " return {\n", + " \"has_arrow\": symbol_counts[\"→\"] > 0,\n", + " \"has_pipe\": symbol_counts[\"|\"] > 0,\n", + " \"has_at\": symbol_counts[\"@\"] > 0,\n", + " \"has_because\": symbol_counts[\"∵\"] > 0,\n", + " \"has_colon\": symbol_counts[\":\"] > 0,\n", + " \"count_arrow\": symbol_counts[\"→\"],\n", + " \"count_pipe\": symbol_counts[\"|\"],\n", + " \"count_at\": symbol_counts[\"@\"],\n", + " \"count_because\": symbol_counts[\"∵\"],\n", + " \"count_colon\": symbol_counts[\":\"],\n", + " \"total_symbols\": sum(symbol_counts.values()),\n", + " \"unique_symbols\": sum(1 for v in symbol_counts.values() if v > 0),\n", + " \"compressed_length\": len(compressed),\n", + " }\n", + "\n", + "\n", + "# Analyze all samples\n", + "results = [analyze_sample(sample) for sample in data]\n", + "df = pd.DataFrame(results)\n", + "\n", + "print(f\"✓ Analyzed symbol usage in {len(df)} samples\\n\")\n", + "\n", + "# ============================================================================\n", + "# 3. VISUALIZATION: SYMBOL FREQUENCY\n", + "# ============================================================================\n", + "\n", + "fig = plt.figure(figsize=(16, 10))\n", + "gs = fig.add_gridspec(3, 2, hspace=0.3, wspace=0.3)\n", + "\n", + "# Calculate presence rates (% of samples containing each symbol)\n", + "presence_rates = {\n", + " \"→\": df[\"has_arrow\"].sum() / len(df) * 100,\n", + " \"|\": df[\"has_pipe\"].sum() / len(df) * 100,\n", + " \"@\": df[\"has_at\"].sum() / len(df) * 100,\n", + " \"∵\": df[\"has_because\"].sum() / len(df) * 100,\n", + " \":\": df[\"has_colon\"].sum() / len(df) * 100,\n", + "}\n", + "\n", + "# Average counts per sample (including samples without the symbol)\n", + "avg_counts = {\n", + " \"→\": df[\"count_arrow\"].mean(),\n", + " \"|\": df[\"count_pipe\"].mean(),\n", + " \"@\": df[\"count_at\"].mean(),\n", + " \"∵\": df[\"count_because\"].mean(),\n", + " \":\": df[\"count_colon\"].mean(),\n", + "}\n", + "\n", + "# Average counts per sample that HAS the symbol (conditional mean)\n", + "avg_counts_when_present = {\n", + " \"→\": df[df[\"has_arrow\"]][\"count_arrow\"].mean() if df[\"has_arrow\"].sum() > 0 else 0,\n", + " \"|\": df[df[\"has_pipe\"]][\"count_pipe\"].mean() if df[\"has_pipe\"].sum() > 0 else 0,\n", + " \"@\": df[df[\"has_at\"]][\"count_at\"].mean() if df[\"has_at\"].sum() > 0 else 0,\n", + " \"∵\": df[df[\"has_because\"]][\"count_because\"].mean() if df[\"has_because\"].sum() > 0 else 0,\n", + " \":\": df[df[\"has_colon\"]][\"count_colon\"].mean() if df[\"has_colon\"].sum() > 0 else 0,\n", + "}\n", + "\n", + "# Plot 1: Symbol Presence Rate (% of samples)\n", + "ax1 = fig.add_subplot(gs[0, 0])\n", + "symbols = list(presence_rates.keys())\n", + "rates = list(presence_rates.values())\n", + "colors = plt.cm.viridis(np.linspace(0, 1, len(symbols)))\n", + "\n", + "bars = ax1.barh(symbols, rates, color=colors, alpha=0.7, edgecolor=\"black\")\n", + "ax1.set_xlabel(\"% of Samples Containing Symbol\")\n", + "ax1.set_title(f\"{DOMAIN_NAME}: Symbol Presence Rate\")\n", + "ax1.set_xlim(0, 100)\n", + "\n", + "# Add value labels on bars\n", + "for i, (_bar, rate) in enumerate(zip(bars, rates, strict=True)):\n", + " ax1.text(rate + 2, i, f\"{rate:.1f}%\", va=\"center\", fontsize=10)\n", + "\n", + "\n", + "ax1.grid(True, alpha=0.3, axis=\"x\")\n", + "\n", + "# Plot 2: Average Count Per Sample\n", + "ax2 = fig.add_subplot(gs[0, 1])\n", + "counts = list(avg_counts.values())\n", + "\n", + "bars = ax2.barh(symbols, counts, color=colors, alpha=0.7, edgecolor=\"black\")\n", + "ax2.set_xlabel(\"Average Count Per Sample (All Samples)\")\n", + "ax2.set_title(f\"{DOMAIN_NAME}: Average Symbol Usage\")\n", + "\n", + "# Add value labels\n", + "for i, (_bar, count) in enumerate(zip(bars, counts, strict=True)):\n", + " ax2.text(count + 0.1, i, f\"{count:.2f}\", va=\"center\", fontsize=10)\n", + "\n", + "ax2.grid(True, alpha=0.3, axis=\"x\")\n", + "\n", + "# Plot 3: Average Count When Present\n", + "ax3 = fig.add_subplot(gs[1, 0])\n", + "counts_present = list(avg_counts_when_present.values())\n", + "\n", + "bars = ax3.barh(symbols, counts_present, color=colors, alpha=0.7, edgecolor=\"black\")\n", + "ax3.set_xlabel(\"Average Count (When Symbol Is Present)\")\n", + "ax3.set_title(f\"{DOMAIN_NAME}: Intensity When Used\")\n", + "\n", + "# Add value labels\n", + "for i, (_bar, count) in enumerate(zip(bars, counts_present, strict=True)):\n", + " ax3.text(count + 0.1, i, f\"{count:.2f}\", va=\"center\", fontsize=10)\n", + "\n", + "ax3.grid(True, alpha=0.3, axis=\"x\")\n", + "\n", + "# Plot 4: Distribution of unique symbols per sample\n", + "ax4 = fig.add_subplot(gs[1, 1])\n", + "unique_counts = df[\"unique_symbols\"].value_counts().sort_index()\n", + "\n", + "ax4.bar(unique_counts.index, unique_counts.values, color=\"steelblue\", alpha=0.7, edgecolor=\"black\")\n", + "ax4.set_xlabel(\"Number of Unique Symbols in Sample\")\n", + "ax4.set_ylabel(\"Number of Samples\")\n", + "ax4.set_title(f\"{DOMAIN_NAME}: Symbol Diversity Per Sample\")\n", + "ax4.grid(True, alpha=0.3, axis=\"y\")\n", + "\n", + "# Add mean line\n", + "mean_unique = df[\"unique_symbols\"].mean()\n", + "ax4.axvline(mean_unique, color=\"red\", linestyle=\"--\", linewidth=2, label=f\"Mean: {mean_unique:.1f}\")\n", + "ax4.legend()\n", + "\n", + "# Plot 5: Symbol co-occurrence heatmap\n", + "ax5 = fig.add_subplot(gs[2, :])\n", + "\n", + "# Build co-occurrence matrix\n", + "cooccurrence = np.zeros((5, 5))\n", + "symbol_names = [\"→\", \"|\", \"@\", \"∵\", \":\"]\n", + "\n", + "for _, row in df.iterrows():\n", + " present = [\n", + " row[\"has_arrow\"],\n", + " row[\"has_pipe\"],\n", + " row[\"has_at\"],\n", + " row[\"has_because\"],\n", + " row[\"has_colon\"],\n", + " ]\n", + "\n", + " for i in range(5):\n", + " for j in range(5):\n", + " if present[i] and present[j]:\n", + " cooccurrence[i, j] += 1\n", + "\n", + "# Normalize by total samples\n", + "cooccurrence = cooccurrence / len(df) * 100\n", + "\n", + "# Create heatmap\n", + "sns.heatmap(\n", + " cooccurrence,\n", + " annot=True,\n", + " fmt=\".1f\",\n", + " cmap=\"YlOrRd\",\n", + " xticklabels=symbol_names,\n", + " yticklabels=symbol_names,\n", + " cbar_kws={\"label\": \"% of Samples\"},\n", + " ax=ax5,\n", + " linewidths=0.5,\n", + " linecolor=\"gray\",\n", + ")\n", + "ax5.set_title(f\"{DOMAIN_NAME}: Symbol Co-occurrence Matrix\")\n", + "ax5.set_xlabel(\"Symbol\")\n", + "ax5.set_ylabel(\"Symbol\")\n", + "\n", + "plt.suptitle(f\"{DOMAIN_NAME}: Symbol Usage Analysis\", fontsize=16, fontweight=\"bold\", y=0.995)\n", + "plt.savefig(f\"analysis_02_{DOMAIN_TYPE}_symbol_usage.png\", dpi=300, bbox_inches=\"tight\")\n", + "plt.show()\n", + "\n", + "# ============================================================================\n", + "# 4. DETAILED STATISTICS\n", + "# ============================================================================\n", + "\n", + "print(\"\\n\" + \"=\" * 80)\n", + "print(f\"{DOMAIN_NAME.upper()} SYMBOL USAGE STATISTICS\")\n", + "print(\"=\" * 80)\n", + "\n", + "print(f\"\\nDataset Size: {len(df)} samples\")\n", + "\n", + "print(\"\\nSYMBOL PRESENCE RATES:\")\n", + "print(f\"{'Symbol':<10} {'Description':<25} {'Samples':<10} {'Rate':<10}\")\n", + "print(\"-\" * 60)\n", + "for sym in SYMBOL_CHARS:\n", + " desc = SYMBOLS[sym].split(\"(\")[0].strip()\n", + " count = df[f\"has_{['arrow', 'pipe', 'at', 'because', 'colon'][SYMBOL_CHARS.index(sym)]}\"].sum()\n", + " rate = count / len(df) * 100\n", + " print(f\"{sym:<10} {desc:<25} {count:<10} {rate:>6.1f}%\")\n", + "\n", + "print(\"\\nAVERAGE COUNTS (ALL SAMPLES):\")\n", + "print(f\"{'Symbol':<10} {'Avg Count':<15} {'Total Uses':<15}\")\n", + "print(\"-\" * 45)\n", + "for sym in SYMBOL_CHARS:\n", + " col = f\"count_{['arrow', 'pipe', 'at', 'because', 'colon'][SYMBOL_CHARS.index(sym)]}\"\n", + " avg = df[col].mean()\n", + " total = df[col].sum()\n", + " print(f\"{sym:<10} {avg:<15.2f} {total:<15.0f}\")\n", + "\n", + "print(\"\\nAVERAGE COUNTS (WHEN PRESENT):\")\n", + "print(f\"{'Symbol':<10} {'Avg When Used':<15}\")\n", + "print(\"-\" * 30)\n", + "for sym, avg in avg_counts_when_present.items():\n", + " print(f\"{sym:<10} {avg:<15.2f}\")\n", + "\n", + "print(\"\\nSYMBOL DIVERSITY:\")\n", + "print(f\" Average unique symbols per sample: {df['unique_symbols'].mean():.2f}\")\n", + "print(f\" Median unique symbols per sample: {df['unique_symbols'].median():.0f}\")\n", + "print(f\" Max unique symbols in one sample: {df['unique_symbols'].max():.0f}\")\n", + "print(\n", + " f\" Samples using all 5 symbols: {(df['unique_symbols'] == 5).sum()} ({(df['unique_symbols'] == 5).sum() / len(df) * 100:.1f}%)\"\n", + ")\n", + "print(\n", + " f\" Samples using 0 symbols: {(df['unique_symbols'] == 0).sum()} ({(df['unique_symbols'] == 0).sum() / len(df) * 100:.1f}%)\"\n", + ")\n", + "\n", + "# ============================================================================\n", + "# 5. INSIGHTS & VALIDATION\n", + "# ============================================================================\n", + "\n", + "print(\"\\n\" + \"=\" * 80)\n", + "print(\"INSIGHTS & VALIDATION\")\n", + "print(\"=\" * 80)\n", + "\n", + "# Check for expected patterns based on domain\n", + "if DOMAIN_TYPE == \"nl\":\n", + " print(\"\\n📋 EXPECTED PATTERNS FOR NATURAL LANGUAGE:\")\n", + " print(\" • @ symbol: Moderate usage (15-30%) for location contexts\")\n", + " print(\" • ∵ symbol: Moderate-High usage (20-40%) for causation\")\n", + " print(\" • → symbol: Moderate usage (20-40%) for implications\")\n", + " print(\" • | symbol: Low-Moderate usage for separators\")\n", + " print(\" • : symbol: High usage (60-90%) for definitions/assignments\")\n", + "\n", + " print(\"\\n📊 ACTUAL RESULTS:\")\n", + " at_rate = presence_rates[\"@\"]\n", + " because_rate = presence_rates[\"∵\"]\n", + " arrow_rate = presence_rates[\"→\"]\n", + " colon_rate = presence_rates[\":\"]\n", + "\n", + " # Validate expectations\n", + " if at_rate < 10:\n", + " print(f\" ⚠️ @ symbol underutilized ({at_rate:.1f}%) - expected 15-30%\")\n", + " print(\" → ACTION: Review if location contexts are being compressed\")\n", + " elif at_rate > 30:\n", + " print(f\" ⚠️ @ symbol overutilized ({at_rate:.1f}%) - may be used incorrectly\")\n", + " else:\n", + " print(f\" ✅ @ symbol usage normal ({at_rate:.1f}%)\")\n", + "\n", + " if because_rate < 15:\n", + " print(f\" ⚠️ ∵ symbol underutilized ({because_rate:.1f}%) - expected 20-40%\")\n", + " print(\" → ACTION: Review if causation contexts are being compressed\")\n", + " else:\n", + " print(f\" ✅ ∵ symbol usage appropriate ({because_rate:.1f}%)\")\n", + "\n", + " if colon_rate < 50:\n", + " print(f\" ⚠️ : symbol underutilized ({colon_rate:.1f}%) - expected 60-90%\")\n", + " else:\n", + " print(f\" ✅ : symbol usage strong ({colon_rate:.1f}%)\")\n", + "\n", + "else: # code\n", + " print(\"\\n📋 EXPECTED PATTERNS FOR CODE:\")\n", + " print(\" • @ symbol: High usage (70-95%) for decorators\")\n", + " print(\" • : symbol: Very high usage (85-100%) for type hints/assignments\")\n", + " print(\" • → symbol: Moderate-High usage (40-70%) for return indicators\")\n", + " print(\" • | symbol: High usage (60-90%) for union types, pipes\")\n", + " print(\" • ∵ symbol: Low usage (<10%) - rarely used in code\")\n", + "\n", + " print(\"\\n📊 ACTUAL RESULTS:\")\n", + " at_rate = presence_rates[\"@\"]\n", + " colon_rate = presence_rates[\":\"]\n", + " arrow_rate = presence_rates[\"→\"]\n", + " pipe_rate = presence_rates[\"|\"]\n", + " because_rate = presence_rates[\"∵\"]\n", + "\n", + " if at_rate < 60:\n", + " print(f\" ⚠️ @ symbol underutilized ({at_rate:.1f}%) - expected 70-95%\")\n", + " print(\" → ACTION: Decorators may not be preserved properly\")\n", + " else:\n", + " print(f\" ✅ @ symbol usage strong ({at_rate:.1f}%)\")\n", + "\n", + " if colon_rate < 80:\n", + " print(f\" ⚠️ : symbol underutilized ({colon_rate:.1f}%) - expected 85-100%\")\n", + " else:\n", + " print(f\" ✅ : symbol usage excellent ({colon_rate:.1f}%)\")\n", + "\n", + " if because_rate > 10:\n", + " print(f\" ⚠️ ∵ symbol unexpectedly high ({because_rate:.1f}%) - should be <10% in code\")\n", + " print(\" → ACTION: May be misused, check samples\")\n", + " else:\n", + " print(f\" ✅ ∵ symbol usage appropriate ({because_rate:.1f}%)\")\n", + "\n", + "# Symbol diversity check\n", + "zero_symbols = (df[\"unique_symbols\"] == 0).sum()\n", + "if zero_symbols > 0:\n", + " print(\"\\n⚠️ SYMBOL COVERAGE ISSUE:\")\n", + " print(f\" {zero_symbols} samples ({zero_symbols / len(df) * 100:.1f}%) use NO symbols\")\n", + " print(\" → ACTION: These samples may be poorly compressed\")\n", + " print(\" → Investigate: Are they very short? Failed compression?\")\n", + "\n", + "# High symbol usage\n", + "high_symbol_samples = df[df[\"total_symbols\"] > df[\"total_symbols\"].quantile(0.95)]\n", + "if len(high_symbol_samples) > 0:\n", + " print(\"\\n📊 HIGH SYMBOL USAGE:\")\n", + " print(f\" Top 5% of samples use {high_symbol_samples['total_symbols'].min():.0f}+ symbols\")\n", + " print(f\" Max symbols in one sample: {df['total_symbols'].max():.0f}\")\n", + "\n", + "# ============================================================================\n", + "# 6. CO-OCCURRENCE INSIGHTS\n", + "# ============================================================================\n", + "\n", + "print(\"\\n\" + \"=\" * 80)\n", + "print(\"SYMBOL CO-OCCURRENCE INSIGHTS\")\n", + "print(\"=\" * 80)\n", + "\n", + "print(\"\\nMost common symbol pairs (co-occur in same sample):\")\n", + "cooccur_pairs = []\n", + "for i in range(len(symbol_names)):\n", + " for j in range(i + 1, len(symbol_names)):\n", + " if cooccurrence[i, j] > 0:\n", + " cooccur_pairs.append((symbol_names[i], symbol_names[j], cooccurrence[i, j]))\n", + "\n", + "cooccur_pairs.sort(key=lambda x: x[2], reverse=True)\n", + "for sym1, sym2, rate in cooccur_pairs[:5]:\n", + " print(f\" {sym1} + {sym2}: {rate:.1f}% of samples\")\n", + "\n", + "# ============================================================================\n", + "# 7. NEXT STEPS\n", + "# ============================================================================\n", + "\n", + "print(\"\\n\" + \"=\" * 80)\n", + "print(\"NEXT STEPS\")\n", + "print(\"=\" * 80)\n", + "\n", + "if DOMAIN_TYPE == \"nl\":\n", + " print(\"1. ✅ NL symbol analysis complete\")\n", + " print(\"2. ⏭️ Change to 'code_dataset.jsonl' and re-run\")\n", + " print(\"3. ⏭️ Compare NL vs Code symbol usage patterns\")\n", + " print(\"4. ⏭️ Move to Analysis #3: Token Length Distribution\")\n", + "else:\n", + " print(\"1. ✅ Code symbol analysis complete\")\n", + " print(\"2. 📊 Compare with NL results:\")\n", + " print(\" • Is @ high in code (decorators) and low in NL?\")\n", + " print(\" • Is ∵ high in NL (causation) and low in code?\")\n", + " print(\" • Are patterns as expected?\")\n", + " print(\"3. ⏭️ Move to Analysis #3: Token Length Distribution\")\n", + "\n", + "print(\"=\" * 80)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "bd0fbff4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Split complete\n", + "Input file: ../nl_v2.jsonl\n", + "Output dir: ../splits\n", + "Total samples: 8256\n", + "GOOD (>= 20% reduction): 5326\n", + "BAD (< 20% or elongated): 2930\n", + "Skipped (invalid): 0\n" + ] + } + ], + "source": [ + "from typing import Any\n", + "\n", + "# ===== PARAMETERS =====\n", + "INPUT_PATH = Path(\"../nl_v2.jsonl\")\n", + "OUT_DIR = Path(\"../splits\")\n", + "\n", + "THRESHOLD = 0.20 # 20% reduction\n", + "MIN_LEN = 1 # skip empty samples\n", + "\n", + "\n", + "def safe_strip_len(x: Any) -> int:\n", + " if not isinstance(x, str):\n", + " return 0\n", + " return len(x.strip())\n", + "\n", + "\n", + "def split_by_compression(\n", + " input_path: Path,\n", + " out_dir: Path,\n", + " threshold: float,\n", + " min_len: int,\n", + ") -> None:\n", + " if not input_path.exists():\n", + " raise FileNotFoundError(f\"Input file not found: {input_path}\")\n", + "\n", + " out_dir.mkdir(parents=True, exist_ok=True)\n", + "\n", + " bad_path = out_dir / \"bad_or_undercompressed.jsonl\"\n", + " good_path = out_dir / \"good_20pct_or_more.jsonl\"\n", + " skipped_path = out_dir / \"skipped_invalid.jsonl\"\n", + "\n", + " n_total = n_bad = n_good = n_skipped = 0\n", + "\n", + " with (\n", + " input_path.open(\"r\", encoding=\"utf-8\") as f_in,\n", + " bad_path.open(\"w\", encoding=\"utf-8\") as f_bad,\n", + " good_path.open(\"w\", encoding=\"utf-8\") as f_good,\n", + " skipped_path.open(\"w\", encoding=\"utf-8\") as f_skip,\n", + " ):\n", + " for line_no, line in enumerate(f_in, start=1):\n", + " line = line.strip()\n", + " if not line:\n", + " continue\n", + "\n", + " n_total += 1\n", + "\n", + " try:\n", + " obj: dict[str, Any] = json.loads(line)\n", + " except json.JSONDecodeError:\n", + " f_skip.write(\n", + " json.dumps({\"line_no\": line_no, \"reason\": \"json_decode_error\"}, ensure_ascii=False)\n", + " + \"\\n\"\n", + " )\n", + " n_skipped += 1\n", + " continue\n", + "\n", + " verbose = obj.get(\"verbose\", \"\")\n", + " compressed = obj.get(\"compressed\", \"\")\n", + "\n", + " if not isinstance(verbose, str) or not isinstance(compressed, str):\n", + " f_skip.write(\n", + " json.dumps(\n", + " {\"line_no\": line_no, \"reason\": \"non_string_fields\", \"keys\": list(obj.keys())},\n", + " ensure_ascii=False,\n", + " )\n", + " + \"\\n\"\n", + " )\n", + " n_skipped += 1\n", + " continue\n", + "\n", + " v_len = safe_strip_len(verbose)\n", + " c_len = safe_strip_len(compressed)\n", + "\n", + " if v_len < min_len or c_len < min_len:\n", + " f_skip.write(\n", + " json.dumps(\n", + " {\"line_no\": line_no, \"reason\": \"too_short\", \"v_len\": v_len, \"c_len\": c_len},\n", + " ensure_ascii=False,\n", + " )\n", + " + \"\\n\"\n", + " )\n", + " n_skipped += 1\n", + " continue\n", + "\n", + " ratio = c_len / v_len\n", + " reduction = 1.0 - ratio\n", + "\n", + " obj[\"_metrics\"] = {\n", + " \"char_verbose\": v_len,\n", + " \"char_compressed\": c_len,\n", + " \"ratio_c_over_v\": round(ratio, 4),\n", + " \"reduction\": round(reduction, 4),\n", + " \"threshold\": threshold,\n", + " }\n", + "\n", + " if ratio > 1.0 or reduction < threshold:\n", + " f_bad.write(json.dumps(obj, ensure_ascii=False) + \"\\n\")\n", + " n_bad += 1\n", + " else:\n", + " f_good.write(json.dumps(obj, ensure_ascii=False) + \"\\n\")\n", + " n_good += 1\n", + "\n", + " print(\"✅ Split complete\")\n", + " print(f\"Input file: {input_path}\")\n", + " print(f\"Output dir: {out_dir}\")\n", + " print(f\"Total samples: {n_total}\")\n", + " print(f\"GOOD (>= {threshold:.0%} reduction): {n_good}\")\n", + " print(f\"BAD (< {threshold:.0%} or elongated): {n_bad}\")\n", + " print(f\"Skipped (invalid): {n_skipped}\")\n", + "\n", + "\n", + "# Run\n", + "split_by_compression(INPUT_PATH, OUT_DIR, THRESHOLD, MIN_LEN)\n" + ] + }, + { + "cell_type": "markdown", + "id": "f8deb7f1", + "metadata": {}, + "source": [ + "# Summary :\n", + "Verbose samples are sometimes expanded, and the distribution suggests that almost half of our samples are expanded or less than 20% compression. Hence, a very slight chance that the model has learnt to use symbols instead." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "965144b1", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}