Início / coding / Perguntas / 78976447
Accepted
DJDuque
Asked: 2024-09-12 12:09:59 +0800 CST

Junte carimbos de data/hora entre 2 conjuntos de dados, mantendo a diferença de tempo

  • 772

Tenho os 2 conjuntos de dados a seguir:

  1. Este é muito confiável para me dizer se um evento aconteceu, mas seu registro de data e hora só é válido com uma precisão de alguns segundos (vamos supor 2 segundos): 
    coarse = {
    "name": ["a", "a", "b", "c", "a"],
    "timestamp": [100, 103, 195, 220, 221],
}
coarse_df = pl.DataFrame(coarse)
"""
┌──────┬───────────┐
│ name ┆ timestamp │
│ ---  ┆ ---       │
│ str  ┆ i64       │
╞══════╪═══════════╡
│ a    ┆ 100       │
│ a    ┆ 103       │
│ b    ┆ 195       │
│ c    ┆ 220       │
│ a    ┆ 221       │
└──────┴───────────┘
"""
  1. Este tem um tempo muito preciso, mas tem alguns ruídos/falsos positivos (observe que t=0é diferente para ambos os conjuntos de dados, há um deslocamento arbitrário): 
    fine = {
    "name": ["a", "a", "a", "a", "b", "c", "b", "a"],
    "time": [0.05, 10.05, 12.51, 51.12, 106.0, 128.01, 130.0, 132.9],
}
fine_df = pl.DataFrame(fine)
"""
┌──────┬────────┐
│ name ┆ time   │
│ ---  ┆ ---    │
│ str  ┆ f64    │
╞══════╪════════╡
│ a    ┆ 0.05   │
│ a    ┆ 10.05  │
│ a    ┆ 12.51  │
│ a    ┆ 51.12  │
│ b    ┆ 106.0  │
│ c    ┆ 128.01 │
│ b    ┆ 130.0  │
│ a    ┆ 132.9  │
└──────┴────────┘
"""

Estou tentando de alguma forma juntar esses conjuntos de dados para obter algo como o seguinte. Essencialmente, obtendo os timestamps do segundo conjunto de dados e usando as diferenças de tempo no primeiro conjunto de dados para filtrar os falsos positivos.

"""
┌──────┬────────┐
│ name ┆ time   │
│ ---  ┆ ---    │
│ str  ┆ f64    │
╞══════╪════════╡
│ a    ┆ 10.05  │
│ a    ┆ 12.51  │
│ b    ┆ 106.0  │
│ c    ┆ 128.01 │
│ a    ┆ 132.9  │
└──────┴────────┘
"""

EDITAR

O que estou fazendo atualmente para identificar falsos positivos (em palavras, porque este é um loop for aninhado feio):

Dado que o deslocamento entre ambos os conjuntos de dados é arbitrário, suponha que o primeiro evento "a" seja o real:

Agora coarseparece que o tempo mudou em 100:

┌──────┬───────────┐
│ name ┆ timestamp │
│ ---  ┆ ---       │
│ str  ┆ i64       │
╞══════╪═══════════╡
│ a    ┆ 0         │  -> Good, there is a timestamp in `fine` within 2s
│ a    ┆ 3         │  -> Bad, no timestamp in `fine` matches
│ b    ┆ 95        │  -> Bad, ditto
│ c    ┆ 120       │  -> Bad, ditto
│ a    ┆ 121       │  -> Bad, ditto
└──────┴───────────┘

Ok, não encontrei todos os resultados, então o segundo "a" deve ser o real (deslocado em 90 segundos):

┌──────┬───────────┐
│ name ┆ timestamp │
│ ---  ┆ ---       │
│ str  ┆ i64       │
╞══════╪═══════════╡
│ a    ┆ 10        │  -> Good, it matches 10.05
│ a    ┆ 13        │  -> Good, it matches 12.51
│ b    ┆ 105       │  -> Good, it matches 106.0
│ c    ┆ 130       │  -> Good, it matches 128.01
│ a    ┆ 131       │  -> Good it matches 132.9
└──────┴───────────┘

