Perguntas[numpy](coding)

Estou tentando preparar dados para visualização com o Seaborn. Então, preciso obter vários tipos diferentes de sessões para um gráfico de várias linhas.

Com
session_cnt = df.groupby(df['EVENT_DATETIME'].dt.date, df['CUSTOMER_ID']).agg(session_count=('SESSION_ID', 'nunique'), app_session_cnt=('APP_SESSION_ID', 'nunique')).reset_index()

Eu obtive

TypeError: unhashable type 'series'

Então eu fiz isso:

session_cnt = df.groupby(df['EVENT_DATETIME'].dt.date, df['CUSTOMER_ID'].values).agg(session_count=('SESSION_ID', 'nunique'), app_session_cnt=('APP_SESSION_ID', 'nunique')).reset_index()

Mas consegui

TypeError: unhashable type 'numpy.ndarray'

Gostaria de entender qual coluna verificar ao usar groupby e obter TypeError, porque agora estou apenas supondo. Talvez eu precise ler um bom artigo sobre esse erro.

Eu tenho um array ade tamanho (M, N, K). E eu tenho um array bde tamanho (M, N)com valores inteiros de [0, K-1].

Como faço para obter a matriz... cde tamanho (M, N), onde c[i, j] == a[i, j, b[i, j]] da maneira mais simples?

Qual parte do guia de indexação é?

Como posso alterar a matriz dessa forma?

arr = [
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
[20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31],
[30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41],
...,
[130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141],
]

=> [
[ [0, 1], [20, 21], [30, 31], ,.., [130, 131]],
[ [2, 3], [22, 23], [32, 33], .., [132, 133]],
[ [4, 5], [24, 25], [34, 35], .., [134, 135]],
[ [6, 7], [26, 27], [36, 37], .., [136, 137]],
[ [8, 9], [28, 29], [38, 39], .., [138, 139]],
[ [10, 11], [30, 31], [40, 41], .., [140, 141]],
...
]

Minha tentativa foi melhor modificada para o seguinte, o que não foi o resultado que eu queria.

[ [0, 1], [2, 3], [4, 5], ,.., [10, 11]],
[ [20, 21], [22, 23], [24, 25], .., [30, 31]],

Estou tentando entender como o NumPy implementa o arredondamento para o mais próximo, mesmo ao converter para um formato de precisão mais baixa, neste caso, Float32 para Float16, especificamente o caso em que o número é normal em Float32, mas é arredondado para um subnormal em Float16.

Link para o código: https://github.com/numpy/numpy/blob/13a5c4e569269aa4da6784e2ba83107b53f73bc9/numpy/core/src/npymath/halffloat.c#L244-L365

Meu entendimento é o seguinte,

Em float32, o número tem os bits

        /*
         * If the last bit in the half significand is 0 (already even), and
         * the remaining bit pattern is 1000...0, then we do not add one
         * to the bit after the half significand. However, the (113 - f_exp)
         * shift can lose up to 11 bits, so the || checks them in the original.
         * In all other cases, we can just add one.
         */
        if (((f_sig&0x00003fffu) != 0x00001000u) || (f&0x000007ffu)) {m
            f_sig += 0x00001000u;
        }

O código acima é usado ao quebrar empates para o par mais próximo. Não entendo por que na segunda parte do OR lógico, fazemos AND bit a bit contra 0x0000'07ffu(bits m12-m22) e não 0x0000'ffffu(m11-m22) .

Depois de alinharmos os bits da mantissa para que fiquem no formato subnormal para float16 (que é o que a mudança de bits antes deste pedaço de código faz), na representação numérica float32 acima teríamos m10- m22decidindo qual direção arredondar.

Meu entendimento é que a segunda parte do OR verifica se o número é maior do que o ponto médio, e se for, então adiciona um ao bit meio-significante. Mas com o número original, ele não está apenas verificando um subconjunto dos números que estão acima do ponto médio? No número float16, m9 seria a última precisão que vai permanecer. Então, arredondaremos para cima se,

1. m9 é 1, m10 é 1 e m11-m22 são todos 0 (A primeira parte do OR)

2. m10 é 1, pelo menos um de m11-m22 é 1 (para colocar o número acima do ponto médio)

3. pode ser simplificado adicionando 1 a m10, se qualquer um de m11-m22 for 1. se m10 já for 1, a adição sangrará para m9, caso contrário, permanecerá inalterado. Mas, no caso do código NumPy, os bits verificados são m12-m22.

