[PYTHON] Essayez les prévisions de prix Bitcoin avec Deep Learning

Étude gratuite des vacances d'été ~ Rêve de revenus au chômage ~

J'ai pris un certificat à Coursera, c'est donc une façon de passer mes vacances d'été à essayer de faire quelque chose comme l'apprentissage automatique ou le Deep Learning. Il y a des gens formidables dans le monde, et il y a une approche qui a déjà été essayée au point de m'en lasser, et je vais l'essayer avec le pouvoir de réflexion que j'ai étudié.

À l'avenir, j'aimerais créer un modèle très précis, créer un revenu de chômage de rêve et payer des impôts.

introduction

Il m'a fallu une journée pour étudier.

Environnement

Comment installer TensorFlow que même les débutants en apprentissage automatique peuvent faire immédiatement Beaucoup de gens le font déjà, alors veuillez l'imiter. Faites attention de le faire en Python3, c'est une bonne idée de spécifier la version à utiliser dans pyenv etc.

Je pense que cela peut être fait en 10 minutes environ.

Bibliothèque

Keras

Keras est une bibliothèque de réseau neuronal de haut niveau écrite en Python qui peut être exécutée sur TensorFlow, CNTK ou Theano.

Je me demandais si Deep Learning devrait avoir TensorFlow, mais bien sûr, il existe de nombreux frameworks qui l'enveloppent, et Keras en fait partie. Vous pouvez choisir d'utiliser theano/tensorflow comme décrit dans la documentation.

Après tout, les deux sont destinés à traiter les tenseurs, et je ne comprends pas vraiment la différence, mais au début, j'ai pensé que ce n'était pas si important et je l'ai sauté.

numpy Guy pratique pour le calcul numérique de python

pandas Un gars pratique qui gère les données de séries chronologiques

data = pandas.read_csv('./csv/bitcoin_log_1month.csv')
data = data.sort_values(by='date')
data = data.reset_index(drop=True)

Il est pratique de charger csv de cette manière. En plus du chargement, il a la possibilité de trier et d'indexer.

Scikit-learn Il fournit un module pratique pour l'apprentissage automatique. Comme il est basé sur le traitement de numpy.ndarray, il est exécuté pour cela. Il existe également des modules de normalisation.

tflearn C'est une bibliothèque qui vous permet d'utiliser TensorFlow comme Scikit-learn. Intégré à TensorFlow, il construit des réseaux de neurones et définit des modèles.

matplotlib Tout le monde aime le matlab. Il est utilisé pour visualiser le graphique créé et l'enregistrer sous forme d'image. Puisqu'une erreur se produit lors de l'importation, modifiez en partie matplotlibrc en vous référant au lien ci-dessous.

Que faire si matplotlib.pyplot ne peut pas être utilisé lors de la création d'un environnement avec pyenv et virtualenv

conception

Que dois-je faire en premier? Jetons un coup d'œil à de nombreux liens utiles. Après tout, ce que je veux faire, c'est faire quelque chose qui puisse résoudre la classification binaire de "si le cours de clôture de demain augmentera ou baissera". En appelant un lien de référence, j'ai pu transmettre la volonté de générer des revenus de chômage pour tous. Ah ouais.

référence

• TensorFlow (LSTM) Stock Forecast ~ Stock Forecast Part 1 ~
• RNN prédit le nombre de passagers aériens du mois prochain: TFLearn implémente de LSTM à GRU
• Essayez de prédire le taux de change (FX) avec TensorFlow (apprentissage en profondeur)

Comprenons

Après tout ML et DL sont assez différents, donc ce qui est géré est très différent, alors je l'ai organisé.

Flux requis

1. Sécurisation des données de séries chronologiques

Il existe différents endroits où les données de séries chronologiques de Bitcoin peuvent être obtenues via l'API, mais je voulais le faire investir ) Vers DL. Vous pouvez prendre le cours de clôture annuel pendant plusieurs années. S'il ne s'agit pas de JPY, il existe de nombreuses autres options.

2. Formatage de l'ensemble de données

Nous normaliserons et standardiserons les données nécessaires. En ce moment, c'est dans sklearn [package de traitement](http://qiita.com/nazoking@github/items/d6ac1948ee138d73fef1#431-%E6%A8%99%E6%BA%96%E5%8C%96%E5%B9%B3%E5% 9D% 87% E9% 99% A4% E5% 8E% BB% E3% 81% A8% E5% 88% 86% E6% 95% A3% E3% 81% AE% E3% 82% B9% E3% 82% Avec B1% E3% 83% BC% E3% 83% AA% E3% 83% B3% E3% 82% B0), vous pouvez facilement effectuer les opérations suivantes:

