Weekly GitHub Report for Tensorflow

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.19.0

1.2 Version Information:

Released on March 5, 2025, TensorFlow version 2.19.0 introduces breaking changes to the tf.lite API, including the deprecation of tf.lite.Interpreter in favor of ai_edge_litert.interpreter and changes to certain C++ constants for improved API flexibility. Key updates also include runtime support for the bfloat16 data type in the tfl.Cast operation, alongside the discontinuation of standalone libtensorflow package publishing, with continued availability via PyPI.

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. [TYPE:BUG] [COMP:OPS] [COMP:CORE] [2.21.0] Crash due to CHECK failure in ConjugateTranspose with DT_STRING using TensorFlow C++ API on v2.21.0: This issue reports a crash caused by a fatal CHECK failure when running the ConjugateTranspose operation with a scalar DT_STRING input and an empty permutation using the TensorFlow C++ API version 2.21.0 on Linux Ubuntu 22.04. Instead of gracefully handling this unsupported tensor configuration, the process aborts, and the expected behavior is for TensorFlow to either correctly execute the operation or return a standard error status without terminating the process.

   • The comments discuss what the appropriate error status should be if an error is raised, with consensus leaning towards returning a regular TensorFlow error like InvalidArgument or Unimplemented rather than aborting. The original reporter agrees to try returning a simpler error, and a maintainer acknowledges the issue and commits to providing a fix and root cause analysis.
   • Number of comments this week: 4

2. [TYPE:BUG] [COMP:AUTOGRAPH] [AWAITING PR MERGE] [TF 2.19] Using a tf.Variable as index when writing to a tf.TensorArray yields error in graph mode: This issue describes a bug encountered when using a tf.Variable as an index to write to a tf.TensorArray in graph mode, which results in an OperatorNotAllowedInGraphError due to disallowed Python casts of symbolic tensors within @tf.function. The user seeks clarification on whether this is a user error and how to properly update the index symbolically within the graph, as the current approach works in eager mode but fails in graph mode.

   • The comments confirm the error arises from using Python casts on symbolic tensors and capturing TensorArrays created in eager mode inside traced functions; a recommended solution is to create the TensorArray within the @tf.function and use a 0-D int tensor as the index. Some users report the workaround does not fully resolve their issues, and a fix has been proposed and is awaiting merge, with maintainers encouraging community contributions.
   • Number of comments this week: 3

3. [TYPE:BUG] [COMP:OPS] [AWAITING PR MERGE] [TF 2.19] minlength should be dealt together with maxlength in tf.math.bincount: This issue addresses a bug in the tf.math.bincount function where the parameters minlength and maxlength are handled separately rather than together, which can lead to inconsistent behavior when maxlength is less than minlength. The user provides a reproducible example demonstrating this problem and highlights that the documentation suggests maxlength should be at least minlength, but the current implementation does not enforce this properly.

   • The comments show that a pull request was opened to fix the issue, with maintainers acknowledging the contribution and expressing appreciation. The discussion includes encouragement for community contributions and confirmation that the proposed fix will resolve the problem once merged.
   • Number of comments this week: 3

4. [TYPE:BUG] [AWAITING PR MERGE] [TF 2.19] tf.math.erf returns nan for inf and -inf, inconsistent with PyTorch/SciPy: This issue reports that the TensorFlow function tf.math.erf returns NaN when given positive or negative infinity as input, which is inconsistent with PyTorch, SciPy, and the Python math library that return 1.0 and -1.0 respectively, reflecting the mathematically expected behavior. The user suggests that this discrepancy likely arises from missing explicit handling of infinite inputs in TensorFlow's implementation and requests a fix to correctly return ±1.0 for ±inf inputs.

   • The comments discuss the nature of the bug and confirm the inconsistency with other libraries, express interest in contributing fixes, and note that a pull request addressing the issue has been submitted and is awaiting merge.
   • Number of comments this week: 3

