Weekly GitHub Report for Pytorch

Thank you for subscribing to our weekly newsletter! Each week, we deliver a comprehensive summary of your GitHub project's latest activity right to your inbox, including an overview of your project's issues, pull requests, contributors, and commit activity.

Table of Contents

• I. News
  • 1.1. Recent Version Releases
  • 1.2. Other Noteworthy Updates
• II. Issues
  • 2.1. Top 5 Active Issues
  • 2.2. Top 5 Stale Issues
  • 2.3. Open Issues
  • 2.4. Closed Issues
  • 2.5. Issue Discussion Insights

• III. Pull Requests
  • 3.1. Open Pull Requests
  • 3.2. Closed Pull Requests
  • 3.3. Pull Request Discussion Insights

• IV. Contributors
  • 4.1. Contributors

I. News

1.1 Recent Version Releases:

The current version of this repository is v2.6.0

1.2 Version Information:

Released on January 29, 2025, PyTorch 2.6 introduces significant enhancements including torch.compile support for Python 3.13, a new dynamic compilation control API torch.compiler.set_stance, and improved AOTInductor packaging and ABI compatibility. Notable highlights also include FP16 support on X86 CPUs, expanded Intel GPU support with simplified installation, and a backward-incompatible security improvement flipping the default of torch.load to weights_only=True, alongside numerous performance optimizations, bug fixes, and deprecations such as the discontinuation of official Conda packages.

II. Issues

2.1 Top 5 Active Issues:

We consider active issues to be issues that that have been commented on most frequently within the last week. Bot comments are omitted.

1. [TRIAGE REVIEW] [MODULE: CPU] [MODULE: CORRECTNESS (SILENT)] [MODULE: REDUCTIONS] [BOT-TRIAGED] [RELEASE TRIAGE] torch.cumsum drops the sign of IEEE -0.0 on CPU (CUDA and NumPy preserve it): This issue reports that the torch.cumsum function on CPU incorrectly converts IEEE-754 negative zero (-0.0) inputs to positive zero, unlike CUDA and NumPy implementations which preserve the sign bit. The problem stems from the CPU implementation initializing the accumulator to positive zero, causing the loss of the signed-zero semantics during the cumulative sum operation, and a fix involving seeding the accumulator from the first input element is proposed and under review.

   • The comments show multiple contributors expressing interest in fixing the issue, coordinating to avoid duplicate work, and investigating the root cause, which was identified as the CPU accumulator initialization; a fix was implemented by seeding the accumulator from the first input element and accompanied by regression tests, with a pull request opened to address the problem.
   • Number of comments this week: 7

2. [TRIAGED] [OSS CONTRIBUTION WANTED] [ONCALL: PT2] [MODULE: DYNAMO] [dynamo] Meta-issue: torch.compile gaps found via the CPython test suite: This issue is a comprehensive meta-tracker for identifying and addressing various missing features and correctness bugs in the Dynamo compiler, as revealed by running the CPython test suite with PyTorch compiled for Python 3.13. It catalogs a wide range of gaps including unsupported builtins, object model inconsistencies, descriptor protocol issues, and internal compiler crashes, prioritizing fixes that improve correctness and reduce silent errors or crashes.

   • The comment discussion shows multiple contributors expressing interest in working on specific gaps, with encouragement to pick tasks freely and coordinate via PRs; there is a focus on reproducing issues, implementing fixes, and adding tests, with some contributors already investigating particular problems like cmath, length_hint(), and zero-argument bytes().
   • Number of comments this week: 7

3. [ONCALL: DISTRIBUTED] [TRIAGED] [BOT-TRIAGED] [ONCALL: DISTRIBUTED INFRA] [FSDP2][NCCL] Large slowdown for non-16-byte-aligned per-rank collective payloads: This issue reports a significant latency increase when using PyTorch's NCCL tensor collectives with per-rank payloads that are not 16-byte aligned, affecting both single-node and multi-node setups. The author proposes a fix involving padding communication staging strides to 16-byte boundaries without altering logical tensor sizes, aiming to improve collective performance on the default non-symmetric-memory NCCL path.

   • The comments acknowledge the detailed report and discuss related ongoing work on mixed precision and alignment issues, noting that slowdowns on unaligned inputs are expected due to hardware constraints, but clarifying that in this case the base address is aligned and the slowdown is caused by unaligned per-rank offsets.
   • Number of comments this week: 5

4. [TRIAGE REVIEW] [MODULE: PERFORMANCE] [MODULE: CPU] [MODULE: REGRESSION] [OP-BENCH] [MODULE: LINEAR ALGEBRA] [MODULE: ARM] [BOT-TRIAGED] [RELEASE TRIAGE] aarch64 CPU op-benchmark: matmul 256×256 trans_b ~25× slower than baseline: This issue reports a significant performance regression in the aarch64 CPU operator benchmark for a specific 256×256 matrix multiplication configuration with the second matrix transposed, which runs approximately 25 times slower than the expected baseline. The reporter seeks confirmation on whether the expected performance should be around 234 ms or closer to 6,000 ms to determine if this is a genuine regression in the GEMM/transpose path on the main branch.

   • The comments show interest in addressing the issue, with one contributor outlining a detailed plan to reproduce, characterize, and trace the regression, and requesting assistance for benchmarking on the specific ARM environment; there is also a follow-up asking for review and workflow approval on a related draft pull request.
   • Number of comments this week: 5

5. [GOOD FIRST ISSUE] [ONCALL: PT2] [EXPORT-TRIAGED] [ONCALL: EXPORT] [Feature request] torch.export .save/.load could support safetensors and/or weights_only=True: This issue requests adding optional support for the safetensors format and a weights_only=True flag to the torch.export save/load functions to enhance security by avoiding deserialization of pickled custom objects. The goal is to improve the safety of loading exported models while maintaining backward compatibility and providing clear tests and documentation for these new features.

   • Multiple contributors expressed interest in working on the issue, proposing to add flags for safe deserialization and safetensors support; discussions included implementation details like try/catch handling and fallback behavior, and a related PR was merged that restricts fallback loading to known safe types to mitigate security risks.
   • Number of comments this week: 4

