From 73b6f85db270f16f23e398798b765533affd34ab Mon Sep 17 00:00:00 2001 From: Yiyu Ni Date: Tue, 13 Aug 2024 09:56:28 -0700 Subject: [PATCH] update Signed-off-by: Yiyu Ni --- .gitignore | 1 + README.md | 8 +- ...aining.ipynb => training_RFFN_KKFLS.ipynb} | 227 +++++++++++------- ...ining.ipynb => training_SHRED_KKFLS.ipynb} | 157 +++--------- ...ining.ipynb => training_SIREN_KKFLS.ipynb} | 187 ++++++--------- scripts/datasets.py | 65 +++++ scripts/models.py | 67 ++++++ scripts/utils.py | 35 +++ 8 files changed, 433 insertions(+), 314 deletions(-) rename notebooks/{RFFN_KKFLS_training.ipynb => training_RFFN_KKFLS.ipynb} (96%) rename notebooks/{SHRED_KKFLS_training.ipynb => training_SHRED_KKFLS.ipynb} (72%) rename notebooks/{SIREN_KKFLS_training.ipynb => training_SIREN_KKFLS.ipynb} (99%) create mode 100644 scripts/datasets.py create mode 100644 scripts/models.py create mode 100644 scripts/utils.py diff --git a/.gitignore b/.gitignore index 44542bb..0b4d697 100644 --- a/.gitignore +++ b/.gitignore @@ -14,6 +14,7 @@ figures/INR/*.pdf *.out *.mov *.key +SYNC.sh # docs shall not be uploaded docs/manuscript/ diff --git a/README.md b/README.md index 64e97cd..b58ebfa 100644 --- a/README.md +++ b/README.md @@ -8,16 +8,16 @@ This study explores wavefield reconstruction using machine learning methods for This repository provides independent notebook examples of model training and inference performed in the manuscript. All codes are implemented in PyTorch. ### SHallow REcurrent Decoder -The notebook of SHRED model training is available at [notebooks/SHRED_KKFLS_training.ipynb](./notebooks/SHRED_KKFLS_training.ipynb). See below for instructions of getting the training data. +The notebook of SHRED model training on the CI DAS data is available at [notebooks/training_SHRED_KKFLS.ipynb](./notebooks/training_SHRED_KKFLS.ipynb). See below for instructions of getting the training data. ![SHRED](./docs/shred.png) ### Implicit Neural Representation ![SIREN_vs_RFFN](./docs/siren_vs_rffn_50_40epoch.gif) -- Random Fourier Feature Network (RFFN, [Tancik et al., 2020](https://arxiv.org/abs/2006.10739)): [notebooks/RFFN_KKFLS_training.ipynb](./notebooks/RFFN_KKFLS_training.ipynb) -- Sinusoidal Representation Network (SIREN, [Sitzmann et al., 2020](https://arxiv.org/abs/2006.09661)): [notebooks/SIREN_KKFLS_training.ipynb](./notebooks/SIREN_KKFLS_training.ipynb) +- Random Fourier Feature Network (RFFN, [Tancik et al., 2020](https://arxiv.org/abs/2006.10739)): [notebooks/training_RFFN_KKFLS.ipynb](./notebooks/training_RFFN_KKFLS.ipynb) +- Sinusoidal Representation Network (SIREN, [Sitzmann et al., 2020](https://arxiv.org/abs/2006.09661)): [notebooks/training_SIREN_KKFLS.ipynb](./notebooks/training_SIREN_KKFLS.ipynb) ## Data -The earthquake data from the Cook Inlet DAS experiment are available at [https://dasway.ess.washington.edu/gci/index.html](https://dasway.ess.washington.edu/gci/index.html). Earthquakes and daily data reports will be updated daily. +The earthquake data from the Cook Inlet DAS experiment are available at [https://dasway.ess.washington.edu/gci/index.html](https://dasway.ess.washington.edu/gci/index.html). Earthquakes and daily data reports are updated daily. Due to the size of the data used in this study (~260 GB per cable), we cannot upload it directly in this repository. However, we prepared a Python script to download these data from our archival server. Please refer to the script [download.py](./data/download.py) and list of events [event_list.csv](./data/event_list.csv) in the repository. diff --git a/notebooks/RFFN_KKFLS_training.ipynb b/notebooks/training_RFFN_KKFLS.ipynb similarity index 96% rename from notebooks/RFFN_KKFLS_training.ipynb rename to notebooks/training_RFFN_KKFLS.ipynb index 033c2c2..7565b73 100644 --- a/notebooks/RFFN_KKFLS_training.ipynb +++ b/notebooks/training_RFFN_KKFLS.ipynb @@ -7,79 +7,26 @@ "metadata": {}, "outputs": [], "source": [ + "import os, time, sys, gc\n", + "\n", + "# please update this path accordingly\n", + "sys.path.append(\"../../DAS-reconstruction/scripts/\")\n", + "os.environ['CUDA_VISIBLE_DEVICES'] = \"3\"\n", + "\n", + "import h5py\n", + "import torch\n", "import numpy as np\n", - "import matplotlib\n", "import matplotlib.pyplot as plt\n", "from tqdm import tqdm\n", "import pickle\n", - "import time\n", - "import os\n", - "import gc\n", - "os.environ['CUDA_VISIBLE_DEVICES'] = \"0\"\n", - "\n", - "import torch\n", - "from torch.utils.data import DataLoader\n", - "from torch.nn import MSELoss\n", - "import h5py\n", "\n", - "from scipy.signal import butter, filtfilt\n", - "from scipy.signal import correlate\n", + "from models import RandomFourierFeature\n", + "from datasets import DASDataset2DOnTheFly\n", + "from utils import clean_up, count_weights\n", "\n", "device = torch.device('cuda')" ] }, - { - "cell_type": "code", - "execution_count": 2, - "id": "338efea5", - "metadata": {}, - "outputs": [], - "source": [ - "class DASDatasetOnTheFly(torch.utils.data.Dataset):\n", - " def __init__(self, B, T, X, outputs):\n", - " 'Initialization'\n", - " self.B = torch.Tensor(B)\n", - " self.T = torch.Tensor(T)\n", - " self.X = torch.Tensor(X)\n", - " self.outputs = torch.Tensor(outputs)\n", - "\n", - " def __len__(self):\n", - " 'Denotes the total number of samples'\n", - " return len(self.outputs)\n", - "\n", - " def __getitem__(self, index):\n", - " 'Generates one sample of data'\n", - " _t = self.T[index]\n", - " _x = self.X[index]\n", - " _Bv = torch.matmul(torch.Tensor(torch.concat([_t, _x], axis = -1)), self.B.T)\n", - " X = torch.cat([torch.cos(2*torch.pi*_Bv), torch.sin(2*torch.pi*_Bv)], axis = -1)\n", - " y = self.outputs[index, :]\n", - "\n", - " return X, y\n", - " \n", - "class RandomFourierFeature(torch.nn.Module):\n", - " def __init__(self, nfeature, n_layers, n_outputs = 1):\n", - " super().__init__()\n", - " self.n_layers = n_layers\n", - " self.n_outputs = n_outputs\n", - " self.inputs = torch.nn.Linear(2 * nfeature, nfeature)\n", - "\n", - " for i in range(self.n_layers):\n", - " setattr(self, f\"ln{i+1}\", torch.nn.Linear(nfeature, nfeature))\n", - "\n", - " self.outputs = torch.nn.Linear(nfeature, self.n_outputs)\n", - " self.sigmoid = torch.nn.Sigmoid()\n", - " self.relu = torch.relu\n", - "\n", - " def forward(self, x):\n", - " x = self.relu(self.inputs(x))\n", - " for i in range(self.n_layers):\n", - " layer = getattr(self, f\"ln{i+1}\")\n", - " x = self.relu(layer(x))\n", - " x = 2*self.sigmoid(self.outputs(x))-1\n", - " return x" - ] - }, { "cell_type": "markdown", "id": "62c4da24", @@ -90,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 2, "id": "95defcc1", "metadata": {}, "outputs": [ @@ -140,7 +87,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 3, "id": "ccf2a0dd", "metadata": {}, "outputs": [ @@ -150,6 +97,14 @@ "text": [ "torch.Size([1000, 1500]) torch.Size([1000, 1500])\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/niyiyu/anaconda3/envs/seisbench/lib/python3.9/site-packages/torch/functional.py:504: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:3483.)\n", + " return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]\n" + ] } ], "source": [ @@ -157,10 +112,6 @@ "data /= np.max(np.abs(data), axis=-1, keepdims=True)\n", "data = torch.Tensor(data)\n", "\n", - "# b, a = butter(4, (1, 12), fs=25, btype='bandpass')\n", - "# data_bp = filtfilt(b, a, data, axis=-1)\n", - "# data_bp /= np.std(data_bp, axis=-1, keepdims=True)\n", - "\n", "in_x, in_t = torch.meshgrid(torch.arange(nc), torch.arange(ns))\n", "T = in_t/(ns-1); X = in_x/(nc-1)\n", "print(T.shape, X.shape)" @@ -168,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 4, "id": "d7f68adb", "metadata": {}, "outputs": [ @@ -191,17 +142,17 @@ "index = np.abs(d) > 0.1\n", "sum(index)/len(d)\n", "\n", - "datasetonthefly = DASDatasetOnTheFly(B.to(device), \n", + "datasetonthefly = DASDataset2DOnTheFly(B.to(device), \n", " T.reshape([-1, 1])[index[:, 0]].to(device), \n", " X.reshape([-1, 1])[index[:, 0]].to(device), \n", " data.reshape([-1, 1])[index[:, 0]].to(device))\n", "\n", - "datasetonthefly_val = DASDatasetOnTheFly(B.to(device), \n", + "datasetonthefly_val = DASDataset2DOnTheFly(B.to(device), \n", " T.reshape([-1, 1]).to(device), \n", " X.reshape([-1, 1]).to(device), \n", " data.reshape([-1, 1]).to(device))\n", "\n", - "data_loader = DataLoader(datasetonthefly, batch_size=4096*2, shuffle=True, num_workers=0)" + "data_loader = torch.utils.data.DataLoader(datasetonthefly, batch_size=4096*2, shuffle=True, num_workers=0)" ] }, { @@ -214,7 +165,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 7, "id": "04f6ff44", "metadata": {}, "outputs": [ @@ -222,7 +173,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "have total 128801 weights\n" + "The model have total 128801 weights\n" ] } ], @@ -235,21 +186,18 @@ "\n", "model.to(device);\n", "\n", - "n_weights = 0\n", - "for i in model.parameters():\n", - " n_weights += len(i.data.flatten())\n", - "print(f\"have total {n_weights} weights\")" + "print(f\"The model have total {count_weights(model)} weights\")" ] }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 8, "id": "58827fa0", "metadata": {}, "outputs": [], "source": [ "optimizer = torch.optim.Adam(model.parameters(), lr = 3e-4)\n", - "loss_fn = MSELoss()" + "loss_fn = torch.nn.MSELoss()" ] }, { @@ -529,7 +477,120 @@ "plt.subplot(1,3,3)\n", "plt.imshow(data - reconstruct, cmap = 'RdBu', aspect = 'auto', origin='lower', \n", " vmin = -vmax, vmax = vmax)\n", - "plt.xticks([]); plt.yticks([])" + "plt.xticks([]); plt.yticks([])\n", + "\n", + "# plt.savefig(\"/home/niyiyu/rff.png\", bbox_inches = 'tight', dpi=300)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "e88dee7f", + "metadata": {}, + "outputs": [], + "source": [ + "fs = 2.5\n", + "ns = data.shape[1]\n", + "t = np.arange(ns)/fs # time in s\n", + "frq = np.fft.rfftfreq(ns,d=1./fs)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "4c0c103a", + "metadata": {}, + "outputs": [], + "source": [ + "cha = 2\n", + "ftr_raw = 20 * np.log10( (2/ns) * abs(np.fft.rfft(data[cha, :] * np.hamming(ns))) )\n", + "ftr_rec = 20 * np.log10( (2/ns) * abs(np.fft.rfft(reconstruct[cha, :] * np.hamming(ns))) )" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "dc1e1242", + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure(figsize=(10, 5))\n", + "plt.plot(frq, ftr_raw, label='raw data')\n", + "plt.plot(frq, ftr_rec, label='reconstruction')\n", + "plt.plot(frq, np.abs(ftr_raw - ftr_rec), label='reconstruction')\n", + "plt.legend()\n", + "plt.xlim([0.01, 5.])\n", + "plt.xlabel(\"Frequency [Hz]\")" + ] + }, + { + "cell_type": "markdown", + "id": "ebf33100", + "metadata": {}, + "source": [ + "## f-k (2D-FFT) transformation " + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "0f06ccbe", + "metadata": {}, + "outputs": [], + "source": [ + "nnx = data.shape[0]\n", + "nns = data.shape[1]\n", + "dx = 9.57\n", + "dt = 1/2.5\n", + "freq = np.fft.fftshift(np.fft.fftfreq(nns, d=dt))\n", + "knum = np.fft.fftshift(np.fft.fftfreq(nnx, d=dx))\n", + "\n", + "# Calculate the frequency-wavenumber spectrum\n", + "ft2_resc = np.fft.fftshift(np.fft.fft2(data))\n", + "ft2_resc = np.log10(abs(ft2_resc)) # this is not normalized\n", + "\n", + "ft2_orig = np.fft.fftshift(np.fft.fft2(reconstruct))\n", + "ft2_orig = np.log10(abs(ft2_orig)) # this is not normalized" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "id": "8dc3afd7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "xlim = [-0.2, 0.2]; ylim = [-0.005,0.005]\n", + "plt.figure(figsize= (8, 5), dpi = 120)\n", + "plt.imshow(ft2_resc, cmap='magma', aspect = \"auto\", \n", + " extent=[min(freq),max(freq),min(knum),max(knum)], \n", + " vmin=0, vmax=7)\n", + "plt.ylabel(\"Wavenumber (1/m)\", fontsize = 15)\n", + "plt.xlabel(\"Frequency (Hz)\", labelpad = 15, fontsize = 15)\n", + "plt.xlim(xlim)\n", + "plt.ylim(ylim)\n", + "plt.colorbar()" ] } ], diff --git a/notebooks/SHRED_KKFLS_training.ipynb b/notebooks/training_SHRED_KKFLS.ipynb similarity index 72% rename from notebooks/SHRED_KKFLS_training.ipynb rename to notebooks/training_SHRED_KKFLS.ipynb index 81a312f..d212b05 100644 --- a/notebooks/SHRED_KKFLS_training.ipynb +++ b/notebooks/training_SHRED_KKFLS.ipynb @@ -2,76 +2,27 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "bda9187d", "metadata": {}, "outputs": [], "source": [ + "import os, time, sys, gc\n", + "\n", + "# please update this path accordingly\n", + "sys.path.append(\"../../DAS-reconstruction/scripts/\")\n", + "os.environ['CUDA_VISIBLE_DEVICES'] = \"3\"\n", + "\n", "import glob\n", + "import h5py\n", + "import torch\n", "import numpy as np\n", - "import matplotlib\n", "import matplotlib.pyplot as plt\n", "from tqdm import tqdm\n", - "import scipy\n", - "import pickle\n", - "import os\n", - "import h5py\n", - "import obspy\n", - "import pandas as pd\n", - "import time\n", - "from obspy.core.utcdatetime import UTCDateTime\n", - "os.environ['CUDA_VISIBLE_DEVICES'] = \"3\"\n", - "import torch\n", - "from torch.utils.data import DataLoader\n", - "from torch.nn import MSELoss\n", - "from torch.optim import lr_scheduler\n", "\n", - "from obspy.signal.filter import bandpass, lowpass, highpass\n", - "from obspy.signal.invsim import cosine_taper\n", - "from scipy.signal import butter, filtfilt, detrend" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2da99073", - "metadata": {}, - "outputs": [], - "source": [ - "class DASDataset(torch.utils.data.Dataset):\n", - " def __init__(self, inputs, outputs):\n", - " 'Initialization'\n", - " if isinstance(inputs, torch.Tensor):\n", - " self.inputs = inputs\n", - " self.outputs = outputs\n", - " else:\n", - " self.inputs = inputs.astype(np.float32)\n", - " self.outputs = outputs.astype(np.float32)\n", - "\n", - " def __len__(self):\n", - " 'Denotes the total number of samples'\n", - " return len(self.outputs)\n", - "\n", - " def __getitem__(self, index):\n", - " 'Generates one sample of data'\n", - " X = self.inputs[index, :]\n", - " y = self.outputs[index, :]\n", - "\n", - " return X, y\n", - " \n", - "class SHRED(torch.nn.Module):\n", - " def __init__(self, input_size, hidden_size, output_size, num_layers):\n", - " super().__init__()\n", - " self.lstm = torch.nn.LSTM(input_size, hidden_size, num_layers, batch_first=True, dropout=0.2)\n", - " self.sdn1 = torch.nn.Linear(hidden_size, output_size//2)\n", - " self.sdn3 = torch.nn.Linear(output_size//2, output_size)\n", - " self.relu = torch.nn.ReLU()\n", - "\n", - " def forward(self, x):\n", - " x = self.lstm(x)[1][0][-1] # should be -1\n", - " x = self.relu(self.sdn1(x))\n", - " x = self.sdn3(x)\n", - " return x" + "from utils import clean_up, count_weights\n", + "from models import SHRED\n", + "from datasets import DASDataset" ] }, { @@ -81,13 +32,14 @@ "metadata": {}, "outputs": [], "source": [ + "# please update this path accordingly\n", "flist = glob.glob(\"../../datasets/earthquakes/*\")\n", "\n", "nsample_train = 300\n", "nsample_val = 300\n", "nsample_test = 300\n", "\n", - "ncha = 201\n", + "ncha = 151\n", "ntime = 200\n", "\n", "ncha_start = 1000\n", @@ -126,7 +78,7 @@ " f.close()\n", "\n", " for _ in range(nsample_train):\n", - " idt = np.random.randint(ntime+1, 3000) # last time index\n", + " idt = np.random.randint(ntime+1, 3000) # last time index\n", " ic = np.random.randint(0, ncha_end-ncha_start-noutput) # first channel indexes\n", " X[i, :, :] = data[ic+cidx, idt-(ntime-1):idt+1].T\n", " Y[i, :] = data[ic:ic+noutput, idt]\n", @@ -134,23 +86,6 @@ "print(f\"training set size: {i}\") " ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "0208ddd5", - "metadata": {}, - "outputs": [], - "source": [ - "vmax = 5\n", - "\n", - "plt.figure(figsize=(10, 8), dpi=300)\n", - "plt.imshow(data, aspect='auto', cmap='RdBu', origin='lower', \n", - " vmax = vmax, vmin = -vmax)\n", - "plt.title(\"original\", fontsize=20)\n", - "plt.xticks([]); \n", - "plt.yticks([])" - ] - }, { "cell_type": "code", "execution_count": null, @@ -183,30 +118,19 @@ "Y_test_ts = torch.Tensor(Y[idx_test, :])\n", "\n", "dataset = DASDataset(X_train_ts, Y_train_ts)\n", - "data_loader = DataLoader(dataset, batch_size=64, shuffle=True, num_workers=0)\n", + "data_loader = torch.utils.data.DataLoader(dataset, batch_size=64, shuffle=True, num_workers=0)\n", "\n", "val_dataset = DASDataset(X_val_ts, Y_val_ts)\n", - "val_data_loader = DataLoader(val_dataset, batch_size=512, shuffle=True, num_workers=0)\n", + "val_data_loader = torch.utils.data.DataLoader(val_dataset, batch_size=512, shuffle=True, num_workers=0)\n", "\n", "test_dataset = DASDataset(X_test_ts, Y_test_ts)\n", - "test_data_loader = DataLoader(test_dataset, batch_size=512, shuffle=True, num_workers=0)\n", + "test_data_loader = torch.utils.data.DataLoader(test_dataset, batch_size=512, shuffle=True, num_workers=0)\n", "\n", "print(\"train: \", X_train_ts.shape, Y_train_ts.shape)\n", "print(\"validate: \", X_val_ts.shape, Y_val_ts.shape)\n", "print(\"test: \", X_test_ts.shape, Y_test_ts.shape)" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "27043620", - "metadata": {}, - "outputs": [], - "source": [ - "import gc\n", - "gc.collect()" - ] - }, { "cell_type": "code", "execution_count": null, @@ -226,10 +150,7 @@ " torch.nn.init.kaiming_normal_(m.weight)\n", " m.bias.data.fill_(0.01)\n", " \n", - "n_weights = 0\n", - "for i in model.parameters():\n", - " n_weights += len(i.data.flatten())\n", - "print(f\"have total {n_weights} weights\")" + "print(f\"The model have total {count_weights(model)} weights\")" ] }, { @@ -241,8 +162,8 @@ "source": [ "nepoch = 80\n", "optimizer = torch.optim.Adam(model.parameters(), lr = 1e-4)\n", - "loss_fn = MSELoss()\n", - "scheduler = lr_scheduler.LinearLR(optimizer, start_factor=1.0, end_factor=0.5, total_iters=nepoch)" + "loss_fn = torch.nn.MSELoss()\n", + "scheduler = torch.optim.lr_scheduler.LinearLR(optimizer, start_factor=1.0, end_factor=0.5, total_iters=nepoch)" ] }, { @@ -254,11 +175,9 @@ }, "outputs": [], "source": [ - "t0 = time.time()\n", - "train_loss_log = []\n", - "val_loss_log = []\n", - "test_loss_log = []\n", - " \n", + "train_loss_log = []; val_loss_log = []; test_loss_log = []\n", + "\n", + "t0 = time.time() \n", "for t in range(nepoch):\n", " model.train()\n", " train_loss = []\n", @@ -294,22 +213,28 @@ " print(\"Epoch %d: Adam lr %.4f -> %.4f\" % (t, before_lr, after_lr))\n", " print(\"%d, %.4f, %.4f, %.4f\" % (t, np.mean(train_loss), np.mean(test_loss), np.mean(val_loss)))\n", " \n", - "# torch.save(model.state_dict(), \n", - "# f\"/home/niyiyu/Research/DAS-NIR/gci-summary/results/weights/SHRED_KKFLS_25Hz_201i_1000o_200sp_epo{t}.pt\")\n", "print(time.time() - t0)" ] }, { "cell_type": "code", "execution_count": null, - "id": "4394698d", + "id": "a7ff4216", "metadata": {}, "outputs": [], "source": [ - "with open(\"../../datasets/loss.pt\", \"wb\") as f:\n", - " pickle.dump({\"train\": train_loss_log,\n", - " \"validate\": val_loss_log,\n", - " \"test\": test_loss_log}, f)" + "clean_up()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d473baef", + "metadata": {}, + "outputs": [], + "source": [ + "torch.save(model.state_dict(), \n", + " f\"../../datasets/weights/SHRED_KKFLS_25Hz_151i_1000o_200sp.pt\")" ] }, { @@ -327,8 +252,7 @@ "plt.xlabel(\"Epoch\", fontsize = 15)\n", "plt.ylabel(\"Loss\", fontsize = 15)\n", "plt.grid(True)\n", - "plt.savefig(\"../figures/manuscripts/FigS_loss.pdf\", bbox_inches='tight', dpi=300)\n", - "# plt.yscale('log')" + "plt.savefig(\"../figures/manuscripts/FigS_loss.pdf\", bbox_inches='tight', dpi=300)" ] }, { @@ -338,10 +262,9 @@ "metadata": {}, "outputs": [], "source": [ - "model.train()\n", - "idx = np.random.randint(0, len(X_val_ts))\n", + "model.eval()\n", "\n", - "# model.eval()\n", + "idx = np.random.randint(0, len(X_val_ts))\n", "inputs = X_val_ts[idx, :, :]\n", "label = Y_val_ts[idx, :]\n", "predict = model(inputs.to(device)).cpu().detach().numpy()\n", diff --git a/notebooks/SIREN_KKFLS_training.ipynb b/notebooks/training_SIREN_KKFLS.ipynb similarity index 99% rename from notebooks/SIREN_KKFLS_training.ipynb rename to notebooks/training_SIREN_KKFLS.ipynb index cb44494..c7133a8 100644 --- a/notebooks/SIREN_KKFLS_training.ipynb +++ b/notebooks/training_SIREN_KKFLS.ipynb @@ -2,90 +2,31 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "d10fc521", "metadata": {}, "outputs": [], "source": [ + "import os, time, sys, gc\n", + "\n", + "# please update this path accordingly\n", + "sys.path.append(\"../../DAS-reconstruction/scripts/\")\n", + "os.environ['CUDA_VISIBLE_DEVICES'] = \"3\"\n", + "\n", + "import h5py\n", + "import torch\n", "import numpy as np\n", - "import matplotlib\n", "import matplotlib.pyplot as plt\n", "from tqdm import tqdm\n", - "import time\n", - "import os\n", - "import gc\n", - "os.environ['CUDA_VISIBLE_DEVICES'] = \"2\"\n", - "\n", - "import torch\n", - "from torch.utils.data import DataLoader\n", - "from torch.nn import MSELoss\n", - "import h5py\n", + "import pickle\n", "\n", - "from scipy.signal import butter, filtfilt\n", - "from scipy.signal import correlate\n", - "from obspy.signal.invsim import cosine_taper\n", + "from models import SIREN\n", + "from datasets import DASDataset2D\n", + "from utils import clean_up, count_weights\n", "\n", "device = torch.device('cuda')" ] }, - { - "cell_type": "code", - "execution_count": 2, - "id": "8c801f08", - "metadata": {}, - "outputs": [], - "source": [ - "class DASDataset(torch.utils.data.Dataset):\n", - " def __init__(self, T, X, outputs):\n", - " 'Initialization'\n", - " self.T = torch.Tensor(T)\n", - " self.X = torch.Tensor(X)\n", - " self.outputs = torch.Tensor(outputs)\n", - " \n", - " def __len__(self):\n", - " 'Denotes the total number of samples'\n", - " return len(self.outputs)\n", - "\n", - " def __getitem__(self, index):\n", - " 'Generates one sample of data'\n", - " # Select sample\n", - " t = self.T[index]\n", - " x = self.X[index]\n", - " y = self.outputs[index]\n", - "\n", - " return torch.concat([t, x], axis=-1), y\n", - " \n", - "class SIREN(torch.nn.Module):\n", - " def __init__(self, n_input, n_output, n_layers, n_units, omega):\n", - " super().__init__()\n", - " self.omega = omega\n", - " self.n_layers = n_layers\n", - "\n", - " # input layer\n", - " self.inputs = torch.nn.Linear(n_input, n_units, bias=False)\n", - " self.inputs_bias = torch.nn.Parameter(torch.rand(n_units))\n", - "\n", - " # hidden layers\n", - " for i in range(self.n_layers):\n", - " setattr(self, f\"ln{i+1}\", torch.nn.Linear(n_units, n_units, bias=False))\n", - " setattr(self, f\"ln{i+1}_bias\", torch.nn.Parameter(torch.rand(n_units)))\n", - "\n", - " # output layer\n", - " self.outputs_bias = torch.nn.Parameter(torch.rand(n_output))\n", - " self.outputs = torch.nn.Linear(n_units, n_output, bias=False)\n", - " self.sigmoid = torch.nn.Sigmoid()\n", - "\n", - " def forward(self, x):\n", - " x = torch.sin(self.omega * self.inputs(x) + self.inputs_bias)\n", - " for i in range(self.n_layers):\n", - " layer = getattr(self, f\"ln{i+1}\")\n", - " bias = getattr(self, f\"ln{i+1}_bias\")\n", - " x = torch.sin(self.omega * layer(x) + bias)\n", - " x = 2*self.sigmoid(self.outputs(x) + self.outputs_bias) - 1\n", - "\n", - " return x" - ] - }, { "cell_type": "markdown", "id": "ac1197b8", @@ -96,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 3, "id": "d7f68adb", "metadata": {}, "outputs": [ @@ -146,7 +87,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 4, "id": "9ed1acb3", "metadata": {}, "outputs": [ @@ -156,17 +97,21 @@ "text": [ "torch.Size([1000, 1500]) torch.Size([1000, 1500])\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/niyiyu/anaconda3/envs/seisbench/lib/python3.9/site-packages/torch/functional.py:504: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:3483.)\n", + " return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]\n" + ] } ], "source": [ "data -= np.mean(data, axis=-1, keepdims=True)\n", "data /= np.max(np.abs(data), axis=-1, keepdims=True)\n", - "\n", "data = torch.Tensor(data.copy())\n", "\n", - "# data_bp = filtfilt(b, a, data, axis=-1)\n", - "# data_bp /= np.std(data_bp, axis=-1, keepdims=True)\n", - "\n", "in_x, in_t = torch.meshgrid(torch.arange(nc), torch.arange(ns))\n", "T = in_t/(ns-1); X = in_x/(nc-1)\n", "print(T.shape, X.shape)" @@ -174,35 +119,59 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 5, "id": "cf52f1e0", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'DataLoader' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[5], line 9\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28msum\u001b[39m(index)\u001b[38;5;241m/\u001b[39m\u001b[38;5;28mlen\u001b[39m(d)\n\u001b[1;32m 5\u001b[0m dataset \u001b[38;5;241m=\u001b[39m DASDataset2D(T\u001b[38;5;241m.\u001b[39mreshape([\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m1\u001b[39m])[index[:, \u001b[38;5;241m0\u001b[39m]]\u001b[38;5;241m.\u001b[39mto(device), \n\u001b[1;32m 6\u001b[0m X\u001b[38;5;241m.\u001b[39mreshape([\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m1\u001b[39m])[index[:, \u001b[38;5;241m0\u001b[39m]]\u001b[38;5;241m.\u001b[39mto(device), \n\u001b[1;32m 7\u001b[0m data\u001b[38;5;241m.\u001b[39mreshape([\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m1\u001b[39m])[index[:, \u001b[38;5;241m0\u001b[39m]]\u001b[38;5;241m.\u001b[39mto(device))\n\u001b[0;32m----> 9\u001b[0m data_loader \u001b[38;5;241m=\u001b[39m \u001b[43mDataLoader\u001b[49m(dataset, batch_size\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1024\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m16\u001b[39m, shuffle\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, num_workers\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)\n\u001b[1;32m 12\u001b[0m dataset_val \u001b[38;5;241m=\u001b[39m DASDataset2D(T\u001b[38;5;241m.\u001b[39mreshape([\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m1\u001b[39m])\u001b[38;5;241m.\u001b[39mto(device), \n\u001b[1;32m 13\u001b[0m X\u001b[38;5;241m.\u001b[39mreshape([\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m1\u001b[39m])\u001b[38;5;241m.\u001b[39mto(device), \n\u001b[1;32m 14\u001b[0m data\u001b[38;5;241m.\u001b[39mreshape([\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m1\u001b[39m])\u001b[38;5;241m.\u001b[39mto(device))\n\u001b[1;32m 16\u001b[0m data_loader \u001b[38;5;241m=\u001b[39m DataLoader(dataset, batch_size\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m4096\u001b[39m, shuffle\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, num_workers\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)\n", + "\u001b[0;31mNameError\u001b[0m: name 'DataLoader' is not defined" + ] + } + ], "source": [ "d = data.reshape([-1, 1]).numpy()\n", "index = np.abs(d) > 0.1\n", "sum(index)/len(d)\n", "\n", - "dataset = DASDataset(T.reshape([-1, 1])[index[:, 0]].to(device), \n", - " X.reshape([-1, 1])[index[:, 0]].to(device), \n", - " data.reshape([-1, 1])[index[:, 0]].to(device))\n", + "dataset = DASDataset2D(T.reshape([-1, 1])[index[:, 0]].to(device), \n", + " X.reshape([-1, 1])[index[:, 0]].to(device), \n", + " data.reshape([-1, 1])[index[:, 0]].to(device))\n", "\n", "data_loader = DataLoader(dataset, batch_size=1024*16, shuffle=True, num_workers=0)\n", "\n", "\n", - "dataset_val = DASDataset(T.reshape([-1, 1]).to(device), \n", - " X.reshape([-1, 1]).to(device), \n", - " data.reshape([-1, 1]).to(device))\n", + "dataset_val = DASDataset2D(T.reshape([-1, 1]).to(device), \n", + " X.reshape([-1, 1]).to(device), \n", + " data.reshape([-1, 1]).to(device))\n", "\n", "data_loader = DataLoader(dataset, batch_size=4096, shuffle=True, num_workers=0)" ] }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 1, "id": "04f6ff44", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'SIREN' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 6\u001b[0m\n\u001b[1;32m 4\u001b[0m n_output \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 5\u001b[0m omega \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m30\u001b[39m\n\u001b[0;32m----> 6\u001b[0m model \u001b[38;5;241m=\u001b[39m \u001b[43mSIREN\u001b[49m(n_input \u001b[38;5;241m=\u001b[39m n_input, \n\u001b[1;32m 7\u001b[0m n_output \u001b[38;5;241m=\u001b[39m n_output, \n\u001b[1;32m 8\u001b[0m n_layers \u001b[38;5;241m=\u001b[39m n_layers, \n\u001b[1;32m 9\u001b[0m n_units \u001b[38;5;241m=\u001b[39m n_units, \n\u001b[1;32m 10\u001b[0m omega \u001b[38;5;241m=\u001b[39m omega)\n\u001b[1;32m 12\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m name, mod \u001b[38;5;129;01min\u001b[39;00m model\u001b[38;5;241m.\u001b[39mnamed_parameters():\n\u001b[1;32m 13\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124minputs\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01min\u001b[39;00m name: \u001b[38;5;66;03m# for input layer\u001b[39;00m\n", + "\u001b[0;31mNameError\u001b[0m: name 'SIREN' is not defined" + ] + } + ], "source": [ "n_units = 128\n", "n_layers = 20\n", @@ -227,28 +196,9 @@ " elif 'weight' in name:\n", " mod.data.uniform_(-np.sqrt(6/n_units)/omega, np.sqrt(6/n_units)/omega) \n", " \n", - "model.to(device);" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "id": "c8d16990", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "have total 330753\n" - ] - } - ], - "source": [ - "nweights = 0\n", - "for name, i in model.named_parameters():\n", - " nweights += len(i.data.flatten())\n", - "print(f\"have total {nweights}\")" + "model.to(device);\n", + "\n", + "print(f\"The model have total {count_weights(model)} weights\")" ] }, { @@ -672,6 +622,23 @@ " vmin = data.min()/2, vmax = data.max()/2)\n", "plt.xticks([]); plt.yticks([])\n", "\n", + "# plt.subplot(2,3,4)\n", + "# plt.imshow(data_bp, cmap = 'RdBu', aspect = 'auto', origin='lower', \n", + "# vmin = data.min(), vmax = data.max())\n", + "# plt.xticks([]); plt.yticks([])\n", + "# plt.title(\"original\", fontsize = 20)\n", + "\n", + "# plt.subplot(2,3,5)\n", + "# plt.imshow(reconstruct_bp, cmap = 'RdBu', aspect = 'auto', origin='lower', \n", + "# vmin = data.min(), vmax = data.max())\n", + "# plt.xticks([]); plt.yticks([])\n", + "# plt.title(\"reconstruction\", fontsize = 20)\n", + "\n", + "# plt.subplot(2,3,6)\n", + "# plt.imshow(data_bp - reconstruct_bp, cmap = 'RdBu', aspect = 'auto', origin='lower', \n", + "# vmin = data.min(), vmax = data.max())\n", + "# plt.xticks([]); plt.yticks([])\n", + "\n", "plt.savefig(\"/home/niyiyu/siren.png\", bbox_inches = 'tight', dpi=300)" ] }, diff --git a/scripts/datasets.py b/scripts/datasets.py new file mode 100644 index 0000000..ae5e8b0 --- /dev/null +++ b/scripts/datasets.py @@ -0,0 +1,65 @@ +import numpy as np +import torch + +class DASDataset(torch.utils.data.Dataset): + ''' + torch dataset class for SHallow REcurrent Network. + ''' + def __init__(self, inputs, outputs): + if isinstance(inputs, torch.Tensor): + self.inputs = inputs + self.outputs = outputs + else: + self.inputs = inputs.astype(np.float32) + self.outputs = outputs.astype(np.float32) + + def __len__(self): + return len(self.outputs) + + def __getitem__(self, index): + X = self.inputs[index, :] + Y = self.outputs[index, :] + + return X, Y + +class DASDataset2DOnTheFly(torch.utils.data.Dataset): + ''' + torch dataset class for Random Fourier Feature Network. + ''' + def __init__(self, B, T, X, outputs): + self.B = torch.Tensor(B) + self.T = torch.Tensor(T) + self.X = torch.Tensor(X) + self.outputs = torch.Tensor(outputs) + + def __len__(self): + return len(self.outputs) + + def __getitem__(self, index): + _t = self.T[index] + _x = self.X[index] + _Bv = torch.matmul(torch.Tensor(torch.concat([_t, _x], axis = -1)), self.B.T) + X = torch.cat([torch.cos(2*torch.pi*_Bv), torch.sin(2*torch.pi*_Bv)], axis = -1) + Y = self.outputs[index, :] + + return X, Y + +class DASDataset2D(torch.utils.data.Dataset): + ''' + torch dataset class for SIREN model. + ''' + def __init__(self, T, X, outputs): + self.T = torch.Tensor(T) + self.X = torch.Tensor(X) + self.outputs = torch.Tensor(outputs) + + def __len__(self): + return len(self.outputs) + + def __getitem__(self, index): + # Select sample + T = self.T[index] + X = self.X[index] + Y = self.outputs[index] + + return torch.concat([T, X], axis=-1), Y \ No newline at end of file diff --git a/scripts/models.py b/scripts/models.py new file mode 100644 index 0000000..cfdef67 --- /dev/null +++ b/scripts/models.py @@ -0,0 +1,67 @@ +import torch + +class SHRED(torch.nn.Module): + def __init__(self, input_size, hidden_size, output_size, num_layers): + super().__init__() + self.lstm = torch.nn.LSTM(input_size, hidden_size, num_layers, batch_first=True, dropout=0.1) + self.sdn1 = torch.nn.Linear(hidden_size, output_size//2) + self.sdn3 = torch.nn.Linear(output_size//2, output_size) + self.relu = torch.nn.ReLU() + + def forward(self, x): + x = self.lstm(x)[1][0][-1] # should be -1 + x = self.relu(self.sdn1(x)) + x = self.sdn3(x) + return + +class RandomFourierFeature(torch.nn.Module): + def __init__(self, nfeature, n_layers, n_outputs = 1): + super().__init__() + self.n_layers = n_layers + self.n_outputs = n_outputs + self.inputs = torch.nn.Linear(2 * nfeature, nfeature) + + for i in range(self.n_layers): + setattr(self, f"ln{i+1}", torch.nn.Linear(nfeature, nfeature)) + + self.outputs = torch.nn.Linear(nfeature, self.n_outputs) + self.sigmoid = torch.nn.Sigmoid() + self.relu = torch.relu + + def forward(self, x): + x = self.relu(self.inputs(x)) + for i in range(self.n_layers): + layer = getattr(self, f"ln{i+1}") + x = self.relu(layer(x)) + x = 2*self.sigmoid(self.outputs(x))-1 + return x + +class SIREN(torch.nn.Module): + def __init__(self, n_input, n_output, n_layers, n_units, omega): + super().__init__() + self.omega = omega + self.n_layers = n_layers + + # input layer + self.inputs = torch.nn.Linear(n_input, n_units, bias=False) + self.inputs_bias = torch.nn.Parameter(torch.rand(n_units)) + + # hidden layers + for i in range(self.n_layers): + setattr(self, f"ln{i+1}", torch.nn.Linear(n_units, n_units, bias=False)) + setattr(self, f"ln{i+1}_bias", torch.nn.Parameter(torch.rand(n_units))) + + # output layer + self.outputs_bias = torch.nn.Parameter(torch.rand(n_output)) + self.outputs = torch.nn.Linear(n_units, n_output, bias=False) + self.sigmoid = torch.nn.Sigmoid() + + def forward(self, x): + x = torch.sin(self.omega * self.inputs(x) + self.inputs_bias) + for i in range(self.n_layers): + layer = getattr(self, f"ln{i+1}") + bias = getattr(self, f"ln{i+1}_bias") + x = torch.sin(self.omega * layer(x) + bias) + x = 2*self.sigmoid(self.outputs(x) + self.outputs_bias) - 1 + + return x \ No newline at end of file diff --git a/scripts/utils.py b/scripts/utils.py new file mode 100644 index 0000000..601b7cf --- /dev/null +++ b/scripts/utils.py @@ -0,0 +1,35 @@ +import gc +import torch +import numpy as np + +def get_mse(original, compressed): + if isinstance(original, torch.Tensor): + original = get_array(original) + if isinstance(compressed, torch.Tensor): + compressed = get_array(compressed) + + return np.mean((original - compressed) ** 2) + +def get_rmse(original, compressed): + mse = get_mse(original, compressed) + return np.sqrt(mse) + +def get_psnr(original, compressed): + if isinstance(original, torch.Tensor): + original = get_array(original) + if isinstance(compressed, torch.Tensor): + compressed = get_array(compressed) + + mse = get_mse(original, compressed) + if mse == 0: + return np.inf + max_pixel = np.abs(original).max() + psnr = 20 * np.log10(max_pixel / np.sqrt(mse)) + return psnr + +def clean_up(): + gc.collect() + torch.cuda.empty_cache() + +def count_weights(model): + return sum(p.numel() for p in model.parameters() if p.requires_grad) \ No newline at end of file