DJDuque's questions

Eu tenho um tensor pde forma (B, 3, N)no PyTorch:

# 2 batches, 3 channels (x, y, z), 5 points
p = torch.rand(2, 3, 5, requires_grad=True)
"""
p: tensor([[[0.8365, 0.0505, 0.4208, 0.7465, 0.6843],
         [0.9922, 0.2684, 0.6898, 0.3983, 0.4227],
         [0.3188, 0.2471, 0.9552, 0.5181, 0.6877]],

        [[0.1079, 0.7694, 0.2194, 0.7801, 0.8043],
         [0.8554, 0.3505, 0.4622, 0.0339, 0.7909],
         [0.5806, 0.7593, 0.0193, 0.5191, 0.1589]]], requires_grad=True)
"""

E depois outro z_shiftde formato [B, 1]:

z_shift = torch.tensor([[1.0], [10.0]], requires_grad=True)
"""
z_shift: tensor([[1.],
        [10.]], requires_grad=True)
"""

Quero aplicar o deslocamento z apropriado de todos os pontos em cada lote, deixando x e y inalterados:

"""
p: tensor([[[0.8365, 0.0505, 0.4208, 0.7465, 0.6843],
         [0.9922, 0.2684, 0.6898, 0.3983, 0.4227],
         [1.3188, 1.2471, 1.9552, 1.5181, 1.6877]],

        [[0.1079, 0.7694, 0.2194, 0.7801, 0.8043],
         [0.8554, 0.3505, 0.4622, 0.0339, 0.7909],
         [10.5806, 10.7593, 10.0193, 10.5191, 10.1589]]])
"""

Consegui fazer assim:

p[:, 2, :] += z_shift

para o caso em que requires_grad=False, mas isso falha dentro do forwardmeu nn.Module(que eu presumo ser equivalente a requires_grad=True) com:

RuntimeError: a view of a leaf Variable that requires grad is being used in an in-place operation.

Tenho dados que parecem:

lf = pl.LazyFrame(
    {
        "points": [
            [
                [1.0, 2.0],
            ],
            [
                [3.0, 4.0],
                [5.0, 6.0],
            ],
            [
                [7.0, 8.0],
                [9.0, 10.0],
                [11.0, 12.0],
            ],
        ],
        "other": ["foo", "bar", "baz"],
    },
    schema={
        "points": pl.List(pl.Array(pl.Float32, 2)),
        "other": pl.String,
    },
)

E eu quero fazer com que todas as listas tenham o mesmo número de elementos. Se atualmente tiver mais do que eu preciso, ela deve truncar. Se tiver menos do que eu preciso, ela deve se repetir em ordem até que tenha o suficiente.

Consegui fazer funcionar, mas sinto que estou pulando obstáculos. Existe uma maneira mais limpa de fazer isso? Talvez com gather?

target_length = 3

result = (
    lf.with_columns(
        needed=pl.lit(target_length).truediv(pl.col("points").list.len()).ceil()
    )
    .with_columns(
        pl.col("points")
        .repeat_by("needed")
        .list.eval(pl.element().explode())
        .list.head(target_length)
    )
    .drop("needed")
)

EDITAR

O método acima funciona para exemplos de brinquedo, mas quando tento usá-lo em meu conjunto de dados real, ele falha com:

pyo3_runtime.PanicException: Polars' maximum length reached. Consider installing 'polars-u64-idx'.

Não consegui fazer um MRE para isso, mas meus dados têm 4 milhões de linhas, e a lista de "pontos" em cada linha tem entre 1 e 8000 elementos (e estou tentando preencher/truncar para 800 elementos). Tudo isso parece bem pequeno, não vejo como um u32comprimento máximo é alcançado.

Agradeço qualquer abordagem alternativa que eu possa tentar.

O mais próximo que tenho (o que não causa pânico) é:

Mas isso não preenche a lista em ordem. Ele apenas preenche a repetição do último elemento.

target_length = 3

result = (
    lf.with_columns(
        pl.col("points")
        .list.gather(
            pl.int_range(target_length),
            null_on_oob=True,
        )
        .list.eval(pl.element().forward_fill())
    )
    .drop("needed")
)

Tenho um conjunto de dados com um esquema como:

df = pl.DataFrame(
    {
        "target": [
            [1.0, 1.0, 0.0],
            [1.0, 1.0, 0.1],
            [1.0, 1.0, 0.2],
            [1.0, 1.0, 0.8],
            [1.0, 1.0, 0.9],
            [1.0, 1.0, 1.0],
        ],
        "feature": ["a", "b", "c", "d", "e", "f"],
    },
    schema={
        "target": pl.Array(pl.Float32, 3),
        "feature": pl.String,
    },
)

Se eu fizer um histograma dos valores alvo-z, ele ficará assim:

Quero reamostrar os dados para que fiquem planos ao longo de z.

Consegui fazer isso de uma forma hacky-multi-steps (também muito lenta). Gostaria de saber se as pessoas poderiam sugerir uma forma mais limpa (e mais eficiente)?

O que estou fazendo é:

1. Encontre as arestas do compartimento do referido histograma:

