Semi-supervise learning with (250,125) 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 250 samples\n",
      "Training with 125 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 = 250\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, index2features = ('uf', 'u_x',  'u_xx', 'u_tt', 'u_xt', 'u_tx')):\n",
    "        super(Network, self).__init__()\n",
    "        # pls init the self.model before\n",
    "        self.model = model\n",
    "        # For tracking, the default tup is for the burgers' equation.\n",
    "        self.index2features = index2features\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": [
    "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": [
      "Using old implementation of TorchMLP. See models.py for more new model-related source code.\n",
      "Using old implementation of TorchMLP. See models.py for more new model-related source code.\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_trained250labeledsamples_trained0unlabeledsamples_2.2e-03.pth')\n",
    "network_state_dict = None\n",
    "use_pretrained_weights = False\n",
    "lets_pretrain = 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 use_pretrained_weights:\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": "markdown",
   "metadata": {},
   "source": [
    "#### You can pretrain the semisup_model if pretrained weights are not provided"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pretraining\n",
      "Epoch 0:  4.375875960249687e-06\n",
      "Test MSE: 8.5e-04\n",
      "Epoch 100:  2.4230496364907594e-07\n",
      "Test MSE: 7.2e-04\n",
      "Computing derivatives features\n"
     ]
    }
   ],
   "source": [
    "if lets_pretrain:\n",
    "    print(\"Pretraining\")\n",
    "    pretraining_optimizer = LBFGSNew(semisup_model.network.parameters(), \n",
    "                                     lr=1e-1, max_iter=300, \n",
    "                                     max_eval=int(300*1.25), history_size=120, \n",
    "                                     line_search_fn=True, batch_mode=False)\n",
    "\n",
    "    semisup_model.train()\n",
    "    for i in range(200):\n",
    "        def pretraining_closure():\n",
    "            global N, X_u_train, u_train\n",
    "            if torch.is_grad_enabled():\n",
    "                pretraining_optimizer.zero_grad()\n",
    "            # Only focusing on first [:N, :] elements\n",
    "            mse_loss = F.mse_loss(semisup_model.network(*dimension_slicing(X_u_train))[:N, :], u_train[:N, :])\n",
    "            if mse_loss.requires_grad:\n",
    "                mse_loss.backward(retain_graph=False)\n",
    "            return mse_loss\n",
    "\n",
    "        pretraining_optimizer.step(pretraining_closure)\n",
    "\n",
    "        l = pretraining_closure()\n",
    "        if (i % 100) == 0:\n",
    "            curr_loss = l.item()\n",
    "            print(\"Epoch {}: \".format(i), curr_loss)\n",
    "\n",
    "            # Sneak on the test performance...\n",
    "            semisup_model.network.eval()\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)\n",
    "    \n",
    "    print(\"Computing derivatives features\")\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": 7,
   "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": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate finding\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6eb9925144774651a0ef22e87829115b",
       "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.73E-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": 9,
   "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 = 10000;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using old implementation of TorchMLP. See models.py for more new model-related source code.\n"
     ]
    }
   ],
   "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": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  1%|          | 2/300 [00:00<00:21, 13.61it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training the generator for \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 300/300 [00:20<00:00, 14.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The best generator loss: -1.300350546836853\n",
      "Semi-supervised solver loss @Epoch 0:  1.1012123823165894\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  1%|          | 2/300 [00:00<00:27, 10.89it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training the generator for \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 300/300 [00:21<00:00, 13.67it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The best generator loss: -0.38608336448669434\n",
      "Semi-supervised solver loss @Epoch 100:  0.40373706817626953\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  1%|          | 2/300 [00:00<00:17, 16.64it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training the generator for \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 300/300 [00:18<00:00, 16.44it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The best generator loss: -0.3976665735244751\n",
      "Semi-supervised solver loss @Epoch 200:  0.28162938356399536\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 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": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0:  8.4718396919925e-07\n",
      "Epoch 100:  1.1283788836635722e-07\n",
      "Epoch 200:  7.535419399573584e-08\n",
      "Epoch 300:  5.370054978470762e-08\n",
      "Epoch 400:  4.179691615036063e-08\n",
      "Epoch 500:  3.3153749967596013e-08\n",
      "Epoch 600:  2.7751077880111552e-08\n",
      "Epoch 700:  2.5824840932386905e-08\n",
      "Epoch 800:  2.326346226766418e-08\n",
      "Epoch 900:  2.0732056071892657e-08\n",
      "Epoch 1000:  1.9267114126364504e-08\n",
      "Epoch 1100:  1.7761456305720458e-08\n",
      "Epoch 1200:  1.6106650235769848e-08\n",
      "Epoch 1300:  1.5523420771046403e-08\n",
      "Epoch 1400:  1.4363633837888301e-08\n",
      "Epoch 1500:  1.3836245038589823e-08\n",
      "Epoch 1600:  1.3079943350646772e-08\n",
      "Epoch 1700:  1.239070179792634e-08\n",
      "Epoch 1800:  1.0966076935403635e-08\n",
      "Epoch 1900:  9.849411952700393e-09\n",
      "Epoch 2000:  9.41160216427761e-09\n",
      "Epoch 2100:  8.34190760912179e-09\n",
      "Epoch 2200:  7.793817147216942e-09\n",
      "Epoch 2300:  7.48415995843743e-09\n",
      "Epoch 2400:  6.732988833135778e-09\n",
      "Epoch 2500:  6.472983038463553e-09\n",
      "Epoch 2600:  6.125263407597004e-09\n",
      "Epoch 2700:  6.105383310028856e-09\n",
      "Epoch 2800:  5.926514390353077e-09\n",
      "Epoch 2900:  5.576253681027765e-09\n",
      "Epoch 3000:  5.519715351454124e-09\n",
      "Epoch 3100:  5.20515053281656e-09\n",
      "Epoch 3200:  5.16638154479665e-09\n",
      "Epoch 3300:  5.167562378005641e-09\n",
      "Epoch 3400:  5.086216336991356e-09\n",
      "Epoch 3500:  4.6771475581408595e-09\n",
      "Epoch 3600:  4.54199744481798e-09\n",
      "Epoch 3700:  4.520810836794453e-09\n",
      "Epoch 3800:  4.513733831146283e-09\n",
      "Epoch 3900:  4.412573417766907e-09\n",
      "Epoch 4000:  3.875099352512734e-09\n",
      "Epoch 4100:  3.831738037973764e-09\n",
      "Epoch 4200:  3.811456927849122e-09\n",
      "Epoch 4300:  3.761368994048553e-09\n",
      "Epoch 4400:  3.534859072118479e-09\n",
      "Epoch 4500:  3.2391138660159413e-09\n",
      "Epoch 4600:  3.156814365468108e-09\n",
      "Epoch 4700:  3.120508740295236e-09\n",
      "Epoch 4800:  3.0794862215799412e-09\n",
      "Epoch 4900:  2.8664459694738298e-09\n",
      "Epoch 5000:  2.6519157980686714e-09\n",
      "Epoch 5100:  2.6186888213430848e-09\n",
      "Epoch 5200:  2.6129343133618477e-09\n",
      "Epoch 5300:  2.6085416049426158e-09\n",
      "Epoch 5400:  2.6059872038075582e-09\n",
      "Epoch 5500:  2.604655158222613e-09\n",
      "Epoch 5600:  2.5996864660982055e-09\n",
      "Epoch 5700:  2.574535917787557e-09\n",
      "Epoch 5800:  2.539686905222993e-09\n",
      "Epoch 5900:  2.4328106196236376e-09\n",
      "Epoch 6000:  2.331458581750212e-09\n",
      "Epoch 6100:  2.2341495320432614e-09\n",
      "Epoch 6200:  2.125294384924814e-09\n",
      "Epoch 6300:  2.0695420932526076e-09\n",
      "Epoch 6400:  2.02823180472933e-09\n",
      "Epoch 6500:  2.0056858396344523e-09\n",
      "Epoch 6600:  1.97877003671465e-09\n",
      "Epoch 6700:  1.9428503250651374e-09\n",
      "Epoch 6800:  1.9159125397294474e-09\n",
      "Epoch 6900:  1.882747069359425e-09\n",
      "Epoch 7000:  1.822922368610591e-09\n",
      "Epoch 7100:  1.7653898343183982e-09\n",
      "Epoch 7200:  1.7286594378163045e-09\n",
      "Epoch 7300:  1.7131274177017985e-09\n",
      "Epoch 7400:  1.701175200707894e-09\n",
      "Epoch 7500:  1.6951527959108148e-09\n",
      "Epoch 7600:  1.68279390422299e-09\n",
      "Epoch 7700:  1.6690476778435936e-09\n",
      "Epoch 7800:  1.658157611217348e-09\n",
      "Epoch 7900:  1.6522707646515755e-09\n",
      "Epoch 8000:  1.6488129750413805e-09\n",
      "Epoch 8100:  1.6446799477876084e-09\n",
      "Epoch 8200:  1.635771740282621e-09\n",
      "Epoch 8300:  1.6230420341045715e-09\n",
      "Epoch 8400:  1.594035015095585e-09\n",
      "Epoch 8500:  1.5042032064371824e-09\n",
      "Epoch 8600:  1.470392252400643e-09\n",
      "Epoch 8700:  1.4184245999970813e-09\n",
      "Epoch 8800:  1.3967277334714367e-09\n",
      "Epoch 8900:  1.38493005952256e-09\n",
      "Epoch 9000:  1.3780938612484306e-09\n",
      "Epoch 9100:  1.3714804847353435e-09\n",
      "Epoch 9200:  1.3679132271349204e-09\n",
      "Epoch 9300:  1.364409030202296e-09\n",
      "Epoch 9400:  1.3557014399978584e-09\n",
      "Epoch 9500:  1.3471478377269364e-09\n",
      "Epoch 9600:  1.324671594638005e-09\n",
      "Epoch 9700:  1.2929450843301993e-09\n",
      "Epoch 9800:  1.2524182801953998e-09\n",
      "Epoch 9900:  1.222081325025215e-09\n"
     ]
    }
   ],
   "source": [
    "optimizer2 = LBFGSNew(semisup_model.network.parameters(), \n",
    "                              lr=learning_rate2, max_iter=300, max_eval=int(300*1.25),\n",
    "                              history_size=120, line_search_fn=True, batch_mode=False)\n",
    "\n",
    "curr_loss = 1000\n",
    "# Stage II\n",
    "semisup_model.train()\n",
    "for i in range(10000):\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.1e-04\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_trained250labeledsamples_trained125unlabeledsamples_'+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": 15,
   "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": 16,
   "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": 17,
   "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
}