Quant_Code/5.课程代码/4.Stock-Prediction-Models/使用文档/Stock-Prediction-Models-master/deep-learning/13.gru-seq2seq.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import warnings\n",
    "\n",
    "if not sys.warnoptions:\n",
    "    warnings.simplefilter('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from datetime import datetime\n",
    "from datetime import timedelta\n",
    "from tqdm import tqdm\n",
    "sns.set()\n",
    "tf.compat.v1.random.set_random_seed(1234)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Date</th>\n",
       "      <th>Open</th>\n",
       "      <th>High</th>\n",
       "      <th>Low</th>\n",
       "      <th>Close</th>\n",
       "      <th>Adj Close</th>\n",
       "      <th>Volume</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2016-11-02</td>\n",
       "      <td>778.200012</td>\n",
       "      <td>781.650024</td>\n",
       "      <td>763.450012</td>\n",
       "      <td>768.700012</td>\n",
       "      <td>768.700012</td>\n",
       "      <td>1872400</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2016-11-03</td>\n",
       "      <td>767.250000</td>\n",
       "      <td>769.950012</td>\n",
       "      <td>759.030029</td>\n",
       "      <td>762.130005</td>\n",
       "      <td>762.130005</td>\n",
       "      <td>1943200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2016-11-04</td>\n",
       "      <td>750.659973</td>\n",
       "      <td>770.359985</td>\n",
       "      <td>750.560974</td>\n",
       "      <td>762.020020</td>\n",
       "      <td>762.020020</td>\n",
       "      <td>2134800</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2016-11-07</td>\n",
       "      <td>774.500000</td>\n",
       "      <td>785.190002</td>\n",
       "      <td>772.549988</td>\n",
       "      <td>782.520020</td>\n",
       "      <td>782.520020</td>\n",
       "      <td>1585100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2016-11-08</td>\n",
       "      <td>783.400024</td>\n",
       "      <td>795.632996</td>\n",
       "      <td>780.190002</td>\n",
       "      <td>790.510010</td>\n",
       "      <td>790.510010</td>\n",
       "      <td>1350800</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Date        Open        High         Low       Close   Adj Close  \\\n",
       "0  2016-11-02  778.200012  781.650024  763.450012  768.700012  768.700012   \n",
       "1  2016-11-03  767.250000  769.950012  759.030029  762.130005  762.130005   \n",
       "2  2016-11-04  750.659973  770.359985  750.560974  762.020020  762.020020   \n",
       "3  2016-11-07  774.500000  785.190002  772.549988  782.520020  782.520020   \n",
       "4  2016-11-08  783.400024  795.632996  780.190002  790.510010  790.510010   \n",
       "\n",
       "    Volume  \n",
       "0  1872400  \n",
       "1  1943200  \n",
       "2  2134800  \n",
       "3  1585100  \n",
       "4  1350800  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('../dataset/GOOG-year.csv')\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.112708</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.090008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.089628</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.160459</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.188066</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          0\n",
       "0  0.112708\n",
       "1  0.090008\n",
       "2  0.089628\n",
       "3  0.160459\n",
       "4  0.188066"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "minmax = MinMaxScaler().fit(df.iloc[:, 4:5].astype('float32')) # Close index\n",
    "df_log = minmax.transform(df.iloc[:, 4:5].astype('float32')) # Close index\n",
    "df_log = pd.DataFrame(df_log)\n",
    "df_log.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Split train and test\n",
    "\n",
    "I will cut the dataset to train and test datasets,\n",
    "\n",
    "1. Train dataset derived from starting timestamp until last 30 days\n",
    "2. Test dataset derived from last 30 days until end of the dataset\n",
    "\n",
    "So we will let the model do forecasting based on last 30 days, and we will going to repeat the experiment for 10 times. You can increase it locally if you want, and tuning parameters will help you by a lot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((252, 7), (222, 1), (30, 1))"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_size = 30\n",
    "simulation_size = 10\n",
    "\n",
    "df_train = df_log.iloc[:-test_size]\n",
    "df_test = df_log.iloc[-test_size:]\n",
    "df.shape, df_train.shape, df_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model:\n",
    "    def __init__(\n",
    "        self,\n",
    "        learning_rate,\n",
    "        num_layers,\n",
    "        size,\n",
    "        size_layer,\n",
    "        output_size,\n",
    "        forget_bias = 0.1,\n",
    "    ):\n",
    "        def lstm_cell(size_layer):\n",
    "            return tf.nn.rnn_cell.GRUCell(size_layer)\n",
    "\n",
    "        rnn_cells = tf.nn.rnn_cell.MultiRNNCell(\n",
    "            [lstm_cell(size_layer) for _ in range(num_layers)],\n",
    "            state_is_tuple = False,\n",
    "        )\n",
    "        self.X = tf.placeholder(tf.float32, (None, None, size))\n",
    "        self.Y = tf.placeholder(tf.float32, (None, output_size))\n",
    "        drop = tf.contrib.rnn.DropoutWrapper(\n",
    "            rnn_cells, output_keep_prob = forget_bias\n",
    "        )\n",
    "        self.hidden_layer = tf.placeholder(\n",
    "            tf.float32, (None, num_layers * size_layer)\n",
    "        )\n",
    "        _, last_state = tf.nn.dynamic_rnn(\n",
    "            drop, self.X, initial_state = self.hidden_layer, dtype = tf.float32\n",
    "        )\n",
    "        \n",
    "        with tf.variable_scope('decoder', reuse = False):\n",
    "            rnn_cells_dec = tf.nn.rnn_cell.MultiRNNCell(\n",
    "                [lstm_cell(size_layer) for _ in range(num_layers)], state_is_tuple = False\n",
    "            )\n",
    "            drop_dec = tf.contrib.rnn.DropoutWrapper(\n",
    "                rnn_cells_dec, output_keep_prob = forget_bias\n",
    "            )\n",
    "            self.outputs, self.last_state = tf.nn.dynamic_rnn(\n",
    "                drop_dec, self.X, initial_state = last_state, dtype = tf.float32\n",
    "            )\n",
    "            \n",
    "        self.logits = tf.layers.dense(self.outputs[-1], output_size)\n",
    "        self.cost = tf.reduce_mean(tf.square(self.Y - self.logits))\n",
    "        self.optimizer = tf.train.AdamOptimizer(learning_rate).minimize(\n",
    "            self.cost\n",
    "        )\n",
    "        \n",
    "def calculate_accuracy(real, predict):\n",
    "    real = np.array(real) + 1\n",
    "    predict = np.array(predict) + 1\n",
    "    percentage = 1 - np.sqrt(np.mean(np.square((real - predict) / real)))\n",
    "    return percentage * 100\n",
    "\n",
    "def anchor(signal, weight):\n",
    "    buffer = []\n",
    "    last = signal[0]\n",
    "    for i in signal:\n",
    "        smoothed_val = last * weight + (1 - weight) * i\n",
    "        buffer.append(smoothed_val)\n",
    "        last = smoothed_val\n",
    "    return buffer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_layers = 1\n",
    "size_layer = 128\n",
    "timestamp = 5\n",
    "epoch = 300\n",
    "dropout_rate = 0.8\n",
    "future_day = test_size\n",
    "learning_rate = 0.01"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def forecast():\n",
    "    tf.reset_default_graph()\n",
    "    modelnn = Model(\n",
    "        learning_rate, num_layers, df_log.shape[1], size_layer, df_log.shape[1], dropout_rate\n",
    "    )\n",
    "    sess = tf.InteractiveSession()\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    date_ori = pd.to_datetime(df.iloc[:, 0]).tolist()\n",
    "\n",
    "    pbar = tqdm(range(epoch), desc = 'train loop')\n",
    "    for i in pbar:\n",
    "        init_value = np.zeros((1, num_layers * size_layer))\n",
    "        total_loss, total_acc = [], []\n",
    "        for k in range(0, df_train.shape[0] - 1, timestamp):\n",
    "            index = min(k + timestamp, df_train.shape[0] - 1)\n",
    "            batch_x = np.expand_dims(\n",
    "                df_train.iloc[k : index, :].values, axis = 0\n",
    "            )\n",
    "            batch_y = df_train.iloc[k + 1 : index + 1, :].values\n",
    "            logits, last_state, _, loss = sess.run(\n",
    "                [modelnn.logits, modelnn.last_state, modelnn.optimizer, modelnn.cost],\n",
    "                feed_dict = {\n",
    "                    modelnn.X: batch_x,\n",
    "                    modelnn.Y: batch_y,\n",
    "                    modelnn.hidden_layer: init_value,\n",
    "                },\n",
    "            )        \n",
    "            init_value = last_state\n",
    "            total_loss.append(loss)\n",
    "            total_acc.append(calculate_accuracy(batch_y[:, 0], logits[:, 0]))\n",
    "        pbar.set_postfix(cost = np.mean(total_loss), acc = np.mean(total_acc))\n",
    "    \n",
    "    future_day = test_size\n",
    "\n",
    "    output_predict = np.zeros((df_train.shape[0] + future_day, df_train.shape[1]))\n",
    "    output_predict[0] = df_train.iloc[0]\n",
    "    upper_b = (df_train.shape[0] // timestamp) * timestamp\n",
    "    init_value = np.zeros((1, num_layers * size_layer))\n",
    "\n",
    "    for k in range(0, (df_train.shape[0] // timestamp) * timestamp, timestamp):\n",
    "        out_logits, last_state = sess.run(\n",
    "            [modelnn.logits, modelnn.last_state],\n",
    "            feed_dict = {\n",
    "                modelnn.X: np.expand_dims(\n",
    "                    df_train.iloc[k : k + timestamp], axis = 0\n",
    "                ),\n",
    "                modelnn.hidden_layer: init_value,\n",
    "            },\n",
    "        )\n",
    "        init_value = last_state\n",
    "        output_predict[k + 1 : k + timestamp + 1] = out_logits\n",
    "\n",
    "    if upper_b != df_train.shape[0]:\n",
    "        out_logits, last_state = sess.run(\n",
    "            [modelnn.logits, modelnn.last_state],\n",
    "            feed_dict = {\n",
    "                modelnn.X: np.expand_dims(df_train.iloc[upper_b:], axis = 0),\n",
    "                modelnn.hidden_layer: init_value,\n",
    "            },\n",
    "        )\n",
    "        output_predict[upper_b + 1 : df_train.shape[0] + 1] = out_logits\n",
    "        future_day -= 1\n",
    "        date_ori.append(date_ori[-1] + timedelta(days = 1))\n",
    "\n",
    "    init_value = last_state\n",
    "    \n",
    "    for i in range(future_day):\n",
    "        o = output_predict[-future_day - timestamp + i:-future_day + i]\n",
    "        out_logits, last_state = sess.run(\n",
    "            [modelnn.logits, modelnn.last_state],\n",
    "            feed_dict = {\n",
    "                modelnn.X: np.expand_dims(o, axis = 0),\n",
    "                modelnn.hidden_layer: init_value,\n",
    "            },\n",
    "        )\n",
    "        init_value = last_state\n",
    "        output_predict[-future_day + i] = out_logits[-1]\n",
    "        date_ori.append(date_ori[-1] + timedelta(days = 1))\n",
    "    \n",
    "    output_predict = minmax.inverse_transform(output_predict)\n",
    "    deep_future = anchor(output_predict[:, 0], 0.3)\n",
    "    \n",
    "    return deep_future[-test_size:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: Logging before flag parsing goes to stderr.\n",
      "W0816 17:29:50.622041 140611410274112 deprecation.py:323] From <ipython-input-6-7a2cc302036d>:12: GRUCell.__init__ (from tensorflow.python.ops.rnn_cell_impl) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "This class is equivalent as tf.keras.layers.GRUCell, and will be replaced by that in Tensorflow 2.0.\n",
      "W0816 17:29:50.624857 140611410274112 deprecation.py:323] From <ipython-input-6-7a2cc302036d>:16: MultiRNNCell.__init__ (from tensorflow.python.ops.rnn_cell_impl) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "This class is equivalent as tf.keras.layers.StackedRNNCells, and will be replaced by that in Tensorflow 2.0.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0816 17:29:50.941864 140611410274112 lazy_loader.py:50] \n",
      "The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
      "For more information, please see:\n",
      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
      "  * https://github.com/tensorflow/addons\n",
      "  * https://github.com/tensorflow/io (for I/O related ops)\n",
      "If you depend on functionality not listed there, please file an issue.\n",
      "\n",
      "W0816 17:29:50.945153 140611410274112 deprecation.py:323] From <ipython-input-6-7a2cc302036d>:27: dynamic_rnn (from tensorflow.python.ops.rnn) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `keras.layers.RNN(cell)`, which is equivalent to this API\n",
      "W0816 17:29:51.137009 140611410274112 deprecation.py:506] From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/init_ops.py:1251: calling VarianceScaling.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
      "W0816 17:29:51.144164 140611410274112 deprecation.py:506] From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/rnn_cell_impl.py:564: calling Constant.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
      "W0816 17:29:51.155159 140611410274112 deprecation.py:506] From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/rnn_cell_impl.py:574: calling Zeros.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
      "W0816 17:29:51.387444 140611410274112 deprecation.py:323] From <ipython-input-6-7a2cc302036d>:41: dense (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use keras.layers.dense instead.\n",
      "train loop: 100%|██████████| 300/300 [01:36<00:00,  3.15it/s, acc=97.7, cost=0.00125] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:37<00:00,  3.07it/s, acc=98.1, cost=0.000968]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 3\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:34<00:00,  3.14it/s, acc=97.3, cost=0.00201] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:36<00:00,  3.12it/s, acc=97.8, cost=0.00113] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:36<00:00,  3.15it/s, acc=97.6, cost=0.00147] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 6\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:36<00:00,  3.11it/s, acc=98.2, cost=0.000856]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 7\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:35<00:00,  3.14it/s, acc=97.7, cost=0.00139] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 8\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:36<00:00,  3.11it/s, acc=97.1, cost=0.002]   \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 9\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:36<00:00,  3.13it/s, acc=97.8, cost=0.00111] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:37<00:00,  3.06it/s, acc=97.4, cost=0.00152] \n"
     ]
    }
   ],
   "source": [
    "results = []\n",
    "for i in range(simulation_size):\n",
    "    print('simulation %d'%(i + 1))\n",
    "    results.append(forecast())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "accuracies = [calculate_accuracy(df['Close'].iloc[-test_size:].values, r) for r in results]\n",
    "\n",
    "plt.figure(figsize = (15, 5))\n",
    "for no, r in enumerate(results):\n",
    "    plt.plot(r, label = 'forecast %d'%(no + 1))\n",
    "plt.plot(df['Close'].iloc[-test_size:].values, label = 'true trend', c = 'black')\n",
    "plt.legend()\n",
    "plt.title('average accuracy: %.4f'%(np.mean(accuracies)))\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
}