├── .gitignore ├── GenericRNN-2.ipynb ├── LorenzLSTM2.ipynb ├── README.md ├── SHREDSeaSurfaceTemperature.ipynb ├── additional_notebooks ├── ML_tutorial.ipynb ├── advection_diffusion_DL.ipynb ├── autoencoder_fluids_pytorch.ipynb ├── autoencoder_fluids_tensorflow.ipynb └── lorenz_timesteper.ipynb ├── google_drive_mount_code.ipynb ├── lorenz_diffeomorphism.ipynb ├── lorenz_diffeomorphism_practice.ipynb ├── slides ├── CTFRNN.pptx └── deep-learning-slides.pdf └── sparsify_reg.ipynb /.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | -------------------------------------------------------------------------------- /GenericRNN-2.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "provenance": [] 7 | }, 8 | "kernelspec": { 9 | "name": "python3", 10 | "display_name": "Python 3" 11 | }, 12 | "language_info": { 13 | "name": "python" 14 | }, 15 | "accelerator": "GPU", 16 | "gpuClass": "standard" 17 | }, 18 | "cells": [ 19 | { 20 | "cell_type": "markdown", 21 | "source": [ 22 | "### Generic RNNs for forecasting periodic, univariate time-series\n", 23 | "In this notebook, we'll walk through a simple example using RNNs in Pytorch to forecast sine waves (with middling to poor success)" 24 | ], 25 | "metadata": { 26 | "id": "qd68IrEevsOV" 27 | } 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "source": [ 32 | "Link to colab: https://colab.research.google.com/drive/10-FpzKl5mf7UejimUWziqcGMRrSHMpHD?usp=sharing" 33 | ], 34 | "metadata": { 35 | "id": "cFfhbfH8oRGz" 36 | } 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": 1, 41 | "metadata": { 42 | "id": "hhtYNSQwvnCZ" 43 | }, 44 | "outputs": [], 45 | "source": [ 46 | "### necessary imports\n", 47 | "import numpy as np\n", 48 | "import torch\n", 49 | "import matplotlib.pyplot as plt\n", 50 | "from torch.utils.data import DataLoader" 51 | ] 52 | }, 53 | { 54 | "cell_type": "markdown", 55 | "source": [ 56 | "We start by generating training data. We simulate 500 instances of $x_i (t) = \\cos \\omega_i t$ with each $\\omega_i \\sim \\mathcal U (\\pi, 3\\pi)$. " 57 | ], 58 | "metadata": { 59 | "id": "F90qT2EWweAk" 60 | } 61 | }, 62 | { 63 | "cell_type": "code", 64 | "source": [ 65 | "t = np.linspace(start=0, stop=5, num=1000)\n", 66 | "lookback = 50\n", 67 | "train_sims = np.zeros((500,1000,1))\n", 68 | "for i in range(len(train_sims)):\n", 69 | " train_sims[i] = np.sin(np.random.uniform(np.pi, 3*np.pi) * t).reshape(-1,1)\n", 70 | "\n", 71 | "train_data_in = np.zeros((480*500, lookback, 1))\n", 72 | "train_data_out = np.zeros((480*500, 1))\n", 73 | "for i in range(500):\n", 74 | " temp_in = np.zeros((480, lookback, 1))\n", 75 | " temp_out = np.zeros((480,1))\n", 76 | " for j in range(480):\n", 77 | " temp_in[j] = train_sims[i, j:j+lookback]\n", 78 | " temp_out[j] = train_sims[i, j+lookback]\n", 79 | " train_data_in[(i)*480:(i+1)*480] = temp_in\n", 80 | " train_data_out[(i)*480:(i+1)*480] = temp_out\n", 81 | "\n", 82 | "### plot example trajectory\n", 83 | "plt.plot(t, train_sims[0, :, :])\n", 84 | "plt.xlabel('t')\n", 85 | "plt.ylabel('x')\n", 86 | "plt.show()" 87 | ], 88 | "metadata": { 89 | "colab": { 90 | "base_uri": "https://localhost:8080/", 91 | "height": 279 92 | }, 93 | "id": "2MIGyGlPwdMZ", 94 | "outputId": "34359121-9680-404a-bf16-3a8db6adef78" 95 | }, 96 | "execution_count": 2, 97 | "outputs": [ 98 | { 99 | "output_type": "display_data", 100 | "data": { 101 | "text/plain": [ 102 | "
" 103 | ], 104 | "image/png": "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\n" 105 | }, 106 | "metadata": { 107 | "needs_background": "light" 108 | } 109 | } 110 | ] 111 | }, 112 | { 113 | "cell_type": "markdown", 114 | "source": [ 115 | "An easy way of training networks in Pytorch involves the creation of torch datasets. These datasets cleanly store input output pairs. In our case, we'd like to use a trajectory of measurements to forecast one step in the future. That is, we'll use $\\{x_1, \\dots x_k\\}$ (input) to forecast $x_{k+1}$ (output)." 116 | ], 117 | "metadata": { 118 | "id": "Whm8aKHqy7Rd" 119 | } 120 | }, 121 | { 122 | "cell_type": "code", 123 | "source": [ 124 | "class TimeSeriesDataset(torch.utils.data.Dataset):\n", 125 | " def __init__(self, X, Y):\n", 126 | " self.X = X\n", 127 | " self.Y = Y\n", 128 | " self.len = X.shape[0]\n", 129 | "\n", 130 | " def __getitem__(self, index):\n", 131 | " return self.X[index], self.Y[index]\n", 132 | "\n", 133 | " def __len__(self):\n", 134 | " return self.len\n", 135 | "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n", 136 | "train_dataset = TimeSeriesDataset(torch.tensor(train_data_in, dtype=torch.float32).to(device),\n", 137 | " torch.tensor(train_data_out, dtype=torch.float32).to(device))\n" 138 | ], 139 | "metadata": { 140 | "id": "12Bn6jOxyZTw" 141 | }, 142 | "execution_count": 3, 143 | "outputs": [] 144 | }, 145 | { 146 | "cell_type": "markdown", 147 | "source": [ 148 | "We'll now make the recurrent model in Pytorch. The model will consist of a single, generic RNN layer followed by two linear layers." 149 | ], 150 | "metadata": { 151 | "id": "VXhOD2ZZz9YM" 152 | } 153 | }, 154 | { 155 | "cell_type": "code", 156 | "source": [ 157 | "class RNN(torch.nn.Module):\n", 158 | " def __init__(self, input_size, hidden_size):\n", 159 | " super(RNN, self).__init__()\n", 160 | "\n", 161 | " self.rnn = torch.nn.RNNCell(input_size, hidden_size)\n", 162 | " self.linear1 = torch.nn.Linear(hidden_size, hidden_size)\n", 163 | " self.linear2 = torch.nn.Linear(hidden_size, 1)\n", 164 | " self.hidden_size = hidden_size\n", 165 | "\n", 166 | " def forward(self, x):\n", 167 | " batch_size = x.shape[0]\n", 168 | " h_0 = torch.zeros(batch_size, self.hidden_size)\n", 169 | " if next(self.parameters()).is_cuda:\n", 170 | " h_0 = h_0.cuda()\n", 171 | "\n", 172 | " ### here is the for loop that captures the recurrence\n", 173 | " for i in range(x.shape[1]):\n", 174 | " h_0 = self.rnn(x[:, i, :], h_0)\n", 175 | " output = self.linear1(h_0)\n", 176 | " output = torch.nn.functional.relu(output)\n", 177 | " output = self.linear2(output)\n", 178 | " return output\n", 179 | "\n", 180 | "rnn_model = RNN(1, 64).to(device)" 181 | ], 182 | "metadata": { 183 | "id": "Po2QttSgz67g" 184 | }, 185 | "execution_count": 9, 186 | "outputs": [] 187 | }, 188 | { 189 | "cell_type": "markdown", 190 | "source": [ 191 | "Now we write a (very) bare bones training loop for the RNN model." 192 | ], 193 | "metadata": { 194 | "id": "jE4_k9b40dX-" 195 | } 196 | }, 197 | { 198 | "cell_type": "code", 199 | "source": [ 200 | "batch_size = 64\n", 201 | "criterion = torch.nn.MSELoss()\n", 202 | "optimizer = torch.optim.Adam(rnn_model.parameters(), lr=1e-4)\n", 203 | "### data loader object automatically handles batching for a Pytorch dataset\n", 204 | "train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)\n", 205 | "for epoch in range(4):\n", 206 | " for k, data in enumerate(train_loader):\n", 207 | " rnn_model.train()\n", 208 | " outputs = rnn_model(data[0])\n", 209 | " optimizer.zero_grad()\n", 210 | " loss = criterion(outputs, data[1])\n", 211 | " loss.backward()\n", 212 | " optimizer.step()\n", 213 | " print('Epoch ' + str(epoch))\n", 214 | " print(\"Error \" + str(loss.item()))" 215 | ], 216 | "metadata": { 217 | "colab": { 218 | "base_uri": "https://localhost:8080/" 219 | }, 220 | "id": "boEf3gaI0aUk", 221 | "outputId": "6ae28a0b-d590-4ded-ba6f-bb2fa48648c3" 222 | }, 223 | "execution_count": 10, 224 | "outputs": [ 225 | { 226 | "output_type": "stream", 227 | "name": "stdout", 228 | "text": [ 229 | "Epoch 0\n", 230 | "Error 1.0415634278615471e-05\n", 231 | "Epoch 1\n", 232 | "Error 4.317570528655779e-06\n", 233 | "Epoch 2\n", 234 | "Error 1.3992064396006754e-06\n", 235 | "Epoch 3\n", 236 | "Error 9.377056358061964e-07\n" 237 | ] 238 | } 239 | ] 240 | }, 241 | { 242 | "cell_type": "markdown", 243 | "source": [ 244 | "To see how well our RNN model is working, we'll try to forecast the signal $\\sin 2.5 \\pi t$." 245 | ], 246 | "metadata": { 247 | "id": "MgiVtIuP6AOP" 248 | } 249 | }, 250 | { 251 | "cell_type": "code", 252 | "source": [ 253 | "test_wave = np.sin(2.5*np.pi *t)\n", 254 | "test_data_in = np.zeros((1000 - lookback, lookback, 1))\n", 255 | "test_data_out = np.zeros((1000 - lookback,1))\n", 256 | "for i in range(1000 - lookback):\n", 257 | " test_data_in[i] = test_wave[i:i+lookback].reshape(lookback,1)\n", 258 | " test_data_out[i] = test_wave[i+lookback]\n", 259 | "\n", 260 | "test_data_in = torch.tensor(test_data_in,dtype=torch.float32)" 261 | ], 262 | "metadata": { 263 | "id": "-pJMqtV83HYF" 264 | }, 265 | "execution_count": 11, 266 | "outputs": [] 267 | }, 268 | { 269 | "cell_type": "code", 270 | "source": [ 271 | "### forecasting code adapted from https://github.com/ashesh6810/RCESN_spatio_temporal\n", 272 | "rnn_model.to('cpu')\n", 273 | "ypred = np.zeros((1000 - lookback, 1))\n", 274 | "\n", 275 | "for i in range(test_data_in.shape[0]):\n", 276 | " if i ==0:\n", 277 | " inputs = test_data_in[0, -lookback:, :].reshape((1,lookback, 1)).cpu()\n", 278 | " ypred[i, :] = rnn_model(inputs).detach().numpy()\n", 279 | "\n", 280 | " elif i < lookback:\n", 281 | " inputs = test_data_in[i, -lookback:, :].reshape((1, lookback, 1)).cpu()\n", 282 | " temp = ypred[:i,:]\n", 283 | " inputs[0, (lookback - i):lookback, :] = torch.tensor(temp, dtype=torch.float32)\n", 284 | " ypred[i, :] = rnn_model(inputs).detach().numpy()\n", 285 | "\n", 286 | " else:\n", 287 | " inputs = torch.tensor(ypred[i - lookback:i,:].reshape((1, lookback, 1)), dtype=torch.float32)\n", 288 | " ypred[i, :] = rnn_model(inputs).detach().numpy()\n", 289 | "\n" 290 | ], 291 | "metadata": { 292 | "id": "KQSHD5Gc1CzX" 293 | }, 294 | "execution_count": 12, 295 | "outputs": [] 296 | }, 297 | { 298 | "cell_type": "markdown", 299 | "source": [ 300 | "Plot our forecast and the ground truth." 301 | ], 302 | "metadata": { 303 | "id": "W7kSYpSM65R0" 304 | } 305 | }, 306 | { 307 | "cell_type": "code", 308 | "source": [ 309 | "plt.plot(t[lookback:], ypred, label='Forecast')\n", 310 | "plt.plot(t[lookback:], test_data_out, label='Truth')\n", 311 | "plt.ylabel('x')\n", 312 | "plt.xlabel('t')\n", 313 | "plt.legend()\n", 314 | "plt.show()" 315 | ], 316 | "metadata": { 317 | "colab": { 318 | "base_uri": "https://localhost:8080/", 319 | "height": 279 320 | }, 321 | "id": "2LoVmd8dqpDM", 322 | "outputId": "db72bd5f-67d2-497b-9edc-4ee7524c0f9e" 323 | }, 324 | "execution_count": 13, 325 | "outputs": [ 326 | { 327 | "output_type": "display_data", 328 | "data": { 329 | "text/plain": [ 330 | "
" 331 | ], 332 | "image/png": "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\n" 333 | }, 334 | "metadata": { 335 | "needs_background": "light" 336 | } 337 | } 338 | ] 339 | }, 340 | { 341 | "cell_type": "markdown", 342 | "source": [ 343 | "The forecast is generally bad, but reasonable in the short term. \n", 344 | "Questions for exploration:\n", 345 | "1. This architecture was designed with hyperparameters chosen mostly randomly. Can you tune parameters to improve performance?\n", 346 | "2. Can you improve the basic training loop provided to train the network faster? Improve performance? Revert to better performing parameters?\n", 347 | "3. How does the network generalize beyond the range $\\omega \\in (\\pi, 3\\pi)?$\n", 348 | "4. Try making the lookback parameter very long. You should find that past some length, the network will struggle to yield forecasts that are reasonable even in the very short term. This is the problem of \"vanishing gradients.\" LSTMs are one way to address this issue." 349 | ], 350 | "metadata": { 351 | "id": "vWK3z4zI64iw" 352 | } 353 | } 354 | ] 355 | } -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # CTF Workshop Tutorial 2 | 3 | This repository contains codes for the CTF Workshop tutorial of the AI Intstitute in Dynamic Systems. Please download or clone the repository for running the notebooks on your machine. Otherwise, every notebook has a link to Google Colab. 4 | 5 | # Outline 6 | 7 | ### Part 1: Introduction to Deep Learning - 9:00-11:00AM (Joe Bakarji) 8 | - Introduction to Deep Learning 9 | - Time-delay embedding and Takens' theorem 10 | - Introduction to PyTorch 11 | - The Lorenz system 12 | - The Hankel matrix 13 | - Approximating Takens' diffeomorphism 14 | - Autoencoders 15 | - Linear and nonlinear dominant time-modes 16 | - Practice Examples: 17 | - Surrogate model of the diffusion equation solution: u(x, t) 18 | - Fit the model $\mathbf x_{i+1}=\mathbf f(\mathbf x_i)$ with a fully connected network. 19 | 20 | 21 | ### Part 2: Recurrent Neural Networks - 1:00PM-2:30PM (Jan Williams) 22 | - Prevalence of sequential data in dynamical system applications 23 | 24 | - Recurrent neural network architectures 25 | 26 | - Mathematical formulation of generic RNNs (with focus on RNN's) 27 | 28 | - Barebones implementation of vanilla RNN for forecasting periodic univariate data 29 | 30 | - Mathematical formulation of LSTMs 31 | - Time delay embeddings using recurrent layers and Lorenz, $x_{i+1}= f(x_i, x_{i-1}, ... x_{i-k})$. 32 | - Reconstruct and/or forecast sea-surface temperature from limited sensor measurements using LSTMs 33 | 34 | 35 | ### Part 3: Pruning - 3:00PM-4:30PM (Olivia Thomas) 36 | - Why sparsify neural networks? 37 | - The importance of Regularization 38 | - Reducing the memory footprint 39 | - Sparsification methods 40 | - traditional regularization approaches 41 | - Defining a sparse architecture 42 | - Pruning 43 | - Practice problems 44 | 45 | 46 | -------------------------------------------------------------------------------- /google_drive_mount_code.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 10, 6 | "metadata": { 7 | "id": "D6QIb5zOSi2v" 8 | }, 9 | "outputs": [], 10 | "source": [ 11 | "import os\n", 12 | "import scipy.io\n", 13 | "\n", 14 | "import pandas as pd" 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": 1, 20 | "metadata": { 21 | "colab": { 22 | "base_uri": "https://localhost:8080/" 23 | }, 24 | "id": "e2-lIL57RR3g", 25 | "outputId": "2f119fe4-2a6a-4468-cec4-e76591fcdacd" 26 | }, 27 | "outputs": [ 28 | { 29 | "name": "stdout", 30 | "output_type": "stream", 31 | "text": [ 32 | "Mounted at /gdrive/\n", 33 | "MyDrive Shareddrives\n" 34 | ] 35 | } 36 | ], 37 | "source": [ 38 | "from google.colab import drive\n", 39 | "drive.mount('/gdrive/')\n", 40 | "!ls /gdrive" 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": 4, 46 | "metadata": { 47 | "id": "fLrQRBl8RoWP" 48 | }, 49 | "outputs": [], 50 | "source": [ 51 | "BASE_PATH = '/gdrive/My Drive/CTF Deep Learning Workshop/'\n", 52 | "if not os.path.exists(BASE_PATH):\n", 53 | " os.makedirs(BASE_PATH)\n", 54 | "DATA_PATH = BASE_PATH + 'Sea surface temperature/'" 55 | ] 56 | }, 57 | { 58 | "cell_type": "code", 59 | "execution_count": 6, 60 | "metadata": { 61 | "id": "B-rRj-nfShZe" 62 | }, 63 | "outputs": [], 64 | "source": [ 65 | "data = scipy.io.loadmat(os.path.join(DATA_PATH, 'SST_data.mat'))" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": null, 71 | "metadata": { 72 | "id": "FyGXft7dTcam" 73 | }, 74 | "outputs": [], 75 | "source": [] 76 | } 77 | ], 78 | "metadata": { 79 | "colab": { 80 | "provenance": [] 81 | }, 82 | "kernelspec": { 83 | "display_name": "base", 84 | "language": "python", 85 | "name": "python3" 86 | }, 87 | "language_info": { 88 | "name": "python", 89 | "version": "3.8.5" 90 | }, 91 | "vscode": { 92 | "interpreter": { 93 | "hash": "1cec93c3674bfd1afa4b15c70c9d9dc0c8affa484b58136f14c49e79b9d4b788" 94 | } 95 | } 96 | }, 97 | "nbformat": 4, 98 | "nbformat_minor": 0 99 | } 100 | -------------------------------------------------------------------------------- /slides/CTFRNN.pptx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dynamicslab/ctf-dl-tutorial/094498c9075a5c4d8a3c384d3b09d11c8c6fc805/slides/CTFRNN.pptx -------------------------------------------------------------------------------- /slides/deep-learning-slides.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dynamicslab/ctf-dl-tutorial/094498c9075a5c4d8a3c384d3b09d11c8c6fc805/slides/deep-learning-slides.pdf --------------------------------------------------------------------------------