A/B testa nozīmīguma kalkulators

Q: Kāds izlases lielums man nepieciešams?

Pietiekami, lai nozīmīgu pieaugumu varētu atklāt. Kā stāvokli, censieties vismaz dažas simtus konversiju uz variantu; izmantojiet īpašu izlases lieluma kalkulatoru ar jūsu bāzes likmi un mazāko pieaugumu, kas vērts atklāt.

Q: Divpusēja vai vienpusēja?

Izmantojiet divpusēju, ja vien jums nav stingras, iepriekš saistītas iemesles, lai rūpētos tikai par uzlabojumiem. Vienpusēja divkāršo jūsu jutību, bet aizliedz reaģēt uz B būšanu sliktāku.

Q: Kāpēc kalkulators parāda ticamības intervālu?

Tas parāda patiesās atšķirības ticamo diapazonu, nevis tikai jā/nē spriedumu. Plats intervāls, kas krusto 0, nozīmē "vēl nav pietiekami daudz datu."

Q: Vai tā ir Bajesiana?

Nē — tā ir frekventista z-tests, visplašāk pasniegstais un izmantotais paņēmiens. Bajesiana A/B rīki ziņo "varbūtība, ka B uzvar A" vietā p-vērtības; abi ir derīgi, viņi atbild uz nedaudz atšķirīgiem jautājumiem.

A/B testēšana vienas minūtes laikā

Jūs mainījāt pogu, virsrakstu vai norēķināšanās plūsmu. Versija A ir vecā, versija B ir jaunā. B izskatās labāka — tā konvertēja 15% apmeklētāju pret 10% A variantam. Bet vai šī atšķirība vienkārši tikai veiksme, tāpat kā monētas mešana desmit reizes var dot septiņus ģerbonīcas?

Šis kalkulators atbild tieši uz šo jautājumu. Jūs ievadāt, cik cilvēku redzēja katru versiju un cik no viņiem konvertēja, un tas norāda varbūtību, ka izmērītā atšķirība ir reāla nevis nejaušs troksnis. Ja šī varbūtība ir pietiekami liela, jūs esat atraduši uzvarētāju. Ja nē, turpiniet testa izpildi.

Viens skaitlis, uz kuru jākoncentrējas, ir p-vērtība: varbūtība redzēt atšķirību vismaz šāda lieluma ja abas versijas būtu faktiski identiskas. Maza p-vērtība (piemēram, zem 0,05) nozīmē "tas reti notiktu pēc nejaušības, tāpēc atšķirība ir droši vien reāla."

Kā to izmantot

Apmeklētāji — cik daudz unikālu cilvēku tika parādīta katra versija.
Konversijas — cik no viņiem izdarīja darbību, par kuru jums ir rūpe (nopirka, pierakstījās, noklikšķināja).
Ticamības līmenis — cik drošs vēlaties būt pirms uzvarētāja paziņošanas. 95% ir nozares standarts.
Hipotēze — divpusēja jautā "vai B atšķiras no A?" (drošāka, noklusējums); vienpusēja jautā tikai "vai B ir labāka par A?" (jutīgāka, bet jums jāizlemj virziens pirms testa sākuma).

Rezultāts atjauninās tiešraidē un ievadi tiek saglabāti lapas URL, tāpēc varat grāmatzīmēt vai dalīties ar rezultātu. Atiestatīt notīra formu; Ielādēt parauga datus aizpilda apstrādātu piemēru.

Apstrādāts piemērs

	Apmeklētāji	Konversijas	Likme
A (kontrole)	1 000	100	10,0%
B (variācija)	1 000	150	15,0%

Tā ir 5 procentpunktu absolūts pieaugums un +50% relatīvs pieaugums. Kalkulators atgriež p-vērtību aptuveni 0,0007 — zem 0,05 — tātad ar 95% ticamības līmeni rezultāts ir statistiski nozīmīgs. Aptuveni, ja abas versijas būtu patiešām identiskas, jūs redzētu šādu atšķirību mazāk kā vienu reizi uz tūkstošiem testiem.

Matemātika (divu proporciju z-tests)

Zem pārsega šis ir standarta divu proporciju z-tests, tas pats tests, ko māca ievadniecības statistikā un ko lieto galvenie A/B rīki.

Konversijas likme katrai grupai:

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

