מחשבון משמעות בדיקות A/B

בדיקות A/B בדקה אחת

שינית כפתור, כותרת או זרימת קנייה. גרסה A היא הישנה, גרסה B היא החדשה. B נראית טוב יותר — היא המירה 15% מהמבקרים לעומת 10% ל-A. אבל האם הפער הזה יכול להיות רק מזל, באותו אופן שהטלת מטבע עשר פעמים יכולה לתן שבע ראשים?

המחשבון הזה עונה בדיוק על זה. אתה מזין כמה אנשים ראו כל גרסה וכמה הומרו, והוא אומר לך את ההסתברות שההבדל שמדדת הוא אמיתי ולא רעש אקראי. אם ההסתברות הזו גבוהה מספיק, יש לך זוכה. אם לא, אתה מחזיק את הבדיקה לפעול.

המספר היחיד שצריך להתעקב אחריו הוא ערך ה-p: הסיכוי לראות פער של לפחות גודל זה אם שתי הגרסות היו למעשה זהות. ערך p קטן (נגיד, מתחת ל-0.05) אומר "זה בדרך כלל לא היה קורה במקרה, כך שההבדל כנראה אמיתי."

איך להשתמש בו

1. מבקרים — כמה אנשים ייחודיים הוצגו לכל גרסה.
2. המרות — כמה מהם עשו את הדבר שחשוב לך (קנו, נרשמו, לחצו).
3. רמת ביטחון — כמה בטוח אתה רוצה להיות לפני שאתה קורא לזוכה. 95% הוא ברירת המחדל של התעשייה.
4. השערה — דו-צדדית שואלת "האם B שונה מ-A?" (בטוח יותר, ברירת המחדל); חד-צדדית שואלת רק "האם B טוב יותר מ-A?" (רגיש יותר, אבל עליך להחליט על הכיוון לפני הפעלת הבדיקה).

התוצאה מתעדכנת בזמן אמת והתשומות מאוחסנות בכתובת ה-URL של העמוד, כך שתוכל לסמן בחוקים או לשתף תוצאה. אפס מוחק את הטופס; טען נתוני דוגמה משמש דוגמה מעובדת.

דוגמה מעובדת

זה גדילה מוחלטת של 5 נקודות אחוז וגדילה יחסית של +50%. המחשבון מחזיר ערך p של בערך 0.0007 — מתחת ל-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% ביטחון, z מעבר ±1.96 (הזנבות המוצללים, 5% מהשטח) נחשב משמעותי.

קריאת התוצאה בכנות

• משמעות סטטיסטית היא לא משמעות עסקית. גדילה של 0.1% יכולה להיות אמיתית מבחינה סטטיסטית עדיין לא שווה שינוע.
• אל תביט ועצור מוקדם. בדיקה של ערך ה-p כל יום ועצירה ברגע שהוא מטפטף מתחת ל-0.05 מוגברת שיעור החיובי השקר שלך. החלט על גודל המדגם מראש והנח לבדיקה להסתיים.
• צפה בכלל אצבע גודל מדגם. הקירוב הנורמלי אמין כאשר לכל קבוצה יש לפחות ~10 המרות ו~10 אי-המרות. עם מספרים זעירים, התייחסות לתוצאה כלא לכן בלבד.
• ביטחון ≠ הסתברות B טוב יותר. רמת ביטחון 95% פירושה ההליך טעוני לכל היותר 5% של הזמן בטווח ארוך — זה הצהרה לא בתכנון תדירות, לא "95% סיכוי B ינצח."
• בדיקה אחת, מטרי אחד. בדיקה של מטרים רבים או גרסים בו זמנית מכפילה את הסיכוי לתאונה; תתקן לזה (למשל Bonferroni) או הירשם מראש למטרי יחיד המחליט את הבדיקה.

חשבו זה בעצמכם

כל קטע מחשב את ערך ה-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

שאלות נפוצות

איזה גודל מדגם אני צריך? מספיק שגדילה משמעותית תהיה ניתנת לגילוי. כרצפה, תשאף לפחות כמה מאות המרות לכל גרסה; השתמש במחשבון גודל מדגם ייעודי עם שיעור ייצור הבסיס שלך וגדילה הקטנה ביותר שכדאי לגלות.

דו-צדדית או חד-צדדית? השתמש דו-צדדית אלא אם יש לך סיבה חזקה וחוקית מראש לטפל בשיפור בלבד. חד-צדדית מכפילה את רגישותך אך אוסרת על תגובה ל-B להיות גרוע.

למה המחשבון מציג רווח ביטחון? הוא מציג את הטווח הגיוני של ההבדל האמיתי, לא רק פסק דין כן/לא. רווח רחב שחוצה 0 אומר "לא מספיק נתונים עדיין."

האם זה בייסיאני? לא — זה בדיקת z בתדירות, השיטה הנלמדת בעיקר והשימוש. כלים A/B בייסיאניים דווחו על "הסתברות B מנצחת A" במקום ערך p; שניהם תקפים, הם עונים על שאלות מעט שונות.

מקורות

• בדיקת Z דו-פרופורציה — Wikipedia
• NIST/SEMATECH ספר הנדסה אלקטרוני של שיטות סטטיסטיות — השוואה שתי פרופורציות
• Kohavi, Tang & Xu, Trustworthy Online Controlled Experiments (Cambridge, 2020)
• How VWO calculates statistical significance