आर में मेरे डेटा के लिए एक चिकनी वक्र कैसे फिट करें?

Question 1

मैं एक चिकनी वक्र आकर्षित करने की कोशिश कर रहा हूं R। मैं निम्नलिखित सरल खिलौना डेटा है:

> x
 [1]  1  2  3  4  5  6  7  8  9 10
> y
 [1]  2  4  6  8  7 12 14 16 18 20

अब जब मैं इसे एक मानक आदेश के साथ प्लॉट करता हूं तो यह उबाऊ और नुकीला लगता है:

> plot(x,y, type='l', lwd=2, col='red')

मैं वक्र को चिकना कैसे बना सकता हूं ताकि अनुमानित मूल्यों का उपयोग करके 3 किनारों को गोल किया जाए? मुझे पता है कि एक चिकनी वक्र फिट करने के कई तरीके हैं लेकिन मुझे यकीन नहीं है कि इस प्रकार के वक्र के लिए कौन सा सबसे उपयुक्त होगा और आप इसमें कैसे लिखेंगे R।

Question 2

मुझे loess()चौरसाई करना बहुत पसंद है:

x <- 1:10
y <- c(2,4,6,8,7,12,14,16,18,20)
lo <- loess(y~x)
plot(x,y)
lines(predict(lo), col='red', lwd=2)

वेनेबल्स और रिप्ले की एमएएस पुस्तक में चौरसाई पर एक पूरा खंड है जो स्प्लिन और बहुपद को भी कवर करता है - लेकिन loess()यह हर किसी के पसंदीदा के बारे में है।

Question 3

शायद smooth.spline एक विकल्प है, आप यहां एक चौरसाई पैरामीटर (आमतौर पर 0 और 1 के बीच) सेट कर सकते हैं

smoothingSpline = smooth.spline(x, y, spar=0.35)
plot(x,y)
lines(smoothingSpline)

तुम भी smooth.spline वस्तुओं पर भविष्यवाणी का उपयोग कर सकते हैं। फ़ंक्शन आर के साथ आता है, विवरण के लिए देखें? Smooth.spline।

Question 4

वास्तव में इसे प्राप्त करने के लिए ...

x <- 1:10
y <- c(2,4,6,8,7,8,14,16,18,20)
lo <- loess(y~x)
plot(x,y)
xl <- seq(min(x),max(x), (max(x) - min(x))/1000)
lines(xl, predict(lo,xl), col='red', lwd=2)

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

scatter.smooth(x, y)

Question 5

qplot () ggplot2 पैकेज में समारोह का उपयोग करने के बहुत सरल है और एक सुरुचिपूर्ण समाधान है कि आत्मविश्वास बैंड भी शामिल है प्रदान करता है। उदाहरण के लिए,

qplot(x,y, geom='smooth', span =0.5)

पैदा करता है यहाँ छवि विवरण दर्ज करें

Question 6

LOESS एक बहुत अच्छा दृष्टिकोण है, जैसा कि डिर्क ने कहा।

एक अन्य विकल्प बेजियर स्प्लिन्स का उपयोग कर रहा है, जो कुछ मामलों में LOESS से बेहतर काम कर सकता है यदि आपके पास कई डेटा बिंदु नहीं हैं।

यहां आपको एक उदाहरण मिलेगा: http://rosettacode.org/wiki/Cubic_bezier_curves#R

# x, y: the x and y coordinates of the hull points
# n: the number of points in the curve.
bezierCurve <- function(x, y, n=10)
    {
    outx <- NULL
    outy <- NULL

    i <- 1
    for (t in seq(0, 1, length.out=n))
        {
        b <- bez(x, y, t)
        outx[i] <- b$x
        outy[i] <- b$y

        i <- i+1
        }

    return (list(x=outx, y=outy))
    }

bez <- function(x, y, t)
    {
    outx <- 0
    outy <- 0
    n <- length(x)-1
    for (i in 0:n)
        {
        outx <- outx + choose(n, i)*((1-t)^(n-i))*t^i*x[i+1]
        outy <- outy + choose(n, i)*((1-t)^(n-i))*t^i*y[i+1]
        }

    return (list(x=outx, y=outy))
    }

# Example usage
x <- c(4,6,4,5,6,7)
y <- 1:6
plot(x, y, "o", pch=20)
points(bezierCurve(x,y,20), type="l", col="red")

Question 7

अन्य उत्तर सभी अच्छे दृष्टिकोण हैं। हालांकि, आर में कुछ अन्य विकल्प हैं , जिनका उल्लेख नहीं किया गया है, जिनमें शामिल हैं lowessऔर approx, जो बेहतर फिट या तेज प्रदर्शन दे सकते हैं।

वैकल्पिक डेटासेट के साथ फायदे अधिक आसानी से प्रदर्शित होते हैं:

sigmoid <- function(x)
{
  y<-1/(1+exp(-.15*(x-100)))
  return(y)
}

dat<-data.frame(x=rnorm(5000)*30+100)
dat$y<-as.numeric(as.logical(round(sigmoid(dat$x)+rnorm(5000)*.3,0)))

यहाँ सिग्मॉइड वक्र के साथ डेटा ओवरलेड है जो इसे उत्पन्न करता है:

