pypi / torch
torch
What changed in torch 2, from its official release notes, upgrade guides and advisories. Sources checked 2026-10-18.
36 breaking7 security8 deprecations74 new APIs and options6 performance48 behavior and defaults3 tooling109 fixes and other
See which of these apply to your code, ranked, in your agent:
npx @unstale/cli inittorch 2291 changes
Breaking changes 36
Replaces the exported is_macos_13_or_newer() helper; no compatibility alias is provided.
The enum members drop the VER and PLUS portions of their names, with no compatibility aliases.
The zero-argument C++ overload was removed; pass includeBool explicitly, using false to preserve its previous behavior.
The zero-argument C++ overload was removed; pass includeBool explicitly, using false to preserve its previous behavior.
Dynamo graph-breaks rather than silently dropping tangents; fullgraph=True now errors.
Individual Python function events are excluded by default; pass include_python_functions=True to retain the previous view.
Custom Python process groups implementing new_group() must accept the backend keyword, which PyTorch now forwards when creating subgroups.
The setting is replaced with memory-headroom controls.
Segments allocated after registering a symmetric-memory pool are no longer automatically upgraded to symmetric windows; collectively deregister and register again after allocations to use symmetric-window algorithms.
It is now a deprecation shim: install and develop still forward to pip, while build and other commands print replacement commands instead of running setuptools. Build through pip or python -m build.
The deprecated API was removed; use torch.linalg.cholesky(). For an upper-triangular factor, take the conjugate transpose with .mH.
The deprecated API was removed; use torch.linalg.qr() with mode="reduced" or mode="complete" instead of the Boolean some argument.
Compiled and fake/meta execution enforce the same exact output-dtype requirements as eager execution.
The use_cuda argument was removed; use use_device="cuda" instead.
Complex type promotion for bfloat16 now uses bcomplex32 instead of complex64; cast explicitly to complex64 when its precision or operator coverage is required.
The deprecated API was removed; use torch.linalg.cholesky(). For an upper-triangular factor, take the conjugate transpose with .mH.
Boundary subgradients now follow the selected dispatcher schema's input space: scalar-bound equality gives the input gradient 0, while tensor-bound ties split gradients evenly.
At an ordinary tensor-bound tie, gradients split evenly between the input and bound.
At a scalar-bound equality the input gradient changes from 1 to 0; at an ordinary tensor-bound tie, gradients split evenly between input and bound.
The tvm backend now requires TVM's relax frontend; older TVM installations raise ImportError. Pass a TVM pipeline through options instead of relay-only scheduler and trials options.
It is a no-op for fake process groups and warns rather than failing for backends that cannot configure timeouts.
Ranks absent from every requested split now receive GroupMember.NON_GROUP_MEMBER instead of None.
Fractional max pooling raw operations now reject non-positive kernel_size values instead of returning invalid outputs and indices.
Ties now split gradients evenly, and forward-mode AD for the min/max family is aligned with the new rules.
Ties now split gradients evenly, and forward-mode AD for the min/max family is aligned with the new rules.
Functional and module Lp pooling APIs now raise a descriptive ValueError when norm_type=0.
Eligible fused backends are now selected for dense rank-3 inputs on CPU, CUDA/ROCm, and XPU. Selection may change numerics, dropout RNG consumption, view behavior, and higher-order-gradient support; select the math backend when those semantics are required.
The balanced policy is no longer accepted; use compact instead. Passing balanced now raises ValueError.
Invalid dim types are rejected at construction rather than failing later during forward.
Invalid dim types are rejected at construction rather than failing later during forward.
Setting profiler_measure_per_kernel to a non-default value no longer enables CUPTI range profiling, is ignored, and emits a FutureWarning.
Setting profiler_metrics to a non-default value no longer enables CUPTI range profiling, is ignored, and emits a FutureWarning.
The use_cuda argument was removed. Select CUDA through activities instead.
The deprecated API was removed; use torch.linalg.qr() with mode="reduced" or mode="complete" instead of the Boolean some argument.
The relay-only backend entry point no longer exists in torch._dynamo.backends.tvm.
The relay-only backend entry point no longer exists in torch._dynamo.backends.tvm.
Security 7
PyTorch is vulnerable to memory corruption through its torch.jit.script function
PyTorch is a Python package that provides tensor computation. Prior to version 2.10.0, a vulnerability in PyTorch's
weights_onlyunpickler allows an attacker to craft a malicious checkpoint file (.pth) that, when loaded withtorch.load(..., weights_only=True), can corrupt memory and potentiallyPyTorch is vulnerable to memory corruption through its torch.lstm_cell function
PyTorch is vulnerable to memory corruption through its unpack_sequence function
An issue in the component torch.linalg.lu of pytorch v2.8.0 allows attackers to cause a Denial of Service (DoS) when performing a slice operation.
pytorch v2.8.0 was discovered to contain an integer overflow in the component torch.nan_to_num-.long().
pytorch v2.8.0 was discovered to display unexpected behavior when the components torch.rot90 and torch.randn_like are used together.
Deprecations 8
The method is now a no-op with a deprecation warning; generator state is registered lazily on first RNG use during capture, so explicit registration calls should be removed.
The method emits a FutureWarning; activate a green context by creating a stream from it and using that stream with torch.cuda.stream().
The method emits a FutureWarning; activate a green context by creating a stream from it and using that stream with torch.cuda.stream().
The private alias remains available with a deprecation warning; use the public torch.distributed.set_timeout API.
The setting is deprecated and is now a no-op; generators are always traced lazily.
The distributed spelling remains a forwarding alias but now emits a FutureWarning; use torch.compiler.config.compile_on_one_rank.
TorchScript APIs now emit visible FutureWarnings directing users toward torch.compile or torch.export.
with_modules is deprecated and emits a FutureWarning; it collected module hierarchy only for TorchScript, while eager users can use with_stack=True to record nn.Module events.
New APIs and options 74
When set, AOTInductor prints timing and diagnostic messages for each constant-loading stage without requiring a rebuild.
Supports explicit user-defined streams and emits stream-guard code so compiled kernels run on the selected stream rather than always on the default stream.
Creates an AOTInductor model container from caller-owned weight tensors for zero-copy sharing; constants are not loaded from the package and remain caller-owned.
Adds a protocol for distributed checkpointing tensors that expose global and local shape and offset metadata.
Lets custom autograd.Function implementations declare each output's expected gradient dtype independently of its storage dtype.
Adds destroy callbacks and object retention.
Adds replay start and end hooks.
Adds portable JSON loading of distributed execution logs for comparisons across processes or model configurations.
Adds portable JSON serialization of distributed execution logs for comparisons across processes or model configurations.
Expanded sharding strategies for matrix, attention, sorting, scanning, softmax, tensor operations, and Conv1d/2d/3d; added redistribution from final-dimension sharding to Partial("sum").
Adds a shared keyword accepting ShapesSpec or ParamsSpec for explicit dynamic shapes in export, fake make_fx tracing, and torch.compile.
Profiler events expose Kineto metadata as typed values when expose_kineto_event_metadata is enabled, avoiding JSON reparsing.
Adds an experimental backend that creates per-peer NCCL point-to-point communicators on demand.
Adds an explicit legacy NCCL backend name alongside an opt-in for selecting the experimental replacement behind the nccl name.
The experimental backend gains fault-tolerant reconfiguration and one-sided window operations.
The experimental backend adds split_group, complete Work semantics, nonblocking communicators, uneven list collectives, communicator memory suspend/resume, and memory-pool registration and deregistration.
Can consume explicitly pre-split positional inputs, keyword inputs, and targets through arg_mbs, kwarg_mbs, and target_mbs.
Custom Python process groups can use batch_isend_irecv, the coalescing manager, and complete collective coverage, including single-tensor gather/scatter.
Adds an experimental accessor for custom backend development.
Gloo process groups support fault-tolerant reconfiguration.
Allows readable communicator names in NCCL logs and profiler tools.
Controls the number of cuBLASLt heuristic candidates requested by TunableOp.
Adds an option to choose whether selective activation checkpointing honors surrounding saved_tensors_hooks; the current default preserves legacy behavior and warns when hooks are active. Requires use_reentrant=False.
Used to provide optional shell-completion generation for torchrun.
Callers can provide an is_impure_node callback so side-effecting nodes are preserved during dead-code elimination.
Adds a prototype higher-order op selecting among N branches by index; autograd is not yet supported.
Adds XPU support for symmetric-memory operations used by asynchronous tensor parallelism, enabling communication and computation overlap on Intel GPUs.
Adds read-only DLPack export, including copy-on-write-preserving exchange with compatible consumers.
This is the preferred environment variable for compile_on_one_rank; the older distributed-prefixed variable remains supported for compatibility.
The opt-in selects the experimental replacement backend behind the nccl name.
Enables an autotuning_inputs log artifact reporting Triton autotuning input shapes, dtypes, strides, and scalar values.
Adds stable-ABI permute.
Adds stable-ABI Tensor overloads for bitwise operations, index_select, floor_divide, and is_pinned.
Adds stable-ABI conversion from Python torch.Tensor objects to torch::stable::Tensor.
Adds a stable-ABI query for whether a Tensor has storage.
Adds stable-ABI conversion from torch::stable::Tensor to Python torch.Tensor objects.
Adds a dtype overload to stable-ABI view.
Adds a length argument so a scan can run a fixed number of steps when xs=None.
Opt-in setting applies locality-based graph reordering to training graphs.
Opt-in CUDA Graph Trees generation cloning preserves live user-visible outputs across generations.
Adds backend-agnostic accelerator RNG state inspection.
Adds backend-agnostic inspection of RNG states across accelerators.
Adds backend-agnostic accelerator RNG seed inspection.
Adds a thread-local context manager whose callback receives fully populated autograd graph nodes created in its scope, including during higher-order differentiation and checkpoint recomputation.
Opts eligible bfloat16 grouped GEMM workloads into the cuBLASLt backend on Hopper and Blackwell with CUDA 13.3 or newer; eligible float16 workloads select it by default.
Adds support for TVM's Relax frontend and pipeline-based tuning.
Lets code request another CUDA Graph Trees warmup iteration.
Adds a public API for non-strict tracing.
Adds a capture-start hook alongside global CUDA graph capture and replay start/end hooks.
Adds a public CUDA graph annotations module.
The CUDAGraph debug flag is unified, debug_dump moves to Python, and capture hooks are added.
Attaches timestamped metadata events to live CUDA allocations; annotations appear in snapshots when memory history is enabled and only the native CUDA caching allocator supports them.
Memory snapshots can include CPU pinned-memory allocations; pass record_cuda=False to record only pinned host memory.
Adds a control for the number of cuBLASLt heuristic candidates used by TunableOp, which now supports CUDA cuBLASLt.
Adds an experimental accessor for custom backend development.
Adds a public API for setting distributed timeouts; the private alias remains available with a deprecation warning.
Adds construction of distributed linearly spaced tensors.
Adds construction of distributed logarithmically spaced tensors.
Attaches a dynamic-shape specification to a function or nn.Module.forward; compile, export, and make_fx use it automatically, and conflicting call-site specifications error.
Lets Python-authored kernels reserve Philox counter ranges that remain correct across CUDA Graph capture and replay.
Computes the principal square root of symmetric or Hermitian positive-definite matrices, supporting batches, autograd, vmap, and torch.compile.
Computes the polar decomposition A = U @ H for matrices with at least as many rows as columns, using portable SVD and eligible CUDA cuSOLVER QDWH acceleration.
MPS adds flex_attention auxiliary and dynamic-shape support, polar, large-tensor nonzero, complex Cholesky and nan_to_num, upsampling backward, and geqrf support.
Adds MPS forward and backward support.
The CUDA memory-efficient backend adds grouped-query attention, implicit multi-query key/value broadcasting, and backward support under vmap.
Adds a maximize parameter.
Adds the spectral_unclamped scaling option to the adjust_lr_fn parameter.
Can be called without a function to create an eager-mode decorator with checkpoint configuration separated from wrapped-function arguments; direct calls remain the compatible form under torch.compile.
Adds a wrapper for read-only DLPack export and compatible copy-on-write-preserving exchange.
Adds a query for per-process GPU memory usage on XPU.
Device-wide synchronization support is added on XPU.
Adds a log-line prefix template and hostname variable to identify the host that emitted each worker log line.
Adds optional shell-completion generation through the shtab package.
A dedicated error type is added for SYCL compilation failures.
Performance 6
Importing this module no longer eagerly compiles TorchScript merely because the module is imported.
Conversions are lowered directly on CPU and CUDA instead of relying on fallback conversion code.
Importing this module no longer eagerly compiles TorchScript merely because the module is imported.
Adds native float32 and complex64 MPS implementations, retaining CPU fallbacks for small matrices and matrices exceeding threadgroup memory.
Adds native float32 and complex64 MPS implementations, retaining CPU fallbacks for small matrices and matrices exceeding threadgroup memory.
Importing this module no longer eagerly compiles TorchScript merely because the module is imported.
Behavior and default changes 48
Supports lazy autotuning and compilation of torch.cond and torch.while_loop.
Adds native MPS support.
A single CUDA graph can now use multiple memory pools.
Supports head dimension 256 on SM90 and SM10.x with cuDNN newer than 9.22 and cuDNN Frontend 1.24 or newer; backward currently requires d_qk and d_v both 256.
Multiword compiler commands such as "zig c++" are accepted when building Inductor-generated C++ code on POSIX systems.
Returns input nodes, output nodes, and parameters in deterministic graph order.
Adds initial technology-preview AMD support; CK SDPA/GEMM, FP8 grouped GEMM, and int4 matrix multiplication remain unsupported.
Enabled on Linux with ROCm 7.14 or newer.
Pair communicators are included in error reporting, suspend/resume operations, and memory statistics, with broader shared backend coverage.
Partitioned-scatter selection is memory- and contention-aware and enabled by default on ROCm; set this setting to False to opt out.
Adds native MPS sampling, eliminating its CPU fallback.
Module functions and constants are accepted as messages.
Explicitly registered logging.Logger methods with supported positional arguments run after the compiled region instead of causing graph breaks.
Adds XPU FP8 blockwise scaling support for MXFP8, MXFP4, and NVFP4 recipes.
Adds XPU FP8 blockwise scaling support for MXFP8, MXFP4, and NVFP4 recipes.
CUDA now supports torch.float16 and torch.bfloat16 inputs.
Selecting the CK GEMM backend now works on ROCm gfx90a devices, independently of CK attention support.
Compilation support expands for Python constructs and tracing covers additional accelerator, tensor, and distributed operations.
Reuse now supports source-backed objects, symbolic shapes, dataclasses, and namedtuples.
Supports dynamic shapes for dimensions marked with mark_unbacked, allowing one artifact to serve multiple runtime sizes without guarding on that dimension.
CUDA graph memory pools are included in the reported reserved memory.
Can be used inside a compiled region; allocations in the context, including fallback and extern kernels, are routed to the pool.
Device-qualified Gloo backends are accepted when TorchComms is enabled.
Adds bfloat16 support on CUDA and float16/bfloat16 support on XPU; unsupported CUDA and XPU cases promote to float32, while CPU FFT continues to reject these dtypes.
The eager CPU torch.polar kernel now supports Half inputs.
MPS dispatch key is preserved through transforms, enabling MPS autocast and autograd under vmap and grad.
Enabled on ROCm 7.14 or newer through hipSOLVER's generic Xgeev API.
Adds native float32 and complex64 MPS implementations, retaining CPU fallbacks for small matrices and matrices exceeding threadgroup memory.
Adds native float32 and complex64 MPS implementations, retaining CPU fallbacks for small matrices and matrices exceeding threadgroup memory.
Adds MPS support, including complex inputs, on macOS 15 or newer.
Backward support is available on CPU, CUDA, and MPS, and Dynamo can trace the operation.
MPS gains support for the operation.
Adds native float32 and complex64 MPS implementations, retaining CPU fallbacks for small matrices and matrices exceeding threadgroup memory.
Added to the core ATen decomposition table used by ExportedProgram.run_decompositions(), including correct dim=() handling, and gained sparse COO dispatch.
Out-of-tree backends can define additional out_dtype combinations under fake/meta tracing; CUDA and XPU restrictions remain unchanged.
Can process float32 and float64 inputs larger than 2**24 elements on devices supporting float64 by computing ranks in float64.
The chunked path handles probability targets with mean or sum reduction when target dtype matches input and targets do not require gradients.
Can process float32 and float64 inputs larger than 2**24 elements on devices supporting float64 by computing ranks in float64.
CUDA float16 and bfloat16 support is added, including supported sparse-CSR backward paths.
Adds bfloat16 support on CUDA and float16/bfloat16 support on XPU; unsupported CUDA and XPU cases promote to float32, while CPU continues to reject these dtypes.
Compiled scans now honor deterministic-algorithm settings.
Adds scalar searchsorted support, broader copy-view batching, scalar fill and comparison support, and a native in-place masked_fill_ rule. Batched repeat_interleave requires a common output_size.
Adds CUDA graph support.
Bare backend names are auto-qualified, process-group options pass through custom backend creation, and unknown device-qualified names can register as custom backends.
Adds native recording mode on non-PVC devices when built with oneAPI 2026.1 or newer.
Profiler overhead is recorded as OVERHEAD activities on a dedicated track in exported traces.
Adds IPC memory handle sharing support on XPU.
Inductor autotuning subprocesses now honor this XPU environment variable.
Tooling 3
Adds the documented memory_format overload so static type checkers accept calls such as module.to(memory_format=torch.channels_last).
Static typing for indexing now resolves integer keys to Module and slices to Sequential.
Adds mappings for cublasMath_t, its enum values, and CUBLAS_COMPUTE_16F so HIP-ported extensions using these cuBLAS features hipify without project aliases.
Fixes and other changes 109
Updates the binaries to CUDA 13.2.2, resolving CUDA issues that could produce incorrect results in NVFP4 matrix multiplications and kernels with nested thread divergence.
Fixes incorrect solutions on MPS for complex batched underdetermined systems.
Fixes failures on MPS with a Metal pipeline-state error for inputs above 8192 elements.
Fixes non-orthogonal U and inaccurate small singular values on MPS for rank-deficient and ill-conditioned inputs.
Fixes failures on MPS with a Metal pipeline-state error for inputs above 8192 elements.
Fixes failures on MPS with a Metal pipeline-state error for inputs above 8192 elements.
Fixes an internal assert on MPS for complex inputs when using out.
Functional backward supports the linear avg reduction instead of rejecting it after a successful forward pass.
The NCCL symmetric-memory backend now implements barrier instead of raising a not-implemented error.
Replacing FileBaton with filelock prevents stale-lock deadlocks.
Its pool is trimmed and allocation is retried once before an out-of-memory error is raised.
Registered custom communication backends are selected instead of incorrectly falling back to NCCL or Gloo when the backend is unspecified.
CUDA IPC-backed dataset storage is released when workers exit, preventing retained producer-side references and allocations.
Post-dispatch make_fx tracing decomposes detach by default to fix silently incorrect second-order gradients; an explicit decomposition table retains previous behavior.
Compiled functions can return DTensor permutation views such as transpose, permute, or movedim.
Quantized byte and 4-bit rowwise lookups no longer fault on ROCm.
Generating guard messages for deeply nested symbolic-shape expressions no longer raises RecursionError.
summon_full_params with offload_to_cpu no longer accesses freed storage when the flattened parameter is already on CPU.
HIP C++ extensions on Windows now register hipify-produced .hip sources with MSVC so they are dispatched to hipcc.
Complex inputs are rejected with NotImplementedError instead of an internal MPSGraph error.
Pinned memory correctly appears as a CPU tensor while retaining its shared Metal buffer.
Unsupported dtypes now produce a clear error.
The correct Metal cooperative-tensor ABI is selected on macOS 26 to prevent corrupted output.
Dtype-converting copies no longer overwrite their source and non-dense views copy correctly with matching strides.
Non-contiguous tensors are handled safely, fixing vmap failures and possible out-of-bounds memory accesses.
Non-contiguous tensors are handled safely, and CUDA backward precision errors are fixed by applying missing upcasts.
Ranks are normalized through Python's integer protocol, allowing tensor integer ranks and clearly rejecting non-integral values.
CUDA backward uses 64-bit sample offsets.
Python subclasses can be constructed through the (store, rank, size) constructor, and their virtual overrides are dispatched correctly.
PyTorch publishes Python 3.15 wheels for Linux x86-64 and aarch64, Windows x86-64, and macOS Apple silicon across applicable builds; torch.compile remains unsupported.
PyTorch publishes free-threaded Python 3.15t wheels across the listed Linux, Windows, and macOS platforms; torch.compile remains unsupported.
Dynamo now matches Python behavior for a range of built-ins, conversions, descriptors, errors, operators, subclass types, and attribute probing.
The FBGEMM ARM path now checks overflow, fixing incorrect quantized values on some hardware.
Modules using only this hook no longer emit a warning intended for register_full_backward_hook when forward inputs do not require gradients.
The ROCm meta-kernel now uses the compact log-sum-exp dimension returned by ROCm backends, fixing nested tensor backward and torch.compile.
A warning is issued when collectives are launched concurrently on multiple streams, which can otherwise deadlock.
MPS computes integer absolute values exactly instead of rounding through float32.
MPS handles empty dimensions.
MPS supports strided output tensors on macOS 14 and 15.
Fractional arguments with an integer output dtype no longer produce the wrong length due to premature truncation.
Validation error messages preserve dynamic type names and argument indices.
MPS handles empty dimensions and does not propagate NaN or infinity from input when beta=0.
MPS handles empty dimensions.
Supports second-order gradients, so grad-grad computations no longer fail for lack of a backward derivative.
CUDA clamp preserves signed zero.
Inductor handling of torch.combinations and several other operation and graph-output cases is corrected.
Compilation better matches Python built-ins, operators, iterators, container initialization, object behavior, exceptions, and subgenerator closure behavior.
Selected Dynamo, Inductor, and FX tracing state is thread-local to prevent race conditions when compilation is invoked concurrently from multiple threads.
No-op dropout decompositions preserve eager identity semantics, avoiding replacement of a Parameter with a cloned fake tensor when dropout is disabled.
Graph reuse, eager autograd, graph capture, and transposed captured buffers are fixed.
Compilation fixes cover tensor subclasses, torch.func, autocast, metadata guards, fake-mode re-entry, in-place mutation, and several graph-break cases.
Symbolic proxy tracing and repeated lowering edge cases involving contiguous-stride expressions are fixed.
ROCm graph capture no longer fails or hangs for callables using hipBLASLt; warmup and capture use the same stream.
A nonzero root argument is respected instead of always broadcasting from the first tensor.
Compiled output and gradients are corrected for overlapping-input operations.
Streams are flushed before fsync so buffered writes are persisted correctly on remote filesystems such as GCS.
Locally synchronized calls consistently return GroupMember.NON_GROUP_MEMBER on nonmember ranks.
Subgroups whose local and global source ranks differ no longer produce a zero source gradient.
Gloo and NCCL no longer crash when the world process group was not the first backend instance created.
MPS floor division now matches CPU and CUDA nonfinite-value semantics.
Dynamic-shape specifications for functions with **kwargs now accept call-like keys and specs nested under the variadic parameter, and ambiguous name collisions report UserError.
Strict export treats parameters from modules in unregistered Python containers as constants rather than trying to restore them from eager module state.
Non-strict export now handles tensor indexing under vmap when the index is a batched scalar tensor.
Restores parameters, buffers, and constants for non-contiguously numbered repeated module calls.
Compiled MPS operations no longer fail with KeyError for unsigned 16-, 32-, or 64-bit index expressions.
MPS results are corrected for extreme values.
MPS handles empty indices.
Length clamping and padding remain symbolic under dynamic shapes, avoiding recompilation and data-dependent guard failures when requested length crosses signal length.
Signed right-shift export rounds negative values toward negative infinity, matching PyTorch.
Gradients for negative integer exponents now return 2.0 ** exponent instead of zero.
Invalid complex norm orders raise a clear ValueError; dynamic compilation also handles p='fro' and p='nuc' with symbolic tensor sizes.
CUDA Graph capture is fixed for this operation.
The CPU gelsy driver no longer returns an incorrect rank because of stale pivot values between batched LAPACK calls.
Backward accuracy improves using a correctly rounded double-precision log(10) constant.
Backward accuracy improves by using named mathematical constants.
Inconsistent LU_pivots and LU_data shapes now raise a clear error instead of segfaulting.
Compiled output strides and channels-last memory format now match eager CPU execution.
MPS supports strided output tensors on macOS 14 and 15.
Meta output shapes are corrected when dim=() should reduce all dimensions.
MPS bfloat16 tensors no longer return their input unchanged.
Backward no longer crashes for channels-last MPS tensors.
MPS output is corrected when a kernel spatial dimension is at least 256.
Compiled execution rejects alpha=0 with the same error as eager execution.
CUDA backward no longer overflows int32 for mode="max".
ROCm nearest interpolation no longer fails on large channels-last inputs whose output approaches 2^32 elements.
MPS linear backward handles inputs with more than four dimensions, and complex high-rank linear operations no longer abort on macOS 27.
MPS linear forward and backward handle zero in_features without aborting.
Compiled values and gradients are corrected when targets use -1 padding.
Supports second-order gradients, so grad-grad computations no longer fail for lack of a backward derivative.
The attention-mask dtype is declared to cuDNN rather than inherited from graph I/O dtype.
Memory-efficient attention remap extents, causal key bounds, and 32-bit dropout offsets are corrected.
cuDNN variable-length SDPA is fixed.
CPU flash SDPA now returns correct results when the innermost input dimension is not contiguous.
MPS attention kernels now propagate NaNs correctly.
ROCm results are corrected for very large row counts when normalized size is not a multiple of 4.
Decompositions avoid data-dependent guard failures when sequence lengths are symbolic.
Quantized gather export unpacks quantized tensor inputs before lowering.
The constant_pad_nd reference decomposition is fully functional, so dynamo ONNX export no longer fails functionalization for models using pad.
Fused CPU optimizer updates and float16/bfloat16 casts are corrected.
Becomes a no-op for an empty parameter group.
Fused CPU optimizer updates and float16/bfloat16 casts are corrected.
Backward handles Boolean scalar bases and symbolic Python integer exponents without an assertion failure or NYI SymInt equality crash.
Ordinary profiling no longer imports the experimental CUPTI monitor, preventing repeated warnings and tracebacks on systems with incompatible cupti-python versions.
The qint32 per-channel float_qparams path no longer divide-by-zero crashes, and whole-byte quantized types pack correctly.
CUDA relu preserves signed zero.
Assigning Python integers greater than INT64_MAX no longer raises an overflow-unpacking error.
Nonempty inputs with a zero-sized shape dimension raise a clear ValueError; empty indices remain supported.
Unsupported third-order derivatives are rejected instead of silently returning an invalid result; second-order derivatives and evaluation mode are unchanged.
Zero-sized spatial outputs now short-circuit to empty output and zero backward gradients, matching cuDNN and CPU behavior.