2.2 Top 5 Stale Issues:

We consider stale issues to be issues that has had no activity within the last 30 days. The team should work together to get these issues resolved and closed as soon as possible.

As of our latest update, there are no stale issues for the project this week.

2.3 Open Issues

This section lists, groups, and then summarizes issues that were created within the last week in the repository.

Issues Opened This Week: 127

Summarized Issues:

• Quantization Support and Extensions: This issue proposes adding a new torch.nn.functional.quantize_tensor operation to enable efficient single-kernel tensor quantization for popular quantization recipes targeting functions like scaled_mm and scaled_grouped_mm. The design supports various quantization formats, is extensible for future recipes, and includes both frontend Python and backend JIT implementations with CPU fallback.
  • issues/195481

• Training Accuracy Regression on NVIDIA H100 GPUs: The functorch_dp_cifar10 training accuracy has consistently failed 100% on NVIDIA H100 GPUs since June 13, 2026, due to a regression linked to a cuDNN runtime upgrade and a separate GroupNorm kernel change. This results in numeric divergence from eager execution rather than a runtime failure across all configurations.
  • issues/195483

• Autocast State Management Bugs: The torch._dynamo.test_case.TestCase does not restore autocast state between tests, causing state leakage and masking test failures. Additionally, PyTorch Dynamo lowers the autocast context manager without a try/finally block, leading to leaked autocast state and incorrect nesting counters that may cause silent numerical errors.
  • issues/195487, issues/195488

• NVSHMEM Backend Resource Leaks and Deadlocks: The NVSHMEM backend initializes NVSHMEM without finalization, causing resource leaks and unrecoverable states due to a static guard flag. Moreover, symmetric tensor deallocation is unsafe because deleters perform collective nvshmem_free calls that can deadlock if ranks do not synchronize properly, and hidden collective operations during symmetric memory allocation can cause deadlocks with rank-asymmetric allocation orders.
  • issues/195499, issues/195500, issues/195501

• Float64 Derivative Computation Errors in Activation Functions: PyTorch's torch.autograd prematurely returns zero for first- and second-order derivatives of float64 sigmoid, tanh, logsigmoid, and silu functions at large positive inputs, despite analytic derivatives being finite and nonzero. This causes discrepancies in gradient and curvature computations during backward passes on CPU.
  • issues/195527, issues/195530, issues/195681, issues/195682, issues/195679

• Inconsistent Gradient and Loss Computations in BCE and Cross-Entropy: The binary_cross_entropy_with_logits function produces inconsistent forward values and gradients for mathematically equivalent float64 inputs, losing finite tail terms and causing incorrect gradients. Similarly, torch.nn.functional.cross_entropy returns zero for finite float64 first-order gradient components, leading to gradient sum deviations.
  • issues/195529, issues/195677, issues/195678

• Shape and Size Validation Missing in Operators: A class of bugs arises from missing shape and size validation in operators, leading to out-of-bounds tensor data access, heap-buffer-overflow errors, or silent memory corruption. A holistic, device-agnostic fix is proposed to validate input shapes based on operator schemas before kernel dispatch rather than patching operators individually.
  • issues/195547

• Disabled Failing Tests on XPU Platforms: Multiple tests related to index_add_bfloat16 variants are disabled on the main branch due to consistent failures on XPU platforms, indicating platform-specific instability or incompatibility.
  • issues/195558, issues/195559, issues/195560, issues/195561

• Context Parallel Sharding and Identity Node Bugs in TorchInductor: The _context_parallel_shard function incorrectly reduces the Q dimension block mask size, causing incompatibility with FlexAttention4's FlashAttention4 backend on Blackwell GPUs. Additionally, the remove_identity pre-gradient pass fails to remove all aliased nn.Identity nodes and crashes when Identity nodes are called with keyword arguments.
  • issues/195563, issues/195568, issues/195569

• Broadcast Shape Check Bypass in torch.compile: torch.compile bypasses the broadcast shape check performed by eager mode in torch.addmm, causing compiled code to return broadcasted results where eager mode raises runtime errors due to incompatible input shapes, leading to inconsistent execution behavior.
  • issues/195579

• Inductor Backend Compilation Bugs and Silent Errors: The Inductor backend produces silently incorrect and non-reproducible outputs when compiling models with BatchNorm2d followed by shrinking F.pad, and fusion of scaled dot-product attention (SDPA) on 5-D tensors fails with invalid addmm operations. Also, SDPA fusion raises ZeroDivisionError when matched scale is zero instead of skipping the operation.
  • issues/195582, issues/195589, issues/195591

• Reference Cycle Causing Delayed Tensor Deallocation: torch.fx.wrap() creates a reference cycle during the first lazy import of torch._dynamo that retains the entire caller stack and tensors from the initial forward call, delaying tensor deallocation and potentially causing CUDA out-of-memory errors until cyclic garbage collection runs.
  • issues/195586

• MPS Backend Indexing and Sparse Tensor Bugs: The MPS backend raises out-of-range negative index errors during large tensor scatter/index_put_ operations due to incorrect inverse indices from torch.unique on large int64 tensors. Additionally, sparse CSR tensor multiplication with integer types produces invalid compressed tensors that fail invariant checks intermittently.
  • issues/195595, issues/196190

• CUDA Illegal Memory Access in AOTInductor on H100 GPUs: A CUDA illegal memory access error occurs during AOTInductor compilation of a multi-level iterative module with dynamic shapes involving bilinear interpolation and torch.cond on NVIDIA H100 GPUs, causing crashes despite successful export and correct eager execution.
  • issues/195604

• FA4 SM100 Forward Specialization Limitation: FA4's SM100 forward specialization lacks support for head_dim=256 when using seqused_k in paged variable-length attention, blocking inference for Qwen3.5-9B models and causing assertion errors that prevent use of causal paged KV attention with required metadata on NVIDIA GB200 GPUs.
  • issues/195603

