studio - superponer graficas en r

¿Cómo ajustar una curva suave a mis datos en R?

Question

Estoy tratando de dibujar una curva suave en R Tengo los siguientes datos simples de juguete:

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

Ahora, cuando lo trazo con un comando estándar, se ve lleno de baches y nervioso, por supuesto:

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

¿Cómo puedo hacer que la curva sea suave para que los 3 bordes se redondeen usando valores estimados? Sé que hay muchos métodos para adaptarse a una curva suave, pero no estoy seguro de cuál sería el más adecuado para este tipo de curva y cómo lo escribirías en R

Answer 1

En ggplot2 puedes hacer suavizaciones de varias maneras, por ejemplo:

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)

Answer 2

LOESS es un enfoque muy bueno, como dijo Dirk.

Otra opción es utilizar las splines de Bezier, que en algunos casos pueden funcionar mejor que LOESS si no tienes muchos puntos de datos.

Aquí encontrará un ejemplo: 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")

Answer 3

Las otras respuestas son todos buenos enfoques. Sin embargo, hay algunas otras opciones en R que no se han mencionado, incluidas lowess y approx , que pueden dar mejores ajustes o un rendimiento más rápido.

Las ventajas se demuestran más fácilmente con un conjunto de datos alternativo:

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)))

Aquí están los datos superpuestos con la curva sigmoidea que lo generó:

Este tipo de datos es común cuando se observa un comportamiento binario entre una población. Por ejemplo, esto podría ser una trama de si un cliente compró algo (un 1/0 binario en el eje y) frente a la cantidad de tiempo que pasó en el sitio (eje x).

Se usa una gran cantidad de puntos para demostrar mejor las diferencias de rendimiento de estas funciones.

Smooth , spline y smooth.spline producen un galimatías en un conjunto de datos como este con cualquier conjunto de parámetros que he intentado, tal vez debido a su tendencia a mapear cada punto, lo que no funciona para los datos ruidosos.

Las funciones loess , lowess y approx producen todos resultados utilizables, aunque apenas por approx . Este es el código para cada uno que usa parámetros ligeramente optimizados:

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))

Y los resultados:

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"))

Como puede ver, lowess produce un ajuste casi perfecto a la curva de generación original. Loess está cerca, pero experimenta una desviación extraña en ambas colas.

Aunque su conjunto de datos será muy diferente, he encontrado que otros conjuntos de datos funcionan de manera similar, con loess y lowess capaces de producir buenos resultados. Las diferencias se vuelven más significativas cuando observa los puntos de referencia:

> 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 es extremadamente lento, tomando 100x tan largo como approx . Lowess produce mejores resultados que approx , mientras sigue funcionando bastante rápido ( Lowess más rápido que loess).

Loess también se empantana cada vez más a medida que aumenta el número de puntos, llegando a ser inutilizable alrededor de 50,000.

EDITAR: Investigaciones adicionales muestran que loess da mejores ajustes para ciertos conjuntos de datos. Si está tratando con un pequeño conjunto de datos o el rendimiento no es una consideración, pruebe ambas funciones y compare los resultados.

Answer 4

Me gusta loess() mucho para suavizar:

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)

El libro MASS de Venables y Ripley tiene una sección completa sobre suavizado que también cubre splines y polinomios, pero loess() es casi el favorito de todos.

Answer 5

Para conseguirlo REALMENTE smoooth ...

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)

Este estilo interpola muchos puntos extra y te ofrece una curva que es muy suave. También parece ser el enfoque que toma ggplot. Si el nivel estándar de suavidad es bueno, puede usarlo.

scatter.smooth(x, y)

Answer 6

Tal vez smooth.spline es una opción, puede establecer un parámetro de suavizado (generalmente entre 0 y 1) aquí

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

también puede usar predecir en objetos smooth.spline. La función viene con la base R, ver? Smooth.spline para más detalles.

Answer 7

la función qplot () en el paquete ggplot2 es muy simple de usar y proporciona una solución elegante que incluye bandas de confianza. Por ejemplo,

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

produce