प्रतिगमन जब

मैंने बनाया दो चर की माप और । वे दोनों अनिश्चितताओं को जानते हैं और उन लोगों के साथ जुड़ा हुआ है। मैं और बीच संबंध खोजना चाहता हूं । मैं यह कैसे कर सकता हूं? $n$ $x$ $y$ $\sigma_x$ $\sigma_y$ $x$ $y$

संपादित करें : प्रत्येक एक अलग है इसके साथ जुड़े, और के साथ एक ही । $x_i$ $\sigma_{x,i}$ $y_i$

Reproducible R उदाहरण:

## pick some real x and y values 
true_x <- 1:100
true_y <- 2*true_x+1

## pick the uncertainty on them
sigma_x <- runif(length(true_x), 1, 10) # 10
sigma_y <- runif(length(true_y), 1, 15) # 15

## perturb both x and y with noise 
noisy_x <- rnorm(length(true_x), true_x, sigma_x)
noisy_y <- rnorm(length(true_y), true_y, sigma_y)

## make a plot 
plot(NA, xlab="x", ylab="y",
    xlim=range(noisy_x-sigma_x, noisy_x+sigma_x), 
    ylim=range(noisy_y-sigma_y, noisy_y+sigma_y))
arrows(noisy_x, noisy_y-sigma_y, 
       noisy_x, noisy_y+sigma_y, 
       length=0, angle=90, code=3, col="darkgray")
arrows(noisy_x-sigma_x, noisy_y,
       noisy_x+sigma_x, noisy_y,
       length=0, angle=90, code=3, col="darkgray")
points(noisy_y ~ noisy_x)

## fit a line 
mdl <- lm(noisy_y ~ noisy_x)
abline(mdl)

## show confidence interval around line 
newXs <- seq(-100, 200, 1)
prd <- predict(mdl, newdata=data.frame(noisy_x=newXs), 
    interval=c('confidence'), level=0.99, type='response')
lines(newXs, prd[,2], col='black', lty=3)
lines(newXs, prd[,3], col='black', lty=3)

इस उदाहरण के साथ समस्या यह है कि मुझे लगता है कि यह मानता है कि में अनिश्चितताएं नहीं हैं । मैं इसे कैसे ठीक करूं? $x$

r regression deming-regression

— rhombidodecahedron
स्रोत

lm

Y

$Y$

P (Y | X)

$P(Y | X)$

Y

$Y$

X

$X$

X

$X$

आपके बजाय विशेष मामले के लिए (एक्स और वाई के लिए शोर के स्तर के ज्ञात अनुपात के साथ अविभाजित ) डेमिंग रिग्रेशन ट्रिक करेगा, जैसे कि Demingआर पैकेज मेथकॉम में फ़ंक्शन ।

— संयुक्ताक्षर

@conjugateprior धन्यवाद, यह आशाजनक लगता है। मैं सोच रहा हूँ: क्या डेमिंग प्रतिगमन अभी भी काम करता है अगर मेरे पास प्रत्येक व्यक्ति x और y पर एक अलग (लेकिन अभी भी ज्ञात) विचरण है? यानी एक्स के समान नहीं हैं, और मैं प्रत्येक x प्राप्त करने के लिए अलग अलग precisions के साथ शासकों का इस्तेमाल किया है, तो

— rhombidodecahedron

मुझे लगता है कि शायद इसे हल करने का तरीका जब प्रत्येक माप के लिए अलग-अलग संस्करण हैं, यॉर्क की विधि का उपयोग कर रहा है। क्या किसी को पता है कि क्या इस पद्धति का एक आर कार्यान्वयन है?

— rhombidodecahedron

@rhombidodecahedron मेरे जवाब में "मापी गई त्रुटियों के साथ" देखें, जो मेरे जवाब में फिट बैठता है: आंकड़े.stackexchange.com/questions/174533/… (जो पैकेज डिमिंग के प्रलेखन से लिया गया था)।

— रोलैंड

जवाबों:

$L$ $\theta$ $\gamma$

(x, y) : \cos (θ) x + \sin (θ) y = γ .

$(x,y): \cos(\theta) x + \sin(\theta) y = \gamma.$

$(x,y)$

d (x, y; L) = \cos (θ) x + \sin (θ) y - γ .

$d(x,y;L) = \cos(\theta) x + \sin(\theta) y - \gamma.$

$x_i$ $\sigma_i^2$ $y_i$ $\tau_i^2$ $x_i$ $y_i$

Var (d (x_{i}, y_{i}; L)) = \cos^{2} (θ) σ_{i}^{2} + \sin^{2} (θ) τ_{i}^{2} .

$\operatorname{Var}(d(x_i,y_i;L)) = \cos^2(\theta)\sigma_i^2 + \sin^2(\theta)\tau_i^2.$

$\theta$ $\gamma$

