[PYTHON] Aktienprognose mit TensorFlow (LSTM) ~ Aktienprognose Teil 1 ~

Einführung

Ich werde anfangen, Aktieninvestitionen zu studieren, also werde ich eine Notiz davon hinterlassen.

Prognostizieren Sie Aktienkurse mithilfe von Zielen, maschinellem Lernen und tiefem Lernen.

Bevor Sie mit dem Studium beginnen, lesen Sie zunächst die folgenden Bücher.

• Es scheint, dass die Bedingungen für die Aktienbewegung "gute Performance", "niedriger PER" und "gute Chartform" sind. Ich möchte jeden durch Schaben bringen und Vorhersagen treffen.

[Ergänzung]

Zusätzlich zu den Aktien verwende ich normalerweise die Pferderennprognose siva. Gegenseitiger Vorhersagewert: Ungefähr 86% Wiederherstellungsrate: ca. 136%

twitter Ich habe angefangen. Bitte folgen Sie mir.

Warum lagern?

Ich habe die Aktie aus den folgenden Ansichten ausgewählt.

◆ Glücksspiele wie Pferderennen
Die Rendite von 0 oder 100 ist ebenfalls groß, aber das Risiko ist groß.
　◆ FX 
Auf der anderen Seite gibt es Leute, die Geld verdienen, aber es gibt Leute, die es verlieren, also passt es nicht zu ihrem Geschlecht.
　◆ bitcoin
Da der Wert nicht ermittelt wurde, besteht die Möglichkeit eines Zusammenbruchs.
◆ Lager
Bei Aktien ist jeder profitabel.

Zunächst ein Experiment zur Aktienvorhersage

Beginnen wir das Experiment von Site, wo Sie es herunterladen und experimentieren können, bevor Sie es durch Scraping starten.

Die heruntergeladenen Daten sind die Nikkei-Durchschnittsinformationen von 2007 bis 2017. Enthält Daten zu Datums-, Open-, High-, Low- und Close-Preisen.

Die diesmal verwendeten Daten verwenden den Schlusskurs.

Denken Sie über den Ansatz nach

Für Aktien wird davon ausgegangen, dass es besser ist, RNN (Recurrent Neural Network) (* 2) anhand von Zeitreihen vorherzusagen, als die vergangene Performance statistisch zu analysieren (* 1), sodass es sich um eine Erweiterung von RNN handelt. Versuchen wir es mit LSTM (Long Short Term Memory).

• 1 Wir werden ab dem nächsten Mal versuchen, die tatsächlichen Ergebnisse vergangener Daten in der Tabelle zu lernen.
• 2 RNN ist eine Art tiefes Lernen. Im Gegensatz zu einem normalen neuronalen Netz gibt es zusätzlich zum aktuellen Eingabewert seinen vorherigen Zustand ein. Die Ein- und Ausgabe von RNN erfolgt wie in der folgenden Abbildung dargestellt. Wenn zeitlich kontinuierliche Daten x (= x_1, x_2, x_3,…, x_n) als Eingabe betrachtet werden, wird der vorherige Zustand s_t-1 zusammen mit der Eingabe von x_t eingegeben. Dieser "vorherige Zustand" enthält frühere Informationen bis zu diesem Punkt.

Schematische Darstellung von RNN (Quelle)

Wie auch immer, experimentieren Sie mit dem Programm

Zunächst habe ich dem Versuch Priorität eingeräumt und ein Programm mit Nikkei-Durchschnitt erstellt.

# -*- coding: utf-8 -*-
import numpy
import pandas
import matplotlib.pyplot as plt

from sklearn import preprocessing
from keras.models import Sequential
from keras.layers.core import Dense, Activation
from keras.layers.recurrent import LSTM

class Prediction :

  def __init__(self):
    self.length_of_sequences = 10
    self.in_out_neurons = 1
    self.hidden_neurons = 300


  def load_data(self, data, n_prev=10):
    X, Y = [], []
    for i in range(len(data) - n_prev):
      X.append(data.iloc[i:(i+n_prev)].as_matrix())
      Y.append(data.iloc[i+n_prev].as_matrix())
    retX = numpy.array(X)
    retY = numpy.array(Y)
    return retX, retY


  def create_model(self) :
    model = Sequential()
    model.add(LSTM(self.hidden_neurons, \
              batch_input_shape=(None, self.length_of_sequences, self.in_out_neurons), \
              return_sequences=False))
    model.add(Dense(self.in_out_neurons))
    model.add(Activation("linear"))
    model.compile(loss="mape", optimizer="adam")
    return model


  def train(self, X_train, y_train) :
    model = self.create_model()
    #Lernen
    model.fit(X_train, y_train, batch_size=10, nb_epoch=100)
    return model


if __name__ == "__main__":

  prediction = Prediction()

  #Datenaufbereitung
  data = None
  for year in range(2007, 2017):
    data_ = pandas.read_csv('csv/indices_I101_1d_' + str(year) +  '.csv')
    data = data_ if (data is None) else pandas.concat([data, data_])
  data.columns = ['date', 'open', 'high', 'low', 'close']
  data['date'] = pandas.to_datetime(data['date'], format='%Y-%m-%d')
  #Standardisierung der Schlusskursdaten
  data['close'] = preprocessing.scale(data['close'])
  data = data.sort_values(by='date')
  data = data.reset_index(drop=True)
  data = data.loc[:, ['date', 'close']]

  #20% zum Testen von Daten
  split_pos = int(len(data) * 0.8)
  x_train, y_train = prediction.load_data(data[['close']].iloc[0:split_pos], prediction.length_of_sequences)
  x_test,  y_test  = prediction.load_data(data[['close']].iloc[split_pos:], prediction.length_of_sequences)

  model = prediction.train(x_train, y_train)

  predicted = model.predict(x_test)
  result = pandas.DataFrame(predicted)
  result.columns = ['predict']
  result['actual'] = y_test
  result.plot()
  plt.show()

Ergebnis

Es ist ziemlich vorhersehbar ...

Es scheint, dass Sie eine gute Vorhersage treffen können, indem Sie sie auf UP / DOWN setzen.

schließlich

Dieses Mal habe ich dem Verschieben Vorrang eingeräumt, werde aber auch in Zukunft Artikel schreiben. twitter Ich habe angefangen. Bitte folgen Sie mir.

Darüber hinaus betreiben wir Pferderennen Vorhersage siva. Bitte folgen Sie uns auch.