• Unsafe Checkpoint Loading via setattr in _set_obj_state(): The _set_obj_state() function unsafely applies setattr to keys from checkpoint pickle streams when loading with weights_only=True, allowing crafted state dictionaries to silently change object types or inject arbitrary attributes without error or warning, leading to subtle downstream failures.
  • issues/195607

• Performance Regression in aarch64 CPU GEMM: The 256×256 matrix multiplication with transposed B input on aarch64 CPU is approximately 25 times slower than expected, despite other GEMM operations showing improved speeds, raising concerns about a possible regression.
  • issues/195629

• torch.compile Skips Storage-Bounds Check in as_strided: torch.compile skips the storage-bounds check in torch.as_strided, causing out-of-bounds memory reads and non-reproducible incorrect tensor outputs, whereas eager mode correctly raises runtime errors for invalid views.
  • issues/195665

• ROCm 7.14 Import Errors Due to rocSHMEM libnuma Mismatch: Importing PyTorch built with ROCm 7.14 triggers repeated error messages from rocSHMEM about failing to open "libnuma" due to a vendored library soname mismatch, causing noisy but harmless logs on interpreter start.
  • issues/195670

• torch.rand_like and Boolean Subtraction Accepted Under torch.compile: torch.rand_like on integer tensors is rejected in eager mode but incorrectly accepted under torch.compile, returning all-zero tensors silently. Similarly, subtraction involving boolean tensors is rejected in eager mode but accepted and evaluated numerically under torch.compile, causing silent behavioral changes.
  • issues/195673, issues/195674

• torch.clamp Bound Errors Silently Ignored Under torch.compile: torch.clamp with bounds unrepresentable in the tensor's dtype raises errors in eager mode but silently ignores the issue under torch.compile, leading to inconsistent behavior between execution paths.
  • issues/195675

• MPS Backend max_unpool Operators Lack Input Validation: The max_unpool3d and max_unpool2d operators on MPS do not validate input types properly, returning empty tensors silently instead of raising errors as on CPU.
  • issues/195849

• torch.cumsum CPU Converts -0.0 to +0.0 Incorrectly: On CPU, torch.cumsum converts IEEE-754 negative zero inputs to positive zero, unlike CUDA and NumPy which preserve the sign, causing semantic inconsistencies.
  • issues/195851

• Multiple Disabled Tests on XPU Platforms: Several tests including test_regional_codegen_only_config_cpp_wrapper_xpu, test_regional_fallback_by_default_invoke_subgraph_xpu, test_no_xpu_device_query_on_inductor_import, and test_benchmark_combo_kernel_emits_real_num_gb are disabled due to failures on XPU platforms, indicating platform-specific issues needing investigation.
  • issues/195875, issues/195876, issues/195878, issues/195976

• Asset Path Resolution Issues in Editable Installs: Asset lookups derived from __file__ break under scikit-build-core editable installs due to separation of Python source files and CMake-installed assets, causing path resolution failures. Multiple issues address fixing path resolutions in torch/_inductor and related test cases to correctly reference installed Torch distributions rather than source checkouts.
  • issues/195887, issues/195888, issues/195889, issues/195890, issues/195891

• PyTorch Dynamo Compiler Gaps and Bugs: A meta-issue tracks numerous correctness bugs, unsupported builtins, object model limitations, and internal crashes in PyTorch Dynamo identified via the CPython test suite, highlighting the need for improvements in compatibility and correctness.
  • issues/195901

• Inductor Backend Fusion Assertion Crash: The Inductor C++ backend crashes with an assertion error during fusion of two pointwise nodes with equal element counts but differing dimensionalities due to a stale cache in the fused scheduler node.
  • issues/195963

• Unified IPC Reduction Framework Proposal: A proposal to create a unified, extensible IPC reduction framework in torch.multiprocessing.reductions with backend-agnostic registration APIs and device-agnostic IPC storage methods to support multiple accelerator backends without modifying PyTorch source.
  • issues/195964

• torch.while_loop Validation Bypass and Mutation Bugs: torch.while_loop allows carried-input mutations combined with captured tensor mutations due to auto-functionalization in Inductor, causing inconsistent behavior and failures in Python and C++ wrappers. Also, the condition function is not properly evaluated once when returning constant False, dropping mutations to captured tensors.
  • issues/195966, issues/195970

• TorchInductor SDPA Fusion Pattern Matching Bugs: TorchInductor fusion fails to recognize commuted addition of attention mask and scores, missing fusion when operands are reversed. Also, fusion patterns fail to handle mixed-precision cases where Q/K/V tensors are FP16 but attention mask is FP32, causing missed fusion.
  • issues/195782, issues/195784

• nn.LSTM PackedSequence Input Validation Missing: The nn.LSTM module lacks argument validation for PackedSequence inputs, leading to misleading error messages when hidden-state shapes are incorrect, unlike the clear validation for dense inputs.
  • issues/195803

• ROCm torch.compile as_strided Negative Offset Bug: On ROCm, torch.compile produces incorrect values for torch.as_strided with negative rebased storage offsets due to Triton kernel reading zeros from negative pointer offsets, causing output mismatches compared to CUDA.
  • issues/195823

• CUDA Context Teardown Exception Masking: The destructor AllocationRef::~AllocationRef() throws exceptions during CUDA context teardown when the context is broken, causing std::terminate() and masking original errors with opaque CUDA driver errors, complicating debugging of distributed training failures.
  • issues/195824

• DLPack Stream Information Dropped on Non-CUDA Devices: torch.utils.dlpack.from_dlpack() does not pass the consumer's current stream to DLPack producers for non-CUDA/ROCm devices like XPU, silently dropping stream information and causing potential inconsistencies in stream handling.
  • issues/195825

