A/B-test signifikansberegner

Q: Hvilken stikprøvestørrelse har jeg brug for?

Nok til at et meningsfuldt løft ville være påviseligt. Som minimum, sigte på mindst et par hundrede konverteringer pr. variant; brug en dedikeret stikprøvestørrelse-beregner med din baseline-rate og det mindste løft værd at opdage.

Q: To-sidet eller en-sidet?

Brug to-sidet medmindre du har en fast, forudgående grund til kun at bekymre dig om forbedring. En-sidet fordobler din følsomhed, men forbyder at reagere på B værende værre.

Q: Hvorfor viser beregneren et konfidensinterval?

Det viser det plausible område for den sande forskel, ikke bare et ja/nej-dom. Et bredt interval, der strider mod 0, betyder "ikke nok data endnu."

Q: Er dette Bayesiansk?

Nej — det er en frequentist z-test, den mest bredt undervist og brugt metode. Bayesianske A/B-værktøjer rapporterer "sandsynlighed B slår A" i stedet for en p-værdi; begge er gyldige, de besvarer lidt forskellige spørgsmål.

A/B-test på et minut

Du ændrede en knap, en overskrift eller en checkout-flow. Version A er den gamle, version B er den nye. B ser bedre ud — den konverterede 15% af besøgende mod 10% for A. Men kunne det gap bare være held, på samme måde som at slå mønt ti gange kan give syv plat?

Denne beregner besvarer præcis det. Du angiver, hvor mange mennesker der så hver version, og hvor mange der konverterede, og den fortæller dig sandsynligheden for, at den forskel, du målte, er reel snarere end tilfældig støj. Hvis denne sandsynlighed er høj nok, har du en vinder. Hvis ikke, fortsætter du testen.

Det ene tal at holde øje med er p-værdien: chancen for at se et gap mindst så stort hvis de to versioner faktisk var identiske. En lille p-værdi (f.eks. under 0,05) betyder "dette ville sjældent ske ved held, så forskellen er sandsynligvis reel."

Sådan bruges den

Besøgende — hvor mange unikke mennesker der blev vist hver version.
Konverteringer — hvor mange af dem gjorde det, du ønsker (købte, tilmeldte sig, klikked).
Konfidensniveau — hvor sikker du vil være, før du erklærer en vinder. 95% er industristandarden.
Hypotese — to-sidet spørger "er B forskellig fra A?" (sikrer, standard); en-sidet spørger kun "er B bedre end A?" (mere følsom, men du skal beslutte retningen før testen).

Resultatet opdateres live, og inputs lagres i side-URL'en, så du kan bogmærke eller dele et resultat. Nulstil rydder formularen; Indlæs eksempeldata udfylder et gennemarbejdet eksempel.

Et gennemarbejdet eksempel

	Besøgende	Konverteringer	Rate
A (kontrol)	1.000	100	10,0%
B (variation)	1.000	150	15,0%

Det er et løft på 5 procentpoint absolut og et +50% relativt løft. Beregneren returnerer en p-værdi på omkring 0,0007 — under 0,05 — så med 95% tillid er resultatet statistisk signifikant. Cirka, hvis de to versioner var virkelig identiske, ville du se et gap af denne størrelse mindre end én gang i tusinde tests.

Matematikken (to-proportions z-test)

Under hætten er dette standard to-proportions z-test, samme test undervist i introduktionsstatistik og brugt af mainstream A/B-værktøjer.

Konverteringsrate for hver gruppe:

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

hvor $x$ er konverteringer og $n$ er besøgende.
Pooled rate, der antager (for nulhypotesen), at begge grupper deler én sand rate:

$\hat{p} = \dfrac{x_1 + x_2}{n_1 + n_2}$
Standardfejl af forskellen:

$SE = \sqrt{\hat{p}\,(1-\hat{p})\left(\dfrac{1}{n_1} + \dfrac{1}{n_2}\right)}$
Z-score'en — hvor mange standardfejl fra hinanden de to rater er:

$z = \dfrac{p_2 - p_1}{SE}$
P-værdien kommer fra standardnormalfordelingen $\Phi$ . To-sidet: $p = 2\left(1 - \Phi(|z|)\right)$ . En-sidet: $p = 1 - \Phi(z)$ .
Signifikant når $p < \alpha$ , hvor $\alpha = 1 - \text{confidence}$ (så 0,05 ved 95%).

Beregneren rapporterer også et konfidensinterval for forskellen, beregnet med usamlet standardfejl $\sqrt{\tfrac{p_1(1-p_1)}{n_1} + \tfrac{p_2(1-p_2)}{n_2}}$ : det plausible område for det sande gap. Hvis det interval udelukker 0, er resultatet signifikant.

Ved 95% tillit tæller en z ud over ±1,96 (de skraverede haler, 5% af området) som signifikant.

Læs resultatet ærligt

Statistisk signifikans er ikke forretningssignifikans. Et 0,1% løft kan være statistisk reelt, men ikke værd at udrulles.
Kig ikke og stop tidligt. At kontrollere p-værdien hver dag og stoppe i det øjeblik, den dykker under 0,05, oppusterkassen din falsk-positive rate. Beslut stikprøvestørrelse på forhånd og lad testen afsluttes.
Se stikprøvestørrelse tommelfingerregel. Normalapproksimationen er pålidelig, når hver gruppe har mindst ~10 konverteringer og ~10 ikke-konverteringer. Med små tal, behandl resultatet som retningsgivende kun.
Tillid ≠ sandsynlighed B er bedre. Et 95% konfidensniveau betyder proceduren er forkert højst 5% af tiden i det lange løb — det er en frequentist-erklæring, ikke "95% chance B vinder."
En test, en metrik. Test af mange metrikker eller varianter på én gang multiplicerer chancen for en tilfældighed; korriger for det (f.eks. Bonferroni) eller forhåndsregistrer den eneste metrik, der afgør testen.

Beregn det selv

Hvert snippet beregner to-sidet p-værdi for det gennemarbejdet eksempel ovenfor.

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

Hvilken stikprøvestørrelse har jeg brug for? Nok til at et meningsfuldt løft ville være påviseligt. Som minimum, sigte på mindst et par hundrede konverteringer pr. variant; brug en dedikeret stikprøvestørrelse-beregner med din baseline-rate og det mindste løft værd at opdage.

To-sidet eller en-sidet? Brug to-sidet medmindre du har en fast, forudgående grund til kun at bekymre dig om forbedring. En-sidet fordobler din følsomhed, men forbyder at reagere på B værende værre.

Hvorfor viser beregneren et konfidensinterval? Det viser det plausible område for den sande forskel, ikke bare et ja/nej-dom. Et bredt interval, der strider mod 0, betyder "ikke nok data endnu."

Er dette Bayesiansk? Nej — det er en frequentist z-test, den mest bredt undervist og brugt metode. Bayesianske A/B-værktøjer rapporterer "sandsynlighed B slår A" i stedet for en p-værdi; begge er gyldige, de besvarer lidt forskellige spørgsmål.

A/B-test signifikansberegner