Data Science 101 : Le Guide Complet pour le Trading

Pourquoi la Data Science en Trading ?

En 2026, la data est le carburant du trading moderne. Les hedge funds quantitatifs comme Two Sigma, Renaissance Technologies et Citadel ne sont pas des fonds d'investissement traditionnels : ce sont des entreprises de données qui font aussi du trading. Leur avantage compétitif repose sur la qualité, la vitesse et la profondeur de leurs pipelines de données.

Mais la révolution data ne concerne plus uniquement les institutionnels. Les outils qui coûtaient des millions de dollars par an sont désormais accessibles gratuitement aux traders retail. DuckDB, dbt, Grafana, Evidence — ces technologies open-source vous permettent de construire une infrastructure de données digne d'un hedge fund depuis votre ordinateur portable.

Qu'est-ce que la Data Science, exactement ?

Comment les meilleurs utilisent la data

Le paysage de la Data Science

La Data Science est un domaine vaste. Voici une cartographie des sous-domaines pertinents pour le trading :

Le Data Lake — Le Réservoir Brut

Le Data Lake est le point de départ de toute architecture data moderne. C'est un système de stockage qui accepte toutes les données, dans tous les formats, sans transformation préalable. Contrairement à un data warehouse qui impose un schéma rigide à l'écriture, le data lake stocke les données telles quelles et ne les structure qu'au moment de la lecture.

Data Lake vs Data Warehouse

Ces deux concepts sont souvent confondus. Voici les différences fondamentales :

Les formats de données en trading

Dans un data lake de trading, vous rencontrerez différents formats de fichiers. Chacun a ses avantages :

Technologies de Data Lake

Pour le trader retail

En pratique, votre "data lake" sera probablement un dossier de fichiers Parquet organisé par source et par date. Voici un exemple de structure :

data-lake/
├── market/
│   ├── daily/
│   │   ├── 2026-02-27_ohlcv.parquet
│   │   └── 2026-02-26_ohlcv.parquet
│   └── intraday/
│       └── 2026-02-27_15m.parquet
├── fundamentals/
│   ├── earnings_q4_2025.parquet
│   └── financials_annual.parquet
├── sentiment/
│   ├── reddit_wsb_2026-02-27.json
│   └── stocktwits_trending.json
├── sec/
│   ├── 10k_filings_2025.parquet
│   └── insider_transactions.parquet
└── news/
    └── 2026-02-27_reuters.json

Avec DuckDB, vous pouvez requêter ces fichiers directement en SQL sans les charger dans une base de données :

-- Requêter directement un fichier Parquet avec DuckDB
SELECT symbol, date, close, volume
FROM 'data-lake/market/daily/2026-02-27_ohlcv.parquet'
WHERE volume > 1000000
ORDER BY volume DESC
LIMIT 20;

L'Architecture Medallion (Bronze, Silver, Gold)

L'architecture Medallion, popularisée par Databricks, est le standard de facto pour organiser les données dans un data lake. Elle divise les données en trois couches de qualité croissante : Bronze (brut), Silver (nettoyé) et Gold (prêt à l'emploi).

Flux de la donnée : de Bronze à Gold

Exemple concret en trading

Pipeline Bronze → Silver en Python

# Pipeline Bronze → Silver pour les données OHLCV
import json
import pandas as pd
from pathlib import Path

def bronze_to_silver(bronze_path: str, silver_path: str):
    """Transforme les réponses JSON brutes en Parquet normalisé."""

    # 1. Lire le Bronze (JSON brut de l'API)
    with open(bronze_path) as f:
        raw = json.load(f)

    # 2. Extraire et normaliser
    records = []
    for item in raw['chart']['result']:
        symbol = item['meta']['symbol']
        timestamps = item['timestamp']
        quotes = item['indicators']['quote'][0]

        for i, ts in enumerate(timestamps):
            records.append({
                'symbol': symbol,
                'date': pd.Timestamp(ts, unit='s').date(),
                'open': round(quotes['open'][i], 2),
                'high': round(quotes['high'][i], 2),
                'low': round(quotes['low'][i], 2),
                'close': round(quotes['close'][i], 2),
                'volume': int(quotes['volume'][i] or 0),
            })

    # 3. Créer le DataFrame, dédupliquer, trier
    df = pd.DataFrame(records)
    df = df.drop_duplicates(subset=['symbol', 'date'])
    df = df.sort_values(['symbol', 'date'])

    # 4. Écrire en Parquet (Silver)
    df.to_parquet(silver_path, index=False)
    print(f"Silver: {len(df)} rows → {silver_path}")

