आर: परिवार के साथ glm फ़ंक्शन = "द्विपद" और "वजन" विनिर्देश

Question

मैं बहुत उलझन में हूं कि परिवार के साथ चमक में कैसे काम करता है = "द्विपद"। मेरी समझ में, परिवार के साथ glm की संभावना = "द्विपद" इस प्रकार निर्दिष्ट की गई है: जहां y "मनाया सफलता का अनुपात" है और n परीक्षणों की ज्ञात संख्या है।य

$$f(y) = {n\choose{ny}} p^{ny} (1-p)^{n(1-y)} = \exp \left(n \left[ y \log \frac{p}{1-p} - \left(-\log (1-p)\right) \right] + \log {n \choose ny}\right)$$ $y$$n$

मेरी समझ में, सफलता p की संभावना $p$कुछ रैखिक गुणांक $\beta$ साथ $p=p(\beta)$ और परिवार के साथ glm फ़ंक्शन = "द्विपद" खोज के लिए है:

$$\textrm{arg}\max_{\beta} \sum_i \log f(y_i).$$ तब इस अनुकूलन समस्या को सरल बनाया जा सकता है:

$$\textrm{arg}\max_{\beta} \sum_i \log f(y_i)= \textrm{arg}\max_{\beta} \sum_i n_i \left[ y_i \log \frac{p(\beta)}{1-p(\beta)} - \left(-\log (1-p(\beta))\right) \right] + \log {n_i \choose n_iy_i}\\ = \textrm{arg}\max_{\beta} \sum_i n_i \left[ y_i \log \frac{p(\beta)}{1-p(\beta)} - \left(-\log (1-p(\beta))\right) \right] \\ $$
इसलिए अगर हम $n_i^*=n_ic$ को सभी $i=1,...,N$ लिए कुछ निरंतर $c$ , तो यह भी सही होना चाहिए कि: $$\textrm{arg}\max_{\beta} \sum_i \log f(y_i) = \textrm{arg}\max_{\beta} \sum_i n^*_i \left[ y_i \log \frac{p(\beta)}{1-p(\beta)} - \left(-\log (1-p(\beta))\right) \right] \\ $$ इस से, मैंने सोचा कि परीक्षण की संख्या की स्केलिंग $n_i$एक निरंतर साथ की अधिकतम संभावना अनुमान को प्रभावित नहीं करता है $\beta$ सफलता का अनुपात को देखते हुए $y_i$ ।

Glm की सहायता फ़ाइल कहती है:

 "For a binomial GLM prior weights are used to give the number of trials 
  when the response is the proportion of successes" 

इसलिए मुझे उम्मीद थी कि प्रतिक्रिया के रूप में सफलता के अनुपात को देखते हुए वजन के स्केलिंग से अनुमानित \ बीटा पर कोई असर नहीं पड़ेगा $\beta$। हालांकि निम्नलिखित दो कोड अलग गुणांक मान लौटाते हैं:

 Y <- c(1,0,0,0) ## proportion of observed success
 w <- 1:length(Y) ## weight= the number of trials
 glm(Y~1,weights=w,family=binomial)

यह प्रदान करता है:

 Call:  glm(formula = Y ~ 1, family = "binomial", weights = w)

 Coefficients:
 (Intercept)  
      -2.197     

अगर मैं 1000 से सभी वजन गुणा करता हूं, तो अनुमानित गुणांक अलग हैं:

 glm(Y~1,weights=w*1000,family=binomial)

 Call:  glm(formula = Y ~ 1, family = binomial, weights = w * 1000)

 Coefficients:
 (Intercept)  
    -3.153e+15  

मैंने कई अन्य उदाहरणों को देखा, यहां तक ​​कि भार में कुछ मध्यम स्केलिंग के साथ। यहाँ क्या हो रहा है?

Comments

इसके लायक होने के लिए, फ़ंक्शन के weightsअंदर दो स्थानों पर तर्क समाप्त होता है glm.fit( glm.R में ), जो है जो काम करता है R: 1 में) अवशिष्ट अवशिष्ट में, C फ़ंक्शन के माध्यम से binomial_dev_resids( family.c में ) और Cdqrls( lm.c में ) IWLS कदम से 2 )। मुझे पता नहीं है कि तर्क को ट्रेस करने में अधिक मददगार होने के लिए पर्याप्त C