Não tenho certeza do que estou perdendo aqui. Esse é um cenário de caso especial?

Eu esperava que os bits m11-m22 fossem os que decidiriam se adicionariam 1 e nem m12-m22.

No windows com python 3.13.1, ao executar pip install para algo (aeneas) não consigo resolver: Você deve instalar o numpy antes de instalar o aeneas

Tentei muitas abordagens diferentes, incluindo seguir postagens mais antigas do stackoverflow sobre o assunto.

Eu esperava que pelo menos essa abordagem funcionasse:

python -m venv myenv
.\myenv\Scripts\Activate
pip install numpy
pip list

Package Version
------- -------
numpy   2.2.1
pip     24.3.1

pip install aeneas

Collecting aeneas
  Using cached aeneas-1.7.3.0.tar.gz (5.5 MB)
  Installing build dependencies ... done
  Getting requirements to build wheel ... error
  error: subprocess-exited-with-error

  × Getting requirements to build wheel did not run successfully.
  │ exit code: 1
  ╰─> [3 lines of output]
      [ERRO] You must install numpy before installing aeneas
      [INFO] Try the following command:
      [INFO] $ sudo pip install numpy
      [end of output]

  note: This error originates from a subprocess, and is likely not a problem with pip.
error: subprocess-exited-with-error

pip install setuptools
pip install --upgrade pip setuptools wheel
pip install --no-build-isolation aeneas

...You must install numpy before installing aeneas

Ainda estou pegando o jeito das melhores práticas em jax. Minha pergunta geral é a seguinte:

Quais são as melhores práticas para a implementação de rotinas de criação de matrizes personalizadas em jax?

Por exemplo, eu quero implementar uma função que cria uma matriz com zeros em todos os lugares, exceto com uns em uma coluna dada. Eu fui para isso (Jupyter notebook):

import numpy as np
import jax.numpy as jnp

def ones_at_col(shape_mat, idx):
    idxs = jnp.arange(shape_mat[1])[None,:]
    mat = jnp.where(idx==idxs, 1, 0)
    mat = jnp.repeat(mat, shape_mat[0], axis=0)
    return mat

shape_mat = (5,10)

print(ones_at_col(shape_mat, 5))

%timeit np.zeros(shape_mat)

%timeit jnp.zeros(shape_mat)

%timeit ones_at_col(shape_mat, 5)

A saída é

[[0 0 0 0 0 1 0 0 0 0]
 [0 0 0 0 0 1 0 0 0 0]
 [0 0 0 0 0 1 0 0 0 0]
 [0 0 0 0 0 1 0 0 0 0]
 [0 0 0 0 0 1 0 0 0 0]]
127 ns ± 0.717 ns per loop (mean ± std. dev. of 7 runs, 10,000,000 loops each)
31.3 µs ± 331 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
123 µs ± 1.79 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

Minha função é um fator de 4 mais lenta que a jnp.zeros()rotina, o que não é tão ruim. Isso me diz que o que estou fazendo não é loucura.

Mas então ambas jaxas rotinas são muito mais lentas do que as numpyrotinas equivalentes. Essas funções não podem ser jitadas porque elas tomam a forma como um argumento e, portanto, não podem ser rastreadas. Presumo que seja por isso que elas são inerentemente mais lentas? Acho que se qualquer uma delas aparecesse dentro do escopo de outra função jitada, elas poderiam ser rastreadas e aceleradas?

Existe algo melhor que eu possa fazer ou estou forçando os limites do que é possível jax?

Suponha que você tenha um numpy histogramcalculado a partir de alguns dados (aos quais você não tem acesso), então você só conhece bins e contagens. Existe uma maneira eficiente de calcular a média e a mediana da distribuição descrita pelo histograma?

Estou tentando multiplicar duas matrizes no numpy com dimensionalidade bastante grande. Veja os 3 métodos abaixo. Eu percebo as 3 matrizes aleatoriamente para mostrar meu problema. A primeira matriz, ou seja, Y1[:,:,0]é parte de uma matriz 3D maior no início. A segunda é uma .copy()dessa matriz e a terceira é sua própria matriz.

Por que a primeira multiplicação é muito mais lenta que as duas segundas?

import numpy as np
from time import time

Y1 = np.random.uniform(-1, 1, (5000, 1093, 201))
Y2 = Y1[:,:,0].copy()
Y3 = np.random.uniform(-1, 1, (5000, 1093))

