Add files using upload-large-folder tool

PGLearn-Small-30_ieee.py

@@ -0,0 +1,397 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from pathlib import Path
+import json
+import gzip
+
+import datasets as hfd
+import h5py
+import pyarrow as pa
+
+# ┌──────────────┐
+# │   Metadata   │
+# └──────────────┘
+
+@dataclass
+class CaseSizes:
+    n_bus:    int
+    n_load:   int
+    n_gen:    int
+    n_branch: int
+
+CASENAME = "30_ieee"
+SIZES = CaseSizes(n_bus=30, n_load=21, n_gen=6, n_branch=41)
+NUM_TRAIN = 793067
+NUM_TEST = 198267
+NUM_INFEASIBLE = 8666
+
+URL = "https://huggingface.co/datasets/PGLearn/PGLearn-Small-30_ieee"
+DESCRIPTION = """\
+The 30_ieee PGLearn optimal power flow dataset, part of the PGLearn-Small collection. \
+"""
+VERSION = hfd.Version("1.0.0")
+DEFAULT_CONFIG_DESCRIPTION="""\
+This configuration contains feasible input, metadata, primal solution, and dual solution data \
+for the ACOPF, DCOPF, and SOCOPF formulations on the {case} system.
+"""
+USE_ML4OPF_WARNING = """
+================================================================================================
+  Loading PGLearn-Small-30_ieee 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-Small-30_ieee#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 PGLearnSmall30_ieeeConfig(hfd.BuilderConfig):
+    """BuilderConfig for PGLearn-Small-30_ieee. 
+    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(PGLearnSmall30_ieeeConfig, 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
+
+        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: urls[split].append(f"{split}/{formulation}/primal.h5" + self.gz_ext)
+                if self.dual:   urls[split].append(f"{split}/{formulation}/dual.h5" + self.gz_ext)
+                if self.meta:   urls[split].append(f"{split}/{formulation}/meta.h5" + self.gz_ext)
+        return urls
+
+# ┌────────────────────┐
+# │   DatasetBuilder   │
+# └────────────────────┘
+
+class PGLearnSmall30_ieee(hfd.ArrowBasedBuilder):
+    """DatasetBuilder for PGLearn-Small-30_ieee.
+    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-Small-30_ieee", 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 = PGLearnSmall30_ieeeConfig
+    DEFAULT_CONFIG_NAME=CASENAME
+    BUILDER_CONFIGS = [
+        PGLearnSmall30_ieeeConfig(
+            name=CASENAME, description=DEFAULT_CONFIG_DESCRIPTION.format(case=CASENAME),
+            formulations=list(FORMULATIONS_TO_FEATURES.keys()),
+            primal=True, dual=True, meta=True, input=True, casejson=True,
+            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["case"], 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["case"], 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["case"], 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], n_samples: int):
+        case_data: str | None = json.dumps(json.load(open_maybe_gzip(case_file))) if case_file is not None else None
+
+        opened_files = [open_maybe_gzip(file) for file in data_files]
+        data = {'/'.join(Path(df.get_origin()).parts[-2:]).split('.')[0]: h5py.File(of) for of, df in zip(opened_files, data_files)}
+        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 opened_files:
+            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(path):
+    return gzip.open(path, "rb") if path.endswith(".gz") else open(path, "rb")

README.md

@@ -0,0 +1,11 @@
+---
+license: cc-by-sa-4.0
+tags:
+- energy
+- optimization
+- optimal_power_flow
+- power_grid
+pretty_name: PGLearn Optimal Power Flow (30_ieee)
+task_categories:
+- tabular-regression
+---

case.json.gz

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

config.toml

@@ -0,0 +1,42 @@
+# Name of the reference PGLib case. Must be a valid PGLib case name.
+pglib_case = "pglib_opf_case30_ieee"
+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

infeasible/ACOPF/dual.h5.gz

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

infeasible/ACOPF/meta.h5.gz

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

infeasible/ACOPF/primal.h5.gz

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

infeasible/DCOPF/dual.h5.gz

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

infeasible/DCOPF/meta.h5.gz

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

infeasible/DCOPF/primal.h5.gz

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

infeasible/SOCOPF/dual.h5.gz

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

infeasible/SOCOPF/meta.h5.gz

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

infeasible/SOCOPF/primal.h5.gz

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

infeasible/input.h5.gz

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

test/ACOPF/dual.h5.gz

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

test/ACOPF/meta.h5.gz

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

test/ACOPF/primal.h5.gz

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

test/DCOPF/dual.h5.gz

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

test/DCOPF/meta.h5.gz

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

test/DCOPF/primal.h5.gz

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

test/SOCOPF/dual.h5.gz

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

test/SOCOPF/meta.h5.gz

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

test/SOCOPF/primal.h5.gz

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

test/input.h5.gz

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

train/ACOPF/dual.h5.gz

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

train/ACOPF/meta.h5.gz

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

train/ACOPF/primal.h5.gz

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

train/DCOPF/dual.h5.gz

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

train/DCOPF/meta.h5.gz

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

train/DCOPF/primal.h5.gz

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

train/SOCOPF/dual.h5.gz

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

train/SOCOPF/meta.h5.gz

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

train/SOCOPF/primal.h5.gz

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

train/input.h5.gz

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