• linear_cross_entropy Fast Path Incorrectly Gated on is_cuda: The fast path in torch.nn.functional.linear_cross_entropy is gated solely on is_cuda, preventing other backends like XPU from using optimized implementations due to conflated capability checks, requiring split gating for broader backend support.
  • issues/195832

• torch.compile fullgraph=True dataclasses.replace Tracing Regression: A regression causes torch.compile(fullgraph=True) to fail tracing dataclasses.replace for sourceless instances due to changes in __class__ source provenance handling, breaking tracing unless a config flag is enabled.
  • issues/195838

• Inductor Mix-Order Reduction xmask Ignored Bug: The split column sum operation in Inductor's mix-order reduction ignores the xmask, causing wrong results when rows are not multiples of XBLOCK due to unmasked padded rows contributing erroneous values.
  • issues/195845

• torch.compile Skips Storage-Bounds Check in as_strided: torch.compile skips storage-bounds checks in torch.as_strided, causing out-of-bounds memory reads and incorrect outputs, unlike eager mode which raises errors.
  • issues/195665

• TorchInductor Backend Bugs with BatchNorm and F.pad: Models with BatchNorm2d followed by shrinking F.pad produce silently incorrect and non-reproducible outputs during compilation, indicating uninitialized memory reads, while eager execution remains correct.
  • issues/195582

• TorchInductor SDPA Fusion Pattern Matching Bugs: Fusion of masked scaled dot-product attention patterns fails to recognize commuted addition of attention mask and scores, missing fusion when operands are reversed.
  • issues/195782

• TorchInductor SDPA Fusion Mixed-Precision Pattern Registration Missing: Patterns fail to handle mixed-precision cases where Q/K/V tensors are FP16 but attention mask is FP32, causing missed fusion due to missing FP32 mask registrations.
  • issues/195784

• torch.compile Bugs with User-Defined Python Objects: torch.compile fails to handle user-defined Python objects implementing __index__ as tensor slice indices, causing TypeErrors during compilation despite working in eager mode. It also produces incorrect results when control flow depends on identity comparisons involving mutable attributes, losing mutations silently.
  • issues/196172, issues/196173

• torch.compile Bugs with Iterator Methods: torch.compile produces incorrect results when calling iter() on partially consumed reversed iterators and fails to trace the iter() method on list_reverseiterator objects, causing compilation errors.
  • issues/196211, issues/196212

• Sparse CSR Tensor Reduction Produces Invalid Outputs: _sparse_csr_sum and _sparse_csr_prod produce invalid sparse CSR tensors with scalar values instead of 1-D empty tensors when fully reducing 2-D empty CSR tensors, causing validation failures and errors in downstream operations.
  • issues/196214

• torch.compile(fullgraph=True) Fails to Return Python Scalars: torch.compile(fullgraph=True) fails to capture and return valid Python scalars from Tensor.storage_offset(), resulting in unsupported operation errors because non-Tensor outputs cannot be traced into the FX graph output.
  • issues/196215

• TorchDynamo Fails to Trace Three-Argument pow(): TorchDynamo fails to trace the three-argument form of Python's builtin pow() when used with user-defined objects implementing __pow__, causing unsupported operator errors instead of dispatching correctly.
  • issues/196219

• torch.compile Crash with torch.func.grad and torch.masked_select: An internal FakeTensor assertion error causes torch.compile to crash when using torch.func.grad combined with torch.masked_select, indicating problematic interaction between higher-order differentiation, dynamic output shapes, and symbolic tensor handling.
  • issues/196221

• Inductor CUDA Crash on _native_multi_head_attention Operator: The Inductor compiler crashes on CUDA when compiling _native_multi_head_attention with need_weights=False due to an assert_alignment check on a suppressed second output that is not a tensor, causing a TypeError.
  • issues/196226

• torch.compile with DDP and Stochastic-Depth Blocks Crash: Using torch.compile with DistributedDataParallel on models containing stochastic-depth blocks causes crashes due to FakifiedOutWrapper failing with an AttributeError related to float partition outputs lacking a meta attribute during compilation.
  • issues/196227

2.4 Closed Issues

This section lists, groups, and then summarizes issues that were closed within the last week in the repository. This section also links the associated pull requests if applicable.

Issues Closed This Week: 123

Summarized Issues:

• Segmentation Faults Due to Missing Shape or Size Checks: Multiple issues report segmentation faults triggered by missing shape or size validation in various PyTorch functions, leading to out-of-bounds tensor access and crashes. These faults occur across a wide range of operations including pooling, LSTM, SVD, embedding, convolution, and padding functions, often caused by edge case inputs with zero or extremely large dimensions.
  • issues/88036, issues/94590, issues/94593, issues/94594, issues/94668, issues/94669, issues/94696, issues/94698, issues/94808, issues/96275, issues/96276, issues/96277, issues/97087, issues/97088, issues/98136, issues/128691, issues/128693, issues/128694, issues/140945, issues/141203, issues/141449, issues/141450, issues/141481, issues/142209, issues/142454, issues/142459, issues/142837, issues/142838, issues/143480, issues/143481, issues/143482, issues/143483, issues/143487, issues/143490, issues/145064, issues/145071, issues/145267, issues/145604, issues/146788, issues/146789, issues/146790, issues/146793, issues/146794, issues/140945, issues/143484, issues/143485

• Memory Corruption and Heap Overflow Bugs: Several issues describe memory corruption, heap overflow, and invalid free errors triggered by edge case inputs or invalid parameters in internal PyTorch functions such as LSTM, batch dimension removal, and fused moving average fake quantization. These bugs cause segmentation faults or corrupted size errors during execution.
  • issues/94593, issues/94808, issues/128691, issues/128693, issues/128694, issues/143485

• Sparse Tensor Operation Limitations and Crashes: Issues report errors and segmentation faults when performing operations on sparse tensors, including matrix multiplication and copying, due to unimplemented methods and invalid metadata. These limitations cause inconsistent behavior and crashes when using sparse tensor APIs.
  • issues/88053, issues/145604

