Analyse OHLCV Bitcoin à 5 secondes : notre premier notebook Kaggle
Analyse OHLCV Bitcoin à 5 secondes : notre premier notebook Kaggle
Aujourd’hui, nous avons créé notre premier notebook Kaggle pour l'analyse d'un historique de données du Bitcoin au format OHLCV en granularité 5 secondes.
Nous partageons le fonctionnement de notre code python pour vous présenter 3 points : Comment analyser les données historiques du Bitcoin OHLCV en granularité 5 secondes, comment vérifier la continuité des données, et comment visualiser efficacement le marché grâce à un notebook Kaggle dédié.
- Chargement des données historiques du Bitcoin OHLCV
- Vérification de la continuité des timestamps
- Visualisation du prix Bitcoin (Close)
- Graphique OHLC à haute fréquence
- Indicateurs SMA 50 et SMA 200
- Matrice de corrélation OHLCV
- les bonnes pratiques en Python, code clean..
Avant de commencé, vous pouvez retrouver les données historiques OHLCV du Bitcoin à cette adresse :
Kaggle - Données historiques du Bitcoin OHLCV
Et le lien vers le notebook :
Kaggle - Notebook
Petit préambule,
En python, pour travailler sur des données historiques au format CSV, nous utilisons deux librairies :
Pandas, pour manipuler et analyser des données facilement.
Matplotlib, pour afficher les données graphiquement,
Pour aller plus loin, des exemples pour ces librairies sont présentes :
Panda, retrouvez des exemples d'utilisations ici
MatPlotLib, les exemples se trouvent ici.
D'autres ressources sur Internet expliquent beaucoup mieux que moi la manière les possibilités de ces librairies. Bien que cela donne d'excellent résultat, je suis plutôt de la Team PowerBi pour la visualisation des données. Mais aujourd'hui, c'est Python !
On commence donc par le commencement,
1. Charger les données historiques OHLCV Bitcoin à 5 secondes
Le notebook commence par charger les données historiques du Bitcoin (BTC/USDT) au format CSV séparé par un point-virgule, avec les colonnes classiques OHLCV + QuoteVolume :
- Timestamp
- Open : Prix d'ouverture de la période
- High : Le prix le plus haut atteint durant la période
- Low : Le plus le plus bas atteint durant la période
- Close : Le prix de clôture
- Volume : La quantité d'actif échangée (crypto)
- QuoteVolume : La quantité total en USDT échangée
def main():
df = pd.read_csv(
"BTCUSDT_2025_01_01-07_avg5s.csv",
sep=';',
parse_dates=['Timestamp'])
print(df.head())
La fonction parse_dates convertit automatiquement les timestamps en objets datetime.
Notre fichier CSV est désormais chargé.
2. Vérification de la continuité des timestamps
Il est important de vérifier que la continuité des données est correcte lorsque l'on travaille avec des données historiques. Sans cela, les analyses, backtests ou modèles quantitatifs peuvent être faussés.
Dans notre code Python, nous avons créé une fonction utilisant la librairie pandas pour facilité cette recherche à partir du jeu de données :
def missingTimestamp(df):
df = df.sort_values('Timestamp')
expected_freq = pd.to_timedelta("5s")
actual_gaps = df['Timestamp'].diff().value_counts()
print()
print("Most common timestamp gaps:")
print(actual_gaps)
if len(actual_gaps) == 1 and actual_gaps.index[0] == expected_freq:
print("✅ Dataset is perfectly continuous at 5-second intervals.")
else:
print("⚠ Irregular gaps detected.")
Si tout ce passe bien, le résultat attendu devrait être le suivant : 
Dans notre cas :
👉 100 % des intervalles sont de 5 secondes
👉 Aucun trou, aucune anomalie
👉 Les données historiques sont parfaitement propres
3. Visualisation du prix Bitcoin (Close)
Nous avons affiché l’évolution du prix “Close” à intervalle 5 secondes grâce à Matplotlib dans notre fonction :
def visualizingPrice(df):
plt.plot(df['Timestamp'], df['Close'], linewidth=0.7)
plt.title("Bitcoin Close Price (5-Second Intervals)")
plt.xlabel("Time")
plt.ylabel("Price (USDT)")
plt.show()
Il suffit de remplacer "Close" par "Open", "High" ou "Low" dans la première ligne de la fonction pour afficher une autre donnée:
plt.plot(df['Timestamp'], df['Close'], linewidth=0.7)
Visualisation de l’évolution du prix “Close” à intervalle 5 secondes grâce à Matplotlib :
Ce graphique offre une première vue du marché à haute résolution (5s).
4. Visualisation OHLC (pseudo-candlestick)
Ensuite, nous avons représenté la structure OHLC sur les 2000 premières lignes à l’aide d’un shading High–Low et d’une ligne Close :
def candlestick(df):
sample = df.iloc[:2000].copy()
plt.plot(sample['Timestamp'], sample['Close'], label='Close', linewidth=0.7)
plt.fill_between(sample['Timestamp'], sample['Low'], sample['High'],
alpha=0.5, color='red', label='High-Low range')
plt.title("Bitcoin OHLC Visualization — First 2000 Intervals")
plt.xlabel("Time")
plt.ylabel("Price")
plt.legend()
plt.show()
Nous obtenons un joli graphique :
Ce type de visualisation est très utile pour :- repérer les zones de forte volatilité
- identifier les comportement de prix rapides
- visualiser l'évolution intra-structurelle du marché
À ce niveau de granularité, on obtient une vision quasi “microstructurelle”.
5. Moyennes mobiles : SMA 50 et SMA 200
Nous ajoutons ensuite deux indicateurs les plus utilisées en trading :
- SMA 50 pour les tendances rapides
- SMA 200 pour les tendances longues.
👉 Point particulier :
Les moyennes mobiles ici sont calculées directement sur des données à 5 secondes, ce qui n’est pas une pratique courante. Pour obtenir une vision moins bruitée et plus représentative des conditions réelles de marché (la plupart des traders expérimentés utilisent les SMA 50 et 200 sur des périodes plus larges), ces indicateurs sont généralement appliqués sur des bougies de plus grande durée.
Toutefois, la visualisation de moyennes mobiles sur des données à 5 secondes reste intéressante pour analyser la dynamique du prix en haute fréquence.
Notre fonction python :
def movingAverage(df):
sample = df.iloc[:2000].copy()
sample['SMA50'] = sample['Close'].rolling(50).mean()
sample['SMA200'] = sample['Close'].rolling(200).mean()
plt.plot(sample['Timestamp'], sample['Close'], linewidth=0.7, label='Close')
plt.plot(sample['Timestamp'], sample['SMA50'], label='SMA 50')
plt.plot(sample['Timestamp'], sample['SMA200'], label='SMA 200')
plt.legend()
plt.title("Close Price with Moving Averages")
plt.show()
sample['SMA50'] = sample['Close'].rolling(50).mean()
sample['SMA100'] = sample['Close'].rolling(100).mean()
sample['SMA150'] = sample['Close'].rolling(150).mean()
sample['SMA200'] = sample['Close'].rolling(200).mean()
plt.plot(sample['Timestamp'], sample['SMA50'], label='SMA 50')
plt.plot(sample['Timestamp'], sample['SMA100'], label='SMA 100')
plt.plot(sample['Timestamp'], sample['SMA150'], label='SMA 150')
plt.plot(sample['Timestamp'], sample['SMA200'], label='SMA 200')
Le graphique permet de visualiser les croisements, les tendances et les phases de consolidation.
C’est également un excellent point de départ pour développer un backtest simple (croisement SMA). Nous verrons dans un prochain article comment créer un backtest SMA croisée.
6. Matrice de corrélation OHLCV
Pour finir, nous calculons la matrice de corrélation :
def corrMatrix(df):
corr = df[['Open', 'High', 'Low', 'Close', 'Volume', 'QuoteVolume']].corr()
print()
print("Correlation matrix:")
print(corr)
Cette analyse permet de comprendre :
- les corrélations naturelles entre Open/Close
- l'impact du volume sur les mouvements
- si des patterns structurels apparaissent
- la relation entre volatilité et volume
C’est un premier pas vers une analyse quantitative plus poussée.
7. N'oublions pas les bonnes pratiques du Python
Comme pour les applications compilées, il est recommandé d’utiliser une fonction main() :
def main():
df = pd.read_csv(
"/kaggle/input/bitcoin-historical-data-ohlcv-5-second-interval/BTCUSDT_2025_01_01-07_avg5s.csv",
sep=';',
parse_dates=['Timestamp']
) print(df.head())
missingTimestamp(df)
candlestick(df)
movingAverage(df)
corrMatrix(df)
if __name__ == "__main__":
main()
import pandas as pd
import matplotlib.pyplot as plt
plt.rcParams['figure.figsize'] = (14, 7)
plt.rcParams['axes.grid'] = True
Conclusion
Ce premier notebook Kaggle montre à quel point les données haute fréquence peuvent être exploitées facilement pour :
- explorer la microstructure du marché
- comprendre la dynamique des prix
- développer des stratégies
- tester des modèles
- préparer des analyses quantitatives
Grâce au format OHLCV à 5 secondes, nous avons accès à une finesse rarement disponible publiquement. Idéal pour la réalisation de backtest de stratégies Grid ou Scalping sur cet historique de prix.
Merci pour votre lecture, à vos notebooks :)