bins = 2 # Use e.g. 100 or larger in reality
z = df.select(z=pl.col("target").arr.get(2))
z_min = z.min()
z_max = z.max()
breaks = np.linspace(z_min, z_max, num=bins+1)

2. Descubra quantas contagens estão no compartimento com o menor número de contagens:

counts = (
    df.with_columns(bin=pl.col("target").arr.get(2).cut(breaks))
    .with_columns(counter=pl.int_range(pl.len()).over("bin"))
    .group_by("bin")
    .agg(pl.col("counter").max())
    .filter(pl.col("counter") > 0)  # <- Nasty way of filtering the (-inf, min] bin
    .select(pl.col("counter").min())
).item()

3. Selecione apenas os elementos "count" em cada bin:

df = (
    df.with_columns(bin=pl.col("target").arr.get(2).cut(breaks))
    .with_columns(counter=pl.int_range(pl.len()).over("bin"))
    .filter(pl.col("counter") <= counts)
    .select("target", "feature")
)

Isso me dá:

As pessoas têm alguma sugestão?

Eu tenho um dataframe como:

data = {
    "a": [[1], [2], [3, 4], [5, 6, 7]],
    "b": [[], [8], [9, 10], [11, 12]],
}
df = pl.DataFrame(data)
"""
┌───────────┬───────────┐
│ a         ┆ b         │
│ ---       ┆ ---       │
│ list[i64] ┆ list[i64] │
╞═══════════╪═══════════╡
│ [1]       ┆ []        │
│ [2]       ┆ [8]       │
│ [3, 4]    ┆ [9, 10]   │
│ [5, 6, 7] ┆ [11, 12]  │
└───────────┴───────────┘
"""

Cada par de listas pode não ter o mesmo comprimento, e eu quero "truncar" a explosão para a menor das duas listas:

"""
┌─────┬─────┐
│ a   ┆ b   │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═════╪═════╡
│ 2   ┆ 8   │
│ 3   ┆ 9   │
│ 4   ┆ 10  │
│ 5   ┆ 11  │
│ 6   ┆ 12  │
└─────┴─────┘
"""

Eu estava pensando que talvez eu tivesse que preencher o menor de ambas as listas com Nonepara combinar ambos os comprimentos, e então drop_nulls. Mas eu estava pensando se havia uma abordagem mais direta para isso?

Estou tentando fazer basicamente o oposto de drop_nulls(). Quero manter todas as linhas que tenham pelo menos um null.

Quero fazer algo como (mas não quero listar todas as outras colunas):

for (name,) in (
    df.filter(
        pl.col("a").is_null()
        | pl.col("b").is_null()
        | pl.col("c").is_null()
    )
    .select("name")
    .unique()
    .rows()
):
    print(
        f"Ignoring `{name}` because it has at least one null",
        file=sys.stderr,
    )
df = df.drop_nulls()

Tenho 2 conjuntos de dados:

O primeiro descreve o que espero:

expected = {
    "name": ["start", "stop", "start", "stop", "start", "stop", "start", "stop"],
    "description": ["a", "b", "c", "d", "e", "f", "g", "h"],
}

e o segundo descreve o que observo:

observed = {
    "name": ["start", "stop", "start", "stop", "stop", "stop", "start"],
    "time": [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7],
}

Quero combinar todas as minhas observações com descrições baseadas na ordem que espero. Mas, uma vez que vejo uma inconsistência, nada mais deve combinar.

Consegui encontrar a primeira inconsistência como:

observed_df = pl.DataFrame(observed).with_row_index()
expected_df = pl.DataFrame(expected).with_row_index()

result = observed_df.join(expected_df, on=["index", "name"], how="left").select(
    "description", "time"
)
"""
┌─────────────┬──────┐
│ description ┆ time │
│ ---         ┆ ---  │
│ str         ┆ f64  │
╞═════════════╪══════╡
│ a           ┆ 0.1  │
│ b           ┆ 0.2  │
│ c           ┆ 0.3  │
│ d           ┆ 0.4  │
│ null        ┆ 0.5  │   -> First inconsistency gets a "null" description
│ f           ┆ 0.6  │
│ g           ┆ 0.7  │
└─────────────┴──────┘
"""

Como posso propagar isso nullapós a primeira inconsistência?

Além disso, meus dados reais têm uma idcoluna adicional, onde cada um idé um caso como descrito acima, e independente de outros ids. É possível de alguma forma "agrupar por id" e aplicar essa lógica de uma só vez em vez de trabalhar com cada um idseparadamente:

observed = {
    "id": [1, 2, 1, 2, 2],
    "name": ["start", "start", "stop", "stop", "stop"],
    "time": [0.1, 0.2, 0.3, 0.4, 0.5],
}

expected = {
    "id": [1, 1, 2, 2],
    "name": ["start", "stop", "start", "stop"],
    "description": ["a", "b", "c", "d"],
}

