बायेसियन ए / बी टेस्टिंग के लिए फॉर्मूला का कोई मतलब नहीं है

मैं बायेसियन कार्यप्रणाली का उपयोग करके एबी परीक्षण के परिणामों की गणना करने के लिए बायेसियन एब परीक्षण से सूत्र का उपयोग कर रहा हूं ।

Pr (p_{B} > p_{A}) = \sum_{i = 0}^{α_{B} - 1} \frac{B (α_{A} + i, β_{B} + β_{A})}{(β_{B} + i) B (1 + i, β_{B}) B (α_{A}, β_{A})}

$\Pr(p_B > p_A) = \sum^{\alpha_B-1}_{i=0} \frac{B(\alpha_A+i,\beta_B+\beta_A)}{(\beta_B+i)B(1+i,\beta_B)B(\alpha_A, \beta_A)}$

कहाँ पे

$\alpha_A$ एक के लिए एक से अधिक सफलताओं की संख्या में
$\beta_A$ प्लस में विफलताओं की संख्या
$\alpha_B$ बी के लिए सफलताओं की संख्या में एक प्लस में
$\beta_B$ बी के लिए विफलताओं की संख्या एक प्लस में
$B$ है बीटा समारोह

उदाहरण डेटा:

control: 1000 trials with 78 successes
test: 1000 trials with 100 successes

एक मानक गैर बायेसियन प्रोप टेस्ट मुझे महत्वपूर्ण परिणाम देता है (p <10%):

prop.test(n=c(1000,1000), x=c(100,78), correct=F)

#   2-sample test for equality of proportions without continuity correction
# 
# data:  c(100, 78) out of c(1000, 1000)
# X-squared = 2.9847, df = 1, p-value = 0.08405
# alternative hypothesis: two.sided
# 95 percent confidence interval:
#  -0.0029398  0.0469398
# sample estimates:
# prop 1 prop 2 
#  0.100  0.078

जबकि बेयस सूत्र के मेरे कार्यान्वयन (लिंक में स्पष्टीकरण का उपयोग करके) ने मुझे बहुत ही अजीब परिणाम दिए:

# success control+1
a_control <- 78+1
# failures control+1
b_control <- 1000-78+1
# success control+1
a_test <- 100+1
# failures control+1
b_test <- 1000-100+1

is_control_better <- 0
for (i in 0:(a_test-1) ) {
  is_control_better <- is_control_better+beta(a_control+i,b_control+b_test) / 
                       (b_test+i)*beta(1+i,b_test)*beta(a_control,b_control)

}

round(is_control_better, 4)
# [1] 0

कि इसका मतलब है कि $P(TEST > CONTROL)$ है $0$ है, जो इस डेटा को देखते हुए किसी भी मतलब नहीं है।

क्या कोई स्पष्ट कर सकता है?

r bayesian ab-test

— येहोशहाट श्लेलेकेंस
स्रोत

एक p-valueटैग के साथ एक बायेसियन विश्लेषण क्वेस्टियोब ? मैंने सोचा कि बायेसियन ने पी-वैल्यू के साथ कुछ भी करने से इनकार कर दिया।

— दिलीप सरवटे

आपका अधिकार! बस सोचा था कि यह अधिक ध्यान आकर्षित करेगा!

— येहोशहाट श्लेलेकेंस

@YehoshaphatSchellekens यदि वह वास्तविक कारण था तो मैं p-valueटैग को हटा देता हूं क्योंकि यह संबंधित नहीं है।

— टिम

बिलकुल कोई परेशानी नही।

— येहोशहाट स्केलेकेंसे

जिस साइट पर आप उद्धृत करते हैं, वह एक सूचना है

बीटा फ़ंक्शन बहुत बड़ी संख्या में उत्पादन करता है, इसलिए यदि आप अपने प्रोग्राम में अनंत मान प्राप्त कर रहे हैं, तो ऊपर दिए गए कोड के अनुसार, लघुगणक के साथ काम करना सुनिश्चित करें। आपके मानक पुस्तकालय का लॉग-बीटा फ़ंक्शन यहाँ काम आएगा।

