first commit

README.md

@@ -1,3 +1,52 @@
 ---
 license: apache-2.0
 ---
+
+# Preparing OpenMLPerf dataset
+
+To process the semi-raw MLPerf data into the OpenMLPerf dataset, run the following command:
+
+```bash
+# Go to the OpenMLPerf-dataset directory
+cd OpenMLPerf-dataset
+
+# Create a virtual environment
+python -m venv .venv
+
+# Activate the virtual environment
+source .venv/bin/activate
+
+# Install the required packages
+pip install -r requirements.txt
+
+# Run the processing script
+python process.py
+```
+
+The processed dataset will be saved both as `data.json` and `data.parquet` in the `OpenMLPerf-dataset` directory.
+The `data.json` file is a JSON file containing the processed data, while the `data.parquet` file is a Parquet file containing the same data in a more efficient format for storage and processing.
+
+# Preprocessing raw MLPerf results using MLCommons CMX
+
+We preprocess official raw MLPerf data, such as [inference v5.0](https://github.com/mlcommons/inference_results_v5.0),
+into semi-raw format compatible with the `process.py` script, using the [MLCommons CM/CMX automation framework](https://arxiv.org/abs/2406.16791).
+This is done using through the ["import mlperf results"](https://github.com/mlcommons/ck/tree/master/cmx4mlops/repo/flex.task/import-mlperf-results) 
+automation action, which we plan to document in more detail soon.
+
+# License and Copyright
+
+This project is licensed under the [Apache License 2.0](LICENSE.md).
+
+© 2025 FlexAI
+
+Portions of the data were adapted from the following MLCommons repositories, 
+which are also licensed under the Apache 2.0 license:
+
+* [mlcommons@inference_results_v5.0](https://github.com/mlcommons/inference_results_v5.0)
+* [mlcommons@inference_results_v4.1](https://github.com/mlcommons/inference_results_v4.1)
+* [mlcommons@inference_results_v4.0](https://github.com/mlcommons/inference_results_v4.0)
+* [mlcommons@inference_results_v3.1](https://github.com/mlcommons/inference_results_v3.1)
+
+# Authors and maintaners
+
+[Daniel Altunay](https://www.linkedin.com/in/daltunay) and [Grigori Fursin](https://cKnowledge.org/gfursin) (FCS Labs)

data.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:845063b17e66072eb21e17c650f7745b49da8f12eb2e591827c823c041121588
+size 44318

processor.py

@@ -0,0 +1,624 @@
+"""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)

requirements.txt

@@ -0,0 +1,3 @@
+datasets
+polars
+cmind

semi-raw-mlperf-data.tar.bz2

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d5538ec2e98ba482949a4daf722937a1d7790dab57bb74fbe014c9f651b9e5d8
+size 1745626