Calculadora de Significació de Test A/B per a Resultats Ràpids

Proves A/B en un minut

Has canviat un botó, un titular o un flux de pagament. La versió A és l'antiga, la versió B és la nova. B sembla millor—va convertir el 15% de visitants enfront del 10% de A. Però podria aquest buit ser només sort, igual que llançar una moneda deu vegades pot donar set cares?

Aquesta calculadora respon exactament això. Introdueixes quants visitants va veure cada versió i quants es van convertir, i et diu la probabilitat que la diferència que has mesurat sigui real en lloc de soroll aleatori. Si aquesta probabilitat és prou alta, tens un guanyador. Si no, continua amb la prova.

L'únic número que has de vigilar és el p-valor: la probabilitat de veure una bretxa almenys tan gran si les dues versions fossin realment idèntiques. Un p-valor petit (per exemple, per sota de 0,05) significa "això rarament succeiria per sort, així que la diferència probablement és real."

Com utilitzar-ho

1. Visitants—quants visitants únics van veure cada versió.
2. Conversions—quants d'ells van fer la cosa que t'importa (van comprar, es van registrar, van fer clic).
3. Nivell de confiança—com de segur vols estar abans de trucar a un guanyador. El 95% és l'estàndard de la indústria.
4. Hipòtesi—bilateral pregunta "és B diferent de A?" (més segur, per defecte); unilateral només pregunta "és B millor que A?" (més sensible, però has de decidir la direcció abans d'executar la prova).

El resultat s'actualitza en temps real i els inputs s'emmagatzemen a l'URL de la pàgina, de manera que pots marcar com a preferit o compartir un resultat. Restablir neteja el formulari; Carregar dades de mostra omple un exemple treballat.

Un exemple treballat

Aquesta és una millora absoluta de 5 punts percentuals i una millora relative de +50%. La calculadora retorna un p-valor d'aproximadament 0,0007—inferior a 0,05—de manera que amb una confiança del 95% el resultat és estadísticament significatiu. En termes generals, si les dues versions eren veritablement idèntiques, hauríes de veure una bretxa tan gran menys d'una vegada en mil proves.

La matemàtica (prova z de dues proporcions)

Sota el capó, aquesta és la prova z de dues proporcions estàndard, la mateixa prova que s'ensenya en estadística introductòria i que utilitzen les eines A/B principals.

1. Taxa de conversió de cada grup:

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

   on $x$ és conversions i $n$ és visitants.

2. Taxa agrupada, assumint (per a la hipòtesi nul·la) que ambdós grups comparteixen una taxa veritable:

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

3. Error estàndard de la diferència:

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

4. La puntuació z—quants errors estàndard estan les dues taxes apart:

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

5. El p-valor prové de la distribució normal estàndard $\Phi$. Bilateral: $p = 2\left(1 - \Phi(|z|)\right)$. Unilateral: $p = 1 - \Phi(z)$.

6. Significatiu quan $p < \alpha$, on $\alpha = 1 - \text{confiança}$ (així que 0,05 al 95%).

La calculadora també informa d'un interval de confiança per a la diferència, calculat amb l'error estàndard no agrupat $\sqrt{\tfrac{p_1(1-p_1)}{n_1} + \tfrac{p_2(1-p_2)}{n_2}}$: el rang plausible per a la brecxa veritable. Si aquest interval exclou 0, el resultat és significatiu.

Al 95% de confiança, una z més allà de ±1,96 (les cues ombrejades, el 5% de l'àrea) compta com a significativa.

Llegir el resultat amb honestedat

• La significació estadística no és significació empresarial. Un ascens del 0,1% pot ser estadísticament real però no mereix la pena d'implementar.
• No espiïs i no pares aviat. Comprovar el p-valor cada dia i parar quan cau per sota de 0,05 infla la taxa de fals positius. Decideix la mida de la mostra per avançat i deixa que la prova es completi.
• Vigila la regla de thumb de la mida de la mostra. L'aproximació normal és fiable quan cada grup té almenys ~10 conversions i ~10 no-conversions. Amb nombres petits, tracta el resultat com només direccional.
• Confiança ≠ probabilitat que B sigui millor. Un nivell de confiança del 95% significa que el procediment és incorrecte com a màxim el 5% de les vegades a llarg termini—és una afirmació freqüentista, no "95% de probabilitat que B guanyi."
• Una prova, una mètrica. Provar moltes mètriques o variants alhora multiplica la probabilitat d'una coincidència; corregeix-ho (p. ex. Bonferroni) o pre-registra la mètrica única que decideix la prova.

Calcula-ho tu mateix

Cada fragment calcula el p-valor bilateral per a l'exemple treballat anterior.

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

Preguntes Freqüents

Quina mida de mostra necessito? Prou perquè una millora significativa seria detectable. Com a mínim, apunta a almenys alguns centenars de conversions per variant; utilitza una calculadora dedicada de mida de mostra amb la teva taxa base i l'ascens més petit que val la pena detectar.

Bilateral o unilateral? Utilitza bilateral tret que tinguis una raó fermament pre-compromesa per només preocupar-te per millorar. Unilateral duplica la teva sensibilitat però prohibeix reaccionar si B és pitjor.

Per què la calculadora mostra un interval de confiança? Mostra el rang plausible de la veritable diferència, no només un veredicte sí/no. Un interval ampl que travessa 0 significa "encara no hi ha prou dades."

Això és Bayesià? No—és una prova z freqüentista, el mètode més àmpliament ensenyat i utilitzat. Les eines A/B Bayesianes informen de "probabilitat que B guanyi A" en lloc d'un p-valor; tots dos són vàlids, responen preguntes lleugerament diferents.

Fonts

• Two-proportion Z-test — Wikipedia
• NIST/SEMATECH e-Handbook of Statistical Methods — Comparing two proportions
• Kohavi, Tang & Xu, Trustworthy Online Controlled Experiments (Cambridge, 2020)
• How VWO calculates statistical significance