usdn's questions

Emitir

Estou (desesperadamente) tentando replicar essa configuração mlflow/minio no podman: https://github.com/minio/blog-assets/blob/main/mlflow-minio-setup/docker-compose.yml . O tutorial roda bem em uma VM usando docker-compose.

No podman, no entanto, eu simplesmente não consigo descobrir como executar o script para criar automaticamente um bucket no minio. Eu tentei muitas combinações possíveis para a opção --entrypoint, mas sempre falha com: Error: crun: executable file [/bin/sh,-c,/create_bucket.sh] not found in $PATH: No such file or directory: OCI runtime attempted to invoke a command that was not found...

Minha configuração

criar_bucket.sh:

#!/bin/sh
sleep 5;
/usr/bin/mc config host add mlflow_minio_storage http://mlflow_minio_storage:9000 "$MINIO_ACCESS_KEY" "$MINIO_SECRET_ACCESS_KEY" --api S3v4;
/usr/bin/mc ls mlflow_minio_storage | grep -q challenge || /usr/bin/mc mb mlflow_minio_storage/mlflow;
/usr/bin/mc policy download mlflow_minio_storage/mlflow;
exit 0;

Arquivo Docker:

FROM docker.io/minio/mc

COPY create_bucket.sh /create_bucket.sh
RUN chmod +x /create_bucket.sh

podman executado:

podman build -t minio_client:latest -f Containerfile
podman run \
--name=mlflow_minio_client \
--detach \
--secret=MINIO_ACCESS_KEY,type=env,target=MINIO_ACCESS_KEY \
--secret=MINIO_SECRET_ACCESS_KEY,type=env,target=MINIO_SECRET_ACCESS_KEY \
--net mlflow_net \
--network-alias mlflow_minio_client \
--restart always \
--requires mlflow_minio_storage \
--entrypoint ["/bin/sh","-c","/create_bucket.sh"] \
localhost/minio_client:latest

Exemplo mínimo

Mesmo esse caso simples resulta no mesmo erro. Estou entendendo algo errado aqui?

podman run \
--entrypoint ["/bin/sh","-c","/usr/bin/mc version"] \
docker.io/minio/mc:latest
>>> Error: crun: executable file `[/bin/sh,-c,/usr/bin/mc version]` not found in $PATH: No such file or directory: OCI runtime attempted to invoke a command that was not found

Tenho dois dataframes: a (~600M linhas) e b (~2M linhas) . Qual é a melhor abordagem para unir b em a, ao usar 1 condição de igualdade e 2 condições de desigualdade nas respectivas colunas?

• a_1 = b_1
• a_2 >= b_2
• a_3 >= b_3

Até agora explorei os seguintes caminhos:

• Polares :
  • join_asof(): permite apenas 1 condição de desigualdade
  • join_where() com filter(): mesmo com uma pequena janela de tolerância, a instalação padrão do Polars fica sem linhas (limite de 4,3 bilhões de linhas) durante a junção, e a instalação do polars-u64-idx fica sem memória (512 GB)
• DuckDB : ASOF LEFT JOIN: também permite apenas 1 condição de desigualdade
• Numba : Como o acima não funcionou, tentei criar minha própria função join_asof() - veja o código abaixo. Ela funciona bem, mas com o aumento do comprimento de a, ela se torna proibitivamente lenta. Tentei várias configurações diferentes de loops for/while e filtragem, todas com resultados semelhantes.

Agora estou ficando sem ideias... Qual seria uma maneira mais eficiente de implementar isso?

Obrigado

import numba as nb
import numpy as np
import polars as pl
import time


@nb.njit(nb.int32[:](nb.int32[:], nb.int32[:], nb.int32[:], nb.int32[:], nb.int32[:], nb.int32[:], nb.int32[:]), parallel=True)
def join_multi_ineq(a_1, a_2, a_3, b_1, b_2, b_3, b_4):
    output = np.zeros(len(a_1), dtype=np.int32)

    for i in nb.prange(len(a_1)):

        for j in range(len(b_1) - 1, -1, -1):

            if a_1[i] == b_1[j]:

                if a_2[i] >= b_2[j]:

                    if a_3[i] >= b_3[j]:
                        output[i] = b_4[j]
                        break

    return output


length_a = 5_000_000
length_b = 2_000_000

start_time = time.time()
output = join_multi_ineq(a_1=np.random.randint(1, 1_000, length_a, dtype=np.int32),
                         a_2=np.random.randint(1, 1_000, length_a, dtype=np.int32),
                         a_3=np.random.randint(1, 1_000, length_a, dtype=np.int32),
                         b_1=np.random.randint(1, 1_000, length_b, dtype=np.int32),
                         b_2=np.random.randint(1, 1_000, length_b, dtype=np.int32),
                         b_3=np.random.randint(1, 1_000, length_b, dtype=np.int32),
                         b_4=np.random.randint(1, 1_000, length_b, dtype=np.int32))
print(f"Duration: {(time.time() - start_time):.2f} seconds")

Tenho um data frame de ~100M linhas contendo IDs em diferentes grupos. Alguns deles estão errados (indicados pelo 99). Estou tentando corrigi-los com uma janela de modo de rolagem, semelhante ao exemplo de código abaixo. Existe uma maneira melhor de fazer isso, já que rolling_map() é super lento?

import polars as pl
from scipy import stats

def dummy(input):
    return stats.mode(input)[0]

df = pl.DataFrame({'group': [10, 10, 10, 10, 10, 10, 10, 20, 20, 20, 20],
                   'id': [1, 1, 99, 1, 1, 2, 2, 3, 3, 99, 3]})

df.with_columns(pl.col('id')
                 .rolling_map(function=dummy,
                              window_size=3,
                              min_periods=1,
                              center=True)
                 .over('group')
                 .alias('id_mode'))

shape: (11, 3)
╭───────┬─────┬─────────╮
│ group ┆  id ┆ id_mode │
│   i64 ┆ i64 ┆     i64 │
╞═══════╪═════╪═════════╡
│    10 ┆   1 ┆       1 │
│    10 ┆   1 ┆       1 │
│    10 ┆  99 ┆       1 │
│    10 ┆   1 ┆       1 │
│    10 ┆   1 ┆       1 │
│    10 ┆   2 ┆       2 │
│    10 ┆   2 ┆       2 │
│    20 ┆   3 ┆       3 │
│    20 ┆   3 ┆       3 │
│    20 ┆  99 ┆       3 │
│    20 ┆   3 ┆       3 │
╰───────┴─────┴─────────╯