A/B ಪರೀಕ್ಷೆ ಮಹತ್ವ ಕ್ಯಾಲ್ಕುಲೇಟರ್

ಒಂದು ನಿಮಿಷದಲ್ಲಿ A/B ಪರೀಕ್ಷೆ

ನೀವು ಒಂದು ಬಟನ್, ಶೀರ್ಷಿಕೆ ಅಥವಾ ಚೆಕೌಟ್ ಹರಿವನ್ನು ಬದಲಾಯಿಸಿದ್ದೀರಿ. ಆವೃತ್ತಿ A ಹಳೆಯದು, ಆವೃತ್ತಿ B ಹೊಸದು. B ಚೆನ್ನಾಗಿ ತೋರುತ್ತಿದೆ — ಇದು 10% ಕೆ 15% ಭೇಟಿ ಮಾಡುವವರನ್ನು ರೂಪಾಂತರಿಸಿದೆ. ಆದರೆ ಆ ಅಂತರವು ಕೇವಲ ಭಾಗ್ಯವಾಗಿರಬಹುದೇ, ನಾಣ್ಯವನ್ನು ಹತ್ತು ಬಾರಿ ತಿರುವುವುದು ಏಳು ತಲೆಗಳನ್ನು ನೀಡುವ ಅದೇ ರೀತಿ?

ಈ ಕ್ಯಾಲ್ಕುಲೇಟರ್ ನಿಖರವಾಗಿ ಇದಕ್ಕೆ ಉತ್ತರ ನೀಡುತ್ತದೆ. ನೀವು ಪ್ರತಿಯೊಂದು ಆವೃತ್ತಿಯನ್ನು ಕಂಡ ಜನರ ಸಂಖ್ಯೆ ಮತ್ತು ಎಷ್ಟು ಮಂದಿ ರೂಪಾಂತರಿಸಿದ್ದಾರೆ ಎಂಬುದನ್ನು ನಮೂದಿಸುತ್ತೀರಿ, ಮತ್ತು ಇದು ನೀವು ಅಳೆದ ವ್ಯತ್ಯಾಸ ನಿಜವೋ ಅಥವಾ ಯಾದೃಚ್ಛಿಕ ಶಬ್ದವೋ ಎಂಬುದರ ಸಂಭವನೀಯತೆ ಹೇಳುತ್ತದೆ. ಆ ಸಂಭವನೀಯತೆ ಸಾಕಷ್ಟು ಹೆಚ್ಚಿದ್ದರೆ, ನೀವು ವಿಜೇತೆಯನ್ನು ಹೊಂದಿದ್ದೀರಿ. ಅದು ಸಾಕಿಲ್ಲದಿದ್ದರೆ, ನೀವು ಪರೀಕ್ಷೆ ಹೆಚ್ಚು ಚಲಾಯಿಸುವುದನ್ನು ಮುಂದುವರಿಸಿ.

ವೀಕ್ಷಿಸಬೇಕಾದ ಒಂದೇ ಸಂಖ್ಯೆ ಎನ್ನುವುದು p-value: ಯಾವ ಆವೃತ್ತಿಗಳು ವಾಸ್ತವವಾಗಿ ಒಂದೇ ಆಗಿದ್ದರೆ ಈ ಮಾತ್ರೆಯ ಅಂತರ ನೋಡುವ ಅವಕಾಶ. ಸಣ್ಣ p-value (ಹೇಳಿ, 0.05 ಕ್ಕಿಂತ ಕಡಿಮೆ) ಎಂದರೆ "ಇದು ಭಾಗ್ಯದಿಂದ ಅಪೂರ್ವವಾಗಿ ಸಂಭವಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ವ್ಯತ್ಯಾಸವು ಬಹುಶಃ ನಿಜವಾಗಿದೆ."

ಅದನ್ನು ಕೋಶ ಬಳಸುವುದು

