import numpy as np

a = np.arange(12, dtype=np.float64).reshape(3, 4)
a.shape        # (3, 4)     la forme logique
a.dtype        # float64    le type, identique pour TOUS les éléments
a.strides      # (32, 8)    combien d'octets sauter pour avancer d'un cran…
               #            …sur l'axe 0 (une ligne = 4 × 8 octets) et sur l'axe 1
a.nbytes       # 96         la mémoire réellement occupée
a.flags        # C_CONTIGUOUS : les lignes sont contiguës en mémoire

b = a.T              # transposée
b.strides            # (8, 32) — les strides sont inversés, les données inchangées
b.base is a          # True : b n'est qu'une nouvelle VUE sur la mémoire de a
np.shares_memory(a, b)   # True

x = np.arange(10)

v = x[2:5]          # VUE : aucune donnée copiée
v[0] = 999
x[2]                # 999  → x a été modifié sans qu'on l'ait touché

c = x[[2, 3, 4]]    # COPIE (indexation par liste d'indices)
c[0] = -1
x[2]                # 999  → x est intact

m = x[x > 5]        # COPIE (masque booléen)

np.shares_memory(x, v)   # True
np.shares_memory(x, c)   # False

  X        (1000, 50)          X       (1000, 50)         X      (3, 1)
  mu             (50,)   ✓     poids  (1000,)      ✗      Y         (4,)   ✓
  ─────────────────────        ────────────────────       ──────────────────
  résultat (1000, 50)          ERREUR : 50 ≠ 1000         résultat (3, 4)
                               → il faut poids[:, None]        (produit externe)

X = np.random.randn(1000, 50)
mu = X.mean(axis=0)                # (50,)  une moyenne par colonne
Xc = X - mu                        # broadcasting : mu n'est PAS dupliquée 1000 fois

# centrer par LIGNE demande d'ajouter explicitement l'axe manquant
moy_ligne = X.mean(axis=1)         # (1000,)
Xc = X - moy_ligne[:, None]        # (1000,1) contre (1000,50) → compatible
# X - moy_ligne lèverait une erreur : (50,) et (1000,) ne s'alignent pas

x = np.random.randn(1_000_000)

# ≈ 400 ms : un million de tours d'interpréteur
out = np.array([v ** 2 + 3 * v if v > 0 else 0.0 for v in x])

# ≈ 4 ms : une seule descente dans le code compilé
out = np.where(x > 0, x ** 2 + 3 * x, 0.0)

# agrégations par axe
X.sum(axis=0)          # somme par colonne        X.mean(axis=1)   # moyenne par ligne
X.argmax(axis=1)       # indice du maximum        np.percentile(X, 95, axis=0)

# sélection et conditions
np.where(cond, a, b)   np.clip(x, 0, 1)   np.select([c1, c2], [v1, v2], defaut)

# einsum : produits et contractions, sans reshape acrobatique
np.einsum("ij,jk->ik", A, B)        # produit matriciel classique
np.einsum("ij,ij->i", A, B)         # produit scalaire ligne à ligne
np.einsum("ii->", A)                # trace

# opérations "sur place" : évitent une allocation (utile sur de gros tableaux)
np.multiply(X, 2, out=X)            # équivalent de X *= 2

# quand l'algorithme est SÉQUENTIEL et ne se vectorise pas : Numba compile la boucle
from numba import njit
@njit                                # décorateur (module 1) : compilation à la volée
def recurrence(x, alpha):
    y = np.empty_like(x)
    y[0] = x[0]
    for i in range(1, len(x)):       # boucle Python… compilée en code machine
        y[i] = alpha * x[i] + (1 - alpha) * y[i - 1]
    return y

a = pd.Series([1, 2, 3], index=["x", "y", "z"])
b = pd.Series([10, 20, 30], index=["z", "y", "x"])
a + b        # x: 31, y: 22, z: 13  → aligné par étiquette, pas par position

import pandas as pd

df = (
    pd.read_parquet("data/commandes.parquet")
      .assign(                                    # créer des colonnes
          date=lambda d: pd.to_datetime(d["date"]),
          marge=lambda d: d["prix"] - d["cout"],
      )
      .query("marge > 0")                         # filtrer
      .astype({"categorie": "category"})          # mémoire ÷ 10 sur du texte répété
      .sort_values("date")
)

  DataFrame          SPLIT               APPLY              COMBINE
  cat  val      cat=A : [10, 30]      A : mean = 20      cat   val
  A    10       cat=B : [20]          B : mean = 20      A     20
  B    20       cat=C : [5, 15]       C : mean = 10      B     20
  A    30                                                 C     10
  C     5
  C    15

stats = (
    df.groupby(["categorie", pd.Grouper(key="date", freq="ME")])   # ME = fin de mois
      .agg(ca=("prix", "sum"), n=("prix", "size"), marge_moy=("marge", "mean"))
      .reset_index()
)

# transform : renvoie un résultat de MÊME TAILLE que l'entrée (comme une fonction
# de fenêtre SQL, module 4) — indispensable pour normaliser par groupe
df["ecart_a_la_moyenne"] = df["prix"] - df.groupby("categorie")["prix"].transform("mean")

import polars as pl