5. [TYPE:DOCS-FEATURE] [AWAITING PR MERGE] Document that tf.io.gfile APIs do not prevent path traversal: This issue requests a documentation update to clearly warn developers that the tf.io.gfile APIs do not prevent path traversal, do not sandbox paths, and follow symbolic links, which can lead to security risks if untrusted paths are used. It emphasizes that applications must validate or canonicalize paths themselves to avoid accidental vulnerabilities, and the current TensorFlow documentation lacks these important security warnings.

   • The comments show a user volunteering to improve the documentation by adding explicit warnings in the API docstrings, with a related pull request opened but initially closed as stale; maintainers encouraged community contributions and acknowledged a new PR addressing the issue, expressing appreciation for the efforts to resolve it.
   • Number of comments this week: 3

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: 22

Summarized Issues:

• Fatal process aborts due to internal check failures instead of proper exceptions: Several TensorFlow operations such as tf.raw_ops.LookupTableExportV2, tf.raw_ops.TensorScatterUpdate, tf.raw_ops.FusedPadConv2D, tf.nn.conv2d_transpose, and tf.signal.irfft cause the entire process to abort with fatal internal check failures or assertion failures when given malformed inputs, rather than raising appropriate Python-level or framework-level exceptions. This behavior leads to crashes and unstable execution environments instead of manageable error handling.
• [issues/125503, issues/125504, issues/125505, issues/125506, issues/125507]

• Inconsistent error handling between CPU and GPU devices: Functions like tf.keras.layers.MaxPool1D, tf.nn.atrous_conv2d, and tf.nn.conv2d_transpose exhibit inconsistent behavior across CPU and GPU, where invalid inputs cause process aborts or fatal check failures on CPU but raise proper exceptions on GPU. This inconsistency highlights the need for uniform input validation and error reporting across different device implementations.
• [issues/125509, issues/125510, issues/125511]

• Inconsistent behavior and silent failures in graph tracing, eager execution, and XLA compilation: TensorFlow operations such as tf.SparseTensor indexing, tf.while_loop tuple indexing, tf.slice with out-of-bounds sizes, and tf.broadcast_to with invalid shapes show inconsistent behavior depending on execution mode. Some modes silently succeed or cast types without error, while others raise exceptions or produce incorrect results, indicating bugs in input validation and constant folding during graph tracing and compilation.
• [issues/125537, issues/125538, issues/125544, issues/125545]

• Segmentation faults and crashes due to unsupported or malformed inputs: The tf.linalg.LinearOperatorLowRankUpdate causes segmentation faults during gradient computation when upstream gradients count mismatches occur, and the ConjugateTranspose operation crashes with a fatal CHECK failure when given scalar DT_STRING inputs with empty permutations. These issues cause process aborts instead of graceful error handling.
• [issues/125502, issues/125665]

• Bugs related to XLA compilation and kernel registration: The tf.linalg.det function fails to run with jit_compile=True due to missing XLA kernel registration for the MatrixDeterminant operation, preventing successful graph compilation on CPU with XLA JIT.
• [issues/125536]

• Inconsistent numerical results and overflow issues in CPU implementations: The CPU implementation of tf.nn.max_pool2d produces inconsistent outputs when processing NaN-containing float64 channels together versus separately, indicating inconsistent NaN handling. Additionally, tf.reduce_mean on int32 and uint32 tensors under tf.function(jit_compile=True) produces incorrect negative means due to overflow in internal sums, differing from eager execution results.
• [issues/125965, issues/125978]

• Build and configuration issues affecting TensorFlow compilation and runtime: Cross-compilation of TensorFlow Lite 2.21.0 for ARM64 fails due to mismatched function declarations and undefined types in xnnpack delegate source files. The TensorFlow configure script also fails to detect Clang version when using ccache, causing an AttributeError. Furthermore, TensorFlow 2.20+ breaks hwloc PCI device discovery for NCCL network plugins on GPU instances due to symbol visibility conflicts in the bundled hwloc library.
• [issues/125854, issues/125892, issues/125939]

• Inconsistent results or failures with autoclustering and XLA auto JIT: The tf.while_loop function returns consistent results in eager and jit_compile=True modes but produces empty arrays when using autoclustering with TF_XLA_FLAGS=--tf_xla_auto_jit=2, indicating a bug in the autoclustering execution path.
• [issues/125686]

