{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# KNO for 1D Burgers\n",
    "\n",
    "[![DownloadNotebook](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.1/resource/_static/logo_notebook_en.svg)](https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/r2.1/mindflow/en/data_driven/mindspore_burgers_KNO1D.ipynb) [![DownloadCode](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.1/resource/_static/logo_download_code_en.svg)](https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/r2.1/mindflow/en/data_driven/mindspore_burgers_KNO1D.py) [![ViewSource](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.1/resource/_static/logo_source_en.svg)](https://gitee.com/mindspore/docs/blob/r2.1/docs/mindflow/docs/source_en/data_driven/burgers_KNO1D.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Overview\n",
    "\n",
    "Computational fluid dynamics is one of the most important techniques in the field of fluid mechanics in the 21st century. The flow analysis, prediction and control can be realized by solving the governing equations of fluid mechanics by numerical method. Traditional finite element method (FEM) and finite difference method (FDM) are inefficient because of the complex simulation process (physical modeling, meshing, numerical discretization, iterative solution, etc.) and high computing costs. Therefore, it is necessary to improve the efficiency of fluid simulation with AI.\n",
    "\n",
    "Machine learning methods provide a new paradigm for scientific computing by providing a fast solver similar to traditional methods. Classical neural networks learn mappings between finite dimensional spaces and can only learn solutions related to a specific discretization. Different from traditional neural networks, Fourier Neural Operator (FNO) is a new deep learning architecture that can learn mappings between infinite-dimensional function spaces. It directly learns mappings from arbitrary function parameters to solutions to solve a class of partial differential equations.  Therefore, it has a stronger generalization capability. More information can be found in the paper, [Fourier Neural Operator for Parametric Partial Differential Equations](https://arxiv.org/abs/2010.08895).\n",
    "\n",
    "But these kinds of neural operator become less accurate and explainable while learning long-term behaviours of non-linear PDE families. Koopman neural operator (KNO), a new neural operator, overcome these challenges by formulating a non-linear dynamic system of equation solution. By approximating the Koopman operator, an infnite-dimensional linear operator governing all possible observations of the dynamic system, to act on the flow mapping of dynamic system, we can equivalently learn the solution of an entire non-linear PDE family by solving simple linear prediction problems. More information can be found in these papers:\n",
    "\n",
    "- \"[Koopman neural operator as a mesh-free solver of non-linear partial differential equations](https://arxiv.org/abs/2301.10022).\" arXiv preprint arXiv:2301.10022 (2023).\n",
    "- \"[KoopmanLab: machine learning for solving complex physics equations](https://arxiv.org/abs/2301.01104).\" arXiv preprint arXiv:2301.01104 (2023).\n",
    "\n",
    "This tutorial describes how to solve the 1-d Burgers' equation using Koopman neural operator."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Burgers' equation\n",
    "\n",
    "The 1-d Burgers’ equation is a non-linear PDE with various applications including modeling the one\n",
    "dimensional flow of a viscous fluid. It takes the form\n",
    "\n",
    "$$\n",
    "\\partial_t u(x, t)+\\partial_x (u^2(x, t)/2)=\\nu \\partial_{xx} u(x, t), \\quad x \\in(0,1), t \\in(0, 1]\n",
    "$$\n",
    "\n",
    "$$\n",
    "u(x, 0)=u_0(x), \\quad x \\in(0,1)\n",
    "$$\n",
    "\n",
    "where $u$ is the velocity field, $u_0$ is the initial condition and $\\nu$ is the viscosity coefficient.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Problem Description\n",
    "\n",
    "We aim to learn the operator mapping the initial condition to the solution at time one:\n",
    "\n",
    "$$\n",
    "u_0 \\mapsto u(\\cdot, 1)\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Technology Path\n",
    "\n",
    "MindSpore Flow solves the problem as follows:\n",
    "\n",
    "1. Training Dataset Construction.\n",
    "2. Model Construction.\n",
    "3. Optimizer and Loss Function.\n",
    "4. Model Training.\n",
    "5. Model Evaluation and Visualization."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Koopman Neural Operator\n",
    "\n",
    "The following figure shows the architecture of the Koopman Neural Operator, which contains the upper and lower main branches and corresponding outputs. In the figure, Input represents the initial vorticity. In the upper branch, the input vector is lifted to higher dimension channel space by the Encoding layer. Then the mapping result is used as the input of the Koopman layer to perform nonlinear transformation of the frequency domain information. Finally, the Decoding layer maps the transformation result to the Prediction. At the same time, the lower branch does high-dimensional mapping of the input vector through the Encoding Layer, and then reconstructs the input through the Decoding Layer. The Encoding layers of the upper and lower branches share the weight, and the Decoding layers share the weight too. Prediction is used to calculate the prediction error with Label, and Reconstruction is used to calculate the reconstruction error with Input. The two errors together guide the gradient calculation of the model.\n",
    "\n",
    "The Koopman Neural Operator consists of the Encoding Layer, Koopman Layers, Decoding Layer and two branches.\n",
    "\n",
    "The Koopman Layer is shown in the dotted box, which could be repeated. Start from input: apply the Fourier transform(FFT); apply a linear transformation on the lower Fourier modes and filters out the higher modes; then apply the inverse Fourier transform(iFFT). Then the output is added into input. Finally, the Koopman Layer output vector is obtained through the activation function.\n",
    "\n",
    "![Fourier Layer structure](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.1/docs/mindflow/docs/source_en/data_driven/images/kno.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import datetime\n",
    "import numpy as np\n",
    "\n",
    "import mindspore\n",
    "from mindspore import nn, context, ops, Tensor, set_seed\n",
    "from mindspore.nn.loss import MSELoss\n",
    "\n",
    "from mindflow.cell import KNO1D\n",
    "from mindflow.common import get_warmup_cosine_annealing_lr\n",
    "from mindflow.utils import load_yaml_config"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "The following `src` pacakage can be downloaded in [applications/data_driven/burgers_kno/src](https://gitee.com/mindspore/mindscience/tree/r0.3/MindFlow/applications/data_driven/burgers_kno/src)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pid: 9647\n",
      "2023-03-04 08:03:20.885806\n"
     ]
    }
   ],
   "source": [
    "from src.dataset import create_training_dataset\n",
    "from src.trainer import BurgersWithLoss\n",
    "from src.utils import visual\n",
    "\n",
    "set_seed(0)\n",
    "np.random.seed(0)\n",
    "\n",
    "print(\"pid:\", os.getpid())\n",
    "print(datetime.datetime.now())\n",
    "\n",
    "context.set_context(mode=context.GRAPH_MODE, device_target='Ascend', device_id=1)\n",
    "use_ascend = context.get_context(attr_key='device_target') == \"Ascend\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "You can get hyperparameters of model, data and optimizer from [config](https://gitee.com/mindspore/mindscience/blob/r0.3/MindFlow/applications/data_driven/burgers_kno/burgers1d.yaml)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "config = load_yaml_config('burgers1d.yaml')\n",
    "data_params = config[\"data\"]\n",
    "model_params = config[\"model\"]\n",
    "optimizer_params = config[\"optimizer\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Training Dataset Construction\n",
    "\n",
    "Download the training and test dataset: [data_driven/burgers/dataset](https://download.mindspore.cn/mindscience/mindflow/dataset/applications/data_driven/burgers/dataset/) .\n",
    "\n",
    "In this case, training datasets and test datasets are generated according to Zongyi Li's dataset in [Fourier Neural Operator for Parametric Partial Differential Equations](https://arxiv.org/pdf/2010.08895.pdf) . The settings are as follows:\n",
    "\n",
    "the initial condition $u_0(x)$ is generated according to periodic boundary conditions:\n",
    "\n",
    "$$\n",
    "u_0 \\sim \\mu, \\mu=\\mathcal{N}\\left(0,625(-\\Delta+25 I)^{-2}\\right)\n",
    "$$\n",
    "\n",
    "We set the viscosity to $\\nu=0.1$ and solve the equation using a split step method where the heat equation part is solved exactly in Fourier space then the non-linear part is advanced, again in Fourier space, using a very fine forward Euler method. The number of samples in the training set is 1000, and the number of samples in the test set is 200.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data preparation finished\n",
      "input_path:  (1000, 1024, 1)\n",
      "label_path:  (1000, 1024)\n",
      "Data preparation finished\n",
      "input_path:  (200, 1024, 1)\n",
      "label_path:  (200, 1024)\n"
     ]
    }
   ],
   "source": [
    "# create training dataset\n",
    "train_dataset = create_training_dataset(data_params, shuffle=True)\n",
    "\n",
    "# create test dataset\n",
    "eval_dataset = create_training_dataset(\n",
    "    data_params, shuffle=False, is_train=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Model Construction\n",
    "\n",
    "The network is composed of 1 shared Encoding Layer, multiple Koopman Layers and 1 shared Decoding Layer:\n",
    "\n",
    "- The Encoding Layer corresponds to the `KNO2D.enc` in the case, and maps the output data to the high dimension;\n",
    "- Koopman Layer corresponds to the `KNO2D.koopman_layer` in the case. Discrete Fourier transform is used to realize the conversion between time domain and frequency domain;\n",
    "- The Decoding Layer corresponds to `KNO2D.dec` in the case to obtain the final predictive value.\n",
    "\n",
    "Initialize the model based on the network above. Hyperparameters can be modified in config."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name:KNO1D_channels:32_modes:64_depths:4_resolution:1024\n"
     ]
    }
   ],
   "source": [
    "model = KNO1D(in_channels=data_params['in_channels'],\n",
    "              channels=model_params['channels'],\n",
    "              modes=model_params['modes'],\n",
    "              depths=model_params['depths'],\n",
    "              resolution=model_params['resolution']\n",
    "              )\n",
    "\n",
    "model_params_list = []\n",
    "for k, v in model_params.items():\n",
    "    model_params_list.append(f\"{k}:{v}\")\n",
    "model_name = \"_\".join(model_params_list)\n",
    "print(model_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Optimizer and Loss Function\n",
    "\n",
    "Use the mean square error as the training loss function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "train_size = train_dataset.get_dataset_size()\n",
    "eval_size = eval_dataset.get_dataset_size()\n",
    "\n",
    "lr = get_warmup_cosine_annealing_lr(lr_init=optimizer_params[\"lr\"],\n",
    "                                    last_epoch=optimizer_params[\"epochs\"],\n",
    "                                    steps_per_epoch=train_size,\n",
    "                                    warmup_epochs=1)\n",
    "optimizer = nn.AdamWeightDecay(model.trainable_params(),\n",
    "                               learning_rate=Tensor(lr),\n",
    "                               weight_decay=optimizer_params[\"weight_decay\"])\n",
    "model.set_train()\n",
    "loss_fn = MSELoss()\n",
    "if use_ascend:\n",
    "    from mindspore.amp import DynamicLossScaler, auto_mixed_precision, all_finite\n",
    "    loss_scaler = DynamicLossScaler(1024, 2, 100)\n",
    "    auto_mixed_precision(model, 'O3')\n",
    "else:\n",
    "    loss_scaler = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Model Training\n",
    "\n",
    "With **MindSpore version >= 2.0.0**, we can use the functional programming for training neural networks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "./summary_dir/name:KNO1D_channels:32_modes:64_depths:4_resolution:1024\n",
      "epoch: 1, time cost: 18.375901, recons loss: 0.295517, pred loss: 0.085093\n",
      "epoch: 2, time cost: 2.577698, recons loss: 0.161718, pred loss: 0.002227\n",
      "epoch: 3, time cost: 2.564470, recons loss: 0.027144, pred loss: 0.000992\n",
      "epoch: 4, time cost: 2.547690, recons loss: 0.000782, pred loss: 0.000511\n",
      "epoch: 5, time cost: 2.532924, recons loss: 0.000057, pred loss: 0.000279\n",
      "epoch: 6, time cost: 2.536904, recons loss: 0.000048, pred loss: 0.000241\n",
      "epoch: 7, time cost: 2.527330, recons loss: 0.000048, pred loss: 0.000213\n",
      "epoch: 8, time cost: 2.536032, recons loss: 0.000048, pred loss: 0.000227\n",
      "epoch: 9, time cost: 2.462490, recons loss: 0.000048, pred loss: 0.000230\n",
      "epoch: 10, time cost: 2.564090, recons loss: 0.000049, pred loss: 0.000229\n",
      "---------------------------start evaluation-------------------------\n",
      "Eval epoch: 10, recons loss: 4.7733558130858e-05, relative pred loss: 0.01156728882342577\n",
      "---------------------------end evaluation---------------------------\n",
      "\n",
      "...\n",
      "\n",
      "epoch: 91, time cost: 2.662080, recons loss: 0.000042, pred loss: 0.000006\n",
      "epoch: 92, time cost: 2.604443, recons loss: 0.000042, pred loss: 0.000007\n",
      "epoch: 93, time cost: 2.576527, recons loss: 0.000042, pred loss: 0.000006\n",
      "epoch: 94, time cost: 2.621569, recons loss: 0.000042, pred loss: 0.000006\n",
      "epoch: 95, time cost: 2.578712, recons loss: 0.000042, pred loss: 0.000006\n",
      "epoch: 96, time cost: 2.607216, recons loss: 0.000042, pred loss: 0.000006\n",
      "epoch: 97, time cost: 2.588060, recons loss: 0.000042, pred loss: 0.000006\n",
      "epoch: 98, time cost: 2.911451, recons loss: 0.000042, pred loss: 0.000006\n",
      "epoch: 99, time cost: 2.542502, recons loss: 0.000042, pred loss: 0.000006\n",
      "epoch: 100, time cost: 2.514851, recons loss: 0.000042, pred loss: 0.000006\n",
      "---------------------------start evaluation-------------------------\n",
      "Eval epoch: 100, recons loss: 4.17057997037773e-05, relative pred loss: 0.004054672718048095\n",
      "---------------------------end evaluation---------------------------\n"
     ]
    }
   ],
   "source": [
    "problem = BurgersWithLoss(model, data_params[\"out_channels\"], loss_fn)\n",
    "\n",
    "def forward_fn(inputs, labels):\n",
    "    loss, l_recons, l_pred = problem.get_loss(inputs, labels)\n",
    "    if use_ascend:\n",
    "        loss = loss_scaler.scale(loss)\n",
    "    return loss, l_recons, l_pred\n",
    "\n",
    "grad_fn = ops.value_and_grad(forward_fn, None, optimizer.parameters, has_aux=True)\n",
    "\n",
    "def train_step(inputs, labels):\n",
    "    (loss, l_recons, l_pred), grads = grad_fn(inputs, labels)\n",
    "    if use_ascend:\n",
    "        loss = loss_scaler.unscale(loss)\n",
    "        if all_finite(grads):\n",
    "            grads = loss_scaler.unscale(grads)\n",
    "    loss = ops.depend(loss, optimizer(grads))\n",
    "    return loss, l_recons, l_pred\n",
    "\n",
    "def eval_step(inputs, labels):\n",
    "    return problem.get_rel_loss(inputs, labels)\n",
    "\n",
    "train_sink = mindspore.data_sink(train_step, train_dataset, sink_size=1)\n",
    "eval_sink = mindspore.data_sink(eval_step, eval_dataset, sink_size=1)\n",
    "\n",
    "summary_dir = os.path.join(config[\"summary_dir\"], model_name)\n",
    "os.makedirs(summary_dir, exist_ok=True)\n",
    "print(summary_dir)\n",
    "\n",
    "for epoch in range(1, optimizer_params[\"epochs\"] + 1):\n",
    "    time_beg = time.time()\n",
    "    l_recons_train = 0.0\n",
    "    l_pred_train = 0.0\n",
    "    for _ in range(train_size):\n",
    "        _, l_recons, l_pred = train_sink()\n",
    "        l_recons_train += l_recons.asnumpy()\n",
    "        l_pred_train += l_pred.asnumpy()\n",
    "    l_recons_train = l_recons_train / train_size\n",
    "    l_pred_train = l_pred_train / train_size\n",
    "    print(f\"epoch: {epoch}, time cost: {(time.time() - time_beg):>8f},\"\n",
    "          f\" recons loss: {l_recons_train:>8f}, pred loss: {l_pred_train:>8f}\")\n",
    "\n",
    "    if epoch % config['eval_interval'] == 0:\n",
    "        l_recons_eval = 0.0\n",
    "        l_pred_eval = 0.0\n",
    "        print(\"---------------------------start evaluation-------------------------\")\n",
    "        for _ in range(eval_size):\n",
    "            l_recons, l_pred = eval_sink()\n",
    "            l_recons_eval += l_recons.asnumpy()\n",
    "            l_pred_eval += l_pred.asnumpy()\n",
    "        l_recons_eval = l_recons_eval / eval_size\n",
    "        l_pred_eval = l_pred_eval / eval_size\n",
    "        print(f'Eval epoch: {epoch}, recons loss: {l_recons_eval},'\n",
    "              f' relative pred loss: {l_pred_eval}')\n",
    "        print(\"---------------------------end evaluation---------------------------\")\n",
    "        mindspore.save_checkpoint(model, ckpt_file_name=summary_dir + '/save_model.ckpt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Model Evaluation and Visualization\n",
    "\n",
    "Take 6 samples, and do 10 consecutive steps of prediction. Visualize the prediction as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 7 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Infer and plot some data.\n",
    "inputs = np.load(os.path.join(data_params[\"path\"], \"test/inputs.npy\"))  # (200,1024,1)\n",
    "problem = BurgersWithLoss(model, 10, loss_fn)\n",
    "visual(problem, inputs)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.13 ('ms_torch': conda)",
   "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.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "18d517ad782f4af88457d7728181a1bbe8dd4413f6d6fb70c713f7a70ee9d7f9"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}