result = {
    "id": [1, 2, 1, 2, 2],
    "description": ["a", "c", "b", "d", None],
    "time": [0.1, 0.2, 0.3, 0.4, 0.5],
}

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       │
   └──────┴───────────┘
   """
   

2. 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.

Imagine que tenho um conjunto de dados como:

data = {
    "a": [1, 4, 2, 4, 7, 4],
    "b": [4, 2, 3, 3, 0, 2],
    "c": ["a", "b", "c", "d", "e", "f"],
}

e quero manter apenas as linhas a + bdescritas exclusivamente por uma única combinação de ae b. Eu consegui hackear isso:

df = (
    pl.DataFrame(data)
    .with_columns(sum_ab=pl.col("a") + pl.col("b"))
    .group_by("sum_ab")
    .agg(pl.col("a"), pl.col("b"), pl.col("c"))
    .filter(
        (pl.col("a").list.unique().list.len() == 1)
        & (pl.col("b").list.unique().list.len() == 1)
    )
    .explode(["a", "b", "c"])
    .select("a", "b", "c")
)

"""
shape: (2, 3)
┌─────┬─────┬─────┐
│ a   ┆ b   ┆ c   │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str │
╞═════╪═════╪═════╡
│ 4   ┆ 2   ┆ b   │
│ 4   ┆ 2   ┆ f   │
└─────┴─────┴─────┘
"""

Alguém pode sugerir uma maneira melhor de conseguir o mesmo? Lutei um pouco para descobrir essa lógica, então imagino que exista uma maneira mais direta/elegante de obter o mesmo resultado.

Estou aprendendo bootstrap e quero ter um nome xao lado de cada guia para fechá-la:

<link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-rbsA2VBKQhggwzxH7pPCaAqO46MgnOM80zW1RWuH61DGLwZJEdK2Kadq2F9CUG65" crossorigin="anonymous">

<ul class="nav nav-tabs" id="myTab" role="tablist">
  <li class="nav-item" id="tab-li-1">
    <button
      class="nav-link active"
      data-bs-toggle="tab"
      data-bs-target="#tab-1"
      type="button"
    >
      First
      <button
        class="btn-close"
        onclick="
          document.getElementById(`tab-li-1`).remove();
          document.getElementById(`tab-1`).remove();
        "
       ></button>
    </button>
  </li>
  <li class="nav-item" id="tab-li-2">
    <button
      class="nav-link"
      data-bs-toggle="tab"
      data-bs-target="#tab-2"
      type="button"
     >
     Second
       <button
        class="btn-close"
        onclick="
          document.getElementById(`tab-li-2`).remove();
          document.getElementById(`tab-2`).remove();
        "
       ></button>
     </button>
  </li>
</ul>
<div class="tab-content" id="myTabContent">
  <div class="tab-pane fade show active" id="tab-1" tabindex="0">Some text here for `First`</div>
  <div class="tab-pane fade" id="tab-2" tabindex="0">More text here for `Second`</div>
</div>

    <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap.bundle.min.js" integrity="sha384-kenU1KFdBIe4zVF0s0G1M5b4hcpxyD9F7jL+jjXkk+Q2h455rYXK/7HAuoJl+0I4" crossorigin="anonymous"></script>

Consegui hackear algo para aninhar outro botão dentro do meu primeiro botão e então:

document.getElementById(tabId).remove();
document.getElementById(tabContentId).remove();

mas descobri on-line que não é válido aninhar um botão dentro de outro botão

Existe uma alternativa melhor que as pessoas podem sugerir?

Desculpe se minha pergunta não faz muito sentido. Não tenho muita experiência em python.

Eu tenho um código que se parece com:

import polars as pl
from typing import NamedTuple


class Event(NamedTuple):
    name: str
    description: str


def event_table(num) -> list[Event]:
    events = []
    for i in range(5):
        events.append(Event("name", "description"))
    return events


def pretty_string(events: list[Event]) -> str:
    pretty = ""
    for event in events:
        pretty += f"{event.name}: {event.description}\n"
    return pretty

# This does work
print(pretty_string(event_table(5)))

# But then it doesn't work if I have my `list[Event]` in a dataframe
data = {"events": [0, 1, 2, 3, 4]}
df = pl.DataFrame(data).select(events=pl.col("events").map_elements(event_table))

# This doesn't work
pretty_df = df.select(events=pl.col("events").map_elements(pretty_string))
print(pretty_df)

# Neither does this
print(pretty_string(df["events"][0]))

Falha com erro:

Traceback (most recent call last):
  File "path/to/script.py", line 32, in <module>
    pretty_df = df.select(events=pl.col("events").map_elements(pretty_string))
                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "path/to/.venv/lib/python3.11/site-packages/polars/dataframe/frame.py", line 8116, in select
    return self.lazy().select(*exprs, **named_exprs).collect(_eager=True)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "path/to/.venv/lib/python3.11/site-packages/polars/lazyframe/frame.py", line 1934, in collect
    return wrap_df(ldf.collect())
                   ^^^^^^^^^^^^^
polars.exceptions.ComputeError: AttributeError: 'dict' object has no attribute 'name'

Parece que o meu list[Event]não está mais tão dentro do arquivo df. Não tenho certeza de como fazer isso funcionar.