{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# 5. Hybrid model for CSTR 🔆\n", "\n", "\"Open\n", "\n", "This Notebook was initially prepared by [Marcus Wenzel](https://www.linkedin.com/in/marcus-wenzel-356a34184/?originalSubdomain=de) and few modifications have been made by us. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Goals of this exercise 🌟\n", "- We will build a hybrid model for a reactor \n", "- We will train the model using sensitivity equations and autodiff" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## A quick reminder ✅\n", "**Data-driven models** are also known as black-box models, or machine learning-based, empirical models. **Mechanistic models** are also called white-box models, or knowledge-based, first-principles, or phenomenological models. **Hybrid**, or grey-box models models combine understanding of physical/chemical/biological processes in mechanistic models with modelling unknown phenomena via data-driven approaches [{cite}`glassey2018hybrid, von2014hybrid, mcbride2020hybrid`]. \n", "\n", "Hybrid models aim to balance the advantages and disadvantages of mechanistic and data-driven models. Fundamental knowledge introduces structure to data-driven models, so not all interactions have to be learned by the model. ML-based models introduce a statistical element to knowledge-based models, so not all interactions have to be explained by first-principles.\n", "\n", "Advantages of hybrid models include: Lower data requirements, improved understanding of the system, and better extrapolation compared to purely data-driven models; higher estimation/prediction accuracy, more efficient model development compared to purely mechanistic models." ] }, { "cell_type": "markdown", "metadata": { "id": "JSMsxFeTYxmh" }, "source": [ "## First-principles model part for CSTR\n", "\n", "We model a continuous stirred tank reactor (CSTR) with the following liquid-phase reaction:\n", "$$\n", "A + B \\rightleftarrows X\n", "$$\n", "\n", "The reactor is fed by a feed of flowrate $F_{in}$ and concentrations $C_{i, in}$ with $i$ denoting species $A$, $B$, and $X$. The reactor has constant volume $V$ and is assumed to be perfectly mixed, with an average residence time $\\tau$. The concentrations in the reactor are denoted by $C_{i}$. A stream with constant flowrate $F=F_{in}$ exits the reactor: \n", "\n", "```{figure} media/05_hybrid/CSTR_vars_2.png\n", ":alt: cstr\n", ":width: 40%\n", ":align: center\n", "\n", "Schematic representation of the CSTR considered here\n", "```\n", "\n", "Let's say we use the following reactor model:\n", "\n", "$$\n", "\\frac{\\mathrm{d}N_A}{\\mathrm{d}t} = C_{i,in}F_{in} - C_{i}F - \\nu_i rV\n", "$$\n", "\n", "$$\n", "\\Leftrightarrow \\frac{\\mathrm{d}C_A}{\\mathrm{d}t} = \\frac{C_{A,in} - C_A}{\\tau} - r\n", "$$\n", "\n", "$$\n", "\\frac{\\mathrm{d}C_B}{\\mathrm{d}t} = \\frac{C_{B,in} - C_B}{\\tau} - r\n", "$$\n", "\n", "$$\n", "\\frac{\\mathrm{d}C_X}{\\mathrm{d}t} = \\frac{C_{X,in} - C_X}{\\tau} + r\n", "$$\n", "\n", "\n", "The changes in concentration are a result of material added and withdrawn from the reactor as well as created or consumed by the reaction with stochiometric coefficients $\\nu_i$ and reaction rate $r$. We assume an average residence time of $\\tau= \\frac{V}{F} = 100s$. The inlet concentrations of substance $i$ into the reactor are given by\n", "\n", "\n", "$$\n", "C_{A,in} = 0.7\\,\\mathrm{kmol/m^3}\n", "$$\n", "\n", "$$\n", "C_{B,in} = 0.3\\,\\mathrm{kmol/m^3}\n", "$$\n", "\n", "$$\n", "C_{X,in} = 0\\,\\mathrm{kmol/m^3}\n", "$$\n", "\n", "\n", "For solving the differential equation system, we also need to know the initial concentration of each substance inside the reactor, denoted as $C_{i,0}$. From the data it is known that the experiment was started with the following initial concentrations:\n", "\n", "$$\n", "C_{A,0} = 0.5\\,\\mathrm{kmol/m^3}\n", "$$\n", "\n", "$$\n", "C_{B,0} = 0.5\\,\\mathrm{kmol/m^3}\n", "$$\n", "\n", "$$\n", "C_{X,0} = 0\\,\\mathrm{kmol/m^3}\n", "$$\n", "\n", "\n", "Time-dependent experimental measurements for all concentrations are available:\n", "\n", "\n", "```{figure} media/05_hybrid/CSTR_experimental.png\n", ":alt: cstr_measurements\n", ":width: 60%\n", ":align: center\n", "\n", "CSTR measurements of the concentrations.\n", "```\n", "\n", "\n", "The task is to construct a **serial hybrid model**, in which the reaction rate $r$ is described by a data-driven model. In this particular example, a **neural network** will be used." ] }, { "cell_type": "markdown", "metadata": { "id": "fB3Ws3TGYxmp" }, "source": [ "## Serial model construction\n", "### Problem description\n", "\n", "The problem with constructing a serial hybrid model, as exemplified above, is that _the data-driven model cannot be trained independently of the differential equation system_ that describes the system (mechanistic part of the hybrid model). The neural network has to learn the function $r=f(C)$ but, of course, we do not have values for $r$ which we could use to train the model. One way to solve this problem is by using **sensitivity equations**. This approach will be discussed in the following." ] }, { "cell_type": "markdown", "metadata": { "id": "wwkyCdLAYxmq" }, "source": [ "### Sensitivity equations and solution procedure\n", "\n", "We can describe the differential equation system as follows:\n", "\n", "$$\n", "\\frac{\\mathrm{d}y}{\\mathrm{d}t} = f(y, u,\\phi(y,w))\n", "$$\n", "\n", "where $y$ are states of the system, $u$ are system inputs and $\\phi(y,w)$ denotes a data-driven model that describes a part of the mechanistic model with the use of the states $y$ and a set of parameter values $w$. In the case of a neural network, the parameter vector $w$ includes all the weights and biases.\n", "\n", "In order to train any kind of model, we need a **loss or cost function** (denoted here by $J$) to estimate the quality of our model predictions. Often times, the sum of squares of the deviations between the model predictions and the data is used as an objective for parameter estimation:\n", "\n", "$$\n", "J = 0.5 \\sum_{i=1}^N\\left(y_i - y_{i, \\text{exp}}\\right)^2,\n", "$$\n", "\n", "where $y$ are the set of model predictions corresponding to the $N$ measurement points $y_\\text{i,exp}$. The model predictions depend on $u$ and $w$, i.e. $y=f(u,w)$.\n", "\n", "Usually, when training a neural network, the gradient of the loss function with respect to the network parameters is used for optimization. The gradient of the loss function with respect to a single parameter $w_j$ is given by\n", "\n", "$$\n", "\\frac{\\partial J}{\\partial w_j} = \\sum_{i=1}^N\\left(y_i - y_{i, \\text{exp}}\\right)\\frac{\\partial y}{\\partial w_j}.\n", "$$\n", "\n", "As can be seen, the gradient depends on $\\frac{\\partial y}{\\partial w_j}$, i.e. the sensitivities of the system states with respect to the parameters (the weights and biases characterizing the neural network). Training of the neural network is then achieved by iteratively updating the parameters according to\n", "\n", "$$\n", "w_j^{n+1} = w_j^{n} - g \\frac{\\partial J}{\\partial w_j^{n}},\n", "$$\n", "\n", "where $w_j^{n+1}$ is the updated parameter that is calculated from the current parameter $w_j^{n}$ using the gradient $\\frac{\\partial J}{\\partial w_j^{n}}$ and a learning rate (step size) $g$.\n", "\n", "The problem could be solved once we have the sensitivities $\\frac{\\partial y}{\\partial w_j}$. Since the mechanistic part of the model is given by a differential equation system, calculating these sensitivities is a bit more complicated than for an algebraic model. Using local sensitivity analysis of the ODE system and denoting the sensitivities $\\frac{\\partial y}{\\partial w_j}$ as $s_j$, the sensitivities can be described by\n", "\n", "$$\n", "\\frac{\\mathrm{d}s_j}{\\mathrm{d}t} = \\frac{\\partial f}{\\partial y}s_j + \\frac{\\partial f}{\\partial w_j}.\n", "$$\n", "\n", "This equation is a differential equation for the sensitivities. Since $f$ depends on the system states, the differential equations for the sensitivities need to be integrated simultaneously with the ODE system of the mechanistic part." ] }, { "cell_type": "markdown", "metadata": { "id": "pz6WCB3hYxmr" }, "source": [ "### Loss function and sensitivity equations for hybrid CSTR model\n", "\n", "For the reactor example above, the loss function is defined as\n", "\n", "$$\n", "J = 0.5\\left[ \\sum_{i=1}^N\\left(C_{A,i} - C_{A,i,\\text{exp}}\\right)^2 + \\sum_{i=1}^N\\left(C_{B,i} - C_{B,i,\\text{exp}}\\right)^2 + \\sum_{i=1}^N\\left(C_{X,i} - C_{X,i,\\text{exp}}\\right)^2\\right],\n", "$$\n", "\n", "if we assume that we have measurements for all components at each point $i$. Then, the gradient of the loss function with respect to the parameters $w$ is given as \n", "\n", "$$\n", "\\frac{\\partial J}{\\partial w_j} = \\sum_{i=1}^N\\left(C_{A,i} - C_{A,i,\\text{exp}}\\right)\\frac{\\partial C_{A,i}}{\\partial w_j} + \\sum_{i=1}^N\\left(C_{B,i} - C_{B,i,\\text{exp}}\\right)\\frac{\\partial C_{B,i}}{\\partial w_j} + \\sum_{i=1}^N\\left(C_{X,i} - C_{X,i,\\text{exp}}\\right)\\frac{\\partial C_{X,i}}{\\partial w_j},\n", "$$\n", "\n", "since the concentrations $C_A$, $C_B$ and $C_X$ are all functions of the parameters of the neural network (weights and biases). The sensitivities are calculated by combining the sensitivity equations with the model definition, according to the following ODE system for each parameter $w_j$, :\n", "\n", "$$\n", "\\frac{\\mathrm{d}}{\\mathrm{d}t}\\begin{bmatrix}\n", " \\frac{\\partial C_{A}}{\\partial w_j}\\\\\n", " \\frac{\\partial C_{B}}{\\partial w_j}\\\\\n", " \\frac{\\partial C_{X}}{\\partial w_j}\\\\\n", "\\end{bmatrix}\n", "=\n", "\\begin{bmatrix}\n", " -\\frac{1}{\\tau}-\\frac{\\partial r}{\\partial c_A} & -\\frac{\\partial r}{\\partial c_B} & -\\frac{\\partial r}{\\partial c_X}\\\\\n", " -\\frac{\\partial r}{\\partial c_A} & -\\frac{1}{\\tau}-\\frac{\\partial r}{\\partial c_B} & -\\frac{\\partial r}{\\partial c_X} \\\\\n", " +\\frac{\\partial r}{\\partial c_A} & +\\frac{\\partial r}{\\partial c_B} & -\\frac{1}{\\tau}+\\frac{\\partial r}{\\partial c_X} \\\\\n", "\\end{bmatrix}\n", "\\begin{bmatrix}\n", " \\frac{\\partial c_{A}}{\\partial w_j}\\\\\n", " \\frac{\\partial c_{B}}{\\partial w_j}\\\\\n", " \\frac{\\partial c_{X}}{\\partial w_j}\\\\\n", "\\end{bmatrix}\n", "+\n", "\\begin{bmatrix}\n", " -\\frac{\\partial r}{\\partial w_j}\\\\\n", " -\\frac{\\partial r}{\\partial w_j}\\\\\n", " +\\frac{\\partial r}{\\partial w_j}\\\\\n", "\\end{bmatrix}\n", "$$\n", "\n", "Hence, for $p$ parameters and $l$ system states, there are $p*l$ sensitivity equations to be integrated additionally to the $l$ system equations. If a neural network with 3 input nodes, 10 hidden nodes and 1 output node is used, the total number of parameters is $3*10+10+10*1+1=51$ parameters for three states ($C_A$, $C_B$ and $C_X$). Thus, there would be $3*51=153$ sensitivity equations to be integrated, which quickly becomes computationally intensive." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Differentiation & autograd\n", "In order to train and run the model, we will need to compute derivates. Automatic differentiation (autodiff) is an algorithm for the fast calculation of accurate derivatives. We will use autograd, the implementation of autodiff in the pytorch package.\n", "\n", "Let's see how it works:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "if 'google.colab' in str(get_ipython()):\n", " !pip install autograd" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import autograd\n", "import autograd.numpy as np\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's define a function and differentiate it with autograd:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "value of the function: -26.0\n", "value of the derivative: -19.0\n" ] } ], "source": [ "def ex_function(x):\n", " y = -1.*x*x*x + 3.*x*x - 10.*x + 4.\n", " #y = np.tanh(x)\n", " return y\n", "\n", "ex_deriv = autograd.grad(ex_function)\n", "\n", "input = 3.\n", "print(\"value of the function: \" + str(ex_function(input)))\n", "print(\"value of the derivative: \" + str(ex_deriv(input)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note: Autograd required inputs to be `float` (`int` will not work!). " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can show this for ranges:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0, 0.5, 'f(x)')" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "deriv1 = autograd.grad(ex_function)\n", "deriv2 = autograd.grad(deriv1)\n", "deriv3 = autograd.grad(deriv2)\n", "\n", "x = np.linspace(-3,3,100, dtype=float)\n", "y = list()\n", "y1 = list()\n", "y2 = list()\n", "y3 = list()\n", "\n", "for i in range(len(x)):\n", " y.append(ex_function(x[i]))\n", " y1.append(deriv1(x[i]))\n", " y2.append(deriv2(x[i]))\n", " y3.append(deriv3(x[i]))\n", "\n", "f, ax = plt.subplots(1)\n", "ax.plot(x,y, label = \"f(x)\", color=plt.get_cmap(\"Blues\")(0.9))\n", "ax.plot(x, y1, label = \"f'(x)\", color=plt.get_cmap(\"Blues\")(0.7))\n", "ax.plot(x, y2, label = \"f''(x)\", color=plt.get_cmap(\"Blues\")(0.5))\n", "ax.plot(x, y3, label = \"f'''(x)\", color=plt.get_cmap(\"Blues\")(0.3))\n", "ax.axhline(0, color=\"black\", linewidth=0.5)\n", "ax.axvline(0, color=\"black\", linewidth=0.5)\n", "#f.legend(loc=(0.75,0.2))\n", "f.legend(loc=\"center right\", bbox_to_anchor=(0.9,0.25), edgecolor=\"black\")\n", "ax.set_xlabel(\"x\")\n", "ax.set_ylabel(\"f(x)\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise - autograd ❗❗\n", "\n", "Just to practice: implement another function and calculate its derivatives using autograd. Plot them similarly to the above example." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# Your code here" ] }, { "cell_type": "markdown", "metadata": { "id": "CKeD4awHYxms" }, "source": [ "## Implementation\n", "\n", "Let's first import the relevant packages:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "from autograd import jacobian\n", "from autograd.misc.optimizers import adam\n", "from autograd.scipy.integrate import odeint\n", "import matplotlib.pyplot as plt\n", "import pandas as pd\n", "import autograd.numpy as np" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we build the neural network. The first function generates random numbers in the shape needed to initialize the neural network. The second function is handed the parameters describing the network as well as an input, and returns the prediction of the network." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "id": "SuiF9j8bgH8j" }, "outputs": [], "source": [ "# initialize random number generator for repeatable results\n", "np.random.seed(0)\n", "\n", "def init_random_params(layer_sizes, scale):\n", " \"\"\"Build a list of weights and biases, one for each layer in the net.\n", " layers is a list with the number of nodes in each layer. Minimum number of layers is three (input, hidden \n", " and output) scale is a constant factor to scale the random values (down or up) if necessary\"\"\"\n", " params = []\n", " for idx in range(len(layer_sizes)-1):\n", " weight_mat_elem = layer_sizes[idx]*layer_sizes[idx+1]\n", " bias_vec_elem = layer_sizes[idx+1]\n", " params = np.append(params, np.random.rand(weight_mat_elem+bias_vec_elem))\n", " return params*scale\n", "\n", "def neural_net_predict(params, inputs):\n", " \"\"\"Implements a (deep) neural network for regression.\n", " params is a list of weights and biases.\n", " inputs is a matrix of input values.\n", " returns network prediction.\"\"\"\n", " # Make sure that params is a vector\n", " params = params.flatten()\n", " # set separator value for easier indexing of the parameters and assigning them to weights and biases \n", " # for each layer\n", " sep = 0\n", " # loop over all layers\n", " for idx in range(len(layer_sizes)-1):\n", " # calculate weight matrix\n", " W = params[sep:sep+layer_sizes[idx]*layer_sizes[idx+1]].reshape(layer_sizes[idx],layer_sizes[idx+1])\n", " # calculate bias vector\n", " b = params[sep+layer_sizes[idx]*layer_sizes[idx+1]:sep+layer_sizes[idx]*layer_sizes[idx+1]\n", " +layer_sizes[idx+1]]\n", " # set new separator value\n", " sep = layer_sizes[idx]*layer_sizes[idx+1]+layer_sizes[idx+1]\n", " # calculate output as weighted sum of inputs plus bias\n", " outputs = np.dot(inputs, W) + b\n", " # apply activation function and assign the result as the input to the next layer \n", " # (note that this has no effect on the output layer)\n", " inputs = 1/(1 + np.exp(-outputs))\n", " return outputs" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's now initialized the model parameters:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "id": "fymDeYGEgQx_" }, "outputs": [], "source": [ "# system parameters\n", "tau = 100\n", "\n", "# inlet concentrations\n", "c_Ain = 0.7\n", "c_Bin = 0.3\n", "c_Xin = 0\n", "\n", "# initial conditions for the concentrations in the reactor\n", "c_A0 = 0.5\n", "c_B0 = 0.5\n", "c_X0 = 0\n", "\n", "# end time for integration\n", "t_end = 100\n", "n_samples = 30\n", "t_span = np.linspace(0, t_end, n_samples)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we implement the mechanistic part of the model:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "id": "RSws_AhogTns" }, "outputs": [], "source": [ "# define system equations\n", "def dcdt(c, t, params):\n", " \"\"\"Mechanistic part of the hybrid model (ODE system describing the time-dependent \n", " concentrations in the reactor)\"\"\"\n", " # disassemble input vector\n", " c_A, c_B, c_X = c\n", " # calculate reaction rates by neural network prediction\n", " r = neural_net_predict(params, c)\n", " #r = 0.08*c_A**0.7*c_B**1.3 # true underlying reaction rate\n", " # system equations\n", " dcdt = [(c_Ain-c_A)/tau - r,\n", " (c_Bin-c_B)/tau - r,\n", " (c_Xin-c_X)/tau + r]\n", " return np.array(dcdt)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we use the autograd package to calculate the jacobian with respect to the system states and the parameters, which we'll need for the sensitivity equations:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "id": "uMenTWFCgXEd" }, "outputs": [], "source": [ "# calculate system jacobian and parameter derivatives by automatic differentiation with autograd\n", "dfdc = autograd.jacobian(dcdt, 0) # system jacobian\n", "dfdp = autograd.jacobian(dcdt, 2) # parameter derivatives" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We write a function that takes in the system variables $y$ at time $t$ and calculates the sensitivities:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "id": "36nAnk9CgdkE" }, "outputs": [], "source": [ "# differential equation system\n", "def DiffEqs(y, t, params):\n", " \"\"\"Hybrid model including the ODE system for the concentrations as well as the sensitivities \n", " that are used for training the neural network part of the model\"\"\"\n", " # disassemble input vector\n", " c = y[:3]\n", " s = y[3:]\n", " # evaluate system jacobian at current point\n", " dfdc_eval = dfdc(c, t, params)\n", " # evaluate parameter derivatives at current point\n", " dfdp_eval = dfdp(c, t, params) # Shape: (3, 1, 16)\n", " \n", " # define sensitivities for all parameters\n", " dcdp = np.zeros(len(s)) # preallocate memory for sensitivities\n", " for i in range(len_p): # loop over all parameters to construct the corresponding sensitivity equations\n", " dcdp[i*len_c:(i+1)*len_c] = (dfdc_eval @ s[i*len_c:(i+1)*len_c]).flatten() + dfdp_eval[:,0,i] \n", " # construct sensitivities (see https://docs.sciml.ai/v4.0/analysis/sensitivity.html#Example-solving-an-\n", " # ODELocalSensitivityProblem-1)\n", " # [c1/w1, c2/w1, c3/w1, c1/w2, ...]\n", " return np.concatenate((dcdt(c, t, params).flatten(), dcdp))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For training the network, the following parameters need to be specified:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "id": "CfOxtugKglVm" }, "outputs": [], "source": [ "# Training parameters\n", "scale = 0.0005\n", "num_epochs = 1000\n", "step_size = 0.001\n", "\n", "# set neural network size\n", "layer_sizes = [3, 3, 1] # no. of nodes in input layer, hidden layer(s) and output layer\n", "\n", "# initialize parameter vector for neural network or load saved parameters\n", "init_params = init_random_params(layer_sizes, scale)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we specify the initial value of the variables:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "id": "7qpT8g6Tg-iV" }, "outputs": [], "source": [ "# assemble initial value vector\n", "c0 = [c_A0, c_B0, c_X0]\n", "len_c = len(c0)\n", "len_p = len(init_params)\n", "s0 = np.zeros((len_p*len_c))\n", "y0 = np.concatenate((c0,s0))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's import the training data" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "if 'google.colab' in str(get_ipython()):\n", " df = pd.read_csv(\"https://raw.githubusercontent.com/edgarsmdn/MLCE_book/main/references/CSTR_ODE_data.txt\", sep=';')\n", "else:\n", " df = pd.read_csv(\"references/CSTR_ODE_data.txt\", sep=';')\n", "c_exp = np.array(df)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The following defines the objective function, also known as loss/risk/error function. First, the model is run, then the difference between experimental data and model prediction is calculated as objective value:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "id": "-CBjYSzWhFPr" }, "outputs": [], "source": [ "def objective(params, iter):\n", " \"\"\"Objective function (sum of squared errors between measurements and model predictions)\"\"\"\n", " # calculate hybrid model in forward direction with odeint\n", " sol = odeint(DiffEqs, y0, t_span, args=(params,))\n", " # disassemble results\n", " c_pred = sol[:,:3] # predicted concentrations\n", " return np.trace((c_pred - c_exp).T @ (c_pred - c_exp))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In order to train the model, we require the gradient of the objective with respect to the parameters:" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "id": "3H6KjJfsiuMO" }, "outputs": [], "source": [ "def objective_grad(params, iter):\n", " \"\"\"Function calculates the gradient of the objective function with respect to the network parameters\"\"\"\n", " sol = odeint(DiffEqs, y0, t_span, args=(params,))\n", " # disassemble results\n", " c_pred = sol[:,:3] # predicted concentrations\n", " sens = sol[:,3:] # sensititvities 16*3=48 -> c1/w1, c2/w1, c3/w1, c1/w2.....\n", " # calculate gradients of the loss function\n", " loss_grad = np.zeros(len_p) # set vector size\n", " for comp_idx in range(len_c):\n", " # For loop is running for each concentration and all parameters\n", " loss_grad += sens[:,comp_idx::3].T @ (c_pred[:,comp_idx] - c_exp[:,comp_idx])\n", " return loss_grad" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally, the following function allows us to print the status of the model during training:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "id": "9MvPw2uiYxmt" }, "outputs": [], "source": [ "def summary(params, iter, gradient):\n", " \"\"\"Callback function gives informative output during optimization\"\"\"\n", " if iter % 10 == 0:\n", " print('step {0:5d}: {1:1.3e}'.format(iter, objective(params, iter)))\n", " np.save('Params', params)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now let's train the model with adam! Remember, adam is a gradient descent method with an adaptive learning rate. It uses both the previous gradients (momentum) and their squares (RMSProp) to calculate the next iteration. \n", "\n", "Note: the code will take a few minutes to run." ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "-w7FV2Ahko7G", "outputId": "6188f026-d1c3-4385-a3df-84cb9209340a" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "step 0: 4.279e+00\n", "step 10: 4.804e-01\n", "step 20: 5.815e-01\n", "step 30: 4.494e-01\n", "step 40: 3.714e-01\n", "step 50: 3.808e-01\n", "step 60: 3.715e-01\n", "step 70: 3.713e-01\n", "step 80: 3.696e-01\n", "step 90: 3.695e-01\n", "step 100: 3.689e-01\n", "step 110: 3.685e-01\n", "step 120: 3.681e-01\n", "step 130: 3.676e-01\n", "step 140: 3.672e-01\n", "step 150: 3.667e-01\n", "step 160: 3.662e-01\n", "step 170: 3.656e-01\n", "step 180: 3.650e-01\n", "step 190: 3.644e-01\n", "step 200: 3.637e-01\n", "step 210: 3.630e-01\n", "step 220: 3.622e-01\n", "step 230: 3.614e-01\n", "step 240: 3.605e-01\n", "step 250: 3.596e-01\n", "step 260: 3.586e-01\n", "step 270: 3.575e-01\n", "step 280: 3.563e-01\n", "step 290: 3.550e-01\n", "step 300: 3.536e-01\n", "step 310: 3.521e-01\n", "step 320: 3.505e-01\n", "step 330: 3.487e-01\n", "step 340: 3.468e-01\n", "step 350: 3.447e-01\n", "step 360: 3.425e-01\n", "step 370: 3.401e-01\n", "step 380: 3.375e-01\n", "step 390: 3.347e-01\n", "step 400: 3.317e-01\n", "step 410: 3.284e-01\n", "step 420: 3.250e-01\n", "step 430: 3.212e-01\n", "step 440: 3.173e-01\n", "step 450: 3.130e-01\n", "step 460: 3.085e-01\n", "step 470: 3.037e-01\n", "step 480: 2.986e-01\n", "step 490: 2.932e-01\n", "step 500: 2.876e-01\n", "step 510: 2.816e-01\n", "step 520: 2.754e-01\n", "step 530: 2.689e-01\n", "step 540: 2.622e-01\n", "step 550: 2.552e-01\n", "step 560: 2.480e-01\n", "step 570: 2.407e-01\n", "step 580: 2.331e-01\n", "step 590: 2.254e-01\n", "step 600: 2.176e-01\n", "step 610: 2.097e-01\n", "step 620: 2.017e-01\n", "step 630: 1.937e-01\n", "step 640: 1.857e-01\n", "step 650: 1.778e-01\n", "step 660: 1.699e-01\n", "step 670: 1.622e-01\n", "step 680: 1.545e-01\n", "step 690: 1.470e-01\n", "step 700: 1.397e-01\n", "step 710: 1.325e-01\n", "step 720: 1.256e-01\n", "step 730: 1.189e-01\n", "step 740: 1.125e-01\n", "step 750: 1.062e-01\n", "step 760: 1.003e-01\n", "step 770: 9.456e-02\n", "step 780: 8.910e-02\n", "step 790: 8.389e-02\n", "step 800: 7.895e-02\n", "step 810: 7.425e-02\n", "step 820: 6.979e-02\n", "step 830: 6.557e-02\n", "step 840: 6.159e-02\n", "step 850: 5.782e-02\n", "step 860: 5.427e-02\n", "step 870: 5.093e-02\n", "step 880: 4.778e-02\n", "step 890: 4.483e-02\n", "step 900: 4.205e-02\n", "step 910: 3.943e-02\n", "step 920: 3.698e-02\n", "step 930: 3.469e-02\n", "step 940: 3.253e-02\n", "step 950: 3.051e-02\n", "step 960: 2.862e-02\n", "step 970: 2.685e-02\n", "step 980: 2.519e-02\n", "step 990: 2.364e-02\n" ] } ], "source": [ "# Optimize the network parameters\n", "optimized_params = adam(objective_grad, init_params, step_size=step_size, num_iters=num_epochs, callback=summary)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's compare model solutions with the initial parameters vs. the optimized parameters. We need to run the model forward in time, first with the initial parameters, then with the parameters optimized in training:" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "id": "-pCQcF2ektY9" }, "outputs": [], "source": [ "sol_init = odeint(DiffEqs, y0, t_span, args=(init_params,))\n", "sol_opt = odeint(DiffEqs, y0, t_span, args=(optimized_params,))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Then we plot the trajectories for the three components, for the untrained model vs. the trained model:" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 279 }, "id": "kU_ngpOHYxmw", "outputId": "afbff4d2-f156-4287-d45d-870f2d2e2470" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# plot system trajectories\n", "plt.figure(1)\n", "plt.plot(t_span, sol_init[:,:len_c],'--')\n", "plt.gca().set_prop_cycle(None)\n", "plt.plot(t_span, sol_opt[:,:len_c])\n", "plt.gca().set_prop_cycle(None)\n", "plt.plot(t_span, c_exp, 'x')\n", "plt.xlabel('t')\n", "plt.ylabel('c')\n", "plt.legend(('initial c_A', 'initial c_B', 'initial c_X', \n", " 'final c_A', 'final c_B', 'final c_X'), loc='upper right',ncol=2) # make a legend\n", "plt.grid()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## References\n", "\n", "```{bibliography}\n", ":filter: docname in docnames\n", "```" ] } ], "metadata": { "colab": { "name": "Hybrid model for CSTR.ipynb", "provenance": [] }, "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.7.15" }, "latex_envs": { "LaTeX_envs_menu_present": true, "autoclose": false, "autocomplete": true, "bibliofile": "biblio.bib", "cite_by": "apalike", "current_citInitial": 1, "eqLabelWithNumbers": true, "eqNumInitial": 1, "hotkeys": { "equation": "Ctrl-E", "itemize": "Ctrl-I" }, "labels_anchors": false, "latex_user_defs": false, "report_style_numbering": false, "user_envs_cfg": false }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": {}, "toc_section_display": true, "toc_window_display": false }, "varInspector": { "cols": { "lenName": 16, "lenType": 16, "lenVar": 40 }, "kernels_config": { "python": { "delete_cmd_postfix": "", "delete_cmd_prefix": "del ", "library": "var_list.py", "varRefreshCmd": "print(var_dic_list())" }, "r": { "delete_cmd_postfix": ") ", "delete_cmd_prefix": "rm(", "library": "var_list.r", "varRefreshCmd": "cat(var_dic_list()) " } }, "oldHeight": 409.25, "position": { "height": "40px", "left": "1266px", "right": "20px", "top": "120px", "width": "250px" }, "types_to_exclude": [ "module", "function", "builtin_function_or_method", "instance", "_Feature" ], "varInspector_section_display": "none", "window_display": true } }, "nbformat": 4, "nbformat_minor": 1 }