— छायाकार

यहां उत्तर देखें ।

— स्टेट

@ssdecontrol मैं उस लिंक में glm.fit के माध्यम से पढ़ रहा हूं जो आपने मुझे दिया था, लेकिन मुझे यह नहीं मिल रहा है कि C फ़ंक्शन "binomial_dev_resids" को glm.fit में कहां कहा जाता है। अगर आप इसे इंगित करेंगे तो क्या आप बुरा मानेंगे?

— परीऑनसीस

@ssdecontrol ओह, माफ करना मुझे लगता है कि मैं समझता हूं। प्रत्येक "परिवार" एक सूची है और तत्वों में से एक "dev.resids" है। जब मैं R कंसोल में द्विपद टाइप करता हूं, तो मुझे द्विपद वस्तु की परिभाषा दिखाई देती है और इसकी एक रेखा होती है: dev.resids <- function (y, mu, wt) .Call (C_binomial_dev_resids, y, mu, wt)

— FairyOnIce

Answer 1

आपका उदाहरण केवल आर में गोलाई त्रुटि का कारण है। बड़े वजन में अच्छा प्रदर्शन नहीं करते हैं glm। यह सच है कि w100 की तरह, किसी भी छोटी संख्या से स्केलिंग , बिना अनुमान के समान अनुमानों की ओर ले जाती है w।

यदि आप वज़न तर्कों के साथ अधिक विश्वसनीय व्यवहार चाहते हैं, svyglmतो surveyपैकेज से फ़ंक्शन का उपयोग करने का प्रयास करें ।

यहाँ देखें:

    > svyglm(Y~1, design=svydesign(ids=~1, weights=~w, data=data.frame(w=w*1000, Y=Y)), family=binomial)
Independent Sampling design (with replacement)
svydesign(ids = ~1, weights = ~w, data = data.frame(w = w * 1000, 
    Y = Y))

Call:  svyglm(formula = Y ~ 1, design = svydesign(ids = ~1, weights = ~w2, 
    data = data.frame(w2 = w * 1000, Y = Y)), family = binomial)

Coefficients:
(Intercept)  
     -2.197  

Degrees of Freedom: 3 Total (i.e. Null);  3 Residual
Null Deviance:      2.601 
Residual Deviance: 2.601    AIC: 2.843

Answer 2

मुझे लगता है कि यह उन प्रारंभिक मूल्यों के लिए नीचे आता है जो इसमें से उपयोग किया जाता है glm.fit, family$initializeजो विधि को विचलन बनाता है। जहां तक ​​मुझे पता है,glm.fit का क्यूआर-अपघटन बनाकर समस्या को हल करें जहां डिजाइन मैट्रिक्स है और प्रविष्टियों का वर्गमूल के साथ एक विकर्ण है जैसा कि यहां वर्णित है । यही है, न्यूटन-रैपसन विधि का उपयोग करता है।$\sqrt{W}X$$X$$\sqrt{W}$

प्रासंगिक $intializeकोड है:

if (NCOL(y) == 1) {
    if (is.factor(y)) 
        y <- y != levels(y)[1L]
    n <- rep.int(1, nobs)
    y[weights == 0] <- 0
    if (any(y < 0 | y > 1)) 
        stop("y values must be 0 <= y <= 1")
    mustart <- (weights * y + 0.5)/(weights + 1)
    m <- weights * y
    if (any(abs(m - round(m)) > 0.001)) 
        warning("non-integer #successes in a binomial glm!")
}

यहाँ एक सरलीकृत संस्करण है, glm.fitजो मेरी बात दर्शाता है

> #####
> # setup
> y <- matrix(c(1,0,0,0), ncol = 1)
> weights <- 1:nrow(y) * 1000
> nobs <- length(y)
> family <- binomial()
> X <- matrix(rep(1, nobs), ncol = 1) # design matrix used later
> 
> # set mu start as with family$initialize
> if (NCOL(y) == 1) {
+   n <- rep.int(1, nobs)
+   y[weights == 0] <- 0
+   mustart <- (weights * y + 0.5)/(weights + 1)
+   m <- weights * y
+   if (any(abs(m - round(m)) > 0.001)) 
+     warning("non-integer #successes in a binomial glm!")
+ }
> 
> mustart # starting value
             [,1]
