CircuitNet: an EDA dataset for congestion, DRC, IR drop and net delay models

The gap CircuitNet fills for ML work on chip layout

Most published work on learning-based EDA prediction is hard to compare because the training data is private. CircuitNet's contribution is the data itself: layout, congestion, DRC and IR drop features released alongside reference models, so a result can be reproduced without an internal tapeout. The repository README frames it as a place to "host codes and demos for CircuitNet" and to help users "reproduce exiting methods".

The intended user is someone with machine learning experience who is entering an EDA problem, or an EDA engineer who wants a baseline before building internal tooling. The topics list on the repository names the task areas: congestion prediction, DRC violation, IR drop and the broader EDA and machine learning categories. This is not a tool you point at your own design and get an answer from. It is a benchmark and a starting codebase, and the models included are demonstrations of how the data can be consumed rather than production predictors.

How the repository, dataset and task code fit together

The repository separates data generation from model training. Top-level entries include feature_extraction/, which turns LEF/DEF files into features, build_graph_demo/, which builds graphs from graph information in the dataset, net_delay_prediction/, and routability_ir_drop_prediction/, which holds the congestion, DRC and IR drop code paths.

Feature extraction is the interesting design decision. The README states that the code lets users "implement self-defined features with the LEF/DEF we released or extract features with LEF/DEF from other sources", so the feature pipeline is not tied to the shipped dataset. That matters if your layouts differ from the released ones.

Training and testing are driven by a task flag. The same scripts cover congestion, DRC and IR drop, and the configuration lives in utils/configs.py, which the README tells you to change to fit your file paths and hyper-parameters before starting. Net delay is the exception: it uses graph data built by build_graph.py and requires DGL, which the README notes is not in requirements.txt.

Installing CircuitNet and running a first prediction

Install the Python dependencies from the repository root. PyTorch is deliberately excluded from requirements.txt, and the README says to install it following the instructions on the PyTorch homepage; the same applies to DGL, which is needed only for net delay prediction. The README states that the authors' experiments ran on Python 3.9 and PyTorch 1.11, and that other versions should work but are not tested.

pip install -r requirements.txt

Before running anything, open utils/configs.py and set the paths to your local dataset copy and adjust hyper-parameters. The README gives no default path, so this edit is the first real step, not an optional one.

Download the dataset generation you need. The README points N28 (V1.0) to Google Drive and Baidu Netdisk, and states that N14 (v2.0) and N45 (v3.0) are maintained on Hugging Face at the dataset repositories CircuitNet/CircuitNet and SKLP-EDA-LAB/CircuitNet3.0 respectively. The download page on the project site has the per-task setup instructions.

Once the data is in place, a test run needs the pretrained weights path. This is the congestion example from the README:

python test.py --task congestion_gpdl --pretrained PRETRAINED_WEIGHTS_PATH

The DRC and IR drop tests add a save path and a plotting flag, for example `python test.py --task drc_routenet --pretrained PRETRAINED_WEIGHTS_PATH --save_path work_dir/drc_routenet/ --plot_roc`. Training swaps test.py for train.py and drops the pretrained flag: `python train.py --task congestion_gpdl --save_path work_dir/congestion_gpdl/`.

For net delay, build the graphs first with `python build_graph.py --data_path DATA_PATH --save_path ./graph`, where DATA_PATH is the parent directory of the timing features (nodes, net_edges and pin_positions). Training then takes a checkpoint directory name, and testing adds the iteration to load: `python train.py --checkpoint CHECKPOINT_NAME --test_iter TEST_ITERATION`. Pretrained weights for the earlier models are hosted on Google Drive and Baidu Netdisk according to the changelog, not in the repository.

Where CircuitNet will slow you down