1. ಭೇಟಿ ಮಾಡುವವರು — ಪ್ರತಿಯೊಂದು ಆವೃತ್ತಿಯನ್ನು ಕಂಡ ಅನನ್ಯ ಜನರ ಸಂಖ್ಯೆ.
2. ರೂಪಾಂತರಗಳು — ಅವರಲ್ಲಿ ಎಷ್ಟು ಮಂದಿ ನೀವು ಕಾಳಜಿ ಮಾಡುವ ವಿಷಯ ಮಾಡಿದ್ದಾರೆ (ಕೆನೆ, ಸೈನ್ ಅಪ್ ಮಾಡಿದರು, ಕ್ಲಿಕ್ ಮಾಡಿದರು).
3. ವಿಶ್ವಾಸ ಮಟ್ಟ — ವಿಜೇತೆಯನ್ನು ಕರೆಯುವ ಮೊದಲು ನೀವು ಎಷ್ಟು ಖಚಿತವಾಗಿರಬೇಕೆ. 95% ಕೈಗಾರಿಕೆ ಮಿತಿ.
4. ಊಹೆ — two-sided "B ಯು A ಗೆ ವಿಭಿನ್ನ?" ಕೇಳುತ್ತದೆ (ಸುರಕ್ಷಿತ, ಮಿತಿ); one-sided "B ಯು A ಗೆ ಉತ್ತಮ?" ಕೇವಲ ಕೇಳುತ್ತದೆ (ಹೆಚ್ಚು ಸೂಕ್ಷ್ಮ, ಆದರೆ ನೀವು ಪರೀಕ್ಷೆ ಚಲಾಯಿಸುವ ಮೊದಲು ದಿಕ್ಕು ಖಚಿತಪಡಿಸಿ).

ಫಲಿತಾಂಶವು ನೇರ ನವೀಕರಣ ಮಾಡುತ್ತದೆ ಮತ್ತು ಇನ್‌ಪುಟ್‌ಗಳು ಪೇಜ್ URL ನಲ್ಲಿ ಸಂಚಯಿಸಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ನೀವು ಫಲಿತಾಂಶವನ್ನು ಸಂಚಲನ ಚಿಹ್ನೆ ಮಾಡಿ ಬಾಂಧವ ಮಾಡಬಹುದು. ಮುಂಚೆ ಮಾಡು ಫಾರ್ಮ್ ಸ್ಪಷ್ಟ ಮಾಡುತ್ತದೆ; ಮಾದರಿ ಡೇಟಾ ಲೋಡ್ ಕೊರೆ ಕೆಲಸ ಉದಾಹರಣೆ ತುಂಬಿಸುತ್ತದೆ.

ಕೆಲಸ ಉದಾಹರಣೆ

ಅದು 5 ಶೇಕಡಾ-ಪಾಯಿಂಟ್ ಪರಿಪೂರ್ಣ ಹೆಚ್ಚುವರಿ ಮತ್ತು +50% ಸಾಪೇಕ್ಷ ಹೆಚ್ಚುವರಿ. ಕ್ಯಾಲ್ಕುಲೇಟರ್ ಸುಮಾರು 0.0007 ರ p-value ಹಿಂದಿರುತ್ತದೆ — 0.05 ಕ್ಕಿಂತ ಕಡಿಮೆ — ಆದ್ದರಿಂದ 95% ವಿಶ್ವಾಸದಲ್ಲಿ ಫಲಿತಾಂಶವು ಸಾಂಖ್ಯಿಕೀಯವಾಗಿ ಮಹತ್ವಪೂರ್ಣ. ಅಂದಾಜೆ, ಎರಡೂ ಆವೃತ್ತಿಗಳು ನಿಜವಾಗಿಯೂ ಒಂದೇ ಆಗಿದ್ದರೆ, ನೀವು ಸಾವಿರ ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ಇದರ ಮೊದಲು ಈ ಗಾತ್ರದ ಅಂತರ ನೋಡುತ್ತಿದ್ದೀರಿ.

ಗಣಿತ (two-proportion z-test)

ಆಂತರಿಕವಾಗಿ ಇದು ಪ್ರಮಾಣಿತ two-proportion z-test, ಆರಂಭಿಕ ಅಂಕೀಯಯಲ್ಲಿ ಬೋಧನೀಯ ಅದೇ ಪರೀಕ್ಷೆ ಮತ್ತು ಮುಖ್ಯ A/B ಸಾಧನಗಳಿಂದ ಬಳಸಲಾಗುತ್ತಿದೆ.

1. ಪ್ರತಿಯೊಂದು ಮಾನ್ಯತೆಯ ರೂಪಾಂತರ ಪ್ರಮಾಣ:

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

   ಅಲ್ಲಿ $x$ ರೂಪಾಂತರಗಳು ಮತ್ತು $n$ ಭೇಟಿ ಮಾಡುವವರು.

2. ಸಂಮಿಶ್ರ ಪ್ರಮಾಣ, ಅಂದಾಜೆ (null hypothesis ಸಕಲು) ಎರಡೂ ಮಾನ್ಯತೆಗಳು ಒಂದು ನಿಜ ಪ್ರಮಾಣ ಪಾಲು ಮಾಡಿ:

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

3. ವ್ಯತ್ಯಾಸದ ಮಾನ್ಯತೆ ತ್ರುಟಿ:

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

4. z-score — ಎರಡೂ ಪ್ರಮಾಣಗಳು ಮಾನ್ಯತೆ ತ್ರುಟಿ ಅನುವಾದ ಅಂತರ:

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

