Science">
Prédiction Des Cours Du Bitcoin Avec Les Modèles de Markov Cachés
Prédiction Des Cours Du Bitcoin Avec Les Modèles de Markov Cachés
Prédiction Des Cours Du Bitcoin Avec Les Modèles de Markov Cachés
Sommaire :
I. Introduction
Contexte et motivation
Objectifs du projet
Aperçu des méthodes utilisées
II. Fondements théoriques
Présentation des modèles de Markov
Introduction aux chaînes de Markov cachées (HMM)
Applications des HMM dans la prédiction des séries temporelles
III. Collecte et prétraitement des données
Sources de données utilisées
Description des données
Nettoyage et prétraitement des données
IV. Modélisation avec HMM
Choix des paramètres du modèle
Formation du modèle HMM
Validation du modèle
V. Implémentation et méthodologie
Description des algorithmes utilisés (Viterbi, Forward-Backward)
Développement du système de prédiction
VI. Résultats
Évaluation de la performance du modèle
Analyse des prédictions par rapport aux données réelles
Limitations et pistes d'amélioration
VII. Conclusion
Résumé des résultats
Retour sur les objectifs du projet
Contributions et implications
I. Introduction
Contexte et Motivation
Le Bitcoin, la première crypto-monnaie décentralisée, a attiré l'attention mondiale en raison de sa
volatilité et de son potentiel de gain élevé. La prédiction des prix du Bitcoin est cruciale pour les
investisseurs et les traders, mais elle est également complexe en raison de la nature volatile du marché.
Dans ce rapport, nous abordons l'utilisation des modèles de Markov cachés (HMM) pour prédire les
mouvements futurs des prix du Bitcoin.
Objectifs du Projet
Ce projet vise à développer un modèle de prédiction des prix du Bitcoin basé sur les HMM. Notre
objectif principal est de créer un modèle robuste capable de capturer les tendances et les modèles dans
les données historiques des prix du Bitcoin et de générer des prédictions précises pour les futurs
mouvements de prix.
Aperçu des Méthodes Utilisées
Nous utiliserons des données historiques des prix du Bitcoin pour entraîner notre modèle HMM. Nous
explorerons les concepts théoriques des HMM et les techniques d'apprentissage automatique associées
pour construire un modèle de prédiction performant. Les algorithmes de Viterbi et de Forward-
Backward seront utilisés pour l'inférence des séquences d'états cachés et l'estimation des paramètres du
modèle.
Avant de passer à la description d'un modèle de Markov caché, voyons d'abord ce qu'est un modèle de
Markov.
Le modèle de Markov, aussi appelé Chaîne de Markov, est un modèle statistique composé d'états et de
transitions. Une transition matérialise la possibilité de passer d'un état à un autre.
Dans le modèle de Markov, les transitions sont unidirectionnelles : une transition de l'état A vers état B
ne permet pas d'aller de l'état B vers l'état A. Tous les états ont des transitions vers tous les autres états,
y compris vers eux-mêmes. Chaque transition est associée à sa probabilité d'être empruntée et cette
probabilité peut éventuellement être nulle.
Voici la représentation d'un modèle de Markov simple avec 2 états :
Introduction aux HMM
Les HMM sont une extension des chaînes de Markov dans lesquelles les états réels du système ne sont
pas observables directement. Au lieu de cela, nous observons une séquence d'événements générés par
les états cachés du système. Les HMM sont couramment utilisés pour modéliser des séquences de
données où les états cachés représentent des variables latentes.
Pour comprendre, reprenons le modèle de Markov représenté plus haut et transformons le en modèle
de Markov caché :
Nous avons un HMM dont nous connaissons tous les paramètres (nombre d'états,
nombre d'observations, probabilités de départ, probabilités de transition et
probabilités d'émission) ainsi qu'une séquence d'observations de longeur T. Nous
nous demandons alors quelle était la séquence d'états génératrice. C'est la question
à laquelle nous souhaitons répondre dans le cadre de la reconnaissance vocale.
Cette question n'a pas qu'une seule réponse. Si le HMM étudié ne présente aucune
probabilité d'émission nulle, n'importe quelle séquence d'états de longeur T peut
générer n'importe quelle séquence d'observations de longeur T. Même avec
certaines probabilités d'émission nulles, il reste plusieurs réponses à cette question.
Puisqu'il y a plusieurs séquences d'états possibles pour une séquence d'observations
donnée, nous ne pouvons pas dire avec certitude laquelle a généré nos observations.
En revanche, puisque nous connaissons les paramètres du HMM, nous pouvons
dire quelle est la plus probable.
De façon naïve, nous pourrions encore écrire un algorithme qui parcourt toutes les
séquences d'états possibles en calculant la probabilité d'appartion de la séquence
d'observations, trouvant ainsi la séquence d'états qui a le plus probablement généré
notre séquence d'observations. Le problème est à nouveau la complexité : il y a
NT séquences d'états candidates (N états, T longeur de la séquence d'observations)
et donc une complexité en O(NT).
L'algorithme de Viterbi permet de trouver la solution avec une bien meilleure
complexité : O(N2T).
Étape 1 : Initialisation
L'algorithme commence par initialiser une matrice δ de taille T×N, où T est la longueur de la séquence
d'observations et N est le nombre d'états cachés du HMM. La valeur δ(t,i) représente la probabilité
maximale d'atteindre l'état i à l'instant t en suivant la meilleure séquence d'états jusqu'à cet instant.
Étape 2 : Calcul de la Probabilité Maximale
L'algorithme utilise une approche itérative pour calculer la probabilité maximale d'atteindre chaque
état à chaque instant. À chaque instant t, pour chaque état j, l'algorithme calcule δ(t+1,j), qui
représente la probabilité maximale d'atteindre l'état j à l'instant t+1 en suivant la meilleure séquence
d'états jusqu'à cet instant.
δ(t+1,j)=max1≤i≤N[δ(t,i)⋅aij]⋅bj(Ot+1)
Cette équation calcule la probabilité maximale d'atteindre l'état j à l'instant t+1 en considérant
toutes les transitions possibles de tous les états précédents vers l'état j, et en multipliant cette
probabilité par la probabilité d'observation Ot+1 à partir de l'état j.
Ψ(t+1,j)=argmax1≤i≤N[δ(t,i)⋅aij]
Cette équation détermine l'indice i de l'état précédent qui maximise la probabilité d'atteindre l'état j à
l'instant t+1, ce qui permet de reconstruire la séquence d'états optimale à la fin de l'algorithme.
Étape 4 : Terminaison
Une fois que les probabilités maximales ont été calculées pour tous les instants et tous les états, ainsi
que les indices des états précédents qui ont contribué à ces probabilités, l'algorithme sélectionne le
dernier état avec la probabilité maximale comme point de départ pour reconstruire la séquence d'états
optimale.
Étape 5 : Reconstruire la Séquence d'États Optimale
En utilisant la matrice Ψ, l'algorithme reconstruit la séquence d'états cachés la plus probable en suivant
les indices des états précédents à partir de l'état final sélectionné à l'étape de terminaison jusqu'au
début de la séquence.
Conclusion
L'algorithme de Viterbi fournit une méthode efficace pour trouver la séquence d'états cachés la plus
probable dans un HMM, ce qui est utile dans de nombreux domaines tel que la finance pour modéliser
des séquences de données et effectuer des prédictions.
Implémentation :
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
# Charger les données historiques des prix du Bitcoin depuis un fichier CSV
bitcoin_prices = pd.read_csv('historique_prix_bitcoin.csv')
# Supprimer les colonnes non pertinentes et convertir les prix en séries temporelles
bitcoin_prices = bitcoin_prices[['Date', 'Close']]
bitcoin_prices['Date'] = pd.to_datetime(bitcoin_prices['Date'])
bitcoin_prices.set_index('Date', inplace=True)
# Définir les états cachés du HMM (par exemple: bullish, bearish, stable)
states = ['bullish', 'bearish', 'stable']
# Générer des observations (peut être adapté selon votre besoin)
observations = bitcoin_prices['Close'].values
# Initialiser les probabilités de départ, les probabilités de transition et les probabilités d'émission
# Ces probabilités peuvent être initialisées ou estimées à partir des données historiques
start_probability = {'bullish': 0.3, 'bearish': 0.3, 'stable': 0.4}
transition_probability = {
'bullish': {'bullish': 0.7, 'bearish': 0.2, 'stable': 0.1},
'bearish': {'bullish': 0.3, 'bearish': 0.5, 'stable': 0.2},
'stable': {'bullish': 0.3, 'bearish': 0.3, 'stable': 0.4}
}
# Exemple d'utilisation de l'algorithme de Viterbi avec les données historiques des prix du Bitcoin
prob, path = viterbi(observations, states, start_probability, transition_probability, emission_probability)
Nous avons un HMM dont nous connaissons tous les paramètres (nombre d'états,
nombre d'observations, probabilités de départ, probabilités de transition et
probabilités d'émission) ainsi qu'une séquence d'observations de longeur T. Nous
nous demandons alors quelle est la probabilité d'apparition de cette séquence. Dans
le cas d'un HMM "entraîné" à reconnaître "quelque chose" (la langue d'un texte, par
exemple), c'est cette question que nous nous posons pour déterminer si "autre
chose" est du même type ou non.
De façon naïve, nous pourrions écrire un algorithme qui parcourt toutes les
séquences d'états possibles en calculant la probabilité d'apparition de la séquence
d'observations, puis additionnerait tous les résultats pour trouver la réponse à la
question. Le problème de cet algorithme est qu'il y a NT séquences d'états
candidates (N états, T longeur de la séquence d'observations), ce qui donnerait une
complexité en O(NT). Autant dire incalculable car T est souvent très grand.
/////////////////////////////////////////////NNNNAAAAAAAAAAAADDDDAaaaaaaaa/////
Étape 1 : Initialisation
α(t+1,j)=∑iα(t,i)⋅aij⋅bj(Ot+1)
Une fois que les probabilités d'observation partielle ont été calculées pour tous les
instants, l'algorithme calcule la probabilité d'observation totale en sommant les
probabilités d'observation partielle à l'instant final.
P(O|λ)=∑iα(T,i)
import numpy as np
T = len(observations)
N = len(states)
# Initialisation de la matrice alpha
for i in range(N):
for j in range(N):
prob_observation = sum(alpha[T-1])
# Exemple d'utilisation
```
Cette implémentation de l'algorithme de Forward calcule la probabilité totale
d'observation d'une séquence donnée et génère également la matrice alpha, qui
contient les probabilités d'observation partielle à chaque instant pour chaque état
caché.
Baum-Welch