• Unspecified bug in TensorFlow artificial neural network functionality: A bug related to TensorFlow's artificial neural network features is confirmed reproducible with TensorFlow Nightly, but lacks detailed environment information, limiting diagnosis.
• [issues/125755]

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: 44

Summarized Issues:

• JavaScript Integration and Runtime Support: There is a proposal to add a js_func feature to TensorFlow to define computation nodes using JavaScript, similar to py_func for Python, aimed at supporting environments like iOS and Android that have JavaScript runtimes but lack Python runtimes. This feature would enable broader platform compatibility by leveraging existing JavaScript engines.
• issues/18280

• Embedding and Gradient Computation Issues: Multiple issues describe problems with gradient computation and embedding layers in TensorFlow. Gradients cannot be computed for Keras embedding layers using gradient-based methods like SHAP, and applying gradients to slices of variables results in NotImplementedError, limiting training capabilities involving embeddings and sliced variables.
• issues/22059, issues/75351

• Autograph and Package Management: There is a proposal to move the Autograph component into a separate package and repository to facilitate easier maintenance and potential support for other computation graph frameworks, aiming to modularize TensorFlow components for better development workflows.
• issues/23601

• Global Default Data Type Configuration: A feature request suggests introducing global methods like tf.set_default_float and tf.set_default_int in TensorFlow 2.0 to allow users to change default data types globally, reducing the complexity of repeatedly specifying data types, especially for algorithms requiring higher precision such as Cholesky decompositions and solvers.
• issues/26033

• CPU Support and Performance Parity: TensorFlow currently lacks CPU support for dilation rates larger than 1 in convolution operations, causing training failures on CPU due to missing support in libxsmm and custom kernels. This limits parity with GPU training and affects performance and functionality on CPU devices.
• issues/28264

• Threading and Parallelism Limitations: Setting limits on inter- and intra-op parallelism threads does not prevent the creation of many more threads than specified, leading to excessive context switches and delayed execution despite only the limited number of threads actually running, which impacts performance and resource management.
• issues/29968

• File Handling and Error Behavior: Attempting to read from a nonexistent file opened in w+ mode using tf.gfile.GFile raises a NotFoundError instead of returning an empty string, causing crashes in workflows like numpy.savez() that expect the latter behavior, indicating inconsistent file I/O error handling.
• issues/32090

• Data Batching and Shape Inference Bugs: The function tf.data.experimental.dense_to_ragged_batch fails with inputs from generators that have unspecified shapes, causing errors when batching tensors of different shapes unless the output shape is explicitly specified, which complicates data pipeline construction.
• issues/42349

• CUDA and GPU Compilation Errors: Setting groups greater than 1 in tf.keras.layers.Conv2D on WSL Ubuntu triggers errors due to missing libdevice directories, causing compilation failures and runtime errors not present in earlier TensorFlow versions, indicating environment-specific GPU build issues.
• issues/56927

• Gradient Computation Failures in XLA Mode: Computing gradients for tf.vectorized_map nested inside a tf.while_loop works in eager and graph modes but fails in XLA mode due to shape arguments not being compile-time constants, causing InvalidArgumentErrors during XLA compilation and limiting XLA compatibility.
• issues/73367

• Distributed Communication Limitations: TensorFlow's tf.distribute strategy lacks an MPI AlltoAll communication primitive on CPU/GPU devices, with the existing AlltoAll operation only available for TPUs, limiting distributed training capabilities on non-TPU hardware.
• issues/77367

• Numerical Function Inconsistencies: TensorFlow's special Bessel functions and tf.math.log1p produce inconsistent or incorrect results compared to SciPy and NumPy when given negative infinity or complex inputs with infinite values, resulting in infinite or NaN outputs instead of expected NaNs or complex values, indicating numerical stability issues.
• issues/77864, issues/80850

• Profiler and Visualization Bugs: The TensorBoard Profiler Trace Viewer displays some thread IDs as negative numbers on Linux Mint 21.2 with TensorFlow Nightly and Python 3.11, indicating a bug in thread ID reporting that may affect profiling accuracy.
• issues/79128

