A/B परीक्षण महत्त्व कॅल्क्युलेटर

एक मिनिटात A/B परीक्षण

तुम्ही बटण, शीर्षक, किंवा चेकआउट प्रवाह बदलले. आवृत्ती A ही जुनी आहे, आवृत्ती B ही नवीन आहे. B दिसते चांगली आहे — हे 15% रूपांतरित केले विरुद्ध A साठी 10%. परंतु हा फरक फक्त भाग्य असू शकतो का, त्याचप्रमाणे नाणे दहा वेळा फेकल्याने सात डोके मिळू शकते?

हा कॅल्क्युलेटर अचूकपणे त्याचे उत्तर देतो. आप प्रत्येक आवृत्तीला किती लोकांना दिसले आणि किती रूपांतरित झाले हे प्रविष्ट करता, आणि हे आपल्याला सांगते की आपण मोजलेला फरक वास्तविक आहे की यादृच्छिक शोर. जर हा संभाव्यता पुरेशी जास्त असेल तर आपल्याकडे विजेता आहे. जर नाही, तर आप परीक्षण चालू ठेवा.

एक क्रमांक पाहणे आवश्यक आहे p-मूल्य: जर दोन आवृत्त्या खरेतर एकसारखी असल्या तर कमीतकमी या आकाराचा फरक पाहण्याची संधी. एक लहान p-मूल्य (म्हणा, 0.05 खाली) अर्थ "हे भाग्याने क्वचित घडते, त्यामुळे फरक संभवतः वास्तविक आहे."

हे कसे वापरायचे

1. दर्शक — प्रत्येक आवृत्तीला किती अद्वितीय लोकांना दिसले.
2. रूपांतरण — त्यांपैकी किती यांनी तुम्हाला काळजी असलेली गोष्ट केली (खरेदी केली, साइन अप केली, क्लिक केली).
3. विश्वास पातळी — विजेता कॉल करण्यापूर्वी आप किती निश्चित असू इच्छित आहात. 95% हा उद्योग मानक आहे.
4. गृहीतक — द्विमुखी विचारते "B A पेक्षा वेगळा आहे का?" (सुरक्षित, डिफॉल्ट); एकमुखी फक्त विचारते "B A पेक्षा चांगला आहे का?" (अधिक संवेदनशील, परंतु आप परीक्षण चालू करण्यापूर्वी दिशा ठरवले पाहिजे).

परिणाम लाइव अपडेट होतो आणि इनपुट पृष्ठ URL मध्ये संचयित केले जातात, त्यामुळे आप एक परिणाम बुकमार्क किंवा शेअर करू शकता. रीसेट फॉर्म साफ करते; नमुना डेटा लोड करा एक कार्य केलेले उदाहरण भरते.

एक कार्य केलेले उदाहरण

हा 5 प्रतिशत-बिंदू निरपेक्ष लिफ्ट आणि +50% सापेक्ष लिफ्ट आहे. कॅल्क्युलेटर सुमारे 0.0007 चा p-मूल्य परत करतो — 0.05 खाली — त्यामुळे 95% आत्मविश्वास परिणाम सांख्यिकीयदृष्ट्या महत्त्वपूर्ण आहे. अंदाजे, जर दोन आवृत्त्या खरोखर एकसारखी असल्या, तर आप हजारातून एकदा हा फरक पाहिले असते.

गणित (द्विप्रमाण z-परीक्षण)

या पृष्ठभागाखाली हा मानक द्विप्रमाण z-परीक्षण आहे, परिचयात्मक आकडेवारीत शिकविला जाणारा समान परीक्षण आणि मुख्य A/B साधनांद्वारे वापरला जातो.

1. प्रत्येक समूहाचा रूपांतरण दर:

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

   जेथे $x$ रूपांतरण आहे आणि $n$ दर्शक आहे.

2. पूल केलेला दर, असे गृहीत धरून (शून्य गृहीतकासाठी) दोन्ही समूह एक सत्य दर सामायिक करतात:

   $\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-स्कोर — दोन दर किती मानक त्रुटी अलग आहेत:

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