• Build and Compilation Failures: Some issues describe build errors caused by missing modules or incompatible compiler flags, such as missing _ctypes module on Python 3.8.12, and failures compiling libtorch on Windows with Intel oneAPI compiler due to missing SSSE3 features.
  • issues/74421, issues/122592, issues/194874

• Anomaly Detection and Debugging Features: One issue reports the absence of anomaly detection functionality in the C++ frontend of PyTorch, which was needed for debugging in-place operation errors during gradient computation, and was later resolved by adding an equivalent feature in the C++ API.
  • issues/35872

• Memory Leaks on Linux with LSTM Modules: An issue describes a memory leak occurring on Linux systems when instantiating or training LSTM modules in certain PyTorch versions, where memory is allocated but never released until process termination, with potential causes related to MKL, OpenMP, threading, and glibc memory allocation behavior.
  • issues/41486

• Incorrect Distribution Support Checks: An issue reports that computing the log probability of zero from the half normal distribution in float32 precision incorrectly throws an error in PyTorch 1.8 due to a strict support condition, whereas version 1.7 returned a valid log probability, suggesting the support condition should be inclusive of zero.
  • issues/54394

• Floating Point Exception Crashes in Attention Kernels: Issues describe floating point exception crashes in scaled dot product attention functions when processing zero-sized or empty tensor inputs, caused by missing validation checks leading to division errors in CPU flash attention kernels.
  • issues/141218, issues/141219

• Performance and Compilation Optimization Issues: Some issues discuss performance bottlenecks such as slow CPU vector ISA picking due to multiple PyTorch imports in subprocesses, suboptimal kernel generation for bfloat16 to nvfp4 casting, and opportunities for kernel fusion to improve speed.
  • issues/140970, issues/167098

• Dynamo and TorchCompile Bugs and Limitations: Several issues report bugs in PyTorch's Dynamo compiler and torch.compile, including silent incorrect results from in-place operations after graph breaks, dropped inference mode effects, stale tensor values due to missed in-place mutations, and incorrect index computations in fused kernels.
  • issues/137068, issues/185382, issues/195418, issues/195422, issues/193661

• MPS Backend Regressions and Bugs: Issues report regressions and bugs on the Apple MPS backend, including failures in SVD and least squares functions for large inputs, non-deterministic behavior in embedding backward, and incorrect attention masking in scaled dot product attention with causal masking in float16 and bfloat16.
  • issues/195404, issues/195910, issues/195937, issues/196112, issues/196113, issues/195822

• Memory Safety and Heap Buffer Overflow Bugs in CPU Operators: Multiple issues describe memory safety bugs in CPU implementations of backward operators such as _log_softmax_backward_data, _adaptive_avg_pool3d_backward, nll_loss2d_backward, _adaptive_avg_pool2d_backward, _weight_norm, and unfold_backward, where missing input validation leads to out-of-bounds reads or writes and heap-buffer-overflow errors.
  • issues/194799, issues/194800, issues/194802, issues/194803, issues/194805, issues/194807

• Incorrect or Missing Input Validation Causing Crashes: Several issues highlight crashes caused by missing or insufficient input validation, such as invalid padding in replication_pad1d and replication_pad2d, invalid weight tensor sizes in gru_cell, and invalid parameters in mkldnn_rnn_layer causing double free or corruption errors.
  • issues/143484, issues/143487, issues/143490, issues/143485

• Segmentation Faults from Large or Invalid Storage Offsets: Issues report segmentation faults and illegal memory access errors caused by extremely large storage_offset values passed to as_strided and as_strided_copy functions, leading to out-of-bounds tensor access.
  • issues/145071, issues/146793, issues/146794

• Warnings and Errors in Graph Compilation and Tracing: Some issues describe warnings and errors during graph compilation and tracing, such as graph breaks caused by unsupported builtin Python functions like time.time, and non-actionable error messages when output types are not pytree-able, indicating a need for clearer guidance and registration APIs.
  • issues/137068, issues/140615

• Security Vulnerability in Socket Path Handling: One issue reports a stack-based buffer overflow vulnerability in the Unix socket path copying code due to unbounded strcpy usage without length checks, which can lead to overflow when paths exceed 107 characters, suggesting replacement with bounded copy functions.
  • issues/195182

• Test Failures and Disabling on ROCm and XPU Platforms: Multiple issues report disabling of tests due to consistent failures on ROCm and XPU platforms, including tests related to nested tensor subclasses, combo kernel dynamic shapes, and RMSNorm kernels, indicating ongoing platform-specific stability challenges.
  • issues/168784, issues/168791, issues/180017, issues/180023, issues/185616, issues/191000, issues/191078, issues/194147, issues/194155, issues/194562, issues/195071, issues/195008

• Incorrect Gradient and Numerical Behavior: Issues report incorrect gradient computations such as non-translation-invariant gradients for softmax and cross-entropy in float64 precision, and a regression causing ZeroDivisionError in integer modulo operations due to vectorization bugs in CPU Inductor backend.
  • issues/191968, issues/195531

• Documentation and Annotation Issues: Some issues highlight documentation problems such as invalid comment syntax in examples and missing documentation for functions like torch.Tensor.masked_fill, as well as the need to update type annotations for parameters in PyTorch classes.
  • issues/165277, issues/190202, issues/195908

• Miscellaneous Bugs and Feature Requests: Other issues include bugs like silent incorrect results from frexp on CUDA for subnormal floats, delayed tensor release due to references in torch.compile frames, and requests for platform-independent C++ Generator APIs and reopening closed pull requests.
  • issues/169371, issues/192226, issues/195007, issues/195866, issues/196218

2.5 Issue Discussion Insights

This section will analyze the tone and sentiment of discussions within this project's open and closed issues that occurred within the past week. It aims to identify potentially heated exchanges and to maintain a constructive project environment.

Based on our analysis, there are no instances of toxic discussions in the project's open or closed issues from the past week.

III. Pull Requests

3.1 Open Pull Requests

