From cbe4767c1b7ccc7db95d13e7fb4ebfcba81fa943 Mon Sep 17 00:00:00 2001
From: Kara Lamb <karadlamb@gmail.com>
Date: Mon, 5 Feb 2024 21:30:01 +0000
Subject: [PATCH] Regime dependence

---
 RegimeDependence.ipynb | 514 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 514 insertions(+)
 create mode 100644 RegimeDependence.ipynb

diff --git a/RegimeDependence.ipynb b/RegimeDependence.ipynb
new file mode 100644
index 0000000..530c5b5
--- /dev/null
+++ b/RegimeDependence.ipynb
@@ -0,0 +1,514 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "3c30ab9e-0312-4a76-bf66-009b469edb61",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import zarr\n",
+    "import xarray as xr\n",
+    "import os\n",
+    "from sklearn import preprocessing\n",
+    "import torch\n",
+    "import math\n",
+    "\n",
+    "import torch\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "from torch.autograd import Variable\n",
+    "import torch.utils.data as data_utils\n",
+    "from torch.nn import Linear, Conv1d, ConvTranspose1d\n",
+    "\n",
+    "from torch.nn import Sequential as Seq, Linear as Lin, ReLU, Sigmoid, ConstantPad1d\n",
+    "from torch.functional import F\n",
+    "from torch.optim.lr_scheduler import OneCycleLR\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "from tqdm.notebook import tqdm\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3d33077e-12d5-4beb-bc44-d3a1c74bd794",
+   "metadata": {},
+   "source": [
+    "## Load the data for the case"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "24e33168-4aae-4f68-85eb-a61b5b1dc12c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from models import DriverDatasetCase, VAElatentdynamics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "id": "07e74c67-3806-434f-ba5c-f4692e1085d1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "case = 3 \n",
+    "caseloader=torch.load('/home/jovyan/neural-dsds/neural-dsds/data/case'+str(case)+'loader.pth')\n",
+    "mask = np.load('/home/jovyan/neural-dsds/neural-dsds/data/case'+str(case)+'mask.npy')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "id": "32b15ebf-c1dd-459b-a380-4ba5e6fc18cc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "onecatfile = 'offline_singlecat_referencedetail.nc'\n",
+    "twocatfile = 'offline_79micron_referencedetail.nc'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "id": "9d4fc730-2136-4c56-b96c-c2e48c25216c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "onecatfilepath=os.path.join('/home/jovyan/neural-dsds/neural-dsds/data',onecatfile)\n",
+    "twocatfilepath = os.path.join('/home/jovyan/neural-dsds/neural-dsds/data',twocatfile)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "id": "fbd6c499-3c89-4ee8-8f80-4686a47a0972",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from netCDF4 import Dataset\n",
+    "ds1 = Dataset(onecatfilepath)\n",
+    "ds2 = Dataset(twocatfilepath)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "id": "cd2b9eff-afb1-453f-ac5d-176a92ff49d2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def inference(model,dataloader,device,nlatent):\n",
+    "    model.eval()\n",
+    "    dataset = dataloader.dataset\n",
+    "\n",
+    "    ntargets = nlatent\n",
+    "    nmoms = 4\n",
+    "    nrates = 3\n",
+    "    bs = 500\n",
+    "    print(len(dataset))\n",
+    "    \n",
+    "    pred = np.zeros((len(dataset),ntargets,nrates))\n",
+    "    real = np.zeros((len(dataset),ntargets,nrates))\n",
+    "    \n",
+    "    #[500, 3, 3, 2]) torch.Size([500, 3, 3, 2] \n",
+    "    realM = np.zeros((len(dataset),nmoms,nrates))\n",
+    "    realdMdt = np.zeros((len(dataset),nmoms,nrates))\n",
+    "    \n",
+    "    realbin1 = np.zeros((len(dataset),2,35))\n",
+    "    realbin0 = np.zeros((len(dataset),2,35))\n",
+    "    predbin0 = np.zeros((len(dataset),2,35))\n",
+    "    predbin1 = np.zeros((len(dataset),2,35))\n",
+    " \n",
+    "    Lt0= np.zeros((len(dataset),ntargets))\n",
+    "    predL = np.zeros((len(dataset),ntargets))\n",
+    "    realL = np.zeros((len(dataset),ntargets))\n",
+    "\n",
+    "    jj = 0\n",
+    "    i = 0\n",
+    "\n",
+    "    for data in dataloader:\n",
+    "        M,dMdt,bin0,bin1coal,bin1condevap,binmag,M1,dM1dt,M2,dM2dt=data\n",
+    "        bin1 = bin1coal \n",
+    "        bin0 = bin0.to(device)\n",
+    "        bin1 = bin1.to(device)\n",
+    "        binmag = binmag.to(device)\n",
+    "                             \n",
+    "        normRt0,normRt1,Lit1,Lit1_pred,binmagRt0,binmagRt1,Lit0_cond,mu0,logvar0,mu1,logvar1 = model(torch.Tensor(bin0).float(),\n",
+    "                        torch.Tensor(bin1).float(),binmag[:,0:2].float(),binmag[:,2:4].float())\n",
+    "        bs = normRt0.size(0)\n",
+    "        \n",
+    "        normbin0 = bin0.float()*torch.broadcast_to(binmag[:,0:2].float().unsqueeze(dim=2),(bs,2,35))\n",
+    "        normbin1 = bin1.float()*torch.broadcast_to(binmag[:,2:4].float().unsqueeze(dim=2),(bs,2,35))\n",
+    "        \n",
+    "        if normRt0 is not(None):\n",
+    "\n",
+    "            realM[jj:jj+bs,:,:] = M.cpu().detach().numpy().reshape(bs,nmoms,nrates)\n",
+    "            realdMdt[jj:jj+bs,:,:] = dMdt.cpu().detach().numpy().reshape(bs,nmoms,nrates)\n",
+    "            realbin0[jj:jj+bs,:] = normbin0.cpu().detach().numpy().reshape(bs,2,35)\n",
+    "            realbin1[jj:jj+bs,:] = normbin1.cpu().detach().numpy().reshape(bs,2,35)\n",
+    "            predbin0[jj:jj+bs,:] = normRt0.cpu().detach().numpy().reshape(bs,2,35)\n",
+    "            predbin1[jj:jj+bs,:] = normRt1.cpu().detach().numpy().reshape(bs,2,35)\n",
+    "            predL[jj:jj+bs,:] = Lit1_pred.cpu().detach().numpy().reshape(bs,ntargets)\n",
+    "            realL[jj:jj+bs,:] = Lit1.cpu().detach().numpy().reshape(bs,ntargets)\n",
+    "            Lt0[jj:jj+bs,:] = Lit0_cond.cpu().detach().numpy().reshape(bs,ntargets)\n",
+    "            \n",
+    "            jj=jj+bs\n",
+    "            i = i+1\n",
+    "        else:\n",
+    "            break\n",
+    "\n",
+    "    return realM,realdMdt,realbin0,realbin1,predbin0,predbin1,predL,realL,Lt0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "id": "b1d6abc0-a45b-4c43-839f-052cef1095b4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "cuda:0\n",
+      "VAElatentdynamics(\n",
+      "  (encoder): CNNEncoderVAE(\n",
+      "    (conv1): Conv1d(2, 4, kernel_size=(4,), stride=(2,), padding=(1,))\n",
+      "    (activation1): ReLU()\n",
+      "    (conv2): Conv1d(4, 8, kernel_size=(4,), stride=(2,), padding=(1,))\n",
+      "    (activation2): ReLU()\n",
+      "    (conv3): Conv1d(8, 4, kernel_size=(4,), stride=(2,), padding=(1,))\n",
+      "    (activation3): ReLU()\n",
+      "    (fc_mu): Linear(in_features=16, out_features=3, bias=True)\n",
+      "    (fc_var): Linear(in_features=16, out_features=3, bias=True)\n",
+      "  )\n",
+      "  (decoder): CNNDecoder(\n",
+      "    (lin): Linear(in_features=3, out_features=16, bias=True)\n",
+      "    (conv1): ConvTranspose1d(4, 8, kernel_size=(4,), stride=(2,), padding=(1,))\n",
+      "    (activation1): ReLU()\n",
+      "    (constantpad1d1): ConstantPad1d(padding=(1, 0), value=0)\n",
+      "    (conv2): ConvTranspose1d(8, 4, kernel_size=(4,), stride=(2,), padding=(1,))\n",
+      "    (activation2): ReLU()\n",
+      "    (constantpad1d2): ConstantPad1d(padding=(1, 0), value=0)\n",
+      "    (conv3): ConvTranspose1d(4, 2, kernel_size=(4,), stride=(2,), padding=(1,))\n",
+      "    (activation3): ReLU()\n",
+      "    (lin2): Linear(in_features=35, out_features=35, bias=True)\n",
+      "    (activation4): Sigmoid()\n",
+      "  )\n",
+      "  (L0): LatentTransform(\n",
+      "    (dLidt): Linear(in_features=3, out_features=3, bias=False)\n",
+      "  )\n",
+      ")\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = VAElatentdynamics(n_bins=35,n_latent=3)\n",
+    "\n",
+    "\n",
+    "# Check if there is a gpu\n",
+    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+    "print(device)\n",
+    "print(model)\n",
+    "model = model.to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "id": "4f9bd062-6d4d-4443-b726-14c66559db4f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<All keys matched successfully>"
+      ]
+     },
+     "execution_count": 60,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Load the best model weights\n",
+    "j = 4\n",
+    "epochs = 500\n",
+    "# Check if there is a gpu\n",
+    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+    "\n",
+    "model = model.to(device)\n",
+    "mod_weights = \"LatentDynamicsModels/VAELatentDynamics3var_CNN_n{}_{}epochs_Sigmoid_magnitude_expdynLin_nobias_updatedata_Li_dLdt2_c1e2\".format(j,epochs)\n",
+    "model.load_state_dict(torch.load(mod_weights))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "id": "98052f92-9567-4dcb-b95a-4cdbd9133196",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "14380\n"
+     ]
+    }
+   ],
+   "source": [
+    "nlatent = 3\n",
+    "trainM,traindMdt,trainrealbin0,trainrealbin1,trainpredbin0,trainpredbin1,trainpredL,trainrealL,trainrealL0=inference(model,caseloader,device,nlatent)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "id": "263c56d2-c44f-4d2d-8841-302f2fb587c3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load the moment based representations\n",
+    "moment = 1\n",
+    "nstart=2\n",
+    "cauto = ds2['cauto'][case,moment,nstart:,:]\n",
+    "caccr = ds2['caccr'][case,moment,nstart:,:]\n",
+    "ccoal = ds2['ccoal'][case,moment,nstart:,:]\n",
+    "\n",
+    "auto = ds2['auto'][case,moment,nstart:,:]\n",
+    "accr = ds2['accr'][case,moment,nstart:,:]\n",
+    "coal = ds2['coal'][case,moment,nstart:,:]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "id": "72d21024-9ec4-43cf-a666-ce2d50fcd51c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(14380,)"
+      ]
+     },
+     "execution_count": 63,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mask2=np.log(np.abs(accr/auto)).mask.reshape(719*20)\n",
+    "mask2.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "id": "7cc900af-a3b9-4b39-ad90-18ff99145235",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(14380, 3)"
+      ]
+     },
+     "execution_count": 69,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "trainrealL.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "id": "1858580a-809f-469f-bbd1-7cc309ac10c1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "trainL = trainrealL[~mask2,:]\n",
+    "trainLmask = np.zeros((719*20,nlatent))\n",
+    "trainLmask[~mask2,:]=trainL\n",
+    "trainLmask[mask2,:]=np.nan\n",
+    "plotvar = trainLmask.reshape(719,20,nlatent)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "id": "2ba365ba-6fa2-4618-9b89-d25f6270d841",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def rgblatent(latentvar):\n",
+    "    # would be better to set this as an absolute color\n",
+    "    r = np.zeros((latentvar.shape[0],3))\n",
+    "    r[:,0] = (latentvar[:,0]-np.min(latentvar[:,0]))/(np.max(latentvar[:,0])-np.min(latentvar[:,0]))\n",
+    "    r[:,1] = (latentvar[:,1]-np.min(latentvar[:,1]))/(np.max(latentvar[:,1])-np.min(latentvar[:,1]))\n",
+    "    r[:,2] = (latentvar[:,2]-np.min(latentvar[:,2]))/(np.max(latentvar[:,2])-np.min(latentvar[:,2]))\n",
+    "\n",
+    "    return r"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "id": "f81a248e-2dd5-421e-a639-ac442ba96b16",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "coloredvar = rgblatent(trainLmask)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "id": "44005b4c-239a-4c42-bd4d-9655fcefedcf",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(719, 20, 3)"
+      ]
+     },
+     "execution_count": 73,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "coloredvar.reshape(719,20,nlatent).shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "id": "681d88b3-5c60-4a4d-b973-1a8eb1e5ce96",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.colorbar.Colorbar at 0x7c52adbabc90>"
+      ]
+     },
+     "execution_count": 74,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x1200 with 8 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#visualize regimes in time/space for a specific case\n",
+    "moment = 1\n",
+    "nstart=2\n",
+    "cauto = ds2['cauto'][case,moment,nstart:,:]\n",
+    "caccr = ds2['caccr'][case,moment,nstart:,:]\n",
+    "ccoal = ds2['ccoal'][case,moment,nstart:,:]\n",
+    "\n",
+    "auto = ds2['auto'][case,moment,nstart:,:]\n",
+    "accr = ds2['accr'][case,moment,nstart:,:]\n",
+    "coal = ds2['coal'][case,moment,nstart:,:]\n",
+    "\n",
+    "rh = ds2['cliq_mom'][case,1,:,:]\n",
+    "\n",
+    "vmi = -5\n",
+    "vma = 5\n",
+    "\n",
+    "vmal = 0.6\n",
+    "vmil = -0.6\n",
+    "\n",
+    "np.seterr(divide='ignore', invalid='ignore')\n",
+    "fig, ax = plt.subplots(nrows=4, ncols=1, figsize=(14,12))\n",
+    "\n",
+    "SMALL_SIZE = 14\n",
+    "MEDIUM_SIZE = 14\n",
+    "BIGGER_SIZE = 14\n",
+    "\n",
+    "plt.rc('font', size=SMALL_SIZE)          # controls default text sizes\n",
+    "plt.rc('axes', titlesize=SMALL_SIZE)     # fontsize of the axes title\n",
+    "plt.rc('axes', labelsize=MEDIUM_SIZE)    # fontsize of the x and y labels\n",
+    "plt.rc('xtick', labelsize=SMALL_SIZE)    # fontsize of the tick labels\n",
+    "plt.rc('ytick', labelsize=SMALL_SIZE)    # fontsize of the tick labels\n",
+    "plt.rc('legend', fontsize=SMALL_SIZE)    # legend fontsize\n",
+    "plt.rc('figure', titlesize=BIGGER_SIZE)  # fontsize of the figure title\n",
+    "\n",
+    "ax0 = ax[0] #ax[0,0]\n",
+    "im0=ax0.imshow((np.log(np.abs(accr/auto))).T, aspect=100,cmap=\"bwr\",vmin=vmi,vmax=vma,origin='lower',extent=[1,720,0,2])\n",
+    "ax0.set_title(\"Case {}\".format(case))\n",
+    "ax0.set_xlabel(\"Time (s)\", fontsize=18)\n",
+    "ax0.set_ylabel(\"Height (km)\", fontsize=18)\n",
+    "\n",
+    "ax1 = ax[1]\n",
+    "im1=ax1.imshow(plotvar[:,:,0].T, aspect=100,origin='lower',vmin=vmil,vmax=vmal,cmap=\"jet\",extent=[1,720,0,2])\n",
+    "ax1.set_xlabel(\"Time (s)\", fontsize=18)\n",
+    "ax1.set_ylabel(\"Height (km)\", fontsize=18)\n",
+    "\n",
+    "ax2 = ax[2] \n",
+    "im2=ax2.imshow(plotvar[:,:,1].T, aspect=100,origin='lower',vmin=vmil,vmax=vmal,cmap=\"jet\",extent=[1,720,0,2])\n",
+    "ax2.set_xlabel(\"Time (s)\", fontsize=18)\n",
+    "ax2.set_ylabel(\"Height (km)\", fontsize=18)\n",
+    "\n",
+    "ax3 = ax[3]\n",
+    "im3=ax3.imshow(plotvar[:,:,2].T, aspect=100,origin='lower',vmin=vmil,vmax=vmal,cmap=\"jet\",extent=[1,720,0,2])\n",
+    "ax3.set_xlabel(\"Time (s)\", fontsize=18)\n",
+    "ax3.set_ylabel(\"Height (km)\", fontsize=18)\n",
+    "\n",
+    "fig.subplots_adjust(wspace=0.5,hspace=0.5)\n",
+    "fig.colorbar(im0, label=r\"$Log(|r_{accr}/r_{auto}|)$\",ax=ax0)\n",
+    "fig.colorbar(im1, label=r\"$L_{0}$\",ax=ax1)\n",
+    "fig.colorbar(im2, label=r\"$L_{1}$\",ax=ax2)\n",
+    "fig.colorbar(im3, label=r\"$L_{2}$\",ax=ax3)\n",
+    "\n",
+    "#plt.savefig(\"RateRegimesMassCase3.png\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e2913267-13a9-4640-bdb7-1c8ea4982716",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}