इसलिए आपका कार्यान्वयन गलत है। नीचे मैं सही कोड प्रदान करता हूं:

a_A <- 78+1
b_A <- 1000-78+1
a_B <- 100+1
b_B <- 1000-100+1

total <- 0

for (i in 0:(a_B-1) ) {
  total <- total + exp(lbeta(a_A+i, b_B+b_A)
                       - log(b_B+i)
                       - lbeta(1+i, b_B)
                       - lbeta(a_A, b_A))

}

यह कुल = 0.9576921 को आउटपुट करता है, जो कि "बाधाओं कि बी लंबे समय में ए को हरा देगा" (आपके लिंक को उद्धृत करते हुए) जो आपके उदाहरण में बी से मान्य है, उसका अनुपात अधिक है। इसलिए, यह है नहीं एक पी -value बल्कि एक संभावना है कि अधिक से अधिक बी तो एक है (यदि आप करते नहीं यह होने की उम्मीद <0.05)।

आप परिणामों की जांच करने के लिए सरल सिमुलेशन चला सकते हैं:

set.seed(123)

# does Binomial distributions with proportions
# from your data give similar estimates?

mean(rbinom(n, 1000, a_B/1000)>rbinom(n, 1000, a_A/1000))

# and does values simulated in a similar fashion to
# the model yield similar results?

fun2 <- function(n=1000) {
  pA <- rbeta(1, a_A, b_A)
  pB <- rbeta(1, a_B, b_B)
  mean(rbinom(n, 1000, pB) > rbinom(n, 1000, pA))
}

summary(replicate(1000, fun2(1000)))

दोनों मामलों में जवाब हां है।

कोड के बारे में, ध्यान दें कि लूप अनावश्यक है और आम तौर पर वे आर में चीजों को धीमा कर देते हैं, इसलिए आप वैकल्पिक रूप vapplyसे क्लीनर और थोड़ा तेज कोड का उपयोग कर सकते हैं :

fun <- function(i) exp(lbeta(a_A+i, b_B+b_A)
             - log(b_B+i)
             - lbeta(1+i, b_B)
             - lbeta(a_A, b_A))

sum(vapply(0:(a_B-1), fun, numeric(1)))

— टिम
स्रोत

हम्म ... मुझे आश्चर्य है कि अगर आपने वास्तव में गति के लिए परीक्षण किया है, क्योंकि लूप की vapplyतुलना में अधिक वेक्टरोज़िड नहीं है for, इसके विपरीत, वे मूल रूप से समान हैं। हालांकि अच्छा जवाब।

— डेविड आरनबर्ग

C / C ++ / Fortan forloops == वेक्टरकृत; आर forलूप! = सदिश। यह मूल रूप से वेक्टर की परिभाषा है।

— डेविड ऐरनबर्ग

@YehoshaphatSchellekens लॉग के साथ बिंदु कुछ सॉफ्टवेयर के बारे में नहीं है, लेकिन सामान्य सांख्यिकीय कंप्यूटिंग है। साइट पर उदाहरण में आप जूलिया कोड को उद्धृत करते हैं, प्रदान किया जाता है - जूलिया सांख्यिकीय प्रोग्रामिंग के लिए भी बहुत अच्छी भाषा है और अभी भी लॉग का उपयोग किया जाता है।

— टिम

वास्तव में, मैंने एसओ पर इस सटीक चर्चा के संबंध में एक सवाल पूछा है , मुझे vapplyभविष्य में अपने दृष्टिकोण पर पुनर्विचार करने की आवश्यकता हो सकती है । मुझे उम्मीद है कि मुझे एक बार और सभी के लिए कुछ अच्छा जवाब मिलेगा।

— डेविड अरेनबर्ग

ठीक है, लंबी सोच के बाद और मेरे सवाल पर प्राप्त टिप्पणियों और उत्तरों को संक्षेप में, मुझे लगता है कि मैं कुछ सामान्य समझ के साथ आया हूं जो vapplyवास्तव में है। मेरा जवाब यहाँ

— डेविड एरेन्बर्ग