Pipeline Silver → Gold en SQL (dbt)

-- models/gold/fct_daily_indicators.sql
-- Calcule les indicateurs techniques à partir du Silver

WITH daily AS (
    SELECT * FROM {{ ref('stg_daily_ohlcv') }}
),

with_indicators AS (
    SELECT
        symbol,
        date,
        close,
        volume,

        -- Moyenne mobile simple 20 jours
        AVG(close) OVER (
            PARTITION BY symbol
            ORDER BY date
            ROWS BETWEEN 19 PRECEDING AND CURRENT ROW
        ) AS sma_20,

        -- Moyenne mobile exponentielle approximée
        AVG(close) OVER (
            PARTITION BY symbol
            ORDER BY date
            ROWS BETWEEN 49 PRECEDING AND CURRENT ROW
        ) AS sma_50,

        -- Volume moyen 20 jours
        AVG(volume) OVER (
            PARTITION BY symbol
            ORDER BY date
            ROWS BETWEEN 19 PRECEDING AND CURRENT ROW
        ) AS avg_volume_20,

        -- Rendement quotidien
        (close - LAG(close) OVER (PARTITION BY symbol ORDER BY date))
        / NULLIF(LAG(close) OVER (PARTITION BY symbol ORDER BY date), 0)
        AS daily_return

    FROM daily
)

SELECT
    *,
    CASE WHEN close > sma_20 THEN 'above' ELSE 'below' END AS trend_sma20,
    CASE WHEN volume > avg_volume_20 * 2 THEN true ELSE false END AS volume_surge
FROM with_indicators

Le Star Schema et la Modélisation Dimensionnelle

La modélisation dimensionnelle, inventée par Ralph Kimball dans les années 1990, reste la méthode la plus utilisée pour organiser les données dans un data warehouse. Son concept central est le Star Schema (schéma en étoile) : une table de faits centrale entourée de tables de dimensions.

Les composants du Star Schema

Star Schema pour le trading

Exemple de tables

Table de faits : fct_daily_trades

Table de dimension : dim_instruments

Requête analytique exemple

-- P&L mensuel par secteur et par stratégie
SELECT
    d.month_name,
    i.sector,
    s.strategy_name,
    SUM(f.pnl) AS total_pnl,
    COUNT(*) AS nb_trades,
    ROUND(SUM(CASE WHEN f.pnl > 0 THEN 1 ELSE 0 END)::FLOAT / COUNT(*) * 100, 1) AS win_rate
FROM fct_daily_trades f
JOIN dim_dates d ON f.date_key = d.date_key
JOIN dim_instruments i ON f.instrument_key = i.instrument_key
JOIN dim_strategies s ON f.strategy_key = s.strategy_key
WHERE d.year = 2026
GROUP BY d.month_name, i.sector, s.strategy_name
ORDER BY total_pnl DESC;

Star Schema vs Snowflake Schema

Le Semantic Layer — La Couche de Sens

Le Semantic Layer (couche sémantique) est peut-être le concept le plus sous-estimé de la data science moderne. C'est une couche d'abstraction qui définit de manière unique et cohérente ce que signifient vos métriques. Quand quelqu'un demande "Quel est le Sharpe ratio de ma stratégie ?", le semantic layer garantit que tout le monde obtient la même réponse, calculée de la même manière, quelle que soit l'outil utilisé.

Avec vs Sans Semantic Layer

Technologies de Semantic Layer

Exemple : définir des métriques trading en dbt

# models/metrics/trading_metrics.yml
metrics:
  - name: sharpe_ratio
    label: "Sharpe Ratio (annualisé)"
    description: "Rendement ajusté du risque, annualisé sur 252 jours ouvrés"
    type: derived
    type_params:
      expr: "(avg_daily_return * 252) / (stddev_daily_return * sqrt(252))"
      metrics:
        - avg_daily_return
        - stddev_daily_return

  - name: max_drawdown
    label: "Max Drawdown"
    description: "Perte maximale depuis le pic le plus haut"
    type: derived
    type_params:
      expr: "min(drawdown_pct)"
      metrics:
        - drawdown_pct

  - name: win_rate
    label: "Win Rate (%)"
    description: "Pourcentage de trades profitables (excluant les trades flat)"
    type: ratio
    type_params:
      numerator: winning_trades_count
      denominator: total_trades_count
    filter: "pnl != 0"

Le Modern Data Stack (MDS)