• Import Path and Build Configuration Issues: The import path generated by mypy-protobuf for TensorFlow's .proto files incorrectly references xla.tsl.protobuf.histogram_pb2 instead of tensorflow.tsl.protobuf.histogram_pb2, causing confusion about configuration and whether manual fixes are needed.
• issues/86752

• Memory Management and Resource Leaks: Rank 0 tensors persist in GPU memory and cannot be freed even after deletion, garbage collection, or clearing the Keras session, leading to unreleased memory on Ubuntu 22.04 with CUDA 12.4, which can cause memory bloat and resource exhaustion.
• issues/92103

• Inconsistent Behavior Across Devices: The function tf.sparse.segment_mean behaves inconsistently between CPU and GPU, producing different error messages related to num_segments despite valid segment_ids, indicating device-specific validation bugs.
• issues/93159

• Silent Failures and Input Validation: Passing an invalid class_weight dictionary with non-integer keys to model.fit() in TensorFlow 2.19.0 does not raise errors or warnings, causing silent failures where class weights are not applied as intended, which can mislead users during training.
• issues/98283

• FFT Operation Discrepancies: The high-level tf.signal.ifft and low-level tf.raw_ops.IFFT produce inconsistent results on large complex128 inputs, with the low-level op returning infinite and NaN values due to numerical instability or missing normalization, causing reliability issues in FFT computations.
• issues/102047

• Memory Safety and Kernel Bugs: Compute-Sanitizer detects illegal out-of-bounds memory reads in the DynamicStitchKernel on TensorFlow 2.20 with CUDA 12.5.1, triggered by large index values, indicating a memory safety bug that can cause crashes or undefined behavior.
• issues/103996

• NaN Propagation and GPU Inconsistencies: The function tf.math.unsorted_segment_max fails to propagate NaN values correctly on GPU, returning minimum float32 values instead, unlike CPU behavior which propagates NaNs properly, leading to inconsistent numerical results across devices.
• issues/106602

• Fatal Process Aborts on Invalid Inputs: TensorFlow operations tf.raw.ops.EncodePng and tf.raw.ops.ResourceGather abort the entire process with internal CHECK failures when given empty image tensors or dtype mismatches, respectively, instead of raising recoverable errors, highlighting critical input validation issues.
• issues/113068, issues/113076

• Function Crashes and Attribute Errors: The function tf.linalg.eigh_tridiagonal crashes with a TypeError inside tf.function when using select='v' without select_range, and tf.gather inconsistently handles out-of-bounds indices between eager and compiled modes, causing unexpected errors or silent incorrect behavior.
• issues/113321, issues/115254

• Dataset and Memory Corruption Bugs: The InterleaveDatasetOp lacks an upper bound check on cycle_length, causing integer overflow and heap out-of-bounds memory access, leading to segmentation faults and potential denial of service when processing malicious datasets.
• issues/116198

• Versioning and Release Information Errors: The TensorFlow Lite version string was not updated to reflect the 2.21.0 release and incorrectly shows 2.19.0 despite new features, causing confusion about the actual version in use.
• issues/116676

• NaN Propagation in XLA and Segment Operations: XLA-compiled tf.image.resize incorrectly propagates NaNs to all pixels in a channel, and segment_min/segment_max produce order-dependent incorrect results with NaNs on CPU eager mode, indicating bugs in NaN handling in both XLA and CPU kernels.
• issues/117803, issues/117862

• XLA Compilation Numerical Errors: Using XLA with jit_compile=True causes tf.nn.moments to return incorrect large non-zero variance for identical inputs, and GPU kernels lack out-of-bounds checks causing silent incorrect results, highlighting numerical and safety issues in compiled modes.
• issues/118179, issues/118196

• GPU XLA Backend Data Corruption: Using tf.unique, tf.boolean_mask, or tf.dynamic_partition with 16-bit data types on GPU XLA backend and jit_compile=True causes output tensors to have inflated lengths with silent corruption due to buffer size or offset calculation errors, affecting data integrity.
• issues/119380

• Grappler Optimization and IEEE 754 Violations: Grappler constant folding replaces multiplication by zero with zero, suppressing NaN results for inputs containing Inf or NaN and violating IEEE 754 standards, causing silent failures in NaN propagation within tf.function.
• issues/119428