आबादी के बीच द्विआधारी व्यवहार को देखते हुए इस तरह का डेटा आम है। उदाहरण के लिए, यह ग्राहक द्वारा साइट पर खर्च किए गए समय (x- अक्ष) की राशि के अनुसार कुछ खरीदा (या एक द्विआधारी y- अक्ष पर 1) हो सकता है।

इन कार्यों के प्रदर्शन अंतर को बेहतर ढंग से प्रदर्शित करने के लिए बड़ी संख्या में बिंदुओं का उपयोग किया जाता है।

Smooth, splineऔरsmooth.spline सभी इस तरह के मापदंडों के किसी भी सेट के साथ एक डेटासेट पर gibberish का उत्पादन करते हैं, शायद मैंने हर बिंदु पर मैप करने की उनकी प्रवृत्ति के कारण, जो शोर डेटा के लिए काम नहीं करता है।

हालांकि loess, lowessऔर approxफ़ंक्शन सभी उपयोग करने योग्य परिणाम उत्पन्न करते हैं, हालांकि अभी मुश्किल से ही approx। यह हल्के से अनुकूलित मापदंडों का उपयोग करने वाले प्रत्येक के लिए कोड है:

loessFit <- loess(y~x, dat, span = 0.6)
loessFit <- data.frame(x=loessFit$x,y=loessFit$fitted)
loessFit <- loessFit[order(loessFit$x),]

approxFit <- approx(dat,n = 15)

lowessFit <-data.frame(lowess(dat,f = .6,iter=1))

और परिणाम:

plot(dat,col='gray')
curve(sigmoid,0,200,add=TRUE,col='blue',)
lines(lowessFit,col='red')
lines(loessFit,col='green')
lines(approxFit,col='purple')
legend(150,.6,
       legend=c("Sigmoid","Loess","Lowess",'Approx'),
       lty=c(1,1),
       lwd=c(2.5,2.5),col=c("blue","green","red","purple"))

जैसा कि आप देख सकते हैं, lowessमूल उत्पादक वक्र के पास एक सही फिट का उत्पादन करता है। Loessकरीब है, लेकिन दोनों पूंछों में एक अजीब विचलन का अनुभव करता है।

यद्यपि आपका डेटासेट बहुत अलग होगा, मैंने पाया है कि अन्य डेटासेट समान रूप से प्रदर्शन करते हैं, दोनों के साथ loessऔर lowessअच्छे परिणाम देने में सक्षम हैं। जब आप बेंचमार्क देखते हैं तो अंतर अधिक महत्वपूर्ण हो जाते हैं:

> microbenchmark::microbenchmark(loess(y~x, dat, span = 0.6),approx(dat,n = 20),lowess(dat,f = .6,iter=1),times=20)
Unit: milliseconds
                           expr        min         lq       mean     median        uq        max neval cld
  loess(y ~ x, dat, span = 0.6) 153.034810 154.450750 156.794257 156.004357 159.23183 163.117746    20   c
            approx(dat, n = 20)   1.297685   1.346773   1.689133   1.441823   1.86018   4.281735    20 a  
 lowess(dat, f = 0.6, iter = 1)   9.637583  10.085613  11.270911  11.350722  12.33046  12.495343    20  b

Loessबेहद धीमी है, जब तक 100x ले रही है approx। Lowessकी तुलना में बेहतर परिणाम पैदा करता है approx, जबकि अभी भी काफी तेजी से चल रहा है (15x तेजी से कम)।

Loess 50,000 की संख्या के आसपास अनुपयोगी होने के कारण अंकों की संख्या बढ़ने के साथ-साथ तेजी भी बढ़ती जा रही है।

EDIT: अतिरिक्त शोध से पता चलता है कि loessकुछ डेटासेट के लिए बेहतर फिट बैठता है। यदि आप एक छोटे डेटासेट के साथ काम कर रहे हैं या प्रदर्शन एक विचार नहीं है, तो दोनों कार्यों का प्रयास करें और परिणामों की तुलना करें।

Question 8

Ggplot2 में आप उदाहरण के लिए कई तरह से स्मूथी कर सकते हैं:

library(ggplot2)
ggplot(mtcars, aes(wt, mpg)) + geom_point() +
  geom_smooth(method = "gam", formula = y ~ poly(x, 2)) 
ggplot(mtcars, aes(wt, mpg)) + geom_point() +
  geom_smooth(method = "loess", span = 0.3, se = FALSE)

Question 9

मैंने इस विधि को दिखाया नहीं था, इसलिए यदि कोई और ऐसा करना चाह रहा है तो मैंने पाया कि ggplot प्रलेखन ने उस gamविधि का उपयोग करने के लिए एक तकनीक का सुझाव दिया जो loessछोटे डेटा सेटों के साथ काम करते समय समान परिणाम उत्पन्न करती है ।

library(ggplot2)
x <- 1:10
y <- c(2,4,6,8,7,8,14,16,18,20)

df <- data.frame(x,y)
r <- ggplot(df, aes(x = x, y = y)) + geom_smooth(method = "gam", formula = y ~ s(x, bs = "cs"))+geom_point()
r

पहले लोस विधि और ऑटो फॉर्मूला के साथ दूसरा सुझाव फार्मूला के साथ गम विधि के साथ