The dependency pins are tight and old. requirements.txt fixes numpy at 1.23.2, scikit-image at 0.19.3, scikit-learn at 1.1.2, opencv-python at 4.6.0.66 and mmcv at 1.6.1, among others. Installing this file into an existing environment that already has a newer numpy or OpenCV is likely to conflict, so a separate virtual environment is the practical route. The README does not document a supported upgrade path.

Data integrity has been an issue before. The changelog for 2024/11/09 records that LEF/DEF, netlist and graph information were re-uploaded to fix issue #38, and a known issue dated 2024/12/16 states that some instance names in the DEF are wrong, with the DEF to be re-uploaded later. A fixing script, feature_extraction/fix_module_name_241216.py, is provided to correct the problem in situ. If you downloaded DEF files before those dates, the repository's own notes say your copy may be affected.

There are no tagged releases in the repository. Versioning is done through the changelog and through the dataset generations (N28, N14, N45), which means you cannot pin the code by version number the way you would with a packaged library. The last push to the repository was on 2026-05-17, which the changelog ties to the CircuitNet 3.0 release with the N45 PDK. There is no statement about a support window or a deprecation policy for the earlier generations.

Finally, this is the wrong tool if you want to predict on your own design out of the box. The models are tied to the released feature layouts and to configs you edit by hand; adapting them to a different process or feature set means working through the feature extraction code, not changing a flag.

CircuitNet compared with the ISPD contest benchmarks

The closest alternative in this space is the ISPD contest benchmark suites, which are also public layout data used for routability and related prediction tasks. The difference is scope and packaging. ISPD benchmarks are released as contest inputs, typically LEF/DEF and design files, and leave feature construction and model code to the entrant. CircuitNet ships the extracted features, the graph features, the pretrained weights and the training scripts in one repository, so the distance from download to a running baseline is shorter.

The trade-off runs the other way too. Because CircuitNet fixes its feature definitions, a method that depends on a different representation has to go through the feature_extraction code, whereas an ISPD-based workflow starts from raw design files and imposes nothing. The repository acknowledges this overlap directly: the changelog for 2023/3/22 states that congestion features and graph features generated from the ISPD2015 benchmark are available in the ISPD2015 directory, so the two are not mutually exclusive sources in practice.

Licence and the cost of keeping up

The repository is released under the BSD 3-Clause licence, as stated in the README and in the LICENSE file. That is a permissive licence, which generally means you can use and redistribute the code with the copyright notice and disclaimer intact, but the licence text itself is the authority and this is not legal advice. Note that the licence covers the repository. The README points to dataset downloads on Hugging Face and Google Drive, and to pretrained weights on Google Drive and Baidu Netdisk; those may carry their own terms, and the README does not spell them out.

Upgrade cost is mostly in the changelog. Moving between dataset generations is not a drop-in change: N28, N14 and N45 are separate downloads, and the tasks each supports differ, with N14 described as supporting congestion, IR drop and timing prediction. The code side is pinned to an older Python and PyTorch combination, so a team that wants to run this on current PyTorch is doing untested work. The absence of tagged releases means every update is a pull of main plus a read of the changelog, and the 2024 DEF issue shows why that read matters.

Editorial conclusion

Adopt CircuitNet if you are an ML researcher or EDA engineer who needs public layout data with reference implementations for congestion, DRC, IR drop or net delay prediction, and you are willing to fetch the dataset from Hugging Face or Google Drive and edit utils/configs.py to match your local paths. Do not adopt it if you need a maintained package with versioned releases and a stable API: there are no tagged releases in the repository, the README states that experiments ran on Python 3.9 and PyTorch 1.11 and that other versions are untested, and DGL is an extra dependency for net delay only. Verify first that the dataset generation you need is the one you download, since N28, N14 and N45 live in different places, and check whether the pretrained weights you want are in the Google Drive or Baidu Netdisk folders rather than in the repository.

Frequently asked questions

Official sources

1. circuitnet/CircuitNet on GitHub
2. Issues
3. License: BSD-3-Clause
4. Project website
5. README