Datasets:

utsubo12
/

miic-netdsl-eval

license: other
license_name: miic-derived
license_link: https://doi.org/10.1109/ICIP42928.2021.9506454
task_categories:
  - image-to-text
language:
  - en
tags:
  - semiconductor
  - sem
  - domain-specific-language
  - program-synthesis
  - sim-to-real
  - evaluation
pretty_name: MIIC NetDSL Evaluation Set (inputs + model outputs)
size_categories:
  - 1K<n<10K
configs:
  - config_name: default
    data_files:
      - split: test
        path: data/test-*.parquet

MIIC NetDSL Evaluation Set

The real-SEM evaluation data for the EUSIPCO 2026 paper "Bridging the Sim-to-Real Gap in Semiconductor Visual Program Synthesis via Input Binarization" (Ohtsubo, Dohi, Yawata, Takeshita, Sasaki — Hitachi, Ltd. R&D Group), bundled with every model output the paper reports, so Table I and Fig. 4 can be checked without a GPU.

📄 Paper & code: https://github.com/YusukeO/eusipco2026-sem-dsl
🤖 Fine-tuned model: utsubo12/qwen3-vl-8b-netdsl-l2
🧪 Synthetic training data: utsubo12/netdsl-l2-synthetic-sem

What this is

The model is trained only on synthetic data. This dataset is the real-image test set it is evaluated on, covering both experimental conditions:

binary input (proposed) — the SEM image resized to 256×256 and globally thresholded,
raw input (baseline) — the SEM image merely resized to 256×256.

In both conditions the ground truth is the binarized image, which is what makes the comparison fair.

from datasets import load_dataset

ds = load_dataset("utsubo12/miic-netdsl-eval", split="test")
r = ds[0]
r["image_original"]        # PIL, 512x512 — the source MIIC image
r["image_binary_thr96"]    # PIL, 256x256 — binary-input condition (and the GT)
r["binary_dsl"]            # the NetDSL-L2 program the model generated
r["binary_rendered"]       # that program, rendered
r["binary_iou"], r["binary_dice"]

Features

Column	Type	Description
`sample_id`	string	e.g. `test_normal_00169`
`image_original`	Image	original MIIC image, 512×512 grayscale JPEG
`image_raw_resized256`	Image	LANCZOS resize to 256×256 — raw-input condition
`image_binary_thr96`	Image	resize + global threshold 96 — binary-input condition
`ground_truth`	Image	GT for both conditions (identical to `image_binary_thr96`)
`binary_dsl` / `raw_dsl`	string	generated NetDSL-L2, per condition
`binary_rendered` / `raw_rendered`	Image	the generated DSL, executed
`binary_success` / `raw_success`	bool	whether the DSL was executable
`binary_error` / `raw_error`	string	parser/runtime error when it was not
`binary_<metric>` / `raw_<metric>`	float	`iou`, `dice`, `bf1`, `skel_f1`, `assd`, `hd95`, `x_proj_corr`, `y_proj_corr`, `delta_components`, `delta_endpoints`, `delta_junctions`, `delta_euler`, `lines`, `characters`, `param_tokens`, `unique_params`, `param_digits`

1035 rows — the 1034 evaluated images plus test_normal_01035, whose source file is corrupt (see Caveats).

Headline numbers

Metric	Raw input	Binary input (ours)
IoU	0.2865 ± 0.0802	0.3619 ± 0.0882
Dice	0.4393 ± 0.0980	0.5256 ± 0.0912
BF1 @ 2 px	0.4054 ± 0.1106	0.4412 ± 0.1098
SkF1 @ 1 px	0.1276 ± 0.0960	0.1746 ± 0.1145
ASSD	4.7768 ± 3.4596	4.1327 ± 1.2757

Recomputable directly from this dataset:

import numpy as np
from datasets import load_dataset