Le Modern Data Stack (MDS) est une architecture modulaire où chaque composant est un outil spécialisé, interchangeable, et souvent open-source. Contrairement aux plateformes monolithiques d'antan (Informatica, Oracle Data Integrator), le MDS favorise le best-of-breed : choisissez le meilleur outil pour chaque fonction.

Les 7 couches du Modern Data Stack

Détail de chaque couche

1. Ingestion (Extract & Load)

La première étape consiste à récupérer les données de vos sources et à les charger dans votre warehouse. C'est le "EL" du pipeline ELT.

2. Stockage (Data Warehouse)

3. Transformation

4. Orchestration

5. Visualisation

Data Marts et Data Mesh

À mesure que votre architecture data grandit, vous aurez besoin d'organiser vos données Gold en sous-ensembles spécialisés. C'est le rôle des data marts et, à plus grande échelle, du data mesh.

Data Marts : des boutiques spécialisées

En trading, vous pourriez avoir ces data marts :

Structure dbt des data marts

models/
├── staging/          # Bronze → Silver (nettoyage)
│   ├── stg_yahoo_ohlcv.sql
│   ├── stg_sec_filings.sql
│   └── stg_reddit_posts.sql
├── intermediate/     # Silver → Silver (jointures, enrichissements)
│   ├── int_daily_with_indicators.sql
│   └── int_trades_enriched.sql
└── marts/            # Gold (data marts finaux)
    ├── performance/
    │   ├── fct_daily_pnl.sql
    │   ├── fct_strategy_metrics.sql
    │   └── dim_strategies.sql
    ├── risk/
    │   ├── fct_portfolio_var.sql
    │   ├── fct_correlation_matrix.sql
    │   └── fct_sector_exposure.sql
    ├── screener/
    │   ├── fct_daily_signals.sql
    │   ├── fct_composite_scores.sql
    │   └── fct_backtest_results.sql
    └── sentiment/
        ├── fct_daily_sentiment.sql
        └── fct_mention_volume.sql

Le Data Mesh : la décentralisation

Le Data Mesh est un paradigme architectural proposé par Zhamak Dehghani (Thoughtworks) en 2019. Il s'oppose à l'approche centralisée traditionnelle où une seule équipe data gère tout le pipeline.

Les Profils Data

L'écosystème data regroupe plusieurs métiers distincts. Comprendre ces rôles vous aidera à identifier quelles compétences développer pour votre stack de trading.

Les 5 profils clés

Matrice de compétences

Le profil en T

Le concept du profil en T (T-shaped) est particulièrement pertinent pour le trader data-driven :

Principes et Best Practices

Construire une infrastructure data fiable nécessite de respecter des principes fondamentaux. Voici les règles d'or du data engineering appliquées au trading.

Les 10 commandements de la data

Data Quality : les 4 dimensions

Best Practices vs Bad Practices

Les 5 péchés capitaux de la data

Application au Trading Retail

Maintenant que vous maîtrisez les concepts, voyons comment tout assembler en une architecture fonctionnelle pour le trading retail. Voici l'architecture que nous utilisons chez DailyTickers.

Architecture complète : du marché au signal

Le stack DailyTickers

Pipeline quotidien : de la donnée brute au signal

# Exemple simplifié du pipeline quotidien DailyTickers

# 1. INGESTION (6h00) — Bronze
# Le MCP Gateway collecte les données de marché
mcp_gateway.query(
    types="quote,bars_daily,technicals,sentiment_overall",
    symbols="SPY,QQQ,DIA,IWM,GLD,TLT,BTC-USD,ETH-USD"
)

# 2. TRANSFORMATION (6h15) — Silver → Gold
# dbt transforme les données brutes en indicateurs
# $ dbt run --models staging intermediate marts

# 3. SCREENING (6h30) — Signaux
# Le screener analyse les données Gold
auto_screener.run(
    regime_detection=True,
    strategies=["momentum", "breakout", "oversold", "squeeze"],
    min_score=85,
    top_k=10
)

# 4. PUBLICATION (7h00) — Briefing
# Claude génère le briefing quotidien
briefing = claude.generate(
    template="daily_briefing",
    data=market_data + screener_results + sentiment,
    lang="fr"
)

# 5. DÉPLOIEMENT
# GitHub Pages publie automatiquement
git.add("daily/20260227/index.html")
git.commit("daily: briefing 27 février 2026")
git.push()

Minimum Viable Data Stack (MVDS)

Vous n'avez pas besoin de tout cela pour commencer. Voici le stack minimum pour un trader retail data-driven :

Checklist : êtes-vous prêt ?

Ressources pour aller plus loin