kur $x$ ir konversijas un $n$ ir apmeklētāji.
Kombinētā likme, pieņemot (nulles hipotēzei), ka abas grupas dala vienu patiesu likmi:

$\hat{p} = \dfrac{x_1 + x_2}{n_1 + n_2}$
Standarta kļūda atšķirībai:

$SE = \sqrt{\hat{p}\,(1-\hat{p})\left(\dfrac{1}{n_1} + \dfrac{1}{n_2}\right)}$
Z-rādītājs — cik standarta kļūdu ir atdalītas divas likmes:

$z = \dfrac{p_2 - p_1}{SE}$
p-vērtība nāk no standarta normālā sadalījuma $\Phi$ . Divpusēja: $p = 2\left(1 - \Phi(|z|)\right)$ . Vienpusēja: $p = 1 - \Phi(z)$ .
Nozīmīga kad $p < \alpha$ , kur $\alpha = 1 - \text{ticamības līmenis}$ (tātad 0,05 pie 95%).

Kalkulators arī ziņo par ticamības intervālu atšķirībai, aprēķinātu ar nekombinēto standarta kļūdu $\sqrt{\tfrac{p_1(1-p_1)}{n_1} + \tfrac{p_2(1-p_2)}{n_2}}$ : ticamais diapazons patiesajai atšķirībai. Ja šis intervāls izslēdz 0, rezultāts ir nozīmīgs.

Ar 95% ticamības līmeni, z pārsniedzot ±1,96 (ēnotie asteles, 5% no platības) uzskatās par nozīmīgu.

Rezultāta godīga nolasīšana

Statistiskā nozīmīguma nav biznesa nozīmīgums. 0,1% pieaugums var būt statistiski reāls, bet ne vērts izdot.
Nepieķeries un nestopies agri. P-vērtības pārbaude katru dienu un apstāšanās brīdī, kad tā nokrīt zem 0,05, palielina jūsu viltus-pozitīvu rādītāju. Nolemiet izlases lielumu iepriekš un ļaujiet testam pabeigties.
Pārraugiet izlases lieluma vudu noteikumu. Normālais tuvinājums ir uzticams, kad katrā grupā ir vismaz ~10 konversiju un ~10 nekonversiju. Ar mazu skaitļu skaitu, uzskatiet rezultātu tikai par virziena norādi.
Ticamības līmenis ≠ varbūtība, ka B ir labāka. 95% ticamības līmenis nozīmē, ka procedūra ir nepareiza vairāk kā 5% laika garumā — tā ir frekventista apgalvojums, nevis "95% iespēja, ka B uzvar."
Viens tests, viena metrika. Daudzu metrikas vai variantu vienlaicīga testēšana reizina nejaušības iespēju; koriģējiet to (piemēram, Bonferroni) vai iepriekš reģistrējiet vienu metriku, kas nolemj testu.

Aprēķiniet to pats

Katrs fragments aprēķina divpusējo p-vērtību iepriekš minētajam piemēram.

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

BUJ

Kāds izlases lielums man nepieciešams? Pietiekami, lai nozīmīgu pieaugumu varētu atklāt. Kā stāvokli, censieties vismaz dažas simtus konversiju uz variantu; izmantojiet īpašu izlases lieluma kalkulatoru ar jūsu bāzes likmi un mazāko pieaugumu, kas vērts atklāt.

Divpusēja vai vienpusēja? Izmantojiet divpusēju, ja vien jums nav stingras, iepriekš saistītas iemesles, lai rūpētos tikai par uzlabojumiem. Vienpusēja divkāršo jūsu jutību, bet aizliedz reaģēt uz B būšanu sliktāku.

Kāpēc kalkulators parāda ticamības intervālu? Tas parāda patiesās atšķirības ticamo diapazonu, nevis tikai jā/nē spriedumu. Plats intervāls, kas krusto 0, nozīmē "vēl nav pietiekami daudz datu."

Vai tā ir Bajesiana? Nē — tā ir frekventista z-tests, visplašāk pasniegstais un izmantotais paņēmiens. Bajesiana A/B rīki ziņo "varbūtība, ka B uzvar A" vietā p-vērtības; abi ir derīgi, viņi atbild uz nedaudz atšķirīgiem jautājumiem.

A/B testa nozīmīguma kalkulators