Calculateur de significativité des tests A/B

Tests A/B en une minute

Vous avez changé un bouton, un titre ou un processus de paiement. La version A est l'ancienne, la version B est la nouvelle. B semble meilleure — elle a converti 15 % des visiteurs contre 10 % pour A. Mais cet écart pourrait-il simplement être une coïncidence, comme obtenir sept têtes sur dix lancers de pièce ?

Ce calculateur répond exactement à cette question. Vous entrez le nombre de personnes qui ont vu chaque version et le nombre qui ont converti, et il vous indique la probabilité que la différence mesurée soit réelle plutôt que du bruit aléatoire. Si cette probabilité est suffisamment élevée, vous avez un gagnant. Sinon, vous continuez le test.

Le seul nombre à surveiller est la p-value : la probabilité de voir un écart au moins aussi grand si les deux versions étaient réellement identiques. Une petite p-value (par exemple, inférieure à 0,05) signifie « cela se produirait rarement par chance, donc la différence est probablement réelle ».

Comment l'utiliser

1. Visiteurs — le nombre unique de personnes à qui chaque version a été présentée.
2. Conversions — combien d'entre eux ont fait ce qui vous importe (acheté, inscrit, cliqué).
3. Niveau de confiance — le degré de certitude avant de déclarer un gagnant. 95 % est la norme de l'industrie.
4. Hypothèse — bilatéral demande « B est-il différent de A ? » (plus sûr, par défaut) ; unilatéral demande seulement « B est-il meilleur que A ? » (plus sensible, mais vous devez décider la direction avant d'exécuter le test).

Le résultat se met à jour en temps réel et les entrées sont stockées dans l'URL de la page, vous pouvez donc marquer ou partager un résultat. Réinitialiser efface le formulaire ; Charger des données d'exemple remplit un exemple travaillé.

Un exemple travaillé

C'est une augmentation absolue de 5 points de pourcentage et une augmentation relative de +50 %. Le calculateur retourne une p-value d'environ 0,0007 — inférieure à 0,05 — donc avec une confiance de 95 % le résultat est statistiquement significatif. Grosso modo, si les deux versions étaient vraiment identiques, vous verriez un écart de cette taille moins d'une fois sur mille tests.

Les mathématiques (test z pour deux proportions)

Sous le capot, c'est le test z standard pour deux proportions, le même test enseigné dans les statistiques introductives et utilisé par les principaux outils A/B.

1. Taux de conversion de chaque groupe :

   $p_1 = \dfrac{x_1}{n_1}, \quad p_2 = \dfrac{x_2}{n_2}$

   où $x$ est conversions et $n$ est visiteurs.

2. Taux groupé, en supposant (pour l'hypothèse nulle) que les deux groupes partagent un seul taux vrai :

   $\hat{p} = \dfrac{x_1 + x_2}{n_1 + n_2}$

3. Erreur standard de la différence :

   $SE = \sqrt{\hat{p}\,(1-\hat{p})\left(\dfrac{1}{n_1} + \dfrac{1}{n_2}\right)}$

4. Le score z — combien d'erreurs standard séparent les deux taux :

   $z = \dfrac{p_2 - p_1}{SE}$

5. La p-value provient de la distribution normale standard $\Phi$. Bilatéral : $p = 2\left(1 - \Phi(|z|)\right)$. Unilatéral : $p = 1 - \Phi(z)$.

6. Significatif quand $p < \alpha$, où $\alpha = 1 - \text{confiance}$ (donc 0,05 à 95 %).

Le calculateur rapporte également un intervalle de confiance pour la différence, calculé avec l'erreur standard non groupée $\sqrt{\tfrac{p_1(1-p_1)}{n_1} + \tfrac{p_2(1-p_2)}{n_2}}$ : la plage plausible pour l'écart vrai. Si cet intervalle exclut 0, le résultat est significatif.

Avec une confiance de 95 %, un z au-delà de ±1,96 (les queues ombragées, 5 % de l'aire) compte comme significatif.

Lire le résultat honnêtement

• La significativité statistique n'est pas la significativité métier. Une augmentation de 0,1 % peut être statistiquement réelle mais ne vaut pas la peine de déployer.
• Ne regardez pas et n'arrêtez pas tôt. Vérifier la p-value chaque jour et arrêter le moment où elle tombe sous 0,05 gonfle votre taux de faux positifs. Décidez la taille d'échantillon à l'avance et laissez le test se terminer.
• Observez la règle du pouce sur la taille d'échantillon. L'approximation normale est fiable quand chaque groupe a au moins ~10 conversions et ~10 non-conversions. Avec de petits nombres, traitez le résultat comme directionnel uniquement.
• Confiance ≠ probabilité que B soit meilleur. Un niveau de confiance de 95 % signifie que la procédure est erronée au maximum 5 % du temps sur le long terme — c'est une affirmation fréquentiste, pas « 95 % de chance que B gagne ».
• Un test, une métrique. Tester plusieurs métriques ou variantes à la fois multiplie la chance d'une coïncidence ; corrigez-la (par exemple, Bonferroni) ou pré-enregistrez la seule métrique qui décide du test.

Calculez-le vous-même

Chaque snippet calcule la p-value bilatérale pour l'exemple travaillé ci-dessus.

1=2*(1-NORM.S.DIST(
2   (B2/A2 - B1/A1) /
3   SQRT(((B1+B2)/(A1+A2))*(1-(B1+B2)/(A1+A2))*(1/A1+1/A2)),
4   TRUE))
5' A1,B1 = control visitors, conversions ; A2,B2 = variation visitors, conversions
6

1from math import sqrt, erf
2
3def ab_pvalue(n1, x1, n2, x2, two_sided=True):
4    p1, p2 = x1 / n1, x2 / n2
5    p = (x1 + x2) / (n1 + n2)
6    se = sqrt(p * (1 - p) * (1 / n1 + 1 / n2))
7    z = (p2 - p1) / se
8    phi = lambda v: 0.5 * (1 + erf(v / sqrt(2)))   # standard normal CDF
9    return 2 * (1 - phi(abs(z))) if two_sided else 1 - phi(z)
10
11print(ab_pvalue(1000, 100, 1000, 150))  # ~0.00072
12

1// erf via Abramowitz & Stegun 7.1.26
2function erf(x) {
3  const s = x < 0 ? -1 : 1;
4  x = Math.abs(x);
5  const t = 1 / (1 + 0.3275911 * x);
6  const y = 1 - ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t
7            - 0.284496736) * t + 0.254829592) * t * Math.exp(-x * x);
8  return s * y;
9}
10const phi = z => 0.5 * (1 + erf(z / Math.SQRT2));
11
12function abPValue(n1, x1, n2, x2, twoSided = true) {
13  const p1 = x1 / n1, p2 = x2 / n2, p = (x1 + x2) / (n1 + n2);
14  const se = Math.sqrt(p * (1 - p) * (1 / n1 + 1 / n2));
15  const z = (p2 - p1) / se;
16  return twoSided ? 2 * (1 - phi(Math.abs(z))) : 1 - phi(z);
17}
18console.log(abPValue(1000, 100, 1000, 150)); // ~0.00072
19

1public static double abPValue(int n1, int x1, int n2, int x2) {
2    double p1 = (double) x1 / n1, p2 = (double) x2 / n2;
3    double p = (double) (x1 + x2) / (n1 + n2);
4    double se = Math.sqrt(p * (1 - p) * (1.0 / n1 + 1.0 / n2));
5    double z = (p2 - p1) / se;
6    // Phi via the error function; erf approximated (A&S 7.1.26) separately.
7    double phi = 0.5 * (1 + erf(Math.abs(z) / Math.sqrt(2)));
8    return 2 * (1 - phi);
9}
10

1static double AbPValue(int n1, int x1, int n2, int x2) {
2    double p1 = (double)x1 / n1, p2 = (double)x2 / n2;
3    double p  = (double)(x1 + x2) / (n1 + n2);
4    double se = Math.Sqrt(p * (1 - p) * (1.0 / n1 + 1.0 / n2));
5    double z  = (p2 - p1) / se;
6    double phi = 0.5 * (1 + Erf(Math.Abs(z) / Math.Sqrt(2)));
7    return 2 * (1 - phi);
8}
9

1#include <cmath>
2
3double ab_pvalue(int n1, int x1, int n2, int x2) {
4    double p1 = (double)x1 / n1, p2 = (double)x2 / n2;
5    double p  = (double)(x1 + x2) / (n1 + n2);
6    double se = std::sqrt(p * (1 - p) * (1.0 / n1 + 1.0 / n2));
7    double z  = (p2 - p1) / se;
8    double phi = 0.5 * (1 + std::erf(std::fabs(z) / std::sqrt(2.0)));
9    return 2 * (1 - phi);
10}
11

1import "math"
2
3func abPValue(n1, x1, n2, x2 float64) float64 {
4    p1, p2 := x1/n1, x2/n2
5    p := (x1 + x2) / (n1 + n2)
6    se := math.Sqrt(p * (1 - p) * (1/n1 + 1/n2))
7    z := (p2 - p1) / se
8    phi := 0.5 * (1 + math.Erf(math.Abs(z)/math.Sqrt2))
9    return 2 * (1 - phi)
10}
11

1// erf from the `libm` crate; std has no erf.
2fn ab_pvalue(n1: f64, x1: f64, n2: f64, x2: f64) -> f64 {
3    let (p1, p2) = (x1 / n1, x2 / n2);
4    let p = (x1 + x2) / (n1 + n2);
5    let se = (p * (1.0 - p) * (1.0 / n1 + 1.0 / n2)).sqrt();
6    let z = (p2 - p1) / se;
7    let phi = 0.5 * (1.0 + libm::erf(z.abs() / 2f64.sqrt()));
8    2.0 * (1.0 - phi)
9}
10

1function ab_pvalue($n1, $x1, $n2, $x2) {
2    $p1 = $x1 / $n1; $p2 = $x2 / $n2;
3    $p  = ($x1 + $x2) / ($n1 + $n2);
4    $se = sqrt($p * (1 - $p) * (1 / $n1 + 1 / $n2));
5    $z  = ($p2 - $p1) / $se;
6    $phi = 0.5 * (1 + erf(abs($z) / sqrt(2)));
7    return 2 * (1 - $phi);
8}
9

1def ab_pvalue(n1, x1, n2, x2)
2  p1, p2 = x1.to_f / n1, x2.to_f / n2
3  p  = (x1 + x2).to_f / (n1 + n2)
4  se = Math.sqrt(p * (1 - p) * (1.0 / n1 + 1.0 / n2))
5  z  = (p2 - p1) / se
6  phi = 0.5 * (1 + Math.erf(z.abs / Math.sqrt(2)))
7  2 * (1 - phi)
8end
9

1# R has this built in: prop.test does the whole thing.
2prop.test(c(100, 150), c(1000, 1000), correct = FALSE)$p.value  # ~0.00072
3

FAQ

De quelle taille d'échantillon ai-je besoin ? Assez pour qu'une augmentation significative soit détectable. En tant que plancher, visez au moins quelques centaines de conversions par variante ; utilisez un calculateur de taille d'échantillon dédié avec votre taux de base et l'augmentation minimale qui en vaut la peine.

Bilatéral ou unilatéral ? Utilisez bilatéral sauf si vous avez une raison ferme et pré-engagée de ne vous soucier que de l'amélioration. Unilatéral double votre sensibilité mais vous interdit de réagir si B est pire.

Pourquoi le calculateur affiche-t-il un intervalle de confiance ? Il affiche la plage plausible de la vraie différence, pas juste un verdict oui/non. Un intervalle large qui enjambe 0 signifie « pas assez de données pour le moment ».

Est-ce bayésien ? Non — c'est un test z fréquentiste, la méthode la plus largement enseignée et utilisée. Les outils A/B bayésiens rapportent « probabilité que B batte A » au lieu d'une p-value ; les deux sont valides, ils répondent à des questions légèrement différentes.

Sources

• Test Z pour deux proportions — Wikipedia
• Manuel électronique NIST/SEMATECH des méthodes statistiques — Comparaison de deux proportions
• Kohavi, Tang & Xu, Trustworthy Online Controlled Experiments (Cambridge, 2020)
• Comment VWO calcule la significativité statistique