$\sigma_i$ $\tau_i$ $0$

$\tau_i$ $\sigma_i$ $x$ $n=8$

असली रेखा को बिंदीदार नीले रंग में दिखाया गया है। इसके साथ मूल बिंदु खोखले हलकों के रूप में प्लॉट किए गए हैं। ग्रे तीर उन्हें ठोस काले डिस्क के रूप में प्लॉट किए गए बिंदुओं से जोड़ते हैं। समाधान एक ठोस लाल रेखा के रूप में खींचा गया है। मनाया और वास्तविक मूल्यों के बीच बड़े विचलन की उपस्थिति के बावजूद, समाधान उल्लेखनीय रूप से इस क्षेत्र के भीतर सही रेखा के करीब है।

#
# Generate data.
#
theta <- c(1, -2, 3) # The line is theta %*% c(x,y,-1) == 0
theta[-3] <- theta[-3]/sqrt(crossprod(theta[-3]))
n <- 8
set.seed(17)
sigma <- rexp(n, 1/2)
tau <- rexp(n, 1)
u <- 1:n
xy.0 <- t(outer(c(-theta[2], theta[1]), 0:(n-1)) + c(theta[3]/theta[1], 0))
xy <- xy.0 + cbind(rnorm(n, sd=sigma), rnorm(n, sd=tau))
#
# Fit a line.
#
x <- xy[, 1]
y <- xy[, 2]
f <- function(phi) { # Negative log likelihood, up to an additive constant
  a <- phi[1]
  gamma <- phi[2]
  sum((x*cos(a) + y*sin(a) - gamma)^2 / ((sigma*cos(a))^2 + (tau*sin(a))^2))/2
}
fit <- lm(y ~ x) # Yields starting estimates
slope <- coef(fit)[2]
theta.0 <- atan2(1, -slope)
gamma.0 <- coef(fit)[1] / sqrt(1 + slope^2)
sol <- nlm(f,c(theta.0, gamma.0))
#
# Plot the data and the fit.
#
theta.hat <- sol$estimate[1] %% (2*pi)
gamma.hat <- sol$estimate[2]
plot(rbind(xy.0, xy), type="n", xlab="x", ylab="y")
invisible(sapply(1:n, function(i) 
  arrows(xy.0[i,1], xy.0[i,2], xy[i,1], xy[i,2], 
         length=0.15, angle=20, col="Gray")))
points(xy.0)
points(xy, pch=16)
abline(c(theta[3] / theta[2], -theta[1]/theta[2]), col="Blue", lwd=2, lty=3)
abline(c(gamma.hat / sin(theta.hat), -1/tan(theta.hat)), col="Red", lwd=2)

— व्हीबर
स्रोत

+1। जहाँ तक मैं समझता हूँ, यह इस पुराने Q का भी उत्तर देता है : ysts.stackexchange.com/questions/178727 ? हमें इसे एक डुप्लिकेट के रूप में बंद करना चाहिए।

— अमीबा का कहना है कि

इसके अलावा, उस सूत्र में उत्तर के लिए मेरी टिप्पणी के अनुसार, ऐसा लगता है कि demingफ़ंक्शन चर त्रुटियों को भी संभाल सकता है। यह शायद आप के समान एक फिट उपज चाहिए।

— अमीबा का कहना है कि मोनिका

मुझे आश्चर्य है कि क्या चर्चा का प्रवाह अधिक समझ में आता है यदि आप आकृति के ऊपर और नीचे 2 पैराग्राफ के स्थानों को स्विच करते हैं?

— गूँग - मोनिका

मुझे आज सुबह (एक मतदाता द्वारा) याद दिलाया गया कि यह प्रश्न कई वर्षों से, वर्किंग कोड के साथ, कई वर्षों पहले मैथेमेटिका एसई साइट पर पूछा और उत्तर दिया गया था ।

— whuber

क्या इस समाधान का कोई नाम है? और संभवतः आगे पढ़ने के लिए एक संसाधन (गणितज्ञ एसई साइट के अलावा मेरा मतलब है)?

— JustGettinStarted

एक्स और वाई में अनिश्चितताओं के मामले के लिए अधिकतम संभावना अनुकूलन यॉर्क (2004) द्वारा संबोधित किया गया है। यहाँ उनके फ़ंक्शन के लिए R कोड है।

"यॉर्कफिट", रिक वेहर द्वारा लिखित, 2011 में, राहेल चांग द्वारा आर में अनुवाद किया गया

चर के साथ डेटा के लिए सबसे अच्छी सीधी रेखा को खोजने के लिए सार्वभौमिक दिनचर्या, सहसंबद्ध त्रुटियां, जिसमें त्रुटि और फिट अनुमान की अच्छाई शामिल है, Eq के बाद। (१३) यॉर्क २००४, अमेरिकन जर्नल ऑफ़ फिज़िक्स, जो कि १ ९ ६ ९ में बदले में आधारित था, पृथ्वी और ग्रह विज्ञान के अवसर

