-
New features
- Pallas APIs are now available under
jax.pallas(jax.pallas,
jax.pallas.tpu,jax.pallas.tpu_sc,jax.pallas.mosaic_gpu, and
jax.pallas.fuser, via explicitimport jax.pallas). Existing imports from
jax.experimental.pallasremain valid, whiletritonandopsstay under
jax.experimental.pallas. See the Pallas changelog for Pallas-specific
changes. - Added a keyword-only
with_logsoption tojax.gradand
jax.value_and_grad, returning backward-pass logs alongside
gradients without callingjax.vjpdirectly. Withwith_logs=True,
gradreturns(grad, logs)(or(grad, aux, logs)whenhas_aux=True),
andvalue_and_gradreturns(val, (grad, logs))(or
((val, aux), (grad, logs))). - Added
jax.avals(along withMesh.axesandAbstractMesh.axes) for
concise shorthand construction of abstract array types (ShapedArray) with
optional sharding annotations, such asf32[3@X]andf32[()]. - On Python 3.14 and later,
jax.debug.printnow accepts PEP 750
template strings (for example,jax.debug.print(t"hello {x}"))
(#41565). - Added
F8E4M3FN_F8E4M3FN_F32_X3andF8E4M3FN_F8E4M3FN_F32_X4to
jax.lax.DotAlgorithmPreset(andjax_default_matmul_precision)
for emulatingbfloat16precision matrix multiplications onbfloat16or
float32inputs using 3 or 4float8_e4m3fnproducts accumulated in
float32. - Added CPU support for
jax.lax.DotAlgorithmPreset.F16_F16_F32, fixing
jax.nn.dot_product_attentionwithimplementation="xla"and
float16inputs underjitandgradon CPU. - Added
jax.lax.fmaandjax.lax.fmuladdfor fused
multiply-add (a * b + c).fmaperforms a single-rounding fused
multiply-add where supported;fmuladduses fused multiply-add when
available and falls back safely otherwise (#23919).
jax.lax.polynomialnow usesfmuladdfor floating-point evaluation. - Added
jax.lax.sinpi,jax.lax.cospi, and
jax.lax.tanpi, which computesin(pi * x),cos(pi * x), and
tan(pi * x)more accurately than multiplying bypifirst. They return
exact values at integers and half-integers and stay accurate for large
inputs. Window functions (jax.numpy.blackman,
jax.numpy.hamming,jax.numpy.hanning),
jax.scipy.signal.stft,jax.scipy.special.fresnel, and
Lanczosjax.image.resizenow use them for better accuracy. - Added
jax.lax.asinpi,jax.lax.acospi,
jax.lax.atanpi, andjax.lax.atan2pi, which compute the
inverse trigonometric functions divided bypi(asin(x) / pi,
acos(x) / pi,atan(x) / pi, andatan2(x, y) / pi). - Added
jax.lax.exp2m1andjax.lax.log2p1, which compute
2**x - 1andlog2(1 + x)without losing precision nearx = 0. - Added
jax.scipy.special.gammaincinvand
jax.scipy.special.gammainccinv, the inverses of the regularized
lower and upper incomplete gamma functions, with gradients with respect to
both arguments (#5350). - Added
jax.scipy.special.jn,jax.scipy.special.yn,
jax.scipy.special.iv, andjax.scipy.special.kn, providing
accurate evaluation of integer-order Bessel functions and modified Bessel
functions of the first and second kind (for static integer orders, with
support for real and complex inputs and automatic differentiation). - Added
jax.scipy.special.ndtri_exp, the inverse of
jax.scipy.special.log_ndtr(ndtri(exp(y))without underflow or
cancellation in log-probability space), supporting accurate forward-,
reverse-, and higher-order differentiation. jax.numpy.histogram_bin_edgesandjax.numpy.histogramnow
acceptbins="sqrt"andbins="sturges"to choose bin counts
automatically, matching NumPy (#42199).- Added the keyword-only
deviceargument tojax.numpy.logspaceand
jax.numpy.geomspace(#41659). - Added the keyword-only
correctionargument (NumPy 2.0 alias forddof)
tojax.numpy.nanvarandjax.numpy.nanstd
(#41696). - Added an optional
modekeyword argument tojax.random.normal
(controlled by the newjax_random_normal_modeconfig option, default
"low")."low"keeps existing behavior (truncating around ±5.3 standard
deviations infloat32);"high"uses more random bits per sample (~±6.3
infloat32, ±9.4 infloat64), and"highest"uses two random streams
to reach roughly ±9.1 infloat32without enablingx64. - Added an optional keyword-only
modeargument to
jax.random.truncated_normal(default"low"). Settingmode="high"
improves tail accuracy and eliminates boundary clamping spikes at extreme
truncation bounds and in 16-bit floating-point types. - Added a keyword-only
num_streamsargument tojax.random.bitsto
generate a tuple of1,2, or4independent unsigned integer arrays in
parallel from the underlying generator's native bit streams. - Added optional
out_shardingsupport tojax.lax.scatter(and
scatter_add,scatter_sub,scatter_mul,scatter_min,scatter_max,
scatter_apply),jax.lax.gather,jax.numpy.take
(Array.take),jax.numpy.take_along_axis,jax.numpy.sum,
jax.numpy.max,jax.numpy.quantile,
jax.numpy.nanquantile, andjax.numpy.nanpercentile(and
native pass-through injax.numpy.percentile). jax.lax.top_k,jax.lax.approx_max_k, and
jax.lax.approx_min_know support sharded reduction axes under
explicit sharding.jax.dlpack.from_dlpack(andjax.numpy.from_dlpack) now
acceptjax.experimental.layout.Formatin theirdeviceargument to
specify device-local layouts (such as a linear layouttiling=((1,),)for
TPU pinned host memory buffers,kDLTPUHost;Layout.AUTOis not
supported). Whencopy=None, importingkDLTPUHostbuffers now falls back
to copying if zero-copy sharing is not possible.jax.experimental.serialize_executable.serializenow supports saving
and loading compiled functions that capture large constant arrays (see
Breaking changes regarding format version).- [ROCm] Added
pipextras (jax[rocm],jax[rocm7],jax[rocm10], and
per-GPU-targetjax[rocm7-device-<gfxNNN>]/
jax[rocm10-device-<gfxNNN>]) to install AMD's TheRock ROCm wheels directly
from AMD's package index without a pre-installed system ROCm
(jax[rocm7-local]remains for pre-installed ROCm) (#41331).
- Pallas APIs are now available under
-
Breaking changes
- The
jax_use_simplified_jaxpr_constantsconfiguration flag is nowTrue
by default. Non-scalar constant arrays captured from outside a jitted
function are now passed as separate inputs to compiled executables rather
than embedded inline, reducing executable size and avoiding host copies
during lowering. See the constants note in the JAX documentation for details, including how to
recognize a breakage and migrate your code. You can temporarily set
JAX_USE_SIMPLIFIED_JAXPR_CONSTANTS=Falseto restore the previous behavior;
the flag will be removed in a future release. - Removed support for the legacy GSPMD partitioner
(jax_use_shardy_partitioner=False). JAX now always uses the Shardy
partitioner, which has been the default for about a year. Custom
partitioning rules injax.experimental.custom_partitioningthat only
implement legacy GSPMD callbacks (instead ofsharding_rule) now raise
NotImplementedError. - Updated the binary format written by
jax.experimental.serialize_executable.serializeto version 3 to
support captured constant arrays. Loading executables saved with JAX
0.12.0or earlier via
jax.experimental.serialize_executable.deserialize_and_loadnow
raisesValueError. jax.randomsamplers now propagateout_shardingdirectly per shard
instead of falling back to automatic sharding or inserting hidden
all-gathers. Requesting anout_shardingthat shards non-key dimensions
now requires a partitionable generator (threefry2x32,rbg, or
unsafe_rbg, withjax_threefry_partitionable=True), raising
NotImplementedErrorotherwise. Conflicting parameter shardings or
sharding non-batch axes in composite samplers (permutation,
categorical,multivariate_normal,orthogonal,poisson) now raise
ShardingTypeError.jax.random.poissonwithmethod="exact"(the default) now keeps
the first accepted sample per element so draws do not depend on how the
array is sharded across devices. This can change the exact integer values
drawn for multi-element arrays whenlam >= 10.jax.numpy.histogramnow requiresout_shardingto be fully
replicated (raisingShardingTypeErrorotherwise) and, under explicit
sharding, requiresweightsto match the sharding ofa.jax.scipy.signal.welchandjax.scipy.signal.csd(as well as
jax.scipy.signal.stftwhen explicitly passednperseg=None) now
defaultnpersegto256whenwindowis a string or tuple, matching
SciPy and the documentation. Previously, inputs longer than256used the
full signal length, so output shapes and values may change
(#40012).
- The
-
Deprecations
jax.sharding.SingleDeviceShardingis deprecated. Use
jax.sharding.make_single_device_shardingto construct a single-device
sharding, andjax.sharding.is_single_device_shardingto check whether a
sharding targets a single device (replacing
isinstance(..., SingleDeviceSharding)).- The
jax_use_shardy_partitionerconfiguration flag is deprecated and is now
a no-op (setting it toFalseis silently ignored). JAX always uses the
Shardy partitioner, and the flag will be removed in a future release. jax.scipy.special.bessel_jnis deprecated; use
jax.scipy.special.jninstead, which is more accurate and evaluates
only the singlen-th Bessel function directly (note thatbessel_jn
returned all orders0..v, whereasjn(n, z)returns only ordern).
-
Changes
- On GPU, when neither
XLA_CLIENT_MEM_FRACTIONnor its deprecated alias
XLA_PYTHON_CLIENT_MEM_FRACTIONis set, JAX now preallocates 75% of GPU
memory at startup and allows the default GPU memory pool to grow up to
available device memory as needed for ordinary (non-collective) buffers
(XLA's0.75+policy). SetXLA_CLIENT_MEM_FRACTION=0.75to keep the
previous fixed limit. Explicit XLA memory-policy flags take precedence, and
allocator modes that do not support growth retain their existing behavior
(#41831). - Cached per-primitive compiled wrappers when running
jax.shard_map
eagerly (outsidejax.jitor underjax.disable_jit()), avoiding repeated
recompilation (#42470). jax.sharding.NamedSharding.shard_shapenow supports meshes with
manual axes.- Enabled the custom derivative rule for
jax.nn.softmax(and
jax.scipy.special.softmax) by default
(jax_softmax_custom_jvp=True), improving memory use and numerical
stability during differentiation. Set
jax.config.update("jax_softmax_custom_jvp", False)to temporarily restore
the previous behavior. - On CPU,
jax.lax.logandjax.lax.log1pnow use vectorized
kernels on x86-64 (AVX2/AVX-512) and ARM64 (NEON), speeding upfloat64by
1.7×–4.4× andfloat32by 19%–37%. This improvesfloat32accuracy for
log1p,log10,logit,acosh,asinh, andatanh, and relaxes
float64CPUlogmax error from 0.5 to 1.5 units in the last place
(ULPs), matching GPU; CPU tests expecting bit-exactfloat64logmay see
~1 ULP shifts. - On GPU and TPU,
accumulateforjax.numpy.bitwise_and,
jax.numpy.bitwise_or,jax.numpy.bitwise_xor,
jax.numpy.logical_and,jax.numpy.logical_or,
jax.numpy.logical_xor,jax.numpy.maximum, and
jax.numpy.minimumnow uses a parallel prefix scan for integer and
boolean outputs, which is much faster for long axes (#28097). jax.scipy.fft.dctandjax.scipy.fft.idct
(jax.scipy.fft.idctn) now use real FFTs (rfft/irfft) instead
of full complex FFTs, speeding up batchedidctby up to 2.7× on GPU and
9.4× on CPU (#42467, #42583).- Simplified gradients of
jax.numpy.logaddexpand
jax.numpy.logaddexp2usingjax.lax.logistic, making
gradient evaluation ~2–3× faster on CPU. Note that the gradient at
(inf, inf)now returnsnaninstead of1.0(#41914). - Replaced large elementwise computations for
jax.lax.lgamma
(jax.scipy.special.gammaln) andjax.lax.digamma
(jax.scipy.special.digamma) with dedicated vectorized CPU kernels
(usinghighway, added as aMODULE.bazeldependency) and GPU kernels
(CUDA/ROCm), improving compile time and speed while keeping error within
0.5 ULP (bfloat16) and 1.0 ULP (float16,float32,float64) across
CPU, GPU, and TPU. Also preserves very small (subnormal) inputs on GPU
instead of returning±inf. - Mixed real and complex
jax.numpy.add,jax.numpy.subtract,
jax.numpy.multiply, andjax.numpy.true_divide
(complex / real) no longer convert the real input to complex before
operating. This avoids unnecessary operations on zeros and fixes edge cases
with infinities and signed zeros (for example,0.5 * (inf + 1j)now
returnsinf + 0.5jinstead ofinf + nan*j). - Enabled a more accurate default implementation of
jax.lax.erfc(and
jax.scipy.special.erfc) (jax_accurate_default_erfc=True). It uses
fewer operations, preserves very small (subnormal) outputs on CPU and GPU,
returns1.0at±0.0, and reduces worst-case rounding error (float32:
from ~66 down to ≤7.0 ULPs on CPU, ≤7.5 on GPU, ≤9.5 on TPU v6e/7x, and
≤69.0 on TPU v2–v5p;float64: from ≥350 down to ≤10.0 on CPU and GPU).
Withaccuracy=jax.lax.AccuracyMode.HIGHEST, worst-case error drops to
≤1.5–2.0 ULPs with fewer operations, andbfloat16drops from 63 to 25 ops
with identical results. Setjax_accurate_default_erfc=Falseto temporarily
restore the previous behavior. - Enabled the more accurate implementation of
jax.lax.erf_invby
default (jax_accurate_erf_inv=True), fixing large precision loss near
|x| = 1(float32: ~65 down to ≤2.0 ULPs on CPU, ≤2.5 on GPU/TPU v6e/7x,
and ≤5.5 on TPU v5p;float64: ~500,000 down to ≤2.5 ULPs on CPU and GPU).
Also improved first- and higher-order derivative accuracy near|x| = 1.
Callers such asjax.scipy.special.erfinv,
jax.scipy.special.ndtri, and default normal random samplers may see
small last-bit numerical changes; setjax_accurate_erf_inv=Falseto
temporarily restore the previous behavior. jax.lax.exp2/jax.numpy.exp2andjax.lax.log2/
jax.numpy.log2now lower directly to native operations and support
accuracy=jax.lax.AccuracyMode.HIGHEST, greatly reducing rounding error
across dtypes and backends (for example,exp2float32CPU: 68.5 → 0.5
ULP, GPU: 69.0 → 2.5 ULP;float64CPU: 719.0 → 0.5 ULP, GPU: 719.0 → 1.0
ULP).- Improved numerical accuracy across several math and special functions:
jax.scipy.special.gammaandjax.scipy.special.factorial:
≤0.5 ULP (bfloat16) and ≤1.0 ULP (float16/float32/float64) across
CPU, GPU, and TPU; exactfactorialup to34!(float32) and170!
(float64); preserves subnormal inputs on GPU.jax.lax.sinhandjax.lax.cosh: vectorized CPU/TPU
implementations cutfloat32error to ≤1.0 ULP (down from 25 ULPs on CPU
and up to ~1794 ULPs on TPU) andfloat64CPU error from 496 to ≤2.0
ULPs, and fix prematuresinhoverflow near±89.4.jax.lax.asinandjax.lax.acos: improved CPU and TPU
float32error to ≤1.0 ULP and stopped flushing tiny normal inputs to
zero inasinon TPU.jax.lax.rsqrt: tightenedfloat32CPU error to ≤1.0 ULP on AVX
x86-64 CPUs (≤1.5 ULP on ARM) by always running two refinement steps on
both Intel and AMD CPUs.jax.lax.bessel_i0eandjax.lax.bessel_i1e: faster
implementation (~32 vs 85 ops infloat32) cuttingfloat32error from
8.0 / 15.5 down to ≤2.0–3.0 ULPs andfloat64from 7.5–10.5 down to ≤2.0
ULPs.jax.scipy.special.logit: fixed severe precision loss near0.5
and1(≤2.0–3.0 ULPs infloat32, ≤1.5 ULPs infloat64on CPU/GPU).jax.scipy.special.betalnandjax.scipy.stats.t.logpdf:
rewrittenbetalnimproves accuracy for extreme ratios and negative or
tiny inputs (raisingValueErrorfor complex inputs), andt.logpdf
avoids catastrophic cancellation for large degrees of freedom and in
float32on TPU (#38243, #39106,
#41203).jax.scipy.special.ndtrandjax.scipy.special.log_ndtr:
fixed large negative-tail error, positive-input precision loss, premature
overflow, and derivativeNaNs, with accurate higher-order derivatives
(#41676).jax.lax.logistic(jax.nn.sigmoid,
jax.scipy.special.expit): avoids overflow for large negative
inputs on GPU and infloat16across all backends, preserving very small
(subnormal) outputs instead of flushing prematurely to0.0.
- JAX now uses Bazel 9.3.1 to build from source.
- Linux and macOS source builds now compile with C++20 (Windows remains on
C++17). Linux wheels are built with LLVM 22, statically linkedlibc++,
and aglibc 2.27(manylinux_2_27) sysroot. Hermetic CUDA 13 builds
upgraded from CUDA13.0.0to13.4.1, and CUDA 12 source builds now
compile device code with Clang. - Bumped the pinned
libtpudependency forjax[tpu]from0.0.50.*to
0.0.53.*(#42544). - Added support for building
jaxlibagainst 64-bit integer BLAS/LAPACK
libraries (-DJAX_LAPACK_ILP64), and fixed
jax.scipy.linalg.lu_solvewhen SciPy uses 64-bit integer LAPACK
withjax_enable_x64=True. - [oneAPI] Plugin wheels are now built with C++20 and target
manylinux_2_31(glibc 2.31), allowing installation on older Linux
distributions (#42568).
- On GPU, when neither
-
Bug fixes
- Fixed separate
jax.jitinstances of the same function that differ
only instatic_argnums,static_argnames, orkeep_unusedsharing
internal dispatch cache entries, which could run the executable compiled
for one instance with the arguments of another and return wrong results
(#42313). - Added
jax_high_dynamic_range_gumbelto thejax.jitcache key
(#40609). - Fixed collective operations inside CPU loops (
jax.lax.while_loop)
and conditionals (jax.lax.cond) overlapping with later collectives,
which could swap messages across processes or crash. - Fixed a thread-pool deadlock when multiple batched CPU linear algebra
(LAPACK) calls run concurrently. - Fixed a crash (
SIGSEGV) during complex GPU eigendecomposition
(jax.lax.linalg.eig/jax.numpy.linalg.eig) when using
MAGMA due to insufficient host buffer alignment. - Fixed a crash (
std::bad_function_call) injaxlibwhen transferring
duplicate host shards with forced copying enabled (for example,
jax.device_put(..., may_alias=False)). - Fixed a potential crash when registering multi-stage foreign function
interface (FFI) targets viajax.ffi.register_ffi_target(where the
recordcallback pointer was left uninitialized), and added support for
the"record"handler stage. - Fixed CPU Python callbacks (
jax.pure_callback,
jax.experimental.io_callback, and
jax.experimental.buffer_callback) flushing very small (subnormal)
floating-point values to zero. - Fixed XLA compiler and runtime issues shipped in
jaxlib:- Out-of-memory failures for large GPU allocations (> 1 GiB) on WSL
despite sufficient free memory, by falling back to 1 GiB physical chunks
mapped into one contiguous virtual address range
(openxla/xla#52820). - Wrong numerical results on CPU when fusing a matrix multiplication with a
broadcasted constant right-hand operand and a reduction
(#41414, #42549). - Wrong numerical results on ARM64 SME/SME2 CPUs when fusing a matrix
multiplication with a constant left-hand operand and a reduction
(#42651). - Wrong results on Hopper/Blackwell NVIDIA GPUs (
sm_90+, CUDA 13.4+) for
large-stridefloat64column scatter overwrites (#41888). - Crash compiling a full-slice update (
.at[:].set(...)) immediately
followed by reversing the array ([::-1]) (#41497). lax.log(lax.pow(a, b))returning finite values instead ofNaNfor
negative bases underjax.jit(#41261).- Properly marks donated CPU buffers as deleted when an active host view
forces a copy, and marks multi-device arrays as deleted when donating a
non-first shard (#41256).
- Out-of-memory failures for large GPU allocations (> 1 GiB) on WSL
- Fixed
jax.lax.pmeanand constantjax.lax.psumdividing or
multiplying every group by the first group's size whenaxis_index_groups
has uneven group sizes (#41132). - Fixed batching, autodiff, and sharding bugs in
jax.lax.ragged_all_to_all(#41697). - Fixed
jax.lax.while_loopseeing stale values or dropping final
writes whencond_funreads or writes a mutableRef
(#41073). - Fixed
jax.lax.polynomialerrors insidejax.shard_mapwith
mixed constant and varying inputs (#41853). - Prevented silent wrong results (counting constants once per device) when
mixing unreduced or reduced arrays (under explicit sharding orshard_map)
with replicated constants inpad,concatenate/stack, andselect_n. - Fixed
out_shardingbeing silently ignored when array indexing lowers to
static or dynamic slicing. - Fixed
full_like/empty_likein partially manualjax.shard_map,
mesh context mismatches when differentiatingjax.jitwithexplicit_axes,
and false-positiveForbiddenCollectiveErrorin
jax.sharding.no_collectiveson 3-operandeinsum. - Fixed
jax.ref.new_ref(..., pin=True)errors when reading/writing pinned
references (#41846) or pinning buffers to TPU VMEM
(#41843). - Fixed sharded
philox2x32/philox4x32(lax.mulhi) forward-compatibility
export and compatibility with olderjaxlibbuilds. - Fixed
jax.exportdroppingweak_typeon outputs acrossserializeand
deserialize(bumping serialization format from 12 to 13,
backward-compatible with older payloads) (#41007), baking
caller stack traces into exported MLIR modules (causing non-deterministic
exports and cache misses), and loweringjax.lax.platform_dependent
branches for incompatible platforms during multi-platform export. - Fixed gradient
Refaccumulator forwarding in
jax.custom_vjp.defvjp_with_accumsand
jax.custom_gradient(with_accums=...)throughcheckpoint,jit,scan,
andcheckify; also fixedrematwith tupleprevent_cseand closed-over
constants, improved leaked-tracer error messages, and avoided copying in
jax.numpy.moveaxiswhen no axes move (#41717). - Fixed
jax.vmapofjax.numpy.stackemitting an unnecessary
transpose when stacking along the batched axis (#41794). - Fixed out-of-bounds unsigned integer indices (such as large
uint64or
uint32values) wrapping around modulo2**32instead of clamping when
cast to signedint32during indexing (#42657). - Fixed overflow when wrapping negative indices of narrow signed integer
dtypes (such asint8(-1)) on long axes across indexing, dynamic slicing,
jax.numpy.take, andjax.numpy.put; also madejax.ds
slices consistent between eager andjitexecution (#42354,
#42377). - Fixed
jax.numpy.interpreturningnanat and around sample points
whosefpvalue is infinite; it now returns the sample value or the signed
infinity, matching NumPy. For complexfp, the real and imaginary parts
are now interpolated separately, as in NumPy (#42318). Also
fixedinterpmishandling narrow intervals, duplicate trailingxp
coordinates,NaNquery inputs, andNaNderivatives at narrow or
duplicate boundaries (#42650). - Fixed
jax.numpy.modfreturningnanas the fractional part for
infinite inputs; it now returns a signed zero, matching NumPy
(#41102). - Fixed
jax.numpy.nonzero,jax.numpy.flatnonzero, and
jax.numpy.argwhereignoringfill_valueon empty arrays
(#42233). - Fixed
jax.numpy.nan_to_numoverwriting custom replacement values a
second time when replacingNaNwith infinity (#42406). - Fixed infinite loops in
jax.numpy.gcdandjax.numpy.lcmfor
minimum representable signed integers such asint32(-2**31)
(#40840). - Fixed
jax.numpy.choosewrapping indices when the number of choices
exceeds a narrow index dtype's maximum (#42464). - Fixed
jax.numpy.kronandjax.numpy.vanderfailing on
boolean inputs (#42462). - Fixed weighted
jax.numpy.quantile,jax.numpy.nanquantile,
jax.numpy.percentile, andjax.numpy.nanpercentile(with
method="inverted_cdf") returning zero-weight elements atq=0
(#42190). jax.scipy.linalg.polarwithmethod="qdwh"now honors
max_iterationsand acceptseps, as documented; previously
max_iterationswas silently ignored and any non-Noneepsraised a
ValueError. Bothepsandmax_iterationsare now static arguments of
polar(for allmethodvalues), so passing a traced value for either
raises an error (#41917).- Fixed wrong forward-mode derivatives (
jvp) of pivoted QR decomposition
(jax.lax.linalg.qr,jax.scipy.linalg.qr) for wide matrices
(m < n) (#42634). - Fixed
jax.scipy.linalg.toeplitzandjax.scipy.linalg.hankel
spreading a singleNaNorinfacross the entire output matrix
(#38635, #38636). - Fixed
jax.scipy.sparse.linalg.cgproducingNaNs or stopping early
when the right-hand side or initial guess has very small or very large
magnitude (for example, during differentiation with a preconditioner)
(#40254). - Fixed
jax.scipy.signal.convolve,convolve2d,correlate, and
correlate2draisingValueErroron mixed-size multidimensional arrays
formode="full"andmode="same", matching SciPy (#42063). - Fixed wrong derivatives for padded entries in
jax.experimental.sparse.coo_fromdenseand
jax.experimental.sparse.csr_fromdense(COO/CSR/CSC.fromdense)
whennse > nnz(#40624). - Fixed
jax.experimental.sparse.bcoo_reshape(BCOO.reshape)
miscomputing shapes for sparse arrays with dense dimensions
(#24795). - Fixed overflow and underflow in derivatives of division (
x / y,
jax.lax.div) for very large or very small denominators
(#37909). - Fixed overflow, cancellation in higher-order derivatives, and
NaN
gradients at single-axis infinities for complexjax.numpy.abs,
jax.numpy.hypot, andjax.numpy.arctan2
(jax.lax.atan2) (#25681). - Fixed
jax.nn.soft_signreturningNaNat±inf(now returns±1)
and losing derivative accuracy for large inputs. - Fixed
jax.nn.softmaxwithwhereleakingNaNinto gradients when
masked-out positions haveNaNor infinite tangents/cotangents. - Fixed overflow and out-of-domain derivatives in
jax.nn.log1mexp. - Fixed overflow and precision loss in
jax.nn.squareplusfor large
inputs infloat16(#41647). - Fixed a shape/broadcasting error in
jax.nn.get_scaled_dot_general_configfor'nvfp4'
(#42025). - Fixed wrong higher-order derivatives of
jax.scipy.special.fresnel
at odd integers and0. - Fixed premature overflow in
jax.scipy.special.i0
(jax.numpy.i0) andjax.scipy.special.i1for large finite
inputs (#39770, #39772). - Fixed
jax.scipy.special.expireturningNaNinstead ofinfat
+inf(#38519). - Fixed
jax.scipy.special.loggammareturningNaNinstead ofinfat
0.0and-0.0(#38240). - Fixed
jax.scipy.special.zetaand
jax.scipy.special.polygammafor large or infiniteq
(#41366). - Fixed
NaNgradients injax.scipy.stats.paretomethods outside the
distribution's domain (#41445). - Fixed
float32precision loss injax.scipy.stats.nbinom.logpmf
(#42145). - Fixed
logpmfandpmffor discrete distributions injax.scipy.stats
(betabinom,bernoulli,binom,geom, andnbinom) to return-inf
(0forpmf) for non-integerk - loc, matching SciPy; also fixedloc
bound checks inbetabinom(#41745, #41960). - Fixed
jax.random.poissonreturning undefined values or raising
underjax.debug_nans(True)whenlamis infinite or non-finite
(#38335). - Fixed
jax.random.multivariate_normalwithmethod="eigh"returning
NaNon singular or near-singular covariance matrices (#14345). - Fixed
jax.random.choicedropping other array dimensions when
drawing zero samples (#42429). - Fixed
jax.debug.breakpointwithbackend="web"crashing under
web-pdb2.x. - Preserved operation name (
op_name) metadata in compiled HLO when
jax_include_full_tracebacks_in_locations=False(#41587). - Fixed crashes in
jax_explain_cache_misses=Truewhendebug_infois
passed as a keyword argument (#41455) or argument names are
unknown.
- Fixed separate