• Gradient Computation Crashes on Singular Matrices: Computing gradients of tf.linalg.det crashes with InvalidArgumentError when the input matrix is singular, due to reliance on matrix inverse in the gradient implementation, causing failures in optimization tasks involving singular matrices.
• issues/119477

• Eager vs XLA Execution Discrepancies: The function tf.experimental.numpy.cross runs successfully in eager mode for vectors with last dimension not equal to 3 but fails during XLA compilation, indicating inconsistent validity checks between execution modes.
• issues/122056

• Heap Corruption in Batch MatMul: Eager tf.matmul on CPU with rank-4 left-hand side tensor and broadcasted lower-rank right-hand side causes heap corruption and process aborts due to incorrect stride calculations in oneDNN batch-matmul implementation, despite producing correct numerical results.
• issues/123109

• Numerical Discrepancies in XLA JIT: Chained tf.pow operations on CPU using XLA JIT produce results differing beyond float32 rounding error compared to eager execution, despite exact mathematical representability, indicating precision or implementation differences.
• issues/124746

• Dtype Coercion and Attribute Validation Bugs: Bare Python integer operands cause dtype-mismatch errors under jit_compile=True or autoclustering, and tf.shape incorrectly accepts invalid out_type attributes under compiled modes, while eager execution correctly rejects these, showing inconsistencies in type checking and attribute validation.
• issues/125373, issues/125394

• Result Discrepancies and Execution Mode Bugs: Chaining multiple tf.reduce_sum operations on CPU produces significantly different results under jit_compile=True compared to eager execution, and calling tf.tuple() with repeated variables raises errors in compiled modes but not in eager execution, indicating execution mode inconsistencies.
• issues/125396, issues/125397

• Random Number Generation Errors in Compiled Mode: tf.random.stateless_uniform with int32 dtype and equal minval and maxval silently returns arbitrary values under jit_compile=True instead of raising errors as in eager mode, causing incorrect behavior in scenarios like Keras Conv2D initialization.
• issues/125531

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: 63

Key Open Pull Requests

1. Make checkpoint reader safe for free-threaded Python: This pull request makes the TensorFlow checkpoint reader safe for use in CPython 3.14 free-threaded builds by serializing concurrent access to the native checkpoint reader with a mutex, correctly initializing TensorFlow's shared NumPy C API across translation units, and marking the pybind11 module as GIL-independent to enable thread-safe operations.

• URL: pull/125636

• Associated Commits: 2d59e, 82734, 37686, a5088, d8c6e, ac12f, 472d3, ad6be, cbf93, 48282, bd6fa, 8072d, 785f3

2. Fix: Validate tensor size to prevent OOM DoS: This pull request improves the ReshapeOp in TensorFlow by adding validation for empty and zero-element tensors to prevent out-of-memory denial-of-service crashes, cleaning up file-scope code, and ensuring proper kernel registration across platforms.

• URL: pull/125633

• Associated Commits: 9a78c, 9fdee, b9621, e77b8, d644e, ec030, f7d92, c0a75

3. Make Python API dispatch safe for free-threaded Python: This pull request makes TensorFlow's Python API dispatcher and function-parameter canonicalizer safe for CPython free-threaded builds by synchronizing mutable dispatcher state, ensuring safe ownership and lifetime of Python objects across concurrent operations, making dispatchable-type registration and instance-checker caching thread-safe, updating Python C API state checks for free-threaded contexts, and declaring the dispatcher pybind11 module as GIL-independent, all validated with CPython 3.14 free-threaded hermetic Python.

• URL: pull/125641

• Associated Commits: 19271, 2eeb5, f3535, e96e1, fe866, 8d920, 7ad5f, 8ed31

Other Open Pull Requests

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: 46

Key Closed Pull Requests

1. feat: int16 and int32 for sparse matrices: This pull request proposes adding support for int16 and int32 data types as indices for sparse matrices in TensorFlow to reduce memory usage compared to the default int64, addressing issue #63102, but it was not merged.

• URL: pull/121360

