diff --git a/README.md b/README.md new file mode 100644 index 0000000000000000000000000000000000000000..bac32d6f0de0f8eff48629d6fa685c7a3a1027a3 --- /dev/null +++ b/README.md @@ -0,0 +1,242 @@ +--- +pretty_name: EngiBench PowerElectronics v1 +license: cc-by-nc-sa-4.0 +task_categories: +- tabular-regression +tags: +- engineering-design +- multi-objective-optimization +- circuit-simulation +- ngspice +- engibench +size_categories: +- 10K /opt/power-electronics-v1-requirements.txt + + apt-get clean + rm -rf /var/lib/apt/lists/* + +%environment + export PATH=/opt/power-electronics-v1/bin:/opt/ngspice-44.2/bin:$PATH + export NGSPICE_PATH=/opt/ngspice-44.2/bin/ngspice + export PYTHONNOUSERSITE=1 + export MPLBACKEND=Agg + +%test + set -eu + test "$(uname -m)" = "x86_64" + /opt/ngspice-44.2/bin/ngspice --version 2>&1 | grep -q "ngspice-44.2" + /opt/power-electronics-v1/bin/python -c \ + "import datasets, gymnasium, matplotlib, networkx, numpy, pandas, pyarrow" diff --git a/provenance/python-requirements-freeze.txt b/provenance/python-requirements-freeze.txt new file mode 100644 index 0000000000000000000000000000000000000000..b94e05693fecd5ed0fb8b174360a576dc3672df8 --- /dev/null +++ b/provenance/python-requirements-freeze.txt @@ -0,0 +1,46 @@ +Farama-Notifications==0.0.6 +PyYAML==6.0.3 +aiohappyeyeballs==2.7.1 +aiohttp==3.14.3 +aiosignal==1.4.0 +anyio==4.15.1 +attrs==26.1.0 +certifi==2026.7.22 +charset-normalizer==3.5.1 +click==8.5.0 +cloudpickle==3.1.2 +contourpy==1.3.3 +cycler==0.12.1 +datasets==5.0.1 +dill==0.4.1 +filelock==4.0.1 +fonttools==4.65.0 +frozenlist==1.8.0 +fsspec==2026.6.0 +gymnasium==1.3.0 +h11==0.16.0 +hf-xet==1.6.0 +httpcore==1.0.9 +httpx==0.28.1 +huggingface_hub==1.32.0 +idna==3.20 +kiwisolver==1.5.1 +matplotlib==3.11.2 +multidict==6.9.0 +multiprocess==0.70.19 +networkx==3.6.1 +numpy==2.4.6 +packaging==26.3 +pandas==3.0.6 +pillow==12.3.0 +propcache==0.5.4 +pyarrow==25.0.1 +pyparsing==3.3.2 +python-dateutil==2.9.0.post0 +requests==2.34.2 +six==1.17.0 +tqdm==4.70.1 +typing_extensions==4.16.0 +urllib3==2.8.0 +xxhash==4.0.1 +yarl==1.25.1 diff --git a/provenance/scripts/audit_full_run.py b/provenance/scripts/audit_full_run.py new file mode 100644 index 0000000000000000000000000000000000000000..f0962b30f89c32271e6eb4436138f87b543fdff3 --- /dev/null +++ b/provenance/scripts/audit_full_run.py @@ -0,0 +1,154 @@ +#!/usr/bin/env python3 +from collections import Counter +import hashlib +import json +import math +from pathlib import Path +import statistics +import sys + +EXPECTED_COMMIT = "64e6107d44349e67e031cad36633c1af26817784" +EXPECTED_CONTAINER = "40816f203b7e1c68ae37f4d9353bd302486d77988b98733c021f1ff71f48ae02" +EXPECTED_NGSPICE = "11a4334ee90509f5edfdceef541711a34a1943d26a14cf0928ac8d5947b72374" +EXPECTED_SOURCE = "5c4adb2ec5cfc71794988b1297a7ff8ffe59daa5" +SPLIT_SIZES = {"train": 9676, "val": 2765, "test": 1383} +SHARD_COUNT = 8 + + +def sha256(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as handle: + for chunk in iter(lambda: handle.read(1024 * 1024), b""): + digest.update(chunk) + return digest.hexdigest() + + +def reject_constant(value: str) -> None: + raise ValueError(f"non-standard JSON constant: {value}") + + +def design_sha256(design: list[float]) -> str: + serialized = json.dumps(design, allow_nan=False, separators=(",", ":")) + return hashlib.sha256(serialized.encode()).hexdigest() + + +root = Path(sys.argv[1]) +summaries = [] +grand_total = 0 +for split, row_count in SPLIT_SIZES.items(): + seen_indices = [] + statuses: Counter[str] = Counter() + negative_means = 0 + invalid_rows = [] + v0_gain_differences = [] + v0_ripple_differences = [] + shard_hashes = {} + + for shard_index in range(SHARD_COUNT): + label = f"{shard_index:05d}-of-{SHARD_COUNT:05d}" + data_path = root / f"{split}-{label}.jsonl" + manifest_path = data_path.with_suffix(".jsonl.manifest.json") + assert data_path.is_file(), data_path + assert manifest_path.is_file(), manifest_path + assert data_path.read_bytes().endswith(b"\n") + manifest = json.loads(manifest_path.read_text(), parse_constant=reject_constant) + rows = [json.loads(line, parse_constant=reject_constant) for line in data_path.read_text().splitlines()] + expected_indices = list(range(shard_index, row_count, SHARD_COUNT)) + + assert [row["source_index"] for row in rows] == expected_indices + assert manifest["source"]["selected_indices"] == expected_indices + assert manifest["source"]["source_row_count"] == row_count + assert manifest["source"]["split"] == split + assert manifest["source"]["revision"] == EXPECTED_SOURCE + assert manifest["engibench"] == {"commit": EXPECTED_COMMIT, "dirty": False} + assert manifest["canonical_backend_validated"] is True + assert manifest["container"]["sha256"] == EXPECTED_CONTAINER + assert manifest["simulator"]["version"] == "44.2" + assert manifest["simulator"]["executable_sha256"] == EXPECTED_NGSPICE + assert manifest["simulator"]["platform_system"] == "Linux" + assert manifest["simulator"]["platform_machine"] == "x86_64" + assert manifest["output"]["sha256"] == sha256(data_path) + assert manifest["output"]["record_count"] == len(expected_indices) + shard_hashes[label] = manifest["output"]["sha256"] + + shard_statuses: Counter[str] = Counter() + for row in rows: + assert row["split"] == split + assert row["design_sha256"] == design_sha256(row["initial_design"]) + assert row["source_dataset_revision"] == EXPECTED_SOURCE + assert row["engibench_git_commit"] == EXPECTED_COMMIT + assert row["container_sha256"] == EXPECTED_CONTAINER + assert row["simulator_sha256"] == EXPECTED_NGSPICE + assert row["simulator_version"] == "44.2" + assert row["simulator_platform_system"] == "Linux" + assert row["simulator_platform_machine"] == "x86_64" + status = row["simulation_status"] + shard_statuses[status] += 1 + statuses[status] += 1 + seen_indices.append(row["source_index"]) + + if status != "ok": + invalid_rows.append( + { + "source_index": row["source_index"], + "status": status, + "error_type": row["error_type"], + } + ) + assert row["objectives_valid"] is False + continue + + assert row["simulation_valid"] is True + assert row["objectives_valid"] is True + values = [ + row["output_voltage_mean"], + row["output_voltage_peak_to_peak"], + row["dc_gain"], + row["dc_gain_error"], + row["relative_voltage_ripple"], + ] + assert all(value is not None and math.isfinite(value) for value in values) + mean, peak_to_peak, gain, gain_error, ripple = values + assert math.isclose(gain, mean / 1000.0, rel_tol=1e-12, abs_tol=1e-12) + assert math.isclose(gain_error, abs(gain - 0.25), rel_tol=1e-12, abs_tol=1e-12) + assert math.isclose(ripple, peak_to_peak / abs(mean), rel_tol=1e-12, abs_tol=1e-12) + assert peak_to_peak >= 0.0 + negative_means += mean < 0.0 + v0_gain_differences.append(abs(abs(gain) - row["v0_DcGain"])) + v0_ripple_differences.append(abs(ripple - row["v0_Voltage_Ripple"])) + + assert dict(shard_statuses) == manifest["output"]["status_counts"] + + assert len(seen_indices) == row_count + assert sorted(seen_indices) == list(range(row_count)) + assert len(set(seen_indices)) == row_count + grand_total += row_count + summaries.append( + { + "split": split, + "record_count": row_count, + "statuses": dict(statuses), + "negative_signed_measurements": negative_means, + "invalid_rows": invalid_rows, + "v0_abs_gain_difference": { + "median": statistics.median(v0_gain_differences), + "mean": statistics.mean(v0_gain_differences), + "max": max(v0_gain_differences), + }, + "v0_relative_ripple_difference": { + "median": statistics.median(v0_ripple_differences), + "mean": statistics.mean(v0_ripple_differences), + "max": max(v0_ripple_differences), + }, + "shard_hashes": shard_hashes, + } + ) + +assert grand_total == sum(SPLIT_SIZES.values()) == 13_824 +report = {"audit": "passed", "record_count": grand_total, "summaries": summaries} +serialized_report = json.dumps(report, indent=2, sort_keys=True) + "\n" +if len(sys.argv) == 3: + output_path = Path(sys.argv[2]) + with output_path.open("x", encoding="utf-8") as output_file: + output_file.write(serialized_report) +print(serialized_report, end="") diff --git a/provenance/scripts/build_hf_dataset.py b/provenance/scripts/build_hf_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..5f222b6d3fe673fbc19f7c54f70c9ad5c995a207 --- /dev/null +++ b/provenance/scripts/build_hf_dataset.py @@ -0,0 +1,184 @@ +#!/usr/bin/env python3 +"""Convert audited PowerElectronics v1 JSONL shards to validated HF Parquet shards.""" + +from collections import Counter +import hashlib +import json +from pathlib import Path +import sys + +import pyarrow as pa +import pyarrow.parquet as pq + +SPLIT_SIZES = {"train": 9676, "val": 2765, "test": 1383} +OUTPUT_SHARDS = 8 +EXPECTED_SOURCE_REVISION = "5c4adb2ec5cfc71794988b1297a7ff8ffe59daa5" +EXPECTED_ENGIBENCH_COMMIT = "64e6107d44349e67e031cad36633c1af26817784" +EXPECTED_CONTAINER_SHA256 = "40816f203b7e1c68ae37f4d9353bd302486d77988b98733c021f1ff71f48ae02" +EXPECTED_NGSPICE_SHA256 = "11a4334ee90509f5edfdceef541711a34a1943d26a14cf0928ac8d5947b72374" + +SCHEMA = pa.schema( + [ + pa.field("dataset_schema_version", pa.int64(), nullable=False), + pa.field("split", pa.string(), nullable=False), + pa.field("source_index", pa.int64(), nullable=False), + pa.field("design_sha256", pa.string(), nullable=False), + pa.field("initial_design", pa.list_(pa.float64()), nullable=False), + pa.field("v0_DcGain", pa.float64(), nullable=False), + pa.field("v0_Voltage_Ripple", pa.float64(), nullable=False), + pa.field("source_dataset_id", pa.string(), nullable=False), + pa.field("source_dataset_revision", pa.string(), nullable=False), + pa.field("problem_version", pa.int64(), nullable=False), + pa.field("engibench_git_commit", pa.string(), nullable=False), + pa.field("netlist_sha256", pa.string(), nullable=False), + pa.field("simulator_version", pa.string(), nullable=False), + pa.field("simulator_sha256", pa.string(), nullable=False), + pa.field("simulator_platform_system", pa.string(), nullable=False), + pa.field("simulator_platform_machine", pa.string(), nullable=False), + pa.field("container_sha256", pa.string(), nullable=False), + pa.field("output_voltage_mean", pa.float64()), + pa.field("output_voltage_peak_to_peak", pa.float64()), + pa.field("dc_gain", pa.float64()), + pa.field("dc_gain_error", pa.float64()), + pa.field("relative_voltage_ripple", pa.float64()), + pa.field("simulation_valid", pa.bool_(), nullable=False), + pa.field("objectives_valid", pa.bool_(), nullable=False), + pa.field("simulation_status", pa.string(), nullable=False), + pa.field("error_type", pa.string()), + pa.field("error_message", pa.string()), + ], + metadata={ + b"engibench_problem": b"power_electronics", + b"engibench_problem_version": b"1", + b"engibench_git_commit": EXPECTED_ENGIBENCH_COMMIT.encode(), + b"source_dataset_revision": EXPECTED_SOURCE_REVISION.encode(), + b"container_sha256": EXPECTED_CONTAINER_SHA256.encode(), + b"ngspice_sha256": EXPECTED_NGSPICE_SHA256.encode(), + }, +) + + +def reject_constant(value: str) -> None: + raise ValueError(f"non-standard JSON constant: {value}") + + +def canonical_hash(rows: list[dict]) -> str: + digest = hashlib.sha256() + for row in rows: + serialized = json.dumps(row, allow_nan=False, separators=(",", ":")) + digest.update(serialized.encode()) + digest.update(b"\n") + return digest.hexdigest() + + +def file_sha256(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as handle: + for chunk in iter(lambda: handle.read(1024 * 1024), b""): + digest.update(chunk) + return digest.hexdigest() + + +def assert_storage_schema(actual: pa.Schema) -> None: + """Validate the Parquet round-trip schema despite Arrow's list-child rename.""" + assert actual.names == SCHEMA.names + assert actual.metadata == SCHEMA.metadata + for actual_field, expected_field in zip(actual, SCHEMA, strict=True): + assert actual_field.name == expected_field.name + assert actual_field.nullable == expected_field.nullable + if expected_field.name == "initial_design": + assert pa.types.is_list(actual_field.type) + assert actual_field.type.value_type == pa.float64() + else: + assert actual_field.type == expected_field.type + + +raw_dir = Path(sys.argv[1]) +publish_dir = Path(sys.argv[2]) +data_dir = publish_dir / "data" +report_path = publish_dir / "provenance" / "parquet-conversion-report.json" +assert data_dir.is_dir() +assert not report_path.exists() + +report = { + "format": "PowerElectronics v1 Hugging Face Parquet conversion", + "source_dataset_revision": EXPECTED_SOURCE_REVISION, + "engibench_git_commit": EXPECTED_ENGIBENCH_COMMIT, + "container_sha256": EXPECTED_CONTAINER_SHA256, + "ngspice_sha256": EXPECTED_NGSPICE_SHA256, + "splits": {}, +} + +for split, expected_size in SPLIT_SIZES.items(): + input_paths = sorted(raw_dir.glob(f"{split}-*.jsonl")) + assert len(input_paths) == 8, (split, input_paths) + rows = [] + for input_path in input_paths: + rows.extend( + json.loads(line, parse_constant=reject_constant) + for line in input_path.read_text(encoding="utf-8").splitlines() + ) + rows.sort(key=lambda row: row["source_index"]) + + assert len(rows) == expected_size + assert [row["source_index"] for row in rows] == list(range(expected_size)) + assert all(row["split"] == split for row in rows) + assert all(len(row["initial_design"]) == 20 for row in rows) + assert all(row["source_dataset_revision"] == EXPECTED_SOURCE_REVISION for row in rows) + assert all(row["engibench_git_commit"] == EXPECTED_ENGIBENCH_COMMIT for row in rows) + assert all(row["container_sha256"] == EXPECTED_CONTAINER_SHA256 for row in rows) + assert all(row["simulator_sha256"] == EXPECTED_NGSPICE_SHA256 for row in rows) + + source_semantic_sha256 = canonical_hash(rows) + base_size, remainder = divmod(expected_size, OUTPUT_SHARDS) + output_paths = [] + offset = 0 + for shard_index in range(OUTPUT_SHARDS): + shard_size = base_size + (shard_index < remainder) + shard_rows = rows[offset : offset + shard_size] + offset += shard_size + output_path = data_dir / f"{split}-{shard_index:05d}-of-{OUTPUT_SHARDS:05d}.parquet" + assert not output_path.exists() + table = pa.Table.from_pylist(shard_rows, schema=SCHEMA) + pq.write_table( + table, + output_path, + compression="zstd", + use_dictionary=True, + write_statistics=True, + version="2.6", + ) + output_paths.append(output_path) + assert offset == expected_size + + parquet_rows = [] + for output_path in output_paths: + table = pq.read_table(output_path) + assert_storage_schema(table.schema) + parquet_rows.extend(table.to_pylist()) + parquet_semantic_sha256 = canonical_hash(parquet_rows) + assert parquet_rows == rows + assert parquet_semantic_sha256 == source_semantic_sha256 + + statuses = Counter(row["simulation_status"] for row in rows) + report["splits"][split] = { + "record_count": len(rows), + "status_counts": dict(sorted(statuses.items())), + "source_json_semantic_sha256": source_semantic_sha256, + "parquet_semantic_sha256": parquet_semantic_sha256, + "parquet_files": [ + { + "path": str(path.relative_to(publish_dir)), + "bytes": path.stat().st_size, + "sha256": file_sha256(path), + "record_count": pq.read_metadata(path).num_rows, + } + for path in output_paths + ], + } + +with report_path.open("x", encoding="utf-8") as output_file: + json.dump(report, output_file, indent=2, sort_keys=True) + output_file.write("\n") + +print(json.dumps(report, indent=2, sort_keys=True)) diff --git a/provenance/scripts/generate_full_euler.slurm b/provenance/scripts/generate_full_euler.slurm new file mode 100644 index 0000000000000000000000000000000000000000..6f829e3ee875e1e75b01c4460d95e6bf351c45b7 --- /dev/null +++ b/provenance/scripts/generate_full_euler.slurm @@ -0,0 +1,91 @@ +#!/bin/bash +#SBATCH --job-name=pe-v1-full +#SBATCH --time=02:00:00 +#SBATCH --cpus-per-task=2 +#SBATCH --mem-per-cpu=2G +#SBATCH --array=0-23%8 +#SBATCH --output=/cluster/scratch/smassoudi/engibench-power-electronics-v1/pilot-64e6107-20260920-01/logs/full-%A_%a.out +#SBATCH --error=/cluster/scratch/smassoudi/engibench-power-electronics-v1/pilot-64e6107-20260920-01/logs/full-%A_%a.err + +set -euo pipefail + +readonly GENERATION_ROOT=/cluster/scratch/smassoudi/engibench-power-electronics-v1/pilot-64e6107-20260920-01 +readonly REPOSITORY="$GENERATION_ROOT/EngiBench" +readonly IMAGE="$GENERATION_ROOT/images/power-electronics-v1-40816f203b7e.sif" +readonly CACHE_SEED="$GENERATION_ROOT/runtime/evenly-spaced-100-per-split-20260920-01" +readonly EXPECTED_COMMIT=64e6107d44349e67e031cad36633c1af26817784 +readonly EXPECTED_IMAGE_SHA256=40816f203b7e1c68ae37f4d9353bd302486d77988b98733c021f1ff71f48ae02 +readonly SHARD_COUNT=8 +readonly RUN_NAME=full-8-shards-64e6107-20260920-01 +readonly RESULT_ROOT="$GENERATION_ROOT/results/$RUN_NAME" +readonly WORK_ROOT="$GENERATION_ROOT/work/$RUN_NAME" +readonly RUNTIME_ROOT="$GENERATION_ROOT/runtime/$RUN_NAME" + +task_id="${SLURM_ARRAY_TASK_ID:?SLURM_ARRAY_TASK_ID is required}" +split_offset=$((task_id / SHARD_COUNT)) +shard_index=$((task_id % SHARD_COUNT)) +case "$split_offset" in + 0) split=train ;; + 1) split=val ;; + 2) split=test ;; + *) echo "Unexpected split offset: $split_offset" >&2; exit 2 ;; +esac + +shard_label="$(printf '%05d-of-%05d' "$shard_index" "$SHARD_COUNT")" +output_path="$RESULT_ROOT/$split-$shard_label.jsonl" +work_dir="$WORK_ROOT/task-$task_id-$split-$shard_label" +runtime_dir="$RUNTIME_ROOT/task-$task_id-$split-$shard_label" + +test "$(git -C "$REPOSITORY" rev-parse HEAD)" = "$EXPECTED_COMMIT" +test -z "$(git -C "$REPOSITORY" status --porcelain)" +test -f "$IMAGE" +echo "$EXPECTED_IMAGE_SHA256 $IMAGE" | sha256sum --check +test -d "$CACHE_SEED/hf-home" +test -d "$CACHE_SEED/hf-datasets" +test -d "$CACHE_SEED/hf-hub" +test ! -e "$output_path" +test ! -e "$output_path.manifest.json" +test ! -e "$work_dir" +test ! -e "$runtime_dir" + +mkdir -p \ + "$RESULT_ROOT" \ + "$work_dir" \ + "$runtime_dir/hf-home" \ + "$runtime_dir/hf-datasets" \ + "$runtime_dir/hf-hub" \ + "$runtime_dir/matplotlib" \ + "$runtime_dir/tmp" \ + "$runtime_dir/xdg-cache" + +cp -a "$CACHE_SEED/hf-home/." "$runtime_dir/hf-home/" +cp -a "$CACHE_SEED/hf-datasets/." "$runtime_dir/hf-datasets/" +cp -a "$CACHE_SEED/hf-hub/." "$runtime_dir/hf-hub/" +unset HF_TOKEN HUGGING_FACE_HUB_TOKEN + +apptainer exec \ + --cleanenv \ + --no-home \ + --bind "$GENERATION_ROOT:$GENERATION_ROOT" \ + --env "TMPDIR=$runtime_dir/tmp" \ + --env "XDG_CACHE_HOME=$runtime_dir/xdg-cache" \ + --env "HF_HOME=$runtime_dir/hf-home" \ + --env "HF_DATASETS_CACHE=$runtime_dir/hf-datasets" \ + --env "HF_HUB_CACHE=$runtime_dir/hf-hub" \ + --env "HF_HUB_OFFLINE=1" \ + --env "HF_DATASETS_OFFLINE=1" \ + --env "HF_HUB_DISABLE_TELEMETRY=1" \ + --env "PYTHONPATH=$REPOSITORY" \ + --env "MPLCONFIGDIR=$runtime_dir/matplotlib" \ + "$IMAGE" \ + /opt/power-electronics-v1/bin/python -m \ + engibench.problems.power_electronics.dataset_generation \ + --split "$split" \ + --num-shards "$SHARD_COUNT" \ + --shard-index "$shard_index" \ + --output "$output_path" \ + --work-dir "$work_dir" \ + --ngspice-path /opt/ngspice-44.2/bin/ngspice \ + --container-image "$IMAGE" + +sha256sum "$output_path" "$output_path.manifest.json"