ds = load_dataset("utsubo12/miic-netdsl-eval", split="test")
for cond in ("binary", "raw"):
    v = np.array([x for x in ds[f"{cond}_dice"] if x is not None])
    print(cond, "n =", len(v), "Dice =", f"{v.mean():.4f} ± {v.std(ddof=1):.4f}")

Preprocessing — reproducing the two conditions

Both start from the native 512×512 image and resize before anything else:

from PIL import Image
import numpy as np

img = Image.open("test_normal_00169.jpg").convert("L").resize((256, 256), Image.LANCZOS)

raw_input    = img                                                    # baseline condition
binary_input = Image.fromarray(np.where(np.array(img) > 96, 255, 0).astype(np.uint8), "L")

The threshold is 96, and it is applied to the resampled pixels — thresholding the native 512×512 image gives a different result. Verified: this recipe reproduces image_binary_thr96 with 0 of 65,536 pixels differing. (§III-D of the paper prints "100" and does not mention the resize; the released data, src/miic_binarize_thr96.py and both summary.json files all use 96 after resize.)

Raw file bundles

For running the repository's scripts unchanged:

Path	Contents
`raw/miic_normal_original.tar.gz`	`normal_img/` — 1035 original JPEGs
`raw/miic_binary_thr96.tar.gz`	`preprocessed_thr96_normal/` — 1034 binarized PNGs (inputs and GT)
`raw/miic_raw_resized256.tar.gz`	`temp_resized/` — 1034 256×256 resized PNGs
`raw/outputs_binary_input.tar.gz`	binary condition: `dsl/` (1034), `rendered/` (1005), `results.json`, `summary.json`
`raw/outputs_raw_input.tar.gz`	raw condition: `dsl/` (1034), `rendered/` (1019), `results.json`, `summary.json`

hf download utsubo12/miic-netdsl-eval --repo-type dataset --local-dir data/hf_miic
mkdir -p data/miic_iad
tar xzf data/hf_miic/raw/miic_normal_original.tar.gz -C data/miic_iad
tar xzf data/hf_miic/raw/miic_binary_thr96.tar.gz    -C data/miic_iad

Caveats

Sample counts differ between conditions. The raw run covers all 1034 images (1019 executable, 98.5 %). The binary run crashed and was resumed; the resume restored the processed-names list but not the matching result objects, so its summary.json aggregates 986 samples (957 executable — the paper's 97.1 % is 957/986, not 957/1034). Table I is therefore an unpaired comparison (binary n=957, raw n=1019, intersection 946). The DSL and renderings for the dropped samples survive (dsl/ has all 1034, rendered/ has 1005), so full-set metrics can be recomputed without re-running the model: doing so gives IoU 0.3628 / Dice 0.5265 and executability 1005/1034 = 97.2 %. Rows whose binary_success is null are the 48 that never reached the aggregate, plus the corrupt test_normal_01035 described next.
test_normal_01035 is not a decodable image. The 1035th source file is corrupt; the preprocessing script skipped it silently, which is why there are 1034 ground-truth images. Its row carries the original file for completeness but has no derived images or metrics.
Generation is stochastic. Re-running inference will not reproduce these DSL strings token for token. The stable claim is the ordering — binary input beats raw input on the reported metrics.

License and provenance

The images derive from the MIIC dataset of Huang et al., ICIP 2021 (DOI 10.1109/ICIP42928.2021.9506454) and remain subject to that dataset's terms — please cite it if you use them. Redistributed here for reproducibility of the paper's evaluation. The DSL programs, renderings and metrics are original work of this paper, released under MIT.

@inproceedings{ohtsubo2026bridging,
  author    = {Ohtsubo, Yusuke and Dohi, Kota and Yawata, Koichiro and
               Takeshita, Koki and Sasaki, Tatsuya},
  title     = {Bridging the Sim-to-Real Gap in Semiconductor Visual Program
               Synthesis via Input Binarization},
  booktitle = {Proceedings of the 34th European Signal Processing Conference (EUSIPCO)},
  year      = {2026},
  publisher = {EURASIP}
}