{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Building an AI surrogate model for a directional coupler" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Note: the cost of running the entire notebook is higher than 2 FlexCredits. It also requires at least tidy3d version 2.8 to run. To run the notebook, you will need pytorch installed ([pytorch information](https://pytorch.org)). The notebook has been tested with pytorch version 2.5.1.**\n", "\n", "In this notebook, we build a machine learning model of a directional coupler (DC) that splits power from an incoming waveguide into two output waveguides. Using the surrogate model, we design a DC with a 75/25 splitting ratio. This coupling optimization boils down to choosing the gap size `wg_spacing_coup` and coupling length `coup_length` of the DC.\n", "\n", "Through the machine learning training process, we demonstrate how tidy3d can be used as a data source when training AI models for electromagnetics. We first run a batch of simulations with tidy3d where the two geometric parameters are randomly sampled for each simulation. A mode is injected into one waveguide and monitors on both waveguides characterize the final power split between the two outputs. From this, we define a fitness function describing the performance of a given directional coupler. We define the fitness as the mean squared error between desired output power in each waveguide and actual power. The desired output power fractions are 0.25 and 0.75 in the top and bottom waveguides, respectively. By plotting the fitness function, we can observe that we have found a variety of suitable solutions to the coupling problem. We have also collected a significant amount of data that can be used as input to a data driven model of the coupling. We use the broadband simulation data collected in the first step to train a fully connected neural network. The network is optimized to learn the mapping between the waveguide spacing, coupling length, and input frequency to the power fraction in the two output waveguides. We refer to this network as a surrogate solver because we can now use it as an approximate substitute for the full electromagnetic simulation. The final step of the optimization uses this surrogate solver inside of a Bayesian optimization routine to identify a more optimal set of parameters for the directional coupler. With this set of parameters, we can use tidy3d to run a final verification of the design and evaluate the fidelity of the surrogate solver when compared to ground truth simulation results. The general flow of the notebook is shown in the diagram below.\n", "\n", "
\"diagram\"
" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# Standard python and external package imports\n", "import pickle\n", "from pathlib import Path\n", "\n", "import gdstk\n", "import matplotlib.colors as mcolors\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "# tidy3D imports\n", "import tidy3d as td\n", "import tidy3d.plugins.design as tdd\n", "import torch\n", "import torch.nn as nn\n", "import torch.optim as optim\n", "from tidy3d import web\n", "from torch.utils.data import DataLoader" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The first step in the design process will be to generate a dataset of simulation data for randomly sampled geometric parameters for the directional coupler. This part sets up a place to save the simulation data and the option to reuse it if you've already run through the notebook." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# Configure notebook options for reusing simulation data if it exists\n", "use_previous_simulation_data = False\n", "\n", "output_dir = Path(\"./misc/dc_surrogate/\")\n", "mc_data_dir = output_dir / \"data\"\n", "mc_data_dir.mkdir(parents=True, exist_ok=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Simulation Setup\n", "\n", "Before running simulations, we need to set up general parameters that will remain unchanged for all of the simulations. We set up the desired frequency range to use, optical constants for the materials in the coupler, and parameters controlling fixed aspects of the coupler geometry. Finally, we specify the bounds for the parameters we will sample to create the training dataset." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# Wavelength / frequency\n", "lambda0 = 1.550 # all length scales in microns\n", "freq0 = td.constants.C_0 / lambda0\n", "fwidth = freq0 / 10\n", "ldas = np.linspace(1.5, 1.6, 101) # wavelength range\n", "freqs = td.C_0 / ldas # frequency range\n", "\n", "# Permittivity of waveguide and substrate\n", "wg_n = 3.48\n", "sub_n = 1.45\n", "mat_wg = td.Medium(permittivity=wg_n**2)\n", "mat_sub = td.Medium(permittivity=sub_n**2)\n", "\n", "# Waveguide dimensions\n", "\n", "# Waveguide height\n", "wg_height = 0.22\n", "# Waveguide width\n", "wg_width = 0.45\n", "# Waveguide separation in the beginning/end\n", "wg_spacing_in = 8\n", "# Reference plane where the cross section of the device is defined\n", "reference_plane = \"bottom\"\n", "# Angle of the sidewall deviating from the vertical ones, positive values for the base larger than the top\n", "sidewall_angle = np.pi / 20.0\n", "# Total device length along propagation direction\n", "device_length = 100\n", "# Length of the bend region\n", "bend_length = 16\n", "# space between waveguide and PML\n", "pml_spacing = 1\n", "# resolution control: minimum number of grid cells per wavelength in each material\n", "grid_cells_per_wvl = 16\n", "\n", "# Coupler optimization parameter ranges to consider\n", "wg_spacing_coup_range = (0.05, 0.25)\n", "coup_length_range = (2, 16)\n", "top_waveguide_transmission_goal = 0.25\n", "bottom_waveguide_transmission_goal = 0.75\n", "\n", "# Optimization parameters\n", "num_monte_carlo_sims = 100\n", "\n", "filename_mc_data = mc_data_dir / f\"result_{num_monte_carlo_sims}.pkl\"\n", "if not filename_mc_data.exists() and use_previous_simulation_data:\n", " print(\n", " \"Warning, MC simulation data does not exist to be loaded. Reconfiguring use_previous_simulation_data flag to False and recomputing.\"\n", " )\n", " use_previous_simulation_data = False" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We now add functions to create the directional coupler in a tidy3d simulation. Each coupler from the Monte Carlo sweep will have a different waveguide spacing and coupler length. These are created as tidy3d objects in the `make_coupler` function." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "def tanh_interp(max_arg):\n", " \"\"\"Interpolator for tanh with adjustable extension\"\"\"\n", " scale = 1 / np.tanh(max_arg)\n", " return lambda u: 0.5 * (1 + scale * np.tanh(max_arg * (u * 2 - 1)))\n", "\n", "\n", "def make_coupler(\n", " length,\n", " wg_spacing_in,\n", " wg_width,\n", " wg_spacing_coup,\n", " coup_length,\n", " bend_length,\n", "):\n", " \"\"\"Make an integrated coupler using the gdstk RobustPath object.\"\"\"\n", " # bend interpolator\n", " interp = tanh_interp(3)\n", " delta = wg_width + wg_spacing_coup - wg_spacing_in\n", " offset = lambda u: wg_spacing_in + interp(u) * delta\n", "\n", " coup = gdstk.RobustPath(\n", " (-0.5 * length, 0),\n", " (wg_width, wg_width),\n", " wg_spacing_in,\n", " simple_path=True,\n", " layer=1,\n", " datatype=[0, 1],\n", " )\n", " coup.segment((-0.5 * coup_length - bend_length, 0))\n", " coup.segment(\n", " (-0.5 * coup_length, 0),\n", " offset=[lambda u: -0.5 * offset(u), lambda u: 0.5 * offset(u)],\n", " )\n", " coup.segment((0.5 * coup_length, 0))\n", " coup.segment(\n", " (0.5 * coup_length + bend_length, 0),\n", " offset=[lambda u: -0.5 * offset(1 - u), lambda u: 0.5 * offset(1 - u)],\n", " )\n", " coup.segment((0.5 * length, 0))\n", " return coup" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `make_sim` function below sets up the full simulation in tidy3d for a user specified coupler length and waveguide spacing. It uses the `make_coupler` function above to create the geometry and adds mode sources to inject into the input waveguide and mode monitors to measure outputs from each waveguide. The DC simulation setup process follows this previous [tutorial](https://www.flexcompute.com/tidy3d/examples/notebooks/GDSImport/)." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "def make_sim(coup_length, wg_spacing_coup, add_field_monitor=False):\n", " \"\"\"Make a simulation with a given length of the coupling region and\n", " distance between the waveguides in that region. If ``add_field_monitor``\n", " is True, a 2D in-plane field monitor will be added.\n", " \"\"\"\n", "\n", " # Geometry must be placed in GDS cells to import into Tidy3D\n", " coup_cell = gdstk.Cell(\"Coupler\")\n", "\n", " substrate = gdstk.rectangle(\n", " (-device_length / 2, -wg_spacing_in / 2 - 10),\n", " (device_length / 2, wg_spacing_in / 2 + 10),\n", " layer=0,\n", " )\n", " coup_cell.add(substrate)\n", "\n", " # Add the coupler to a gdstk cell\n", " gds_coup = make_coupler(\n", " device_length,\n", " wg_spacing_in,\n", " wg_width,\n", " wg_spacing_coup,\n", " coup_length,\n", " bend_length,\n", " )\n", " coup_cell.add(gds_coup)\n", "\n", " # Substrate\n", " (oxide_geo,) = td.PolySlab.from_gds(\n", " gds_cell=coup_cell,\n", " gds_layer=0,\n", " gds_dtype=0,\n", " slab_bounds=(-10, 0),\n", " reference_plane=reference_plane,\n", " axis=2,\n", " )\n", "\n", " oxide = td.Structure(geometry=oxide_geo, medium=mat_sub)\n", "\n", " # Waveguides (import all datatypes if gds_dtype not specified)\n", " coupler1_geo, coupler2_geo = td.PolySlab.from_gds(\n", " gds_cell=coup_cell,\n", " gds_layer=1,\n", " slab_bounds=(0, wg_height),\n", " sidewall_angle=sidewall_angle,\n", " reference_plane=reference_plane,\n", " axis=2,\n", " )\n", "\n", " coupler1 = td.Structure(geometry=coupler1_geo, medium=mat_wg)\n", " coupler2 = td.Structure(geometry=coupler2_geo, medium=mat_wg)\n", "\n", " # Simulation size along propagation direction\n", " sim_length = 2 + 2 * bend_length + coup_length\n", "\n", " # Spacing between waveguides and PML\n", " sim_size = [\n", " sim_length,\n", " wg_spacing_in + wg_width + 2 * pml_spacing,\n", " wg_height + 2 * pml_spacing,\n", " ]\n", "\n", " # Source\n", " src_pos = -sim_length / 2 + 0.5\n", " msource = td.ModeSource(\n", " center=[src_pos, wg_spacing_in / 2, wg_height / 2],\n", " size=[0, 3, 2],\n", " source_time=td.GaussianPulse(freq0=freq0, fwidth=fwidth),\n", " direction=\"+\",\n", " mode_spec=td.ModeSpec(num_modes=1),\n", " mode_index=0,\n", " )\n", "\n", " mon_in = td.ModeMonitor(\n", " center=[(src_pos + 0.5), wg_spacing_in / 2, wg_height / 2],\n", " size=[0, 3, 2],\n", " freqs=freqs,\n", " mode_spec=td.ModeSpec(num_modes=1),\n", " name=\"in\",\n", " )\n", " mon_ref_bot = td.ModeMonitor(\n", " center=[(src_pos + 0.5), -wg_spacing_in / 2, wg_height / 2],\n", " size=[0, 3, 2],\n", " freqs=freqs,\n", " mode_spec=td.ModeSpec(num_modes=1),\n", " name=\"reflect_bottom\",\n", " )\n", " mon_top = td.ModeMonitor(\n", " center=[-(src_pos + 0.5), wg_spacing_in / 2, wg_height / 2],\n", " size=[0, 3, 2],\n", " freqs=freqs,\n", " mode_spec=td.ModeSpec(num_modes=1),\n", " name=\"top\",\n", " )\n", " mon_bot = td.ModeMonitor(\n", " center=[-(src_pos + 0.5), -wg_spacing_in / 2, wg_height / 2],\n", " size=[0, 3, 2],\n", " freqs=freqs,\n", " mode_spec=td.ModeSpec(num_modes=1),\n", " name=\"bottom\",\n", " )\n", " monitors = [mon_in, mon_ref_bot, mon_top, mon_bot]\n", "\n", " if add_field_monitor:\n", " field_monitor = td.FieldMonitor(\n", " center=[0, 0, wg_height / 2],\n", " size=[td.inf, td.inf, 0],\n", " freqs=freqs,\n", " name=\"field\",\n", " )\n", " monitors.append(field_monitor)\n", "\n", " # Initialize the simulation\n", " sim = td.Simulation(\n", " size=sim_size,\n", " grid_spec=td.GridSpec.auto(min_steps_per_wvl=grid_cells_per_wvl),\n", " structures=[oxide, coupler1, coupler2],\n", " sources=[msource],\n", " monitors=monitors,\n", " run_time=50 / fwidth,\n", " boundary_spec=td.BoundarySpec.all_sides(boundary=td.PML()),\n", " )\n", "\n", " return sim" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Below, we visualize an example grating coupler for a fixed coupling length and waveguide spacing." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "scrolled": true }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Length of the coupling region\n", "coup_length = 10\n", "\n", "# Waveguide separation in the coupling region\n", "wg_spacing_coup = 0.10\n", "\n", "sim = make_sim(coup_length, wg_spacing_coup, add_field_monitor=True)\n", "\n", "# Visualize geometry\n", "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 4))\n", "sim.plot(z=wg_height / 2 + 0.01, ax=ax1)\n", "sim.plot(x=0.1, ax=ax2)\n", "ax2.set_xlim([-3, 3])\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Design Space Exploration\n", "In this section, we take advantage of the simplicity of the tidy3d design plugin to generate a Monte Carlo search over the geometric parameters of the coupler. The design plugin allows us to easily run optimizations that consider a set of user defined variables as optimization parameters. In this case, we leverage the plugin to generate a randomly sampled set of data that we can later use to train the neural network surrogate model. To do this, we set up the parameter names we are considering along with the ranges to sample values from for each. Then, we create a `MethodMonteCarlo` to specify the number of samples to evaluate and a `DesignSpace` to facilitate the running of the Monte Carlo method. Finally, we write a function, `fn_post` that will be used to postprocess the data from each from each simulation run. In this function, we use the above `measure_coupling_amplitude` function to collect the power flowing into all of the waveguide monitor ports. A tutorial on the design plugin can be found [here](https://www.flexcompute.com/tidy3d/examples/notebooks/Design/). " ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# Set up the parameters we want to sweep in the Monte Carlo search\n", "param_spc = tdd.ParameterFloat(name=\"wg_spacing_coup\", span=wg_spacing_coup_range)\n", "param_len = tdd.ParameterFloat(name=\"coup_length\", span=coup_length_range)\n", "parameters = [param_spc, param_len]\n", "\n", "monte_carlo = tdd.MethodMonteCarlo(\n", " num_points=num_monte_carlo_sims,\n", " seed=2,\n", ")\n", "design_space = tdd.DesignSpace(\n", " method=monte_carlo,\n", " parameters=parameters,\n", " task_name=\"DC_MC_Surrogate\",\n", " path_dir=str(mc_data_dir),\n", ")\n", "\n", "\n", "def measure_coupling_amplitude(sim_data):\n", " \"\"\"Constructs a \"row\" of the scattering matrix when sourced from top left port\"\"\"\n", "\n", " input_amp = sim_data[\"in\"].amps.sel(direction=\"+\")\n", "\n", " amps_dict = {}\n", " directions = (\"-\", \"-\", \"+\", \"+\")\n", " for monitor, direction in zip(sim_data.simulation.monitors[:4], directions):\n", " amp = sim_data[monitor.name].amps.sel(direction=direction)\n", " amp_normalized = amp / input_amp\n", " amps_dict[monitor.name] = amp_normalized\n", "\n", " return amps_dict\n", "\n", "\n", "def fn_post(*args, **kwargs):\n", " \"\"\"Post processing function, but label the outputs using a dictionary.\"\"\"\n", " amps_dict = measure_coupling_amplitude(*args, **kwargs)\n", " return amps_dict" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here, we run the Monte Carlo simulations or load previous simulation data from a past run through the notebook. If the simulations are run again, we overwrite the simulation data file to be loaded again in the future. By setting the `use_previous_simulation_data` flag, you can opt to use past data or rerun the simulations. If any of the parameters controlling the general geometry or number of simulations are changed, you should rerun the simulations to ensure they are accurate for the result of the notebook." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
20:00:27 CEST Running 100 Simulations                                           \n",
       "
\n" ], "text/plain": [ "\u001b[2;36m20:00:27 CEST\u001b[0m\u001b[2;36m \u001b[0mRunning \u001b[1;36m100\u001b[0m Simulations \n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "if use_previous_simulation_data:\n", " with open(filename_mc_data, \"rb\") as in_file:\n", " results = pickle.load(in_file)\n", " df = results.to_dataframe()\n", "else:\n", " results = design_space.run(make_sim, fn_post, verbose=True)\n", " df = results.to_dataframe()\n", "\n", " with open(filename_mc_data, \"wb\") as out_file:\n", " pickle.dump(results, out_file)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can plot the fitness for each set of randomly sampled geometric parameters in the Monte Carlo batch of simulations. Better performing designs correspond to a larger fitness function with a maximum value of 0. In the plot, the points are colored according to their fitness value. The fitness function is the mean squared error between the desired output power fraction into each of the two waveguides and the actual output power fraction computed from the simulation results. In this example, we set the desired power fraction to 0.25/0.75 for top/bottom waveguides. However, this notebook can be re-run with a variety of different splitting ratios by changing the `top_waveguide_transmission_goal` and `bottom_waveguide_transmission_goal` parameters. We can see from this plot that several randomly selected points correspond to acceptable performances in our metric. The data collected in this first step will become the training data for a surrogate model of the coupling problem. We will use the surrogate model as an input to further optimization to see if we can discover even better designs than the ones we found via random sampling." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The best fitness value is -0.0004619891447938993 corresponding to:\n", "MC Top waveguide transmission: 0.262, Bottom waveguide transmission: 0.732\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "top_center_freq = abs(df[\"top\"].apply(lambda x: x.sel(f=freq0, method=\"nearest\"))) ** 2\n", "bot_center_freq = abs(df[\"bottom\"].apply(lambda x: x.sel(f=freq0, method=\"nearest\"))) ** 2\n", "\n", "\n", "# Compute MSE error function for fitness\n", "def fitness(top_wg_power, bottom_wg_power):\n", " return -(\n", " abs(top_wg_power - top_waveguide_transmission_goal) ** 2\n", " + abs(bottom_wg_power - bottom_waveguide_transmission_goal) ** 2\n", " )\n", "\n", "\n", "fitness_val = fitness(top_center_freq, bot_center_freq)\n", "list_fitness = [float(np.squeeze(val.data)) for val in fitness_val]\n", "\n", "best_fitness = np.max(fitness_val)\n", "best_fitness_location = np.argmax(fitness_val)\n", "best_top_power_mc = np.squeeze(top_center_freq[best_fitness_location].data)\n", "best_bottom_power_mc = np.squeeze(bot_center_freq[best_fitness_location].data)\n", "print(f\"The best fitness value is {np.squeeze(best_fitness.data)} corresponding to:\")\n", "print(\n", " f\"MC Top waveguide transmission: {np.round(best_top_power_mc, 3)}, Bottom waveguide transmission: {np.round(best_bottom_power_mc, 3)}\"\n", ")\n", "\n", "scatter = plt.scatter(df[\"wg_spacing_coup\"], df[\"coup_length\"], c=list_fitness)\n", "plt.xlabel(\"wg_spacing_coup\")\n", "plt.ylabel(\"coup_length\")\n", "plt.title(\"Fitness\")\n", "plt.colorbar(scatter)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Neural Network Surrogate Model\n", "\n", "We can now leverage the Monte Carlos data we collected from tidy3d simulation. First, we clean and prepare the dataset for use in training a neural network surrogate model. The inputs to the model are the waveguide spacing (`wg_spacing_coup`), the coupling length (`coup_length`), and the frequency (`freq`). In optimizing the model, we aim to find the connection between these inputs and the output power fractions in the top and bottom waveguides (`top` and `bottom`)." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Monte Carlo data for training the neural network surrogate model\n", " wg_spacing_coup coup_length freq top bottom\n", "0 0.137477 14.698211 1.998616e+14 0.223059 0.771090\n", "1 0.137477 14.698211 1.997285e+14 0.218406 0.775767\n", "2 0.137477 14.698211 1.995955e+14 0.213763 0.780423\n", "3 0.137477 14.698211 1.994627e+14 0.209135 0.785061\n", "4 0.137477 14.698211 1.993301e+14 0.204506 0.789673\n", "... ... ... ... ... ...\n", "10095 0.055433 3.331761 1.878399e+14 0.014354 0.979565\n", "10096 0.055433 3.331761 1.877223e+14 0.012926 0.981028\n", "10097 0.055433 3.331761 1.876048e+14 0.011567 0.982425\n", "10098 0.055433 3.331761 1.874875e+14 0.010278 0.983722\n", "10099 0.055433 3.331761 1.873703e+14 0.009060 0.984942\n", "\n", "[10100 rows x 5 columns]\n" ] } ], "source": [ "expanded_df = df.copy()\n", "# Removing the input and reflection amplitudes because we will run the\n", "# neural network optimization only over the output waveguide amplitudes\n", "# and thus assume reflected power is negligible.\n", "expanded_df.drop(\"in\", axis=1, inplace=True)\n", "expanded_df.drop(\"reflect_bottom\", axis=1, inplace=True)\n", "\n", "# Expand out multiple entries for top and bottom and re-index the dataframe.\n", "# then, we can add the frequency dimension to the dataframe.\n", "expanded_df = expanded_df.explode([\"top\", \"bottom\"]).reset_index(drop=True)\n", "expanded_df[\"freq\"] = expanded_df[\"top\"].apply(lambda x: float(x.f))\n", "\n", "# Convert the amplitude fractions into power fractions for the top and bottom waveguides.\n", "expanded_df[\"top\"] = expanded_df[\"top\"].apply(lambda x: float(abs(x) ** 2))\n", "expanded_df[\"bottom\"] = expanded_df[\"bottom\"].apply(lambda x: float(abs(x) ** 2))\n", "\n", "# Visualize the dataframe\n", "print(\"Monte Carlo data for training the neural network surrogate model\")\n", "print(expanded_df[[\"wg_spacing_coup\", \"coup_length\", \"freq\", \"top\", \"bottom\"]])\n", "\n", "# Read the dataframe back into a Result that we can use as a pytorch Dataset\n", "expanded_results = tdd.Result()\n", "expanded_results = expanded_results.from_dataframe(expanded_df, dims=list(results.dims) + [\"freq\"])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can use the `Result` class directly as a pytorch dataset and take advantage of pytorch utilities to create a training, validation, and testing split of the data. Documentation on handling data in pytorch can be found [here](https://pytorch.org/docs/stable/data.html). The training data we will use directly to adjust network weights. Validation data is used to assess the quality of the model when applied to non-training data. It is a useful evaluation criteria when deciding between different network hyperparameters. We reserve testing data for the end to perform a final verification on the trained model." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "# Neural Network parameters\n", "number_samples = len(expanded_results)\n", "train_samples = int(np.floor(0.6 * number_samples))\n", "validation_samples = int(np.floor(0.2 * number_samples))\n", "test_samples = number_samples - train_samples - validation_samples\n", "batch_size = 16\n", "epochs = 120\n", "final_training_epochs = 1000\n", "\n", "training_dataset, validation_dataset, test_dataset = torch.utils.data.random_split(\n", " expanded_results, [train_samples, validation_samples, test_samples]\n", ")\n", "\n", "training_dataloader = DataLoader(training_dataset, batch_size=batch_size, shuffle=True)\n", "validation_dataloader = DataLoader(validation_dataset, batch_size=batch_size, shuffle=False)\n", "testing_dataloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this section, we set up the general structure for a fully connected neural network with a variable number of hidden layers, ReLU activation functions, and the option to include dropout layers to prevent overfitting and improve generalization. The input to the network is given by two geometric parameters and the frequency, the three of which are normalized to fall between [-1, 1] based on their allowed ranges. The output of the network is the power fraction in the top and bottom waveguides. More information on how to build neural networks in pytorch can be found [here](https://pytorch.org/tutorials/beginner/basics/buildmodel_tutorial.html)." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# Assuming the features are coming in as (wg_spacing_coup, coup_length, freq)\n", "# and we can normalize by the min/max possible values to center each feature in [-1, 1]\n", "min_freq = np.min(freqs)\n", "max_freq = np.max(freqs)\n", "\n", "subtract_min = torch.tensor(\n", " [wg_spacing_coup_range[0], coup_length_range[0], min_freq], dtype=torch.float\n", ")\n", "normalize_max = torch.tensor(\n", " [\n", " wg_spacing_coup_range[1] - wg_spacing_coup_range[0],\n", " coup_length_range[1] - coup_length_range[0],\n", " max_freq - min_freq,\n", " ],\n", " dtype=torch.float,\n", ")\n", "\n", "network_input_size = 3\n", "\n", "\n", "# Define a fully connected model in PyTorch with ReLU activation\n", "# where we can set a variable number of hidden layers through\n", "# neurons list. Allow option to specify dropout percentage.\n", "class VariableANN(nn.Module):\n", " def __init__(self, input_size, neurons, dropout) -> None:\n", " super().__init__()\n", " self.layers = nn.ModuleList()\n", " self.layers.append(nn.Linear(input_size, neurons[0]))\n", "\n", " for i in range(1, len(neurons)):\n", " self.layers.append(nn.Linear(neurons[i - 1], neurons[i]))\n", "\n", " self.layers.append(nn.Linear(neurons[-1], 2))\n", "\n", " self.drop = nn.Dropout(dropout)\n", " self.relu = nn.ReLU()\n", "\n", " def forward(self, x):\n", " subtract_min_unsqueeze = torch.unsqueeze(subtract_min, dim=0)\n", " normalize_max_unsqueeze = torch.unsqueeze(normalize_max, dim=0)\n", "\n", " # normalize inputs to be between [-1, 1]\n", " x = x - subtract_min_unsqueeze\n", " x = x / normalize_max_unsqueeze\n", " x = 2.0 * (x - 0.5)\n", "\n", " for layer in self.layers[:-1]:\n", " x = self.drop(self.relu(layer(x)))\n", "\n", " x = self.layers[-1](x)\n", "\n", " return x" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We set up functions here to facilitate the training of the neural network. By default, we use an MSE loss function in the training that computes the mean squared error between the network's output power fractions and the ground truth output power fractions. In each epoch of training, we run through all the batches in the training dataset, adjusting the weights in the network with an Adam optimizer after each batch. We also keep track of the validation loss from when the network is in evaluation mode and processing data from the validation dataset. This will be useful later for choosing the best network hyperparameters. More information on how to train neural networks in pytorch can be found [here](https://pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html)." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "loss_fn = nn.MSELoss()\n", "\n", "\n", "def evaluate_loss(data, network, loss_fn_user=None):\n", " \"\"\"Extract inputs/labels from the data and allow for loss evaluation on user defined loss\n", " function (otherwise use the default loss_fn which is set to MSE).\"\"\"\n", "\n", " inputs, labels = data\n", "\n", " if loss_fn_user is None:\n", " loss_fn_user = loss_fn\n", "\n", " loss = loss_fn_user(network(inputs.type(torch.FloatTensor)), labels.type(torch.FloatTensor))\n", "\n", " return loss\n", "\n", "\n", "def evaluate_loss_from_loader(data_loader, network, loss_fn_user=None):\n", " \"\"\"Given a data_loader, run all the batches through the network and evaluate loss.\"\"\"\n", " loss_by_iteration = []\n", " for data_idx, data in enumerate(data_loader):\n", " loss = evaluate_loss(data, network, loss_fn_user)\n", " loss_by_iteration.append(loss.item())\n", "\n", " avg_loss = np.mean(loss_by_iteration)\n", " return avg_loss\n", "\n", "\n", "def train_network(hyperparameters, epochs):\n", " \"\"\"Train a network according to hyperparameters specification for a given number of epochs.\"\"\"\n", "\n", " # build network and set to training mode\n", " network = VariableANN(network_input_size, hyperparameters[\"hidden\"], hyperparameters[\"dropout\"])\n", " network.train()\n", " opt = optim.Adam(\n", " network.parameters(),\n", " lr=hyperparameters[\"learning_rate\"],\n", " weight_decay=hyperparameters[\"weight_decay\"],\n", " )\n", "\n", " training_loss_by_epoch = np.zeros(1 + epochs)\n", " validation_loss_by_epoch = np.zeros(1 + epochs)\n", "\n", " avg_training_loss = evaluate_loss_from_loader(training_dataloader, network)\n", " avg_validation_loss = evaluate_loss_from_loader(validation_dataloader, network)\n", "\n", " training_loss_by_epoch[0] = avg_training_loss\n", " validation_loss_by_epoch[0] = avg_validation_loss\n", "\n", " for epoch_idx in range(0, epochs):\n", " training_loss_by_iteration = []\n", "\n", " for data_idx, data in enumerate(training_dataloader):\n", " opt.zero_grad()\n", " loss = evaluate_loss(data, network)\n", "\n", " training_loss_by_iteration.append(loss.item())\n", "\n", " loss.backward()\n", " opt.step()\n", "\n", " # Remove training features like dropout for the evaluation section and then turn it back on for training\n", " network.eval()\n", " avg_validation_loss = evaluate_loss_from_loader(validation_dataloader, network)\n", " network.train()\n", "\n", " training_loss_by_epoch[1 + epoch_idx] = np.mean(training_loss_by_iteration)\n", " validation_loss_by_epoch[1 + epoch_idx] = avg_validation_loss\n", "\n", " return training_loss_by_epoch, validation_loss_by_epoch, network" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, we perform a random search over the network and optimizer hyperparameters to find the best structure and optimization. The figure of merit for the search is the validation error for the trained model because we ultimately care both about good network performance and its ability to generalize outside the training set. This search is done by randomly sampling hidden layer dimensions, number of hidden layers, and dropout percentage for the network and the learning rate and weight decay for the Adam optimizer. In this search, we fix the network to two hidden layers and train 75 trial network and optimization parameter combinations searching for the best validation loss. The tidy3d design plugin once again is useful here as we can utilize the Monte Carlo method once again to randomly choose parameters to evaluate." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "allowed_hidden_layer_sizes = np.arange(16, 257, 16)\n", "allowed_dropout = np.arange(0, 0.55, 0.05)\n", "num_hidden_layers = 2\n", "allowed_learning_rate_log_range = (-5, -3)\n", "allowed_weight_decay_log_range = (-5, -4)\n", "\n", "num_trial_networks = 75\n", "\n", "\n", "def hyperparemeter_fn(dropout, learning_rate_log, weight_decay_log, **hidden_layer_sizes):\n", " hidden_layer_sizes = [\n", " hidden_layer_sizes[f\"hidden_layer_size_{idx}\"] for idx in range(0, len(hidden_layer_sizes))\n", " ]\n", "\n", " hyperparam = {\n", " \"hidden\": hidden_layer_sizes,\n", " \"dropout\": dropout,\n", " \"learning_rate\": 10**learning_rate_log,\n", " \"weight_decay\": 10**weight_decay_log,\n", " }\n", "\n", " training_loss, validation_loss, network = train_network(hyperparam, epochs)\n", "\n", " return -validation_loss[-1]\n", "\n", "\n", "param_dropout = tdd.ParameterAny(name=\"dropout\", allowed_values=tuple(allowed_dropout))\n", "param_lr_log = tdd.ParameterFloat(name=\"learning_rate_log\", span=allowed_learning_rate_log_range)\n", "param_wd_log = tdd.ParameterFloat(name=\"weight_decay_log\", span=allowed_weight_decay_log_range)\n", "params_hyperparameter = [\n", " tdd.ParameterAny(\n", " name=f\"hidden_layer_size_{idx}\",\n", " allowed_values=tuple(allowed_hidden_layer_sizes),\n", " )\n", " for idx in range(0, num_hidden_layers)\n", "]\n", "hyperparameters = [param_dropout, param_lr_log, param_wd_log] + params_hyperparameter\n", "\n", "hyperparam_optimizer = tdd.MethodMonteCarlo(\n", " num_points=num_trial_networks,\n", " seed=2,\n", ")\n", "design_space = tdd.DesignSpace(\n", " method=hyperparam_optimizer,\n", " parameters=hyperparameters,\n", " task_name=\"DC_Network_MC\",\n", " path_dir=str(mc_data_dir),\n", ")\n", "network_hyperparameter_results = design_space.run(hyperparemeter_fn, verbose=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "After the hyperparameter search, we perform one final network training using the best hyperparameter settings and an increased number of training epochs. This network can now operate as the surrogate solver for the coupling problem." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Best network hyperparameters:\n", "hidden : [144, 160]\n", "dropout : 0.0\n", "learning_rate : 0.0005177283857996054\n", "weight_decay : 1.4211205011036916e-05\n", "\n", "Average training loss: 2.111494920924246e-05\n", "Average validation loss: 2.4598028360520316e-05\n", "Average test loss: 2.1038408199166852e-05\n", "Average L1 validation loss: 0.0028564875595286253\n", "Average L1 test loss: 0.0027615668620606226\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Extract the best parameters from the design space result and formulate the hyperparameter dictionary for the optimization\n", "best_parameters = dict(\n", " zip(\n", " network_hyperparameter_results.dims,\n", " network_hyperparameter_results.coords[np.argmax(network_hyperparameter_results.values)],\n", " )\n", ")\n", "best_hyperparam = {\n", " \"hidden\": [best_parameters[f\"hidden_layer_size_{idx}\"] for idx in range(0, num_hidden_layers)],\n", " \"dropout\": best_parameters[\"dropout\"],\n", " \"learning_rate\": 10 ** best_parameters[\"learning_rate_log\"],\n", " \"weight_decay\": 10 ** best_parameters[\"weight_decay_log\"],\n", "}\n", "print(\"Best network hyperparameters:\")\n", "for k, v in best_hyperparam.items():\n", " print(f\"{k} : {v}\")\n", "avg_training_loss, avg_validation_loss, optimized_network = train_network(\n", " best_hyperparam, final_training_epochs\n", ")\n", "optimized_network.eval()\n", "\n", "# Report the final average training loss from the final optimization as well as the validation and test losses for eval mode\n", "avg_test_loss = evaluate_loss_from_loader(testing_dataloader, optimized_network)\n", "print(f\"\\nAverage training loss: {avg_training_loss[-1]}\")\n", "print(f\"Average validation loss: {avg_validation_loss[-1]}\")\n", "print(f\"Average test loss: {avg_test_loss}\")\n", "\n", "# Compute the L1 validation and test loss in eval mode to get a better intuitive sense of the network performance by examining\n", "# absolute error instead of squared error\n", "l1_loss_fn = nn.L1Loss()\n", "avg_l1_validation_loss = evaluate_loss_from_loader(\n", " validation_dataloader, optimized_network, l1_loss_fn\n", ")\n", "avg_l1_test_loss = evaluate_loss_from_loader(testing_dataloader, optimized_network, l1_loss_fn)\n", "\n", "print(f\"Average L1 validation loss: {avg_l1_validation_loss}\")\n", "print(f\"Average L1 test loss: {avg_l1_test_loss}\")\n", "\n", "# Plot log of loss curves for the network\n", "plt.plot(\n", " np.arange(0, len(avg_training_loss)),\n", " np.log(avg_training_loss),\n", " color=\"g\",\n", " linewidth=2,\n", " label=\"training loss\",\n", ")\n", "plt.plot(\n", " np.arange(0, len(avg_validation_loss)),\n", " np.log(avg_validation_loss),\n", " color=\"b\",\n", " linewidth=2,\n", " label=\"validation loss\",\n", " linestyle=\"--\",\n", ")\n", "plt.axhline(y=np.log(avg_test_loss), color=\"k\", linewidth=2, label=\"final test loss\")\n", "plt.xlabel(\"Epoch\")\n", "plt.ylabel(\"Log(Loss)\")\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## DC Optimization\n", "\n", "The final optimization step uses the neural network surrogate as part of a gradient based optimization. Instead of running simulations for each candidate set of geometric parameters, we use the neural network to estimate the output waveguide power fractions. We set as a loss function the mean squared error between the output of the network and our desired splitting ratio of 0.25/0.75. However, instead of optimizing the network weights as we did before, we optimize the network input (i.e. - the coupling geometric parameters) to reduce the loss. Below, we see this converges quickly and identifies a good set of parameters for the coupler." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Set up coupler geometry in a pytorch tensor and initialize to the mean values\n", "# for both the coupling length and the waveguide spacing\n", "coupler_geometry = torch.Tensor([np.mean(wg_spacing_coup_range), np.mean(coup_length_range)])\n", "coupler_geometry.requires_grad = True # we will track the gradient in the optimizer\n", "\n", "freq_tensor = torch.Tensor([freq0]).unsqueeze(dim=0) # design coupler at center frequency\n", "\n", "# Set up bounds to clamp the design parameters between so we stay in the parameter\n", "# space learned by the neural network surrogate\n", "min_design_tensor = torch.Tensor([np.min(wg_spacing_coup_range), np.min(coup_length_range)])\n", "max_design_tensor = torch.Tensor([np.max(wg_spacing_coup_range), np.max(coup_length_range)])\n", "\n", "# Set up the transmission goal we can use in the loss function and define an MSE loss\n", "desired_transmission = torch.Tensor(\n", " [top_waveguide_transmission_goal, bottom_waveguide_transmission_goal]\n", ")\n", "mse_loss = nn.MSELoss()\n", "\n", "# Create an Adam optimizer the focuses on optimizing the coupler geometry\n", "# based on the surrogate prediction\n", "opt = optim.Adam(\n", " [coupler_geometry],\n", " lr=1e-3,\n", " weight_decay=1e-5,\n", ")\n", "\n", "coupler_optimization_iterations = 100\n", "coupler_loss_curve = np.zeros(coupler_optimization_iterations)\n", "\n", "for idx in range(0, coupler_optimization_iterations):\n", " opt.zero_grad()\n", "\n", " # Clamp the geometry between the min/max values allowed\n", " clamp_geometry = torch.clamp(coupler_geometry, min_design_tensor, max_design_tensor)\n", "\n", " # Combine the geometry parameters with the frequency\n", " geometry_and_freq = torch.cat((clamp_geometry.unsqueeze(dim=0), freq_tensor), dim=1)\n", "\n", " # Check the surrogate's prediction for the current coupler geometry\n", " prediction = torch.squeeze(optimized_network(geometry_and_freq))\n", "\n", " # Compute the loss based on the goal transmission in each waveguide\n", " loss = mse_loss(prediction, desired_transmission)\n", " coupler_loss_curve[idx] = loss.item()\n", "\n", " loss.backward() # backpropagate\n", " opt.step() # step parameters\n", "\n", "\n", "final_geometry = torch.clamp(coupler_geometry, min_design_tensor, max_design_tensor)\n", "final_geometry_numpy = final_geometry.detach().numpy()\n", "final_geometry_numpy_display = [float(np.round(float(num), 4)) for num in final_geometry_numpy]\n", "\n", "plt.plot(coupler_loss_curve, linewidth=2, color=\"g\")\n", "plt.xlabel(\"Iteration\")\n", "plt.ylabel(\"Loss\")\n", "plt.title(\n", " \"Optimized coupler geometry\\n\"\n", " rf\"wg_spacing={final_geometry_numpy_display[0]}$\\mu$m\"\n", " \"\\n\"\n", " rf\"coup_length={final_geometry_numpy_display[1]}$\\mu$m\"\n", ")\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Using the parameters from our optimization, we run a final electromagnetic evaluation of the coupler. This allows us to assess one more time the quality of the surrogate model as well as evaluate the performance of the final design." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
20:43:07 CEST Created task 'best_predicted' with task_id                        \n",
       "              'fdve-3017a068-b145-4777-95f9-5d0e7a647a53' and task_type 'FDTD'. \n",
       "
\n" ], "text/plain": [ "\u001b[2;36m20:43:07 CEST\u001b[0m\u001b[2;36m \u001b[0mCreated task \u001b[32m'best_predicted'\u001b[0m with task_id \n", "\u001b[2;36m \u001b[0m\u001b[32m'fdve-3017a068-b145-4777-95f9-5d0e7a647a53'\u001b[0m and task_type \u001b[32m'FDTD'\u001b[0m. \n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
              View task using web UI at                                         \n",
       "              'https://tidy3d.simulation.cloud/workbench?taskId=fdve-3017a068-b1\n",
       "              45-4777-95f9-5d0e7a647a53'.                                       \n",
       "
\n" ], "text/plain": [ "\u001b[2;36m \u001b[0m\u001b[2;36m \u001b[0mView task using web UI at \n", "\u001b[2;36m \u001b[0m\u001b]8;id=336054;https://tidy3d.simulation.cloud/workbench?taskId=fdve-3017a068-b145-4777-95f9-5d0e7a647a53\u001b\\\u001b[32m'https://tidy3d.simulation.cloud/workbench?\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=286107;https://tidy3d.simulation.cloud/workbench?taskId=fdve-3017a068-b145-4777-95f9-5d0e7a647a53\u001b\\\u001b[32mtaskId\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=336054;https://tidy3d.simulation.cloud/workbench?taskId=fdve-3017a068-b145-4777-95f9-5d0e7a647a53\u001b\\\u001b[32m=\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=457499;https://tidy3d.simulation.cloud/workbench?taskId=fdve-3017a068-b145-4777-95f9-5d0e7a647a53\u001b\\\u001b[32mfdve\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=336054;https://tidy3d.simulation.cloud/workbench?taskId=fdve-3017a068-b145-4777-95f9-5d0e7a647a53\u001b\\\u001b[32m-3017a068-b1\u001b[0m\u001b]8;;\u001b\\\n", "\u001b[2;36m \u001b[0m\u001b]8;id=336054;https://tidy3d.simulation.cloud/workbench?taskId=fdve-3017a068-b145-4777-95f9-5d0e7a647a53\u001b\\\u001b[32m45-4777-95f9-5d0e7a647a53'\u001b[0m\u001b]8;;\u001b\\. \n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
              Task folder: 'default'.                                           \n",
       "
\n" ], "text/plain": [ "\u001b[2;36m \u001b[0m\u001b[2;36m \u001b[0mTask folder: \u001b]8;id=792309;https://tidy3d.simulation.cloud/folders/folder-7a0ee478-ee62-43e0-9a9e-26a06b299b0a\u001b\\\u001b[32m'default'\u001b[0m\u001b]8;;\u001b\\. \n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "9388fe2eb6414d6f99719d660c413ce2", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Output()" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
20:43:09 CEST Maximum FlexCredit cost: 0.629. Minimum cost depends on task      \n",
       "              execution details. Use 'web.real_cost(task_id)' to get the billed \n",
       "              FlexCredit cost after a simulation run.                           \n",
       "
\n"
      ],
      "text/plain": [
       "\u001b[2;36m20:43:09 CEST\u001b[0m\u001b[2;36m \u001b[0mMaximum FlexCredit cost: \u001b[1;36m0.629\u001b[0m. Minimum cost depends on task      \n",
       "\u001b[2;36m              \u001b[0mexecution details. Use \u001b[32m'web.real_cost\u001b[0m\u001b[32m(\u001b[0m\u001b[32mtask_id\u001b[0m\u001b[32m)\u001b[0m\u001b[32m'\u001b[0m to get the billed \n",
       "\u001b[2;36m              \u001b[0mFlexCredit cost after a simulation run.                           \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
20:43:10 CEST status = queued                                                   \n",
       "
\n"
      ],
      "text/plain": [
       "\u001b[2;36m20:43:10 CEST\u001b[0m\u001b[2;36m \u001b[0mstatus = queued                                                   \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
              To cancel the simulation, use 'web.abort(task_id)' or             \n",
       "              'web.delete(task_id)' or abort/delete the task in the web UI.     \n",
       "              Terminating the Python script will not stop the job running on the\n",
       "              cloud.                                                            \n",
       "
\n"
      ],
      "text/plain": [
       "\u001b[2;36m             \u001b[0m\u001b[2;36m \u001b[0mTo cancel the simulation, use \u001b[32m'web.abort\u001b[0m\u001b[32m(\u001b[0m\u001b[32mtask_id\u001b[0m\u001b[32m)\u001b[0m\u001b[32m'\u001b[0m or             \n",
       "\u001b[2;36m              \u001b[0m\u001b[32m'web.delete\u001b[0m\u001b[32m(\u001b[0m\u001b[32mtask_id\u001b[0m\u001b[32m)\u001b[0m\u001b[32m'\u001b[0m or abort/delete the task in the web UI.     \n",
       "\u001b[2;36m              \u001b[0mTerminating the Python script will not stop the job running on the\n",
       "\u001b[2;36m              \u001b[0mcloud.                                                            \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b528f2ae4d254435ada18f988600805f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
20:43:15 CEST status = preprocess                                               \n",
       "
\n"
      ],
      "text/plain": [
       "\u001b[2;36m20:43:15 CEST\u001b[0m\u001b[2;36m \u001b[0mstatus = preprocess                                               \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
20:43:19 CEST starting up solver                                                \n",
       "
\n"
      ],
      "text/plain": [
       "\u001b[2;36m20:43:19 CEST\u001b[0m\u001b[2;36m \u001b[0mstarting up solver                                                \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
              running solver                                                    \n",
       "
\n"
      ],
      "text/plain": [
       "\u001b[2;36m             \u001b[0m\u001b[2;36m \u001b[0mrunning solver                                                    \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "95666ac9e73b4b33b2cd8d0864110adb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
20:43:49 CEST early shutoff detected at 48%, exiting.                           \n",
       "
\n"
      ],
      "text/plain": [
       "\u001b[2;36m20:43:49 CEST\u001b[0m\u001b[2;36m \u001b[0mearly shutoff detected at \u001b[1;36m48\u001b[0m%, exiting.                           \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
              status = postprocess                                              \n",
       "
\n"
      ],
      "text/plain": [
       "\u001b[2;36m             \u001b[0m\u001b[2;36m \u001b[0mstatus = postprocess                                              \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cb0945dade9f4620a83fa0f977beb3e6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
20:43:53 CEST status = success                                                  \n",
       "
\n"
      ],
      "text/plain": [
       "\u001b[2;36m20:43:53 CEST\u001b[0m\u001b[2;36m \u001b[0mstatus = success                                                  \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
20:43:55 CEST View simulation result at                                         \n",
       "              'https://tidy3d.simulation.cloud/workbench?taskId=fdve-3017a068-b1\n",
       "              45-4777-95f9-5d0e7a647a53'.                                       \n",
       "
\n"
      ],
      "text/plain": [
       "\u001b[2;36m20:43:55 CEST\u001b[0m\u001b[2;36m \u001b[0mView simulation result at                                         \n",
       "\u001b[2;36m              \u001b[0m\u001b]8;id=251136;https://tidy3d.simulation.cloud/workbench?taskId=fdve-3017a068-b145-4777-95f9-5d0e7a647a53\u001b\\\u001b[4;34m'https://tidy3d.simulation.cloud/workbench?\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=675776;https://tidy3d.simulation.cloud/workbench?taskId=fdve-3017a068-b145-4777-95f9-5d0e7a647a53\u001b\\\u001b[4;34mtaskId\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=251136;https://tidy3d.simulation.cloud/workbench?taskId=fdve-3017a068-b145-4777-95f9-5d0e7a647a53\u001b\\\u001b[4;34m=\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=902314;https://tidy3d.simulation.cloud/workbench?taskId=fdve-3017a068-b145-4777-95f9-5d0e7a647a53\u001b\\\u001b[4;34mfdve\u001b[0m\u001b]8;;\u001b\\\u001b]8;id=251136;https://tidy3d.simulation.cloud/workbench?taskId=fdve-3017a068-b145-4777-95f9-5d0e7a647a53\u001b\\\u001b[4;34m-3017a068-b1\u001b[0m\u001b]8;;\u001b\\\n",
       "\u001b[2;36m              \u001b[0m\u001b]8;id=251136;https://tidy3d.simulation.cloud/workbench?taskId=fdve-3017a068-b145-4777-95f9-5d0e7a647a53\u001b\\\u001b[4;34m45-4777-95f9-5d0e7a647a53'\u001b[0m\u001b]8;;\u001b\\\u001b[4;34m.\u001b[0m                                       \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a2b5abb4525d46e6b6dc020e808f2228",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
20:43:57 CEST loading simulation from simulation_data.hdf5                      \n",
       "
\n"
      ],
      "text/plain": [
       "\u001b[2;36m20:43:57 CEST\u001b[0m\u001b[2;36m \u001b[0mloading simulation from simulation_data.hdf5                      \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "optimized_coup_length = final_geometry_numpy[1]\n",
    "optimized_wg_spacing = final_geometry_numpy[0]\n",
    "sim = make_sim(optimized_coup_length, optimized_wg_spacing)\n",
    "sim_data = web.run(sim, task_name=\"best_predicted\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the optimal point, we report the power in both the top and bottom waveguides after the coupling. We can compare these powers to the best ones we found with Monte Carlo sampling of the coupler geometric parameters. They are improved, albeit not by a significant margin because the random sampler did a good job of finding adequate design parameters. For a low dimensional optimization problem like this, it is not entirely unexpected for this to be the case. However, this technique may improve in utility as the number of design parameters grows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Top simulated waveguide transmission: 0.24442, Bottom simulated waveguide transmission: 0.74861\n",
      "\n",
      "Compare these values to the predicted values from the surrogate model:\n",
      "Top predicted waveguide transmission: 0.24604, Bottom predicted waveguide transmission: 0.7475\n",
      "\n",
      "Compare these values to the ones found via Monte Carlo sampling:\n",
      "Top simulated MC waveguide transmission: 0.26192, Bottom simulated MC waveguide transmission: 0.73212\n"
     ]
    }
   ],
   "source": [
    "def make_prediction(network, wg_spacing_coup, coup_length, freq):\n",
    "    \"\"\"Use the neural network surrogate to estimate the output coupling power fractions.\"\"\"\n",
    "    feature_array = np.expand_dims(np.array([wg_spacing_coup, coup_length, freq]), axis=0)\n",
    "    input_tensor = torch.Tensor(feature_array)\n",
    "    prediction = np.squeeze(network(input_tensor).detach().numpy())\n",
    "\n",
    "    return prediction\n",
    "\n",
    "\n",
    "# Extract power in each waveguide from simulation data\n",
    "amps_dict = measure_coupling_amplitude(sim_data)\n",
    "print(\n",
    "    f\"Top simulated waveguide transmission: {np.round(float(abs(amps_dict['top'].sel({'f': freq0})) ** 2), 5)}, Bottom simulated waveguide transmission: {np.round(float(abs(amps_dict['bottom'].sel({'f': freq0})) ** 2), 5)}\\n\"\n",
    ")\n",
    "\n",
    "# Check the network prediction for this point to compare\n",
    "feature_array = np.array(\n",
    "    (\n",
    "        optimized_wg_spacing,\n",
    "        optimized_coup_length,\n",
    "        freq0,\n",
    "    )\n",
    ")\n",
    "\n",
    "prediction = make_prediction(optimized_network, *feature_array)\n",
    "print(\"Compare these values to the predicted values from the surrogate model:\")\n",
    "print(\n",
    "    f\"Top predicted waveguide transmission: {np.round(float(prediction[0]), 5)}, Bottom predicted waveguide transmission: {np.round(float(prediction[1]), 5)}\\n\"\n",
    ")\n",
    "\n",
    "# Compare the result above to the best point found via Monte Carlo sampling where geometric parameters were chosen at random\n",
    "print(\"Compare these values to the ones found via Monte Carlo sampling:\")\n",
    "print(\n",
    "    f\"Top simulated MC waveguide transmission: {np.round(best_top_power_mc, 5)}, Bottom simulated MC waveguide transmission: {np.round(best_bottom_power_mc, 5)}\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the neural network was trained to predict output powers for multiple frequencies, we can compare the spectrum prediction for our final design to the ground truth simulation data. We also summarize the mean squared and mean absolute error across the spectrum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error summary for optimal point:\n",
      "MSE for top: 5.756458536304202e-06\n",
      "MSE for bottom: 4.2418515470648096e-06\n",
      "MAE for top: 0.0018401715521854354\n",
      "MAE for bottom: 0.0015413127160672296\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "
"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "top_amp_predict = np.zeros(len(freqs))\n",
    "top_amp_real = np.zeros(len(freqs))\n",
    "bot_amp_predict = np.zeros(len(freqs))\n",
    "bot_amp_real = np.zeros(len(freqs))\n",
    "\n",
    "for idx, freq_val in enumerate(freqs):\n",
    "    feature_array = np.array(\n",
    "        (\n",
    "            optimized_wg_spacing,\n",
    "            optimized_coup_length,\n",
    "            freq_val,\n",
    "        )\n",
    "    )\n",
    "\n",
    "    prediction = make_prediction(optimized_network, *feature_array)\n",
    "\n",
    "    top_amp_predict[idx] = prediction[0]\n",
    "    top_amp_real[idx] = float(abs(amps_dict[\"top\"].sel({\"f\": freq_val})) ** 2)\n",
    "\n",
    "    bot_amp_predict[idx] = prediction[1]\n",
    "    bot_amp_real[idx] = float(abs(amps_dict[\"bottom\"].sel({\"f\": freq_val})) ** 2)\n",
    "\n",
    "fig, ax = plt.subplots(1, tight_layout=True, figsize=(10, 5))\n",
    "\n",
    "\n",
    "mse_top = np.mean((top_amp_predict - top_amp_real) ** 2)\n",
    "mse_bottom = np.mean((bot_amp_predict - bot_amp_real) ** 2)\n",
    "mae_top = np.mean(np.abs(top_amp_predict - top_amp_real))\n",
    "mae_bottom = np.mean(np.abs(bot_amp_predict - bot_amp_real))\n",
    "\n",
    "print(\"Error summary for optimal point:\")\n",
    "print(f\"MSE for top: {mse_top}\")\n",
    "print(f\"MSE for bottom: {mse_bottom}\")\n",
    "print(f\"MAE for top: {mae_top}\")\n",
    "print(f\"MAE for bottom: {mae_bottom}\")\n",
    "\n",
    "ax.plot(td.C_0 / freqs, top_amp_predict, label=\"Predicted\")\n",
    "ax.plot(td.C_0 / freqs, top_amp_real, label=\"Actual\")\n",
    "ax.set_xlabel(r\"Wavelength ($\\mu$m)\")\n",
    "ax.set_ylabel(\"Amp$^2$\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}