[1,] 0.9995004995
[2,] 0.0002498751
[3,] 0.0001666111
[4,] 0.0001249688
> (eta <- family$linkfun(mustart))
          [,1]
[1,]  7.601402
[2,] -8.294300
[3,] -8.699681
[4,] -8.987322
> 
> #####
> # Start loop to fit
> mu <- family$linkinv(eta)
> mu_eta <- family$mu.eta(eta)
> z <- drop(eta + (y - mu) / mu_eta)
> w <- drop(sqrt(weights * mu_eta^2 / family$variance(mu = mu)))
> 
> # code is simpler here as (X^T W X) is a scalar
> X_w <- X * w
> (.coef <- drop(crossprod(X_w)^-1 * ((w * z) %*% X_w)))
[1] -5.098297
> (eta <- .coef * X)
          [,1]
[1,] -5.098297
[2,] -5.098297
[3,] -5.098297
[4,] -5.098297
> 
> # repeat a few times from "start loop to fit"

हम न्यूटन-राफसन पद्धति को देखने के लिए पिछले भाग को दो बार दोहरा सकते हैं:

> #####
> # Start loop to fit
> mu <- family$linkinv(eta)
> mu_eta <- family$mu.eta(eta)
> z <- drop(eta + (y - mu) / mu_eta)
> w <- drop(sqrt(weights * mu_eta^2 / family$variance(mu = mu)))
> 
> # code is simpler here as (X^T W X) is a scalar
> X_w <- X * w
> (.coef <- drop(crossprod(X_w)^-1 * ((w * z) %*% X_w)))
[1] 10.47049
> (eta <- .coef * X)
         [,1]
[1,] 10.47049
[2,] 10.47049
[3,] 10.47049
[4,] 10.47049
> 
> 
> #####
> # Start loop to fit
> mu <- family$linkinv(eta)
> mu_eta <- family$mu.eta(eta)
> z <- drop(eta + (y - mu) / mu_eta)
> w <- drop(sqrt(weights * mu_eta^2 / family$variance(mu = mu)))
> 
> # code is simpler here as (X^T W X) is a scalar
> X_w <- X * w
> (.coef <- drop(crossprod(X_w)^-1 * ((w * z) %*% X_w)))
[1] -31723.76
> (eta <- .coef * X)
          [,1]
[1,] -31723.76
[2,] -31723.76
[3,] -31723.76
[4,] -31723.76

ऐसा तब नहीं होता जब आप शुरुआत करते हैं weights <- 1:nrow(y)या कहते हैं weights <- 1:nrow(y) * 100।

ध्यान दें कि आप mustartतर्क सेट करके विचलन से बच सकते हैं । जैसे करते हैं

> glm(Y ~ 1,weights = w * 1000, family = binomial, mustart = rep(0.5, 4))

Call:  glm(formula = Y ~ 1, family = binomial, weights = w * 1000, mustart = rep(0.5, 
    4))

Coefficients:
(Intercept)  
     -2.197  

Degrees of Freedom: 3 Total (i.e. Null);  3 Residual
Null Deviance:      6502 
Residual Deviance: 6502     AIC: 6504

Comments

मुझे लगता है कि वज़न आरंभ करने के लिए तर्कों से अधिक प्रभावित करता है। लॉजिस्टिक रिग्रेशन के साथ, न्यूटन रैपसन अधिकतम संभावना का अनुमान लगाता है जो मौजूद है और जब डेटा अलग नहीं होते हैं तो यह अद्वितीय है। आशावादी के लिए अलग-अलग शुरुआती मूल्यों की आपूर्ति अलग-अलग मूल्यों पर नहीं होगी, लेकिन वहां पहुंचने में शायद अधिक समय लगेगा।

— आदमियो

"आशावादी के लिए अलग-अलग शुरुआती मूल्यों की आपूर्ति अलग-अलग मूल्यों पर नहीं आएगी ..." । खैर न्यूटन विधि विचलित नहीं होती है और अंतिम उदाहरण में अद्वितीय अधिकतम पाता है जहां मैंने प्रारंभिक मान सेट किया है (उदाहरण देखें जहां मैं mustart तर्क प्रदान करता हूं )। यह गरीब प्रारंभिक अनुमान से जुड़ा मामला लगता है ।

— बेंजामिन क्रिस्टोफर्सन