oldoldstone / benchmark_in_de

Benchmarking Deep Learning-based Models on Nanophotonic Inverse Design Problems

This repository is the implementation of paper Benchmarking deep learning-based models on nanophotonic inverse design problems.

Introduction

1. Two inverse design tasks:

(a) Template structure: Silicon Nanorods for structural color inverse design.

This structure can be described by 4 parameters: Period (P), Diameter (D), Gap (G), and Height (H).

The optical response is reflection structural color.

(b) Freeform structure: Transmission spectrum inverse design based on the Si free-from structures.

This structure is described by a pixlated image.

The optical response is the transmission.

2. Three examined deep learning models

(b) Tandem networks

(c) Variational Auto-Encoders (VAE)

(d) Generative Adversarial Networks (GAN)

3. Three evaluation metrics

Usage

1. Load the dataset and necessary files

(1) Task 1:

The dataset is already included in the folder './tasks1_template'.

(2) Task 2:

Please download the dataset, the trained models, the predicted structures (for diversity metrics) from the google drive folder, and put it under the folder './tasks2_free_form'.

2. Simulation

All datasets are simulated using the RCWA reticolo packages in MATLAB. You can find its introduction and technical file here. We provide examples of simulating the template and free-form structures in the folder './RCWA'.

(a) How to simulate the free-form structures?

We treat the free-from structure as a 64*64 pixlated image. The Reticolo packages allow the definition of inclusions, including rectangles and ellipses. Therefore, an image can be treated as containing 64*64=4096 rectangle inclusions, where each rectangle inclusion only corresponding to one pixel. We give a code example here. Detailed can be found in the simulation files.

function texture = shape_from_img(img,n_air,n_medium,pixel_unit)
    % MATLAB function
    % Define the texture of arbitrary structures from an image 
    [a, b, width, height] = size(img);
    texture{1} = n_air;
    pixel = [];
    width_shift = width / 2;
    height_shift = height / 2;
    for i = - width_shift + 1:1:width_shift
        for j = -height_shift + 1:1:height_shift
            x = i + width_shift;
            y = j + height_shift;
            if img(1, 1, x,y) <=0.5
            # the binarization threshold
                pixel = [pixel_unit*(i-0.5),pixel_unit*(j-0.5),pixel_unit,pixel_unit,n_air,1];
            else
                pixel = [pixel_unit*(i-0.5),pixel_unit*(j-0.5),pixel_unit,pixel_unit,n_medium,1]; 
            end
            texture = [texture,pixel];
        end
    end   
end

The way to generate free-from structures is similar to this. We also give the code to generate images in file './tasks2_free_form/image_process.py'.

Cite

If you reference or cite this work in your research, please cite:

Ma TG, Tobah M, Wang HZ, Guo LJ. Benchmarking deep learning-based models on nanophotonic inverse design problems. Opto-Electron Sci 1, 210012 (2022). doi: 10.29026/oes.2022.210012

@article{ma2022benchmarking,
  title={Benchmarking deep learning-based models on nanophotonic inverse design problems},
  author={Ma, Taigao and Tobah, Mustafa and Wang, Haozhu and Guo, L Jay},
  journal={Opto-Electronic Science},
  volume={1},
  number={1},
  pages={210012--1},
  year={2022},
  publisher={Opto-Electronic Science}
}