This section provides a summary of pull requests that were opened in the repository over the past week. The top three pull requests with the highest number of commits are highlighted as 'key' pull requests. Other pull requests are grouped based on similar characteristics for easier analysis. Up to 25 pull requests are displayed in this section, while any remaining pull requests beyond this limit are omitted for brevity.

Pull Requests Opened This Week: 415

Key Open Pull Requests

1. PlateauLR, a composable version of ReduceLROnPlateau (and extensible LRSchedule step API to support it): This pull request introduces PlateauLR, a composable and extensible learning rate scheduler designed as a replacement for ReduceLROnPlateau that integrates with the standard LRScheduler lifecycle, supports metric-based stepping, enables composition with other schedulers, deprecates the old scheduler with migration guidance, and updates documentation and tests accordingly.

• URL: pull/195634

• Associated Commits: 9d9e5, 96c81, 182b1, e7a1a, 157c1, 748c6, a3e76, 0e607, b647a, 8f818, adca6, 3baa6, 548a0, 15aef, c2790, eaf9d, f32dd, b5aae, 1b618, e6cbe, dcd37, 727a8, 8a2cb, 0eae7, edda5, 2672f, 5c51f, e9931, c814c, 481b8, 15435, 7ef61, 3a1f6, 3bf1f, 92ca7

2. grid_sample: support pixel-coordinate grids: This pull request introduces an opt-in pixel-coordinate sampling mode to F.grid_sample in PyTorch, enabling the grid to hold continuous pixel indices instead of normalized coordinates, which allows exact bitwise reproduction of input at integer locations, supports double-precision grids for higher coordinate accuracy, generalizes bicubic interpolation with a customizable Keys coefficient, and implements these features via new private CPU and CUDA operators with comprehensive testing and benchmarking while maintaining backward compatibility and leaving the default normalized behavior unchanged.

• URL: pull/195497

• Associated Commits: 11c5e, 3dffd, d39e6, 26b9a, 33d76, 44bb4, 06310, 59d72, 8051d, 5a4b8, 879d8, 50aa7, f5c55, 6362e, 6162f, 0e82e, dd14c, 49766, 15ee9, a07c6, e472a, c38e5, e6c71, 26ca2, de03d, 0bbc8, 43dd8, a35a3, 61346, 8dac5

3. [precompile] Settle the public docs on the capture/save/load surface: This pull request settles and clarifies the public documentation and API surface of the torch.compiler precompile module by defining two main caller-driven entry points—precompile.capture as a context manager for capturing and saving artifacts, and precompile.load for reloading them—while removing outdated conventions and types such as ExampleInput, and updating the API reference, user guide, and module comments accordingly.

• URL: pull/195929

• Associated Commits: 9bcec, 35e7b, 0f462, f3369, ba5e2, 00fc8, 523e4, 10dd3, fde2a, 3ee3a, 42e2d, 694ab, e12a9, 4ff60, 8276d, f168a, bd252, 863b0, 3d25b, f18b2, 504dd, 8b4fb, 6f406, 6e3c5, 957c4, a871c

Other Open Pull Requests

• Precompile session and multi-graph capture enhancements: Multiple pull requests introduce and improve the PrecompileSession for managing multi-graph capture and compilation in PyTorch. These include adding public capture entry points, session save functionality, guard-state pickling fixes, and detailed guard-drop accounting to ensure safe, complete, and efficient compilation workflows.
• pull/195924, pull/195919, pull/195928

• Guard management and serialization improvements: Several pull requests focus on refining guard handling by implementing guard-drop policies, pruning unreachable guard state during pickling, re-serializing guards after dropping non-discriminating invariants, and improving error diagnostics. These changes enhance guard classification, serialization robustness, and correctness in precompilation and capture processes.
• pull/195917, pull/195920, pull/195912

• Artifact installation, ownership, and concurrency management: Pull requests introduce region-owned precompile entry installation, per-install renaming of resume functions, region-scoped ownership tracking, skip-strategy bookkeeping, and concurrency tests for the ExtraState lock. These improvements ensure multiple packages can coexist without interference, manage shared global bindings correctly, and maintain thread-safe cache and state management.
• pull/195911, pull/195915, pull/196120

• Dynamo tracer documentation and API enhancements: One pull request adds detailed documentation for the Dynamo tracer's precompile feature, covering API surfaces, example inputs, tracer selection, multi-variant capture options, loading mechanisms, and prototype warnings. This ensures the API reference renders correctly and improves user understanding without code changes.
• pull/195923

• Blackwell Triton backend and BMM template improvements: Multiple pull requests extend the Blackwell persistent TMA BMM template with support for 2CTA execution, bounded autotuning for rank-3 batch matrix multiplication, and MetaWS scheduling with data partitioning and separate epilogue stores. These enhancements optimize backend performance and autotuning capabilities in the Inductor component.
• pull/195776, pull/195775, pull/195773, pull/195774

• Capture and serve mode refactoring in CompilePackage: A pull request introduces explicit capture and serve modes, refactors guard serialization and caching behavior, and improves guard management and recompile tracking. This refactoring clarifies strict filtered captures versus ambient caching and fixes related package issues exposed by the new capture path.
• pull/195913

• Inlined code object naming and source capture fixes: One pull request fixes source checksum mismatches by associating inlined code objects with their actual defining files instead of relying on potentially incorrect module names. This ensures accurate source capture for dynamically inlined code in the Dynamo package.
• pull/195914

• Eager graph serialization improvements: A pull request implements carrying a Dynamo eager graph as a generated source within the eager backend artifact serialization process to avoid lossy round trips during pickling. It introduces new classes to preserve graph state without re-tracing and enhances deep copying and artifact management.
• pull/195916

• Escape analysis refinement for event recording: One pull request refines Dynamo's escape analysis by deferring error checks for trace-created events until confirmed to escape the compiled region, eliminating false positives. It also enhances detection logic for events stored in sets, dict keys, and generator finally blocks, supported by new tests.
• pull/195573

