Finam of SBER-CNN_Coder_Decoder-Multi.ipynb

{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
  "kernelspec": {
   "name": "python3",
   "language": "python",
   "display_name": "Python 3 (ipykernel)"
  },
  "colab": {
   "name": "Finam of SBER-CNN_Coder_Decoder-Multi.ipynb",
   "provenance": [
    {
     "file_id": "1u14juAdYey4S5vL5kYmpixo9mjjqNzBJ",
     "timestamp": 1584103025516
    },
    {
     "file_id": "1E5Zc5QIeUtwzjNC4s2pOE1URZ5k3Rpr9",
     "timestamp": 1584075321729
    },
    {
     "file_id": "1NXjPSAXS501exqlzAkrUJOv1pmUH2RKs",
     "timestamp": 1582895755061
    },
    {
     "file_id": "1iOm8wU4QyvTYOXZrAPFkQu2iKd8bakXL",
     "timestamp": 1582790559148
    }
   ],
   "collapsed_sections": []
  },
  "accelerator": "GPU"
 },
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 95,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/mazeinsv/PycharmProjects/python.Neural.Market\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "ROOT_DIR = os.path.abspath(os.curdir)\n",
    "print(ROOT_DIR)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "outputs": [],
   "source": [
    "# !pip install --upgrade pip\n",
    "# !pip install pandas matplotlib statsmodels tensorflow sklearn xlwt"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "outputs": [],
   "source": [
    "# !git clone https://github.com/keras-team/keras-tuner.git\n",
    "# %cd keras-tuner\n",
    "# !pip install ."
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "outputs": [],
   "source": [
    "# !pip uninstall tensorflow-gpu\n",
    "# !pip install tensorflow-gpu"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "outputs": [],
   "source": [
    "from urllib.parse import urlencode\n",
    "from urllib.request import urlopen\n",
    "import urllib.request\n",
    "from datetime import datetime, timedelta\n",
    "import statsmodels.api as sm\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "outputs": [],
   "source": [
    "# Для работы с google диском\n",
    "# from google.colab import drive\n",
    "# drive.mount('/content/gdrive')\n",
    "# import sys\n",
    "# sys.path.append('/content/gdrive/My Drive/Python/Market/')\n",
    "# data_path = '/content/gdrive/My Drive/Python/Market/Data/'\n",
    "\n",
    "#Для работы локально на виртуальной машине\n",
    "data_path = ROOT_DIR + '/data/'\n",
    "if not os.path.exists(data_path):\n",
    "\tos.mkdir(data_path)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "today: 2021-11-20\n"
     ]
    }
   ],
   "source": [
    "#periods = {'tick': 1, '1m': 2, '5m': 3, '10m': 4, '15m': 5, '30m': 6, 'H': 7, 'D': 8, 'W': 9, 'M': 10}\n",
    "seccode = \"S&P\"\n",
    "period = \"D\"\n",
    "today = datetime.today().strftime('%Y-%m-%d')\n",
    "print(\"today: \" + today)\n",
    "path_best_model = data_path + today + '_' + seccode + '_' + period + '_' + 'best.h5'"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "zsh:1: command not found: nvidia-smi\n"
     ]
    }
   ],
   "source": [
    "gpu_info = !nvidia-smi\n",
    "gpu_info = '\\n'.join(gpu_info)\n",
    "if gpu_info.find('failed') >= 0:\n",
    "  print('Select the Runtime → \"Change runtime type\" menu to enable a GPU accelerator, ')\n",
    "  print('and then re-execute this cell.')\n",
    "else:\n",
    "  print(gpu_info)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "outputs": [],
   "source": [
    "# ============================= Мoдуль извлечения котировок с сайта www.finam.ru ===================\n",
    "\n",
    "FINAM_URL = \"http://export.finam.ru/\"  # сервер, на который стучимся\n",
    "# каждому таймфрейму на Финаме соответствует цифровой код:\n",
    "# periods = {'tick': 1, 'min': 2, '5min': 3, '10min': 4, '15min': 5, '30min': 6, 'hour': 7, 'daily': 8, 'week': 9, 'month': 10}\n",
    "periods = {'tick': 1, '1m': 2, '5m': 3, '10m': 4, '15m': 5, '30m': 6, 'H': 7, 'D': 8, 'W': 9, 'M': 10}\n",
    "# каждому символу Финам присвоил цифровой код:\n",
    "symbols = {'S&P': 13944, 'USDRUB': 901, 'ED':83, 'GD':18953, 'MICEX': 420450, 'BZ': 19473, 'ABRD':82460,'AESL':181867,'AFKS':19715,'AFLT':29,'AGRO':399716,'AKRN':17564,'ALBK':82616,'ALNU':81882,'ALRS':81820,'AMEZ':20702,'APTK':13855,'AQUA':35238,'ARMD':19676,'ARSA':19915,'ASSB':16452,'AVAN':82843,'AVAZ':39,'AVAZP':40,'BANE':81757,'BANEP':81758,'BGDE':175840,'BISV':35242,'BISVP':35243,'BLNG':21078,'BRZL':81901,'BSPB':20066,'CBOM':420694,'CHEP':20999,'CHGZ':81933,'CHKZ':21000,'CHMF':16136,'CHMK':21001,'CHZN':19960,'CLSB':16712,'CLSBP':16713,'CNTL':21002,'CNTLP':81575,'DASB':16825,'DGBZ':17919,'DIOD':35363,'DIXY':18564,'DVEC':19724,'DZRD':74744,'DZRDP':74745,'ELTZ':81934,'ENRU':16440,'EPLN':451471,'ERCO':81935,'FEES':20509,'FESH':20708,'FORTP':82164,'GAZA':81997,'GAZAP':81998,'GAZC':81398,'GAZP':16842,'GAZS':81399,'GAZT':82115,'GCHE':20125,'GMKN':795,'GRAZ':16610,'GRNT':449114,'GTLC':152876,'GTPR':175842,'GTSS':436120,'HALS':17698,'HIMC':81939,'HIMCP':81940,'HYDR':20266,'IDJT':388276,'IDVP':409486,'IGST':81885,'IGST03':81886,'IGSTP':81887,'IRAO':20516,'IRGZ':9,'IRKT':15547,'ISKJ':17137,'JNOS':15722,'JNOSP':15723,'KAZT':81941,'KAZTP':81942,'KBSB':19916,'KBTK':35285,'KCHE':20030,'KCHEP':20498,'KGKC':83261,'KGKCP':152350,'KLSB':16329,'KMAZ':15544,'KMEZ':22525,'KMTZ':81903,'KOGK':20710,'KRKN':81891,'KRKNP':81892,'KRKO':81905,'KRKOP':81906,'KROT':510,'KROTP':511,'KRSB':20912,'KRSBP':20913,'KRSG':15518,'KSGR':75094,'KTSB':16284,'KTSBP':16285,'KUBE':522,'KUNF':81943,'KUZB':83165,'KZMS':17359,'KZOS':81856,'KZOSP':81857,'LIFE':74584,'LKOH':8,'LNTA':385792,'LNZL':21004,'LNZLP':22094,'LPSB':16276,'LSNG':31,'LSNGP':542,'LSRG':19736,'LVHK':152517,'MAGE':74562,'MAGEP':74563,'MAGN':16782,'MERF':20947,'MFGS':30,'MFGSP':51,'MFON':152516,'MGNT':17086,'MGNZ':20892,'MGTS':12984,'MGTSP':12983,'MGVM':81829,'MISB':16330,'MISBP':16331,'MNFD':80390,'MOBB':82890,'MOEX':152798,'MORI':81944,'MOTZ':21116,'MRKC':20235,'MRKK':20412,'MRKP':20107,'MRKS':20346,'MRKU':20402,'MRKV':20286,'MRKY':20681,'MRKZ':20309,'MRSB':16359,'MSNG':6,'MSRS':16917,'MSST':152676,'MSTT':74549,'MTLR':21018,'MTLRP':80745,'MTSS':15523,'MUGS':81945,'MUGSP':81946,'MVID':19737,'NAUK':81992,'NFAZ':81287,'NKHP':450432,'NKNC':20100,'NKNCP':20101,'NKSH':81947,'NLMK':17046,'NMTP':19629,'NNSB':16615,'NNSBP':16616,'NPOF':81858,'NSVZ':81929,'NVTK':17370,'ODVA':20737,'OFCB':80728,'OGKB':18684,'OMSH':22891,'OMZZP':15844,'OPIN':20711,'OSMP':21006,'OTCP':407627,'PAZA':81896,'PHOR':81114,'PHST':19717,'PIKK':18654,'PLSM':81241,'PLZL':17123,'PMSB':16908,'PMSBP':16909,'POLY':175924,'PRFN':83121,'PRIM':17850,'PRIN':22806,'PRMB':80818,'PRTK':35247,'PSBR':152320,'QIWI':181610,'RASP':17713,'RBCM':74779,'RDRB':181755,'RGSS':181934,'RKKE':20321,'RLMN':152677,'RLMNP':388313,'RNAV':66644,'RODNP':66693,'ROLO':181316,'ROSB':16866,'ROSN':17273,'ROST':20637,'RSTI':20971,'RSTIP':20972,'RTGZ':152397,'RTKM':7,'RTKMP':15,'RTSB':16783,'RTSBP':16784,'RUAL':414279,'RUALR':74718,'RUGR':66893,'RUSI':81786,'RUSP':20712,'RZSB':16455,'SAGO':445,'SAGOP':70,'SARE':11,'SAREP':24,'SBER':3,'SBERP':23,'SELG':81360,'SELGP':82610,'SELL':21166,'SIBG':436091,'SIBN':2,'SKYC':83122,'SNGS':4,'SNGSP':13,'STSB':20087,'STSBP':20088,'SVAV':16080,'SYNG':19651,'SZPR':22401,'TAER':80593,'TANL':81914,'TANLP':81915,'TASB':16265,'TASBP':16266,'TATN':825,'TATNP':826,'TGKA':18382,'TGKB':17597,'TGKBP':18189,'TGKD':18310,'TGKDP':18391,'TGKN':18176,'TGKO':81899,'TNSE':420644,'TORS':16797,'TORSP':16798,'TRCN':74561,'TRMK':18441,'TRNFP':1012,'TTLK':18371,'TUCH':74746,'TUZA':20716,'UCSS':175781,'UKUZ':20717,'UNAC':22843,'UNKL':82493,'UPRO':18584,'URFD':75124,'URKA':19623,'URKZ':82611,'USBN':81953,'UTAR':15522,'UTII':81040,'UTSY':419504,'UWGN':414560,'VDSB':16352,'VGSB':16456,'VGSBP':16457,'VJGZ':81954,'VJGZP':81955,'VLHZ':17257,'VRAO':20958,'VRAOP':20959,'VRSB':16546,'VRSBP':16547,'VSMO':15965,'VSYD':83251,'VSYDP':83252,'VTBR':19043,'VTGK':19632,'VTRS':82886,'VZRZ':17068,'VZRZP':17067,'WTCM':19095,'WTCMP':19096,'YAKG':81917,'YKEN':81766,'YKENP':81769,'YNDX':388383,'YRSB':16342,'YRSBP':16343,'ZHIV':181674,'ZILL':81918,'ZMZN':556,'ZMZNP':603,'ZVEZ':82001}\n",
    "\n",
    "# Функция запрашивает котировки с сервера экспорта данных Финама по инструменту для заданного таймфрейма за последние\n",
    "# period_days дней и возвращает соответствующий датафрейм\n",
    "def GetCandles (ticker, time_frame, start_d):\n",
    "    period=periods[time_frame] # Выбор из: 'tick': 1, 'min': 2, '5min': 3, '10min': 4, '15min': 5, '30min': 6, 'hour': 7, 'daily': 8, 'week': 9, 'month': 10\n",
    "    market = 0  # можно не задавать. Это рынок, на котором торгуется бумага. Для акций работает с любой цифрой. Другие рынки не проверял.\n",
    "    # Текущий момент времени\n",
    "    end_date = datetime.today()\n",
    "    print(\"end_date \" + str(end_date))\n",
    "    # Время period_days дней назад\n",
    "    start_date = ToDate(start_d) #end_date - timedelta(days = period_days)\n",
    "    # Все параметры упаковываем в единую структуру. Здесь есть дополнительные параметры, кроме тех, которые заданы в шапке. См. комментарии внизу:\n",
    "    params = urlencode([\n",
    "     ('market', market), # на каком рынке торгуется бумага\n",
    "     ('em', symbols[ticker]), # вытягиваем цифровой символ, который соответствует бумаге.\n",
    "     ('code', ticker), # тикер нашей акции\n",
    "     ('df', start_date.day), # Начальная дата, номер дня (1-31)\n",
    "     ('mf', start_date.month - 1), # Начальная дата, номер месяца (0-11)\n",
    "     ('yf', start_date.year), # Начальная дата, год\n",
    "     ('from', start_date), # Начальная дата полностью\n",
    "     ('dt', end_date.day), # Конечная дата, номер дня\n",
    "     ('mt', end_date.month - 1), # Конечная дата, номер месяца\n",
    "     ('yt', end_date.year), # Конечная дата, год\n",
    "     ('to', end_date), # Конечная дата\n",
    "     ('p', period), # Таймфрейм\n",
    "     ('f', ticker), # Имя сформированного файла\n",
    "     ('e', \".csv\"), # Расширение сформированного файла\n",
    "     ('cn', ticker), # ещё раз тикер акции\n",
    "     ('dtf', 1), # В каком формате брать даты. Выбор из 5 возможных. См. страницу https://www.finam.ru/profile/moex-akcii/sberbank/export/\n",
    "     ('MSOR', 0), # Время свечи (0 - open; 1 - close)\n",
    "     ('mstime', \"on\"), # Московское время\n",
    "     ('mstimever', 1), # Коррекция часового пояса\n",
    "     ('sep', 1), # Разделитель полей (1 - запятая, 2 - точка, 3 - точка с запятой, 4 - табуляция, 5 - пробел)\n",
    "     ('sep2', 1), # Разделитель разрядов\n",
    "     ('datf', 1), # Формат записи в файл. Выбор из 6 возможных.\n",
    "     ('at', 1)]) # Нужны ли заголовки столбцов\n",
    "    url = FINAM_URL + ticker + \".csv?\" + params # собственно URL сформированного запроса\n",
    "    # Создаем датафрейм candles с котировками\n",
    "    print(url)\n",
    "    # candles = pd.read_csv(url)\n",
    "\n",
    "    req = urllib.request.Request(url, data=None, headers={\n",
    "        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.47 Safari/537.36'})\n",
    "\n",
    "    candles = pd.read_csv(urllib.request.urlopen(req))\n",
    "    # candles.to_csv(\"Data/\" + ticker + \".csv\")\n",
    "\n",
    "    # Добавляем в датафрейм столбец 'DT', который будет содержать время каждой свечи в формате datetime.\n",
    "    # Формируем его из столбцов '<DATE>'и '<TIME>', их в последствие можете удалить\n",
    "    candles['DT'] = list(map(lambda d, t: ToDatetime(d, t), candles['<DATE>'], candles['<TIME>']))\n",
    "    # Возвращает Датафрейм Пандас со свечами, соответствующими запросу\n",
    "    return candles\n",
    "\n",
    "\n",
    "# Преобразует число (или строку) вида 20201030 и строку вида '12:15:00' в объект datetime.datetime(2020, 10, 30, 12, 15)\n",
    "def ToDatetime (date_num, time_hhmmss):\n",
    "    return datetime.strptime(str(date_num) + time_hhmmss, '%Y%m%d%H:%M:%S')\n",
    "\n",
    "\n",
    "# Преобразует строку (или число) вида \"20201102\" в дату (формат datetime)\n",
    "def ToDate (date_yyyymmdd):\n",
    "    return datetime.strptime(str(date_yyyymmdd), '%Y%m%d').date()\n",
    "\n",
    "# вызов micex=GetCandles ('MICEX', «15min», \"20000101\") вернет в переменную micex датафрейм, содержащий 15-ти\n",
    "# минутные свечи индекса ММВБ с начала даты \"20000101\" до текущего момента времени.\n",
    "# candles = GetCandles (\"SBER\", \"daily\", \"20000101\")\n",
    "#\n",
    "# print(candles.tail)\n",
    "# candles.to_csv(\"SBER.csv\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.7.0\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
    "import warnings\n",
    "warnings.simplefilter('ignore')\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# univariate multi-step encoder-decoder cnn-lstm\n",
    "from math import sqrt\n",
    "from numpy import split\n",
    "from numpy import array\n",
    "from pandas import read_csv\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from matplotlib import pyplot\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense, Flatten, LSTM,RepeatVector,TimeDistributed\n",
    "from tensorflow.keras.layers import Conv1D,MaxPooling1D\n",
    "from tensorflow import keras\n",
    "\n",
    "import tensorflow as tf\n",
    "print(tf.__version__)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "outputs": [],
   "source": [
    "def parser(x):\n",
    "\treturn datetime.strptime(x, '%d.%m.%Y')\n",
    " \n",
    "\n",
    "def split_dataset(data):\n",
    "\tprint(\"data len {}\".format(len(data)))\n",
    "\tshift = len(data) - step_forecast*(len(data)//step_forecast)\n",
    "\tprint(\"start row {}\".format(shift))\n",
    "\n",
    "\ttrain = data[(shift):(-(rows_to_test)-step_forecast)]\n",
    "\tstd_train = data[(shift):(-(rows_to_test)-step_forecast)]\n",
    "\ttest = data[(-(rows_to_test)-step_forecast):-step_forecast]\n",
    "\tall_history = data[(shift):]\n",
    "\tstd_history = data[(shift):]\n",
    "\n",
    "\t# train = array(split(train, len(train)/step_forecast))\n",
    "\t# std_train = array(split(std_train, len(std_train)/step_forecast))\n",
    "\t# test = array(split(test, len(test)/step_forecast))\n",
    "\t# all_history = array(split(all_history,len(all_history)/step_forecast))\n",
    "\t# std_history = array(split(std_history,len(std_history)/step_forecast))\n",
    " \n",
    "\treturn std_train, train, test , std_history , all_history\n",
    "\n",
    "\n",
    "# evaluate one or more weekly forecasts against expected values\n",
    "def evaluate_forecasts(actual, predicted):\n",
    "\tscores = list()\n",
    "\tlist_actual = list()\n",
    "\t# calculate an RMSE score for each day\n",
    "\tfor i in range(actual.shape[1]):\n",
    "\t\t# calculate mse\n",
    "\t\tmse = mean_squared_error(actual[:, i], predicted[:, i])\n",
    "\t\t# calculate rmse\n",
    "\t\trmse = sqrt(mse)\n",
    "\t\t# store\n",
    "\t\tscores.append(rmse)\n",
    "\n",
    "\t\tlist_predict = predicted[:, i]  # [round(x) for x in predicted[:, i]]\n",
    "\t\t# print(\"Текущее:{}  Прогнозное:{} rmse:{}\".format(actual[:, i], list_predict, round(rmse)))\n",
    "\t# calculate overall RMSE\n",
    "\ts = 0\n",
    "\tfor row in range(actual.shape[0]):\n",
    "\t\tfor col in range(actual.shape[1]):\n",
    "\t\t\ts += (actual[row, col] - predicted[row, col])**2\n",
    "\tscore = sqrt(s / (actual.shape[0] * actual.shape[1]))\n",
    "\treturn score, scores\n",
    "\n",
    "# summarize scores\n",
    "def summarize_scores(name, score, scores):\n",
    "\ts_scores = ', '.join(['%.1f' % s for s in scores])\n",
    "\tprint('%s: [%.3f] %s' % (name, score, s_scores))\n",
    "\n",
    "# convert history into inputs and outputs\n",
    "def to_supervised_x(train_1, n_input, n_out):\n",
    "\t# flatten data\n",
    "\tdata = train_1.reshape((train_1.shape[0]*train_1.shape[1], train_1.shape[2]))\n",
    "\tX, y = list(), list()\n",
    "\tin_start = 0\n",
    "\t# step over the entire history one time step at a time\n",
    "\tfor _ in range(len(data)):\n",
    "\t\t# define the end of the input sequence\n",
    "\t\tin_end = in_start + n_input\n",
    "\t\tout_end = in_end + n_out\n",
    "\t\t# ensure we have enough data for this instance\n",
    "\t\tif out_end <= len(data):\n",
    "\t\t\tX.append(data[in_start:in_end, :])\n",
    "\t\t\ty.append(data[in_end:out_end, 0])\n",
    "\t\t# move along one time step\n",
    "\t\tin_start += 1\n",
    "\treturn array(X)\n",
    "def to_supervised_y(train_2, n_input, n_out):\n",
    "\t# flatten data\n",
    "\tdata = train_2.reshape((train_2.shape[0]*train_2.shape[1], train_2.shape[2]))\n",
    "\tX, y = list(), list()\n",
    "\tin_start = 0\n",
    "\t# step over the entire history one time step at a time\n",
    "\tfor _ in range(len(data)):\n",
    "\t\t# define the end of the input sequence\n",
    "\t\tin_end = in_start + n_input\n",
    "\t\tout_end = in_end + n_out\n",
    "\t\t# ensure we have enough data for this instance\n",
    "\t\tif out_end <= len(data):\n",
    "\t\t\tX.append(data[in_start:in_end, :])\n",
    "\t\t\ty.append(data[in_end:out_end, 0])\n",
    "\t\t# move along one time step\n",
    "\t\tin_start += 1\n",
    "\treturn array(y)\n",
    "\n",
    "# train the model\n",
    "def build_model(train_x,train_y, train, n_input):\n",
    "\t# prepare data\n",
    "\t# train_x, train_y = to_supervised(train, n_input, step_forecast)\n",
    "\n",
    "\t# train_y = to_supervised_y(train, n_input, step_forecast)\n",
    "\t# train_x = to_supervised_x(std_train, n_input, step_forecast)\n",
    "\n",
    "\t# print('train_x')\n",
    "\t# print(train_x)\n",
    "\n",
    "\t# print('train_y')\n",
    "\t# print(train_y)\n",
    "\n",
    "\t# define parameters\n",
    "\n",
    "\tn_timesteps, n_features, n_outputs = train_x.shape[1], train_x.shape[2], train_y.shape[1]\n",
    "\t# reshape output into [samples, timesteps, features]\n",
    "\ttrain_y = train_y.reshape((train_y.shape[0], train_y.shape[1], 1))\n",
    "\t# define model\n",
    "\tmodel = Sequential()\n",
    "\tmodel.add(Conv1D(filters=128, kernel_size=3, activation='elu', input_shape=(n_timesteps,n_features)))\n",
    "\tmodel.add(Conv1D(filters=64, kernel_size=3, activation='elu'))\n",
    "\tmodel.add(MaxPooling1D(pool_size=2))\n",
    "\tmodel.add(Flatten())\n",
    "\tmodel.add(RepeatVector(n_outputs))\n",
    "\tmodel.add(LSTM(1024, activation='elu', return_sequences=True))\n",
    "\tmodel.add(TimeDistributed(Dense(544, activation='elu')))\n",
    "\tmodel.add(TimeDistributed(Dense(544, activation='elu')))\n",
    "\tmodel.add(TimeDistributed(Dense(544, activation='elu')))\n",
    "\tmodel.add(TimeDistributed(Dense(1)))\n",
    "\tmodel.compile(loss='mse', optimizer='adam')\n",
    "\t# fit network\n",
    "\n",
    "\t\n",
    "\treturn model\n",
    "\n",
    "# make a forecast\n",
    "def forecast(model, history, n_input):\n",
    "\t# flatten data\n",
    "\tdata = array(history)\n",
    "\tdata = data.reshape((data.shape[0]*data.shape[1], data.shape[2]))\n",
    "\t# retrieve last observations for input data\n",
    "\tinput_x = data[-n_input:, :]\n",
    "\tinput_x = input_x.reshape((1, input_x.shape[0], input_x.shape[1]))\n",
    "\t# forecast the next week\n",
    "\tyhat = model.predict(input_x, verbose=0)\n",
    "\t# we only want the vector forecast\n",
    "\tyhat = yhat[0]\n",
    "\n",
    "\tinput_x = input_x[0]\n",
    "\t# yhat_list = [round(x) for x in yhat]\n",
    "\t# print(\"Вход (input_x):{} Прогноз (yhat):{}\".format(input_x[0], yhat))\n",
    "\n",
    "\treturn yhat\n",
    "\n",
    "# evaluate a single model\n",
    "def evaluate_model(train, test, n_input):\n",
    "\t# fit model\n",
    "\tmodel = build_model(train, n_input)\n",
    "\t# history is a list of weekly data\n",
    "\thistory = [x for x in train]\n",
    "\t# walk-forward validation over each week\n",
    "\tpredictions = list()\n",
    "\tfor i in range(len(test)):\n",
    "\t\t# predict the week\n",
    "\t\tyhat_sequence = forecast(model, history, n_input)\n",
    "\t\t# store the predictions\n",
    "\t\tpredictions.append(yhat_sequence)\n",
    "\t\t# get real observation and add to history for predicting the next week\n",
    "\t\thistory.append(test[i, :])\n",
    "\t# evaluate predictions days for each week\n",
    "\tpredictions = array(predictions)\n",
    "\tscore, scores = evaluate_forecasts(test[:, :, 0], predictions)\n",
    "\treturn score, scores, model\n",
    "\n",
    "# create a differenced series\n",
    "def difference(dataset, interval=1):\n",
    "\tdiff = list()\n",
    "\tfor i in range(interval, len(dataset)):\n",
    "\t\tvalue = dataset[i] - dataset[i - interval]\n",
    "\t\tdiff.append(value)\n",
    "\treturn diff\n",
    "\n",
    "# invert differenced forecast\n",
    "def inverse_difference(last_ob, value):\n",
    "\treturn value + last_ob\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "end_date 2021-11-20 18:20:54.180093\n",
      "http://export.finam.ru/S&P.csv?market=0&em=13944&code=S%26P&df=1&mf=0&yf=2000&from=2000-01-01&dt=20&mt=10&yt=2021&to=2021-11-20+18%3A20%3A54.180093&p=8&f=S%26P&e=.csv&cn=S%26P&dtf=1&MSOR=0&mstime=on&mstimever=1&sep=1&sep2=1&datf=1&at=1\n"
     ]
    }
   ],
   "source": [
    "def parser_finam(x):\n",
    "\treturn datetime.strptime(x, '%Y%m%d')\n",
    " \n",
    " # dataset = read_csv(data_path + 'Finam/' + 'SBER.txt', header=0, parse_dates=[0], index_col=0, squeeze=True, date_parser=parser,sep=\";\", decimal=',')\n",
    "# dataset = read_csv(data_path + 'Finam/' + 'SBER.txt', header=0, parse_dates=[2],  squeeze=True, date_parser=parser_finam,sep=\";\", decimal='.')\n",
    "\n",
    "dataset = GetCandles (seccode, period, \"20000101\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     <TICKER> <PER>    <DATE>    <TIME>   <OPEN>   <HIGH>    <LOW>  <CLOSE>  \\\n",
      "5929      S&P     D  20211115  00:00:00  4681.50  4697.50  4667.00  4676.75   \n",
      "5930      S&P     D  20211116  00:00:00  4676.75  4709.75  4670.75  4693.50   \n",
      "5931      S&P     D  20211117  00:00:00  4693.75  4701.00  4679.25  4691.50   \n",
      "5932      S&P     D  20211118  00:00:00  4691.75  4722.00  4668.00  4717.75   \n",
      "5933      S&P     D  20211119  00:00:00  4717.75  4723.50  4684.25  4697.75   \n",
      "\n",
      "        <VOL>         DT  \n",
      "5929  1003360 2021-11-15  \n",
      "5930   986375 2021-11-16  \n",
      "5931  1019370 2021-11-17  \n",
      "5932  1147513 2021-11-18  \n",
      "5933  1221166 2021-11-19  \n"
     ]
    }
   ],
   "source": [
    "print(dataset.tail())"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            CLOSE\n",
      "DATE             \n",
      "20030505   925.00\n",
      "20030506   934.00\n",
      "20030507   928.50\n",
      "20030508   919.25\n",
      "20030509   932.75\n",
      "...           ...\n",
      "20211115  4676.75\n",
      "20211116  4693.50\n",
      "20211117  4691.50\n",
      "20211118  4717.75\n",
      "20211119  4697.75\n",
      "\n",
      "[5934 rows x 1 columns]\n"
     ]
    }
   ],
   "source": [
    "dataset = dataset.drop(['<TICKER>','<PER>','<TIME>','<VOL>'], 1)\n",
    "dataset.rename(columns={'<DATE>':'DATE','<OPEN>':'OPEN', '<HIGH>':'HIGH', '<LOW>':'LOW', '<CLOSE>':'CLOSE'}, inplace=True)\n",
    "dataset = dataset[['DATE','CLOSE']]\n",
    "dataset.set_index('DATE', inplace=True)\n",
    "# dataset = dataset[['CLOSE']]\n",
    "\n",
    "if seccode == \"SBER\":\n",
    "\tdataset.loc[:'2007-07-17'] /=1000 # Делим на 1000 все цены до указанного периода. По сберу была переоценка в лотах \n",
    "\n",
    "\n",
    "# dataset.loc['2007-07-16':'2007-07-20'].values.tolist()\n",
    "\n",
    "print(dataset)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           CLOSE\n",
      "DATE            \n",
      "20030505  925.00\n",
      "20030506  934.00\n",
      "20030507  928.50\n",
      "20030508  919.25\n",
      "20030509  932.75\n"
     ]
    }
   ],
   "source": [
    "if seccode == \"SBER\":\n",
    "  dataset = dataset.loc['2004-01-01':]\n",
    "print(dataset.head())"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          CLOSE\n",
      "DATE           \n",
      "20030506   9.00\n",
      "20030507  -5.50\n",
      "20030508  -9.25\n",
      "20030509  13.50\n",
      "20030510  -0.25\n",
      "...         ...\n",
      "20211115  -4.75\n",
      "20211116  16.75\n",
      "20211117  -2.00\n",
      "20211118  26.25\n",
      "20211119 -20.00\n",
      "\n",
      "[5933 rows x 1 columns]\n"
     ]
    }
   ],
   "source": [
    "data1diff = dataset.diff(periods=1).dropna()\n",
    "print(data1diff)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "В коде выше функция diff() вычисляет разность исходного ряда с рядом с заданным смещением периода. Период смещения передается как параметр period. Т.к. в разности первое значение получиться неопределенным, то нам надо избавиться от него для этого и используется метод dropna().\n",
    "Проверим получившийся ряд на стационарность:"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "adf:  -14.288599243372492\n",
      "p-value:  1.2871099137174363e-26\n",
      "Critical values:  {'1%': -3.4314588385367197, '5%': -2.8620300031826043, '10%': -2.5670308264579145}\n",
      "единичных корней нет, ряд стационарен\n"
     ]
    }
   ],
   "source": [
    "# https://habr.com/ru/post/207160/\n",
    "test = sm.tsa.adfuller(data1diff['CLOSE'])\n",
    "# test = sm.tsa.adfuller(dataset['CLOSE'])\n",
    "print('adf: ', test[0])\n",
    "print('p-value: ', test[1])\n",
    "print('Critical values: ', test[4])\n",
    "if test[0]> test[4]['5%']: \n",
    "    print('есть единичные корни, ряд не стационарен')\n",
    "else:\n",
    "    print('единичных корней нет, ряд стационарен')"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            CLOSE\n",
      "DATE             \n",
      "20030505   925.00\n",
      "20030506   934.00\n",
      "20030507   928.50\n",
      "20030508   919.25\n",
      "20030509   932.75\n",
      "...           ...\n",
      "20211115  4676.75\n",
      "20211116  4693.50\n",
      "20211117  4691.50\n",
      "20211118  4717.75\n",
      "20211119  4697.75\n",
      "\n",
      "[5934 rows x 1 columns]\n"
     ]
    }
   ],
   "source": [
    "print(dataset)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rows_to_test 12\n",
      "data len 5934\n",
      "start row 0\n"
     ]
    }
   ],
   "source": [
    "step_forecast =1\n",
    "n_input = 6 # пакет прошлых данных, назад для прогноза, т.е. 6 все входные данне за прошлый период, что бы получить прогноз\n",
    "rows_to_test = 12 # количесвтов месяцев для теста модели, кратно шагам прогноза (step_forecast), смотри след строку\n",
    "rows_to_test = rows_to_test//step_forecast*step_forecast\n",
    "print(\"rows_to_test\",rows_to_test)\n",
    "\n",
    "# split into train and test\n",
    "std_train , train, test, std_history ,all_history = split_dataset(dataset.values)\n",
    "# std_train , train, test, std_history ,all_history = split_dataset(data1diff.values)\n",
    "# evaluate model and get scores\n",
    "\n",
    "# print(all_history[-1:])\n",
    "\n",
    "# Стандартизация \n",
    "# std_train = train\n",
    "# mean = std_train.mean(axis=0) # Среднее значение\n",
    "# std = std_train.std(axis=0) # Стандартное отклонение\n",
    "\n",
    "# std_train -= mean\n",
    "# std_train /= std\n",
    "\n",
    "# std_history -= mean\n",
    "# std_history /= std\n",
    "\n",
    "# Стандартизация через sklearn \n",
    "# from sklearn.preprocessing import StandardScaler\n",
    "# x_scaler = StandardScaler().fit(std_train)\n",
    "# std_train = x_scaler.transform(std_train)\n",
    "# x_scaler = StandardScaler().fit(std_history)\n",
    "# std_history = x_scaler.transform(std_history)\n",
    "\n",
    "# from sklearn.preprocessing import MinMaxScaler\n",
    "# x_scaler = MinMaxScaler(feature_range=(0, 1))\n",
    "# x_scaler = MinMaxScaler(feature_range=(-1, 1))\n",
    "# std_train = x_scaler.fit_transform(std_train)\n",
    "# std_history = x_scaler.fit_transform(std_history)\n",
    "# train = x_scaler.fit_transform(std_train)\n",
    "# history = x_scaler.fit_transform(std_history)\n",
    "\n",
    "# std_train = x_scaler.inverse_transform(std_train)\n",
    "\n",
    "\n",
    "# Normalize data (length of 1)\n",
    "# from sklearn.preprocessing import Normalizer\n",
    "# x_scaler = Normalizer().fit(std_train)\n",
    "# std_train = x_scaler.transform(std_train)\n",
    "# # x_scaler = Normalizer().fit(std_history)\n",
    "# std_history = x_scaler.transform(std_history)\n",
    "\n",
    "\n",
    "train = array(split(train, len(train)/step_forecast))\n",
    "std_train = array(split(std_train, len(std_train)/step_forecast))\n",
    "test = array(split(test, len(test)/step_forecast))\n",
    "all_history = array(split(all_history,len(all_history)/step_forecast))\n",
    "std_history = array(split(std_history,len(std_history)/step_forecast))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "outputs": [],
   "source": [
    "# score, scores, model = evaluate_model(train, test, n_input)\n",
    "\n",
    "# fit model\n",
    "train_y = to_supervised_y(train, n_input, step_forecast)\n",
    "train_x = to_supervised_x(std_train, n_input, step_forecast)\n",
    "model = build_model(train_x,train_y, train, n_input)\n",
    "# print(train_x)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Модель уже просчитана, загружаем модель\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Занижаем скорость обучения при снижении качества\n",
    "reduce_ = keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=10, verbose=0, mode='auto', min_delta=0.0001, cooldown=0, min_lr=0)\n",
    "# Ранний выход при переобучении\n",
    "es = keras.callbacks.EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=50)\n",
    "# Сохраняет лучшую модель (рекомендуется переобучать новую модель на найденных гиперпараметрах)\n",
    "mc = keras.callbacks.ModelCheckpoint(path_best_model, monitor='val_loss',  mode='auto', save_best_only=True)\n",
    "# mc = keras.callbacks.ModelCheckpoint(data_path + 'best.h5', monitor='val_acc', mode='auto', save_best_only=True)\n",
    "\n",
    "# tuner.search(x_train,                  # Данные для обучения\n",
    "# \t\t\t\t\t\ty_train,                  # Правильные ответы\n",
    "# \t\t\t\t\t\tbatch_size=100,           # Размер мини-выборки\n",
    "# \t\t\t\t\t\tepochs=150,                # Количество эпох обучения \n",
    "# \t\t\t\t\t\tvalidation_split=0.2,     # Часть данных, которая будет использоваться для проверки\n",
    "# \t\t\t\t\t\tcallbacks=[reduce_,es],\n",
    "# \t\t\t\t\t\tverbose=2,\n",
    "# \t\t\t\t\t\t)\n",
    "verbose, epochs, batch_size = 1, 150, 3 # обычно ставлю 150 эпох\n",
    "# verbose, epochs, batch_size = 1, 10, 20\n",
    "if os.path.exists(path_best_model):\n",
    "\tprint(\"Модель уже просчитана, загружаем модель\")\n",
    "\tmodel = keras.models.load_model(path_best_model)\n",
    "\n",
    "else:\n",
    "\tresults = model.fit(train_x, train_y, epochs=epochs, batch_size=batch_size,\n",
    "\t\t\t\tvalidation_split=0.2,     # Часть данных, которая будет использоваться для проверки\n",
    "\t\t\t\t# validation_data=(x_test, y_test),\n",
    "\t\t\t\tcallbacks=[mc],\n",
    "\t\t\t  verbose=verbose)\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lstm: [12.884] 12.9\n",
      "       test      predict\n",
      "0   4685.75  4667.858398\n",
      "1   4683.75  4669.293945\n",
      "2   4687.25  4673.244141\n",
      "3   4663.75  4673.245117\n",
      "4   4646.50  4658.199707\n",
      "5   4650.75  4641.444824\n",
      "6   4681.00  4667.541016\n",
      "7   4681.50  4672.508789\n",
      "8   4676.75  4672.508301\n",
      "9   4693.50  4677.033203\n",
      "10  4691.50  4682.485840\n",
      "11  4717.75  4699.837891\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 864x576 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# best_model.save(model_path+'stfk_mod1_google_350dpi.h5')\n",
    "# model = keras.models.load_model(data_path + 'best.h5')\n",
    "\n",
    "history = [x for x in std_history]\n",
    "# \n",
    "predictions = list()\n",
    "std_data = array(history)\n",
    "std_data = std_data.reshape((std_data.shape[0]*std_data.shape[1], std_data.shape[2]))\n",
    "\n",
    "# rows_to_test = 36\n",
    "# Смотрим тест\n",
    "for i in range(len(test)):\n",
    "  # predict the week\n",
    "  input_x = std_data[(-n_input-len(test)+i):-len(test)+i, :]\n",
    "  input_x = input_x.reshape((1, input_x.shape[0], input_x.shape[1]))\n",
    "\n",
    "  yhat = model.predict(input_x, verbose=0)\n",
    "  # yhat = x_scaler.inverse_transform(yhat)\n",
    "\n",
    "  yhat = yhat[0]\n",
    "  # yhat_sequence = forecast_new(model, history, n_input)\n",
    "  # store the predictions\n",
    "  predictions.append(yhat)\n",
    "  # get real observation and add to history for predicting the next week\n",
    "  # history.append(test[i, :])\n",
    "# evaluate predictions days for each week\n",
    "\n",
    "# predictions = x_scaler.inverse_transform(predictions)\n",
    "predictions = array(predictions)\n",
    "score, scores = evaluate_forecasts(test[:, :, 0], predictions)\n",
    "\n",
    "# summarize scores\n",
    "summarize_scores('lstm', score, scores)\n",
    "predictions_data = predictions.reshape((predictions.shape[0], 1))\n",
    "df_pred = pd.DataFrame(data=predictions_data,columns=[\"predict\"])\n",
    "test_data = test[:, :, 0].reshape((test[:, :, 0].shape[0], 1))\n",
    "df_test = pd.DataFrame(data=test_data,columns=[\"test\"])\n",
    "df = pd.concat([df_test,df_pred],axis=1)\n",
    "print(df)\n",
    "df.to_excel(data_path + today + '_' + seccode + '_' + \"_prognoz.xls\")\n",
    "df[['test', 'predict']].plot(figsize=(12, 8))\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "outputs": [],
   "source": [
    "# Прогноз на будущее (находим последнюю известную строку)\n",
    "history_all = [x for x in all_history]\n",
    "data_all = array(history_all)\n",
    "data_all = data_all.reshape((data_all.shape[0]*data_all.shape[1], data_all.shape[2]))\n",
    "fact = data_all[-1:,0:1]"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Факт вчера[[4697.75]]; Прогноз на сегодня(yhat):[[4699.8374]]\n"
     ]
    }
   ],
   "source": [
    "input_x = std_data[(-n_input):, :]\n",
    "input_x = input_x.reshape((1, input_x.shape[0], input_x.shape[1]))\n",
    "\n",
    "yhat = model.predict(input_x, verbose=0)\n",
    "yhat = yhat[0]\n",
    "\n",
    "# print(\"Вход (input_x):{};Факт{}; Прогноз (yhat):{}\".format(input_x,fact, yhat))\n",
    "print(\"Факт вчера{}; Прогноз на сегодня(yhat):{}\".format(fact, yhat))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Факт[[4697.75]]; Прогноз (yhat):[[4699.838]]\n"
     ]
    }
   ],
   "source": [
    "input_x = std_data[(-n_input-1):-1, :]\n",
    "input_x = input_x.reshape((1, input_x.shape[0], input_x.shape[1]))\n",
    "\n",
    "yhat = model.predict(input_x, verbose=0)\n",
    "yhat = yhat[0]\n",
    "# print(\"Вход (input_x):{};Факт{}; Прогноз (yhat):{}\".format(input_x,fact, yhat))\n",
    "print(\"Факт{}; Прогноз (yhat):{}\".format(fact, yhat))\n",
    "\n",
    "# plot scores\n",
    "# days = ['sun', 'mon', 'tue', 'wed', 'thr', 'fri', 'sat']\n",
    "# pyplot.plot(days, scores, marker='o', label='lstm')\n",
    "# pyplot.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lstm: [12.884] 12.9\n",
      "       test      predict\n",
      "0   4685.75  4667.858398\n",
      "1   4683.75  4669.293945\n",
      "2   4687.25  4673.244141\n",
      "3   4663.75  4673.245117\n",
      "4   4646.50  4658.199707\n",
      "5   4650.75  4641.444824\n",
      "6   4681.00  4667.541016\n",
      "7   4681.50  4672.508789\n",
      "8   4676.75  4672.508301\n",
      "9   4693.50  4677.033203\n",
      "10  4691.50  4682.485840\n",
      "11  4717.75  4699.837891\n"
     ]
    }
   ],
   "source": [
    "# import sys\n",
    "\n",
    "# sys.exit()\n",
    "\n",
    "# best_model.save(model_path+'stfk_mod1_google_350dpi.h5')\n",
    "model = keras.models.load_model(path_best_model)\n",
    "\n",
    "history = [x for x in std_history]\n",
    "# \n",
    "predictions = list()\n",
    "std_data = array(history)\n",
    "std_data = std_data.reshape((std_data.shape[0]*std_data.shape[1], std_data.shape[2]))\n",
    "\n",
    "# rows_to_test = 36\n",
    "# Смотрим тест\n",
    "for i in range(len(test)):\n",
    "  # predict the week\n",
    "  input_x = std_data[(-n_input-len(test)+i):-len(test)+i, :]\n",
    "  input_x = input_x.reshape((1, input_x.shape[0], input_x.shape[1]))\n",
    "\n",
    "  yhat = model.predict(input_x, verbose=0)\n",
    "  # yhat = x_scaler.inverse_transform(yhat)\n",
    "\n",
    "  yhat = yhat[0]\n",
    "  # yhat_sequence = forecast_new(model, history, n_input)\n",
    "  # store the predictions\n",
    "  predictions.append(yhat)\n",
    "  # get real observation and add to history for predicting the next week\n",
    "  # history.append(test[i, :])\n",
    "# evaluate predictions days for each week\n",
    "\n",
    "# predictions = x_scaler.inverse_transform(predictions)\n",
    "predictions = array(predictions)\n",
    "score, scores = evaluate_forecasts(test[:, :, 0], predictions)\n",
    "\n",
    "# summarize scores\n",
    "summarize_scores('lstm', score, scores)\n",
    "predictions_data = predictions.reshape((predictions.shape[0], 1))\n",
    "df_pred = pd.DataFrame(data=predictions_data,columns=[\"predict\"])\n",
    "test_data = test[:, :, 0].reshape((test[:, :, 0].shape[0], 1))\n",
    "df_test = pd.DataFrame(data=test_data,columns=[\"test\"])\n",
    "df = pd.concat([df_test,df_pred],axis=1)\n",
    "print(df)\n",
    "df.to_excel(data_path + today + '_' + seccode + \"_prognoz.xls\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 864x576 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df[['test', 'predict']].plot(figsize=(12, 8))\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Факт[[4697.75]]; Прогноз (yhat):[[4699.838]]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Прогноз на будущее (последняя известная строка)\n",
    "history = [x for x in all_history]\n",
    "data = array(history)\n",
    "data = data.reshape((data.shape[0]*data.shape[1], data.shape[2]))\n",
    "fact = data[-1:,0:1]\n",
    "\n",
    "input_x = std_data[(-n_input-1):-1, :]\n",
    "input_x = input_x.reshape((1, input_x.shape[0], input_x.shape[1]))\n",
    "\n",
    "yhat = model.predict(input_x, verbose=0)\n",
    "yhat = yhat[0]\n",
    "# print(\"Вход (input_x):{};Факт{}; Прогноз (yhat):{}\".format(input_x,fact, yhat))\n",
    "print(\"Факт{}; Прогноз (yhat):{}\".format(fact, yhat))\n",
    "\n",
    "# plot scores\n",
    "# days = ['sun', 'mon', 'tue', 'wed', 'thr', 'fri', 'sat']\n",
    "# pyplot.plot(days, scores, marker='o', label='lstm')\n",
    "# pyplot.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Факт вчера[[4697.75]]; Прогноз на сегодня(yhat):[[4699.8374]]\n"
     ]
    }
   ],
   "source": [
    "input_x = std_data[(-n_input):, :]\n",
    "input_x = input_x.reshape((1, input_x.shape[0], input_x.shape[1]))\n",
    "\n",
    "yhat = model.predict(input_x, verbose=0)\n",
    "yhat = yhat[0]\n",
    "# print(\"Вход (input_x):{};Факт{}; Прогноз (yhat):{}\".format(input_x,fact, yhat))\n",
    "print(\"Факт вчера{}; Прогноз на сегодня(yhat):{}\".format(fact, yhat))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Low: Факт вчера[[189.1]]; Прогноз на сегодня(yhat):[[194.83665]]\n",
    "\n",
    "Close: Факт вчера[[192.64]]; Прогноз на сегодня(yhat):[[191.94373]]\n",
    "\n",
    "High: Факт вчера[[195.]]; Прогноз на сегодня(yhat):[[194.56512]] - весьма точно\n",
    "\n",
    "Close Без Open: Факт вчера[[192.64]]; Прогноз на сегодня(yhat):[[204.97925]] - точно если сделать (-10)\n",
    "\n",
    "High Без Open: Факт вчера[[195.]]; Прогноз на сегодня(yhat):[[197.63686]] \n",
    "lstm: [7.108] 7.1\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lstm: [57.107] 57.1\n"
     ]
    }
   ],
   "source": [
    "# best_model.save(model_path+'stfk_mod1_google_350dpi.h5')\n",
    "# model = keras.models.load_model(data_path + 'best.h5')\n",
    "\n",
    "history = [x for x in std_history]\n",
    "# \n",
    "predictions = list()\n",
    "std_data = array(history)\n",
    "std_data = std_data.reshape((std_data.shape[0]*std_data.shape[1], std_data.shape[2]))\n",
    "\n",
    "# rows_to_test = 36\n",
    "# Смотрим тест\n",
    "\n",
    "for i in range(len(train)):\n",
    "  # predict the week\n",
    "  input_x = std_data[(-n_input-len(train)+i):-len(train)+i, :]\n",
    "  input_x = input_x.reshape((1, input_x.shape[0], input_x.shape[1]))\n",
    "\n",
    "  yhat = model.predict(input_x, verbose=0)\n",
    "  # yhat = x_scaler.inverse_transform(yhat)\n",
    "\n",
    "  yhat = yhat[0]\n",
    "  # yhat_sequence = forecast_new(model, history, n_input)\n",
    "  # store the predictions\n",
    "  predictions.append(yhat)\n",
    "  # get real observation and add to history for predicting the next week\n",
    "  # history.append(test[i, :])\n",
    "# evaluate predictions days for each week\n",
    "\n",
    "# predictions = x_scaler.inverse_transform(predictions)\n",
    "predictions = array(predictions)\n",
    "score, scores = evaluate_forecasts(train[:, :, 0], predictions)\n",
    "\n",
    "# summarize scores\n",
    "summarize_scores('lstm', score, scores)\n",
    "\n",
    "predictions_data = predictions.reshape((predictions.shape[0], 1))\n",
    "df_pred = pd.DataFrame(data=predictions_data,columns=[\"predict\"])\n",
    "test_data = train[:, :, 0].reshape((train[:, :, 0].shape[0], 1))\n",
    "df_test = pd.DataFrame(data=test_data,columns=[\"test\"])\n",
    "\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 864x576 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df = pd.concat([df_test,df_pred],axis=1)\n",
    "df = df[-100:]\n",
    "df[['test', 'predict']].plot(figsize=(12, 8))\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "outputs": [],
   "source": [
    "# Рисует основной график\n",
    "def draw_candles(candles):\n",
    "    # Добавим на график несколько ЕМА-средних\n",
    "    # candles['ema100'] = pd.Series.ewm(candles['<CLOSE>'], span=100).mean()\n",
    "    # candles['ema50'] = pd.Series.ewm(candles['<CLOSE>'], span=50).mean()\n",
    "    # candles['ema20'] = pd.Series.ewm(candles['<CLOSE>'], span=20).mean()\n",
    "    plt.style.use('ggplot')  # 'seaborn-paper'\n",
    "    # Отображаем график по цене закрытия свечей и ЕМА-шки\n",
    "    fig = candles.plot(y=['test', 'predict'], figsize=(25, 16))\n",
    "    # Добавляем заголовок\n",
    "    fig.set_title('График ' + seccode)\n",
    "    # Рисуем шкалу с датами\n",
    "    PlotDatesX(fig, candles)\n",
    "\n",
    "# Определяет начальную и конечную позицию Х (по индексу свечей) для заданной даты. Пригодится при отрисовке ценовых уровней\n",
    "def DateX(date, candles):\n",
    "    # Цикл по датам в свечах, результат - список X-координат, соответствующих заданной дате\n",
    "    xpositions = [index for index, row in candles.iterrows() if row['Date'].date() == date]\n",
    "    # Возвращает список - пару начальная координата Х и конечная координата Х для заданной даты на графике\n",
    "    if xpositions == []:\n",
    "        return [len(candles) - 1, len(candles)]  # На случай если за текущую дату нет еще свечей\n",
    "    return [xpositions[0], xpositions[-1]]\n",
    "\n",
    "\n",
    "# Рисует метки дат на оси Х\n",
    "def PlotDatesX(fig, candles):\n",
    "    # Составляем список дат (только уникальные даты) из столбца DT. Они будут метками на оси Х. Сортировка по датам\n",
    "    # обязательна, т.к. при создании множества(set) даже из отсортированного списка, множество может не сохранить порядок списка\n",
    "    dates = sorted(set(map(lambda dt: datetime.date(dt), candles['Date'])))\n",
    "    # Создаем список координат Х для каждой метки (даты). Нам нужна только первая позиция - [0].\n",
    "    xlabel = [DateX(d, candles)[0] for d in dates]\n",
    "    # Рисуем ось Х, разделенную по датам\n",
    "    fig.set_xticklabels(dates)\n",
    "    fig.set_xticks(xlabel)\n",
    "    return dates, xlabel"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "outputs": [],
   "source": [
    "# print(df)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "outputs": [],
   "source": [
    "# draw_candles(df)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ]
}