---
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](https://huggingface.co/utsubo12/qwen3-vl-8b-netdsl-l2)
- 🧪 Synthetic training data: [utsubo12/netdsl-l2-synthetic-sem](https://huggingface.co/datasets/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.

```python
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:

```python
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**:

```python
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` |

```bash
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

1. **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.

2. **`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.

3. **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](https://doi.org/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.

```bibtex
@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}
}
```