• SessionState synchronization simplification: A pull request simplifies synchronization in the SessionState component by removing unnecessary atomic classes and redundant condition variables, leveraging C++20 atomic wait/notify features to improve clarity and efficiency.
• pull/195642

• XPU manywheel packaging workflow finalization: One pull request consolidates all XPU wheel builds into a single runner reusing backend components across Python versions, aligning with CPU/CUDA packaging models and improving build, test, and upload stability and optimization.
• pull/195699

• FP8 blockwise scale and precision fixes in Inductor: A pull request fixes FP8 blockwise scale layout, indexing, and dot precision by correcting cuBLAS layouts, adjusting scale indexing and broadcast order, and improving precision selection with comprehensive tests validating these changes.
• pull/195751

• Test organization and codebase fixes: Pull requests separate cuDNN-specific variable-length attention tests into a CUDA-only class for clarity and fix unbounded calls to builtin types in the PyTorch codebase, addressing a specific issue.
• pull/195717, pull/195727

3.2 Closed Pull Requests

This section provides a summary of pull requests that were closed in the repository over the past week. The top three pull requests with the highest number of commits are highlighted as 'key' pull requests. Other pull requests are grouped based on similar characteristics for easier analysis. Up to 25 pull requests are displayed in this section, while any remaining pull requests beyond this limit are omitted for brevity.

Pull Requests Closed This Week: 550

Key Closed Pull Requests

1. Fix incomplete device-type allowlists in profiler memory/kernel accounting: This pull request fixes incomplete and inconsistent device-type allowlists in the PyTorch profiler's memory and kernel accounting by replacing two manually maintained lists with a single derived classification that treats all non-host device types (including CUDA, HIP, XPU, MTIA, HPU, PrivateUse1, and future backends) as device work, ensuring accurate memory allocation reporting and kernel-to-parent-event association for all supported device types, and adds a regression test verifying correct host/device classification.

• URL: pull/195821

• Associated Commits: 8c5b4, 2a21a, 8f3c4, 2cc3d, c1c66, 0e1e1, f3478, 00fcf, dc43e, 78630, 9db30, 8091a, 7784a, 08eb9, 1d657, 5132f, 9d703, 53cbf, 0f1f0, ee906, 5c808, 918bd, 46cb1, 9e79e, b0667, 419b5, 51583, 9e94b, 57db6, 0a2eb, 65d92, 7f8b8, e242e, 1ddbc, 4a34a, a19e7, dd3c8, 16b40, 869f8, 31202, e1ee6, 0ddc9, 2ab95, 4d7f4, 49c1a, b87b1, fc140, 87458, 90396, 4ba51, 9043a, 75bcc, c3274, 3ab51, 149cb, 347b1, e0e26, 4d94f, f6aeb, 66103, bb660, d51f5, dc28c, cfa9d, 38f39, 70133, 51b32, 5b429, 1b7f2, 06ad0, d7dd5, c5cf9, a330d, e0ec9, b02e0, 7853d, 25157, acb88, 05f7a, 45685, 44984, 8710e, 7ba38, f3c94, acbfa, 51d63, c52a9, 4adb0, 3e806, 6c5da, 9d25a, f65a9, 4e9a7, 7bc90, a8659, 1eafa, e137a, fbf96, cd08d, 4b2ed, a64ba, 2ad3e, fdbd4, 4434c, 88d69, d2f58, 9edde, c1918, fd2fa, b9f67, 33540, eb086, e38ba, c7141, 74dda, 5ed9a, 49939, 57cd9, 97863, be125, 30096, 72310, 08baf, 91ea8, 11a8d, 34cdb, c30c2, a8277, a947d, 396b4, 13c25, 43d6f, 25ecf, 529dd, f7de3, 85a04, 12979, 98de4, 65a0b, f0b07

2. [dynamo] Support constant ops on unrealized LazyConstantVariables: This pull request proposes adding support for constant operations on unrealized LazyConstantVariables within the Dynamo component of the PyTorch project.

• URL: pull/170092

• Associated Commits: fb7d2, 095be, 3aae4, bbd3c, f2fbe, 034e4, 199d8, b035b, 7d59d, 776f2, 91dbc, cbc1e, 3ffe3, 84113, 698b2, 0f0a1, cf60c, 9bbb6, 16cfb, 9734a, 7c39c, 12848, 346c5, 90566, e383e, d936a, 5e814, e7f2f, e11af, dabec, 0e8b2, fefb8, efaa8, a69dd, 1cd25, 2352e, 6f53e, ab7ef, d107e, 49cfb, ee903, b9c53, 69636, ad398, d331c, 21bb6, 64365, c1548, 7b729, 3d7a5, 2c425, d26ad, 26541, 31227, 888c4, 475ea, d3f23, af37f, aa138, a64c3, 72b3e, efb9e, 45373, 36558, 2711b, d84d0, 00069, 66ff9, 0778d, b4d6c, d3188, 100dc, f23b3, f2b04, 28a00, 6da9e, a13bc, fe0ac, 984e0, d8233, e82ff, 39611, 52ebe, a7c27, d4b47, fdda7, e7d96, 763a8, 38c73, 28d7e, 0945f, 5870d, 01d6f, 7b3b0, f4662, a8b4a, 48d5d, b79e0, 8bd99, fb01e, ec21b, cc483, 805b5, 524a1, 0ba89, 9ea5a, 8fa65

3. [dynamo] Support dict assignment with lazy constant keys: This pull request proposes adding support in the Dynamo component of PyTorch for dictionary assignment operations where the keys are lazy constant expressions, aiming to enhance how such assignments are handled during just-in-time compilation or graph tracing.

• URL: pull/170644