यॉर्कफिट <- फ़ंक्शन (X, Y, Xstd, Ystd, Ri = 0, b0 = 0, printCoefs = 0, makeLine = 0, eps = 1e-7)

X, Y, Xstd, Ystd: X अंक, Y अंक और उनके मानक विचलन वाली तरंगें

चेतावनी: Xstd और Ystd शून्य नहीं हो सकते क्योंकि इससे Xw या Yw NaN होगा। इसके बजाय बहुत छोटे मूल्य का उपयोग करें।

री: X और Y त्रुटियों के लिए सहसंबंध गुणांक - लंबाई 1 या X और Y की लंबाई

b0: ढलान के लिए मोटा प्रारंभिक अनुमान (बिना किसी त्रुटि के एक मानक न्यूनतम-वर्ग से प्राप्त किया जा सकता है)

PrintCoefs: कमांड विंडो में परिणाम प्रदर्शित करने के लिए 1 के बराबर सेट करें

मेकलाइन: फिट लाइन के लिए वाई तरंग उत्पन्न करने के लिए 1 के बराबर सेट

अवरोधन और ढलान के साथ एक मैट्रिक्स लौटाता है और साथ ही उनकी अनिश्चितता भी

यदि b0 के लिए कोई प्रारंभिक अनुमान नहीं दिया गया है, तो बस OLS का उपयोग करें (b0 == 0) {b0 = lm (Y ~ X) $ गुणांक [2]}

tol = abs(b0)*eps #the fit will stop iterating when the slope converges to within this value

a, b: अंतिम अवरोधन और ढलान a .err, b.err: अनुमानित अवरोधन और ढलान

# WAVE DEFINITIONS #

Xw = 1/(Xstd^2) #X weights
Yw = 1/(Ystd^2) #Y weights


# ITERATIVE CALCULATION OF SLOPE AND INTERCEPT #

b = b0
b.diff = tol + 1
while(b.diff>tol)
{
    b.old = b
    alpha.i = sqrt(Xw*Yw)
    Wi = (Xw*Yw)/((b^2)*Yw + Xw - 2*b*Ri*alpha.i)
    WiX = Wi*X
    WiY = Wi*Y
    sumWiX = sum(WiX, na.rm = TRUE)
    sumWiY = sum(WiY, na.rm = TRUE)
    sumWi = sum(Wi, na.rm = TRUE)
    Xbar = sumWiX/sumWi
    Ybar = sumWiY/sumWi
    Ui = X - Xbar
    Vi = Y - Ybar

    Bi = Wi*((Ui/Yw) + (b*Vi/Xw) - (b*Ui+Vi)*Ri/alpha.i)
    wTOPint = Bi*Wi*Vi
    wBOTint = Bi*Wi*Ui
    sumTOP = sum(wTOPint, na.rm=TRUE)
    sumBOT = sum(wBOTint, na.rm=TRUE)
    b = sumTOP/sumBOT

    b.diff = abs(b-b.old)
  }     

   a = Ybar - b*Xbar
   wYorkFitCoefs = c(a,b)

# ERROR CALCULATION #

Xadj = Xbar + Bi
WiXadj = Wi*Xadj
sumWiXadj = sum(WiXadj, na.rm=TRUE)
Xadjbar = sumWiXadj/sumWi
Uadj = Xadj - Xadjbar
wErrorTerm = Wi*Uadj*Uadj
errorSum = sum(wErrorTerm, na.rm=TRUE)
b.err = sqrt(1/errorSum)
a.err = sqrt((1/sumWi) + (Xadjbar^2)*(b.err^2))
wYorkFitErrors = c(a.err,b.err)

# GOODNESS OF FIT CALCULATION #
lgth = length(X)
wSint = Wi*(Y - b*X - a)^2
sumSint = sum(wSint, na.rm=TRUE)
wYorkGOF = c(sumSint/(lgth-2),sqrt(2/(lgth-2))) #GOF (should equal 1 if assumptions are valid), #standard error in GOF

# OPTIONAL OUTPUTS #

if(printCoefs==1)
 {
    print(paste("intercept = ", a, " +/- ", a.err, sep=""))
    print(paste("slope = ", b, " +/- ", b.err, sep=""))
  }
if(makeLine==1)
 {
    wYorkFitLine = a + b*X
  }
 ans=rbind(c(a,a.err),c(b, b.err)); dimnames(ans)=list(c("Int","Slope"),c("Value","Sigma"))
return(ans)
 }

— स्टीवन वोफी
स्रोत

यह भी ध्यान दें, R पैकेज "IsoplotR" में यार्क () फ़ंक्शन शामिल है, जो योरफ़िट कोड के समान परिणाम देता है।

— स्टीवन वोफ़्सी