data['close'] = preprocessing.scale(data['close'])

3. Sélection du modèle et erreur à utiliser

L'erreur requise et le modèle diffèrent selon les données utilisées, donc même si vous n'avez pas beaucoup de connaissances ici, vous pouvez vérifier en remplaçant les arguments. Je pense que vous pouvez vraiment étudier correctement et obtenir des résultats significatifs.

Principe de l'apprentissage en profondeur facile

LSTM (Long Short-Term Memory) est un modèle puissant qui élimine les inconvénients de RNN et peut apprendre des données chronologiques à long terme.

Il existe différents modèles tels que GRU et LSTN, et je ne mentionnerai pas les fonctionnalités, mais il en existe plusieurs.

Le reste est une erreur

Signification de diverses erreurs (RMSE, MAE, etc.) Il existe différents types tels que MAPE et RMSE. Puisqu'il s'agit d'un indice d'évaluation, il évalue la distance entre la valeur mesurée et la valeur prévue lorsque le modèle est modifié ou la quantité de données ajoutée.

4. Préparation des données de formation et des données de test

Choisissez la quantité de données que vous souhaitez apprendre et comparez-la avec les données que vous avez préparées. Formation: j'ai senti que je mettais souvent test = 8: 2.

5. Prédiction basée sur ces

Créez un modèle à l'aide du réseau de neurones construit, effectuez un ajustement basé sur celui-ci et effectuez une prédiction.

6. Évaluation

Après cela, les résultats sont représentés graphiquement, visualisés et évalués. Avec TensorBoard, vous pouvez facilement visualiser les modèles et les erreurs.

J'ai appris des références que je devrais être capable d'implémenter à peu près ce flux.

la mise en oeuvre

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

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.dataset = None
        #Valeurs à calculer
        self.model = None
        self.train_predict = None
        self.test_predict = None

        #Paramètres des paramètres du jeu de données
        self.steps_of_history = 3
        self.steps_in_future = 1
        self.csv_path = './csv/bitcoin_log.csv'

    def load_dataset(self):
        #Préparation des données
        dataframe = pd.read_csv(self.csv_path,
                usecols=['le dernier prix'],
                engine='python').sort_values('le dernier prix', ascending=True)
        self.dataset = dataframe.values
        self.dataset = self.dataset.astype('float32')

        #Standardisation
        self.dataset -= np.min(np.abs(self.dataset))
        self.dataset /= np.max(np.abs(self.dataset))


    def create_dataset(self):
        X, Y = [], []
        for i in range(0, len(self.dataset) - self.steps_of_history, self.steps_in_future):
            X.append(self.dataset[i:i + self.steps_of_history])
            Y.append(self.dataset[i + self.steps_of_history])

        X = np.reshape(np.array(X), [-1, self.steps_of_history, 1])
        Y = np.reshape(np.array(Y), [-1, 1])
        return X, Y

    def setup(self):
        self.load_dataset()
        X, Y = self.create_dataset()

        # Build neural network
        net = tflearn.input_data(shape=[None, self.steps_of_history, 1])

        #LSTM prend du temps alors GRU
        # http://dhero.hatenablog.com/entry/2016/12/02/%E6%9C%80%E5%BC%B1SE%E3%81%A7%E3%82%82%E6%A9%9F%E6%A2%B0%E5%AD%A6%E7%BF%92%E3%81%A7%E3%81%8A%E9%87%91%E3%81%8C%E7%A8%BC%E3%81%8E%E3%81%9F%E3%81%84%E3%80%905%E6%97%A5%E7%9B%AE%E3%83%BBTFLearn%E3%81%A8
        net = tflearn.gru(net, n_units=6)
        net = tflearn.fully_connected(net, 1, activation='linear')

        #Paramètres de régression
        #Mesuré par la méthode Adam
        # http://qiita.com/TomokIshii/items/f355d8e87d23ee8e0c7a
        #Moyenne en tant qu'indice de la précision des prévisions dans l'analyse des séries chronologiques_J'utilise square
        #mape semble être commun
        # categorical_crossentropy
        # mean_square :Racine carrée moyenne carrée
        net = tflearn.regression(net, optimizer='adam', learning_rate=0.001,
                loss='mean_square')

        # Define model
        self.model = tflearn.DNN(net, tensorboard_verbose=0)

        #Cette fois 80%L'ensemble de données de formation, 20%En tant que jeu de données de test.
        pos = round(len(X) * (1 - 0.2))
        trainX, trainY = X[:pos], Y[:pos]
        testX, testY   = X[pos:], Y[pos:]
        
        return trainX, trainY, testX

    def executePredict(self, trainX, trainY, testX):
        # Start training (apply gradient descent algorithm)
        self.model.fit(trainX, trainY, validation_set=0.1, show_metric=True, batch_size=1, n_epoch=150, run_id='btc')

        # predict
        self.train_predict = self.model.predict(trainX)
        self.test_predict = self.model.predict(testX)

    def showResult(self):
        # plot train data
        train_predict_plot = np.empty_like(self.dataset)
        train_predict_plot[:, :] = np.nan
        train_predict_plot[self.steps_of_history:len(self.train_predict) + self.steps_of_history, :] = \
                self.train_predict

        # plot test dat
        test_predict_plot = np.empty_like(self.dataset)
        test_predict_plot[:, :] = np.nan
        test_predict_plot[len(self.train_predict) + self.steps_of_history:len(self.dataset), :] = \
                self.test_predict

        # plot show res
        plt.figure(figsize=(8, 8))
        plt.title('History={} Future={}'.format(self.steps_of_history, self.steps_in_future))
        plt.plot(self.dataset, label="actual", color="k")
        plt.plot(train_predict_plot, label="train", color="r")
        plt.plot(test_predict_plot, label="test", color="b")
        plt.savefig('result.png')
        plt.show()


