allgemein lag in den Zeitreihen, panel Daten

Ich habe einen Datensatz, der ähnlich wie dieser

User    Date        Value
A       2012-01-01  4
A       2012-01-02  5   
A       2012-01-03  6
A       2012-01-04  7
B       2012-01-01  2
B       2012-01-02  3   
B       2012-01-03  4
B       2012-01-04  5

Ich möchte erstellen Sie eine Verzögerung von Value unter Wahrung User.

User    Date        Value   Value.lag
A       2012-01-01  4       NA
A       2012-01-02  5       4
A       2012-01-03  6       5
A       2012-01-04  7       6
B       2012-01-01  2       NA
B       2012-01-02  3       2   
B       2012-01-03  4       3
B       2012-01-04  5       4

Habe ich es geschafft sehr ineffizient in einer Schleife

df$value.lag1<-NA
levs<-levels(as.factor(df$User))
levs
  for (i in 1:length(levs)) {
    temper<- subset(df,User==as.numeric(levs[i]))
    temper<- rbind(NA,temper[-nrow(temper),])  
df$value.lag1[df$User==as.numeric(as.character(levs[i]))]<- temper
      }

Dieser ist aber sehr langsam. Ich habe mit by und tapply, aber nicht herausgefunden, wie man Ihnen zu arbeiten.

Ich glaube nicht, dass XTS oder TS arbeiten wird, weil der Benutzer das element.

Irgendwelche Vorschläge?

Ich denke, die plm Paket ist eine Implementierung für diese Art von Daten.

InformationsquelleAutor Daniel Egan | 2012-01-18

lag r time-series

Können Sie ddply: schneidet den Daten.Rahmen in Stücke und verwandelt jedes Stück.

d <- data.frame( 
  User = rep( LETTERS[1:3], each=10 ),
  Date = seq.Date( Sys.Date(), length=30, by="day" ),
  Value = rep(1:10, 3)
)
library(plyr)
d <- ddply( 
  d, .(User), transform,
  # This assumes that the data is sorted
  Value = c( NA, Value[-length(Value)] ) 
)

Folgende stackoverflow.com/questions/1296646/... Sortieren kann mit arrange()

InformationsquelleAutor Vincent Zoonekynd

4

Ich denke, der einfachste Weg, zumal eine weitere Analyse zu konvertieren Ihre Daten-frame zu pdata.frame Klasse aus plm Paket.

Nach der Umwandlung von diff() und lag() Operatoren können verwendet werden zu erstellen-panel lag und Unterschiede.
```
df<-pdata.frame(df,index=c("id","date")
df<-transofrm(df, l_value=lag(value,1))
```
- elegante Antwort-mit nur lag (), um die Zeit berechnen, die Verzögerung als eine neue variable, nachdem es umgewandelt zu einem pdata.frame auch funktioniert!
InformationsquelleAutor Andriy Levitskyy

Stolperte ich über ein ähnliches problem, und schrieb eine Funktion.

#df needs to be a structured balanced paneldata set sorted by id and date
#OBS the function deletes the row where the NA value would have been.

df <- data.frame(id = c(1, 1, 1, 1, 1, 2, 2,2,2,2), 
                 date = c(1992, 1993, 1991, 1990, 1994, 1992, 1991
                          ,1994,1990,1993), 
                 value = c(4.1, 4.5, 3.3, 5.3, 3.0, 3.2, 5.2,5.3,3.4,5.6))
# sort paneldata set
library(dplyr)
df<-arrange(df,id,date)

#Function
# a=df
# b=colname of variable/variables that you want to lag
# q=number of lag years
# t=colname of date/time column
retraso<-function(a,b,q,t){

  sto<-max(as.numeric(unique(a[[t]])))
  sta<-min(as.numeric(unique(a[[t]])))

  yo<-a[which(a[[t]]>=(sta+q)),]

  la<-function(a,d,t,sto,sta){


    ja<-data.frame(a[[d]],a[[t]])
    colnames(ja)<-c(d,t)


    ja<-ja[which(ja[[t]]<=(sto-q)),1]
    return(ja)
  }

  for (i in 1:length(b)){

    yo[[b[i]]] <-la(a,b[i],t,sto,sta)

    }
    return(yo)

  }

#lag df 1 year
df<-retraso(df,"value",1,"date")

InformationsquelleAutor Niltzable

1

Wenn Sie keine Lücken in der Zeit variabel , tun
```
df %>% group_by(User) %>% mutate(value_lag = lag(value, order_by =Date)
```
Wenn Sie Lücken in der Zeit variabel, Lesen Sie diese Antwort
https://stackoverflow.com/a/26108191/3662288

InformationsquelleAutor Matthew

Für ein panel ohne fehlende obs das ist eine intuitive Lösung:

df <- data.frame(id = c(1, 1, 1, 1, 1, 2, 2), 
                 date = c(1992, 1993, 1991, 1990, 1994, 1992, 1991), 
                 value = c(4.1, 4.5, 3.3, 5.3, 3.0, 3.2, 5.2))

df<-df[with(df, order(id,date)), ]  # sort by id and then by date
df$l_value=c(NA,df$value[-length(df$value)]) # create a new var with data displaced by 1 unit
df$l_value[df$id != c(NA, df$id[-length(df$id)])] =NA # NA data with different current and lagged id.
df

id date value l_value
4  1 1990   5.3      NA
3  1 1991   3.3     5.3
1  1 1992   4.1     3.3
2  1 1993   4.5     4.1
5  1 1994   3.0     4.5
7  2 1991   5.2      NA
6  2 1992   3.2     5.2

InformationsquelleAutor Fix.B.

Ähnlich, Sie könnte verwenden tapply

# Create Data
user = c(rep('A',4),rep('B',4))
date = rep(seq(as.Date('2012-01-01'),as.Date('2012-01-04'),1),2)
value = c(4:7,2:5) 
df = data.frame(user,date,value)
# Get lagged values
df$value.lag = unlist(tapply(df$value, df$user, function(x) c(NA,x[-length(df$value)])))

Die Idee ist genau die gleiche: Wert annehmen, es teilen, durch den Benutzer, und führen Sie dann eine Funktion auf jeder Teilmenge. Die unlist bringt es zurück in vector format.

InformationsquelleAutor nograpes

Vorausgesetzt, die Tabelle ist sortiert, der Benutzer und das Datum, diese kann getan werden, mit zoo. Der trick ist, nicht auf einen index angeben, an dieser Stelle.

library(zoo)
df <-read.table(text="User Date Value
A 2012-01-01 4
A 2012-01-02 5
A 2012-01-03 6
A 2012-01-04 7
B 2012-01-01 2
B 2012-01-02 3
B 2012-01-03 4
B 2012-01-04 5", header=TRUE, as.is=TRUE,sep = " ")

out <-zoo(df)

Value.lag <-lag(out,-1)[out$User==lag(out$User)]
res <-merge.zoo(out,Value.lag)
res <-res[,-(4:5)]  # to remove extra columns

  User.out Date.out   Value.out Value.Value.lag
1 A        2012-01-01 4         <NA>           
2 A        2012-01-02 5         4              
3 A        2012-01-03 6         5              
4 A        2012-01-04 7         6              
5 B        2012-01-01 2         <NA>           
6 B        2012-01-02 3         2              
7 B        2012-01-03 4         3              
8 B        2012-01-04 5         4

InformationsquelleAutor Pierre Lapointe

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.