synthetic_geomagnetic_storms.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Synthetic Geomagnetic Storms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic description of toy forward model\n",
    "\n",
    "This notebook explores what network architectures work for predicting synthetic geomagnetic storms from impulses, which represent the integrated Xhf peaks described by Tobiska 2013. These impulses contain information about the propagation speed of mass ejections from the solar corona and thereby also about the time lag between ejection and storm as well as the ultimate magnitude of the storm.\n",
    "\n",
    "Here I generate random impulses, ranging initially on a linear scale (one order of magnitude of variation). This should actually be larger variation to resemble the true Xhf data, but I'll add this complication later. The input to the neural network will then be a time history of impulses, say from the past 5 days.\n",
    "\n",
    "The forward model will then be one that generates time lags associated with the impulses (with noise added) as well as Dst deflection magnitudes that roughly also scale with the impulse magnitude. My current implementation represents the lags uncertaintly, meaning that each lag has a mean related deterministically to a velocity computed directly from the impulse magnitude, but the actual lag is sampled from a normal distribution with a prescribed, constant variance. However, it might make more sense to represent the velocity with uncertainty, taking care to make sure that the velocity can never be considered zero or negative. The magnitude also has a mean deterministically computed from the impulse value and also ultimately drawn from a normal distribution with a prescribed variance.\n",
    "\n",
    "These two parameters will then describe the storm, with the main phase being an essentially instantaneous descent in Dst to the maximum deflection and then an exponential decay back to the background value of 0. The timescale of exponential decay will be the same in all storms (for now).  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Filtering by location on disk\n",
    "\n",
    "Amajor complication that will eventually need to be added is a sort of filtering based on impulse emission location. Tobiska 2013 identify particular regions on the solar disk from which solar ejections actually are geoeffective, meaning that many of the peaks in Xhf do not actually generate Dst anomalies because their association ejecta do not reach Earth's magnetosphere. \n",
    "\n",
    "In this toy example, this means that I need to include as part of the forward problem a set of coordinates for which a basic sort of noisy thresholding occurs, meaning that impulses further away from the center of the disk are less likely to be associated with geoeffective ejections. Only the largest ejections away from the center of the disk will generate storms, meaning that the probability should be weighted by the ejection size."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### CME database relevance\n",
    "\n",
    "To be discussed..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow_probability as tfp\n",
    "tfd = tfp.distributions\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "from tqdm import tqdm_notebook\n",
    "from scipy import signal\n",
    "from sklearn import preprocessing\n",
    "from scipy import stats\n",
    "\n",
    "from helper_functions import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate input and output data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input\n",
    "\n",
    "The input data are designed to mimic the model of Tobiska et al. (2013), where solar x-ray fluxes correspond to flares that are often associated with geoeffective mass ejections. The relevant input series are then:\n",
    "\n",
    "1) integrated peak magnitudes, represented as impulses,\n",
    "\n",
    "2) flare location information, represented as coordinates on a simulated solar hemisphere\n",
    "\n",
    "In this model, storm magnitude will decrease with distance of the impulse from the center of the solar disk."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "ndat = 100000\n",
    "\n",
    "# maximum velocity (impulse amplitude)\n",
    "max_vel = 5\n",
    "\n",
    "# generate input impulses\n",
    "impulses = np.random.randint(0, max_vel+1, (ndat, 1))\n",
    "\n",
    "# set most speeds randomly to zero\n",
    "rnd_idx = np.random.randint(0, 30, ndat)\n",
    "rnd_idx = rnd_idx < 29\n",
    "impulses[rnd_idx] = 0\n",
    "\n",
    "# for each impulse, generate location coordinates randomly (lat lon)\n",
    "locations = np.concatenate((np.random.rand(), \n",
    "                           ), axis=1)\n",
    "\n",
    "locations[rnd_idx, :] = 0\n",
    "\n",
    "data_in = np.conatenate((impulses, locations), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ac94a05976c147a295c4070ea603f62e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=100000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# initialize output with extra entries\n",
    "data_out = np.zeros((ndat+1000, 1))\n",
    "\n",
    "# arbitrary distance (modeling Earth-Sun distance)\n",
    "d = 16*24\n",
    "# decay constant\n",
    "tau = 0.05 \n",
    "t = np.arange(0,500).reshape(-1, 1)\n",
    "\n",
    "for ii in tqdm_notebook(range(ndat)):\n",
    "    if data_in[ii] != 0:\n",
    "        # generate velocity\n",
    "        v = data_in[ii] + 2\n",
    "        # generate lag time mean\n",
    "        lag_mu = d/v\n",
    "        # prescribe lag time standard deviation (in hours)\n",
    "        lag_std = 4\n",
    "        # generate lag randomly\n",
    "        lag = int(np.random.normal(loc=lag_mu, scale=lag_std, size=1))\n",
    "        # generate magnitude mean\n",
    "        mag_mu = 8*(v**1.8)\n",
    "        # prescribe magnitude standard deviation (nT)\n",
    "        mag_std = 10\n",
    "        # generate magnitude randomly\n",
    "        mag = int(np.random.normal(loc=mag_mu, scale=mag_std, size=1))\n",
    "        # generate decay profile based on most recent, largest Est excursion\n",
    "        if mag > data_out[ii+lag]:\n",
    "            data_out[ii+lag:ii+lag+500] = mag*np.exp(-tau*t)\n",
    "        \n",
    "# keep only first ndat values\n",
    "data_out = data_out[0:ndat]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since we will use previous values of Dst as input as well, we will add the computed output to the impulse series to generate full input array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_in = np.concatenate((data_in, data_out), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "lahead = 24\n",
    "train_percent = 0.9\n",
    "test_percent = 0.1\n",
    "val_percent = 0.0\n",
    "batch_size = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "in_slice = slice(0, ndat-lahead)\n",
    "out_slice = slice(lahead, ndat)\n",
    "\n",
    "data_in_shift = data_in[in_slice].astype(np.float32)\n",
    "data_out_shift = data_out[out_slice].astype(np.float32)\n",
    "\n",
    "ndat_shift = data_in_shift.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get indices\n",
    "train_idx = np.zeros(ndat_shift, dtype=bool)\n",
    "rlim = int(train_percent*ndat_shift) - (int(train_percent*ndat_shift) % batch_size)\n",
    "train_idx[0:rlim] = 1\n",
    "ntrain = np.sum(train_idx)\n",
    "\n",
    "test_idx = np.ones(ndat_shift, dtype=bool)\n",
    "test_idx[train_idx] = 0\n",
    "ntest = np.sum(test_idx)\n",
    "\n",
    "# split data\n",
    "data_in_train = data_in_shift[train_idx]\n",
    "data_out_train = data_out_shift[train_idx]\n",
    "\n",
    "data_in_test = data_in_shift[test_idx]\n",
    "data_out_test = data_out_shift[test_idx]\n",
    "\n",
    "# normalize and reshape\n",
    "scaler_input = preprocessing.MinMaxScaler(feature_range=(0,1))\n",
    "data_in_train_scaled = scaler_input.fit_transform(data_in_train)\n",
    "data_in_test_scaled = scaler_input.transform(data_in_test)\n",
    "\n",
    "scaler_output = preprocessing.MinMaxScaler(feature_range=(0,1))\n",
    "data_out_train_scaled = scaler_input.fit_transform(data_out_train)\n",
    "data_out_test_scaled = scaler_input.transform(data_out_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualizes\n",
    "\n",
    "Show some side-by-side of input and output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'toy model, 24 hour ahead forecast')"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_idx = slice(120, 300)\n",
    "\n",
    "# set impulses of zero to nan\n",
    "tmp = data_in_train[plot_idx, 0].copy()\n",
    "tmp[tmp == 0] = np.nan\n",
    "\n",
    "fig = plt.figure(figsize=[6,4])\n",
    "ax1 = plt.axes()\n",
    "ax2 = ax1.twinx()\n",
    "# impulses\n",
    "l1 = ax1.stem(tmp, linefmt='r-', markerfmt='ro', basefmt='k-', label='impulses (input 1)')\n",
    "# previous Dst\n",
    "# l2 = ax2.plot(data_in_train[plot_idx, 1], 'k--', label='previous Dst (input)')\n",
    "# Dst lahead \n",
    "l3 = ax2.plot(data_out_train[plot_idx], color='g', label='Est to forecast (output)')\n",
    "fig.legend(loc='upper right', bbox_to_anchor=(1,1), bbox_transform=ax1.transAxes)\n",
    "ax1.set_xlabel('hour')\n",
    "ax1.set_ylabel('impulse magnitude')\n",
    "ax2.set_ylabel('Est magnitude')\n",
    "plt.title('toy model, 24 hour ahead forecast')\n",
    "\n",
    "# plt.savefig('../figures/toy_model_data_example.pdf', format='pdf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Design network, Train, Test\n",
    "\n",
    "Here I design the network to figure out the toy problem. This network contains two couple parts:\n",
    "\n",
    "1) The job of the first part of the network is to effectively convert the impulse value into a broad curve of conceivable arrival impulses, as shown in the following figure. This transformation reflects the uncertainty in storm arrival, but the mean of this curve of arrival impulses should be inversely related to the impulse size, since larger impulses mean faster velocities, which in turn mean shorter lag times. Furthermore, the arrival impulse curve itself should also have uncertainty, since the ultimate Dst deviation from an impulse is uncertain. To represent this, I'll feed the 5%, 50%, and 95% percentiles, meaning that there will actually be three curves output from each impulse (ideally).\n",
    "<img src='figures/impulse_conversion.jpg' width='500px'>\n",
    "\n",
    "However, the network will have to learn this representation. This part of the network will actually receive as input a time history of impulses up to the present. Then, this history will be fed through a couple dense layers, with the last dense layer outputting four parameters for each of the input time steps: lag mean, magnitude mean, lag standard deviation, and magnitude standard deviation. These parameters are fed to an output distribution layer that transforms them into parameters of normal distributions, effectively then generating two distributions for each input time step.\n",
    "\n",
    "What we want is the time history up until the t+kth hour, however, while the input time history is only to the tth hour. So for a batch size $b$, we then initialize a tensor of the same batch size that contains time steps tt+k-b to tt+k and with three columns, containing the 5%, 50%, and 95% confidence intervals.\n",
    "\n",
    "We then populate this tensor by sampling\n",
    "\n",
    "2) The second part of the network takes the impulse arrival curves from the first part as input and additionally takes previous Dst as inputs for the final forecasting of Dst at t+k."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.python.framework import ops\n",
    "\n",
    "# custom layer class for computing arrival curves from lags\n",
    "class ArrivalsLayer(tf.keras.layers.Layer):\n",
    "    def __init__(self):\n",
    "        super(ArrivalsLayer, self).__init__()\n",
    "\n",
    "    def build(self, input_shape): \n",
    "        self.n_batch = input_shape[0]\n",
    "    \n",
    "    # inputs have following structure: \n",
    "    # first means, with first means for velocities and second for magnitudes\n",
    "    # second standard deviations\n",
    "    def call(self, inputs):\n",
    "        inputs = ops.convert_to_tensor(inputs)\n",
    "        # number of data points in batch\n",
    "        self.n_batch = inputs.shape[0]\n",
    "        # indices in output time vecotr (see notes)\n",
    "        self.idx_offset = np.arange(self.n_batch)\n",
    "        vel_mu = inputs[:, 0] + 1e-2\n",
    "        #sigs = inputs[:, 1]\n",
    "        lag_sig = 10*np.ones((self.n_batch, 1)).astype(np.float32)\n",
    "        # convert velocity to lag\n",
    "        lag_mu = d/vel_mu\n",
    "        # compute offset lags in terms of output time vector \n",
    "        lag_mu = lag_mu + self.idx_offset - lahead\n",
    "        lag_mu = tf.reshape(lag_mu, [1, -1])\n",
    "        lag_sig = tf.math.softplus(1e-3 + tf.reshape(lag_sig, [1, -1]))\n",
    "        # compute magnitude \n",
    "        mag_mu = tf.reshape(inputs[:, 1], [1, -1])\n",
    "        # evaluate distribution at mus\n",
    "        arr = mag_mu/np.sqrt(2*np.pi) * 1/lag_sig * tf.exp(-1/(2*tf.pow(lag_sig, 2)) * tf.pow(self.idx_offset.reshape(-1,1) - lag_mu, 2))\n",
    "        arr = tf.reshape(tf.reduce_max(arr, 1), [-1, 1])\n",
    "        return arr\n",
    "#         lag_dist = tfp.distributions.Normal(loc=mus_out, scale=input[:,2])\n",
    "#         mag_dist = tfp.distributions.Normal(loc=input[:,1], scale=input[:,3])\n",
    "#         arr = lag_dist.prob(self.idx_offset.reshape(-1,1))\n",
    "        # multiply by 5, 50, 95 percentiles of magnitude\n",
    "#         arr5 = tf.multiply(arr, mag_dist.quantile(0.05))\n",
    "#         arr50 = tf.multiply(arr, mag_dist)\n",
    "#         arr95 = tf.multiply(arr, mag_dist.quantile(0.95))\n",
    "        # take maxes along columns\n",
    "#         arr5_max = tf.reshape(tf.mean(arr5, 1), [-1, 1])\n",
    "#         arr50_max = tf.reshape(tf.reduce_mean(arr50, 1), [-1, 1])\n",
    "#         arr95_max = tf.reshape(tf.mean(arr95, 1), [-1, 1])\n",
    "        # combine\n",
    "#         arr_comb = tf.concat([arr5_max, arr50_max, arr95_max], 1)\n",
    "#         return arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build Keras model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code implements the sort of hand-crafted layers that convert impulses to velocities and amplitudes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "IN_1 = tf.keras.layers.Input(shape=(1, ), \n",
    "                             batch_size=batch_size, \n",
    "                             name='impulses')\n",
    "D_1 = tf.keras.layers.Dense(2, \n",
    "                            activation='tanh', \n",
    "                            kernel_initializer=tf.keras.initializers.Constant([5, 0.05]), \n",
    "                            use_bias=False,\n",
    "                            name='D_1')(IN_1)\n",
    "D_2 = tf.keras.layers.Dense(2, \n",
    "                            activation='relu', \n",
    "                            kernel_initializer=tf.keras.initializers.Constant([[2, 2], \n",
    "                                                                               [20, 20]]), \n",
    "                            use_bias=False,\n",
    "                            name='D_2')(D_1)\n",
    "D_3 = tf.keras.layers.Dense(2, \n",
    "                            activation='relu', \n",
    "                            kernel_initializer=tf.keras.initializers.Identity,\n",
    "                            use_bias=False,\n",
    "                            name='D_3')(D_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This code instead implements a general wide and slightly deep brute force approach to learning the requisite function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "IN_1 = tf.keras.layers.Input(shape=(1, ), \n",
    "                             batch_size=batch_size, \n",
    "                             name='impulses')\n",
    "D_1 = tf.keras.layers.Dense(200, \n",
    "                            activation='selu', \n",
    "                            kernel_initializer=tf.keras.initializers.RandomNormal(1), \n",
    "                            bias_initializer=tf.keras.initializers.RandomUniform,\n",
    "                            use_bias=True,\n",
    "                            name='D_1')(IN_1)\n",
    "# N_1 = tf.keras.layers.LayerNormalization(name='N_1')(D_1)\n",
    "D_2 = tf.keras.layers.Dense(2, \n",
    "                            activation='relu', \n",
    "                            kernel_initializer=tf.keras.initializers.RandomNormal(1), \n",
    "                            bias_initializer=tf.keras.initializers.RandomUniform,\n",
    "                            use_bias=True,\n",
    "                            name='D_2')(D_1)\n",
    "# N_2 = tf.keras.layers.LayerNormalization(name='N_2')(D_2)\n",
    "D_3 = tf.keras.layers.Dense(2, \n",
    "                            activation='relu', \n",
    "                            kernel_initializer=tf.keras.initializers.Identity,\n",
    "                            bias_initializer=tf.keras.initializers.Constant(0),\n",
    "                            use_bias=True,\n",
    "                            name='D_3')(D_2)\n",
    "# N_3 = tf.keras.layers.LayerNormalization()(D_3)\n",
    "# D_4 = tf.keras.layers.Dense(2, \n",
    "#                             activation='selu', \n",
    "# #                             kernel_initializer=tf.keras.initializers.Constant(1),\n",
    "# #                             bias_initializer=tf.keras.initializers.Constant(1),\n",
    "#                             use_bias=True,\n",
    "#                             name='D_4')(D_3)\n",
    "# D_5 = tf.keras.layers.Dense(1, \n",
    "#                             activation='selu', \n",
    "#                             kernel_initializer=tf.keras.initializers.Constant(1),\n",
    "#                             bias_initializer=tf.keras.initializers.Constant(1),\n",
    "#                             name='D_5')(D_4)\n",
    "# D_6 = tf.keras.layers.Dense(100, \n",
    "#                             activation='relu', \n",
    "# #                             kernel_initializer=tf.keras.initializers.Identity, \n",
    "#                             name='D_6')(D_5)\n",
    "# D_7 = tf.keras.layers.Dense(1, \n",
    "#                             activation='relu',\n",
    "#                             bias_initializer=tf.keras.initializers.Constant(5),\n",
    "#                             name='D_7')(D_2)\n",
    "#                             kernel_initializer=tf.keras.initializers.Constant(0.1),\n",
    "            # first two are means, first is for time lag, second for magnitude\n",
    "#                             )(D_3)\n",
    "\n",
    "# sub_model_3 = tf.keras.models.Model(inputs=IN_1, outputs=N_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here the separate layers are combined into the final models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "IN_2 = tf.keras.layers.Input(shape=(1, ), \n",
    "                             batch_size=batch_size, \n",
    "                             name='dst')\n",
    "\n",
    "ARR_1 = ArrivalsLayer()(D_3)\n",
    "# combine previous \"Dst\" with ARR_1 to make new \"input\"\n",
    "IN_COMB = tf.keras.layers.concatenate([IN_2, ARR_1], name='combined')\n",
    "# reshape\n",
    "IN_COMB = tf.keras.layers.Reshape((1, 2))(IN_COMB)\n",
    "\n",
    "ARR_1R = tf.keras.layers.Reshape((1,1))(ARR_1)\n",
    "\n",
    "LSTM_1 = tf.keras.layers.LSTM(10, name='LSTM_1')(IN_COMB)\n",
    "D_8 = tf.keras.layers.Dense(2, name='D_8', activation='selu')(LSTM_1)\n",
    "DIST_1 = tfp.layers.DistributionLambda(\n",
    "    make_distribution_fn=lambda t: tfd.Normal(loc=t[..., :1], \n",
    "                         scale=1e-3 + tf.math.softplus(1.0*t[..., 1:]))\n",
    "        )(D_8)\n",
    "\n",
    "\n",
    "# model = tf.keras.models.Model(inputs=[IN_1, IN_2], outputs=[D_5])\n",
    "model = tf.keras.models.Model(inputs=[IN_1, IN_2], outputs=[DIST_1])\n",
    "\n",
    "sub_model_1 = tf.keras.models.Model(inputs=IN_1, outputs = ARR_1)\n",
    "sub_model_2 = tf.keras.models.Model(inputs=IN_1, outputs = D_3)\n",
    "# sub_model_3 = tf.keras.models.Model(inputs=IN_1, outputs = LSTM_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compile model\n",
    "\n",
    "Part of this compilation requires specifying a custom loss function. This function ignores the first 72 hours of data within a batch, since for these data, the input series of impulses is not yet relevant for the output series of simulated Dst. The network cannot be expected to predict the first values of Dst if there is a lag in propagation (unless lahead >= 72), so we will ignore the first 72-lahead values. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.python.ops import math_ops\n",
    "from tensorflow.python.keras import backend as K\n",
    "\n",
    "def negloglik_mask(y_true, py_pred):\n",
    "    mask = np.ones((batch_size, 1))\n",
    "    mask[0:120-lahead] = 0\n",
    "    loss = -py_pred.log_prob(y_true)\n",
    "    y_pred_loc = py_pred.loc\n",
    "    loss = loss + tf.reshape(K.mean(math_ops.squared_difference(y_pred_loc, y_true), axis=-1), [-1, 1])\n",
    "    loss = loss*mask\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_34\"\n",
      "__________________________________________________________________________________________________\n",
      "Layer (type)                    Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      "impulses (InputLayer)           [(1000, 1)]          0                                            \n",
      "__________________________________________________________________________________________________\n",
      "D_1 (Dense)                     (1000, 200)          400         impulses[0][0]                   \n",
      "__________________________________________________________________________________________________\n",
      "D_2 (Dense)                     (1000, 2)            402         D_1[0][0]                        \n",
      "__________________________________________________________________________________________________\n",
      "D_3 (Dense)                     (1000, 2)            6           D_2[0][0]                        \n",
      "__________________________________________________________________________________________________\n",
      "dst (InputLayer)                [(1000, 1)]          0                                            \n",
      "__________________________________________________________________________________________________\n",
      "arrivals_layer_9 (ArrivalsLayer (1000, 1)            0           D_3[0][0]                        \n",
      "__________________________________________________________________________________________________\n",
      "combined (Concatenate)          (1000, 2)            0           dst[0][0]                        \n",
      "                                                                 arrivals_layer_9[0][0]           \n",
      "__________________________________________________________________________________________________\n",
      "reshape_18 (Reshape)            (1000, 1, 2)         0           combined[0][0]                   \n",
      "__________________________________________________________________________________________________\n",
      "LSTM_1 (LSTM)                   (1000, 10)           520         reshape_18[0][0]                 \n",
      "__________________________________________________________________________________________________\n",
      "D_8 (Dense)                     (1000, 2)            22          LSTM_1[0][0]                     \n",
      "__________________________________________________________________________________________________\n",
      "distribution_lambda_9 (Distribu ((1000, 1), (1000, 1 0           D_8[0][0]                        \n",
      "==================================================================================================\n",
      "Total params: 1,350\n",
      "Trainable params: 1,350\n",
      "Non-trainable params: 0\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.compile(loss=negloglik_mask,\n",
    "              optimizer=tf.keras.optimizers.Adam(lr=0.002))\n",
    "\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 89000 samples\n",
      "89000/89000 [==============================] - 3s 32us/sample - loss: 6706.8707\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x1c33b1bc18>"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit([data_in_train[:, 0].reshape(-1,1),\n",
    "           data_in_train[:, 1].reshape(-1,1)],\n",
    "          data_out_train,\n",
    "          epochs=1,\n",
    "          verbose=1,\n",
    "          shuffle=False,\n",
    "          batch_size=batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "eval_idx = slice(0, 1000)\n",
    "plot_idx = slice(200, 800)\n",
    "arr_curve = sub_model_1(data_in_train[eval_idx, 0].reshape(-1, 1))\n",
    "\n",
    "imp = data_in_train[plot_idx, 0].copy()\n",
    "imp[imp == 0] = np.nan\n",
    "\n",
    "plt.figure(figsize=[6,4])\n",
    "ax1 = plt.axes()\n",
    "ax2 = ax1.twinx()\n",
    "ax3 = ax1.twinx()\n",
    "ax3.spines[\"right\"].set_position((\"axes\", 1.2))\n",
    "\n",
    "l1 = ax1.stem(imp, linefmt='r-', markerfmt='ro', basefmt='k-', label='impulses (input 1)')\n",
    "ax2.plot(arr_curve[plot_idx], 'b-', label='arrival curve')\n",
    "ax3.plot(data_out_train[plot_idx], 'g-', label='Est to forecast')\n",
    "\n",
    "ax1.set_xlabel('hour')\n",
    "ax1.set_ylabel('impulse magnitude')\n",
    "ax2.set_ylabel('arrival curve amplitude')\n",
    "ax3.set_ylabel('Est to forecast (nT)')\n",
    "plt.title('$f_1(x)$ arrival curve output, %d hour ahead' % lahead)\n",
    "\n",
    "ax1.yaxis.label.set_color('r')\n",
    "ax2.yaxis.label.set_color('b')\n",
    "ax3.yaxis.label.set_color('g')\n",
    "\n",
    "# plt.savefig('../figures/toy_model_arrivalcurve.pdf', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1c4b1a5748>"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "est_pred = model([data_in_train[eval_idx, 0].reshape(-1,1), data_in_train[eval_idx, 1].reshape(-1,1)])\n",
    "\n",
    "fig = plt.figure(figsize=[6,5])\n",
    "\n",
    "ax1 = plt.axes()\n",
    "# ax2 = ax1.twinx()\n",
    "\n",
    "ax1.plot(est_pred.mean()[plot_idx], 'r-', label='mean Est forecast')\n",
    "ax1.fill_between(np.arange(len(data_in_train[plot_idx, 0])),\n",
    "                 est_pred.loc.numpy().reshape(-1)[plot_idx]-\n",
    "                         2*est_pred.scale.numpy().reshape(-1)[plot_idx], \n",
    "                 est_pred.loc.numpy().reshape(-1)[plot_idx]+\n",
    "                         2*est_pred.scale.numpy().reshape(-1)[plot_idx],\n",
    "                color='r', alpha=0.2, label='95% confidence interval')\n",
    "ax1.plot(data_out_train[plot_idx], 'g-', label='true Est')\n",
    "# ax1.plot(data_in_train[plot_idx, 1], 'k--', label='previous Est (input)')\n",
    "# ax2.plot(arr_curve[plot_idx], 'b', label='arrival curve')\n",
    "\n",
    "ax1.set_xlabel('hour')\n",
    "ax1.set_ylabel('Est (nT)')\n",
    "# ax2.set_ylabel('arrival curve amplitude')\n",
    "plt.title('%d hour ahead forecast' % lahead)\n",
    "fig.legend(loc='upper right', bbox_to_anchor=(1,1), bbox_transform=ax1.transAxes)\n",
    "# plt.savefig('../figures/toy_model_24hourforecast.pdf', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reliability"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_out_train_pred = model([data_in_train[:, 0].reshape(-1,1), data_in_train[:, 1].reshape(-1,1)])\n",
    "\n",
    "data_out_train_pred_loc = data_out_train_pred.loc.numpy()\n",
    "data_out_train_pred_scale = data_out_train_pred.scale.numpy()\n",
    "data_out_train_pred_tmp = [stats.norm(loc=loc, scale=scale) for loc, scale in zip(data_out_train_pred_loc, data_out_train_pred_scale)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute reliability curves\n",
    "thres = [50, 100, 150, 200]\n",
    "nthres = len(thres)\n",
    "bin_edges = np.linspace(0, 1, 15)\n",
    "bins = np.diff(bin_edges)/2 + bin_edges[0:-1]\n",
    "nbins = len(bins)\n",
    "first = False\n",
    "exc = 'geq'\n",
    "\n",
    "obs_exc = np.zeros((nbins, nthres))\n",
    "for ii in range(nthres):\n",
    "    obs_exc[:, ii] = reliability(data_out_train_pred_tmp, data_out_train, \n",
    "                                 thres[ii], \n",
    "                                 bin_edges, \n",
    "                                 exc=exc, \n",
    "                                 first=first)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=[6, 6])\n",
    "for ii in range(nthres):\n",
    "    plt.plot(bins, obs_exc[:,ii], label=str(thres[ii])+' nT')\n",
    "abline(1, 0)\n",
    "plt.xlabel('modeled exceedance probability')\n",
    "plt.ylabel('observed exceedance rate')\n",
    "plt.title('toy model reliability, t + %d' % lahead)\n",
    "plt.grid(True)\n",
    "plt.legend(loc='lower right')\n",
    "plt.savefig('../figures/toy_model_reliability_t+6.pdf', format='pdf', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}