• Associated Commits: 545c0, fc43b, 55225, bea62, db4af, a3380, 8176e, 53dc1, 9a70f, 41650, 31b76, 9ffb2, 27eb4, d4884, 433c1, d4bb8, 0e0c9, 4d287, 3884f, 2b735, 17bc7, a7d76, d2520, e80e9, 27403, 715c3, 1fd1c, e69a4, ef526, 3afd7, 9d045, 97df7, 47949, 8db20, 2b1f6, 311de, a397b, a4a38, f6b58, 8810d, cd02b, 6fac7, b5ee1, 46d51, 8d26a, 92823, 8e6e9, 8fbf7, 8c7d0, 4e9e0, 95ec8, cbb35, 8dbd4, 1c1a5, ff7df, a2bae, 20beb, 1a1f5, 68445, 189c1, a63a6, befe6, f9900, 90d83, 7a81a, e574f, 9bbc0, f7bad, 049ea, dd91f, 648f1, 22994, 375f2, fabf7, 9c42d, eebaa, 92289, a1ae4, a39f7, 48090, afed6, f73b5, 1341b, df1fb, c37e7, 3b54f, 697ed, e1c8e, 7ba94, f703f, 38db5, 7967e, 237bd, fd55c, 4f494, 7e3a8, 3c24b, 9b345, c4b1d, b55d6, 8c279, 425e5, 23694, 789c6

Other Closed Pull Requests

• Build-analysis instrumentation for manywheel CI: Two pull requests add build-analysis instrumentation to the manywheel CI build script to collect telemetry data such as ninja_log.txt and cache statistics from Linux binary manywheel CI runs. These telemetry-only branches aim to diagnose prolonged ROCm nightly build times and are not intended to be merged.
  • pull/185822, pull/185935

• Intel GPU test enablement and distributed shard support: Multiple pull requests enable tests and distributed shard test cases on Intel GPUs by porting tests and enabling the XPU backend, using device-agnostic methods to maintain compatibility. These changes allow key test files and distributed tests to run on Intel GPUs while preserving original code styles.
  • pull/179550, pull/182199

• NCCL backend improvements and warnings: One pull request inverts the default NCCL backend registration to make nccl2 the default while maintaining legacy support, and another adds a warning for pipeline parallelism users about eager NCCL communicators creating unnecessary peer communicators. These changes improve backend selection and user awareness for NCCL usage.
  • pull/192281, pull/193241

• Dynamo concurrency and garbage collection optimizations: Pull requests improve PyTorch Dynamo by adding a recursive mutex to protect the frame cache during concurrent installs and lookups, preventing deadlocks and use-after-free errors, and by deferring full generation 2 garbage collections during compilation to reduce costly heap traversals. These enhancements improve concurrency safety and compile time performance with minor memory trade-offs.
  • pull/193697, pull/193289

• Inductor backend NVGEMM and epilogue enhancements: Several pull requests add support for direct CuTeDSL lowering of dense NVGEMM epilogues, adapt the dense EFC provider to consume shared CuTeDSL epilogue fragments, and provide comprehensive grouped epilogue parity coverage including dense and block-scaled grouped reductions. These updates include source assertion improvements, fallback mechanisms, and extensive testing to ensure correctness and compatibility.
  • pull/191515, pull/191514, pull/190825

• Ahead-Of-Time (AOT) kernel tooling and dispatch: Two pull requests introduce declaration-driven AOT kernel DispatchStubs within structured wrappers and add a kernel-source generator that assembles per-declaration C++ files integrated into the libtorch_cuda library. These changes enable optimized kernel dispatch with runtime checks and conditional build execution as part of the PyTorch build process.
  • pull/190896, pull/190897

• Support for multi-input precompilation and incremental capture in torch.compiler: One pull request generalizes torch.compiler.precompile to accept multiple example inputs and introduces a Dynamo-based capture front-end producing multi-variant artifacts with guarded specializations. It also adds a stateful incremental capture API supporting dynamic dispatch, differentiable graphs, guard minimization, and comprehensive validation.
  • pull/195044

• XPU backend enhancements and caching allocator feature: Pull requests port distributed shard tests to support Intel GPUs by enabling the XPU backend and propose adding the use_oom feature to the XPU caching allocator to align with CUDA behavior for distributed usage. The latter has not been merged.
  • pull/182199, pull/192038

• Function serialization and guard set loading fixes: One pull request addresses errors in loading serialized guard sets caused by function fully qualified name mismatches due to decorators. It reconstructs such functions only when rooted in a guard, preserving necessary attributes and closures to fix AttributeErrors and ensure robust guard evaluation during deserialization.
  • pull/192866

• Blackwell persistent TMA batch matrix multiplication exposure: A pull request exposes the generic rank-3 Blackwell persistent TMA batch matrix multiplication template to the max-autotune feature behind a configuration gate, validating TMA-aligned batch bases before enabling this option.
  • pull/195780

• Test suite renaming and device-agnostic refactoring for GPU/XPU compatibility: Two pull requests rename the TestSDPACudaOnly class to TestSDPAGpuOnly and extend the test suite to run on XPU devices by enabling device test instantiation and porting fused attention gradient tests to the XPU graph capture API. Unsupported test cases are selectively skipped while maintaining CUDA compatibility.
  • pull/185114, pull/185115

• Benchmark harness for CUPTI monitor backend: One pull request proposes adding an in-tree benchmark harness for the experimental CUPTI monitor backend to test multistream mixed workloads and compare always-on raw dumping and profiled window distortion against the stock profiler.
  • pull/186038

3.3 Pull Request Discussion Insights

This section will analyze the tone and sentiment of discussions within this project's open and closed pull requests that occurred within the past week. It aims to identify potentially heated exchanges and to maintain a constructive project environment.

Based on our analysis, there are no instances of toxic discussions in the project's open or closed pull requests from the past week.

IV. Contributors

4.1 Contributors

Active Contributors:

We consider an active contributor in this project to be any contributor who has made at least 1 commit, opened at least 1 issue, created at least 1 pull request, or made more than 2 comments in the last month.

If there are more than 10 active contributors, the list is truncated to the top 10 based on contribution metrics for better clarity.

Access Last Week's Newsletter:

• Link