• Associated Commits: 9e7c0, d48e6, cad95, 1c760, 48ef3, 734ed, f692b, 4102c, 1ce61, 5980c, 59dee, 9da08, f1191, dd614, 85859, 6edab, 29fc0, d3aa3, 60d22, 7b209, b43bc, 695fc

2. TFLite: require matching quantization params (scale & zero_point) for Transpose and ResizeBilinear: This pull request adds runtime checks to TensorFlow Lite's Transpose and ResizeBilinear kernels to ensure that for int8-quantized tensors, the input and output tensors have matching scale and zero_point quantization parameters, logging an error and aborting execution if a mismatch is detected, thereby preventing silent errors and enforcing correct model construction, and includes new negative unit tests to validate this behavior.

• URL: pull/101974

• Associated Commits: 9fb00, c78c6, fbd3b, 6fefc, a7b1f, 40ec9, cd959, b31b2, d14cb, 0e5aa, 01194, 87771, cb766, 3791d, b6a05, f72eb, 5602d, db194, 36a08

3. Fix tf.raw_ops.Digamma to return -inf for input 0: This pull request aims to fix the behavior of the TensorFlow Digamma operation so that it correctly returns negative infinity for an input of zero, aligning all execution paths across CPU, XLA, and GPU implementations, and includes corresponding updates to tests and code to handle this special case.

• URL: pull/111945

• Associated Commits: 5e6be, 0c57b, 0c385, d9c8b, be63b, d7335, 05994, 2e19a, 42c87, 8f44c

Other Closed Pull Requests

• Session stability improvements: This pull request adds None checks for the internal _session attribute in TensorFlow's BaseSession to prevent segmentation faults and instead raise a clear RuntimeError when the session handle is None. This change improves stability when users inadvertently set sess.__dict__['_session'] to None.
  • pull/112643

• TensorArray.split static validation: This pull request adds static validation to the graph-mode TensorArray.split operation to detect and reject statically known length mismatches and scalar split inputs consistently across V1 and V2 implementations. This prevents silent acceptance of invalid splits in XLA and aligns error handling with eager execution.
  • pull/112653

• Leaky ReLU and ELU alpha parameter validation: These pull requests add comprehensive validation for the alpha parameter in Leaky ReLU and ELU activation functions, ensuring alpha is non-negative and handling scalar, numpy, tensor, and variable inputs correctly. They remove misleading validation code, fix related bugs, add runtime assertions, and include unit tests to verify proper error handling for invalid alpha values.
  • pull/122771, pull/122773

• MatrixDiag kernel overflow and segmentation fault prevention: This pull request addresses integer overflow issues in the MatrixDiag kernel by adding explicit bounds and non-negative element checks to prevent invalid tensor shapes. It ensures that extremely large input dimensions trigger proper error handling instead of causing crashes.
  • pull/125050

• Windows preload and DLL conflict detection: This pull request enhances TensorFlow's Windows preload check to detect and raise clear errors when conflicting TensorFlow distributions with differing versions are installed simultaneously or when a 32-bit Python interpreter is used. This prevents obscure DLL load failures caused by mixed shared libraries in the same site-packages directory.
  • pull/125351

• XLA GatherV2 bounds checking: This pull request fixes the issue where out-of-bounds indices in XLA's GatherV2 operation were silently clipped, causing incorrect results. It adds bounds checking that clamps indices to valid ranges, builds a validity mask for out-of-bounds indices, and zeroes out invalid results to prevent silent data corruption while maintaining backward compatibility.
  • pull/115255

• XLA numpy cross product compilation fix: This pull request fixes an XLA compilation failure in tf.experimental.numpy.cross by ensuring the statically known last dimension size is used when available. This allows the XLA compiler to verify operand size for cross-products and enables successful JIT compilation for inputs with dynamic batch dimensions but static last dimensions.
  • pull/124588

• TensorFlow Lite input validation and delegate improvements: This pull request enhances TensorFlow Lite's robustness by adding defensive validation against malformed TfLiteIntArray inputs and improving delegate parameter allocation arithmetic to prevent overflow, invalid size handling, and unsafe memory operations.
  • pull/119155