5. p-मूल्य मानक सामान्य वितरण $\Phi$ पासून आते. द्विमुखी: $p = 2\left(1 - \Phi(|z|)\right)$. एकमुखी: $p = 1 - \Phi(z)$.

6. महत्त्वपूर्ण जेव्हा $p < \alpha$, जेथे $\alpha = 1 - \text{confidence}$ (त्यामुळे 0.05 95% मध्ये).

कॅल्क्युलेटर फरकासाठी एक आत्मविश्वास मध्यांतर देखील अहवाल देतो, अनपूल्ड मानक त्रुटी $\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-मूल्य प्रतिदिन तपास करणे आणि 0.05 खाली पडण्याचा क्षण थांबवणे आपल्या खोट्या सकारात्मक दरात वाढ करते. नमुना आकार आगाऊ ठरवा आणि परीक्षण संपू द्या.
• नमुना-आकार नियमाचा सिद्धांत पहा. सामान्य अंदाजे विश्वासार्ह आहे जेव्हा प्रत्येक समूहात कमीतकमी ~10 रूपांतरण आणि ~10 गैर-रूपांतरण असतात. लहान संख्यांसह, परिणाम दिशात्मक म्हणून व्यवहार करा.
• आत्मविश्वास ≠ संभाव्यता B चांगला आहे. 95% विश्वास पातळी म्हणजे प्रक्रिया दीर्घ धावात सर्वात अधिक 5% चुकीच आहे — हे एक फ्रिक्वेंटिस्ट विधान आहे, "95% संभाव्यता B जिंकते" नाही.
• एक परीक्षण, एक मेट्रिक. एकाच वेळी अनेक मेट्रिक्स किंवा व्हेरिएंट्स परीक्षण करणे एक यादृच्छिक संधी गुणा करते; त्यासाठी सुधार करा (उदा. बोनफेरोनी) किंवा परीक्षा निर्णय करणारी एकल मेट्रिक पूर्व-नोंदणी करा.

हे स्वतःला गणना करा

प्रत्येक स्निपेट वरील कार्य केलेल्या उदाहरणाचे द्विमुखी p-मूल्य गणना करतो.

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

मुझे किंवा आकार की आवश्यकता है? पर्याप्त कि अर्थपूर्ण लिफ्ट पहचानकर्ता होगी. मंजिल के रूप में, प्रति वेरिएंट कम से कम कुछ सौ रूपांतरण का लक्ष्य रखें; अपनी आधारभूत दर और पहचानने के लिए लायक सबसे छोटी लिफ्ट के साथ एक समर्पित नमुना आकार कैलकुलेटर का उपयोग करें.

द्विमुखी या एकमुखी? द्विमुखी का उपयोग करें जब तक आपके पास केवल सुधार की परवाह करने का एक मजबूत, पूर्व-प्रतिबद्ध कारण नहीं है. एकमुखी आपकी संवेदनशीलता को दोगुना करता है परंतु B बदतर होने पर प्रतिक्रिया करने पर प्रतिबंध लगाता है.

कैलकुलेटर विश्वास अंतराल क्यों दिखाता है? यह हां/नहीं निर्णय के बजाय वास्तविक फरक की प्रशंसनीय श्रेणी दिखाता है. एक विस्तृत अंतराल जो 0 को स्ट्रैडल करता है का अर्थ "अभी तक पर्याप्त डेटा नहीं है."

क्या यह बायेसियन है? नहीं — यह एक फ्रिक्वेंटिस्ट z-परीक्षण है, सबसे व्यापक रूप से पढ़ाया जाता है और उपयोग की विधि. बायेसियन A/B उपकरण p-मूल्य के बजाय "संभाव्यता B A को मारता है" की रिपोर्ट करते हैं; दोनों वैध हैं, वे थोड़े अलग सवालों का जवाब देते हैं.

स्रोत

• 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