[PYTHON] Prévision de stock avec TensorFlow (LSTM) ~ Prévision de stock Partie 1 ~

introduction

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

Prédisez les cours des actions à l'aide d'objectifs, de machine learning et de deep learning

Avant de commencer à étudier, vérifiez d'abord les livres suivants.

• Il semble que les conditions du mouvement boursier soient «une bonne performance», un «PER faible» et une «bonne forme de graphique». J'aimerais amener chacun en grattant et faire des prédictions.

[Supplément]

En plus des stocks, j'opère habituellement des prévisions de courses de chevaux siva. Valeur prédictive continue: environ 86% Taux de récupération: environ 136%

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

Pourquoi stock?

J'ai choisi le stock parmi les vues suivantes.

◆ Jeux de hasard tels que les courses de chevaux
Le rendement de 0 ou 100 est également important, mais le risque est important.
　◆ FX 
Certaines personnes gagnent de l'argent, mais certaines personnes le perdent, donc cela ne convient pas à leur sexe.
　◆ bitcoin
Puisque la valeur n'a pas été établie, il existe une possibilité d'effondrement.
◆ Stock
Quant aux actions, tout le monde est rentable.

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

Commençons l'expérience depuis Site où vous pouvez télécharger et expérimenter avant de l'apporter en grattant.

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.

Les données utilisées cette fois utilisent le cours de clôture.

Pensez à l'approche

Pour les actions, on considère qu'il est préférable de prédire par RNN (Recurrent Neural Network) (* 2) en utilisant des séries chronologiques plutôt que d'analyser statistiquement les performances passées (* 1), il s'agit donc d'une extension de RNN. Essayons d'utiliser LSTM (Long short-term memory).

• 1 Nous essayerons la méthode d'apprentissage des résultats réels des données passées sur le graphique à partir de la prochaine fois.
• 2 RNN est un type d'apprentissage profond. Contrairement à un réseau neuronal normal, il entre son état précédent en plus de la valeur d'entrée actuelle. L'entrée et la sortie de RNN sont indiquées dans la figure ci-dessous. Lorsque l'on considère les données temporellement continues x (= x_1, x_2, x_3,…, x_n) comme entrée, l'état précédent s_t-1 est entré avec l'entrée de x_t. Cet "état précédent" contient des informations passées jusqu'à ce point.

Diagramme schématique de RNN (source)

Expérimentez quand même le programme

Tout d'abord, j'ai donné la priorité à essayer et j'ai fait un programme avec Nikkei average.

# -*- 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()
    #Apprentissage
    model.fit(X_train, y_train, batch_size=10, nb_epoch=100)
    return model


if __name__ == "__main__":

  prediction = Prediction()

  #Préparation des données
  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')
  #Standardiser les données de cours de clôture
  data['close'] = preprocessing.scale(data['close'])
  data = data.sort_values(by='date')
  data = data.reset_index(drop=True)
  data = data.loc[:, ['date', 'close']]

  #20% pour tester les données
  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()

résultat

Je pense que c'est assez prévisible ...

Il semble que vous puissiez faire de bonnes prédictions en le réglant sur HAUT / BAS.

à la fin

Cette fois, j'ai donné la priorité au déménagement, mais je continuerai à écrire des articles à l'avenir. twitter J'ai commencé. Suis-moi s'il te plait.

De plus, nous exploitons des prévisions de courses de chevaux siva. Veuillez nous suivre également.