• tf.raw_ops.Round integer specialization fix: This pull request addresses a regression where tf.raw_ops.Round incorrectly returned all zeros for integer tensors by relaxing the integer specialization of the rounding kernel to act as the identity function. It restores expected behavior and adds a targeted regression test to verify the fix.
  • pull/123319

• BlockLSTM and BlockLSTMGrad input validation: These pull requests add validation to ensure the seq_len_max parameter is properly checked against the time dimension of the input tensor x in BlockLSTM and BlockLSTMGrad operations. This prevents unguarded out-of-bounds slices that caused process aborts and ensures an InvalidArgumentError is raised instead of crashes.
  • pull/125038, pull/108809

• BoringSSL linking fix: This pull request fixes a linking failure when building with system BoringSSL by explicitly adding the -lcrypto link option to libtensorflow_cc. This resolves undefined references caused by the pywrap rules mechanism ignoring transitive dependencies.
  • pull/125250

• XLA Cumsum and Cumprod complex type support: This pull request enables support for complex64 and complex128 data types in the XLA Cumsum and Cumprod kernels by registering these types for scan operations. It addresses a previous omission that caused compiler rejections and includes expanded test coverage for various scan modes on complex tensors.
  • pull/125286

• tf.stack single Tensor input normalization: This pull request fixes inconsistent behavior of tf.stack when called with a single bare Tensor by normalizing such inputs into a list before graph or operation construction. This ensures consistent execution across eager and compiled graph modes.
  • pull/125381

• tf.shape() out_type validation: This pull request fixes a bug where the constant-folding shortcut path in tf.shape() failed to validate the out_type argument against allowed integral types, silently accepting invalid types like float32 during graph tracing. It adds proper validation and a regression test to ensure consistency with the underlying operation's constraints.
  • pull/125395

• XLA CPU backend reduce_sum precision regression test: This pull request adds a regression test for TensorFlow's XLA CPU backend to detect and prevent excessive precision loss when chaining multiple large tf.reduce_sum operations. It verifies that computed results remain within acceptable error tolerance compared to expected float32 sums.
  • pull/125501

• Double-precision erf overflow fix: This pull request addresses a bug in TensorFlow's double-precision erf function where large finite inputs and infinities caused NaN results due to intermediate overflow in Eigen's implementation. It introduces a saturating wrapper returning exact +/-1 for inputs with absolute value ≥6, ensuring consistency with other libraries without affecting performance or other data types.
  • pull/125596

• SparseTensor indices dtype validation: This pull request improves validation of SparseTensor indices by ensuring only int64 dtype indices are accepted consistently across eager execution and tf.function. It prevents silent casting of int32 indices during graph tracing, preserves Python-list conversion to int64, and adds comprehensive regression tests for all modes.
  • pull/125615

• Docker Image CI workflow proposal: This pull request proposes adding a Docker Image continuous integration workflow by creating a main.yml file to automate build and testing processes, but it was not merged.
  • pull/125756

• Empty captured resource tensor validation proposal: This pull request addresses handling and validation of empty captured resource tensors in batch functions to improve security, but it was not merged.
  • pull/125951

• TFLite TOSA dependency cleanup prototype: This pull request is a prototype aimed at cleaning up TensorFlow Lite dependencies within the TOSA component of TensorFlow.
  • pull/95262

• L2Pool implementation correction: This pull request corrects the L2Pool implementation by ensuring it does not average the squares of the pooling regions, effectively re-landing a previously discussed fix.
  • pull/96599

• Eager execution scope name validation: This pull request adds validation for scope names in TensorFlow's eager execution mode within tf.name_scope, ensuring invalid names raise a ValueError immediately. It mirrors existing graph mode checks, preserves the trailing-slash escape hatch, and improves consistency between eager and graph modes.
  • pull/118030

• TensorListScatterIntoExistingList negative index validation: This pull request fixes a critical out-of-bounds write vulnerability in TensorListScatterIntoExistingList by adding validation to ensure scatter indices are non-negative. It prevents invalid memory access caused by negative indices, aligns behavior with the sibling operation, and introduces a regression test verifying that negative indices raise an error.
  • pull/121412

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.