JAX stands for Just After Execution (or perhaps jokingly, "NumPy on accelerators, with gradients"). Developed by Google Research, it's a Python library specifically designed for high-performance numerical computation and machine learning research. If you're comfortable with NumPy, you'll find JAX's primary interface quite familiar, but underneath the surface, JAX operates very differently to achieve significant performance gains, especially on modern hardware like GPUs (Graphics Processing Units) and TPUs (Tensor Processing Units).

Think of JAX not just as another array library, but as a platform built upon two fundamental pillars:

A Familiar NumPy Interface: JAX provides jax.numpy, an API designed to closely mirror the well-known NumPy API. This allows you to write numerical code using familiar functions like jnp.array, jnp.dot, jnp.sum, etc. (using jnp as the conventional alias). This significantly lowers the barrier to entry if you already work within the Python scientific computing stack. We will explore the subtle but important differences, such as array immutability, in the next section.
Composable Function Transformations: This is where JAX truly distinguishes itself. Instead of executing your Python code directly line-by-line like standard Python or NumPy, JAX is built around transforming your Python functions. The most prominent transformations are:
- jax.jit: Compiles your Python functions using the powerful XLA (Accelerated Linear Algebra) compiler for significant speedups on accelerators.
- jax.grad: Automatically computes the gradient (derivative) of your Python functions. This is essential for optimization tasks common in machine learning.
- jax.vmap: Automatically vectorizes your functions, allowing them to operate efficiently over batches of data without you needing to manually rewrite loops or array operations.
- jax.pmap: Enables parallel execution of functions across multiple devices (e.g., multiple GPUs or TPU cores), primarily for data parallelism.

These transformations can be arbitrarily composed, meaning you can jit a function that you've already taken the grad of, or vmap a function that is jit-compiled and contains collective operations for pmap. This composability allows for expressive and high-performance code.

At its core, JAX takes your Python functions written with jax.numpy and uses these transformations to convert them into an intermediate representation. This representation is then fed into the XLA compiler, which optimizes the computation specifically for the target hardware (CPU, GPU, or TPU).

JAX processes Python functions through transformations, compiles them via XLA, and executes optimized code on target hardware.

This transformation-based approach encourages a functional programming style. Because JAX often traces your functions to compile them (as we'll see with jit), functions that are "pure" (free of side effects, always producing the same output for the same input) work most smoothly with JAX's transformations. While JAX doesn't strictly enforce purity, understanding this principle helps in writing effective JAX code, particularly when managing state (covered in Chapter 6).

In essence, JAX provides a way to write high-level numerical programs in Python using a familiar NumPy-like syntax, while gaining the performance benefits of compilation and execution on specialized accelerators, along with powerful capabilities like automatic differentiation and vectorization, all through the application of function transformations.