La traductrice Polina Kabirova spécialement pour Netologia a adapté un article de l'ingénieur de l'Université de Cambridge Vivek Palaniappan sur la façon de créer un modèle utilisant des réseaux de neurones qui peut prédire les cours des actions en bourse.L'apprentissage automatique et en profondeur est devenu une nouvelle stratégie efficace que de nombreux fonds d'investissement utilisent pour augmenter leurs revenus. Dans l'article, j'expliquerai comment les réseaux de neurones aident à prédire la situation en bourse - par exemple, le prix des actions (ou l'indice). Le texte est basé sur mon
projet écrit en Python. Le code complet et le guide des programmes peuvent être trouvés sur GitHub. Lisez d'autres articles sur le blog
Medium .
Réseaux de neurones en économie
Les changements dans le domaine de la finance ne sont pas linéaires et il peut parfois sembler que les cours des actions se forment de manière complètement aléatoire. Les méthodes traditionnelles de séries chronologiques, telles que les modèles ARIMA et GARCH, sont efficaces lorsque la série est stationnaire - ses propriétés de base ne changent pas avec le temps. Et cela nécessite que la série ait été prétraitée à l'aide
log returns ou amenée à la stationnarité différemment. Cependant, le principal problème se pose lorsque ces modèles sont mis en œuvre dans un véritable système d'échange, car la stationnarité n'est pas garantie lors de l'ajout de nouvelles données.
La solution à ce problème peut être des réseaux de neurones qui ne nécessitent pas de stationnarité. Les réseaux de neurones sont initialement très efficaces pour trouver des relations entre les données et sont capables de prédire (ou classer) de nouvelles données en fonction de celles-ci.
En règle générale, un projet de science des données comprend les opérations suivantes:
- Collecte de données - fournit un ensemble de propriétés nécessaires.
- Le prétraitement des données est souvent une étape effrayante mais nécessaire avant d'utiliser les données.
- Le développement et la mise en œuvre du modèle est le choix du type de réseau neuronal et de ses paramètres.
- Les modèles de backtesting (tests sur des données historiques) sont une étape clé de toute stratégie de trading.
- Optimisation - recherche de paramètres appropriés.
Entrée pour notre réseau de neurones - données sur les cours des actions des 10 derniers jours. Avec leur aide, nous prédirons les prix le lendemain.
Collecte de données
Heureusement, les données nécessaires à ce projet se trouvent sur Yahoo Finance. Les données peuvent être collectées à l'aide de leur API Python
pdr.get_yahoo_data(ticker, start_date, end_date) ou directement à partir du site.
Prétraitement des données
Dans notre cas, les données doivent être divisées en ensembles de formation comprenant 10 prix passés et prix du lendemain. Pour ce faire, j'ai défini la classe de
Preprocessing , qui fonctionnera avec les données de formation et de test. À l'intérieur de la classe, j'ai défini la
get_train(self, seq_len) , qui convertit les données d'entrée et de sortie d'apprentissage en tableaux
NumPy , définissant une longueur de fenêtre spécifique (dans notre cas 10). Le code entier ressemble à ceci:
def gen_train(self, seq_len): """ Generates training data :param seq_len: length of window :return: X_train and Y_train """ for i in range((len(self.stock_train)//seq_len)*seq_len - seq_len - 1): x = np.array(self.stock_train.iloc[i: i + seq_len, 1]) y = np.array([self.stock_train.iloc[i + seq_len + 1, 1]], np.float64) self.input_train.append(x) self.output_train.append(y) self.X_train = np.array(self.input_train) self.Y_train = np.array(self.output_train)
De même, j'ai défini une méthode qui convertit les données de test
X_test et
Y_test .
Modèles de réseaux de neurones
Pour le projet, j'ai utilisé deux modèles de réseaux de neurones: le Perceptron Multicouche (MLP) et le Modèle Long Court Terme (LSTM). Je vais brièvement parler du fonctionnement de ces modèles. En savoir plus sur MLP dans
un autre article , et sur le travail du LSTM dans Jacob Aungiers.
MLP est la forme la plus simple de réseaux de neurones. Les données d'entrée tombent dans le modèle et en utilisant certains poids, les valeurs sont transmises à travers des couches cachées pour obtenir les données de sortie. L'apprentissage de l'algorithme vient de la propagation arrière à travers des couches cachées pour changer les valeurs de poids de chaque neurone. Le problème avec ce modèle est le manque de «mémoire». Il est impossible de déterminer quelles étaient les données précédentes et comment elles peuvent et devraient affecter les nouvelles. Dans le contexte de notre modèle, les différences de 10 jours entre les données de deux ensembles de données peuvent être importantes, mais les MLP ne sont pas en mesure d'analyser de telles relations.
Pour ce faire, utilisez LSTM ou Recurrent Neural Networks (RNN). Les RNN stockent certaines informations de données pour une utilisation ultérieure, ce qui aide le réseau neuronal à analyser la structure complexe des relations entre les données sur les cours des actions. Mais avec RNN, le problème d'un gradient de décoloration se pose. Le gradient diminue car le nombre de couches augmente et le niveau d'entraînement (une valeur inférieure à l'unité) est multiplié plusieurs fois. Résolvez ce problème LSTM en augmentant l'efficacité.
Implémentation du modèle
Pour implémenter le modèle, j'ai utilisé
Keras , car des couches y sont ajoutées progressivement et ne définissent pas tout le réseau à la fois. Nous pouvons donc rapidement changer le nombre et le type de couches, optimisant le réseau neuronal.
La normalisation des données est une étape importante dans l'utilisation des cours boursiers. Habituellement, pour cela, vous soustrayez l'erreur moyenne et divisez par l'erreur standard. Mais nous avons besoin que ce système soit utilisé dans le commerce réel pendant une certaine période de temps. Par conséquent, l'utilisation de statistiques n'est peut-être pas le moyen le plus précis de normaliser les données. J'ai donc divisé toutes les données en 200 (un nombre arbitraire par rapport auquel tous les autres nombres sont petits). Et bien qu'il semble qu'une telle normalisation ne soit pas justifiée et n'a pas de sens, il est efficace de s'assurer que les poids dans le réseau neuronal ne deviennent pas trop importants.
Commençons par un modèle plus simple - MLP. Keras crée une séquence et y ajoute des couches denses. Le code complet ressemble à ceci:
model = tf.keras.models.Sequential() model.add(tf.keras.layers.Dense(100, activation=tf.nn.relu)) model.add(tf.keras.layers.Dense(100, activation=tf.nn.relu)) model.add(tf.keras.layers.Dense(1, activation=tf.nn.relu)) model.compile(optimizer="adam", loss="mean_squared_error")
En utilisant Keras dans cinq lignes de code, nous avons créé MLP avec des couches cachées, cent neurones dans chacune. Et maintenant un peu sur l'optimiseur. La méthode d'Adam (estimation adaptative du moment) gagne en popularité - un algorithme d'optimisation plus efficace que la
descente de gradient stochastique . Il existe deux autres extensions de la descente de gradient stochastique - les avantages d'Adam sont immédiatement visibles sur leur arrière-plan:
AdaGrad - maintient une vitesse d'apprentissage définie, ce qui améliore les résultats lorsque les gradients divergent (par exemple, avec des problèmes de langage naturel et de vision par ordinateur).
RMSProp - maintient une vitesse d'entraînement définie, qui peut varier en fonction des valeurs moyennes des gradients récents pour le poids (par exemple, la vitesse à laquelle il change). Cela signifie que l'algorithme résout bien les problèmes non stationnaires (par exemple, le bruit).
Adam combine les avantages de ces extensions, alors je l'ai choisi.
Nous adaptons maintenant le modèle à nos données d'entraînement. Keras simplifie à nouveau la tâche, seul le code suivant est nécessaire:
model.fit(X_train, Y_train, epochs=100)
Lorsque le modèle est prêt, vous devez le vérifier sur les données de test pour déterminer son bon fonctionnement. Cela se fait comme ceci:
model.evaluate(X_test, Y_test)
Les informations obtenues à partir de la vérification peuvent être utilisées pour évaluer la capacité du modèle à prédire les cours des actions.
Une procédure similaire est utilisée pour le modèle LSTM, je vais donc montrer le code et l'expliquer un peu:
model = tf.keras.Sequential() model.add(tf.keras.layers.LSTM(20, input_shape=(10, 1), return_sequences=True)) model.add(tf.keras.layers.LSTM(20)) model.add(tf.keras.layers.Dense(1, activation=tf.nn.relu)) model.compile(optimizer="adam", loss="mean_squared_error") model.fit(X_train, Y_train, epochs=50) model.evaluate(X_test, Y_test)
Veuillez noter que Keras a besoin de données d'une certaine taille, selon votre modèle. Il est très important de modifier la forme du tableau à l'aide de NumPy.
Modèles de backtesting
Lorsque nous avons préparé nos modèles à l'aide de données de formation et les avons testés sur des données de test, nous pouvons tester le modèle sur des données historiques. Cela se fait comme suit:
def back_test(strategy, seq_len, ticker, start_date, end_date, dim): """ A simple back test for a given date period :param strategy: the chosen strategy. Note to have already formed the model, and fitted with training data. :param seq_len: length of the days used for prediction :param ticker: company ticker :param start_date: starting date :type start_date: "YYYY-mm-dd" :param end_date: ending date :type end_date: "YYYY-mm-dd" :param dim: dimension required for strategy: 3dim for LSTM and 2dim for MLP :type dim: tuple :return: Percentage errors array that gives the errors for every test in the given date range """ data = pdr.get_data_yahoo(ticker, start_date, end_date) stock_data = data["Adj Close"] errors = [] for i in range((len(stock_data)//10)*10 - seq_len - 1): x = np.array(stock_data.iloc[i: i + seq_len, 1]).reshape(dim) / 200 y = np.array(stock_data.iloc[i + seq_len + 1, 1]) / 200 predict = strategy.predict(x) while predict == 0: predict = strategy.predict(x) error = (predict - y) / 100 errors.append(error) total_error = np.array(errors) print(f"Average error = {total_error.mean()}")
Cependant, il s'agit d'une version simplifiée des tests. Pour un système de backtest complet, des facteurs tels que le «biais de survie», le biais (biais d'anticipation), l'évolution des conditions du marché et les coûts de transaction doivent être pris en compte. Comme il ne s'agit que d'un projet éducatif, un simple backtesting suffit.
Prévision de mon modèle LSTM pour le cours des actions Apple en févrierPour un modèle LSTM simple sans optimisation, c'est un très bon résultat. Il montre que les réseaux de neurones et les modèles d'apprentissage automatique sont capables de construire des connexions complexes et stables entre les paramètres.
Optimisation hyperparamétrique
Une optimisation est souvent nécessaire pour améliorer les résultats du modèle après les tests. Je ne l'ai pas inclus dans la version open source afin que les lecteurs puissent essayer d'optimiser le modèle eux-mêmes. Ceux qui ne savent pas optimiser devront trouver des hyperparamètres qui amélioreront les performances du modèle. Il existe plusieurs méthodes pour trouver des hyperparamètres: de la sélection des paramètres sur une grille aux méthodes stochastiques.
Je suis sûr qu'avec l'optimisation des modèles, les connaissances dans le domaine de l'apprentissage automatique atteignent un nouveau niveau. Essayez d'optimiser le modèle pour qu'il fonctionne mieux que le mien. Comparez le résultat avec le graphique ci-dessus.
Conclusion
L'apprentissage automatique est en constante évolution - de nouvelles méthodes émergent chaque jour, il est donc très important d'apprendre constamment. La meilleure façon de le faire est de créer des projets intéressants, par exemple, de construire des modèles pour prévoir les cours des actions. Et bien que mon modèle LSTM ne soit pas assez bon pour être utilisé dans le trading réel, les bases posées dans le développement d'un tel modèle peuvent aider à l'avenir.
Des éditeurs
Cours de netologie sur le sujet: