Add files using upload-large-folder tool

.gitattributes

@@ -57,3 +57,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+train/SOCOPF/dual/xac filter=lfs diff=lfs merge=lfs -text
+test/test/SOCOPF/.dual.h5.ixwvOB filter=lfs diff=lfs merge=lfs -text
+train/SOCOPF/dual/xab filter=lfs diff=lfs merge=lfs -text
+train/SOCOPF/dual/xaa filter=lfs diff=lfs merge=lfs -text

PGLearn-Medium-2869_pegase.py

@@ -0,0 +1,429 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from pathlib import Path
+import json
+import shutil
+
+import datasets as hfd
+import h5py
+import pgzip as gzip
+import pyarrow as pa
+
+# ┌──────────────┐
+# │   Metadata   │
+# └──────────────┘
+
+@dataclass
+class CaseSizes:
+    n_bus:    int
+    n_load:   int
+    n_gen:    int
+    n_branch: int
+
+CASENAME = "2869_pegase"
+SIZES = CaseSizes(n_bus=2869, n_load=1491, n_gen=510, n_branch=4582)
+NUM_TRAIN = 188545
+NUM_TEST = 47137
+NUM_INFEASIBLE = 14322
+SPLITFILES = {
+    "train/SOCOPF/dual.h5.gz": ["train/SOCOPF/dual/xaa", "train/SOCOPF/dual/xab", "train/SOCOPF/dual/xac"],
+}
+
+URL = "https://huggingface.co/datasets/PGLearn/PGLearn-Medium-2869_pegase"
+DESCRIPTION = """\
+The 2869_pegase PGLearn optimal power flow dataset, part of the PGLearn-Medium collection. \
+"""
+VERSION = hfd.Version("1.0.0")
+DEFAULT_CONFIG_DESCRIPTION="""\
+This configuration contains feasible input, primal solution, and dual solution data \
+for the ACOPF, DCOPF, and SOCOPF formulations on the {case} system. For case data, \
+download the case.json.gz file from the `script` branch of the repository. \
+https://huggingface.co/datasets/PGLearn/PGLearn-Medium-2869_pegase/blob/script/case.json.gz
+"""
+USE_ML4OPF_WARNING = """
+================================================================================================
+  Loading PGLearn-Medium-2869_pegase through the `datasets.load_dataset` function may be slow.
+
+  Consider using ML4OPF to directly convert to `torch.Tensor`; for more info see:
+    https://github.com/AI4OPT/ML4OPF?tab=readme-ov-file#manually-loading-data
+
+  Or, use `huggingface_hub.snapshot_download` and an HDF5 reader; for more info see:
+    https://huggingface.co/datasets/PGLearn/PGLearn-Medium-2869_pegase#downloading-individual-files
+================================================================================================
+"""
+CITATION = """\
+@article{klamkinpglearn,
+  title={{PGLearn - An Open-Source Learning Toolkit for Optimal Power Flow}},
+  author={Klamkin, Michael and Tanneau, Mathieu and Van Hentenryck, Pascal},
+  year={2025},
+}\
+"""
+
+IS_COMPRESSED = True
+
+# ┌──────────────────┐
+# │   Formulations   │
+# └──────────────────┘
+
+def acopf_features(sizes: CaseSizes, primal: bool, dual: bool, meta: bool):
+    features = {}
+    if primal: features.update(acopf_primal_features(sizes))
+    if dual:   features.update(acopf_dual_features(sizes))
+    if meta:   features.update({f"ACOPF/{k}": v for k, v in META_FEATURES.items()})
+    return features
+
+def dcopf_features(sizes: CaseSizes, primal: bool, dual: bool, meta: bool):
+    features = {}
+    if primal: features.update(dcopf_primal_features(sizes))
+    if dual:   features.update(dcopf_dual_features(sizes))
+    if meta:   features.update({f"DCOPF/{k}": v for k, v in META_FEATURES.items()})
+    return features
+
+def socopf_features(sizes: CaseSizes, primal: bool, dual: bool, meta: bool):
+    features = {}
+    if primal: features.update(socopf_primal_features(sizes))
+    if dual:   features.update(socopf_dual_features(sizes))
+    if meta:   features.update({f"SOCOPF/{k}": v for k, v in META_FEATURES.items()})
+    return features
+
+FORMULATIONS_TO_FEATURES = {
+    "ACOPF": acopf_features,
+    "DCOPF": dcopf_features,
+    "SOCOPF": socopf_features,
+}
+
+# ┌───────────────────┐
+# │   BuilderConfig   │
+# └───────────────────┘
+
+class PGLearnMedium2869_pegaseConfig(hfd.BuilderConfig):
+    """BuilderConfig for PGLearn-Medium-2869_pegase. 
+    By default, primal solution data, metadata, input, casejson, are included for the train and test splits.
+
+    To modify the default configuration, pass attributes of this class to `datasets.load_dataset`:
+    
+    Attributes:
+        formulations (list[str]): The formulation(s) to include, e.g. ["ACOPF", "DCOPF"]
+        primal (bool, optional): Include primal solution data. Defaults to True.
+        dual (bool, optional): Include dual solution data. Defaults to False.
+        meta (bool, optional): Include metadata. Defaults to True.
+        input (bool, optional): Include input data. Defaults to True.
+        casejson (bool, optional): Include case.json data. Defaults to True.
+        train (bool, optional): Include training samples. Defaults to True.
+        test (bool, optional): Include testing samples. Defaults to True.
+        infeasible (bool, optional): Include infeasible samples. Defaults to False.
+    """
+    def __init__(self,
+            formulations: list[str],
+            primal: bool=True, dual: bool=False, meta: bool=True, input: bool = True, casejson: bool=True,
+            train: bool=True, test: bool=True, infeasible: bool=False,
+            compressed: bool=IS_COMPRESSED, **kwargs
+        ):
+        super(PGLearnMedium2869_pegaseConfig, self).__init__(version=VERSION, **kwargs)
+
+        self.case = CASENAME
+        self.formulations = formulations
+
+        self.primal = primal
+        self.dual = dual
+        self.meta = meta
+        self.input = input
+        self.casejson = casejson
+
+        self.train = train
+        self.test = test
+        self.infeasible = infeasible
+
+        self.gz_ext = ".gz" if compressed else ""
+
+    @property
+    def size(self):
+        return SIZES
+
+    @property
+    def features(self):
+        features = {}
+        if self.casejson: features.update(case_features())
+        if self.input: features.update(input_features(SIZES))
+        for formulation in self.formulations:
+            features.update(FORMULATIONS_TO_FEATURES[formulation](SIZES, self.primal, self.dual, self.meta))
+        return hfd.Features(features)
+    
+    @property
+    def splits(self):
+        splits: dict[hfd.Split, dict[str, str | int]] = {}
+        if self.train:
+            splits[hfd.Split.TRAIN] = {
+                "name": "train",
+                "num_examples": NUM_TRAIN
+            }
+        if self.test:
+            splits[hfd.Split.TEST] = {
+                "name": "test",
+                "num_examples": NUM_TEST
+            }
+        if self.infeasible:
+            splits[hfd.Split("infeasible")] = {
+                "name": "infeasible",
+                "num_examples": NUM_INFEASIBLE
+            }
+        return splits
+    
+    @property
+    def urls(self):
+        urls: dict[str, None | str | list] = {
+            "case": None, "train": [], "test": [], "infeasible": [],
+        }
+
+        if self.casejson:
+            urls["case"] = f"case.json" + self.gz_ext
+        else:
+            urls.pop("case")
+
+        split_names = []
+        if self.train: split_names.append("train")
+        if self.test:  split_names.append("test")
+        if self.infeasible: split_names.append("infeasible")
+
+        for split in split_names:
+            if self.input: urls[split].append(f"{split}/input.h5" + self.gz_ext)
+            for formulation in self.formulations:
+                if self.primal:
+                    filename = f"{split}/{formulation}/primal.h5" + self.gz_ext
+                    if filename in SPLITFILES: urls[split].append(SPLITFILES[filename])
+                    else: urls[split].append(filename)
+                if self.dual:
+                    filename = f"{split}/{formulation}/dual.h5" + self.gz_ext
+                    if filename in SPLITFILES: urls[split].append(SPLITFILES[filename])
+                    else: urls[split].append(filename)
+                if self.meta:
+                    filename = f"{split}/{formulation}/meta.h5" + self.gz_ext
+                    if filename in SPLITFILES: urls[split].append(SPLITFILES[filename])
+                    else: urls[split].append(filename)
+        return urls
+
+# ┌────────────────────┐
+# │   DatasetBuilder   │
+# └────────────────────┘
+
+class PGLearnMedium2869_pegase(hfd.ArrowBasedBuilder):
+    """DatasetBuilder for PGLearn-Medium-2869_pegase.
+    The main interface is `datasets.load_dataset` with `trust_remote_code=True`, e.g.
+
+    ```python
+    from datasets import load_dataset
+    ds = load_dataset("PGLearn/PGLearn-Medium-2869_pegase", trust_remote_code=True,
+        # modify the default configuration by passing kwargs
+        formulations=["DCOPF"],
+        dual=False,
+        meta=False,
+    )
+    ```
+    """
+
+    DEFAULT_WRITER_BATCH_SIZE = 10000
+    BUILDER_CONFIG_CLASS = PGLearnMedium2869_pegaseConfig
+    DEFAULT_CONFIG_NAME=CASENAME
+    BUILDER_CONFIGS = [
+        PGLearnMedium2869_pegaseConfig(
+            name=CASENAME, description=DEFAULT_CONFIG_DESCRIPTION.format(case=CASENAME),
+            formulations=list(FORMULATIONS_TO_FEATURES.keys()),
+            primal=True, dual=True, meta=True, input=True, casejson=False,
+            train=True, test=True, infeasible=False,
+        )
+    ]
+
+    def _info(self):
+        return hfd.DatasetInfo(
+            features=self.config.features, splits=self.config.splits,
+            description=DESCRIPTION + self.config.description,
+            homepage=URL, citation=CITATION,
+        )
+
+    def _split_generators(self, dl_manager: hfd.DownloadManager):
+        hfd.logging.get_logger().warning(USE_ML4OPF_WARNING)
+
+        filepaths = dl_manager.download_and_extract(self.config.urls)
+
+        splits: list[hfd.SplitGenerator] = []
+        if self.config.train:
+            splits.append(hfd.SplitGenerator(
+                name=hfd.Split.TRAIN,
+                gen_kwargs=dict(case_file=filepaths.get("case", None), data_files=tuple(filepaths["train"]), n_samples=NUM_TRAIN),
+            ))
+        if self.config.test:
+            splits.append(hfd.SplitGenerator(
+                name=hfd.Split.TEST,
+                gen_kwargs=dict(case_file=filepaths.get("case", None), data_files=tuple(filepaths["test"]), n_samples=NUM_TEST),
+            ))
+        if self.config.infeasible:
+            splits.append(hfd.SplitGenerator(
+                name=hfd.Split("infeasible"),
+                gen_kwargs=dict(case_file=filepaths.get("case", None), data_files=tuple(filepaths["infeasible"]), n_samples=NUM_INFEASIBLE),
+            ))
+        return splits
+
+    def _generate_tables(self, case_file: str | None, data_files: tuple[hfd.utils.track.tracked_str | list[hfd.utils.track.tracked_str]], n_samples: int):
+        case_data: str | None = json.dumps(json.load(open_maybe_gzip_cat(case_file))) if case_file is not None else None
+        data: dict[str, h5py.File] = {}
+        for file in data_files:
+            v = h5py.File(open_maybe_gzip_cat(file), "r")
+            if isinstance(file, list):
+                k = "/".join(Path(file[0].get_origin()).parts[-3:-1]).split(".")[0]
+            else:
+                k = "/".join(Path(file.get_origin()).parts[-2:]).split(".")[0]
+            data[k] = v
+        for k in list(data.keys()):
+            if "/input" in k: data[k.split("/", 1)[1]] = data.pop(k)
+
+        batch_size = self._writer_batch_size or self.DEFAULT_WRITER_BATCH_SIZE
+        for i in range(0, n_samples, batch_size):
+            effective_batch_size = min(batch_size, n_samples - i)
+
+            sample_data = {
+                f"{dk}/{k}":
+                hfd.features.features.numpy_to_pyarrow_listarray(v[i:i + effective_batch_size, ...])
+                for dk, d in data.items() for k, v in d.items() if f"{dk}/{k}" in self.config.features
+            }
+
+            if case_data is not None:
+                sample_data["case/json"] = pa.array([case_data] * effective_batch_size)
+
+            yield i, pa.Table.from_pydict(sample_data)
+
+        for f in data.values():
+            f.close()
+
+# ┌──────────────┐
+# │   Features   │
+# └──────────────┘
+
+FLOAT_TYPE = "float32"
+INT_TYPE = "int64"
+BOOL_TYPE = "bool"
+STRING_TYPE = "string"
+
+def case_features():
+    # FIXME: better way to share schema of case data -- need to treat jagged arrays
+    return {
+        "case/json": hfd.Value(STRING_TYPE),
+    }
+
+META_FEATURES = {
+    "meta/seed":                   hfd.Value(dtype=INT_TYPE),
+    "meta/formulation":            hfd.Value(dtype=STRING_TYPE),
+    "meta/primal_objective_value": hfd.Value(dtype=FLOAT_TYPE),
+    "meta/dual_objective_value":   hfd.Value(dtype=FLOAT_TYPE),
+    "meta/primal_status":          hfd.Value(dtype=STRING_TYPE),
+    "meta/dual_status":            hfd.Value(dtype=STRING_TYPE),
+    "meta/termination_status":     hfd.Value(dtype=STRING_TYPE),
+    "meta/build_time":             hfd.Value(dtype=FLOAT_TYPE),
+    "meta/extract_time":           hfd.Value(dtype=FLOAT_TYPE),
+    "meta/solve_time":             hfd.Value(dtype=FLOAT_TYPE),
+}
+
+def input_features(sizes: CaseSizes):
+    return {
+        "input/pd":            hfd.Sequence(length=sizes.n_load,   feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "input/qd":            hfd.Sequence(length=sizes.n_load,   feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "input/gen_status":    hfd.Sequence(length=sizes.n_gen,    feature=hfd.Value(dtype=BOOL_TYPE)),
+        "input/branch_status": hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=BOOL_TYPE)),
+        "input/seed":          hfd.Value(dtype=INT_TYPE),
+    }
+
+def acopf_primal_features(sizes: CaseSizes):
+    return {
+        "ACOPF/primal/vm": hfd.Sequence(length=sizes.n_bus,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "ACOPF/primal/va": hfd.Sequence(length=sizes.n_bus,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "ACOPF/primal/pg": hfd.Sequence(length=sizes.n_gen,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "ACOPF/primal/qg": hfd.Sequence(length=sizes.n_gen,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "ACOPF/primal/pf": hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "ACOPF/primal/pt": hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "ACOPF/primal/qf": hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "ACOPF/primal/qt": hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+    }
+def acopf_dual_features(sizes: CaseSizes):
+    return {
+        "ACOPF/dual/kcl_p":     hfd.Sequence(length=sizes.n_bus,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "ACOPF/dual/kcl_q":     hfd.Sequence(length=sizes.n_bus,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "ACOPF/dual/vm":        hfd.Sequence(length=sizes.n_bus,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "ACOPF/dual/pg":        hfd.Sequence(length=sizes.n_gen,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "ACOPF/dual/qg":        hfd.Sequence(length=sizes.n_gen,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "ACOPF/dual/ohm_pf":    hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "ACOPF/dual/ohm_pt":    hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "ACOPF/dual/ohm_qf":    hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "ACOPF/dual/ohm_qt":    hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "ACOPF/dual/pf":        hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "ACOPF/dual/pt":        hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "ACOPF/dual/qf":        hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "ACOPF/dual/qt":        hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "ACOPF/dual/va_diff":   hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "ACOPF/dual/sm_fr":     hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "ACOPF/dual/sm_to":     hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "ACOPF/dual/slack_bus": hfd.Value(dtype=FLOAT_TYPE),
+    }
+def dcopf_primal_features(sizes: CaseSizes):
+    return {
+        "DCOPF/primal/va": hfd.Sequence(length=sizes.n_bus,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "DCOPF/primal/pg": hfd.Sequence(length=sizes.n_gen,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "DCOPF/primal/pf": hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+    }
+def dcopf_dual_features(sizes: CaseSizes):
+    return {
+        "DCOPF/dual/kcl_p":     hfd.Sequence(length=sizes.n_bus,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "DCOPF/dual/pg":        hfd.Sequence(length=sizes.n_gen,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "DCOPF/dual/ohm_pf":    hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "DCOPF/dual/pf":        hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "DCOPF/dual/va_diff":   hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "DCOPF/dual/slack_bus": hfd.Value(dtype=FLOAT_TYPE),
+    }
+def socopf_primal_features(sizes: CaseSizes):
+    return {
+        "SOCOPF/primal/w":  hfd.Sequence(length=sizes.n_bus,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "SOCOPF/primal/pg": hfd.Sequence(length=sizes.n_gen,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "SOCOPF/primal/qg": hfd.Sequence(length=sizes.n_gen,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "SOCOPF/primal/pf": hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "SOCOPF/primal/pt": hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "SOCOPF/primal/qf": hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "SOCOPF/primal/qt": hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "SOCOPF/primal/wr": hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "SOCOPF/primal/wi": hfd.Sequence(length=sizes.n_branch, feature=hfd.Value(dtype=FLOAT_TYPE)),
+    }
+def socopf_dual_features(sizes: CaseSizes):
+    return {
+        "SOCOPF/dual/kcl_p":   hfd.Sequence(length=sizes.n_bus,       feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "SOCOPF/dual/kcl_q":   hfd.Sequence(length=sizes.n_bus,       feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "SOCOPF/dual/w":       hfd.Sequence(length=sizes.n_bus,       feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "SOCOPF/dual/pg":      hfd.Sequence(length=sizes.n_gen,       feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "SOCOPF/dual/qg":      hfd.Sequence(length=sizes.n_gen,       feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "SOCOPF/dual/ohm_pf":  hfd.Sequence(length=sizes.n_branch,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "SOCOPF/dual/ohm_pt":  hfd.Sequence(length=sizes.n_branch,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "SOCOPF/dual/ohm_qf":  hfd.Sequence(length=sizes.n_branch,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "SOCOPF/dual/ohm_qt":  hfd.Sequence(length=sizes.n_branch,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "SOCOPF/dual/jabr":    hfd.Array2D(shape=(sizes.n_branch, 4), dtype=FLOAT_TYPE),
+        "SOCOPF/dual/sm_fr":   hfd.Array2D(shape=(sizes.n_branch, 3), dtype=FLOAT_TYPE),
+        "SOCOPF/dual/sm_to":   hfd.Array2D(shape=(sizes.n_branch, 3), dtype=FLOAT_TYPE),
+        "SOCOPF/dual/va_diff": hfd.Sequence(length=sizes.n_branch,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "SOCOPF/dual/wr":      hfd.Sequence(length=sizes.n_branch,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "SOCOPF/dual/wi":      hfd.Sequence(length=sizes.n_branch,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "SOCOPF/dual/pf":      hfd.Sequence(length=sizes.n_branch,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "SOCOPF/dual/pt":      hfd.Sequence(length=sizes.n_branch,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "SOCOPF/dual/qf":      hfd.Sequence(length=sizes.n_branch,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+        "SOCOPF/dual/qt":      hfd.Sequence(length=sizes.n_branch,    feature=hfd.Value(dtype=FLOAT_TYPE)),
+    }
+
+# ┌───────────────┐
+# │   Utilities   │
+# └───────────────┘
+
+def open_maybe_gzip_cat(path: str | list):
+    if isinstance(path, list):
+        dest = Path(path[0]).parent.with_suffix(".h5")
+        if not dest.exists():
+            with open(dest, "wb") as dest_f:
+                for piece in path:
+                    with open(piece, "rb") as piece_f:
+                        shutil.copyfileobj(piece_f, dest_f)
+            shutil.rmtree(Path(piece).parent)
+        path = dest.as_posix()
+    return gzip.open(path, "rb") if path.endswith(".gz") else open(path, "rb")

README.md

@@ -0,0 +1,293 @@
+---
+license: cc-by-sa-4.0
+tags:
+- energy
+- optimization
+- optimal_power_flow
+- power_grid
+pretty_name: PGLearn Optimal Power Flow (2869_pegase)
+task_categories:
+- tabular-regression
+dataset_info:
+  config_name: 2869_pegase
+  features:
+  - name: input/pd
+    sequence: float32
+    length: 1491
+  - name: input/qd
+    sequence: float32
+    length: 1491
+  - name: input/gen_status
+    sequence: bool
+    length: 510
+  - name: input/branch_status
+    sequence: bool
+    length: 4582
+  - name: input/seed
+    dtype: int64
+  - name: ACOPF/primal/vm
+    sequence: float32
+    length: 2869
+  - name: ACOPF/primal/va
+    sequence: float32
+    length: 2869
+  - name: ACOPF/primal/pg
+    sequence: float32
+    length: 510
+  - name: ACOPF/primal/qg
+    sequence: float32
+    length: 510
+  - name: ACOPF/primal/pf
+    sequence: float32
+    length: 4582
+  - name: ACOPF/primal/pt
+    sequence: float32
+    length: 4582
+  - name: ACOPF/primal/qf
+    sequence: float32
+    length: 4582
+  - name: ACOPF/primal/qt
+    sequence: float32
+    length: 4582
+  - name: ACOPF/dual/kcl_p
+    sequence: float32
+    length: 2869
+  - name: ACOPF/dual/kcl_q
+    sequence: float32
+    length: 2869
+  - name: ACOPF/dual/vm
+    sequence: float32
+    length: 2869
+  - name: ACOPF/dual/pg
+    sequence: float32
+    length: 510
+  - name: ACOPF/dual/qg
+    sequence: float32
+    length: 510
+  - name: ACOPF/dual/ohm_pf
+    sequence: float32
+    length: 4582
+  - name: ACOPF/dual/ohm_pt
+    sequence: float32
+    length: 4582
+  - name: ACOPF/dual/ohm_qf
+    sequence: float32
+    length: 4582
+  - name: ACOPF/dual/ohm_qt
+    sequence: float32
+    length: 4582
+  - name: ACOPF/dual/pf
+    sequence: float32
+    length: 4582
+  - name: ACOPF/dual/pt
+    sequence: float32
+    length: 4582
+  - name: ACOPF/dual/qf
+    sequence: float32
+    length: 4582
+  - name: ACOPF/dual/qt
+    sequence: float32
+    length: 4582
+  - name: ACOPF/dual/va_diff
+    sequence: float32
+    length: 4582
+  - name: ACOPF/dual/sm_fr
+    sequence: float32
+    length: 4582
+  - name: ACOPF/dual/sm_to
+    sequence: float32
+    length: 4582
+  - name: ACOPF/dual/slack_bus
+    dtype: float32
+  - name: ACOPF/meta/seed
+    dtype: int64
+  - name: ACOPF/meta/formulation
+    dtype: string
+  - name: ACOPF/meta/primal_objective_value
+    dtype: float32
+  - name: ACOPF/meta/dual_objective_value
+    dtype: float32
+  - name: ACOPF/meta/primal_status
+    dtype: string
+  - name: ACOPF/meta/dual_status
+    dtype: string
+  - name: ACOPF/meta/termination_status
+    dtype: string
+  - name: ACOPF/meta/build_time
+    dtype: float32
+  - name: ACOPF/meta/extract_time
+    dtype: float32
+  - name: ACOPF/meta/solve_time
+    dtype: float32
+  - name: DCOPF/primal/va
+    sequence: float32
+    length: 2869
+  - name: DCOPF/primal/pg
+    sequence: float32
+    length: 510
+  - name: DCOPF/primal/pf
+    sequence: float32
+    length: 4582
+  - name: DCOPF/dual/kcl_p
+    sequence: float32
+    length: 2869
+  - name: DCOPF/dual/pg
+    sequence: float32
+    length: 510
+  - name: DCOPF/dual/ohm_pf
+    sequence: float32
+    length: 4582
+  - name: DCOPF/dual/pf
+    sequence: float32
+    length: 4582
+  - name: DCOPF/dual/va_diff
+    sequence: float32
+    length: 4582
+  - name: DCOPF/dual/slack_bus
+    dtype: float32
+  - name: DCOPF/meta/seed
+    dtype: int64
+  - name: DCOPF/meta/formulation
+    dtype: string
+  - name: DCOPF/meta/primal_objective_value
+    dtype: float32
+  - name: DCOPF/meta/dual_objective_value
+    dtype: float32
+  - name: DCOPF/meta/primal_status
+    dtype: string
+  - name: DCOPF/meta/dual_status
+    dtype: string
+  - name: DCOPF/meta/termination_status
+    dtype: string
+  - name: DCOPF/meta/build_time
+    dtype: float32
+  - name: DCOPF/meta/extract_time
+    dtype: float32
+  - name: DCOPF/meta/solve_time
+    dtype: float32
+  - name: SOCOPF/primal/w
+    sequence: float32
+    length: 2869
+  - name: SOCOPF/primal/pg
+    sequence: float32
+    length: 510
+  - name: SOCOPF/primal/qg
+    sequence: float32
+    length: 510
+  - name: SOCOPF/primal/pf
+    sequence: float32
+    length: 4582
+  - name: SOCOPF/primal/pt
+    sequence: float32
+    length: 4582
+  - name: SOCOPF/primal/qf
+    sequence: float32
+    length: 4582
+  - name: SOCOPF/primal/qt
+    sequence: float32
+    length: 4582
+  - name: SOCOPF/primal/wr
+    sequence: float32
+    length: 4582
+  - name: SOCOPF/primal/wi
+    sequence: float32
+    length: 4582
+  - name: SOCOPF/dual/kcl_p
+    sequence: float32
+    length: 2869
+  - name: SOCOPF/dual/kcl_q
+    sequence: float32
+    length: 2869
+  - name: SOCOPF/dual/w
+    sequence: float32
+    length: 2869
+  - name: SOCOPF/dual/pg
+    sequence: float32
+    length: 510
+  - name: SOCOPF/dual/qg
+    sequence: float32
+    length: 510
+  - name: SOCOPF/dual/ohm_pf
+    sequence: float32
+    length: 4582
+  - name: SOCOPF/dual/ohm_pt
+    sequence: float32
+    length: 4582
+  - name: SOCOPF/dual/ohm_qf
+    sequence: float32
+    length: 4582
+  - name: SOCOPF/dual/ohm_qt
+    sequence: float32
+    length: 4582
+  - name: SOCOPF/dual/jabr
+    dtype:
+      array2_d:
+        shape:
+        - 4582
+        - 4
+        dtype: float32
+  - name: SOCOPF/dual/sm_fr
+    dtype:
+      array2_d:
+        shape:
+        - 4582
+        - 3
+        dtype: float32
+  - name: SOCOPF/dual/sm_to
+    dtype:
+      array2_d:
+        shape:
+        - 4582
+        - 3
+        dtype: float32
+  - name: SOCOPF/dual/va_diff
+    sequence: float32
+    length: 4582
+  - name: SOCOPF/dual/wr
+    sequence: float32
+    length: 4582
+  - name: SOCOPF/dual/wi
+    sequence: float32
+    length: 4582
+  - name: SOCOPF/dual/pf
+    sequence: float32
+    length: 4582
+  - name: SOCOPF/dual/pt
+    sequence: float32
+    length: 4582
+  - name: SOCOPF/dual/qf
+    sequence: float32
+    length: 4582
+  - name: SOCOPF/dual/qt
+    sequence: float32
+    length: 4582
+  - name: SOCOPF/meta/seed
+    dtype: int64
+  - name: SOCOPF/meta/formulation
+    dtype: string
+  - name: SOCOPF/meta/primal_objective_value
+    dtype: float32
+  - name: SOCOPF/meta/dual_objective_value
+    dtype: float32
+  - name: SOCOPF/meta/primal_status
+    dtype: string
+  - name: SOCOPF/meta/dual_status
+    dtype: string
+  - name: SOCOPF/meta/termination_status
+    dtype: string
+  - name: SOCOPF/meta/build_time
+    dtype: float32
+  - name: SOCOPF/meta/extract_time
+    dtype: float32
+  - name: SOCOPF/meta/solve_time
+    dtype: float32
+  splits:
+  - name: train
+    num_bytes: 189042853073
+    num_examples: 188545
+  - name: test
+    num_bytes: 47261465249
+    num_examples: 47137
+  download_size: 205052847659
+  dataset_size: 236304318322
+---

case.json.gz

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

config.toml

@@ -0,0 +1,54 @@
+export_dir = "data/pglearn/2869_pegase"
+# Name of the reference PGLib case. Must be a valid PGLib case name.
+pglib_case = "pglib_opf_case2869_pegase"
+floating_point_type = "Float32"
+
+[sampler]
+# data sampler options
+[sampler.load]
+noise_type = "ScaledUniform"
+l          = 0.6                # Lower bound of base load factor
+u          = 1.0                # Upper bound of base load factor
+sigma      = 0.20               # Relative (multiplicative) noise level.
+
+
+[OPF]
+
+[OPF.ACOPF]
+type = "ACOPF"
+solver.name = "Ipopt"
+solver.attributes.tol = 1e-6
+solver.attributes.linear_solver = "ma27"
+
+[OPF.DCOPF]
+# Formulation/solver options
+type = "DCOPF"
+solver.name = "HiGHS"
+
+[OPF.SOCOPF]
+type = "SOCOPF"
+solver.name = "Clarabel"
+# Tight tolerances
+solver.attributes.tol_gap_abs    = 1e-6
+solver.attributes.tol_gap_rel    = 1e-6
+solver.attributes.tol_feas       = 1e-6
+solver.attributes.tol_infeas_rel = 1e-6
+solver.attributes.tol_ktratio    = 1e-6
+# Reduced accuracy settings
+solver.attributes.reduced_tol_gap_abs    = 1e-6
+solver.attributes.reduced_tol_gap_rel    = 1e-6
+solver.attributes.reduced_tol_feas       = 1e-6
+solver.attributes.reduced_tol_infeas_abs = 1e-6
+solver.attributes.reduced_tol_infeas_rel = 1e-6
+solver.attributes.reduced_tol_ktratio    = 1e-6
+
+[slurm]
+n_samples = 500000
+n_jobs = 44
+minibatch_size = 32
+cpus_per_task = 8
+queue = "embers"
+charge_account = "gts-phentenryck3-ai4opt"
+sysimage_memory = "128G"
+sampler_memory = "8G"
+extract_memory = "500G"

infeasible/ACOPF/dual.h5.gz

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

infeasible/ACOPF/meta.h5.gz

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

infeasible/ACOPF/primal.h5.gz

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

infeasible/DCOPF/dual.h5.gz

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

infeasible/DCOPF/meta.h5.gz

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

infeasible/DCOPF/primal.h5.gz

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

infeasible/SOCOPF/dual.h5.gz

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

infeasible/SOCOPF/meta.h5.gz

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

infeasible/SOCOPF/primal.h5.gz

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

infeasible/infeasible/ACOPF/dual.h5.gz

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

infeasible/infeasible/ACOPF/meta.h5.gz

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

infeasible/infeasible/ACOPF/primal.h5.gz

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

infeasible/infeasible/DCOPF/dual.h5.gz

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

infeasible/infeasible/DCOPF/meta.h5.gz

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

infeasible/infeasible/DCOPF/primal.h5.gz

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

infeasible/infeasible/SOCOPF/dual.h5.gz

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

infeasible/infeasible/SOCOPF/meta.h5.gz

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

infeasible/infeasible/SOCOPF/primal.h5.gz

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

infeasible/infeasible/input.h5.gz

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

infeasible/input.h5.gz

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

test/ACOPF/dual.h5.gz

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

test/ACOPF/meta.h5.gz

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

test/ACOPF/primal.h5.gz

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

test/DCOPF/dual.h5.gz

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

test/DCOPF/meta.h5.gz

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

test/DCOPF/primal.h5.gz

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

test/SOCOPF/dual.h5.gz

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

test/SOCOPF/meta.h5.gz

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

test/SOCOPF/primal.h5.gz

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

test/input.h5.gz

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

test/test/ACOPF/dual.h5.gz

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

test/test/ACOPF/meta.h5.gz

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

test/test/ACOPF/primal.h5.gz

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

test/test/DCOPF/dual.h5.gz

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

test/test/DCOPF/meta.h5.gz

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

test/test/DCOPF/primal.h5.gz

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

test/test/SOCOPF/.dual.h5.ixwvOB

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

test/test/input.h5.gz

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

train/ACOPF/dual.h5.gz

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

train/ACOPF/meta.h5.gz

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

train/ACOPF/primal.h5.gz

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

train/DCOPF/dual.h5.gz

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

train/DCOPF/meta.h5.gz

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

train/DCOPF/primal.h5.gz

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

train/SOCOPF/dual/xaa

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