import pandas as pd from pathlib import Path import pyarrow # ensures pyarrow is installed for Parquet support import numpy as np import sys from tqdm.auto import tqdm import logging from datetime import datetime # Add the api_models directory to the Python path to import existing modules sys.path.append(str(Path(__file__).parent / "runs" / "api_models")) from compute_bootstrap_ci import ( load_inference_results_by_grader, extract_config_from_log, ) from metrics import compute_metrics from omegaconf import OmegaConf # Set up logging log_dir = Path("logs") log_dir.mkdir(exist_ok=True) log_file = log_dir / f"create_parquet_files_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log" # Configure logging to write to both file and console logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s', handlers=[ logging.FileHandler(log_file), logging.StreamHandler(sys.stdout) ] ) logger = logging.getLogger(__name__) # Also create a separate error-only log file error_log_file = log_dir / f"create_parquet_files_errors_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log" error_handler = logging.FileHandler(error_log_file) error_handler.setLevel(logging.ERROR) error_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')) logger.addHandler(error_handler) def simplify_experiment_name(name): """Simplify experiment names according to the mapping rules.""" if pd.isna(name): return name # Convert to string to handle any non-string inputs name = str(name) # Define the mapping rules mappings = { # Sabia-3 mappings 'sabia-3-zero-shot': 'sabia3-studentPrompt', 'sabia-3-extractor-zero-shot': 'sabia3-extractor', 'sabia-3-grader-zero-shot': 'sabia3-graderPrompt', # Deepseek mappings 'deepseek-reasoner-zero-shot': 'deepseekR1-studentPrompt', 'deepseek-reasoner-extractor-zero-shot': 'deepseekR1-extractor', 'deepseek-reasoner-grader-zero-shot': 'deepseekR1-graderPrompt', # GPT-4o mappings 'gpt-4o-2024-11-20-zero-shot': 'gpt4o-studentPrompt', 'gpt-4o-2024-11-20-extractor-zero-shot': 'gpt4o-extractor', 'gpt-4o-2024-11-20-grader-zero-shot': 'gpt4o-graderPrompt', } # Apply direct mappings first for pattern, replacement in mappings.items(): if pattern in name: name = name.replace(pattern, replacement) # Handle jbcs2025 prefixed names if name.startswith('jbcs2025_'): # Remove the prefix name = name[9:] # First, remove any duplicated model-specific patterns that appear multiple times # These patterns indicate the experiment setup was duplicated in the name duplication_patterns = [ 'llama31_classification_lora', 'phi35_classification_lora', 'phi4_classification_lora', 'encoder_classification' 'tucano_classification_lora' ] for pattern in duplication_patterns: # Count occurrences count = name.count(f'-{pattern}-') if count > 1: # Replace all but keep track of components parts = name.split(f'-{pattern}-') # Keep the first part and the last part (which has the config) if len(parts) > 2: name = parts[0] + '-' + parts[-1] # Handle BERT variants if 'bert-base-portuguese-cased' in name: name = name.replace('bert-base-portuguese-cased', 'bertimbau-base') elif 'BERTugues-base-portuguese-cased' in name: name = name.replace('BERTugues-base-portuguese-cased', 'bertugues-base') elif 'bert-base-multilingual-cased' in name: name = name.replace('bert-base-multilingual-cased', 'mbert-base') elif 'bert-large-portuguese-cased' in name: name = name.replace('bert-large-portuguese-cased', 'bertimbau-large') elif 'albertina-1b5-portuguese-ptbr-encoder' in name: name = name.replace('albertina-1b5-portuguese-ptbr-encoder', 'albertina-1b5-ptbr') # Handle Llama variants elif 'Llama-3.1-8B-llama31_classification_lora' in name: name = name.replace('Llama-3.1-8B-llama31_classification_lora', 'llama3.1-8b-lora') elif 'Llama-3.1-8B' in name: name = name.replace('Llama-3.1-8B', 'llama3.1-8b-lora') # Handle Tucano variants elif 'Tucano-2b4-Instruct-tucano_classification_lora' in name: name = name.replace('Tucano-2b4-Instruct-tucano_classification_lora', 'tucano2b4-lora') elif 'Tucano-2b4-Instruct' in name: name = name.replace('Tucano-2b4-Instruct', 'tucano2b4-lora') # Handle Phi variants elif 'Phi-3.5-mini-instruct-phi35_classification_lora' in name: name = name.replace('Phi-3.5-mini-instruct-phi35_classification_lora', 'phi3.5-mini-lora') elif 'Phi-3.5-mini-instruct' in name: name = name.replace('Phi-3.5-mini-instruct', 'phi3.5-mini-lora') elif 'phi-4-phi4_classification_lora' in name: name = name.replace('phi-4-phi4_classification_lora', 'phi4-lora') elif 'phi-4' in name: name = name.replace('phi-4', 'phi4-lora') # Clean up any remaining classification patterns name = name.replace('-encoder_classification', '') name = name.replace('_classification_lora', '') name = name.replace('-llama31', '') name = name.replace('-phi35', '') name = name.replace('-phi4', '') name = name.replace('-tucano', '') # Extract components and reorder parts = name.split('-') # Look for competency (C1-C5), context type, and LoRA rank competency = None context = None lora_rank = None model_parts = [] i = 0 while i < len(parts): part = parts[i] if part in ['C1', 'C2', 'C3', 'C4', 'C5']: competency = part elif part == 'essay_only': context = 'essay-only' elif part == 'full_context': context = 'full-context' elif part in ['essay', 'full'] and i + 1 < len(parts): # Handle split context names if parts[i+1] == 'only': context = 'essay-only' i += 1 # Skip next part elif parts[i+1] == 'context': context = 'full-context' i += 1 # Skip next part elif part in ['r8', 'r16']: lora_rank = part elif part and part not in ['only', 'context']: # Skip empty parts and orphaned context words model_parts.append(part) i += 1 # Reconstruct the name in the desired order: model-competency-context-rank new_parts = model_parts if competency: new_parts.append(competency) if context: new_parts.append(context) if lora_rank: new_parts.append(lora_rank) name = '-'.join(new_parts) # Final cleanup: remove any double dashes while '--' in name: name = name.replace('--', '-') return name def find_and_group_csvs(): base = Path(".") groups = { "evaluation_results": sorted(base.rglob("evaluation_results.csv")), "bootstrap_confidence_intervals": sorted( base.rglob("bootstrap_confidence_intervals.csv") ), } for name, paths in groups.items(): logger.info(f"Found {len(paths)} files for '{name}'") if not paths: logger.warning(f"No files found for '{name}'") return groups def enhance_evaluation_results(eval_df, csv_paths): """Enhance evaluation results with additional metrics from JSONL files.""" enhanced_rows = [] failed_count = 0 # Create a mapping from row index to CSV path # Since we're processing multiple CSVs that get concatenated, # we need to track which rows came from which CSV file row_to_path = {} current_idx = 0 for path in csv_paths: df = pd.read_csv(path) for i in range(len(df)): row_to_path[current_idx + i] = path current_idx += len(df) for idx, row in tqdm( eval_df.iterrows(), desc="Processing evaluation rows", total=len(eval_df) ): # Get the CSV path for this row csv_path = row_to_path.get(idx) if csv_path is None: error_msg = f"CSV file not found for row {idx}" logger.error(error_msg) failed_count += 1 continue try: # Extract experiment ID from the path # The experiment ID is typically the parent directory name experiment_id = csv_path.parent.name # Simplify the experiment ID experiment_id = simplify_experiment_name(experiment_id) # Find corresponding JSONL file in the same directory jsonl_path = csv_path.parent / "inference_results.jsonl" if not jsonl_path.exists(): # Try with experiment name prefix jsonl_files = list(csv_path.parent.glob("*_inference_results.jsonl")) if jsonl_files: jsonl_path = jsonl_files[0] else: raise FileNotFoundError(f"JSONL file not found in {csv_path.parent}") # Find log file to extract configuration log_files = list(csv_path.parent.glob("*run_inference_experiment.log")) if not log_files: raise FileNotFoundError(f"Log file not found in {csv_path.parent}") log_path = log_files[0] # Load inference results and compute metrics # Extract configuration from log file config_dict = extract_config_from_log(log_path) # Convert to OmegaConf DictConfig for compatibility with compute_metrics cfg = OmegaConf.create(config_dict) # Load data using the existing function grader_a_data, grader_b_data = load_inference_results_by_grader(jsonl_path) # Extract predictions and labels for each grader all_predictions_a = np.array( [data["prediction"] for data in grader_a_data.values()] ) all_labels_a = np.array([data["label"] for data in grader_a_data.values()]) all_predictions_b = np.array( [data["prediction"] for data in grader_b_data.values()] ) all_labels_b = np.array([data["label"] for data in grader_b_data.values()]) # Compute concat(A,B) metrics for verification # Concatenate predictions and labels from both graders concat_predictions = np.concatenate([all_predictions_a, all_predictions_b]) concat_labels = np.concatenate([all_labels_a, all_labels_b]) metrics_concat = compute_metrics((concat_predictions, concat_labels), cfg) # Verify that computed concat metrics match original CSV values # Check a few key metrics with some tolerance for floating point comparison tolerance = 1e-6 for metric in ["accuracy", "QWK", "Macro_F1", "Weighted_F1"]: if metric in row and metric in metrics_concat: original_value = row[metric] computed_value = metrics_concat[metric] # You can make this a hard assertion if needed: assert abs(original_value - computed_value) <= tolerance, ( f"Metric {metric} mismatch: CSV={original_value}, Computed={computed_value}" ) # 1. Add original row with concat(A,B) metrics concat_row = row.copy() concat_row["experiment_id"] = experiment_id concat_row["metric_group"] = "concat(A,B)" enhanced_rows.append(concat_row) # 2. Compute metrics for A and B separately first metrics_a = compute_metrics((all_predictions_a, all_labels_a), cfg) metrics_b = compute_metrics((all_predictions_b, all_labels_b), cfg) # 3. Compute avg(A,B) as the average of metrics, not metrics of averaged predictions avg_row = row.copy() avg_row["experiment_id"] = experiment_id avg_row["metric_group"] = "avg(A,B)" # Average the metrics from A and B for metric in metrics_a: if metric in metrics_b and metric in avg_row: avg_value = (metrics_a[metric] + metrics_b[metric]) / 2 avg_row[metric] = avg_value enhanced_rows.append(avg_row) # 4. Add onlyA metrics only_a_row = row.copy() only_a_row["experiment_id"] = experiment_id only_a_row["metric_group"] = "onlyA" # Update metric columns with onlyA values for metric, value in metrics_a.items(): if metric in only_a_row: only_a_row[metric] = value enhanced_rows.append(only_a_row) # 5. Add onlyB metrics only_b_row = row.copy() only_b_row["experiment_id"] = experiment_id only_b_row["metric_group"] = "onlyB" # Update metric columns with onlyB values for metric, value in metrics_b.items(): if metric in only_b_row: only_b_row[metric] = value enhanced_rows.append(only_b_row) except Exception as e: failed_count += 1 error_msg = f"Failed to process {csv_path.parent if csv_path else 'unknown path'}: {str(e)}" logger.error(error_msg) # Log full traceback for debugging import traceback logger.error(f"Traceback:\n{traceback.format_exc()}") # Skip this row and continue with the next one continue logger.info(f"Successfully processed {len(enhanced_rows)//4} out of {len(eval_df)} rows") if failed_count > 0: logger.warning(f"Failed to process {failed_count} rows. Check error log: {error_log_file}") return pd.DataFrame(enhanced_rows) def combine(paths, out_path): if not paths: logger.info(f"No files to combine for {out_path}") return logger.info(f"Combining {len(paths)} files into {out_path}") dfs = [] for p in paths: df = pd.read_csv(p) # Add experiment_id column based on the parent directory name experiment_id = p.parent.name experiment_id = simplify_experiment_name(experiment_id) df["experiment_id"] = experiment_id dfs.append(df) # Basic schema validation cols = {tuple(df.columns) for df in dfs} if len(cols) > 1: error_msg = f"{out_path}: header mismatch across shards" logger.error(error_msg) raise ValueError(error_msg) combined = pd.concat(dfs, ignore_index=True) # Enhance evaluation results with additional metrics if "evaluation_results" in out_path: logger.info("Enhancing evaluation results with additional metrics...") combined = enhance_evaluation_results(combined, paths) combined.to_parquet(out_path, engine="pyarrow", index=False) logger.info(f"Successfully written {out_path} with {len(combined)} rows") if __name__ == "__main__": logger.info(f"Starting parquet file creation. Logs will be saved to: {log_file}") logger.info(f"Error-only log will be saved to: {error_log_file}") groups = find_and_group_csvs() combine(groups["evaluation_results"], "evaluation_results-00000-of-00001.parquet") combine( groups["bootstrap_confidence_intervals"], "bootstrap_confidence_intervals-00000-of-00001.parquet", ) logger.info("Parquet file creation completed")