5. p-value ಮಾನ್ಯತೆ ಸರಳ ವಿತರಣೆ $\Phi$ ನೆಲೆಯಿಂದ ಬರುತ್ತದೆ. Two-sided: $p = 2\left(1 - \Phi(|z|)\right)$. One-sided: $p = 1 - \Phi(z)$.

6. ಮಹತ್ವಪೂರ್ಣ ಯಾವಾಗ $p < \alpha$, ಅಲ್ಲಿ $\alpha = 1 - \text{confidence}$ (ಆದ್ದರಿಂದ 95% ನಲ್ಲಿ 0.05).

ಕ್ಯಾಲ್ಕುಲೇಟರ್ ಸಹ ವಿಶ್ವಾಸ ಮಧ್ಯಂತರ ವ್ಯತ್ಯಾಸಕ್ಕಾಗಿ ರಿಪೋರ್ಟ ಮಾಡುತ್ತದೆ, unsummarized ಮಾನ್ಯತೆ ತ್ರುಟಿ ಲೆಕ್ಕ $\sqrt{\tfrac{p_1(1-p_1)}{n_1} + \tfrac{p_2(1-p_2)}{n_2}}$: ನಿಜ ಅಂತರಾಳ ಸಮರ್ಥ ಶ್ರೇಣಿ. ಆ ಮಧ್ಯಂತರ 0 ಹೊರತುಪಡಿಸಿ ಇದ್ದರೆ, ಫಲಿತಾಂಶವು ಮಹತ್ವಪೂರ್ಣ.

95% ವಿಶ್ವಾಸದಲ್ಲಿ, ±1.96 ಹೊರತುಪಡಿಸಿ z (ನೆರಳುಪ್ಪು ಬಾಲುಗಳು, 5% ಪ್ರದೇಶ) ಮಹತ್ವಪೂರ್ಣವೆಂದು ಪರಿಗಣನೆ ಮಾಡಲಾಗುತ್ತದೆ.

ಫಲಿತಾಂಶವನ್ನು ಪ್ರಾಮಾಣಿಕವಾಗಿ ಓದುವುದು

• ಸಾಂಖ್ಯಿಕೀಯ ಮಹತ್ವ ವ್ಯವಹಾರ ಮಹತ್ವ ಅಲ್ಲ. ಒಂದು 0.1% ಹೆಚ್ಚುವರಿ ಸಾಂಖ್ಯಿಕೀಯವಾಗಿ ನಿಜವಾಗಿರಬಹುದು ಆದರೆ ಅನುಮೋದಿಸಲು ಯೋಗ್ಯವಲ್ಲ.
• ನೋಡಿ ಮತ್ತು ಯಾವಾಗ ಮುಂದೆ ತಾಮೆ ಮಾಡಬೇಡಿ. p-value ಪ್ರತಿದಿನ ಪರಿಶೀಲಿಸುವುದು ಮತ್ತು ಕೆಳಗೆ 0.05 ತೋರಿದ ಕ್ಷಣದ ನಿಲ್ಲುವುದು ನಿಮ್ಮ ಸುಳ್ಳು-ಸಕಾರಾತ್ಮಕ ಪ್ರಮಾಣ ತೊರೆಸುತ್ತದೆ. ಆಗಾಗೆ ನಮೂನೆ ಗಾತ್ರ ನಿರ್ದಿಷ್ಟ ಮತ್ತು ಪರೀಕ್ಷೆ ಮುಕ್ತಾಯ ಮಾಡಲು.
• ನಮೂನೆ-ಗಾತ್ರ ನೋಂದ್ರಣ ಕಾಳಜಿ. ಸರಳ ಅಂದಾಜೆ ವಿಶ್ವಾಸಾರ್ಹ ಪ್ರತಿಯೊಂದು ಮಾನ್ಯತೆ ಆಸ್ತಿ ~10 ರೂಪಾಂತರಗಳು ಮತ್ತು ~10 ಅ-ರೂಪಾಂತರಗಳು. ಸಣ್ಣ ಪ್ರಮಾಣಗಳು ಕೊರೆ, ಫಲಿತಾಂಶವನ್ನು ಸೂತ್ರಾನುಸಾರ ಕೇವಲ ಪರಿಗಣನೆ ಮಾಡಿ.
• ವಿಶ್ವಾಸ ≠ ಸಂಭವನೀಯತೆ B ಉತ್ತಮ. ಒಂದು 95% ವಿಶ್ವಾಸ ಮಟ್ಟ ಕಾರ್ಯವಿಧಾನ ದೀರ್ಘಾವಧಿಯಲ್ಲಿ 5% ತಪ್ಪು ಎಂದರೆ — ಇದು ಒಂದು frequentist ಪ್ರತಿಪಾದನೆ, "95% ಅವಕಾಶ B ಗೆಲ್ಲುತ್ತದೆ" ಅಲ್ಲ.
• ಒಂದು ಪರೀಕ್ಷೆ, ಒಂದು ಮೆಟ್ರಿಕ್. ಅನೇಕ ಮೆಟ್ರಿಕ್ ಅಥವಾ ಆವೃತ್ತಿಗಳನ್ನು ಒಂದೊಟ್ಟು ಪರೀಕ್ಷೆ ಮಾಡುವುದು ಸಂಯೋಗ ಅವಕಾಶವನ್ನು ಗುಣಾಕಾರ ಮಾಡುತ್ತದೆ; ಸರಿದೂಷಣೆ ಮಾಡಿ (ಯಥಾ Bonferroni) ಅಥವಾ ಮೊದಲು-ನೆರೆಮಾಡಿ ಒಂದೇ ಮೆಟ್ರಿಕ್ ಪರೀಕ್ಷೆ ನಿರ್ಧರಿಸುತ್ತದೆ.

