[R-es] Corregir mismo ID para individuos diferentes en una serie temporal

Mar Ene 26 14:27:42 CET 2016

Hola,

Sí, sería en ese punto.
Bueno, ya sabes, para la próxima...pregunta primero en esta lista... ;-).

Me alegro de que funcione,
Carlos.

El 26 de enero de 2016, 14:17, Ruben Bermad <ruben_bm en hotmail.com> escribió:

> Funciona perfectamente !!!
>
> Solo una duda respecto al codigo, lo he estado mirando para saber que
> parte tengo que cambiar si quiero modificar el periodo en el que considero
> un individuo como el mismo, y creo que es la linea:
>
> if( (new_df$hmyears[max(coin)] < 2) & (df$Year[i] - df$Year[max(coin)]) <
> 2 ) {
>
> estoy en lo cierto? Por lo que si quiero poner 3 años sustituyo los "2"
> por "3", no?
>
> He comprobado que funciona, pero quisiera saber si estoy modificando algo
> que no deba, y quizas no lo vea en este ejemplo.
>
> Muchisimas gracias por tu ayuda, llevaba dando vueltas a este tema varios
> meses.
> Saludos,
> Ruben
>
> ------------------------------
> Date: Tue, 26 Jan 2016 12:55:55 +0100
>
> Subject: Re: [R-es] Corregir mismo ID para individuos diferentes en una
> serie temporal
> From: cof en qualityexcellence.es
> To: ruben_bm en hotmail.com
> CC: r-help-es en r-project.org
>
> Hola,
>
> Please, mira si esta vez funciona:
>
> #----------------------------------------------
> ID <- c(1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6,
> 1, 2, 6, 8, 12, 7, 15, 16, 17, 18, 19, 20, 1, 21, 22, 19 )
> Year <- c (1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
> 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6)
> df <- data.frame (ID, Year)
> df
>
> ID <- c(1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6,
> 1, 2, 6, 8, 12, 7, 15, 16, 17, 18, 19, 20, 1, 21, 22, 19 )
> Year <- c (1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
> 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 1, 6, 6, 6)
> new_ID <- c("A", "B", "C", "D", "E", "F", "G", "A", "B", "C", "H", "I",
> "J", "K", "L", "M", "N", "O", "P", "Q", "R", "M", "N", "Q", "S", "L", "T",
> "U", "V", "W", "X", "Y", "Z", "CC", "AA", "BB", "Y")
> ref_df <- data.frame (ID, Year, new_ID)
> ref_df
>
> rep_val <- rep(0, nrow(df))
> new_df <- data.frame(ID=rep_val, Year=rep_val, newID=rep_val,
> hmyears=rep_val)
> for(i in 1:nrow(df)) { #Cero
>   print(i)
>   if(i==1) {
>     new_df$ID[i] <- df$ID[i]
>     new_df$Year[i] <- df$Year[i]
>     new_df$newID[i] <- df$ID[i]
>     new_df$hmyears[i] <- 1
>   } else {                                #Uno
>     coin <- which(df$ID[i]==df$ID[1:(i-1)])
>     print(coin)
>     if(length(coin) < 1 ) {
>       new_df$ID[i] <- df$ID[i]
>       new_df$Year[i] <- df$Year[i]
>       if(length(which(df$ID[i]==new_df$newID)) < 1) {new_df$newID[i] <-
> df$ID[i]} else {new_df$newID[i] <- max(new_df$newID)+1}
>       new_df$hmyears[i] <- 1
>     } else {                              #Dos
>       if( (new_df$hmyears[max(coin)] < 2) & (df$Year[i] -
> df$Year[max(coin)]) < 2 ) {
>         new_df$ID[i] <- df$ID[i]
>         new_df$Year[i] <- df$Year[i]
>         new_df$newID[i] <- new_df$newID[max(coin)]
>         new_df$hmyears[i] <- new_df$hmyears[max(coin)] + 1
>       } else {                            #Tres
>         new_df$ID[i] <- df$ID[i]
>         new_df$Year[i] <- df$Year[i]
>         new_df$newID[i] <- max(new_df$newID) + 1
>         new_df$hmyears[i] <- 1
>       } #Tres
>     } #Dos
>   } #Uno
> } #Cero
> new_df
>
> #----------------------------------------------
>
>
>
>
>
>
> El 26 de enero de 2016, 12:17, Carlos Ortega <cof en qualityexcellence.es>
> escribió:
>
> Hola,
>
> Cierto. No había tenido en cuenta que los años donde se registra un
> individuo pueden no ser consecutivos.
> Ahora que creo que entiendo la dinámica, veo como incluir esta condición
> en el código cuando ya existe una entrada previa del individuo para que
> incremente su ID.
>
> Gracias,
> Carlos.
>
> El 26 de enero de 2016, 12:04, Ruben Bermad <ruben_bm en hotmail.com>
> escribió:
>
> Hola,
>
> Antes de nada, muchas gracias por tu ayuda.
>
> El código se ha acercado bastante, pero no termina de funcionar
> porque considera cada captura de un individuo como años consecutivos aunque
> haya pasado más tiempo entre ellos.
>
> Por ejemplo el individuo 4 es capturado por primera vez el año 1 y por
> segunda vez el año 3, por lo que debería de ser renombrado ya que en este
> ejemplo en concreto asumimos que la vida maxima son 2 años desde su primera
> aparición. Pero el script considera que es el mismo individuo porque es la
> segunda vez un individuo con ese nombre es capturado, sin tener en cuenta
> el tiempo que ha pasado entre la segunda captura y la primera.
>
> Yo habia pensado en salvar en una columna el tiempo de la primera
> aparicion y cada vez que aparezca un individuo con el mismo nombre restarle
> el tiempo del que aparecio por primera vez con ese nombre. De esa manera
> queda registrado el tiempo que ha pasado entre ambas apariciones, y si es
> superior al tiempo que consideramos imposible habria que renombrarlo.
>
> Lo que no se hacer es como repetir el proceso las veces necesarias,
> suponiendo que puede haber un tercer individuo con el mismo nombre (e.g. el
> individuo 1 en el año 5 que coge como referencia la primera aparicion del
> individuo 1 renombrado como individuo 13).
>
> Muchas gracias.
> Un cordial saludo,
> Rubén
>
>
> ------------------------------
> Date: Mon, 25 Jan 2016 23:09:13 +0100
> Subject: Re: [R-es] Corregir mismo ID para individuos diferentes en una
> serie temporal
> From: cof en qualityexcellence.es
> To: ruben_bm en hotmail.com
> CC: r-help-es en r-project.org
>
>
> Hola,
>
> Creo que el código que te adjunto hace lo que pides.
> Los nuevos ids los he generado con números no con letras, me resulta más
> fácil tratar el problema así.
>
>
> #----------------------
> ID <- c(1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6,
> 1, 2, 6, 8, 12, 7, 15, 16, 17, 18, 19, 20, 1, 21, 22, 19 )
> Year <- c (1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
> 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6)
> df <- data.frame (ID, Year)
> df
>
> ID <- c(1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6,
> 1, 2, 6, 8, 12, 7, 15, 16, 17, 18, 19, 20, 1, 21, 22, 19 )
> Year <- c (1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
> 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 1, 6, 6, 6)
> new_ID <- c("A", "B", "C", "D", "E", "F", "G", "A", "B", "C", "H", "I",
> "J", "K", "L", "M", "N", "O", "P", "Q", "R", "M", "N", "Q", "S", "L", "T",
> "U", "V", "W", "X", "Y", "Z", "CC", "AA", "BB", "Y")
> ref_df <- data.frame (ID, Year, new_ID)
> ref_df
>
> rep_val <- rep(0, nrow(df))
> new_df <- data.frame(ID=rep_val, Year=rep_val, newID=rep_val,
> hmyears=rep_val )
> for(i in 1:nrow(df)) { #Cero
>   if(i==1) {
>     new_df$ID[i] <- df$ID[i]
>     new_df$Year[i] <- df$Year[i]
>     new_df$newID[i] <- df$ID[i]
>     new_df$hmyears[i] <- 1
>   } else {                                #Uno
>     coin <- which(df$ID[i]==df$ID[1:(i-1)])
>     print(coin)
>     if(length(coin) < 1 ) {
>       new_df$ID[i] <- df$ID[i]
>       new_df$Year[i] <- df$Year[i]
>       if(length(which(df$ID[i]==new_df$newID)) < 1) {new_df$newID[i] <-
> df$ID[i]} else {new_df$newID[i] <- max(new_df$newID)+1}
>       new_df$hmyears[i] <- 1
>     } else {                              #Dos
>       if( new_df$hmyears[max(coin)] < 2 ) {
>         new_df$ID[i] <- df$ID[i]
>         new_df$Year[i] <- df$Year[i]
>         new_df$newID[i] <- new_df$newID[max(coin)]
>         new_df$hmyears[i] <- new_df$hmyears[max(coin)] + 1
>       } else {                            #Tres
>         new_df$ID[i] <- df$ID[i]
>         new_df$Year[i] <- df$Year[i]
>         new_df$newID[i] <- max(new_df$newID) + 1
>         new_df$hmyears[i] <- 1
>       } #Tres
>
>     } #Dos
>   } #Uno
> } #Cero
> new_df
>
> #----------------------
>
> Saludos,
> Carlos Ortega
> www.qualityexcellence.es
>
>
> El 25 de enero de 2016, 18:11, Ruben Bermad <ruben_bm en hotmail.com>
> escribió:
>
> Hola a todos,
> Quería preguntar si alguno sabe como puedo identificar registros con un
> mismo ID en el tiempo, pero que hacer referencia a objetos o individuos
> diferentes.
> En mi caso en particular estoy estudiando un animal que tiene una vida
> media cercana 2 años, y tengo una serie longitudinal de 25 años. El
> problema es que durante el muestreo en algunos casos durante la recoleccion
> de los datos, se repitieron los nombres de los individuos porque se asumen
> que si ha pasado 10 años no puede ser el mismo individuo. Y el problema que
> yo tengo es que no se como detectar de manera automática este tipo de
> errores.
> Había pensado era en registrar la primera aparición de cada nombre (e.g
> indiv_1, y ver el tiempo que ha pasado en comparación con el resto de
> registros para ese mismo individuo, y en el caso que fuera superior (por
> ejemplo a 36 meses para estar totalmente seguros), que ese individuo que
> había sido registrado como "indiv_1" sea renombrado (e.g. indiv_150), y
> cambiar todos los siguientes registros de indiv_1 a indiv_150.
> Esto parece sencillo, pero lo complicado al revisar todos los casos
> nombrados ahora como indiv_150 ya que es posible que el nombre indiv_1 haya
> sido usado para varios individuos diferentes a lo largo de la serie (e.g.
> en el año 1, 10 y 20). Entonces lo que había pensado es hacer un bucle para
> cada individuo, pero no consigo que cada vez que cambia el nombre de un
> individuo (e.g. en el año 10) capture la nueva fecha para determinar si los
> siguientes nombres hacen referencia al mismo individuo u a otro muy
> posterior en el tiempo (e.g. año 20).
> Esta pregunta la pregunte hace tiempo en stackoverflowhttp://
> stackoverflow.com/questions/32310520/identify-objects-with-repeated-measures-and-with-the-same-id-between-years,
> pero no obtuve una respuesta que solucionara el problema, y los posteriores
> intentos que he estado haciendo tampoco han sido muy buenos que se digan
> (os lo copio al final del mensaje).
> Por ello os quería preguntar si alguno sabe como puedo ir registrando y
> cambiando los IDs a lo largo del tiempo.
> Muchas gracias por adelantado, Un cordial saludo, Rubén
> Codigo usadodatabase es la base de datos con la serie temporalID_original
> es el identificado original que tiene cada individuoMonth_Capt es la
> variable que me indica en que momento fue capturado cada individuo y por
> tanto si es posible o no que el individuo sea el mismo a lo largo del
> tiempo.
> newID <-sapply(unique(database$ID_original), function(x)
> c(0,cumsum(diff(database$Month_Capt[database$ID_original==x]))%%48))names(newID)<-(unique(database$ID_original))
> new_df<-data.frame(database$ID_original,database$Month_Capt,IDcond=NA,new_ID=NA)for(i
> in unique(database$ID_original)){
> new_df[new_df[,1]==i,3]<-newID[[which(unique(database$ID_original)==i)]]}ltrs<-c(LETTERS,apply(combn(LETTERS,2,simplify
> = T),2,function(x) paste(x,sep = "",collapse = "")))
> letterwrap <- function(n, depth = 1) {  args <- lapply(1:depth, FUN =
> function(x) return(LETTERS))  x <- do.call(expand.grid, args = list(args,
> stringsAsFactors = F))  x <- x[, rev(names(x)), drop = F]  x <-
> do.call(paste0, x)  if (n <= length(x)) return(x[1:n])  return(c(x,
> letterwrap(n - length(x), depth = depth + 1)))}
> ltrs <- letterwrap(nrow(database)) # Create as many letters as unique IDs
>
> ltrn<-0for(i in 1:nrow(new_df)){  if(new_df[i,3]==0)
> {ltrn<-ltrn+1;new_df[i,4]<-ltrs[ltrn]}  else
> {ind<-which(new_df[,1]==new_df[i,1])        ind<-ind[ind<i]
> new_df[i,4]<-tail(new_df[ind,4],1)}}
>
>         [[alternative HTML version deleted]]
>
>
> _______________________________________________
> R-help-es mailing list
> R-help-es en r-project.org
> https://stat.ethz.ch/mailman/listinfo/r-help-es
>
>
>
>
> --
> Saludos,
> Carlos Ortega
> www.qualityexcellence.es
>
>
>
>
> --
> Saludos,
> Carlos Ortega
> www.qualityexcellence.es
>
>
>
>
> --
> Saludos,
> Carlos Ortega
> www.qualityexcellence.es
>

-- 
Saludos,
Carlos Ortega
www.qualityexcellence.es

	[[alternative HTML version deleted]]