Keras_trade_oanda.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!/usr/bin/python\n",
    "from __future__ import absolute_import\n",
    "\n",
    "import numpy as np\n",
    "import scipy.sparse\n",
    "import xgboost as xgb\n",
    "import pickle\n",
    "import talib as ta\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "from keras.models import Sequential\n",
    "from keras.layers.core import Dense, Dropout, Activation\n",
    "from keras.layers.normalization import BatchNormalization\n",
    "from keras.layers.advanced_activations import PReLU\n",
    "from keras.utils import np_utils, generic_utils\n",
    "\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "INPUT_LEN = 1\n",
    "OUTPUT_LEN = 5\n",
    "TRAINDATA_DIV = 10\n",
    "CHART_TYPE_JDG_LEN = 25\n",
    "\n",
    "def preprocess_data(X, scaler=None):\n",
    "    if not scaler:\n",
    "        scaler = StandardScaler()\n",
    "        scaler.fit(X)\n",
    "    X = scaler.transform(X)\n",
    "    return X, scaler\n",
    "    \n",
    "def preprocess_labels(labels, encoder=None, categorical=True):\n",
    "    if not encoder:\n",
    "        encoder = LabelEncoder()\n",
    "        encoder.fit(labels)\n",
    "    y = encoder.transform(labels).astype(np.int32)\n",
    "    if categorical:\n",
    "        y = np_utils.to_categorical(y)\n",
    "    return y, encoder\n",
    "\n",
    "\n",
    "def merge_csv(out_fname, input_files):\n",
    "    frslt = open('./hoge.csv', 'w')        \n",
    "    frslt.write(\"Date Time,Open,High,Low,Close,Volume,Adj Close\\n\")\n",
    "\n",
    "    for iname in input_files:\n",
    "        fd = open(iname, 'r')\n",
    "        for trxline in fd:\n",
    "            splited = trxline.split(\",\")\n",
    "            if splited[0] != \"<DTYYYYMMDD>\" and splited[0] != \"204/04/26\" and splited[0] != \"20004/04/26\":\n",
    "                time = splited[0].replace(\"/\", \"-\") + \" \" + splited[1]\n",
    "                val = splited[2]\n",
    "\n",
    "                frslt.write(str(time) + \",\" + str(val) + \",\" + \\\n",
    "                            str(val) + \",\" + str(val) + \\\n",
    "                            \",\" + str(val) + \",1000000,\"+ str(val) + \"\\n\")\n",
    "\n",
    "    frslt.close()\n",
    "\n",
    "# 0->flat 1->upper line 2-> downer line 3->above is top 4->below is top\n",
    "def judge_chart_type(data_arr):\n",
    "    max_val = 0\n",
    "    min_val = float(\"inf\")\n",
    "\n",
    "    last_idx = len(data_arr)-1\n",
    "    \n",
    "    for idx in xrange(len(data_arr)):\n",
    "        if data_arr[idx] > max_val:\n",
    "            max_val = data_arr[idx]\n",
    "            max_idx = idx\n",
    "\n",
    "        if data_arr[idx] < min_val:\n",
    "            min_val = data_arr[idx]\n",
    "            min_idx = idx\n",
    "\n",
    "\n",
    "    if max_val == min_val:\n",
    "        return 0\n",
    "    \n",
    "    if min_idx == 0 and max_idx == last_idx:\n",
    "        return 1\n",
    "\n",
    "    if max_idx == 0 and min_idx == last_idx:\n",
    "        return 2\n",
    "\n",
    "    if max_idx != 0 and max_idx != last_idx and min_idx != 0 and min_idx != last_idx:\n",
    "        return 0\n",
    "    \n",
    "    if max_idx != 0 and max_idx != last_idx:\n",
    "        return 3\n",
    "\n",
    "    if min_idx != 0 and min_idx != last_idx:\n",
    "        return 4\n",
    "        \n",
    "    return 0\n",
    "\n",
    "def get_rsi(price_arr, cur_pos, period = 40):\n",
    "    if cur_pos <= period:\n",
    "#        s = 0\n",
    "        return 0\n",
    "    else:\n",
    "        s = cur_pos - (period + 1)\n",
    "    tmp_arr = price_arr[s:cur_pos]\n",
    "    tmp_arr.reverse()\n",
    "    prices = np.array(tmp_arr, dtype=float)\n",
    "\n",
    "    return ta.RSI(prices, timeperiod = period)[-1]\n",
    "\n",
    "def get_ma(price_arr, cur_pos, period = 20):\n",
    "    if cur_pos <= period:\n",
    "        s = 0\n",
    "    else:\n",
    "        s = cur_pos - period\n",
    "    tmp_arr = price_arr[s:cur_pos]\n",
    "    tmp_arr.reverse()\n",
    "    prices = np.array(tmp_arr, dtype=float)\n",
    "\n",
    "    return ta.SMA(prices, timeperiod = period)[-1]\n",
    "\n",
    "def get_ma_kairi(price_arr, cur_pos, period = None):\n",
    "    ma = get_ma(price_arr, cur_pos)\n",
    "    return ((price_arr[cur_pos] - ma) / ma) * 100.0\n",
    "    return 0\n",
    "\n",
    "def get_bb_1(price_arr, cur_pos, period = 40):\n",
    "    if cur_pos <= period:\n",
    "        s = 0\n",
    "    else:\n",
    "        s = cur_pos - period\n",
    "    tmp_arr = price_arr[s:cur_pos]\n",
    "    tmp_arr.reverse()\n",
    "    prices = np.array(tmp_arr, dtype=float)\n",
    "\n",
    "    return ta.BBANDS(prices, timeperiod = period)[0][-1]\n",
    "\n",
    "def get_bb_2(price_arr, cur_pos, period = 40):\n",
    "    if cur_pos <= period:\n",
    "        s = 0\n",
    "    else:\n",
    "        s = cur_pos - period\n",
    "    tmp_arr = price_arr[s:cur_pos]\n",
    "    tmp_arr.reverse()\n",
    "    prices = np.array(tmp_arr, dtype=float)\n",
    "\n",
    "    return ta.BBANDS(prices, timeperiod = period)[2][-1]\n",
    "\n",
    "def get_ema(price_arr, cur_pos, period = 20):\n",
    "    if cur_pos <= period:\n",
    "        s = 0\n",
    "    else:\n",
    "        s = cur_pos - period\n",
    "    tmp_arr = price_arr[s:cur_pos]\n",
    "    tmp_arr.reverse()\n",
    "    prices = np.array(tmp_arr, dtype=float)\n",
    "\n",
    "    return ta.EMA(prices, timeperiod = period)[-1]    \n",
    "\n",
    "\n",
    "def get_ema_rsi(price_arr, cur_pos, period = None):\n",
    "    return 0\n",
    "\n",
    "def get_cci(price_arr, cur_pos, period = None):\n",
    "    return 0\n",
    "\n",
    "def get_mo(price_arr, cur_pos, period = 20):\n",
    "    if cur_pos <= (period + 1):\n",
    "#        s = 0\n",
    "        return 0\n",
    "    else:\n",
    "        s = cur_pos - (period + 1)\n",
    "    tmp_arr = price_arr[s:cur_pos]\n",
    "    tmp_arr.reverse()\n",
    "    prices = np.array(tmp_arr, dtype=float)\n",
    "\n",
    "    return ta.CMO(prices, timeperiod = period)[-1]        \n",
    "\n",
    "def get_po(price_arr, cur_pos, period = 10):\n",
    "    if cur_pos <= period:\n",
    "        s = 0\n",
    "    else:\n",
    "        s = cur_pos - period\n",
    "    tmp_arr = price_arr[s:cur_pos]\n",
    "    tmp_arr.reverse()\n",
    "    prices = np.array(tmp_arr, dtype=float)\n",
    "\n",
    "    return ta.PPO(prices)[-1]\n",
    "\n",
    "def get_lw(price_arr, cur_pos, period = None):\n",
    "    return 0\n",
    "\n",
    "def get_ss(price_arr, cur_pos, period = None):\n",
    "    return 0\n",
    "\n",
    "def get_dmi(price_arr, cur_pos, period = None):\n",
    "    return 0\n",
    "\n",
    "def get_vorarity(price_arr, cur_pos, period = None):\n",
    "    tmp_arr = []\n",
    "    prev = -1\n",
    "    for val in price_arr[cur_pos-CHART_TYPE_JDG_LEN:cur_pos]:\n",
    "        if prev == -1:\n",
    "            tmp_arr.append(0)\n",
    "        else:\n",
    "            tmp_arr.append(val - prev)\n",
    "        prev = val\n",
    "        \n",
    "    return np.std(tmp_arr)\n",
    "\n",
    "def get_macd(price_arr, cur_pos, period = 100):\n",
    "    if cur_pos <= period:\n",
    "        s = 0\n",
    "    else:\n",
    "        s = cur_pos - period\n",
    "    tmp_arr = price_arr[s:cur_pos]\n",
    "    tmp_arr.reverse()\n",
    "    prices = np.array(tmp_arr, dtype=float)\n",
    "\n",
    "    macd, macdsignal, macdhist = ta.MACD(prices,fastperiod=12, slowperiod=26, signalperiod=9)\n",
    "    if macd[-1] > macdsignal[-1]:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "\"\"\"\n",
    "main\n",
    "\"\"\"\n",
    "rates_fd = open('./hoge.csv', 'r')\n",
    "exchange_dates = []\n",
    "exchange_rates = []\n",
    "for line in rates_fd:\n",
    "    splited = line.split(\",\")\n",
    "    if splited[2] != \"High\" and splited[0] != \"<DTYYYYMMDD>\"and splited[0] != \"204/04/26\" and splited[0] != \"20004/04/26\":\n",
    "        time = splited[0].replace(\"/\", \"-\") + \" \" + splited[1]\n",
    "        val = float(splited[2])\n",
    "        exchange_dates.append(time)\n",
    "        exchange_rates.append(val)\n",
    "\n",
    "reverse_exchange_rates = []\n",
    "prev_org = -1\n",
    "prev = -1\n",
    "for rate in exchange_rates:\n",
    "    if prev_org != -1:\n",
    "        diff = rate - prev_org\n",
    "        reverse_exchange_rates.append(prev - diff)\n",
    "        prev_org = rate\n",
    "        prev = prev - diff\n",
    "    else:\n",
    "        reverse_exchange_rates.append(rate)\n",
    "        prev_org = rate\n",
    "        prev = rate\n",
    "\n",
    "data_len = len(exchange_rates)\n",
    "train_len = len(exchange_rates)/TRAINDATA_DIV\n",
    "\n",
    "print \"data size: \" + str(data_len)\n",
    "print \"train len: \" + str(train_len)\n",
    "\n",
    "if False:\n",
    "    dump_fd = open(\"./keras.dump\", \"r\")\n",
    "    bst = pickle.load(dump_fd)\n",
    "\n",
    "if True: ### training start\n",
    "    tr_input_mat = []\n",
    "    tr_angle_mat = []\n",
    "    for i in xrange(1000, train_len, OUTPUT_LEN):\n",
    "        tr_input_mat.append(\n",
    "            [exchange_rates[i],\n",
    "             (exchange_rates[i] - exchange_rates[i - 1])/exchange_rates[i - 1],\n",
    "#             (exchange_rates[i] - exchange_rates[i - OUTPUT_LEN])/float(OUTPUT_LEN),             \n",
    "             get_rsi(exchange_rates, i),\n",
    "             get_ma(exchange_rates, i),\n",
    "             get_ma_kairi(exchange_rates, i),\n",
    "             get_bb_1(exchange_rates, i),\n",
    "             get_bb_2(exchange_rates, i),\n",
    "             get_ema(exchange_rates, i),\n",
    "             get_ema_rsi(exchange_rates, i),\n",
    "             get_cci(exchange_rates, i),\n",
    "             get_mo(exchange_rates, i),\n",
    "#             get_po(exchange_rates, i),\n",
    "             get_lw(exchange_rates, i),\n",
    "             get_ss(exchange_rates, i),\n",
    "             get_dmi(exchange_rates, i),\n",
    "             get_vorarity(exchange_rates, i),\n",
    "             get_macd(exchange_rates, i),\n",
    "             judge_chart_type(exchange_rates[i-CHART_TYPE_JDG_LEN:i])\n",
    "         ]\n",
    "            )\n",
    "        tr_input_mat.append(\n",
    "            [reverse_exchange_rates[i],\n",
    "             (reverse_exchange_rates[i] - reverse_exchange_rates[i - 1])/reverse_exchange_rates[i - 1],\n",
    "#             (reverse_exchange_rates[i] - reverse_exchange_rates[i - OUTPUT_LEN])/float(OUTPUT_LEN),             \n",
    "             get_rsi(reverse_exchange_rates, i),\n",
    "             get_ma(reverse_exchange_rates, i),\n",
    "             get_ma_kairi(reverse_exchange_rates, i),\n",
    "             get_bb_1(reverse_exchange_rates, i),\n",
    "             get_bb_2(reverse_exchange_rates, i),\n",
    "             get_ema(reverse_exchange_rates, i),\n",
    "             get_ema_rsi(reverse_exchange_rates, i),\n",
    "             get_cci(reverse_exchange_rates, i),\n",
    "             get_mo(reverse_exchange_rates, i),\n",
    "#             get_po(reverse_exchange_rates, i),\n",
    "             get_lw(reverse_exchange_rates, i),\n",
    "             get_ss(reverse_exchange_rates, i),\n",
    "             get_dmi(reverse_exchange_rates, i),\n",
    "             get_vorarity(reverse_exchange_rates, i),\n",
    "             get_macd(reverse_exchange_rates, i),\n",
    "             judge_chart_type(reverse_exchange_rates[i-CHART_TYPE_JDG_LEN:i])             \n",
    "         ]\n",
    "            )        \n",
    "#        print tr_input_mat\n",
    "\n",
    "        tmp = (exchange_rates[i+OUTPUT_LEN] - exchange_rates[i])/float(OUTPUT_LEN)\n",
    "        if tmp >= 0:\n",
    "            tr_angle_mat.append(1)\n",
    "        else:\n",
    "            tr_angle_mat.append(0)\n",
    "        tmp = (reverse_exchange_rates[i+OUTPUT_LEN] - reverse_exchange_rates[i])/float(OUTPUT_LEN)\n",
    "        if tmp >= 0:\n",
    "            tr_angle_mat.append(1)\n",
    "        else:\n",
    "            tr_angle_mat.append(0)\n",
    "            \n",
    "        \n",
    "    X = np.array(tr_input_mat)\n",
    "    Y = np.array(tr_angle_mat)\n",
    "\n",
    "    X, scaler = preprocess_data(X)\n",
    "    Y, encoder = preprocess_labels(Y)\n",
    "\n",
    "    np.random.seed(1337) # for reproducibility\n",
    "\n",
    "    nb_classes = Y.shape[1]\n",
    "    print(nb_classes, 'classes')\n",
    "\n",
    "    dims = X.shape[1]\n",
    "    print(dims, 'dims')\n",
    "\n",
    "    neuro_num = 50\n",
    "    \n",
    "    # setup deep NN\n",
    "    model = Sequential()\n",
    "    model.add(Dense(dims, neuro_num, init='glorot_uniform'))\n",
    "    model.add(PReLU((neuro_num,)))\n",
    "    model.add(BatchNormalization((neuro_num,)))\n",
    "    model.add(Dropout(0.5))\n",
    "\n",
    "    model.add(Dense(neuro_num, neuro_num, init='glorot_uniform'))\n",
    "    model.add(PReLU((neuro_num,)))\n",
    "    model.add(BatchNormalization((neuro_num,)))\n",
    "    model.add(Dropout(0.5))\n",
    "    \n",
    "    model.add(Dense(neuro_num, 25, init='glorot_uniform'))\n",
    "    model.add(PReLU((25,)))\n",
    "    model.add(BatchNormalization((25,)))\n",
    "    model.add(Dropout(0.5))\n",
    "    \n",
    "    model.add(Dense(25, nb_classes, init='glorot_uniform'))\n",
    "    model.add(Activation('sigmoid'))\n",
    "    \n",
    "    model.compile(loss='binary_crossentropy', optimizer=\"adam\")\n",
    "    \n",
    "    print(\"Training model...\")\n",
    "    model.fit(X, Y, nb_epoch=30000, batch_size=100, validation_split=0.15)\n",
    "\n",
    "#    dump_fd = open(\"./keras.dump\", \"w\")\n",
    "#    pickle.dump(model, dump_fd)\n",
    "### training end\n",
    "\n",
    "# trade\n",
    "portfolio = 1000000\n",
    "LONG = 1\n",
    "SHORT = 2\n",
    "NOT_HAVE = 3\n",
    "pos_kind = NOT_HAVE\n",
    "HALF_SPREAD = 0.0015\n",
    "SONKIRI_RATE = 0.05\n",
    "\n",
    "positions = 0\n",
    "\n",
    "trade_val = -1\n",
    "\n",
    "pos_cont_count = 0\n",
    "for window_s in xrange((data_len - train_len) - (OUTPUT_LEN)):\n",
    "    current_spot = train_len + window_s + OUTPUT_LEN\n",
    "    skip_flag = False\n",
    "\n",
    "    #sonkiri\n",
    "    if pos_kind != NOT_HAVE:\n",
    "        if pos_kind == LONG:\n",
    "            cur_portfo = positions * (exchange_rates[current_spot] - HALF_SPREAD)\n",
    "        elif pos_kind == SHORT:\n",
    "            cur_portfo = portfolio + (positions * trade_val - positions * (exchange_rates[current_spot] + HALF_SPREAD))\n",
    "        if (cur_portfo - portfolio)/portfolio < -1*SONKIRI_RATE:\n",
    "            portfolio = cur_portfo\n",
    "            pos_kind = NOT_HAVE\n",
    "            continue\n",
    "        \n",
    "    # chart_type = 0\n",
    "    chart_type = judge_chart_type(exchange_rates[current_spot-CHART_TYPE_JDG_LEN:current_spot])\n",
    "    if chart_type != 1 and chart_type != 2:\n",
    "        skip_flag = True\n",
    "        if pos_kind != NOT_HAVE:\n",
    "            # if liner trend keep position\n",
    "            continue\n",
    "        \n",
    "    # print \"state1 \" + str(pos_kind)    \n",
    "    if pos_kind != NOT_HAVE:\n",
    "        # print \"pos_cont_count \" + str(pos_cont_count)\n",
    "        if pos_cont_count >= (OUTPUT_LEN-1):\n",
    "            if pos_kind == LONG:\n",
    "                pos_kind = NOT_HAVE\n",
    "                portfolio = positions * (exchange_rates[current_spot] - HALF_SPREAD)\n",
    "                print exchange_dates[current_spot] + \" \" + str(portfolio)\n",
    "            elif pos_kind == SHORT:\n",
    "                pos_kind = NOT_HAVE\n",
    "                portfolio += positions * trade_val - positions * (exchange_rates[current_spot] + HALF_SPREAD)\n",
    "                print exchange_dates[current_spot] + \" \" + str(portfolio)\n",
    "            pos_cont_count = 0\n",
    "        else:\n",
    "            pos_cont_count += 1\n",
    "        continue\n",
    "\n",
    "#    print(\"hoge\")\n",
    "    # try trade in only linear chart case\n",
    "\n",
    "    # vorarity = 0\n",
    "    vorarity = get_vorarity(exchange_rates, current_spot)\n",
    "    if vorarity >= 0.07:\n",
    "        skip_flag = True\n",
    "#    print(\"vorarity: \" + str(vorarity))\n",
    "    \n",
    "    # prediction    \n",
    "    ts_input_mat = []\n",
    "    ts_input_mat.append(\n",
    "       [exchange_rates[current_spot],\n",
    "        (exchange_rates[current_spot] - exchange_rates[current_spot - 1])/exchange_rates[current_spot - 1],\n",
    "#        (exchange_rates[current_spot] - exchange_rates[current_spot - OUTPUT_LEN])/float(OUTPUT_LEN),\n",
    "        get_rsi(exchange_rates, current_spot),\n",
    "        get_ma(exchange_rates, current_spot),\n",
    "        get_ma_kairi(exchange_rates, current_spot),\n",
    "        get_bb_1(exchange_rates, current_spot),\n",
    "        get_bb_2(exchange_rates, current_spot),\n",
    "        get_ema(exchange_rates, current_spot),\n",
    "        get_ema_rsi(exchange_rates, current_spot),\n",
    "        get_cci(exchange_rates, current_spot),\n",
    "        get_mo(exchange_rates, current_spot),\n",
    "#        get_po(exchange_rates, current_spot),\n",
    "        get_lw(exchange_rates, current_spot),\n",
    "        get_ss(exchange_rates, current_spot),\n",
    "        get_dmi(exchange_rates, current_spot),\n",
    "        vorarity,\n",
    "        get_macd(exchange_rates, current_spot),\n",
    "        chart_type\n",
    "    ]        \n",
    "    )\n",
    "#    print(\"vorarity: \" + str(get_vorarity(exchange_rates, current_spot)))\n",
    "\n",
    "    ts_input_arr = np.array(ts_input_mat)\n",
    "\n",
    "    X_test = np.array(ts_input_arr)\n",
    "    X_test, _ = preprocess_data(X_test, scaler)\n",
    "    \n",
    "    proba = model.predict_proba(X_test, verbose=0)\n",
    "#    print(str(proba))\n",
    "    \n",
    "    # print \"state2 \" + str(pos_kind)\n",
    "    # print \"predicted_prob \" + str(predicted_prob)\n",
    "    # print \"skip_flag:\" + str(skip_flag)\n",
    "    if pos_kind == NOT_HAVE and skip_flag == False:\n",
    "        if proba[0][0] >= 0.9 :\n",
    "           pos_kind = LONG\n",
    "           positions = portfolio / (exchange_rates[current_spot] + HALF_SPREAD)\n",
    "           trade_val = exchange_rates[current_spot] + HALF_SPREAD\n",
    "        elif proba[0][1] >= 0.9:\n",
    "           pos_kind = SHORT\n",
    "           positions = portfolio / (exchange_rates[current_spot] - HALF_SPREAD)\n",
    "           trade_val = exchange_rates[current_spot] - HALF_SPREAD"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.7.5"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "nbTranslate": {
   "displayLangs": [
    "*"
   ],
   "hotkey": "alt-t",
   "langInMainMenu": true,
   "sourceLang": "en",
   "targetLang": "fr",
   "useGoogleTranslate": true
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}