Communitygithub.com

G1Joshi/Agent-Skills

Assistência especializada em JAX, cobrindo Autograd, compilação XLA (`jit`), vetorização (`vmap`) e paralelização (`pmap`). Use ao construir computação numérica de alto desempenho e pesquisa de ponta em deep learning.

O que é Agent-Skills?

Esta skill fornece assistência especializada em JAX, um framework de computação numérica de alto desempenho que combina Autograd (diferenciação automática) com XLA (compilação acelerada por hardware). A skill é útil para desenvolvedores e pesquisadores que trabalham com deep learning personalizado, computação científica e otimização de modelos em GPUs ou TPUs. Ela é suportada em ferramentas de agente de IA como Claude Code ou Cursor, e se baseia no SKILL.md para ensinar conceitos fundamentais como transformações de funções compostas (`jit`, `grad`, `vmap`), gerenciamento de chaves PRNG sem estado e construção de redes neurais com Equinox ou Flax NNX. A skill explica como escrever código puramente funcional, evitar armadilhas comuns como reutilização de chaves PRNG ou mutação de arrays, e tira dúvidas sobre erros típicos como `ConcretizationTypeError`, fornecendo exemplos práticos e referências à documentação oficial do JAX.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/G1Joshi/Agent-Skills/tree/HEAD/skills/ai-ml/jax

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

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) e vmap (vetorização).
  • Treinamento distribuído em múltiplos dispositivos: Paralelização de computação em clusters usando pmap e 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 de x[idx] = val).
  • Faça envolver funções críticas de desempenho com @jax.jit para 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; use jax.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, grad ou vmap.

Solução de problemas

ErroCausaSolução
ConcretizationTypeError: Abstract tracer value used in Python if/whileRamificaçã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 immutableTentativa de atribuição in-place (arr[0] = 5).Use sintaxe de atualização funcional: arr = arr.at[0].set(5).
PRNGKey reuse warning / identical randomnessReutilizaçã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).

Referências

Individual skills in this repo

This repo contains 11 individual skills — each has its own dedicated page.

G1Joshi/Agent-Skills

Expert Dask distributed computing assistance covering Dask DataFrames, Arrays, Futures, and cluster scaling. Use when analyzing datasets too large for pandas on a single machine or multi-node cluster.

G1Joshi/Agent-Skills

Expert dbt (data build tool) assistance covering SQL modeling, Jinja macros, tests, documentation, and semantic layer. Use when building analytics engineering pipelines on BigQuery, Snowflake, or PostgreSQL.

G1Joshi/Agent-Skills

Expert Ray distributed computing assistance covering Ray Core (actors, tasks), Ray Train, Ray Tune, and Ray Serve. Use when scaling Python compute and ML training across multi-node clusters.

G1Joshi/Agent-Skills

Expert Git version control assistance covering branching, interactive rebase, cherry-pick, submodules, worktrees, and conflict resolution. Use when managing source code history and collaboration workflows.

G1Joshi/Agent-Skills

Expert K9s CLI assistance covering terminal Kubernetes cluster navigation, real-time log streaming, port forwarding, and pod debugging. Use when managing and troubleshooting Kubernetes clusters with speed.

G1Joshi/Agent-Skills

Expert SWC assistance covering high-performance Rust-based JavaScript/TypeScript compilation, .swcrc configuration, Jest testing via @swc/jest, and minification. Use when replacing Babel with SWC for faster builds, accelerating test execution, or compiling modern ECMAScript features.

G1Joshi/Agent-Skills

Expert Tig assistance covering text-mode interface for Git, interactive staging, commit graph visualization, diff exploration, and blame navigation. Use when navigating Git commit history in the terminal, staging hunks interactively, browsing file changes, or reviewing revisions.

G1Joshi/Agent-Skills

Expert Vim assistance covering modal editing, .vimrc configuration, registers, macros, search/replace, and plugin management via vim-plug. Use when editing text efficiently in terminal environments, writing Vimscript, recording macros, or configuring core Vim settings.

G1Joshi/Agent-Skills

Expert Zed editor assistance covering high-performance Rust-based text editing, multi-buffer editing, language server protocols (LSP), and AI assistant integrations. Use when configuring Zed settings.json, setting up language extensions, collaborating in real-time channels, or optimizing editor startup speed.

G1Joshi/Agent-Skills

Expert Zsh assistance covering shell customization, Oh My Zsh plugins, Zinit plugin manager, prompt engineering (Starship/Powerlevel10k), and shell scripting. Use when configuring .zshrc, writing Zsh automation scripts, optimizing shell startup time, or configuring tab-completion.

G1Joshi/Agent-Skills

Expert [skill-name] assistance covering [feature 1], [feature 2], and [feature 3]. Use when [working with X], [debugging Y], or [implementing Z].

Habilidades Relacionadas