q = (
    pl.scan_parquet("data/commandes_*.parquet")    # scan_ : rien n'est lu pour l'instant
      .filter(pl.col("date") >= pl.date(2025, 1, 1))
      .with_columns(marge=pl.col("prix") - pl.col("cout"))
      .group_by("categorie")
      .agg(
          ca=pl.col("prix").sum(),
          marge_moy=pl.col("marge").mean(),
          n=pl.len(),
      )
      .sort("ca", descending=True)
)

print(q.explain())      # le plan optimisé, comme un EXPLAIN SQL (module 4)
df = q.collect()        # ICI seulement, le calcul a lieu
df = q.collect(streaming=True)    # par morceaux, pour un volume > RAM

import dask.dataframe as dd

ddf = dd.read_parquet("s3://bucket/annee=2025/*.parquet")   # graphe, rien n'est chargé
resultat = ddf[ddf.montant > 0].groupby("client_id").montant.sum()
out = resultat.compute()          # déclenche le calcul, renvoie une Series pandas

Volume            Outil recommandé                    Remarque
──────────────────────────────────────────────────────────────────────────────
< 1 Go            pandas ou polars                    tout tient en RAM
1 – 50 Go         polars (lazy) ou DuckDB             la RAM d'une machine moderne
                                                       suffit encore largement
50 – 500 Go       polars streaming, DuckDB, Dask      une grosse machine coûte souvent
                                                       moins cher qu'un cluster mal utilisé
> 500 Go          Spark, Dask sur cluster             la complexité devient justifiée
Tableaux denses   NumPy (+ Numba)                     calcul numérique pur
GPU               PyTorch, CuPy, cuDF                 si le calcul est massivement
                                                       parallèle

from sklearn.compose import ColumnTransformer
from sklearn.ensemble import HistGradientBoostingRegressor
from sklearn.impute import SimpleImputer
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import Pipeline, make_pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler

num = ["surface", "n_pieces", "age"]
cat = ["ville", "type_bien"]

pre = ColumnTransformer([
    # chaque groupe de colonnes reçoit son propre traitement
    ("num", make_pipeline(SimpleImputer(strategy="median"), StandardScaler()), num),
    ("cat", OneHotEncoder(handle_unknown="ignore", min_frequency=20), cat),
])

modele = Pipeline([
    ("pre", pre),
    ("gbm", HistGradientBoostingRegressor(max_iter=400, learning_rate=0.05)),
])

scores = cross_val_score(modele, X, y, cv=5, scoring="neg_root_mean_squared_error")
print(f"RMSE = {-scores.mean():.3f} ± {scores.std():.3f}")

from sklearn.base import BaseEstimator, TransformerMixin

class ClipOutliers(BaseEstimator, TransformerMixin):
    """Écrête aux quantiles appris SUR LE TRAIN uniquement."""

    def __init__(self, q=0.01):
        self.q = q                        # hyperparamètre : attribut simple, même nom

    def fit(self, X, y=None):
        self.lo_ = np.quantile(X, self.q, axis=0)      # paramètres APPRIS : tiret bas
        self.hi_ = np.quantile(X, 1 - self.q, axis=0)
        return self                       # fit renvoie toujours self

    def transform(self, X):
        return np.clip(X, self.lo_, self.hi_)

import torch

x = torch.tensor([3.0], requires_grad=True)   # "je veux le gradient par rapport à x"
y = x ** 2 + 5 * x                            # PyTorch enregistre : carré, produit, somme

y.backward()                                  # remonte le graphe
print(x.grad)                                 # tensor([11.]) = 2x + 5 en x = 3  ✓

import torch, torch.nn as nn

device = "cuda" if torch.cuda.is_available() else "cpu"

modele = nn.Sequential(                       # un perceptron multicouche (module 16)
    nn.Linear(10, 64), nn.ReLU(),
    nn.Linear(64, 1),
).to(device)

perte_fn = nn.MSELoss()
opt = torch.optim.AdamW(modele.parameters(), lr=1e-3)

for epoque in range(100):
    for xb, yb in chargeur:                   # mini-lots (module 8)
        xb, yb = xb.to(device), yb.to(device)

        opt.zero_grad(set_to_none=True)       # 1. REMETTRE LES GRADIENTS À ZÉRO
        pred = modele(xb)                     # 2. passe avant
        perte = perte_fn(pred, yb)            # 3. calcul de la perte
        perte.backward()                      # 4. passe arrière : remplit les .grad
        opt.step()                            # 5. mise à jour des poids

    modele.eval()                             # bascule en mode évaluation (dropout off)
    with torch.no_grad():                     # pas de graphe : plus rapide, moins de mémoire
        val = sum(perte_fn(modele(x.to(device)), y.to(device)) for x, y in val_loader)
    modele.train()

PyTorch        impératif, déboguable au pdb, domine la recherche. Le défaut aujourd'hui.
               torch.compile compile le graphe à la volée : confort ET performance.
TensorFlow     encore présent en production, écosystème mobile mûr (TFLite). À apprendre
               si l'existant de l'équipe l'impose.
JAX            fonctions pures et transformations composables (grad, vmap, jit).
               Très utilisé en recherche scientifique et en calcul différentiable.
BoTorch        construit sur PyTorch, pour l'optimisation bayésienne (module 19) :
               optimiser un système dont chaque évaluation coûte cher.