02 2D CNN - Keras.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "In this study, we will start by studying the applicability of using the raw data from the seismometer as an input to the neural network for recognition and prediction of earthquakes. The raw data is a time series data of 100 Hz frequency which discribes the vertical motion of the earth. The figure below show a simple illustration of how it is measured. Note that the current tools rely on a more sophisticated and accurate tools but the concept is still the same.\n",
    "\n",
    "As mentioned above, two problems are studied described in the figure above. Obviously, the second problem is more complicated as there is no known method to do this. In fact, it is not known that the signal contain information for the prediction. The two problems are:\n",
    "1. The recognition of the earthquakes signal after they occur.\n",
    "2. The prediction of earthquakes signal before they occur.\n",
    "\n",
    "<img src=\"Figures/For Notbooks/Seismometer.png\" width=\"700\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dataset\n",
    "The dataset was harvested from servers specifically for this study. After compiling numerous datasets with varying [minimum earthquake magnitude](https://en.wikipedia.org/wiki/Richter_magnitude_scale), lateral coverage, and number of stations, this study area ([The Geysers](https://en.wikipedia.org/wiki/The_Geysers)) of the  is specifically chosen because:\n",
    "1. It contains a spatially dense seismometers coverage.\n",
    "2. The seismicmometers have been operating for a relatively long time.\n",
    "3. The area is tectonically active because of the existance of the geysers.\n",
    "4. Enhanced geothermal system are operating in the area creating more earthquakes.\n",
    "\n",
    "<img src=\"Figures/For Notbooks/Map.png\" width=\"600\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Package and helper functions\n",
    "We will use [Keras](https://keras.io/) to build the neural network, [Matplotlib](https://matplotlib.org/) for plotting results if needed, and [Numpy](http://www.numpy.org/) for matrix manipulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Numpy (The God package)\n",
    "import numpy as np\n",
    "\n",
    "# MatplotLib\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import mlab\n",
    "from matplotlib.colors import Normalize\n",
    "\n",
    "# Other\n",
    "import math as M\n",
    "from skimage.transform import resize\n",
    "from obspy.imaging.cm import obspy_sequential\n",
    "\n",
    "# Keras\n",
    "from keras.callbacks import ModelCheckpoint\n",
    "from keras.models import Model, load_model, Sequential\n",
    "from keras.layers import Dense, Activation, Dropout, Input, Masking, TimeDistributed, LSTM, Conv1D, Conv2D\n",
    "from keras.layers import GRU, Bidirectional, BatchNormalization, Reshape, Flatten, MaxPooling1D, MaxPooling2D\n",
    "from keras.optimizers import Adam\n",
    "\n",
    "# Sklearn\n",
    "from sklearn.metrics import confusion_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use this cell to create some helper functions that will be used in the analysis. We decided to have all the functions needed in one script to facilitate readibility and understanding."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def splitDataset2D(X, Y, proportions=np.array([.8, .2])):\n",
    "    \"\"\"\n",
    "    Splits the dataset into a number of smaller datasets with certain given ratios.\n",
    "    \n",
    "    Argument:\n",
    "    X -- Input dataset\n",
    "    Y -- Labels\n",
    "\n",
    "    Returns:\n",
    "    Xs -- Splitted dataset (dictionary with numbers as keys)\n",
    "    Ys -- Splitted labels  (dictionary with numbers as keys)\n",
    "    \"\"\"\n",
    "    \n",
    "    # Make sure proportions are a numpy array\n",
    "    proportions = np.array(proportions)\n",
    "    \n",
    "    # Handle an option to provide one ratio\n",
    "    if (np.sum(proportions)!=1):\n",
    "        ratios = np.concatenate((proportions, np.array([1-np.sum(proportions)])))\n",
    "        \n",
    "    # Create the random indices\n",
    "    m = X.shape[0] \n",
    "    randomIndecies = np.random.permutation(m)\n",
    "    \n",
    "    # Calculate the number of boundaries of indecies in each set\n",
    "    nSamples = np.round(proportions * m)\n",
    "    nSamples = np.concatenate((np.array([0]), np.round(proportions * m)))\n",
    "    nSamples = np.cumsum(nSamples)\n",
    "    nSamples = nSamples.astype(int)\n",
    "    \n",
    "    # Extract teh sets\n",
    "    Xs = []\n",
    "    Ys = []\n",
    "    for i in range(0, proportions.size):\n",
    "        chosenSamples = randomIndecies[nSamples[i]:nSamples[i+1]]\n",
    "        Xs.append(X[chosenSamples, :, :, :])\n",
    "        Ys.append(Y[chosenSamples, :])\n",
    "        \n",
    "    return Xs, Ys\n",
    "\n",
    "# ======================================================================\n",
    "def normalizeData(data, axis=None, keepdims=True):\n",
    "    \"\"\"\n",
    "    Computes the zscore of data along a certain axis.\n",
    "    \n",
    "    Argument:\n",
    "    data -- Data to be normalized\n",
    "    axis -- Axis to normalized (if no axis is given, we\n",
    "\n",
    "    Returns:\n",
    "    normalizedData -- normalized dataset\n",
    "    Ys -- Splitted labels  (dictionary with numbers as keys)\n",
    "    \"\"\"\n",
    "    \n",
    "    # Zscore normalization\n",
    "    normalizedData = (data - np.mean(data, axis = axis, keepdims= keepdims)) / np.std(data, axis = axis, keepdims = keepdims)\n",
    "    return normalizedData\n",
    "\n",
    "# ======================================================================\n",
    "def spectrogramAnalysis(signal, fs, newShape=None, isNormalize=False, isPlot=False):\n",
    "    \"\"\"\n",
    "    Runs the spectogram analysis, resize, and normalize in one go.\n",
    "    \n",
    "    Argument:\n",
    "    signal      -- Data to be analyzed (1D)\n",
    "    fs          -- Sampling frequency\n",
    "    newSahpe    -- New size to scale histogram\n",
    "    isNormalize -- Normalize the result or not\n",
    "    isPlot      -- To show the results in a figure\n",
    "\n",
    "    Returns:\n",
    "    specgram -- Histogram (2D image, 1 channel)\n",
    "    freq     -- Frequency vector\n",
    "    time     -- Time vector\n",
    "    \"\"\"\n",
    "    \n",
    "    specgram, freq, time = getSpectrogram(signal, fs, dbscale=True)\n",
    "    \n",
    "    if (newShape != None):\n",
    "        specgram = resize(specgram,newShape)\n",
    "        \n",
    "    if (isNormalize == True):\n",
    "        specgram = normalizeData(specgram)\n",
    "        \n",
    "    if (isPlot == True):\n",
    "        fig = plt.figure(num=None, figsize=(10, 8), dpi=100)\n",
    "        plt.imshow(specgram)\n",
    "        plt.gca().invert_yaxis()\n",
    "        \n",
    "    return specgram, freq, time\n",
    "\n",
    "# ======================================================================\n",
    "def plotAccuracy(history, isError=True):\n",
    "    trainValues = np.array(history.history[\"acc\"])\n",
    "    validValues = np.array(history.history[\"val_acc\"])\n",
    "    \n",
    "    if (isError == True):\n",
    "        trainValues = 1-trainValues\n",
    "        validValues = 1-validValues\n",
    "    \n",
    "    trainAxe, = plt.plot(trainValues, label=\"Training set\")\n",
    "    validAxe, = plt.plot(validValues, label=\"Validation set\")\n",
    "    \n",
    "    if (isError == True):\n",
    "        plt.ylabel('Error (fraction)')\n",
    "    else:\n",
    "        plt.ylabel('Accuracy (fraction)')\n",
    "\n",
    "    plt.xlabel('Epoch')\n",
    "    \n",
    "    plt.legend(handles=[trainAxe, validAxe])\n",
    "\n",
    "    \n",
    "# ======================================================================\n",
    "def getSpectrogram(data, samp_rate, per_lap=0.9, wlen=None, log=False,\n",
    "                outfile=None, fmt=None, axes=None, dbscale=False,\n",
    "                mult=8.0, zorder=None, title=None,\n",
    "                show=True, sphinx=False, clip=[0.0, 1.0]):\n",
    "    \"\"\"\n",
    "    Computes Spectogram of a 1D signal. This functions are based on Obspy internal functions\n",
    "    \"\"\"\n",
    "    \n",
    "    # enforce float for samp_rate\n",
    "    samp_rate = float(samp_rate)\n",
    "\n",
    "    # set wlen from samp_rate if not specified otherwise\n",
    "    if not wlen:\n",
    "        wlen = samp_rate / 100.\n",
    "\n",
    "    npts = len(data)\n",
    "    # nfft needs to be an integer, otherwise a deprecation will be raised\n",
    "    # XXX add condition for too many windows => calculation takes for ever\n",
    "    nfft = int(_nearest_pow_2(wlen * samp_rate))\n",
    "    if nfft > npts:\n",
    "        nfft = int(_nearest_pow_2(npts / 8.0))\n",
    "\n",
    "    if mult is not None:\n",
    "        mult = int(_nearest_pow_2(mult))\n",
    "        mult = mult * nfft\n",
    "    nlap = int(nfft * float(per_lap))\n",
    "\n",
    "    data = data - data.mean()\n",
    "    end = npts / samp_rate\n",
    "\n",
    "    \n",
    "    specgram, freq, time = mlab.specgram(data, Fs=samp_rate, NFFT=nfft,\n",
    "                                         pad_to=mult, noverlap=nlap)\n",
    "    # db scale and remove zero/offset for amplitude\n",
    "    if dbscale:\n",
    "        specgram = 10 * np.log10(specgram[1:, :])\n",
    "    else:\n",
    "        specgram = np.sqrt(specgram[1:, :])\n",
    "    freq = freq[1:]\n",
    "\n",
    "    vmin, vmax = clip\n",
    "    if vmin < 0 or vmax > 1 or vmin >= vmax:\n",
    "        msg = \"Invalid parameters for clip option.\"\n",
    "        raise ValueError(msg)\n",
    "    _range = float(specgram.max() - specgram.min())\n",
    "    vmin = specgram.min() + vmin * _range\n",
    "    vmax = specgram.min() + vmax * _range\n",
    "    norm = Normalize(vmin, vmax, clip=True)\n",
    "    \n",
    "    return specgram, freq, time\n",
    "\n",
    "# ======================================================================\n",
    "def _nearest_pow_2(x):\n",
    "    \"\"\"\n",
    "    Finds power of two nearest to x.\n",
    "\n",
    "    Argument:\n",
    "    x -- number\n",
    "    \n",
    "    Returns:\n",
    "    a/b -- Nearest power of 2 to x\n",
    "    \"\"\"\n",
    "    a = M.pow(2, M.ceil(np.log2(x)))\n",
    "    b = M.pow(2, M.floor(np.log2(x)))\n",
    "    if abs(a - x) < abs(b - x):\n",
    "        return a\n",
    "    else:\n",
    "        return b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we will load the dataset. The dataset is already saved in binary numpy format using another script written specifically for this study. The data loaded is the time series data and the labels. Note that we have two datasets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "folderName = \"Datasets\"\n",
    "datasetNumber = 9\n",
    "testPercent   = .1\n",
    "fs = 100\n",
    "spectogramShape = [64, 128]\n",
    "\n",
    "data = np.load(folderName + \"\\Data_D\" + str(datasetNumber) + \".npy\")\n",
    "label = np.load(folderName + \"\\Label_D\" + str(datasetNumber) + \".npy\")\n",
    "\n",
    "# for recognition dataset (12,13,14)\n",
    "if (datasetNumber == 12 or datasetNumber == 13 or datasetNumber == 14):\n",
    "    data = data[25000:35000,:,:]\n",
    "\n",
    "# for prediction dataset (9,10,11)\n",
    "if (datasetNumber == 9 or datasetNumber == 10 or datasetNumber == 11):\n",
    "    data = data[29500:30000,:,:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will calculate the spectogram for each 1D signal. The spectogram images are then collected as a dataset that will be used in the analysis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda3\\lib\\site-packages\\skimage\\transform\\_warps.py:84: UserWarning: The default mode, 'constant', will be changed to 'reflect' in skimage 0.15.\n",
      "  warn(\"The default mode, 'constant', will be changed to 'reflect' in \"\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2bda1833f98>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "specgram, freq, time = spectrogramAnalysis(data[:,80,0], fs, spectogramShape, isPlot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda3\\lib\\site-packages\\skimage\\transform\\_warps.py:84: UserWarning: The default mode, 'constant', will be changed to 'reflect' in skimage 0.15.\n",
      "  warn(\"The default mode, 'constant', will be changed to 'reflect' in \"\n"
     ]
    }
   ],
   "source": [
    "# Calculate all spectrograms\n",
    "dataSpectrogram = np.zeros((data.shape[1], spectogramShape[0], spectogramShape[1], data.shape[2]))\n",
    "for i in range(data.shape[1]):\n",
    "    for k in range(data.shape[2]):\n",
    "        dataToAnalyze = data[:,i,k]\n",
    "        specgram, freq, time = spectrogramAnalysis(dataToAnalyze, fs, spectogramShape)\n",
    "        dataSpectrogram[i,:, :,k] = specgram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the training percentage\n",
    "trainingPercent = 1 - testPercent;\n",
    "\n",
    "# Split the dataset\n",
    "Xs, Ys = splitDataset2D(dataSpectrogram, label, proportions=[trainingPercent, testPercent])\n",
    "\n",
    "# Get training data\n",
    "xTrain = Xs[0]\n",
    "yTrain = Ys[0][:,0]\n",
    "\n",
    "# Get test data\n",
    "xTest = Xs[1]\n",
    "yTest = Ys[1][:,0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Neural network model\n",
    "\n",
    "The model that will be used for this 1D convolutional network is as discribed in the figure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_9 (InputLayer)         (None, 64, 128, 1)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_33 (Conv2D)           (None, 64, 125, 16)       80        \n",
      "_________________________________________________________________\n",
      "max_pooling2d_33 (MaxPooling (None, 64, 31, 16)        0         \n",
      "_________________________________________________________________\n",
      "batch_normalization_33 (Batc (None, 64, 31, 16)        64        \n",
      "_________________________________________________________________\n",
      "activation_33 (Activation)   (None, 64, 31, 16)        0         \n",
      "_________________________________________________________________\n",
      "dropout_17 (Dropout)         (None, 64, 31, 16)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_34 (Conv2D)           (None, 58, 31, 32)        2080      \n",
      "_________________________________________________________________\n",
      "max_pooling2d_34 (MaxPooling (None, 29, 31, 32)        0         \n",
      "_________________________________________________________________\n",
      "batch_normalization_34 (Batc (None, 29, 31, 32)        128       \n",
      "_________________________________________________________________\n",
      "activation_34 (Activation)   (None, 29, 31, 32)        0         \n",
      "_________________________________________________________________\n",
      "dropout_18 (Dropout)         (None, 29, 31, 32)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_35 (Conv2D)           (None, 29, 22, 32)        4128      \n",
      "_________________________________________________________________\n",
      "max_pooling2d_35 (MaxPooling (None, 29, 11, 32)        0         \n",
      "_________________________________________________________________\n",
      "batch_normalization_35 (Batc (None, 29, 11, 32)        128       \n",
      "_________________________________________________________________\n",
      "activation_35 (Activation)   (None, 29, 11, 32)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_36 (Conv2D)           (None, 17, 11, 32)        4128      \n",
      "_________________________________________________________________\n",
      "max_pooling2d_36 (MaxPooling (None, 8, 11, 32)         0         \n",
      "_________________________________________________________________\n",
      "batch_normalization_36 (Batc (None, 8, 11, 32)         128       \n",
      "_________________________________________________________________\n",
      "activation_36 (Activation)   (None, 8, 11, 32)         0         \n",
      "_________________________________________________________________\n",
      "flatten_9 (Flatten)          (None, 2816)              0         \n",
      "_________________________________________________________________\n",
      "dense_9 (Dense)              (None, 1)                 2817      \n",
      "=================================================================\n",
      "Total params: 13,681\n",
      "Trainable params: 13,457\n",
      "Non-trainable params: 224\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "def constructModel(inputShape):\n",
    "    \"\"\"\n",
    "    Function creating the model's graph in Keras.\n",
    "    \n",
    "    Argument:\n",
    "    input_shape -- shape of the model's input data (using Keras conventions)\n",
    "\n",
    "    Returns:\n",
    "    model -- Keras model instance\n",
    "    \"\"\"\n",
    "    \n",
    "    xInput = Input(shape = inputShape)\n",
    "    \n",
    "    X = Conv2D(filters=16, kernel_size=[1,4], strides=1, dilation_rate=1)(xInput)        \n",
    "    X = MaxPooling2D(pool_size=[1,4], strides=None, padding='valid')(X)\n",
    "    X = BatchNormalization()(X)                                            \n",
    "    X = Activation('relu')(X)                                             \n",
    "    X = Dropout(.2)(X)                                                      \n",
    "\n",
    "    X = Conv2D(filters=32, kernel_size=[4,1], strides=1, dilation_rate=2)(X)       \n",
    "    X = MaxPooling2D(pool_size=[2,1], strides=None, padding='valid')(X)\n",
    "    X = BatchNormalization()(X)                        \n",
    "    X = Activation('relu')(X)                             \n",
    "    X = Dropout(.2)(X)\n",
    "    \n",
    "    X = Conv2D(filters=32, kernel_size=[1,4], strides=1, dilation_rate=3)(X)        \n",
    "    X = MaxPooling2D(pool_size=[1,2], strides=None, padding='valid')(X)\n",
    "    X = BatchNormalization()(X)                                            \n",
    "    X = Activation('relu')(X)\n",
    "    \n",
    "    X = Conv2D(filters=32, kernel_size=[4,1], strides=1, dilation_rate=4)(X)       \n",
    "    X = MaxPooling2D(pool_size=[2,1], strides=None, padding='valid')(X)\n",
    "    X = BatchNormalization()(X)                        \n",
    "    X = Activation('relu')(X)    \n",
    "    \n",
    "    X = Flatten()(X)\n",
    "    #X = Dense(2, activation = \"relu\")(X) \n",
    "    X = Dense(1, activation = \"sigmoid\")(X) \n",
    "\n",
    "    model = Model(inputs = xInput, outputs = X)\n",
    "    \n",
    "    return model\n",
    "\n",
    "model = constructModel(inputShape = (xTrain.shape[1], xTrain.shape[2], xTrain.shape[3]))\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 309 samples, validate on 35 samples\n",
      "Epoch 1/5\n",
      "309/309 [==============================] - 5s 18ms/step - loss: 0.8729 - acc: 0.4628 - val_loss: 0.6973 - val_acc: 0.6000\n",
      "Epoch 2/5\n",
      "309/309 [==============================] - 3s 10ms/step - loss: 0.8811 - acc: 0.5049 - val_loss: 0.6927 - val_acc: 0.5714\n",
      "Epoch 3/5\n",
      "309/309 [==============================] - 3s 11ms/step - loss: 0.7222 - acc: 0.5631 - val_loss: 0.6928 - val_acc: 0.5143\n",
      "Epoch 4/5\n",
      "309/309 [==============================] - 3s 11ms/step - loss: 0.7362 - acc: 0.5340 - val_loss: 0.6875 - val_acc: 0.5143\n",
      "Epoch 5/5\n",
      "309/309 [==============================] - 3s 11ms/step - loss: 0.7279 - acc: 0.5502 - val_loss: 0.6726 - val_acc: 0.5429\n"
     ]
    }
   ],
   "source": [
    "model = constructModel(inputShape = (xTrain.shape[1], xTrain.shape[2], xTrain.shape[3]))\n",
    "opt = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, decay=0.01)\n",
    "model.compile(loss='binary_crossentropy', optimizer=opt, metrics=[\"accuracy\"])\n",
    "history = model.fit(xTrain, yTrain, batch_size = 256, epochs=5, validation_split=.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "38/38 [==============================] - 0s 3ms/step\n",
      "Test set accuracy =  0.5000000015685433\n",
      "Guess Accuracy =  0.5392670157068062\n",
      "[[0.36842105 0.18421053]\n",
      " [0.31578947 0.13157895]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2bdaa9ab2e8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "loss, acc = model.evaluate(xTest, yTest)\n",
    "print(\"Test set accuracy = \", acc)\n",
    "print(\"Guess Accuracy = \", 1-np.sum(label)/label.size)\n",
    "\n",
    "yPred = model.predict(xTest) > .5                      \n",
    "print(confusion_matrix(yTest, yPred)/yTest.size)\n",
    "plotAccuracy(history, False)"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}