"""Data processing module for MLPerf benchmark data.""" import glob import json import logging import os import re from collections import defaultdict import polars as pl from datasets import Dataset logger = logging.getLogger(__name__) FEATURES = { "Performance": { "metrics.result": "continuous", "metrics.result_per_accelerator": "continuous", "metrics.accuracy": "continuous", }, "Model": { "model.name": "categorical", "model.mlperf_name": "categorical", "model.architecture": "categorical", "model.number_of_parameters": "continuous", "model.weight_data_types": "categorical", }, "Accelerator": { "system.accelerator.vendor": "categorical", "system.accelerator.name": "categorical", "system.accelerator.count_per_node": "continuous", "system.accelerator.total_count": "continuous", "system.accelerator.memory_capacity": "continuous", "system.accelerator.memory_config": "text", "system.interconnect.accelerator": "categorical", }, "CPU": { "system.cpu.vendor": "categorical", "system.cpu.model": "categorical", "system.cpu.core_count": "continuous", "system.cpu.count_per_node": "continuous", "system.cpu.frequency": "continuous", "system.cpu.caches": "text", "system.cpu.vcpu_count": "continuous", }, "System": { "system.name": "text", "system.type": "categorical", "system.cooling": "categorical", "system.number_of_nodes": "continuous", "system.memory.capacity": "continuous", "system.memory.configuration": "text", "system.interconnect.accelerator_host": "categorical", }, "Software": { "software.framework": "categorical", "software.version": "categorical", "software.operating_system": "categorical", }, "Submission": { "submission.organization": "categorical", "submission.division": "categorical", "submission.scenario": "categorical", "submission.availability": "boolean", }, } MISSING_VALUES = defaultdict(set) def get_feature_type(feature_name: str) -> str: """Get the type of a feature from the FEATURES dictionary.""" for group in FEATURES.values(): if feature_name in group: return group[feature_name] return "categorical" def find_result_files(base_path: str = "semi-raw-mlperf-data") -> list[str]: """Find all cmx-result-summary.json files.""" return glob.glob( os.path.join(base_path, "**/cmx-result-summary.json"), recursive=True ) def load_raw_data(base_path: str = "semi-raw-mlperf-data") -> pl.DataFrame: """Load and merge data from MLPerf result files.""" result_files = find_result_files(base_path) logger.info(f"Found {len(result_files)} result files") all_records = [] for file_path in result_files: with open(file_path, "r") as f: all_records.extend(json.loads(f.read())) df = pl.DataFrame(all_records, infer_schema_length=None) logger.info(f"Loaded {len(df)} raw benchmark records") rename_map = { "Accuracy": "metrics.accuracy", "Availability": "submission.availability", "Organization": "submission.organization", "Division": "submission.division", "Scenario": "submission.scenario", "Result": "metrics.result", "Units": "metrics.units", "MlperfModel": "model.mlperf_name", "Model": "model.name", "weight_data_types": "model.weight_data_types", "framework": "software.framework", "operating_system": "software.operating_system", "SystemName": "system.name", "system.system_name": "system.name", "SystemType": "system.type", "system.system_type": "system.type", "accelerator_model_name": "system.accelerator.name", "system.accelerator_model_name": "system.accelerator.name", "number_of_nodes": "system.number_of_nodes", "accelerators_per_node": "system.accelerator.count_per_node", "system.accelerators_per_node": "system.accelerator.count_per_node", "host_processor_core_count": "system.cpu.core_count", "system.host_processor_core_count": "system.cpu.core_count", "host_processor_model_name": "system.cpu.model", "system.host_processor_model_name": "system.cpu.model", "host_processors_per_node": "system.cpu.count_per_node", "system.host_processors_per_node": "system.cpu.count_per_node", "cooling": "system.cooling", "system.cooling": "system.cooling", "system.accelerator_host_interconnect": "system.interconnect.accelerator_host", "system.accelerator_interconnect": "system.interconnect.accelerator", "system.accelerator_memory_capacity": "system.accelerator.memory_capacity", "system.accelerator_memory_configuration": "system.accelerator.memory_config", "system.host_memory_capacity": "system.memory.capacity", "system.host_memory_configuration": "system.memory.configuration", "system.host_processor_frequency": "system.cpu.frequency", "system.host_processor_caches": "system.cpu.caches", "system.host_processor_vcpu_count": "system.cpu.vcpu_count", } for old_name, new_name in rename_map.items(): if old_name in df.columns: if new_name in df.columns: df = df.drop(new_name) df = df.rename({old_name: new_name}) columns_to_select = list(set(rename_map.values())) return df.select([col for col in columns_to_select if col in df.columns]) def is_within_tolerance(value1: float, value2: float, tolerance: float = 0.1) -> bool: """Check if two values are within a specified tolerance.""" if value1 is None or value2 is None: return value1 == value2 if value1 == 0 or value2 == 0: return value1 == value2 percentage_diff = abs(value1 - value2) / max(abs(value1), abs(value2)) return percentage_diff <= tolerance def find_similar_configurations( df: pl.DataFrame, query_config: dict, continuous_tolerance: float = 0.1 ) -> pl.DataFrame: """Find configurations similar to the query_config.""" mask = pl.lit(True) for feature, value in query_config.items(): if value is None: continue if get_feature_type(feature) == "continuous": lower_bound = value * (1 - continuous_tolerance) upper_bound = value * (1 + continuous_tolerance) feature_mask = (pl.col(feature) >= lower_bound) & ( pl.col(feature) <= upper_bound ) else: feature_mask = pl.col(feature) == value mask = mask & feature_mask return df.filter(mask) def convert_memory_to_gb(value: str) -> float | None: """Convert memory string to GB.""" if value is None: return None if "+" in value: left, right = value.split("+", 1) return (convert_memory_to_gb(left) or 0.0) + ( convert_memory_to_gb(right) or 0.0 ) or None value = value.replace(" ", "").upper() numeric = "" for char in value: if char.isdigit() or char == ".": numeric += char else: break if not numeric: return None number = float(numeric) if "TB" in value or "TIB" in value: return number * 1024 elif "GB" in value or "GIB" in value: return number else: return None def convert_frequency_to_ghz(value: str) -> float | None: """Convert frequency string to GHz.""" if not value or value == "undefined": MISSING_VALUES["frequency_values"].add(str(value)) return None value = value.strip().upper() if value.isdigit(): return float(value) / 1000 matches = re.findall(r"([\d.]+)\s*(?:GHZ|MHZ)?", value, re.IGNORECASE) if not matches: MISSING_VALUES["frequency_values"].add(str(value)) return None frequencies = [float(match) for match in matches] max_freq = max(frequencies) if "MHZ" in value.upper(): max_freq /= 1000 return max_freq def extract_accelerator_vendor(name: str) -> str | None: """Extract vendor from accelerator name.""" if name is None: MISSING_VALUES["accelerator_names"].add(None) return None name_upper = name.upper() known_vendors = { "NVIDIA": ["NVIDIA", "TESLA", "A100", "H100", "T4"], "AMD": ["AMD"], "Intel": ["INTEL", "HABANA", "GAUDI"], "Google": ["TPU", "TRILLIUM", "LPU", "VPU"], "Qualcomm": ["QUALCOMM", "ADRENO", "HEXAGON", "CLOUD AI 100", "SNAPDRAGON"], "UntetherAI": ["UNTETHERAIR", "SPEEDAI"], "Huawei": ["DAVINCI"], "Moffett": ["MOFFETT"], } for vendor, keywords in known_vendors.items(): if any(keyword in name_upper for keyword in keywords): return vendor MISSING_VALUES["accelerator_vendors"].add(name) return None def extract_cpu_vendor(name: str) -> str | None: """Extract vendor from CPU model name.""" if name is None: MISSING_VALUES["cpu_names"].add(None) return None name_upper = name.upper() known_vendors = { "AMD": ["AMD", "EPYC"], "Intel": ["INTEL", "XEON"], "NVIDIA": ["NVIDIA", "GRACE"], "ARM": ["ARM", "CORTEX", "NEOVERSE", "ARMV8"], "AWS": ["AWS", "GRAVITON"], "Apple": ["APPLE", "M1", "M2", "M3"], "Qualcomm": ["QUALCOMM", "SNAPDRAGON"], } for vendor, keywords in known_vendors.items(): if any(keyword in name_upper for keyword in keywords): return vendor MISSING_VALUES["cpu_vendors"].add(name) return None def extract_framework_info(framework_str: str) -> list[tuple[str, str]]: """Extract framework name-version pairs.""" if not framework_str: return [] results = [] for item in framework_str.split(","): item = item.strip() name_match = re.search(r"(\w+)\s+", item) version_match = re.search(r"\s+([\d\.]+)", item) if name_match and version_match: name = name_match.group(1).lower() version = version_match.group(1) results.append((name, version.strip("."))) return results def clean_string_value(value: str) -> str | None: """Clean empty and N/A string values.""" if value.upper() in ["", "N/A", "DUMMY"]: return None return value def normalize_interconnect_type(value: str) -> str | None: """Normalize interconnect type strings.""" if value is None or value.upper() in ["TBD", "TODO", "TODD"]: MISSING_VALUES["interconnect_types"].add(str(value)) return None value_upper = value.upper() if "NVLINK" in value_upper: if any(gen in value_upper for gen in ["5TH", "5TH-GEN"]): return "NVLink-5" elif any(gen in value_upper for gen in ["4TH", "4TH-GEN"]): return "NVLink-4" else: return "NVLink" if "PCIE" in value_upper: if "GEN5" in value_upper.replace(" ", ""): return "PCIe-5" else: return "PCIe" if "INFINIBAND" in value_upper: return "InfiniBand" if "XGMI" in value_upper: return "XGMI" return value def clean_string_values( df: pl.DataFrame, string_columns: list[str] | None = None ) -> pl.DataFrame: """Clean string values in specified columns.""" if string_columns is None: string_columns = [col for col in df.columns if df[col].dtype == pl.String] return df.with_columns( [ pl.col(col).map_elements(clean_string_value, return_dtype=str).alias(col) for col in string_columns ] ) def filter_submissions(df: pl.DataFrame) -> pl.DataFrame: """Keep only valid token/s submissions.""" return df.filter( (pl.col("metrics.units") == "Tokens/s") & (pl.col("metrics.result").is_not_null()) & (pl.col("metrics.result") != 0) & (pl.col("metrics.result").is_finite()) & (pl.col("system.accelerator.total_count") > 0) ) def normalize_memory_values(df: pl.DataFrame) -> pl.DataFrame: """Convert memory values to GB.""" return df.with_columns( [ pl.col("system.accelerator.memory_capacity") .map_elements(convert_memory_to_gb, return_dtype=float) .alias("system.accelerator.memory_capacity"), pl.col("system.memory.capacity") .map_elements(convert_memory_to_gb, return_dtype=float) .alias("system.memory.capacity"), ] ) def add_vendor_columns(df: pl.DataFrame) -> pl.DataFrame: """Add vendor columns based on model names.""" return df.with_columns( [ pl.col("system.accelerator.name") .map_elements(extract_accelerator_vendor, return_dtype=str) .alias("system.accelerator.vendor"), pl.col("system.cpu.model") .map_elements(extract_cpu_vendor, return_dtype=str) .alias("system.cpu.vendor"), ] ) def normalize_interconnect_values(df: pl.DataFrame) -> pl.DataFrame: """Normalize interconnect values.""" return df.with_columns( [ pl.col("system.interconnect.accelerator") .map_elements(normalize_interconnect_type, return_dtype=str) .alias("system.interconnect.accelerator"), pl.col("system.interconnect.accelerator_host") .map_elements(normalize_interconnect_type, return_dtype=str) .alias("system.interconnect.accelerator_host"), ] ) def extract_framework_columns(df: pl.DataFrame) -> pl.DataFrame: """Extract framework versions into separate columns.""" df_with_id = df.with_columns(pl.Series(name="row_id", values=range(len(df)))) framework_info = [] for idx, framework_str in enumerate(df["software.framework"]): if framework_str is not None: for name, version in extract_framework_info(framework_str): framework_info.append({"row_id": idx, "name": name, "version": version}) if not framework_info: return df df_frameworks = pl.DataFrame(framework_info) df_pivoted = df_frameworks.pivot( values="version", index="row_id", on="name", aggregate_function="first", ) rename_dict = { col: f"software.framework.{col}" for col in df_pivoted.columns if col != "row_id" } df_pivoted = df_pivoted.rename(rename_dict) return df_with_id.join(df_pivoted, on="row_id", how="left").drop("row_id") def cast_columns(df: pl.DataFrame) -> pl.DataFrame: """Cast columns to proper types.""" column_types = { "system.cpu.core_count": pl.Int64, "system.accelerator.count_per_node": pl.Int64, "system.cpu.count_per_node": pl.Int64, "system.number_of_nodes": pl.Int64, } df = df.with_columns( pl.col("system.cpu.frequency") .map_elements(convert_frequency_to_ghz, return_dtype=float) .alias("system.cpu.frequency") ) return df.cast(column_types) def add_model_parameters(df: pl.DataFrame) -> pl.DataFrame: """Add number of parameters column based on model name.""" model_parameters = { "llama2-70b": 70, "llama-2-70b": 70, "llama3_1-405b": 405, "llama3_1-70b": 70, "gptj": 6, "mixtral-8x7b": 47, "DeepSeek-R1-Distill-Llama-8B": 8, "Llama-3.3-70B": 70, "deepseek-v3": 671, } def extract_parameters(model_name: str) -> float | None: if not model_name: return None for base_name, params in model_parameters.items(): if model_name.lower().startswith(base_name.lower()): return float(params) return None return df.with_columns( pl.col("model.name") .map_elements(extract_parameters, return_dtype=float) .alias("model.number_of_parameters") ) def add_model_architecture(df: pl.DataFrame) -> pl.DataFrame: """Add model architecture classification.""" model_architectures = { "llama": "LLM", "gpt": "LLM", "mixtral": "LLM", "deepseek": "LLM", "falcon": "LLM", "mistral": "LLM", } def classify_architecture(model_name: str) -> str | None: if not model_name: return None model_name_lower = model_name.lower() for pattern, arch in model_architectures.items(): if pattern in model_name_lower: return arch return "Other" return df.with_columns( pl.col("model.name") .map_elements(classify_architecture, return_dtype=str) .alias("model.architecture") ) def add_total_accelerator_count(df: pl.DataFrame) -> pl.DataFrame: """Compute total number of accelerators.""" return df.with_columns( ( pl.col("system.number_of_nodes") * pl.col("system.accelerator.count_per_node") ).alias("system.accelerator.total_count") ) def add_normalized_performance(df: pl.DataFrame) -> pl.DataFrame: """Add performance per accelerator metric.""" return df.with_columns( (pl.col("metrics.result") / pl.col("system.accelerator.total_count")).alias( "metrics.result_per_accelerator" ) ) def sort_columns_alphabetically(df: pl.DataFrame) -> pl.DataFrame: """Sort columns alphabetically.""" return df.select(sorted(df.columns)) def log_missing_values() -> None: """Log all collected missing values once.""" for category, values in MISSING_VALUES.items(): if values: logger.warning( f"Could not determine {len(values)} unique {category}: {sorted(str(v) for v in values)}" ) def upload_to_huggingface_hub( df: pl.DataFrame, dataset_name: str = "OpenMLPerf", private: bool = True ) -> None: """Upload the processed dataset to HuggingFace Hub.""" logger.info(f"Preparing dataset '{dataset_name}' for upload to HuggingFace Hub") data_dict = {col: df[col].to_list() for col in df.columns} dataset = Dataset.from_dict(data_dict) try: dataset.push_to_hub(dataset_name, private=private) logger.info( f"Successfully uploaded dataset to HuggingFace Hub as '{dataset_name}'" ) except Exception as e: logger.error(f"Failed to upload dataset to HuggingFace Hub: {e}") def process_data(base_path: str = "semi-raw-mlperf-data") -> pl.DataFrame: """Main data processing pipeline.""" logger.info("Starting data processing pipeline") MISSING_VALUES.clear() df = ( load_raw_data(base_path) .pipe(clean_string_values) .pipe(normalize_memory_values) .pipe(cast_columns) .pipe(add_vendor_columns) .pipe(normalize_interconnect_values) .pipe(extract_framework_columns) .pipe(add_model_parameters) .pipe(add_model_architecture) .pipe(add_total_accelerator_count) .pipe(add_normalized_performance) .pipe(sort_columns_alphabetically) .pipe(filter_submissions) ) log_missing_values() logger.info(f"Processed {len(df)} records") return df def export_data(df: pl.DataFrame) -> None: """Export processed data to JSON file.""" with open("data.json", "w") as f: json.dump(df.to_dicts(), f, indent=2) logger.info("Exported data to data.json") df.write_parquet("data.parquet") logger.info("Exported data to data.parquet") def main( base_path: str = "semi-raw-mlperf-data", upload_to_hub: bool = False, dataset_name: str = "OpenMLPerf", push_to_hub: bool = True, private: bool = True, ): """Run the complete data processing pipeline.""" logging.basicConfig(level=logging.INFO) df = process_data(base_path) export_data(df) if upload_to_hub: upload_to_huggingface_hub(df, dataset_name, private) return df if __name__ == "__main__": main(upload_to_hub=False, private=True)