ex1-small-area-large-range-tunable.ipynb

{"cells":[{"cell_type":"markdown","metadata":{"id":"GQTWTtpE2V7z"},"source":["# Example 1: tunable part with small area and large $\\varepsilon_r$ range\n","\n","In this example, we consider two small disk regions where the dielectric constant can be significantly varied. The goal is to design a compact 1-to-3 optical switch."]},{"cell_type":"code","source":["from google.colab import drive\n","drive.mount('/content/gdrive')\n","%cd /content/gdrive/MyDrive/research/meta-learnt-optical-switch"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"yVDpbnaFZ-5q","executionInfo":{"status":"ok","timestamp":1679709757510,"user_tz":420,"elapsed":988,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}},"outputId":"e0796e9d-7566-4f18-acdb-bb098907915c"},"execution_count":1,"outputs":[{"output_type":"stream","name":"stdout","text":["Drive already mounted at /content/gdrive; to attempt to forcibly remount, call drive.mount(\"/content/gdrive\", force_remount=True).\n","/content/gdrive/MyDrive/research/meta-learnt-optical-switch\n"]}]},{"cell_type":"code","execution_count":2,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"gaASFZyQzMQg","outputId":"69841742-de80-40dd-e2c8-8b3830e81714","executionInfo":{"status":"ok","timestamp":1679709782080,"user_tz":420,"elapsed":24574,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n","Collecting git+https://github.com/fancompute/ceviche.git\n","  Cloning https://github.com/fancompute/ceviche.git to /tmp/pip-req-build-hfmu4br2\n","  Running command git clone --filter=blob:none --quiet https://github.com/fancompute/ceviche.git /tmp/pip-req-build-hfmu4br2\n","  Resolved https://github.com/fancompute/ceviche.git to commit dcb8587c46e8e64b281004c3dee02a8ecd139721\n","  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n","Requirement already satisfied: numpy>=1.16.2 in /usr/local/lib/python3.9/dist-packages (from ceviche==0.1.3) (1.22.4)\n","Requirement already satisfied: scipy>=1.2.1 in /usr/local/lib/python3.9/dist-packages (from ceviche==0.1.3) (1.10.1)\n","Requirement already satisfied: matplotlib>=3.0.3 in /usr/local/lib/python3.9/dist-packages (from ceviche==0.1.3) (3.7.1)\n","Requirement already satisfied: autograd>=1.3 in /usr/local/lib/python3.9/dist-packages (from ceviche==0.1.3) (1.5)\n","Requirement already satisfied: pyMKL>=0.0.3 in /usr/local/lib/python3.9/dist-packages (from ceviche==0.1.3) (0.0.3)\n","Requirement already satisfied: future>=0.15.2 in /usr/local/lib/python3.9/dist-packages (from autograd>=1.3->ceviche==0.1.3) (0.18.3)\n","Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib>=3.0.3->ceviche==0.1.3) (4.39.2)\n","Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib>=3.0.3->ceviche==0.1.3) (23.0)\n","Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.9/dist-packages (from matplotlib>=3.0.3->ceviche==0.1.3) (2.8.2)\n","Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib>=3.0.3->ceviche==0.1.3) (1.0.7)\n","Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib>=3.0.3->ceviche==0.1.3) (1.4.4)\n","Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib>=3.0.3->ceviche==0.1.3) (8.4.0)\n","Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.9/dist-packages (from matplotlib>=3.0.3->ceviche==0.1.3) (0.11.0)\n","Requirement already satisfied: importlib-resources>=3.2.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib>=3.0.3->ceviche==0.1.3) (5.12.0)\n","Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib>=3.0.3->ceviche==0.1.3) (3.0.9)\n","Requirement already satisfied: zipp>=3.1.0 in /usr/local/lib/python3.9/dist-packages (from importlib-resources>=3.2.0->matplotlib>=3.0.3->ceviche==0.1.3) (3.15.0)\n","Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.9/dist-packages (from python-dateutil>=2.7->matplotlib>=3.0.3->ceviche==0.1.3) (1.16.0)\n"]}],"source":["!pip install git+https://github.com/fancompute/ceviche.git"]},{"cell_type":"code","execution_count":3,"metadata":{"id":"lKkwWHYpzXX2","executionInfo":{"status":"ok","timestamp":1679709783726,"user_tz":420,"elapsed":1652,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["import sys, os\n","sys.path.append('/Users/beicheng/Downloads/ceviche-master-original')\n","\n","import numpy as np\n","import autograd.numpy as npa\n","import pickle\n","\n","import copy\n","\n","import matplotlib as mpl\n","mpl.rcParams['figure.dpi']=100\n","\n","import matplotlib.pylab as plt\n","\n","from autograd.scipy.signal import convolve as conv\n","from skimage.draw import disk\n","from tqdm import tqdm\n","\n","import ceviche\n","from ceviche import fdfd_ez, jacobian\n","from ceviche.optimizers import adam_optimize\n","from ceviche.modes import insert_mode\n","\n","import collections\n","# Create a container for our slice coords to be used for sources and probes\n","Slice = collections.namedtuple('Slice', 'x y')"]},{"cell_type":"code","execution_count":4,"metadata":{"id":"bnldrZj_zbyX","executionInfo":{"status":"ok","timestamp":1679709783726,"user_tz":420,"elapsed":7,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["# Projection that drives rho towards a \"binarized\" design with values either 0 or 1 \n","def operator_proj(rho, eta=0.5, beta=100, N=1):\n","    \"\"\"Density projection\n","    eta     : Center of the projection between 0 and 1\n","    beta    : Strength of the projection\n","    N       : Number of times to apply the projection\n","    \"\"\"\n","    for i in range(N):\n","        rho =  npa.divide(npa.tanh(beta * eta) + npa.tanh(beta * (rho - eta)), \n","                          npa.tanh(beta * eta) + npa.tanh(beta * (1 - eta)))\n","    \n","    return rho\n","\n","# Blurring filter that results in smooth features of the structure\n","# First we define a function to create the kernel\n","def _create_blur_kernel(radius):\n","    \"\"\"Helper function used below for creating the conv kernel\"\"\"\n","#     rr, cc = circle(radius, radius, radius+1)\n","    rr, cc = disk((radius, radius), radius+1)\n","    kernel = np.zeros((2*radius+1, 2*radius+1), dtype=np.float)\n","    kernel[rr, cc] = 1\n","    return  kernel/kernel.sum()\n","\n","# Then we define the function to apply the operation\n","def operator_blur(rho, radius=2, N=1):\n","    \"\"\"Blur operator implemented via two-dimensional convolution\n","    radius    : Radius of the circle for the conv kernel filter\n","    N         : Number of times to apply the filter\n","    \n","    Note that depending on the radius, the kernel is not always a\n","    perfect circle due to \"pixelation\" / stair casing\n","    \"\"\"\n","    \n","    kernel = _create_blur_kernel(radius)\n","    \n","    for i in range(N):\n","        # For whatever reason HIPS autograd doesn't support 'same' mode, so we need to manually crop the output\n","        rho = conv(rho, kernel, mode='full')[radius:-radius,radius:-radius]\n","    \n","    return rho"]},{"cell_type":"code","execution_count":5,"metadata":{"id":"cK18zVc_0BWN","executionInfo":{"status":"ok","timestamp":1679709783726,"user_tz":420,"elapsed":5,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["directory = 'ex1/'\n","if not os.path.exists(directory):\n","    os.makedirs(directory)\n","\n","### some parameters of the tunable disk regions\n","EPS_MIN_ROD = 1-0.01 ### minimum epsilon with leeway\n","EPS_MAX_ROD = 12+0.01 ### maximum epsilon with leeway\n","R_ROD = 0.8 ### radius"]},{"cell_type":"code","execution_count":6,"metadata":{"id":"jVVV8mDW0KlU","executionInfo":{"status":"ok","timestamp":1679709783727,"user_tz":420,"elapsed":6,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["# Angular frequency of the source in 1/s\n","omega=2*np.pi*200e12\n","# Spatial resolution in meters\n","dl=40e-9\n","# Number of pixels in x-direction\n","Nx=121\n","# Number of pixels in y-direction\n","Ny=121\n","# Number of pixels in the PMLs in each direction\n","Npml=20\n","# Minimum value of the relative permittivity\n","epsr_min=1.0\n","# Maximum value of the relative permittivity\n","epsr_max=12.0\n","# Radius of the smoothening features\n","blur_radius=5\n","# Number of times to apply the blur\n","N_blur=1\n","# Strength of the binarizing projection\n","beta=500.0\n","# Middle point of the binarizing projection\n","eta=0.5\n","# Number of times to apply the blur\n","N_proj=1\n","# Space between the PMLs and the design region (in pixels)\n","space=10\n","# Width of the waveguide (in pixels)\n","wg_width=11\n","# Length in pixels of the source/probe slices on each side of the center point\n","space_slice=2\n","\n","# Number of epochs in the optimization \n","Nsteps=50\n","# Step size for the Adam optimizer\n","step_size=1e-4"]},{"cell_type":"code","execution_count":7,"metadata":{"id":"3LP5S-K-0SPB","executionInfo":{"status":"ok","timestamp":1679709783727,"user_tz":420,"elapsed":5,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["### locations of the 3 output waveguides, in units of pixels\n","output_offs = [-18,0,18]\n","def init_domain(Nx, Ny, Npml, space=10, wg_width=10, space_slice=5, offset=0):\n","    \"\"\"Initializes the domain and design region\n","\n","    space       : The space between the PML and the structure\n","    wg_width    : The feed and probe waveguide width\n","    space_slice : The added space for the probe and source slices\n","    \"\"\"\n","    rho = np.zeros((Nx, Ny))  \n","    bg_rho = np.zeros((Nx, Ny))  \n","    design_region = np.zeros((Nx, Ny))\n","    \n","    # Input waveguide\n","    bg_rho[0:int(Npml+space),Ny//2-wg_width//2:Ny//2+wg_width//2+1] = 1\n","\n","    # Input probe slice\n","    input_slice = Slice(x=np.array(Npml+1), \n","        y=np.arange(Ny//2-wg_width//2-space_slice, Ny//2+wg_width//2+space_slice+1))\n","    \n","    # Output waveguide \n","    for off in output_offs: ### now putting all 3 waveguides there\n","        bg_rho[int(Nx-Npml-space)::,Ny//2-wg_width//2-off:Ny//2+wg_width//2+1-off] = 1\n","    \n","    # Output probe slice\n","    output_slice = Slice(x=np.array(Nx-Npml-1), \n","                        y=np.arange(Ny//2-wg_width//2-space_slice-offset, Ny//2+wg_width//2+space_slice+1-offset))\n","    \n","    design_region[Npml+space:Nx-Npml-space, Npml+space:Ny-Npml-space] = 1\n","    \n","    # Const init\n","    rho[Npml+space:Nx-Npml-space, Npml+space:Ny-Npml-space] = 0.5\n","    # Random init\n","    # rho = design_region * np.random.rand(Nx, Ny)\n","\n","    return rho, bg_rho, design_region, input_slice, output_slice\n","\n","def viz_sim(epsr, source, slices=[], wantabs = False, ax_to_use=None):\n","    \"\"\"Solve and visualize a simulation with permittivity 'epsr'\n","    \"\"\"\n","    simulation = fdfd_ez(omega, dl, epsr, [Npml, Npml])\n","    Hx, Hy, Ez = simulation.solve(source)\n","    \n","    if ax_to_use is None:\n","        fig, ax = plt.subplots(1, 2, constrained_layout=True, figsize=(6,3))\n","    else:\n","        assert len(ax_to_use)>=2, \"viz_sim needs at least two axes for plotting\"\n","        ax = ax_to_use\n","    if wantabs:\n","        ceviche.viz.abs(Ez, outline=epsr, ax=ax[0], cbar=False)\n","    else:\n","        ceviche.viz.real(Ez, outline=epsr, ax=ax[0], cbar=False)\n","    for sl in slices:\n","        ax[0].plot(sl.x*np.ones(len(sl.y)), sl.y, 'b-')\n","    ceviche.viz.abs(epsr, ax=ax[1], cmap='Greys');\n","    \n","    return (simulation, ax)\n","\n","\n","def viz_abs(val, outline=None, ax=None, cbar=False, cmap='magma', outline_alpha=0.5, outline_val=None): ### copied from ceviche and customized for paper\n","    if ax is None:\n","        fig, ax = plt.subplots(1, 1, constrained_layout=True)      \n","    vmax = np.abs(val).max()\n","    h = ax.imshow(np.abs(val.T), cmap=cmap, origin='lower', vmin=0, vmax=vmax)  \n","    if outline_val is None and outline is not None: outline_val = 0.5*(outline.min()+outline.max())\n","    if outline is not None:\n","        # ax.contour(outline.T, [outline_val], colors='w', alpha=outline_alpha)\n","        ax.contour(outline.T, [outline_val], colors='yellow', alpha=outline_alpha)\n","    ax.set_ylabel('y (µm)')\n","    ax.set_xlabel(r'x (µm)')\n","    ax.set_xticks([0,40,80,119])\n","    ax.set_yticks([0,40,80,119])\n","    ax.set_xticklabels([0,1.6,3.2,4.8])\n","    ax.set_yticklabels([0,1.6,3.2,4.8])\n","    if cbar:\n","        plt.colorbar(h, ax=ax)\n","    return \n","\n","def viz_sim_for_paper(epsr, source, slices=[], wantabs = False, ax_to_use=None, different_outline = None):\n","    \"\"\"Solve and visualize a simulation with permittivity 'epsr'\n","    \"\"\"\n","    simulation = fdfd_ez(omega, dl, epsr, [Npml, Npml])\n","    Hx, Hy, Ez = simulation.solve(source)\n","    if different_outline is None:\n","        different_outline = epsr\n","    \n","    if ax_to_use is None:\n","        fig, ax = plt.subplots(1, 2, constrained_layout=True, figsize=(6,3))\n","    else:\n","        assert len(ax_to_use)>=2, \"viz_sim needs at least two axes for plotting\"\n","        ax = ax_to_use\n","    if wantabs:\n","        viz_abs(Ez, outline=different_outline, ax=ax[0], cbar=False)\n","    else:\n","        print(\"Go copy viz.real here too\")\n","    for sl in slices:\n","        ax[0].plot(sl.x*np.ones(len(sl.y)), sl.y, 'b-')\n","    viz_abs(epsr, outline=different_outline, ax=ax[1], cmap='Greys');\n","    \n","    return (simulation, ax)\n","\n","def mask_combine_rho(rho, bg_rho, design_region):\n","    \"\"\"Utility function for combining the design region rho and the background rho\n","    \"\"\"\n","    return rho*design_region + bg_rho*(design_region==0).astype(np.float)\n","\n","def mode_overlap(E1, E2):\n","    \"\"\"Defines an overlap integral between the sim field and desired field\n","    \"\"\"\n","    return npa.abs(npa.sum(npa.conj(E1)*E2))\n","def field_mag_int(E, mask):\n","    \"\"\"\n","    Computes the integral of |E|^2 over a given mask\n","\n","    Args:\n","        E: matrix containing field values\n","        mask: matrix where all entries are zero except the entries over which\n","        you would like to integrate\n","    \"\"\"\n","    return npa.abs(npa.sum(npa.multiply(npa.multiply(npa.conj(E), E), mask)))*1e6"]},{"cell_type":"code","execution_count":8,"metadata":{"id":"ZuU6Qucg0XP5","executionInfo":{"status":"ok","timestamp":1679709784054,"user_tz":420,"elapsed":332,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["def cylinders(coor_list,r_list,eps_list,domain_x=10,domain_y=10,Nx=100,Ny=100,edge_sharpness = 5e0):\n","    xs = npa.linspace(-domain_x,domain_x,Nx)\n","    ys = npa.linspace(-domain_y,domain_y,Ny)\n","    ys, xs = npa.meshgrid(ys,xs)\n","    dist = npa.zeros([Nx,Ny])\n","    mask = np.zeros([Nx, Ny])\n","    for i, coor in enumerate(coor_list):\n","        x = coor[0]\n","        y = coor[1]\n","        r = r_list[i]\n","        eps = eps_list[i]\n","        dist += (1-npa.tanh(((xs-x)**2 + (ys-y)**2 - r**2)*edge_sharpness))/2*eps\n","        mask += (1-npa.tanh(((xs-x)**2 + (ys-y)**2 - r**2)*edge_sharpness))/2\n","    return dist,mask\n","\n","def epsr_parameterization(rho, bg_rho, design_region, radius=2, N_blur=1, beta=100, eta=0.5, N_proj=1, rods=(0.,0.)):\n","    \"\"\"Defines the parameterization steps for constructing rho\n","    \"\"\"\n","    # Combine rho and bg_rho; Note: this is so the subsequent blur sees the waveguides\n","    rho = mask_combine_rho(rho, bg_rho, design_region)\n","    \n","    rho = operator_blur(rho, radius=radius, N=N_blur)\n","    rho = operator_proj(rho, beta=beta, eta=eta, N=N_proj)\n","    \n","    # Final masking undoes the blurring of the waveguides\n","    rho = mask_combine_rho(rho, bg_rho, design_region)\n","    rho2,rodmask = cylinders([(0,2),(0,-2)], [R_ROD, R_ROD], rods, Nx=rho.shape[0], Ny=rho.shape[1])\n","    return (epsr_min + (epsr_max-epsr_min) * rho) * (1-rodmask) + rho2"]},{"cell_type":"code","execution_count":9,"metadata":{"id":"HKIh8Vv30Yxz","executionInfo":{"status":"ok","timestamp":1679709784055,"user_tz":420,"elapsed":8,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["def sample_task(task_offset):\n","    global offset\n","    offset = task_offset\n","    global rho, bg_rho, design_region, input_slice, output_slice\n","    rho, bg_rho, design_region, input_slice, output_slice = \\\n","        init_domain(Nx, Ny, Npml, space=space, wg_width=wg_width, space_slice=space_slice, offset=offset)\n","    global epsr_init, source, mask_source, probe, mask_probe, mask_probe_unwanted, simulation, Ez, E0\n","    epsr_init = epsr_parameterization(rho, bg_rho, design_region, \\\n","                                  radius=blur_radius, N_blur=N_blur, beta=beta, eta=eta, N_proj=N_proj)\n","    source = insert_mode(omega, dl, input_slice.x, input_slice.y, epsr_init, m=1)\n","    mask_source = np.zeros_like(source,dtype=np.float)\n","    mask_source[source!=0]=1\n","    probe = insert_mode(omega, dl, output_slice.x, output_slice.y, epsr_init, m=1) ### differ in location\n","    mask_probe = np.zeros_like(probe,dtype=np.float)\n","    mask_probe[probe!=0]=1\n","    mask_probe_unwanted = 1-mask_probe\n","    mask_probe_unwanted[:output_slice.x,:] = 0\n","    mask_probe_unwanted[output_slice.x+1:,:] = 0\n","    source = np.abs(source)\n","    source /= source.max()\n","    probe = np.abs(probe)\n","    probe /= probe.max()"]},{"cell_type":"code","execution_count":10,"metadata":{"id":"RYXfYmuc0aa1","executionInfo":{"status":"ok","timestamp":1679709784055,"user_tz":420,"elapsed":8,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["offset = 0\n","rho, bg_rho, design_region, input_slice, output_slice = \\\n","    init_domain(Nx, Ny, Npml, space=space, wg_width=wg_width, space_slice=space_slice, offset=offset)"]},{"cell_type":"code","execution_count":11,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":548},"id":"TW0JRLgG0b5q","outputId":"59e6c4aa-625b-462b-b811-a313b5dfdc58","executionInfo":{"status":"ok","timestamp":1679709786800,"user_tz":420,"elapsed":2752,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[{"output_type":"stream","name":"stderr","text":["<ipython-input-7-3eeb74451632>:105: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  return rho*design_region + bg_rho*(design_region==0).astype(np.float)\n","<ipython-input-4-d3ec2688f742>:20: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  kernel = np.zeros((2*radius+1, 2*radius+1), dtype=np.float)\n","<ipython-input-11-eb2e938a049a>:5: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  mask_source = np.zeros_like(source,dtype=np.float)\n","<ipython-input-11-eb2e938a049a>:8: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  mask_probe = np.zeros_like(probe,dtype=np.float)\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 600x300 with 2 Axes>"],"image/png":"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\n"},"metadata":{"needs_background":"light"}}],"source":["rho_next = rho.flatten()\n","epsr_init = epsr_parameterization(rho, bg_rho, design_region, \\\n","                                  radius=blur_radius, N_blur=N_blur, beta=beta, eta=eta, N_proj=N_proj)\n","source = insert_mode(omega, dl, input_slice.x, input_slice.y, epsr_init, m=1)\n","mask_source = np.zeros_like(source,dtype=np.float)\n","mask_source[source!=0]=1\n","probe = insert_mode(omega, dl, output_slice.x, output_slice.y, epsr_init, m=1) ### differ in location\n","mask_probe = np.zeros_like(probe,dtype=np.float)\n","mask_probe[probe!=0]=1\n","source = np.abs(source)\n","source /= source.max()\n","probe = np.abs(probe)\n","probe /= probe.max()\n","### get normalization factor (field overlap before optimizing)\n","simulation, ax = viz_sim(epsr_init, source, slices=[input_slice, output_slice])\n","_, _, Ez = simulation.solve(source)\n","E0 = mode_overlap(Ez,probe)\n","E0_source = mode_overlap(Ez,source)\n","E00 = field_mag_int(Ez, mask_probe)"]},{"cell_type":"code","execution_count":12,"metadata":{"id":"vUSLfBaqNd8U","executionInfo":{"status":"ok","timestamp":1679709787022,"user_tz":420,"elapsed":228,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["wvgmask = (epsr_init>10).astype(int) ### for contour plot later"]},{"cell_type":"code","execution_count":13,"metadata":{"id":"Sf4cREAH0dQk","executionInfo":{"status":"ok","timestamp":1679709787022,"user_tz":420,"elapsed":6,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["def regularize_rho(rho, REG_SYMM = 2e5): ### shape (Nx, Ny), to maximize\n","    reg = 0\n","    ### for symmetry heuristic\n","    reg -= npa.sum(npa.square(rho-rho[:,::-1])) / len(rho.flatten()) * REG_SYMM\n","    ### pushing rho away from eta, !!! turn on or off\n","    # reg -= npa.sum(npa.exp(-npa.square(rho.flatten()-eta)/0.01)) / len(rho.flatten()) * REG_BINARIZATION  ### will be changed globally\n","    return reg\n","\n","def objective(rho):\n","    rho = rho.reshape((Nx, Ny))\n","    epsr = epsr_parameterization(rho, bg_rho, design_region, \\\n","                             radius=blur_radius, N_blur=N_blur, beta=beta, eta=eta, N_proj=N_proj, rods=rods_dict[offset])\n","    simulation.eps_r = epsr\n","    _, _, Ez = simulation.solve(source)\n","    ### feel free to try mode_overlap and field_mag_int in different combinations\n","    return mode_overlap(Ez, probe) / E0 - field_mag_int(Ez, mask_probe_unwanted) / E00  +\\\n","            regularize_rho(rho)\n","objective_jac = jacobian(objective, mode='reverse')\n","\n","def objective_all(rho): ### pooling all tasks\n","    res = 0\n","    ### simple sum\n","    # for offset in task_offsets:\n","    #     sample_task(offset)\n","    #     res += objective(rho)\n","    # return res / len(task_offsets)\n","    ### softmin\n","    for offset in task_offsets:\n","        sample_task(offset)\n","        res += npa.exp(-objective(rho))\n","    return -npa.log(res) / len(task_offsets)\n","objective_all_jac = jacobian(objective_all, mode='reverse')\n","\n","def regularize_rod(rods, slope=200, left=EPS_MIN_ROD, right=EPS_MAX_ROD): ### objective to maximize, !!! tune slope\n","    return npa.sum(- npa.exp((left-rods)*slope) - npa.exp((rods-right)*slope)) ### keeping rods within eps range\n","\n","def objective_rod(rods):\n","    epsr = epsr_parameterization(rho_next.reshape((Nx, Ny)), bg_rho, design_region, \\\n","                             radius=blur_radius, N_blur=N_blur, beta=beta, eta=eta, N_proj=N_proj, rods=rods.flatten())\n","    simulation.eps_r = epsr\n","    _, _, Ez = simulation.solve(source)\n","    ### feel free to try mode_overlap and field_mag_int in different combinations\n","    return mode_overlap(Ez, probe) / E0 - field_mag_int(Ez, mask_probe_unwanted) / E00 +\\\n","            regularize_rod(rods)\n","objective_jac_rod = jacobian(objective_rod, mode='reverse')\n"]},{"cell_type":"code","execution_count":14,"metadata":{"id":"4VG1ZGYW0efJ","executionInfo":{"status":"ok","timestamp":1679709787022,"user_tz":420,"elapsed":6,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["task_offsets = output_offs\n","losses = {}\n","losses_short = {} ### 1 pt for each epoch\n","losses_rods = {}\n","rods_dict = {}\n","for task_offset in task_offsets:\n","    losses[task_offset] = []\n","    losses_short[task_offset] = []\n","    losses_rods[task_offset] = []\n","    rods_dict[task_offset] = np.array([1.,1.])*0.5*(EPS_MIN_ROD+EPS_MAX_ROD)\n","task_ids = []\n","REG_BINARIZATION=0\n","Nsteps_inner = 2\n","Nsteps_outer = 2"]},{"cell_type":"code","execution_count":23,"metadata":{"id":"Ii8bgV3Y0fm3","executionInfo":{"status":"ok","timestamp":1679710750679,"user_tz":420,"elapsed":151,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["def train_a_while(reptile_stepsize, nepochs):\n","    global rho_next\n","    for i_outer in tqdm(range(nepochs)):\n","        for task_offset in task_offsets:\n","            sample_task(task_offset)\n","            # Maximize the objective function using an ADAM optimizer\n","            (rods_new, loss_rods) = adam_optimize(objective_rod, rods_dict[task_offset], objective_jac_rod,\n","                                Nsteps=Nsteps_inner, direction='max', step_size=step_size*200,verbose=False) ### give it a boost, as informed by losss curve\n","            rods_dict[task_offset] = rods_new.flatten()\n","            losses_rods[task_offset]+=loss_rods\n","            losses_short[task_offset].append(loss_rods[-1])\n","        (rho_new, loss) = adam_optimize(objective_all, rho_next, objective_all_jac,\n","                             Nsteps=Nsteps_outer, direction='max', step_size=step_size,verbose=False)\n","        rho_next += (rho_new.flatten()-rho_next)*reptile_stepsize\n","        losses[0]+=loss\n","def check_structure(rho, beta_scaling = 1, fname = None, offsets = [0]): ## set beta_scaling to 100 to fully binarize\n","    rho = rho.reshape((Nx, Ny))\n","    for io, offset in enumerate(offsets):\n","        sample_task(offset)\n","        epsr = epsr_parameterization(rho, bg_rho, design_region, \\\n","                                radius=blur_radius, N_blur=N_blur, beta=beta*beta_scaling, eta=eta, N_proj=N_proj, rods=rods_dict[offset])\n","        if fname is not None:\n","            fig, ax = plt.subplots(1,2,figsize=[7,3])\n","            viz_sim(epsr, source, slices=[input_slice, output_slice],wantabs=True, ax_to_use = ax);\n","            fig.savefig(directory+f'{fname}_{io}.png')\n","        else:\n","            viz_sim(epsr, source, slices=[input_slice, output_slice],wantabs=True);\n","        if fname is not None:\n","            plt.close('all')\n","def check_structure_for_paper(rho, beta_scaling = 1, fname = None, offsets = [0]): ## modified version for paper plot\n","    rho = rho.reshape((Nx, Ny))\n","    for io, offset in enumerate(offsets):\n","        sample_task(offset)\n","        epsr = epsr_parameterization(rho, bg_rho, design_region, \\\n","                                radius=blur_radius, N_blur=N_blur, beta=beta*beta_scaling, eta=eta, N_proj=N_proj, rods=rods_dict[offset])\n","        ### get the rods, for contour only\n","        _,rodmask = cylinders([(0,2),(0,-2)], [R_ROD, R_ROD], rods_dict[offset], Nx=rho.shape[0], Ny=rho.shape[1])\n","        if fname is not None:\n","            fig, ax = plt.subplots(1,2,figsize=[6,2.5])\n","            viz_sim_for_paper(epsr, source, slices=[input_slice, output_slice],wantabs=True, ax_to_use = ax, different_outline=rodmask + wvgmask);\n","            fig.savefig(directory+f'{fname}_{io}.png', bbox_inches='tight', dpi=400, transparent=True)\n","        else:\n","            viz_sim_for_paper(epsr, source, slices=[input_slice, output_slice],wantabs=True);\n","        if fname is not None:\n","            plt.close('all')\n","def check_loss(nepochs,every=1,fname=None):\n","    fig,axs = plt.subplots(1,2, figsize=[7,2])\n","    for offset in task_offsets:\n","        tmp = -np.array(losses[offset]) ### was objective function, now loss function\n","        axs[0].plot(tmp[-nepochs::every],label=f'task {offset}')\n","    axs[0].legend()\n","    axs[0].set_title('losses')\n","    for offset in task_offsets:\n","        tmp = -np.array(losses_rods[offset]) ### was objective function, now loss function\n","        axs[1].plot(tmp[-nepochs::every],label=f'task {offset}')\n","    axs[1].legend()\n","    axs[1].set_title('losses rods')\n","    plt.tight_layout()\n","    if fname is None:\n","        plt.show()\n","    else:\n","        fig.savefig(directory+fname+'.png')\n","\n","def saveall():\n","    np.array(rho_next).dump(directory+'rho_next.pkl')\n","    with open(directory+'rods_dict.pkl', 'wb') as handle:\n","        pickle.dump(rods_dict, handle, protocol=pickle.HIGHEST_PROTOCOL)\n","    np.array(losses[0]).dump(directory+'losses.pkl')\n","    for offset in task_offsets:\n","        np.array(losses_rods[offset]).dump(directory+f'losses_rods_{offset}.pkl')\n","def loadall():\n","    rho_next = np.load(directory+'rho_next.pkl',allow_pickle=True)\n","    with open(directory+'rods_dict.pkl', 'rb') as handle:\n","        rods_dict = pickle.load(handle)\n","    losses = [np.load(directory+'losses.pkl',allow_pickle=True)]\n","    losses_rods = {}\n","    for offset in task_offsets:\n","        losses_rods[offset] = np.load(directory+f'losses_rods_{offset}.pkl',allow_pickle=True)\n","    return rho_next, rods_dict, losses, losses_rods"]},{"cell_type":"code","execution_count":24,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":522},"id":"brFignV60lDK","outputId":"d8dfb943-4a66-4f07-8300-4910a9406025","executionInfo":{"status":"ok","timestamp":1679711878067,"user_tz":420,"elapsed":1126547,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[{"output_type":"stream","name":"stderr","text":["\r  0%|          | 0/40 [00:00<?, ?it/s]<ipython-input-7-3eeb74451632>:105: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  return rho*design_region + bg_rho*(design_region==0).astype(np.float)\n","<ipython-input-4-d3ec2688f742>:20: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  kernel = np.zeros((2*radius+1, 2*radius+1), dtype=np.float)\n","<ipython-input-9-b8da0bb49672>:11: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  mask_source = np.zeros_like(source,dtype=np.float)\n","<ipython-input-9-b8da0bb49672>:14: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  mask_probe = np.zeros_like(probe,dtype=np.float)\n","100%|██████████| 40/40 [03:48<00:00,  5.72s/it]\n","100%|██████████| 40/40 [03:39<00:00,  5.50s/it]\n","100%|██████████| 40/40 [03:43<00:00,  5.59s/it]\n","100%|██████████| 40/40 [03:47<00:00,  5.68s/it]\n","100%|██████████| 40/40 [03:36<00:00,  5.41s/it]\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 700x200 with 2 Axes>"],"image/png":"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\n"},"metadata":{"needs_background":"light"}}],"source":["for i in range(1,6):\n","    train_a_while(1.0,40)\n","    check_structure(rho_next, offsets = task_offsets, fname=f'struct_0.5_{100*i}')\n","    check_loss(1000, fname=f'loss_0.5_{100*i}')"]},{"cell_type":"code","execution_count":25,"metadata":{"id":"LvGxpY6F0pna","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1679713006311,"user_tz":420,"elapsed":1128247,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}},"outputId":"35fcdd9f-e12d-46c3-f542-1530ed7bbe32"},"outputs":[{"output_type":"stream","name":"stderr","text":["\r  0%|          | 0/10 [00:00<?, ?it/s]<ipython-input-7-3eeb74451632>:105: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  return rho*design_region + bg_rho*(design_region==0).astype(np.float)\n","<ipython-input-4-d3ec2688f742>:20: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  kernel = np.zeros((2*radius+1, 2*radius+1), dtype=np.float)\n","<ipython-input-9-b8da0bb49672>:11: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  mask_source = np.zeros_like(source,dtype=np.float)\n","<ipython-input-9-b8da0bb49672>:14: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  mask_probe = np.zeros_like(probe,dtype=np.float)\n","100%|██████████| 10/10 [00:53<00:00,  5.37s/it]\n","100%|██████████| 10/10 [00:55<00:00,  5.56s/it]\n","100%|██████████| 10/10 [00:51<00:00,  5.20s/it]\n","100%|██████████| 10/10 [00:56<00:00,  5.62s/it]\n","100%|██████████| 10/10 [00:54<00:00,  5.41s/it]\n","  0%|          | 0/10 [00:00<?, ?it/s]/usr/local/lib/python3.9/dist-packages/autograd/numpy/numpy_vjps.py:90: RuntimeWarning: overflow encountered in square\n","  defvjp(anp.tanh,   lambda ans, x : lambda g: g / anp.cosh(x) **2)\n","100%|██████████| 10/10 [00:52<00:00,  5.24s/it]\n","100%|██████████| 10/10 [00:58<00:00,  5.83s/it]\n","100%|██████████| 10/10 [00:53<00:00,  5.35s/it]\n","100%|██████████| 10/10 [00:52<00:00,  5.21s/it]\n","100%|██████████| 10/10 [00:54<00:00,  5.50s/it]\n","100%|██████████| 10/10 [00:54<00:00,  5.47s/it]\n","100%|██████████| 10/10 [00:55<00:00,  5.56s/it]\n","100%|██████████| 10/10 [00:55<00:00,  5.55s/it]\n","100%|██████████| 10/10 [00:52<00:00,  5.26s/it]\n","100%|██████████| 10/10 [00:54<00:00,  5.48s/it]\n","100%|██████████| 10/10 [00:58<00:00,  5.86s/it]\n","100%|██████████| 10/10 [00:52<00:00,  5.24s/it]\n","100%|██████████| 10/10 [00:53<00:00,  5.31s/it]\n","100%|██████████| 10/10 [00:56<00:00,  5.67s/it]\n","  0%|          | 0/10 [00:00<?, ?it/s]/usr/local/lib/python3.9/dist-packages/autograd/tracer.py:48: RuntimeWarning: overflow encountered in cosh\n","  return f_raw(*args, **kwargs)\n","100%|██████████| 10/10 [00:53<00:00,  5.38s/it]\n"]}],"source":["for beta in range(500,1500,50):\n","    train_a_while(1.0,10)\n","    check_structure(rho_next, offsets = task_offsets, fname = f'cool_down_{beta}_1_1.0')"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"D3YqjwZPrD28"},"outputs":[],"source":["saveall()\n","loadall()"]},{"cell_type":"code","execution_count":27,"metadata":{"id":"uKHt9Fuw15JJ","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1679713010900,"user_tz":420,"elapsed":3026,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}},"outputId":"259bba86-82e6-4700-f6e8-3d0b16598a6d"},"outputs":[{"output_type":"stream","name":"stderr","text":["<ipython-input-7-3eeb74451632>:105: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  return rho*design_region + bg_rho*(design_region==0).astype(np.float)\n","<ipython-input-4-d3ec2688f742>:20: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  kernel = np.zeros((2*radius+1, 2*radius+1), dtype=np.float)\n","<ipython-input-9-b8da0bb49672>:11: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  mask_source = np.zeros_like(source,dtype=np.float)\n","<ipython-input-9-b8da0bb49672>:14: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  mask_probe = np.zeros_like(probe,dtype=np.float)\n"]}],"source":["rho_next, rods_dict, losses, losses_rods = loadall()\n","check_structure_for_paper(rho_next, offsets = task_offsets, fname=f'struct_final')"]},{"cell_type":"code","execution_count":27,"metadata":{"id":"64AnCoXVZ7Nb","executionInfo":{"status":"ok","timestamp":1679713010900,"user_tz":420,"elapsed":3,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":[]}],"metadata":{"colab":{"provenance":[]},"kernelspec":{"display_name":"Python 3","name":"python3"},"language_info":{"name":"python"}},"nbformat":4,"nbformat_minor":0}