Basicamente, estou deslizando o segundo conjunto de dados pelo tempo até encontrar um "padrão de tempo" que corresponda a todos os eventos no primeiro quadro de dados em um subconjunto do segundo.

dataframe

1 respostas

  1. Best Answer

    A tabela final pode ser gerada com um ASOF JOIN usando a estratégia "mais próxima" .

    (coarse_df
  .with_columns(pl.col.timestamp - 90.0)  
  .join_asof(fine_df, by="name", left_on="timestamp", right_on="time", strategy="nearest")
)

    shape: (5, 3)
┌──────┬───────────┬────────┐
│ name ┆ timestamp ┆ time   │
│ ---  ┆ ---       ┆ ---    │
│ str  ┆ f64       ┆ f64    │
╞══════╪═══════════╪════════╡
│ a    ┆ 10.0      ┆ 10.05  │
│ a    ┆ 13.0      ┆ 12.51  │
│ b    ┆ 105.0     ┆ 106.0  │
│ c    ┆ 130.0     ┆ 128.01 │
│ a    ┆ 131.0     ┆ 132.9  │
└──────┴───────────┴────────┘

    No entanto, parece que você quer comparar vários "valores de deslocamento" de uma só vez.

    (
   pl.concat(
      coarse_df.with_columns(pl.col.timestamp - float(shift), shift=shift)
      for shift in range(100, -10, -10)
   )
   .sort("timestamp") # asof requires sorted data
   .join_asof(fine_df, by="name", left_on="timestamp", right_on="time", strategy="nearest")
   .filter((pl.col.timestamp - pl.col.time).abs() <= 2) # within threshold
)

    shape: (8, 4)
┌──────┬───────────┬───────┬────────┐
│ name ┆ timestamp ┆ shift ┆ time   │
│ ---  ┆ ---       ┆ ---   ┆ ---    │
│ str  ┆ f64       ┆ i32   ┆ f64    │
╞══════╪═══════════╪═══════╪════════╡
│ a    ┆ 0.0       ┆ 100   ┆ 0.05   │
│ a    ┆ 10.0      ┆ 90    ┆ 10.05  │
│ a    ┆ 13.0      ┆ 90    ┆ 12.51  │
│ a    ┆ 50.0      ┆ 50    ┆ 51.12  │
│ a    ┆ 53.0      ┆ 50    ┆ 51.12  │
│ b    ┆ 105.0     ┆ 90    ┆ 106.0  │
│ c    ┆ 130.0     ┆ 90    ┆ 128.01 │
│ a    ┆ 131.0     ┆ 90    ┆ 132.9  │
└──────┴───────────┴───────┴────────┘

    E encontre o(s) turno(s) com mais valores.

       ...
   .with_columns(pl.len().over("shift"))
   .filter(pl.col.len == pl.col.len.max())
)   

    shape: (5, 5)
┌──────┬───────────┬───────┬────────┬─────┐
│ name ┆ timestamp ┆ shift ┆ time   ┆ len │
│ ---  ┆ ---       ┆ ---   ┆ ---    ┆ --- │
│ str  ┆ f64       ┆ i32   ┆ f64    ┆ u32 │
╞══════╪═══════════╪═══════╪════════╪═════╡
│ a    ┆ 10.0      ┆ 90    ┆ 10.05  ┆ 5   │
│ a    ┆ 13.0      ┆ 90    ┆ 12.51  ┆ 5   │
│ b    ┆ 105.0     ┆ 90    ┆ 106.0  ┆ 5   │
│ c    ┆ 130.0     ┆ 90    ┆ 128.01 ┆ 5   │
│ a    ┆ 131.0     ┆ 90    ┆ 132.9  ┆ 5   │
└──────┴───────────┴───────┴────────┴─────┘
    • 2

relate perguntas