ನೀವೇ ಅದನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಿ

ಪ್ರತಿಯೊಂದು ಕೋಷ್ಟಕ ಮುಖ್ಯ ಉದಾಹರಣೆ ಅರ್ಧ-ಬದಿಬಿಡಿ p-value ಕಲ್ಪನೆ ಮಾಡುತ್ತದೆ.

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

ಪೂರ್ವ-ಪ್ರಶ್ನೆಗಳು

ನಾನು ಎಷ್ಟು ನಮೂನೆ ಗಾತ್ರ ಅವಶ್ಯಕತೆ? ಮೂರ್ತಿ ಅರ್ಥಪೂರ್ಣ ಹೆಚ್ಚುವರಿ ಸೂಚನೆ ಆಗಿದೆ. ಪೂರ್ವಸೂಚನೆ ರೂಪಿಸ, ಪ್ರತಿ ರೂಪಾಂತರ ಕೆಲವು ನೂರು ರೂಪಾಂತರಗಳು ಸರಿಯಾಗಿ; ನಿಮ್ಮ ಆಧಾರ ಪ್ರಮಾಣ ಮತ್ತು ಸಣ್ಣ ಹೆಚ್ಚುವರಿ ಲಾಭವಾಗಿ ಸಮರ್ಪಿತ ನಮೂನೆ-ಗಾತ್ರ ಕ್ಯಾಲ್ಕುಲೇಟರ್ ಬಳಸಿ.

Two-sided ಅಥವಾ one-sided? Two-sided ಬಳಸಿ ನೀವು ಕಠಿಣ, ಮುಂಚೆ-ಪ್ರತಿಬದ್ಧ ಕಾರಣ ಮಾತ್ರ ಉಧುರುತ್ತದೆ ಹೊರತುಪಡಿಸಿ. One-sided ನಿಮ್ಮ ಸೂಕ್ಷ್ಮತೆ ಎರಡೆರಡು ಆದರೆ ನಿಷೇಧಿಸುತ್ತದೆ ವಿನಂತಿ B ಆಗಿ ನಿಕೃಷ್ಟ.

ಕ್ಯಾಲ್ಕುಲೇಟರ್ ಯಾಕೆ ವಿಶ್ವಾಸ ಮಧ್ಯಂತರ ತೋರುವುದು? ಇದು ನಿಜ ವ್ಯತ್ಯಾಸದ ಸಂಭವನೀಯ ಶ್ರೇಣಿ ತೋರುವುದು, ಹೌದು/ಇಲ್ಲ ತೀರ್ಪು ಕೇವಲ. ವೃಹತ್ ಮಧ್ಯಂತರ ಆ 0 ಹೊರತುಪಡಿಸಿ ಮಾಡುತ್ತಿದೆ ಅರ್ಥ "ಇನ್ನೂ ನೂತನ ಡೇಟಾ."

ಇದು Bayesian ಆಗಿದೆಯೇ? ಇಲ್ಲ — ಇದು frequentist z-test, ಹೆಚ್ಚು ಕಲಿತ ಮತ್ತು ಬಳಸುವಿಕೆ ವಿಧಾನ. Bayesian A/B ಸಾಧನಗಳು "ಸಂಭವನೀಯತೆ B A ಜೋತೆಯಾಗಿದೆ" p-value ಬದಲಾಗಿ ವರದಿ ಮಾಡುತ್ತವೆ; ಎರಡೂ ಮಾನ್ಯ, ಅವರು ಭಿನ್ನ ಪ್ರಶ್ನೆ ಉತ್ತರ ನೀಡುತ್ತವೆ.

ಮೂಲಗಳು

• 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