La prévision boursière est un sujet brûlant de nos jours. En raison du grand risque de spéculation, le marché boursier est fortement influencé par les nouvelles, telles que le changement de politique provoqué par la Réserve fédérale, le taux d’intérêt, etc. Cet article décrit comment utiliser la technologie d’intelligence artificielle des réseaux de neurones profonds pour prédire les cours des actions. Nous allons écrire un programme en python qui prédit le mouvement du marché boursier en utilisant des données historiques.

Conditions préalables:

Numpy:

NumPy, abréviation de Numerical Python, est une bibliothèque Python utilisée pour le calcul scientifique et le traitement de données. Cette bibliothèque facilite l’exécution de code Python sur des tableaux et des matrices au lieu de listes. Il a de nombreuses fonctions pour rendre vos mathématiques plus rapides.

Vous pouvez installer le notebook Jupyter à l’aide de la commande suivante dans votre terminal conda. 

pip install numpy

Matplotlib:

Matplotlib est une bibliothèque très complète. Matplotlin a été créé comme interface utilisateur graphique pour un programme nommé MATLAB. Les ingénieurs et les scientifiques des données utilisent principalement MATLAB, bien que cela fonctionne également bien avec Python. Puisque nous allons créer des tableaux et des graphiques, nous devons donc installer matplotlib.

Vous pouvez installer le notebook Jupyter à l’aide de la commande suivante dans votre terminal conda. 

pip install Matplotlib

Tensorflow:

TensorFlow est une bibliothèque logicielle open source pour le calcul numérique à l’aide de graphes de flux de données. Les nœuds de graphe représentent des opérations mathématiques, tandis que les arêtes de graphe représentent les tableaux de données multidimensionnels (tenseurs) qui circulent entre eux. L’architecture flexible vous permet de déployer des calculs sur un ou plusieurs CPU ou GPU dans un poste de travail, un serveur ou un appareil mobile avec une seule API.

Vous pouvez installer le notebook Jupyter à l’aide de la commande suivante dans votre terminal conda. 

pip install --upgrade tensorflow

Sklearn:

SK-learn est une bibliothèque python qui facilite la compréhension du processus d’apprentissage automatique

Vous pouvez installer le notebook Jupyter à l’aide de la commande suivante dans votre terminal conda. 

pip install -U scikit-learn

Pandas_datareader:

Pandas DataReader est un package Python qui nous permet de créer un objet pandas DataFrame en utilisant diverses sources de données sur Internet. Il est couramment utilisé pour les ensembles de données sur les prix des actions en temps réel.

Vous pouvez installer le notebook Jupyter à l’aide de la commande suivante dans votre terminal conda. 

pip install pandas-datareader

Code:

Importer des dépendances

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.feature_selection import SequentialFeatureSelector
from sklearn.model_selection import PredefinedSplit
import pandas_datareader as web
import datetime as dt

from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, LSTM

charger les données :

Pour cela, nous devons spécifier à partir de quel point nous voulons prendre les données à prédire et nous avons également défini le symbole du ticker, vous pouvez obtenir le symbole du ticker de n’importe quel composant de Google 

company = 'FB'
start = dt.datetime(2014,1,1)
end = dt.datetime(2022,1,1)

# define ticker symbol
data = web.DataReader(company, 'yahoo', start, end)

préparation des données :

Pour préparer les données, nous n’allons pas utiliser l’ensemble du bloc de données, nous n’utilisons que le cours de clôture. 

scaler = MinMaxScaler(feature_range=(0,1))
scaled_data = scaler.fit_transform(data['Close'].values.reshape(-1, 1))

# how many days we want to look at the past to predict
prediction_days = 60

# defining two empty lists for preparing the training data
x_train = []
y_train = []

# we are counting from the 60th index to the last index
for x in range(prediction_days, len(scaled_data)):
    x_train.append(scaled_data[x-prediction_days:x, 0])
    y_train.append(scaled_data[x, 0])

x_train, y_train = np.array(x_train), np.array(y_train)
x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1))

construisez le modèle et spécifiez les calques :

Ici, nous allons toujours inclure une seule couche LSTM, suivie d’une couche d’abandon dans la séquence. Après cela, nous allons avoir des couches denses qui auront plusieurs unités de taille et chaque unité sera la prédiction du cours de l’action. Vous pouvez modifier le nombre d’unités utilisées, mais vous devez savoir que plus d’unités signifient un temps de formation plus long car il y a plus de calculs requis par couche. 

model = Sequential()
# specify the layer
model.add(LSTM(units=50, return_sequences=True, input_shape=(x_train.shape[1], 1)))
model.add(Dropout(0.2))
model.add(LSTM(units=50, return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(units=50))
model.add(Dropout(0.2))
# this is going to be a prediction of the next closing value
model.add(Dense(units=1))

complétant le modèle :

model.compile(optimizer='adam', loss='mean_squared_error')
# fit the model in the training data
model.fit(x_train, y_train, epochs=25, batch_size=32)

tester le modèle :

# Load Test Data
test_start = dt.datetime(2020,1,1)
test_end = dt.datetime.now()

test_data = web.DataReader(company, 'yahoo', test_start, test_end)

Maintenant, ce que nous allons faire avec les données de cette entreprise, c’est que nous devons voir à quel point elles peuvent être prédictives. Nous devons obtenir des prix, les mettre à l’échelle, puis créer un ensemble de données total composé d’informations testées et non testées. Nous utiliserons donc d’abord des données boursières réelles qui ne sont liées à aucune prédiction faite. Dans le monde réel, le type de données que nous utiliserons sera les valeurs de clôture, puis nous combinerons toutes les informations en un seul ensemble de données volumineuses pour nous aider à faire nos prédictions. 

actual_prices = test_data['Close'].values
total_dataset = pd.concat((data['Close'],test_data['Close']), axis=0)

model_input = total_dataset[len(total_dataset)- len(test_data) - prediction_days:].values
# reshaping the model
model_input = model_input.reshape(-1, 1)
# scaling down the model
model_input = scaler.transform(model_input)

Prédire les données du lendemain :

x_test = []
for x in range(prediction_days, len(model_input)):
    x_test.append(model_input[x-prediction_days:x, 0])
 
x_test = np.array(x_test)
x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], 1))
 
predicted_price = model.predict(x_test)
predicted_price = scaler.inverse_transform(predicted_price)
 
# plot the test Predictions
plt.plot(actual_prices, color="black", label=f"Actual{company} price")
plt.plot(predicted_price, color='green', label="Predicted {company} Price")
plt.title(f"{company} Share price")
plt.xlabel('Time')
plt.ylabel(f'{company} share price')
plt.legend
plt.show()

Ici, nous allons utiliser des données réelles comme entrée afin de prédire les données du lendemain. 

prediction = model.predict(real_data)
prediction = scaler.inverse_transform(prediction)
print(f"Prediction: {prediction}")

Sortir:

Conclusion:

Dans ce blog, nous avons appris à prédire le marché boursier avec Python ! Ici, nous avons pris une série de données de 60 jours, puis nous avons prédit les données du lendemain. C’est un peu un processus compliqué mais ce n’est pas si difficile non plus. Cela dit, je ne recommande pas de l’utiliser pour le trading. Je considère cela plus comme une expérience d’apprentissage qu’autre chose. J’espère que vous avez aimé le tutoriel et si vous avez des questions, n’hésitez pas à les laisser ci-dessous et je ferai de mon mieux pour y répondre !