Prévision de stock avec TensorFlow (perceptron multicouche: MLP) ~ Prévision de stock 2 ~

introduction

Je vais commencer à étudier l'investissement en actions, je vais donc en laisser une note.

Poursuite de la précédente TensorFlow (LSTM) Stock Forecast ~ Stock Forecast Part 1 ~

• Dernier cours de bourse prévu

Cette fois, nous utiliserons Multilayer Perceptron (MLP) pour classer si le cours de l'action augmentera ou baissera et ferons une prévision du cours de l'action.

[Supplément]

Nous exploitons des prévisions de courses de chevaux siva qui utilisent l'IA en plus des stocks. Valeur prédictive réciproque: environ 86% Taux de récupération: environ 136%

J'ai commencé twitter. Suis-moi s'il te plait.

Spécifications simples

Comme méthode de prédiction pour précédent, le cours de l'action pour le jour suivant a été prédit par LSTM à partir du cours de clôture des 10 jours précédents.

Cette fois, nous entrerons le cours de clôture des 100 jours précédents et le classerons en deux valeurs, que le cours de l'action augmente ou baisse le jour suivant.

Tout d'abord, une expérience de prévision des stocks

Pour les données, utilisez les données de here avec previous.

Les données téléchargées sont les informations moyennes Nikkei de 2007 à 2017. Contient des données pour les prix de date, d'ouverture, de haut, de bas et de clôture.

approche

Puisqu'il s'agit d'une classification binaire indiquant si le stock du jour suivant augmente ou diminue par rapport aux informations de cours de clôture des 100 derniers jours, la fonction d'activation est une fonction logistique (sigmoïde) et la fonction de perte est une erreur d'entropie.

À propos du perceptron multicouche

Multi-Layer Perceptron (MLP) est un réseau de neurones à réaction dans lequel les neurones sont disposés en plusieurs couches.

Expérience programmatique

Comme la dernière fois, je vais donner la priorité à essayer d'abord et faire un programme rapidement avec la moyenne Nikkei. Donne le taux de réponse correct pour la classification.

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


#
#Générer un modèle
#
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']]

  #Préparation des données
  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)))
  

résultat

Cette fois, il y a deux catégories, HAUT / BAS, alors essayez plusieurs fois pour vérifier les résultats.

Hmm. .. .. .. C'est plus probable qu'approprié, mais je ne suis pas sûr que ce soit prévisible. .. .. Je ferai de mon mieux.

à la fin

Tout d'abord, donnez la priorité à essayer et considérez la meilleure façon. La prochaine fois, j'essaierai le calcul statistique, CNN et l'apprentissage par renforcement.

Veuillez suivre twitter.

Nous exploitons des prévisions de courses de chevaux siva qui utilisent l'IA en plus des stocks. Valeur prédictive réciproque: environ 86% Taux de récupération: environ 136%