if __name__ == "__main__":

    prediction = Prediction()
    trainX, trainY, testX = prediction.setup()
    prediction.executePredict(trainX, trainY, testX)
    prediction.showResult()

J'ai beaucoup parlé du site auquel je faisais référence, mais il a fallu environ une heure pour le mettre en œuvre et le comprendre.

Entrez brièvement la description du code.

load_dataset

Les données utilisées cette fois sont comme ça. Lisez ceci et utilisez-le comme ensemble de données. Puisque l'ordre des données est inversé, triez, etc.

"Date","le dernier prix","Prix ouvert","Prix élevé","Bas prix","Ratio du jour précédent"
"03 septembre 2017","523714.1875","499204.7813","585203.1250","499204.7813","4.91"
"02 septembre 2017","499204.7813","542277.3125","585203.1250","498504.5000","-7.94"

setup Construisez un réseau neuronal. GRU est l'une des méthodes DL. Il y a différentes choses comme le LSTM et le RNN, mais cette fois je l'ai choisi en mettant l'accent sur la vitesse.

net = tflearn.input_data(shape=[None, self.steps_of_history, 1])
net = tflearn.gru(net, n_units=6)
net = tflearn.fully_connected(net, 1, activation='linear')

Sélection de la méthode d'optimisation / erreur de calcul Cette fois, l'optimisation est méthode Adam et l'erreur est mean_square (RMSE (Root Mean Square Error)) / rmsemae) est utilisé. Étant donné que les méthodes telles que MAPE ne sont pas préparées par défaut, il semble nécessaire de réécrire partiellement la bibliothèque afin qu'elle puisse être utilisée.

net = tflearn.regression(net, optimizer='adam', learning_rate=0.001,
                loss='mean_square')

executePredict

Sélectionnez et prédisez les données d'entraînement / de test.

#Cette fois 80%L'ensemble de données de formation, 20%En tant que jeu de données de test.
pos = round(len(X) * (1 - 0.2))
trainX, trainY = X[:pos], Y[:pos]
testX, testY   = X[pos:], Y[pos:]

# Start training (apply gradient descent algorithm)
self.model.fit(trainX, trainY, validation_set=0.1, show_metric=True, batch_size=1, n_epoch=150, run_id='btc')

# predict
self.train_predict = self.model.predict(trainX)
self.test_predict = self.model.predict(testX)

Voir le résultat

Le noir correspond aux données réelles, le rouge correspond aux données d'entraînement et le bleu correspond à la valeur prédite en fonction des données de test.

Voici le résultat de TensorBoard.

C'est comme Humuu. La perte / la validation est étrange pour le moment. À partir de là, nous ferons de notre mieux pour étudier les paramètres susceptibles de réduire les erreurs tout en modifiant le nombre d'époques, de modèles et d'étapes, le rapport de données d'entraînement et la quantité de données, le nombre de couches GRU, etc.

En passant, j'ai essayé de prédire l'utilisation de LSTM avec sklearn sans utiliser tflearn comme suit.

    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")

mape n'est pas dans tflearn, mais est-ce dans sklearn ...? ?? Très difficile.

Résumé

J'ai fait quelque chose qui fonctionne pour le moment, mais les vacances d'été sont terminées et le reste sera fait à une date ultérieure. Maintenant que je peux le déplacer, j'en apprendrai davantage sur la méthode de vérification et j'améliorerai la précision.

après

Visual Studio Code pour Mac était très bon. Je pensais que l'implémentation python était le choix de Pycham, mais c'est très bien.