[PYTHON] Aktienkursprognose mit TensorFlow (mehrschichtiges Perceptron: MLP) ~ Aktienprognose 2 ~

Einführung

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

Fortsetzung der vorherigen TensorFlow (LSTM) Aktienprognose ~ Aktienprognose Teil 1 ~

• Zuletzt prognostizierter Aktienkurs

Dieses Mal werden wir Multilayer Perceptron (MLP) verwenden, um zu klassifizieren, ob der Aktienkurs steigen oder fallen wird, und um eine Aktienkursprognose zu erstellen.

[Ergänzung]

Wir betreiben eine Pferderennprognose siva, bei der zusätzlich zu den Aktien auch KI verwendet wird. Gegenseitiger Vorhersagewert: Ungefähr 86% Wiederherstellungsrate: ca. 136%

Ich habe [twitter] gestartet (https://twitter.com/tsunaki00). Bitte folgen Sie mir.

Einfache Spezifikationen

Als Prognosemethode für vorherige wurde der Aktienkurs für den nächsten Tag von LSTM aus dem Schlusskurs der letzten 10 Tage prognostiziert.

Dieses Mal geben wir den Schlusskurs der letzten 100 Tage ein und klassifizieren ihn in zwei Werte, unabhängig davon, ob der Aktienkurs am nächsten Tag steigen oder fallen wird.

Zunächst ein Experiment zur Aktienvorhersage

Verwenden Sie für die Daten die Daten von hier zusammen mit vorherigen.

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

Ansatz

Da es sich um eine binäre Klassifizierung handelt, ob der Bestand des nächsten Tages gegenüber den Schlusskursinformationen der letzten 100 Tage steigt oder fällt, ist die Aktivierungsfunktion eine logistische Funktion (Sigmoid) und die Verlustfunktion ein Entropiefehler.

Über mehrschichtiges Perzeptron

Multi-Layer Perceptron (MLP) ist ein Feed-Forward-Neuronales Netzwerk, in dem Neuronen in mehreren Schichten angeordnet sind.

Programmatisches Experiment

Wie beim letzten Mal werde ich es vorrangig versuchen, es zuerst zu versuchen und schnell ein Programm mit Nikkei-Durchschnitt zu erstellen. Gibt die richtige Antwortrate für die Klassifizierung an.

stock_mlp.py

# -*- coding: utf-8 -*-
import sys
import os
import numpy
import pandas
from sklearn import preprocessing

from keras.models import Sequential
from keras.layers import Convolution2D, MaxPooling2D
from keras.layers import Activation, Dropout, Flatten, Dense
from keras.utils import np_utils


#
#Modell generieren
#
class StockCNN : 
  def __init__(self):
    self.length_of_sequences = 100

  def load_data(self, date, data, n_prev=100):
    label = []
    X, Y = [], []
    for i in range(len(data) - n_prev):
      label.append(date.iloc[i+n_prev].as_matrix())
      X.append(data['close'].iloc[i:(i+n_prev)].as_matrix())
      array = data.iloc[i:(i+n_prev)].as_matrix()
      if (float(array[-1]) > float(data.iloc[i+n_prev].as_matrix())) :
        Y.append([0])
      else :
        Y.append([1])

    ret_label = numpy.array(label)
    retX = numpy.array(X)
    retY = numpy.array(Y)
    return ret_label, retX, retY

  def create_model(self) :
    model = Sequential()
    model.add(Dense(64, input_dim=self.length_of_sequences, activation='sigmoid'))
    model.add(Dense(128, activation='sigmoid'))
    model.add(Dense(64, activation='sigmoid'))
    model.add(Dense(1, activation='sigmoid'))


    model.compile(loss='binary_crossentropy',
                  optimizer='rmsprop',
                  metrics=['accuracy'])

    return model

if __name__ == "__main__":

  stock = StockCNN()
  data = None
  for year in range(2007, 2018):
    data_ = pandas.read_csv('csv/indices_I101_1d_' + str(year) +  '.csv', encoding="shift-jis")
    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')
  data['close'] = preprocessing.scale(data['close'])
  data = data.sort_values(by='date')
  data = data.reset_index(drop=True)
  data = data.loc[:, ['date', 'close']]

  #Datenaufbereitung
  split_pos = int(len(data) * 0.9)
  x_label, x_train, y_train  = stock.load_data(data[['date']].iloc[0:split_pos],\
                                          data[['close']].iloc[0:split_pos], stock.length_of_sequences)
  x_tlabel, x_test,  y_test  = stock.load_data(data[['date']].iloc[split_pos:], \
                                          data[['close']].iloc[split_pos:], stock.length_of_sequences)

  model = stock.create_model()

  
  model.fit(x_train, y_train, nb_epoch=1000, batch_size=10)



  good = 0
  index = 0
  for values in x_test : 
    y = y_test[index][0]
    predict = model.predict(numpy.array([values]))[0][0]
    print(x_tlabel[index][0])
    print(y)
    print(predict)
    if predict < 0.5 :
      if y == 0 :
        good += 1
    else : 
      if y == 1 :
        good += 1
    index += 1
  print ("accuracy = {0:.2f}".format(float(good) / len(x_test)))
  

Ergebnis

Dieses Mal gibt es zwei Kategorien: AUF / AB. Versuchen Sie also mehrmals, die Ergebnisse zu überprüfen.

Hmm. .. .. .. Es ist wahrscheinlicher als angemessen, aber ich bin nicht sicher, ob es vorhersehbar ist. .. .. Ich werde mein Bestes geben.

schließlich

Versuchen Sie zunächst, den besten Weg zu finden. Nächstes Mal werde ich statistische Berechnungen, CNN und Verstärkungslernen ausprobieren.

Bitte folgen Sie twitter.

Wir betreiben eine Pferderennprognose siva, bei der zusätzlich zu den Aktien auch KI verwendet wird. Gegenseitiger Vorhersagewert: Ungefähr 86% Wiederherstellungsrate: ca. 136%