W = np.random.uniform(-1, 1, (1093, 30))

# method 1
START = time()
Y1[:,:,0].dot(W)
END = time()
print(f"Method 1 : {END - START}")

# method 2
START = time()
Y2.dot(W)
END = time()
print(f"Method 2 : {END - START}")

# method 3
START = time()
Y3.dot(W)
END = time()
print(f"Method 3 : {END - START}")

Os tempos de saída são aproximadamente 34, 0,06 e 0,06 segundos, respectivamente.

Vejo a diferença: enquanto as duas últimas matrizes são matrizes 2D "reais", a primeira é uma fatia da minha matriz 3D maior.

É o subconjunto Y1[:,:,0]que o torna tão lento? Além disso, notei que criar a cópia de Y1 para a matriz Y2 também é bem lento.

Afinal, recebo esta matriz 3D e tenho que calcular repetidamente o produto matricial das fatias de Y1 com uma matriz W (potencialmente diferente). Existe uma maneira melhor/mais rápida de fazer isso?

Desde já, obrigado!

numpyEu tenho um escalar zero-dimensional e uma matriz sbidimensional . Eu quero formar uma matriz de vetores em que todos os elementos de são pareados com como no exemplo a seguir:numpymms

import numpy as np

s = np.asarray(5)

m = np.asarray([[1,2],[3,4]])

# Result should be as follows

array([[[5, 1],
        [5, 2]],

       [[5, 3],
        [5, 4]]])

Em outras palavras, quero vetorizar a operação np.asarray([s, m])elemento a elemento no nível mais baixo de m. Existe uma maneira óbvia de fazer isso para qualquer array multidimensional mdentro de numpy?

Tenho certeza de que isso está em algum lugar, mas tenho dificuldade em expressar em palavras e não consigo encontrar. Se você puder encontrar, sinta-se à vontade para me redirecionar para lá.

Estou tentando desenhar um mapa climatológico da precipitação do GPCC.

Mas descobri que há um espaço em branco (corte de dados) na Linha Meridiana Principal.

Como posso consertar o problema? Posso usar CDO, NCO, Python.

Também compartilho o código e os dados.

(dados) https://drive.google.com/drive/folders/1rEHKz5GQlvC3m_Cfzx48cTrPZPU0qAar?usp=sharing

(metadados do GPCC) https://opendata.dwd.de/climate_environment/GPCC/html/fulldata-monthly_v2022_doi_download.html

type here

from netCDF4 import Dataset
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

import xarray as xr
import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np
import calendar

import cartopy.crs as ccrs
from cartopy.mpl.gridliner import LONGITUDE_FORMATTER, LATITUDE_FORMATTER
import cartopy.feature as cfeature
import cftime
from mpl_toolkits.basemap import Basemap
import matplotlib.pyplot as plt
%matplotlib inline

mpl.rcParams['figure.figsize'] = [8., 6.]

filename = 'D:/ERA5/precip.nc'
ds = xr.open_dataset(filename)
ds

da = ds['precip']
da

def is_jjas(month):
    return (month >= 6) & (month <= 9)

dd = da.sel(time=is_jjas(da['time.month']))

def is_1982(year):
    return (year> 1981)

dn = dd.sel(time=is_1982(dd['time.year']))
dn

JJAS= dn.groupby('time.year').mean('time')

JJAS2 = JJAS.mean(dim='year', keep_attrs=True)
JJAS2

fig, ax = plt.subplots(1, 1, figsize = (16, 8), subplot_kw={'projection': ccrs.PlateCarree()})

cs = plt.contourf(JJAS2.lon, JJAS2.lat, JJAS2, levels=[0, 50, 100, 150, 200, 250, 300, 350, 400, 450, 500],
                  vmin=0, vmax=500, cmap='Blues', extend='both')

# Set the figure title, add lat/lon grid and coastlines
ax.set_title('', fontsize=16)
ax.gridlines(draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--') 
ax.coastlines(color='black')
ax.set_extent([-20, 30, 0, 30], crs=ccrs.PlateCarree())

cbar = plt.colorbar(cs,fraction=0.05, pad=0.04, extend='both', orientation='horizontal')

Tentei pesquisar no Google e encontrar métodos CDO. Se eu interpolar os dados, sua resolução pode ser alterada. Quero usar esses dados GPCC com a mesma resolução, mas sem espaços em branco.