JAX
JAX é "NumPy turbinado". Ele combina Autograd (diferenciação automática) com XLA (compilação). Em 2025, Flax NNX (OOP estilo PyTorch) está se tornando o padrão.
Quando usar
- Computação numérica e científica de alto desempenho: Autograd e compilação XLA para álgebra linear acelerada em GPU/TPU.
- Pesquisa personalizada em deep learning: Construção de redes neurais com Flax, Haiku ou Equinox sem o inchaço de frameworks.
- Transformações de funções combináveis: Encadeamento contínuo de
jit(compilação),grad(derivadas) evmap(vetorização). - Treinamento distribuído em múltiplos dispositivos: Paralelização de computação em clusters usando
pmape mapas de fragmentação (jax.experimental.shard_map).
Início rápido
import jax
import jax.numpy as jnp
# Multiplicação de matrizes compilada com JIT e diferenciação automática
@jax.jit
def loss_fn(w, x, y):
pred = jnp.dot(x, w)
return jnp.mean((pred - y) ** 2)
# Calcula valor e gradientes simultaneamente
grad_fn = jax.grad(loss_fn)
w = jnp.array([1.0, 2.0])
x = jnp.array([[1.0, 0.5], [2.0, 1.0]])
y = jnp.array([2.0, 4.0])
grads = grad_fn(w, x, y)
print("Gradientes:", grads)
Conceitos principais
#Transformações de Funções Combináveis: jit, grad e vmap
Combinando compilação just-in-time, diferenciação automática e batching automatizado:
import jax
import jax.numpy as jnp
# Definição de função pura
def loss_fn(w, x, y):
pred = jnp.dot(x, w)
return jnp.mean((pred - y) ** 2)
# Transformação 1: Gradiente automático em relação aos pesos
grad_fn = jax.grad(loss_fn)
# Transformação 2: Compilação JIT via XLA para aceleração extrema em GPU
fast_grad_fn = jax.jit(grad_fn)
# Transformação 3: Vetorização automática em lotes
# batch_loss_fn lida com matrizes 2D automaticamente sem loops
vmapped_loss = jax.vmap(loss_fn, in_axes=(None, 0, 0))
# Computação de exemplo
key = jax.random.PRNGKey(42)
w = jax.random.normal(key, (3,))
x = jnp.array([[1.0, 2.0, 3.0]])
y = jnp.array([5.0])
grad_val = fast_grad_fn(w, x, y)
print("Gradiente calculado:", grad_val)
#Gerenciamento Explícito de Chaves PRNG
Geração de números pseudoaleatórios sem estado:
import jax
# Inicializa chave PRNG raiz
key = jax.random.PRNGKey(2026)
# As chaves JAX devem ser explicitamente divididas; nunca reutilizadas
key, subkey1, subkey2 = jax.random.split(key, 3)
data_normal = jax.random.normal(subkey1, shape=(4, 4))
data_uniform = jax.random.uniform(subkey2, shape=(4, 4))
print("Média da amostra normal:", jnp.mean(data_normal))
#Modelo com Estado Usando Equinox e Funções Puras
Redes neurais expressivas e orientadas a objetos construídas sobre funções JAX puras:
import equinox as eqx
import jax
import jax.numpy as jnp
class SimpleMLP(eqx.Module):
linear1: eqx.nn.Linear
linear2: eqx.nn.Linear
def __init__(self, in_features, out_features, key):
k1, k2 = jax.random.split(key)
self.linear1 = eqx.nn.Linear(in_features, 64, key=k1)
self.linear2 = eqx.nn.Linear(64, out_features, key=k2)
def __call__(self, x):
x = jax.nn.relu(self.linear1(x))
return self.linear2(x)
key = jax.random.PRNGKey(0)
model = SimpleMLP(in_features=10, out_features=2, key=key)
sample_input = jnp.ones((10,))
output = model(sample_input)
print("Saída do modelo:", output)
Padrões comuns
Vetorização em lote com vmap
Problema: Escrever loops manuais em Python para avaliar funções em lotes diminui a execução.
Solução:
Use jax.vmap para vetorizar automaticamente funções de exemplo único:
def predict_single(w, x):
return jnp.dot(x, w)
# Vetoriza automaticamente na dimensão do lote (eixo 0 de x)
predict_batch = jax.vmap(predict_single, in_axes=(None, 0))
batch_x = jnp.ones((100, 10))
weights = jnp.ones(10)
predictions = predict_batch(weights, batch_x) # Forma de saída: (100,)
Melhores práticas (2026)
- Faça escrever código puramente funcional: sem efeitos colaterais, sem mutação de arrays in-place (
x.at[idx].set(val)em vez dex[idx] = val). - Faça envolver funções críticas de desempenho com
@jax.jitpara acionar a compilação XLA. - Faça dividir chaves PRNG explicitamente (
jax.random.split(key)) sempre que números aleatórios forem gerados. - Faça usar bibliotecas modernas de alto nível como Equinox ou Flax Linen em vez de escrever dicionários de parâmetros brutos.
- Não faça usar condicionais Python padrão (
if x > 0:) dentro de funções JIT em traçadores dinâmicos; usejax.lax.cond. - Não faça reutilizar chaves PRNG; reutilizar chaves gera números aleatórios estatisticamente correlacionados.
- Não faça mutar variáveis globais dentro de funções transformadas com
jit,gradouvmap.
Solução de problemas
| Erro | Causa | Solução |
|---|---|---|
ConcretizationTypeError: Abstract tracer value used in Python if/while | Ramificação condicional Python depende de valores dinâmicos de array JAX dentro de jit. | Use jax.lax.cond ou jax.lax.while_loop em vez do if Python padrão. |
JAX arrays are immutable | Tentativa de atribuição in-place (arr[0] = 5). | Use sintaxe de atualização funcional: arr = arr.at[0].set(5). |
PRNGKey reuse warning / identical randomness | Reutilização de chave PRNG idêntica produz números aleatórios idênticos. | Divida as chaves antes de cada operação aleatória: key, subkey = jax.random.split(key). |