A/B testi olulisuse kalkulaator

A/B testimine ühes minutis

Muutsite nuppu, pealkirja või kassavoogu. Versioon A on vana, versioon B on uus. B näeb paremini välja — see konverteeris 15% külastajaid võrreldes 10% A-ga. Aga kas see erinevus võib olla lihtsalt õnn, nagu müntide kümme käiku, millest saab seitse pead?

See kalkulaator vastab täpselt sellele küsimusele. Te sisestage, kui palju inimesi nägi iga versiooni ja kui palju neist konverteeris, ning see ütleb teile tõenäosuse, et mõõdetud erinevus on reaalne mitte juhuslik müra. Kui see tõenäosus on piisavalt kõrge, on teil võitja. Kui mitte, jätkate testi.

Arv, mille peale tuleb jälgida, on p-väärtus: tõenäosus näha sellist vahet kui kaks versiooni oleksid tegelikult identsed. Väike p-väärtus (näiteks alla 0,05) tähendab "see juhtuks harva õnne tõttu, seega erinevus on tõenäoliselt tegelik."

Kuidas seda kasutada

1. Külastajad — kui palju ainulaadseid inimesi näitas iga versiooni.
2. Konversioonid — kui palju neist tegi asja, millest te hoolisite (ostis, registreerus, klikis).
3. Usaldusnivoo — kui kindel soovite olla enne võitja kuulutamist. 95% on valdkonna standard.
4. Hüpotees — kahepoolne küsib "kas B erineb A-st?" (turvalisem, vaikimisi); ühepoolne küsib vaid "kas B on parem kui A?" (tundlikum, aga te peate suuna ette määrama).

Tulemus uueneb reaalajas ja sisendid salvestatakse lehe URL-sse, nii et saate tulemuse järjehoidjaks märkida või jagada. Lähtestamine kustutab vormi; Näidisandmete laadimine täidab läbitöötatud näite.

Tööläbi näide

See on 5 protsendipunkti absoluutne tõus ja +50% suhteline tõus. Kalkulaator tagastab p-väärtuse umbes 0,0007 — alla 0,05 — nii et 95% usaldusel on tulemus statistiliselt oluline. Ligikaudu, kui kaks versiooni oleksid tõepoolest identsed, näeksite seda suuruselt vahet vähem kui kord tuhandest testist.

Matemaatika (kahe proportiooni z-test)

Tegelikult on see standardne kahe proportiooni z-test, sama test, mida õpetatakse sissejuhatavates statistikakaartides ja mida kasutavad peamised A/B vahendid.

1. Konversiooni määr igast rühmast:

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

   kus $x$ on konversioonid ja $n$ on külastajad.

2. Ühendatud määr, eeldades (nullhüpoteesi jaoks) et mõlemad rühmad jagavad ühte tõelist määra:

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

3. Erinevuse standardviga:

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

4. Z-skoor — mitu standardveamist lahus on kaks määra:

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

5. P-väärtus tuleneb standardsest normaaljaotusest $\Phi$. Kahepoolne: $p = 2\left(1 - \Phi(|z|)\right)$. Ühepoolne: $p = 1 - \Phi(z)$.

6. Oluline kui $p < \alpha$, kus $\alpha = 1 - \text{usaldusnivoo}$ (seega 0,05 koht 95%).

Kalkulaator teatab ka usaldusvahemikku erinevuse jaoks, arvutatud ühendamata standardveaga $\sqrt{\tfrac{p_1(1-p_1)}{n_1} + \tfrac{p_2(1-p_2)}{n_2}}$: reaalne vahe tõenäoline vahemik. Kui see vahemik välistab 0, on tulemus oluline.

95% usaldusel on z ±1,96 väljaspool (varjutatud sabad, 5% piirkonnast) oluline.

Tulemuse aus lugemine

• Statistiline olulisus pole äriline olulisus. 0,1% tõus võib olla statistiliselt reaalne, kuid seda pole väärt teostada.
• Ärge vaadake ja seiskuge vara. P-väärtuse kontrollimine iga päev ja seiskamine hetkel, kui see langeb alla 0,05, paisutab valenegatiivsete määra. Otsustage valimi suurus ette ja laske testil lõpule jõuda.
• Jälgige valimi suuruse reeglit. Normaalne ligikaudne on usaldusväärne, kui igal rühmál on vähemalt ~10 konversiooni ja ~10 mittekonversiooni. Väikeste arvudega käsitlege tulemust vaid suundumuse jaoks.
• Usaldusnivoo ≠ tõenäosus B on parem. 95% usaldusnivoo tähendab protseduuri on vale kõige rohkem 5% ajast pikemas perspektiivis — see on sageduslik väide, mitte "95% võimalus B võidab."
• Üks test, üks mõõdik. Paljude mõõdikute või variantide testimine korraga korrutab juhuse võimaluse; paranda seda (nt Bonferroni) või registreeri ühik mõõdik, mis testi otsustab.

Arvutage see ise

Iga koodilõik arvutab kahepoolset p-väärtust ülaltoodud näitele.

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

KKK

Milline valimi suurus mul on vaja? Piisavalt, et tähenduslik tõus oleks tuvastatav. Alumise piirina sihtige vähemalt mitu sadat konversiooni variantona; kasutage spetsiaalset valimi suuruse kalkulaatorit teie algtasa ja väikseima tuvastatavas tõusus.

Kahepoolne või ühepoolne? Kasutage kahepoolseid kui teil pole kindlat, eelnevalt lubatud põhjust, et hooliksid ainult paranemisest. Ühepoolne kahekordistab teie tundlikkust, kuid keelustab B olemisel halvemat.

Miks kalkulaator näitab usaldusvahemikku? See näitab tõelise erinevuse tõenäolist vahemikku, mitte lihtsalt jah/ei verditkt. Lai vahemik, mis sirutub 0 tähendab "pole piisavalt andmeid veel."

Kas see on Bayesian? Ei — see on sageduslik z-test, kõige laialdasemalt õpetatud ja kasutatud meetod. Bayesi A/B vahendid teatavad "tõenäosus B alistab A" p-väärtuse asemel; mõlemad kehtivad, nad vastavad pisut erinevatele küsimustele.

Allikad

• 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