Semi-supervise learning with (1000,500) adversarial examples.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[MLENS] backend: threading\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[pyKeOps]: Warning, no cuda detected. Switching to cpu only.\n"
     ]
    }
   ],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2 \n",
    "%reload_ext autoreload\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# always import gbm_algos first !\n",
    "import xgboost, lightgbm, catboost\n",
    "\n",
    "# Core\n",
    "import numpy as np\n",
    "import scipy.io as io\n",
    "from torch.autograd import grad\n",
    "from torch.utils.data import DataLoader, Dataset\n",
    "\n",
    "# Sklearn\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from mlens.ensemble import SuperLearner\n",
    "\n",
    "# Let's do facy optimizers\n",
    "from optimizers import Lookahead, AdamGC, SGDGC\n",
    "from madgrad import MADGRAD\n",
    "from lbfgsnew import LBFGSNew\n",
    "# Modify at /usr/local/lib/python3.9/site-packages/torch_lr_finder/lr_finder.py\n",
    "from torch_lr_finder import LRFinder\n",
    "from onecyclelr import OneCycleLR\n",
    "import pcgrad\n",
    "from pytorch_stats_loss import torch_wasserstein_loss, torch_energy_loss\n",
    "from geomloss import SamplesLoss\n",
    "from utils import *\n",
    "\n",
    "from tqdm import trange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training with 1000 samples\n",
      "Training with 500 unsup samples\n"
     ]
    }
   ],
   "source": [
    "DATA_PATH = \"/Users/pongpisit/Desktop/research/pinn/Solving-Differential-Equations-with-Neural-Networks/SymbolicMathematics/data/burgers_shock.mat\"\n",
    "data = io.loadmat(DATA_PATH)\n",
    "\n",
    "t = data['t'].flatten()[:,None]\n",
    "x = data['x'].flatten()[:,None]\n",
    "Exact = np.real(data['usol']).T\n",
    "\n",
    "X, T = np.meshgrid(x,t)\n",
    "\n",
    "X_star = np.hstack((X.flatten()[:,None], T.flatten()[:,None]))\n",
    "u_star = Exact.flatten()[:,None]              \n",
    "\n",
    "# Doman bounds\n",
    "lb = X_star.min(0)\n",
    "ub = X_star.max(0)\n",
    "\n",
    "N = 1000\n",
    "print(f\"Training with {N} samples\")\n",
    "idx = np.random.choice(X_star.shape[0], N, replace=False)\n",
    "X_u_train = X_star[idx, :]\n",
    "u_train = u_star[idx,:]\n",
    "\n",
    "# Unsup data\n",
    "N_res = N//2\n",
    "idx_res = np.array(range(X_star.shape[0]-1))[~idx]\n",
    "idx_res = np.random.choice(idx_res.shape[0], N_res, replace=True)\n",
    "X_res = X_star[idx_res, :]\n",
    "print(f\"Training with {N_res} unsup samples\")\n",
    "X_u_train = np.vstack([X_u_train, X_res])\n",
    "u_train = np.vstack([u_train, torch.rand(X_res.shape[0], 1) - 1000])\n",
    "# del X_res\n",
    "\n",
    "# Convert to torch.tensor\n",
    "X_u_train = torch.tensor(X_u_train).float().requires_grad_(True)\n",
    "u_train = torch.tensor(u_train).float().requires_grad_(True)\n",
    "X_star = torch.tensor(X_star).float().requires_grad_(True)\n",
    "u_star = torch.tensor(u_star).float().requires_grad_(True)\n",
    "# lb and ub are used in adversarial training\n",
    "scaling_factor = 1.0\n",
    "lb = scaling_factor*to_tensor(lb, False)\n",
    "ub = scaling_factor*to_tensor(ub, False)\n",
    "feature_names=['uf', 'u_x',  'u_xx', 'u_tt', 'u_xt', 'u_tx']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(self, model):\n",
    "        super(Network, self).__init__()\n",
    "        # pls init the self.model before\n",
    "        self.model = model\n",
    "        # For tracking\n",
    "        self.index2features = ('uf', 'u_x',  'u_xx', 'u_tt', 'u_xt', 'u_tx')\n",
    "        self.uf = None\n",
    "        \n",
    "    def xavier_init(self, m):\n",
    "        if type(m) == nn.Linear:\n",
    "            torch.nn.init.xavier_uniform_(m.weight)\n",
    "            m.bias.data.fill_(0.01)\n",
    "        \n",
    "    def forward(self, x, t):\n",
    "        self.uf = self.model(torch.cat([x, t], dim=1))\n",
    "        return self.uf\n",
    "    \n",
    "    def get_selector_data(self, x, t):\n",
    "        uf = self.forward(x, t)\n",
    "        \n",
    "        ### PDE Loss calculation ###\n",
    "        # first-order derivatives\n",
    "        u_t = self.gradients(uf, t)[0]\n",
    "        u_x = self.gradients(uf, x)[0]\n",
    "        # Homo second-order derivatives\n",
    "        u_tt = self.gradients(u_t,t)[0]\n",
    "        u_xx = self.gradients(u_x, x)[0]\n",
    "        # Hetero second-order derivatives\n",
    "        u_xt = self.gradients(u_t, x)[0]\n",
    "        u_tx = self.gradients(u_x, t)[0]\n",
    "        \n",
    "        X_selector = torch.cat([uf, u_x, u_xx, u_tt, u_xt, u_tx], dim=1)\n",
    "        y_selector = u_t\n",
    "        \n",
    "        return X_selector, y_selector\n",
    "    \n",
    "    def gradients(self, func, x):\n",
    "        return grad(func, x, create_graph=True, retain_graph=True, grad_outputs=torch.ones(func.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Does the SeclectorNetwork has to be a neural networks ???\n",
    "class SeclectorNetwork(nn.Module):\n",
    "    def __init__(self, X_train_dim, bn=None):\n",
    "        super().__init__()\n",
    "        # Nonlinear model, Training with PDE reg.\n",
    "        self.nonlinear_model = TorchMLP(dimensions=[X_train_dim, 50, 50, 1], activation_function=nn.Tanh, bn=bn, dropout=nn.Dropout(p=0.1), inp_drop=False)\n",
    "        \n",
    "    def xavier_init(self, m):\n",
    "        if type(m) == nn.Linear:\n",
    "            torch.nn.init.xavier_uniform_(m.weight)\n",
    "            m.bias.data.fill_(0.01)\n",
    "        \n",
    "    def forward(self, inn):\n",
    "        ut_approx = self.nonlinear_model(inn)\n",
    "        return ut_approx\n",
    "    \n",
    "    def loss(self, X_input, y_input):\n",
    "        ut_approx = self.forward(X_input)\n",
    "        mse_loss = F.mse_loss(ut_approx, y_input, reduction='mean')\n",
    "        return mse_loss\n",
    "\n",
    "class SemiSupModel(nn.Module):\n",
    "    def __init__(self, network, selector, normalize_derivative_features=False, mini=None, maxi=None):\n",
    "        super(SemiSupModel, self).__init__()\n",
    "        self.network = network\n",
    "        self.selector = selector\n",
    "        self.normalize_derivative_features = normalize_derivative_features\n",
    "        self.mini = mini\n",
    "        self.maxi = maxi\n",
    "    def forward(self, X_u_train):\n",
    "        X_selector, y_selector = self.network.get_selector_data(*dimension_slicing(X_u_train))\n",
    "        if self.normalize_derivative_features:\n",
    "            X_selector = (X_selector-self.mini)/(self.maxi-self.mini)\n",
    "        unsup_loss = self.selector.loss(X_selector, y_selector)\n",
    "        return self.network.uf, unsup_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Use pretrained weights\n"
     ]
    }
   ],
   "source": [
    "# network = Network(model=TorchMLP(dimensions=[6, 50, 50, 50 ,50, 50, 1], bn=nn.BatchNorm1d))\n",
    "# selector = SeclectorNetwork(X_train_dim=6, bn=nn.LayerNorm)\n",
    "\n",
    "### Version without normalized derivatives ###\n",
    "# semisup_model = SemiSupModel(network=Network(model=TorchMLP(dimensions=[2, 50, 50, 50 ,50, 50, 1], activation_function=nn.Tanh, bn=nn.LayerNorm, dropout=None)),\n",
    "#                              selector=SeclectorNetwork(X_train_dim=6, bn=nn.LayerNorm),\n",
    "#                              normalize_derivative_features=False, \n",
    "#                              mini=None, \n",
    "#                              maxi=None)\n",
    "\n",
    "### Version with normalized derivatives ###\n",
    "pretrained_state_dict = torch.load('./saved_path_inverse_burger/lbfgsnew_results/semisup_model_with_LayerNormDropout_without_physical_reg_trained1000labeledsamples_trained0unlabeledsamples_1.6e-06.pth')\n",
    "network_state_dict = None\n",
    "is_pretrained = True\n",
    "semisup_model = SemiSupModel(network=Network(model=TorchMLP(dimensions=[2, 50, 50, 50 ,50, 50, 1], activation_function=nn.Tanh, bn=nn.LayerNorm, dropout=None)),\n",
    "                             selector=SeclectorNetwork(X_train_dim=6, bn=nn.LayerNorm),\n",
    "                             normalize_derivative_features=True, \n",
    "                             mini=None, \n",
    "                             maxi=None)\n",
    "if is_pretrained:\n",
    "    print(\"Use pretrained weights\")\n",
    "    semisup_model.load_state_dict(pretrained_state_dict)\n",
    "    network_state_dict = semisup_model.network.state_dict()\n",
    "    semisup_model.eval()\n",
    "    referenced_derivatives, _ = semisup_model.network.get_selector_data(*dimension_slicing(X_star))\n",
    "    semisup_model.mini = torch.min(referenced_derivatives, axis=0)[0].detach().requires_grad_(False)\n",
    "    semisup_model.maxi = torch.max(referenced_derivatives, axis=0)[0].detach().requires_grad_(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pcgrad_closure():\n",
    "    global N, X_u_train, u_train\n",
    "    uf, unsup_loss = semisup_model(X_u_train)\n",
    "    losses = [F.mse_loss(uf[:N, :], u_train), unsup_loss]\n",
    "    updated_grads = []\n",
    "    \n",
    "    for i in range(2):\n",
    "        optimizer1.zero_grad()\n",
    "        losses[i].backward(retain_graph=True)\n",
    "\n",
    "        g_task = []\n",
    "        for param in semisup_model.parameters():\n",
    "            if param.grad is not None:\n",
    "                g_task.append(Variable(param.grad.clone(), requires_grad=False))\n",
    "            else:\n",
    "                g_task.append(Variable(torch.zeros(param.shape), requires_grad=False))\n",
    "        # appending the gradients from each task\n",
    "        updated_grads.append(g_task)\n",
    "\n",
    "    updated_grads = list(pcgrad.pc_grad_update(updated_grads))[0]\n",
    "    for idx, param in enumerate(semisup_model.parameters()):\n",
    "        param.grad = (updated_grads[0][idx]+updated_grads[1][idx])\n",
    "        \n",
    "    return sum(losses)\n",
    "\n",
    "def closure():\n",
    "    global N, X_u_train, u_train\n",
    "    if torch.is_grad_enabled():\n",
    "        optimizer2.zero_grad()\n",
    "    mse_loss = F.mse_loss(semisup_model.network(*dimension_slicing(X_u_train))[:N, :], u_train)\n",
    "    if mse_loss.requires_grad:\n",
    "        mse_loss.backward(retain_graph=False)\n",
    "    return mse_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate finding\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "373988bbdd7a485d9ce2d331075dc790",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=300.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping early, the loss has diverged\n",
      "\n",
      "Learning rate search finished. See the graph with {finder_name}.plot()\n",
      "LR suggestion: steepest gradient\n",
      "Suggested LR: 3.48E-07\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Deleted the fake labels used in Learning rate finder\n"
     ]
    }
   ],
   "source": [
    "params = semisup_model.parameters()\n",
    "\n",
    "### For SGD and Adam ###\n",
    "learning_rate1, learning_rate2 = 1e-7, 1e-1\n",
    "\n",
    "### For LBFGS (a good choice already!!!) ###\n",
    "# print(\"Using LBFGS's learning rate set\")\n",
    "# learning_rate1, learning_rate2 = 8e-2, 5e-2 # (1e-1, 5e-2) is also OK!\n",
    "\n",
    "choice = 'MAD'; auto_lr = True\n",
    "if choice == 'LBFGS':\n",
    "    optimizer1 = torch.optim.LBFGS(params, lr=learning_rate1, \n",
    "                                   max_iter=100, max_eval=125, \n",
    "                                  history_size=120, line_search_fn='strong_wolfe')\n",
    "if choice == 'Adam':\n",
    "    optimizer1 = AdamGC(params, lr=learning_rate1, use_gc=True, gc_conv_only=False, gc_loc=False)\n",
    "if choice == 'SGD':\n",
    "    optimizer1 = SGDGC(params, lr=learning_rate1, use_gc=True, nesterov=True, momentum=0.95)\n",
    "if choice == 'MAD':\n",
    "    optimizer1 = MADGRAD(params, lr=learning_rate1, momentum=0.9)\n",
    "\n",
    "if choice != 'LBFGS' and auto_lr:\n",
    "    print('Learning rate finding')\n",
    "    bs = 4000; bs = X_u_train.shape[0] if bs>X_u_train.shape[0] else bs\n",
    "    criterion = LadderLoss(return_list=True)\n",
    "    trainloader = get_dataloader(X_u_train, u_train, bs=bs)\n",
    "    \n",
    "    lr_finder = LRFinder(semisup_model, optimizer=optimizer1, \n",
    "                         closure=pcgrad_update, criterion=criterion, device=\"cpu\")\n",
    "    lr_finder.range_test(trainloader, val_loader=None, end_lr=100, num_iter=300)\n",
    "    \n",
    "    # to inspect the loss-learning rate graph\n",
    "    suggested_lr, _ = lr_finder.plot()\n",
    "    # To prevent divergence during the second stage training.\n",
    "    # suggested_lr = min(suggested_lr, 5e-3)\n",
    "    lr_finder.reset(); plt.show()\n",
    "\n",
    "else:\n",
    "    lr_finder = None\n",
    "    suggested_lr = None\n",
    "    \n",
    "print(\"Deleted the fake labels used in Learning rate finder\")\n",
    "u_train = u_train[:N, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the learing_rate to the suggested one.\n",
    "# suggested_lr = 1e-5\n",
    "\n",
    "if lr_finder and suggested_lr:\n",
    "    optimizer1 = lr_finder.optimizer\n",
    "\n",
    "for g in optimizer1.param_groups:\n",
    "    g['lr'] = suggested_lr\n",
    "\n",
    "epochs1 = 300; epochs2 = 30000;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Setting up the generator\n",
    "generator = TorchMLP([2, 50, 50, 2])\n",
    "# generator_training_epochs indicates how string the generator is\n",
    "adv_f = 100; generator_training_epochs = 300; generator_training_limit = epochs1-100\n",
    "# I can use the Learning rate finder to find a good lr for the generator optim  as well\n",
    "generator_optimizer = torch.optim.SGD(generator.parameters(), lr=3e-4, momentum=0.95)\n",
    "sinkhorn_loss = SamplesLoss(\"sinkhorn\", p=2, blur=1.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experiments with the generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/300 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training the generator for \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 300/300 [00:52<00:00,  5.66it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The best generator loss: -2.6131134033203125\n",
      "Semi-supervised solver loss @Epoch 0:  1.1830030679702759\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 1/300 [00:00<00:54,  5.45it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training the generator for \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 300/300 [00:55<00:00,  5.45it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The best generator loss: -0.5488461852073669\n",
      "Semi-supervised solver loss @Epoch 100:  0.49460431933403015\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 1/300 [00:00<00:54,  5.46it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training the generator for \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 300/300 [01:03<00:00,  4.74it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The best generator loss: -0.12598395347595215\n",
      "Semi-supervised solver loss @Epoch 200:  0.25751250982284546\n"
     ]
    }
   ],
   "source": [
    "curr_loss = 1000; F_print = 10 if choice == 'LBFGS' else 100\n",
    "\n",
    "# Stage I\n",
    "# How long should I pretrain selector part of the model?\n",
    "for _ in range(1):\n",
    "    # Reinit the semisup_model.network weights\n",
    "    semisup_model.network.load_state_dict(network_state_dict)\n",
    "    for i in range(epochs1):\n",
    "        if i%adv_f==0 and i<=generator_training_limit:\n",
    "            best_generator_loss = 1000; best_generator_state_dict = None\n",
    "            o_tensor = X_u_train[:N, :] # or X_u_train ?\n",
    "            print(\"Training the generator for \")\n",
    "            for _ in trange(generator_training_epochs):\n",
    "                semisup_model.eval()\n",
    "                generator.train()\n",
    "                generator_optimizer.zero_grad()\n",
    "                X_gen = scale_to_range(generator(o_tensor), lb, ub)\n",
    "                unsup_loss = semisup_model(X_gen)[1]\n",
    "#                 d_loss = F.mse_loss(X_gen, o_tensor)\n",
    "                d_loss = F.mse_loss(X_gen, o_tensor)\n",
    "                generator_loss = d_loss-unsup_loss\n",
    "                generator_loss.backward(retain_graph=True)\n",
    "                generator_optimizer.step()\n",
    "                # Saving the best_generator_state_dict\n",
    "                if generator_loss.item() < best_generator_loss:\n",
    "                    best_generator_loss = generator_loss.item()\n",
    "                    best_generator_state_dict = generator.state_dict()\n",
    "\n",
    "            print(\"The best generator loss:\", best_generator_loss)\n",
    "            generator.load_state_dict(best_generator_state_dict)\n",
    "            generator.eval()\n",
    "            X_gen = scale_to_range(generator(o_tensor), lb, ub)\n",
    "            if N_res<X_gen.shape[0]: X_gen = sampling_from_rows(X_gen, N_res)\n",
    "            X_u_train = torch.cat([X_u_train[:N, :], X_gen], dim=0).detach().requires_grad_(True)\n",
    "\n",
    "        semisup_model.train()\n",
    "        generator_optimizer.zero_grad()\n",
    "        optimizer1.step(pcgrad_closure)\n",
    "        l = pcgrad_closure()\n",
    "        if (i % F_print) == 0:\n",
    "            if l.item() != curr_loss:\n",
    "                curr_loss = l.item()\n",
    "            else:\n",
    "                print(\"Semi-supervised solver loss @Epoch {}: \".format(i), curr_loss)\n",
    "                print(\"Finishing the first stage\")\n",
    "                break\n",
    "            print(\"Semi-supervised solver loss @Epoch {}: \".format(i), curr_loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer2 = LBFGSNew(semisup_model.network.parameters(), \n",
    "                              lr=learning_rate2, max_iter=100, max_eval=125, \n",
    "                              history_size=120, line_search_fn=True, batch_mode=False)\n",
    "\n",
    "# optimizer2 = torch.optim.LBFGS(semisup_model.network.parameters(), \n",
    "#                               lr=learning_rate2, max_iter=100, max_eval=125, \n",
    "#                               history_size=120, line_search_fn='strong_wolfe')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0:  3.842959358735243e-06\n",
      "Epoch 100:  8.522012251432898e-08\n",
      "Epoch 200:  4.024239430577836e-08\n",
      "Epoch 300:  2.511194097110092e-08\n",
      "Epoch 400:  1.718848530174455e-08\n",
      "Epoch 500:  1.3011965727116603e-08\n",
      "Epoch 600:  9.626741181989473e-09\n",
      "Epoch 700:  7.783191868782069e-09\n",
      "Epoch 800:  6.3591096832738e-09\n",
      "Epoch 900:  5.336173725112303e-09\n",
      "Epoch 1000:  4.752135573937721e-09\n",
      "Epoch 1100:  3.7544483078022495e-09\n",
      "Epoch 1200:  3.473671128517708e-09\n",
      "Epoch 1300:  3.2415539141794625e-09\n",
      "Epoch 1400:  2.893987716134916e-09\n",
      "Epoch 1500:  2.8184969913525038e-09\n",
      "Epoch 1600:  2.7347366593488687e-09\n",
      "Epoch 1700:  2.6620621262907207e-09\n",
      "Epoch 1800:  2.426969292201875e-09\n",
      "Epoch 1900:  2.3300499307765676e-09\n",
      "Epoch 2000:  2.305162949411965e-09\n",
      "Epoch 2100:  2.2286934520110435e-09\n",
      "Epoch 2200:  2.077052529969592e-09\n",
      "Epoch 2300:  2.0651655940895353e-09\n",
      "Epoch 2400:  1.876311328530278e-09\n",
      "Epoch 2500:  1.8673951274195133e-09\n",
      "Epoch 2600:  1.850965491989598e-09\n",
      "Epoch 2700:  1.8079802099890685e-09\n",
      "Epoch 2800:  1.8040476890135437e-09\n",
      "Epoch 2900:  1.7530991103242854e-09\n",
      "Epoch 3000:  1.7109771377477045e-09\n",
      "Epoch 3100:  1.7052180778520665e-09\n",
      "Epoch 3200:  1.7015111541951455e-09\n",
      "Epoch 3300:  1.6567031080327865e-09\n",
      "Epoch 3400:  1.5923905527515103e-09\n",
      "Epoch 3500:  1.573983499092435e-09\n",
      "Epoch 3600:  1.5684011867023173e-09\n",
      "Epoch 3700:  1.5602028557992753e-09\n",
      "Epoch 3800:  1.5370417161264527e-09\n",
      "Epoch 3900:  1.4911242240955858e-09\n",
      "Epoch 4000:  1.4769652167956338e-09\n",
      "Epoch 4100:  1.4728913644290742e-09\n",
      "Epoch 4200:  1.468911436930398e-09\n",
      "Epoch 4300:  1.4603659392875556e-09\n",
      "Epoch 4400:  1.4214545096535858e-09\n",
      "Epoch 4500:  1.3800099951666311e-09\n",
      "Epoch 4600:  1.36447864118594e-09\n",
      "Epoch 4700:  1.3581316071764604e-09\n",
      "Epoch 4800:  1.3522510888819284e-09\n",
      "Epoch 4900:  1.3342073001965105e-09\n",
      "Epoch 5000:  1.273205318952364e-09\n",
      "Epoch 5100:  1.2607782595708272e-09\n",
      "Epoch 5200:  1.2575530616842912e-09\n",
      "Epoch 5300:  1.2519576486624828e-09\n",
      "Epoch 5400:  1.2480286804006369e-09\n",
      "Epoch 5500:  1.2419280048803216e-09\n",
      "Epoch 5600:  1.230990198664017e-09\n",
      "Epoch 5700:  1.2153982265061813e-09\n",
      "Epoch 5800:  1.195142096399593e-09\n",
      "Epoch 5900:  1.1864556004326232e-09\n",
      "Epoch 6000:  1.1795322496510607e-09\n",
      "Epoch 6100:  1.1740790561987069e-09\n",
      "Epoch 6200:  1.170961438923257e-09\n",
      "Epoch 6300:  1.149354722507212e-09\n",
      "Epoch 6400:  1.1326682924917009e-09\n",
      "Epoch 6500:  1.1210599115685227e-09\n",
      "Epoch 6600:  1.1133031163623741e-09\n",
      "Epoch 6700:  1.1068266303482233e-09\n",
      "Epoch 6800:  1.098054536186055e-09\n",
      "Epoch 6900:  1.092828383342237e-09\n",
      "Epoch 7000:  1.087875900473989e-09\n",
      "Epoch 7100:  1.07184239261926e-09\n",
      "Epoch 7200:  1.0649835457954282e-09\n",
      "Epoch 7300:  1.0583165455102517e-09\n",
      "Epoch 7400:  1.0556420182439297e-09\n",
      "Epoch 7500:  1.0525330607080718e-09\n",
      "Epoch 7600:  1.0515143200606758e-09\n",
      "Epoch 7700:  1.0479693779430477e-09\n",
      "Epoch 7800:  1.0449328069483954e-09\n",
      "Epoch 7900:  1.0366857372545724e-09\n",
      "Epoch 8000:  1.0304276321093653e-09\n",
      "Epoch 8100:  1.0232528158127252e-09\n",
      "Epoch 8200:  1.0114008519579443e-09\n",
      "Epoch 8300:  1.0007477069251536e-09\n",
      "Epoch 8400:  9.952940693835899e-10\n",
      "Epoch 8500:  9.907992204460925e-10\n",
      "Epoch 8600:  9.832372693807656e-10\n",
      "Epoch 8700:  9.80608927392268e-10\n",
      "Epoch 8800:  9.79199166195599e-10\n",
      "Epoch 8900:  9.76846270539511e-10\n",
      "Epoch 9000:  9.76154490572867e-10\n",
      "Epoch 9100:  9.744246520781985e-10\n",
      "Epoch 9200:  9.738481132615107e-10\n",
      "Epoch 9300:  9.720068083751698e-10\n",
      "Epoch 9400:  9.70412750156413e-10\n",
      "Epoch 9500:  9.660496846919386e-10\n",
      "Epoch 9600:  9.594873784379843e-10\n",
      "Epoch 9700:  9.441720738578852e-10\n",
      "Epoch 9800:  9.333788186793868e-10\n",
      "Epoch 9900:  9.180222693139228e-10\n",
      "Epoch 10000:  9.112559595791936e-10\n",
      "Epoch 10100:  9.054039740163944e-10\n",
      "Epoch 10200:  8.963542130757673e-10\n",
      "Epoch 10300:  8.947158014471768e-10\n",
      "Epoch 10400:  8.907308779448897e-10\n",
      "Epoch 10500:  8.856104738441672e-10\n",
      "Epoch 10600:  8.832687359294766e-10\n",
      "Epoch 10700:  8.747947366494202e-10\n",
      "Epoch 10800:  8.721074973294662e-10\n",
      "Epoch 10900:  8.633566639382195e-10\n",
      "Epoch 11000:  8.518706851035063e-10\n",
      "Epoch 11100:  8.457201605693854e-10\n",
      "Epoch 11200:  8.407100571261594e-10\n",
      "Epoch 11300:  8.32123481231406e-10\n",
      "Epoch 11400:  8.245868987621918e-10\n",
      "Epoch 11500:  8.171482379637496e-10\n",
      "Epoch 11600:  8.148473007452139e-10\n",
      "Epoch 11700:  8.125755623922259e-10\n",
      "Epoch 11800:  8.068714030251556e-10\n",
      "Epoch 11900:  8.027731257520543e-10\n",
      "Epoch 12000:  7.986670769177806e-10\n",
      "Epoch 12100:  7.909620736157308e-10\n",
      "Epoch 12200:  7.785764810641638e-10\n",
      "Epoch 12300:  7.661274392667394e-10\n",
      "Epoch 12400:  7.610143071268283e-10\n",
      "Epoch 12500:  7.57047591282145e-10\n",
      "Epoch 12600:  7.526319567574546e-10\n",
      "Epoch 12700:  7.472302776534434e-10\n",
      "Epoch 12800:  7.446405714262028e-10\n",
      "Epoch 12900:  7.415898450879865e-10\n",
      "Epoch 13000:  7.367825238802084e-10\n",
      "Epoch 13100:  7.32620852872401e-10\n",
      "Epoch 13200:  7.282434100197577e-10\n",
      "Epoch 13300:  7.219215225617859e-10\n",
      "Epoch 13400:  7.141268132393463e-10\n",
      "Epoch 13500:  7.115718014816252e-10\n",
      "Epoch 13600:  7.09966585521471e-10\n",
      "Epoch 13700:  7.073990282435716e-10\n",
      "Epoch 13800:  7.053799766509883e-10\n",
      "Epoch 13900:  7.008775226857722e-10\n",
      "Epoch 14000:  6.934760543586549e-10\n",
      "Epoch 14100:  6.904363747395337e-10\n",
      "Epoch 14200:  6.897130089278392e-10\n",
      "Epoch 14300:  6.892195147933933e-10\n",
      "Epoch 14400:  6.869924074059952e-10\n",
      "Epoch 14500:  6.865433777036856e-10\n",
      "Epoch 14600:  6.844732003408183e-10\n",
      "Epoch 14700:  6.829579679568099e-10\n",
      "Epoch 14800:  6.822892251179269e-10\n",
      "Epoch 14900:  6.800716656485406e-10\n",
      "Epoch 15000:  6.791714968201745e-10\n",
      "Epoch 15100:  6.769073634949052e-10\n",
      "Epoch 15200:  6.752755576933112e-10\n",
      "Epoch 15300:  6.727621237878623e-10\n",
      "Epoch 15400:  6.714104827665324e-10\n",
      "Epoch 15500:  6.681555864140876e-10\n",
      "Epoch 15600:  6.659347517867786e-10\n",
      "Epoch 15700:  6.638883887077895e-10\n",
      "Epoch 15800:  6.625703874441058e-10\n",
      "Epoch 15900:  6.586895473503773e-10\n",
      "Epoch 16000:  6.57305876394787e-10\n",
      "Epoch 16100:  6.546654884864722e-10\n",
      "Epoch 16200:  6.523073192710171e-10\n",
      "Epoch 16300:  6.509102701279801e-10\n",
      "Epoch 16400:  6.485806336442579e-10\n",
      "Epoch 16500:  6.482436809562842e-10\n",
      "Epoch 16600:  6.468294788675166e-10\n",
      "Epoch 16700:  6.464748736334514e-10\n",
      "Epoch 16800:  6.453583223375858e-10\n",
      "Epoch 16900:  6.438676813935729e-10\n",
      "Epoch 17000:  6.436584598645823e-10\n",
      "Epoch 17100:  6.421256859567848e-10\n",
      "Epoch 17200:  6.414624942330249e-10\n",
      "Epoch 17300:  6.402276486738856e-10\n",
      "Epoch 17400:  6.397016250048182e-10\n",
      "Epoch 17500:  6.412542719047565e-10\n",
      "Epoch 17600:  6.389379580973298e-10\n",
      "Epoch 17700:  6.38019859167116e-10\n",
      "Epoch 17800:  6.370675098565926e-10\n",
      "Epoch 17900:  6.36372454732026e-10\n",
      "Epoch 18000:  6.322790069290818e-10\n",
      "Epoch 18100:  6.309079925159722e-10\n",
      "Epoch 18200:  6.299615828986305e-10\n",
      "Epoch 18300:  6.291018261883607e-10\n",
      "Epoch 18400:  6.272150576691615e-10\n",
      "Epoch 18500:  6.255588824721769e-10\n",
      "Epoch 18600:  6.243199290878465e-10\n",
      "Epoch 18700:  6.197879431901754e-10\n",
      "Epoch 18800:  6.179098899217195e-10\n",
      "Epoch 18900:  6.141196440268004e-10\n",
      "Epoch 19000:  6.096179117065503e-10\n",
      "Epoch 19100:  6.07556116527519e-10\n",
      "Epoch 19200:  6.060205115510087e-10\n",
      "Epoch 19300:  6.052740531004019e-10\n",
      "Epoch 19400:  6.000527297267411e-10\n",
      "Epoch 19500:  5.993440743701228e-10\n",
      "Epoch 19600:  5.980511086356444e-10\n",
      "Epoch 19700:  5.971977357077662e-10\n",
      "Epoch 19800:  5.956603543744166e-10\n",
      "Epoch 19900:  5.944794101431228e-10\n",
      "Epoch 20000:  5.938758373957853e-10\n",
      "Epoch 20100:  5.933500357713228e-10\n",
      "Epoch 20200:  5.927547896966701e-10\n",
      "Epoch 20300:  5.918001089177949e-10\n",
      "Epoch 20400:  5.897696775392092e-10\n",
      "Epoch 20500:  5.880876896569021e-10\n",
      "Epoch 20600:  5.877922037988981e-10\n",
      "Epoch 20700:  5.864216334749983e-10\n",
      "Epoch 20800:  5.854803863947211e-10\n",
      "Epoch 20900:  5.844557060541433e-10\n",
      "Epoch 21000:  5.843475703315448e-10\n",
      "Epoch 21100:  5.83035564272194e-10\n",
      "Epoch 21200:  5.82615955480037e-10\n",
      "Epoch 21300:  5.822228810181684e-10\n",
      "Epoch 21400:  5.807712089023198e-10\n",
      "Epoch 21500:  5.799846714005241e-10\n",
      "Epoch 21600:  5.796790270018448e-10\n",
      "Epoch 21700:  5.781927159276279e-10\n",
      "Epoch 21800:  5.76740988300628e-10\n",
      "Epoch 21900:  5.756295440306758e-10\n",
      "Epoch 22000:  5.743123199231093e-10\n",
      "Epoch 22100:  5.739054786957354e-10\n",
      "Epoch 22200:  5.726484841872548e-10\n",
      "Epoch 22300:  5.685132364874335e-10\n",
      "Epoch 22400:  5.672526892652741e-10\n",
      "Epoch 22500:  5.649377077254769e-10\n",
      "Epoch 22600:  5.644568146223605e-10\n",
      "Epoch 22700:  5.638067790414425e-10\n",
      "Epoch 22800:  5.629702815035387e-10\n",
      "Epoch 22900:  5.61499402529364e-10\n",
      "Epoch 23000:  5.613277065386058e-10\n",
      "Epoch 23100:  5.591217488998268e-10\n",
      "Epoch 23200:  5.587376672444577e-10\n",
      "Epoch 23300:  5.582598827658103e-10\n",
      "Epoch 23400:  5.585187867751529e-10\n",
      "Epoch 23500:  5.568721039850288e-10\n",
      "Epoch 23600:  5.55863743922913e-10\n",
      "Epoch 23700:  5.555371718202196e-10\n",
      "Epoch 23800:  5.552781012774233e-10\n",
      "Epoch 23900:  5.548410064726284e-10\n",
      "Epoch 24000:  5.551569204342854e-10\n",
      "Epoch 24100:  5.537770242369788e-10\n",
      "Epoch 24200:  5.533614122477104e-10\n",
      "Epoch 24300:  5.529244284652179e-10\n",
      "Epoch 24400:  5.522726720386117e-10\n",
      "Epoch 24500:  5.51387935310288e-10\n",
      "Epoch 24600:  5.502132083279321e-10\n",
      "Epoch 24700:  5.487488241584515e-10\n",
      "Epoch 24800:  5.475395692400298e-10\n",
      "Epoch 24900:  5.472088338009939e-10\n",
      "Epoch 25000:  5.460929486389432e-10\n",
      "Epoch 25100:  5.458257734680672e-10\n",
      "Epoch 25200:  5.440190520289434e-10\n",
      "Epoch 25300:  5.435339400783334e-10\n",
      "Epoch 25400:  5.438081651654159e-10\n",
      "Epoch 25500:  5.42593359131871e-10\n",
      "Epoch 25600:  5.417480353209214e-10\n",
      "Epoch 25700:  5.404635072814301e-10\n",
      "Epoch 25800:  5.397735591827768e-10\n",
      "Epoch 25900:  5.389432233826597e-10\n",
      "Epoch 26000:  5.373798073193825e-10\n",
      "Epoch 26100:  5.364790833795041e-10\n",
      "Epoch 26200:  5.349844456326025e-10\n",
      "Epoch 26300:  5.343659958967351e-10\n",
      "Epoch 26400:  5.32938693176277e-10\n",
      "Epoch 26500:  5.314010342871711e-10\n",
      "Epoch 26600:  5.284505610880785e-10\n",
      "Epoch 26700:  5.287088544747576e-10\n",
      "Epoch 26800:  5.279133241664624e-10\n",
      "Epoch 26900:  5.287585924662608e-10\n",
      "Epoch 27000:  5.286167614748649e-10\n",
      "Epoch 27100:  5.282337900425205e-10\n",
      "Epoch 27200:  5.276274417376214e-10\n",
      "Epoch 27300:  5.279152115456043e-10\n",
      "Epoch 27400:  5.276237780016402e-10\n",
      "Epoch 27500:  5.275245240632387e-10\n",
      "Epoch 27600:  5.275250236635998e-10\n",
      "Epoch 27700:  5.267907221551127e-10\n",
      "Epoch 27800:  5.26358012731265e-10\n",
      "Epoch 27900:  5.264137459271012e-10\n",
      "Epoch 28000:  5.260732405254487e-10\n",
      "Epoch 28100:  5.256018953403441e-10\n",
      "Epoch 28200:  5.257129731539578e-10\n",
      "Epoch 28300:  5.253456003551094e-10\n",
      "Epoch 28400:  5.25194054912248e-10\n",
      "Epoch 28500:  5.248279033587266e-10\n",
      "Epoch 28600:  5.237060229923429e-10\n",
      "Epoch 28700:  5.240606837375594e-10\n",
      "Epoch 28800:  5.232388411435807e-10\n",
      "Epoch 28900:  5.23365184523783e-10\n",
      "Epoch 29000:  5.221398313715042e-10\n",
      "Epoch 29100:  5.21735543657087e-10\n",
      "Epoch 29200:  5.204733866115419e-10\n",
      "Epoch 29300:  5.20207210641388e-10\n",
      "Epoch 29400:  5.190914365016397e-10\n",
      "Epoch 29500:  5.180281203998049e-10\n",
      "Epoch 29600:  5.157890781148922e-10\n",
      "Epoch 29700:  5.137966163637486e-10\n",
      "Epoch 29800:  5.127371305313488e-10\n",
      "Epoch 29900:  5.119067947312317e-10\n"
     ]
    }
   ],
   "source": [
    "curr_loss = 1000\n",
    "# Stage II\n",
    "semisup_model.train()\n",
    "for i in range(epochs2):\n",
    "    optimizer2.step(closure)\n",
    "    l = closure()\n",
    "    if (i % 100) == 0:\n",
    "        if l.item() != curr_loss:\n",
    "            curr_loss = l.item()\n",
    "        else:\n",
    "            print(\"Finishing the second stage\")\n",
    "            break\n",
    "        print(\"Epoch {}: \".format(i), curr_loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing\n",
      "Test MSE: 4.8e-07\n"
     ]
    }
   ],
   "source": [
    "print(\"Testing\")\n",
    "semisup_model.network.eval()\n",
    "# Compare btw the two semi-supervise learning?\n",
    "test_performance = F.mse_loss(semisup_model.network(*dimension_slicing(X_star)).detach(), u_star).item()\n",
    "string_test_performance = scientific2string(test_performance)\n",
    "print('Test MSE:', string_test_performance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving\n"
     ]
    }
   ],
   "source": [
    "# BEST-2000: 1e-06 (LBFGS)\n",
    "# For saving the plain neural networks.\n",
    "print(\"Saving\")\n",
    "MODEL_PATH = './saved_path_inverse_burger/lbfgsnew_results/semisup_model_with_LayerNormDropout_without_physical_reg_trained1000labeledsamples_trained500unlabeledsamples_'+string_test_performance+'.pth'\n",
    "torch.save(semisup_model.state_dict(), MODEL_PATH)\n",
    "\n",
    "# torch.save(semisup_model.state_dict(), \"./saved_path_inverse_burger/semisup_model_with_LayerNormDropout_without_physical_reg_trained2000labeledsamples_trained1000unlabeledsamples.pth\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loading the best model and testing\n",
    "# semisup_model.load_state_dict(torch.load(MODEL_PATH), strict=False)\n",
    "# semisup_model.eval()\n",
    "# F.mse_loss(semisup_model.network(*dimension_slicing(X_star)).detach(), u_star)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# derivatives_test, dynamics_test = semisup_model.network.get_selector_data(*dimension_slicing(X_star))\n",
    "# derivatives_train, dynamics_train = semisup_model.network.get_selector_data(*dimension_slicing(X_u_train))\n",
    "\n",
    "# derivatives_test, dynamics_test = to_numpy(derivatives_test), to_numpy(dynamics_test)\n",
    "# derivatives_train, dynamics_train = to_numpy(derivatives_train), to_numpy(dynamics_train)\n",
    "\n",
    "# np.save(\"./saved_path_inverse_burger/lbfgsnew_results/data/derivatives-2000-V1.npy\", derivatives_train)\n",
    "# np.save(\"./saved_path_inverse_burger/lbfgsnew_results/data/dynamics-2000-V1.npy\", dynamics_train)\n",
    "# np.save(\"./saved_path_inverse_burger/lbfgsnew_results/data/derivatives-25600-V1.npy\", derivatives_test)\n",
    "# np.save(\"./saved_path_inverse_burger/lbfgsnew_results/data/dynamics-25600-V1.npy\", dynamics_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "original_samples = to_numpy(X_u_train[:N, :])\n",
    "generated_samples = to_numpy(X_gen)\n",
    "x = original_samples[:, 0:1]\n",
    "t = original_samples[:, 1:2]\n",
    "x_g = generated_samples[:, 0:1]\n",
    "t_g = generated_samples[:, 1:2]\n",
    "plt.scatter(t, x, label='Original')\n",
    "plt.scatter(t_g, x_g, label='Gen')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}