tf-nightly-cpu 2.20.0.dev20250220__cp39-cp39-win_amd64.whl → 2.20.0.dev20250221__cp39-cp39-win_amd64.whl

tensorflow/include/xla/pjrt/pjrt_stream_executor_client.h

@@ -52,9 +52,9 @@ limitations under the License.
 #include "xla/pjrt/pjrt_client.h"
 #include "xla/pjrt/pjrt_common.h"
 #include "xla/pjrt/pjrt_compiler.h"
-#include "xla/pjrt/pjrt_device_description.h"
 #include "xla/pjrt/pjrt_executable.h"
 #include "xla/pjrt/pjrt_future.h"
+#include "xla/pjrt/pjrt_stream_executor_device_description.h"
 #include "xla/pjrt/tracked_device_buffer.h"
 #include "xla/pjrt/transpose.h"
 #include "xla/pjrt/utils.h"
@@ -77,54 +77,6 @@ limitations under the License.
 
 namespace xla {
 
-class PjRtStreamExecutorDeviceDescription : public PjRtDeviceDescription {
- public:
-  explicit PjRtStreamExecutorDeviceDescription(int id, std::string device_kind,
-                                               int process_index = 0)
-      : id_(id),
-        process_index_(process_index),
-        device_kind_(std::move(device_kind)) {}
-
-  int id() const override { return id_; }
-
-  int process_index() const override { return process_index_; }
-
-  absl::string_view device_kind() const override { return device_kind_; }
-
-  absl::string_view ToString() const override { return to_string_; }
-
-  absl::string_view DebugString() const override { return debug_string_; }
-
-  absl::Span<int const> coords() const { return absl::MakeSpan(coords_); }
-
-  const absl::flat_hash_map<std::string, PjRtDeviceAttribute>& Attributes()
-      const override {
-    return attributes_;
-  }
-
-  void SetAttributes(
-      absl::flat_hash_map<std::string, PjRtDeviceAttribute> attributes) {
-    attributes_ = std::move(attributes);
-  }
-
-  void SetDebugString(std::string debug_string) {
-    debug_string_ = std::move(debug_string);
-  }
-
-  void SetToString(std::string to_string) { to_string_ = std::move(to_string); }
-
-  void SetCoords(std::array<int, 1> coords) { coords_ = coords; }
-
- private:
-  const int id_;
-  const int process_index_;
-  const std::string device_kind_;
-  std::string debug_string_ = "<unknown SE device>";
-  std::string to_string_ = "<unknown SE device>";
-  absl::flat_hash_map<std::string, PjRtDeviceAttribute> attributes_;
-  std::array<int, 1> coords_;
-};
-
 class PjRtStreamExecutorDevice : public PjRtDevice {
  public:
   explicit PjRtStreamExecutorDevice(

tensorflow/include/xla/pjrt/pjrt_stream_executor_device_description.h

@@ -0,0 +1,75 @@
+/* Copyright 2025 The OpenXLA Authors.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_PJRT_PJRT_STREAM_EXECUTOR_DEVICE_DESCRIPTION_H_
+#define XLA_PJRT_PJRT_STREAM_EXECUTOR_DEVICE_DESCRIPTION_H_
+
+#include <array>
+#include <string>
+#include <utility>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "xla/pjrt/pjrt_device_description.h"
+
+namespace xla {
+
+class PjRtStreamExecutorDeviceDescription : public PjRtDeviceDescription {
+ public:
+  explicit PjRtStreamExecutorDeviceDescription(int id, std::string device_kind,
+                                               int process_index = 0)
+      : id_(id),
+        process_index_(process_index),
+        device_kind_(std::move(device_kind)) {}
+
+  int id() const override { return id_; }
+
+  int process_index() const override { return process_index_; }
+
+  absl::string_view device_kind() const override { return device_kind_; }
+
+  absl::string_view ToString() const override { return to_string_; }
+
+  absl::string_view DebugString() const override { return debug_string_; }
+
+  absl::Span<int const> coords() const { return absl::MakeSpan(coords_); }
+
+  const absl::flat_hash_map<std::string, PjRtDeviceAttribute>& Attributes()
+      const override {
+    return attributes_;
+  }
+
+  void SetAttributes(
+      absl::flat_hash_map<std::string, PjRtDeviceAttribute> attributes) {
+    attributes_ = std::move(attributes);
+  }
+
+  void SetDebugString(std::string debug_string) {
+    debug_string_ = std::move(debug_string);
+  }
+
+  void SetToString(std::string to_string) { to_string_ = std::move(to_string); }
+
+  void SetCoords(std::array<int, 1> coords) { coords_ = coords; }
+
+ private:
+  const int id_;
+  const int process_index_;
+  const std::string device_kind_;
+  std::string debug_string_ = "<unknown SE device>";
+  std::string to_string_ = "<unknown SE device>";
+  absl::flat_hash_map<std::string, PjRtDeviceAttribute> attributes_;
+  std::array<int, 1> coords_;
+};
+}  // namespace xla
+
+#endif  // XLA_PJRT_PJRT_STREAM_EXECUTOR_DEVICE_DESCRIPTION_H_

tensorflow/include/xla/pjrt/plugin/xla_cpu/cpu_execute_options.h

@@ -0,0 +1,57 @@
+/* Copyright 2025 The OpenXLA Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_PJRT_PLUGIN_XLA_CPU_CPU_EXECUTE_OPTIONS_H_
+#define XLA_PJRT_PLUGIN_XLA_CPU_CPU_EXECUTE_OPTIONS_H_
+
+#include <optional>
+
+#include "xla/backends/cpu/collectives/cpu_collectives.h"
+#include "xla/pjrt/pjrt_executable.h"
+
+namespace xla {
+
+// ExecuteContext for XLA:CPU PjRtLoadedExecutable::Execute calls.
+class CpuExecuteContext : public ExecuteContext {
+ public:
+  ~CpuExecuteContext() override = default;
+
+  // If specified, override the process ID specified in
+  // `CpuClientOptions::process_id` for a particular call of
+  // PjRtLoadedExecutable::Execute.
+  //
+  // TODO(hyeontaek): Look for a collectives-agnostic way and combine this
+  // option with `ExecuteOptions::multi_slice_config`.
+  std::optional<int>& process_index() { return process_index_; }
+  std::optional<int> process_index() const { return process_index_; }
+
+  // If specified, override CPU collectives specified in
+  // `CpuClientOptions::collectives` for a particular call of
+  // PjRtLoadedExecutable::Execute. Must remain valid until the execution
+  // finishes.
+  //
+  // TODO(hyeontaek): Look for a collectives-agnostic way and combine this
+  // option with `ExecuteOptions::multi_slice_config`.
+  cpu::CpuCollectives*& collectives() { return collectives_; }
+  cpu::CpuCollectives* collectives() const { return collectives_; }
+
+ private:
+  std::optional<int> process_index_;
+  cpu::CpuCollectives* collectives_ = nullptr;
+};
+
+}  // namespace xla
+
+#endif  // XLA_PJRT_PLUGIN_XLA_CPU_CPU_EXECUTE_OPTIONS_H_

tensorflow/include/xla/pjrt/plugin/xla_cpu/cpu_topology.h

@@ -69,6 +69,10 @@ inline int UnpackCpuProcessIndex(PjRtGlobalDeviceId global_device_id) {
   return global_device_id.value() / kMaxCpuDevicesPerProcess;
 }
 
+inline int UnpackCpuLocalDeviceId(PjRtGlobalDeviceId global_device_id) {
+  return global_device_id.value() % kMaxCpuDevicesPerProcess;
+}
+
 }  // namespace xla
 
 #endif  // XLA_PJRT_PLUGIN_XLA_CPU_CPU_TOPOLOGY_H_

tensorflow/include/xla/service/constant_value.h

@@ -18,6 +18,7 @@ limitations under the License.
 
 #include <string>
 
+#include "absl/base/casts.h"
 #include "absl/status/statusor.h"
 #include "xla/literal.h"
 #include "xla/util.h"

tensorflow/include/xla/service/hlo_module_util.h

@@ -19,16 +19,67 @@ limitations under the License.
 #include <functional>
 #include <memory>
 #include <optional>
+#include <string>
 
-#include "absl/status/status.h"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
 #include "absl/types/span.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/hlo/parser/hlo_parser.h"
 #include "xla/service/compiler.h"
 #include "xla/service/hlo_module_config.h"
 #include "xla/shape.h"
+#include "xla/util.h"
 
 namespace xla {
 
+// Converts an HloModule from the given hlo textual IR string (in
+// HloModule::ToString format).
+absl::StatusOr<std::unique_ptr<HloModule>> CreateModuleFromString(
+    absl::string_view hlo_string,
+    const DebugOptions& debug_options = DebugOptions::default_instance());
+
+// Creates an HloModule from the given proto.
+absl::StatusOr<std::unique_ptr<HloModule>> CreateModuleFromProto(
+    const HloModuleProto& proto,
+    const DebugOptions& debug_options = DebugOptions::default_instance());
+
+// Create an HLO state from serialized representation. In addition to
+// creating the proto with HloModule::CreateFromProto(...) it also
+// uses HloVerifier to ensure basic invariants are held.
+// The HLO module could be a pre-optimizations (default) or post-optimizations
+// module, which affects how the HLO module is verified, e.g., mixed-precision
+// is allowed in post-optimizations HLOs.
+absl::StatusOr<std::unique_ptr<HloModule>> CreateModuleFromProto(
+    const HloModuleProto& proto, const HloModuleConfig& module_config,
+    bool is_module_post_optimizations = false);
+
+// Reads the proto file in xla.HloProto format, creates and returns the
+// HloModule.
+absl::StatusOr<std::unique_ptr<HloModule>> ReadModuleFromBinaryProtoFile(
+    absl::string_view filename,
+    const DebugOptions& debug_options = DebugOptions::default_instance());
+
+// Reads the proto file in xla.HloModule format, creates and returns the
+// HloModule.
+absl::StatusOr<std::unique_ptr<HloModule>> ReadModuleFromModuleBinaryProtofile(
+    absl::string_view filename, const DebugOptions& debug_options);
+
+// Reads the HLO text dump file in HloModule::ToString format, creates and
+// returns the HloModule.
+absl::StatusOr<std::unique_ptr<HloModule>> ReadModuleFromHloTextFile(
+    absl::string_view filename,
+    const DebugOptions& debug_options = DebugOptions::default_instance(),
+    const HloParserOptions& options = HloParserOptions());
+
+// Reads the proto file in xla.HloProto format, creates and returns the
+// HloModule.
+absl::StatusOr<std::unique_ptr<HloModule>> ReadModuleFromTextProtoFile(
+    absl::string_view hlo_file,
+    const DebugOptions& debug_options = DebugOptions::default_instance());
+
 // Creates an HloModuleConfig for a given program shape and arguments.
 // If execution_options does not set num_replicas, default_num_replicas is used.
 // num_threads is optional; if not given, intra_op_parallelism_threads not set.

tensorflow/include/xla/service/hlo_proto_util.h

@@ -18,8 +18,6 @@ limitations under the License.
 #ifndef XLA_SERVICE_HLO_PROTO_UTIL_H_
 #define XLA_SERVICE_HLO_PROTO_UTIL_H_
 
-#include <string>
-
 #include "absl/status/status.h"
 #include "xla/hlo/ir/hlo_module.h"
 #include "xla/service/buffer_assignment.h"
@@ -35,16 +33,6 @@ HloProto MakeHloProto(const HloModule& module,
 // will not be included in the output.
 HloProto MakeHloProto(const HloModule& module);
 
-// Create an HLO state from serialized representation. In addition to
-// creating the proto with HloModule::CreateFromProto(...) it also
-// uses HloVerifier to ensure basic invariants are held.
-// The HLO module could be a pre-optimizations (default) or post-optimizations
-// module, which affects how the HLO module is verified, e.g., mixed-precision
-// is allowed in post-optimizations HLOs.
-absl::StatusOr<std::unique_ptr<HloModule>> CreateModuleFromProto(
-    const HloModuleProto& proto, const HloModuleConfig& module_config,
-    bool is_module_post_optimizations = false);
-
 // Returns the shapes of the parameters of the entry computation. Shape pointers
 // refer to shapes inside of the given HloProto.
 absl::StatusOr<std::vector<const ShapeProto*>> EntryComputationParameterShapes(

tensorflow/include/xla/tsl/framework/convolution/eigen_spatial_convolutions-inl.h

@@ -1604,12 +1604,12 @@ SpatialConvolution(const Input& input, const Kernel& kernel,
                    Index padding_left = 0, Index padding_right = 0) {
   typedef typename internal::traits<Input>::Index TensorIndex;
   typedef typename internal::traits<Input>::Scalar InputScalar;
-  TensorRef<Tensor<InputScalar, internal::traits<Input>::NumDimensions,
-                   internal::traits<Input>::Layout, TensorIndex> >
+  TensorRef<const Tensor<InputScalar, internal::traits<Input>::NumDimensions,
+                         internal::traits<Input>::Layout, TensorIndex> >
       in(input);
-  TensorRef<Tensor<typename internal::traits<Kernel>::Scalar,
-                   internal::traits<Kernel>::NumDimensions,
-                   internal::traits<Kernel>::Layout, TensorIndex> >
+  TensorRef<const Tensor<typename internal::traits<Kernel>::Scalar,
+                         internal::traits<Kernel>::NumDimensions,
+                         internal::traits<Kernel>::Layout, TensorIndex> >
       kern(kernel);
 
   EIGEN_STATIC_ASSERT(

tensorflow/python/compat/compat.py

@@ -29,7 +29,7 @@ from tensorflow.python.util.tf_export import tf_export
 # This value changes every day with an automatic CL. It can be modified in code
 # via `forward_compatibility_horizon()` or with the environment variable
 # TF_FORWARD_COMPATIBILITY_DELTA_DAYS, which is added to the compatibility date.
-_FORWARD_COMPATIBILITY_HORIZON = datetime.date(2025, 2, 19)
+_FORWARD_COMPATIBILITY_HORIZON = datetime.date(2025, 2, 20)
 _FORWARD_COMPATIBILITY_DELTA_DAYS_VAR_NAME = "TF_FORWARD_COMPATIBILITY_DELTA_DAYS"
 _FORWARD_COMPATIBILITY_DATE_NUMBER = None
 

tensorflow/python/eager/imperative_grad.py

@@ -43,13 +43,13 @@ def imperative_grad(tape,
    target: either a Tensor or list of Tensors to be differentiated.
    sources: list of Tensors for which we want gradients
    output_gradients: if not None, a list of gradient provided for each Target,
-    or None if we are to use the target's computed downstream gradient.
+     or None if we are to use the target's computed downstream gradient.
    sources_raw: if not None, a list of the source python objects from which the
-    sources were generated. Should have the same length as sources. Only needs
-    to be populated if unconnected_gradients is 'zero'.
+     sources were generated. Should have the same length as sources. Only needs
+     to be populated if unconnected_gradients is 'zero'.
    unconnected_gradients: determines the value returned if the target and
-    sources are unconnected. When 'none' the value returned is None wheras when
-    'zero' a zero tensor in the same shape as the sources is returned.
+     sources are unconnected. When 'none' the value returned is None whereas
+     when 'zero' a zero tensor in the same shape as the sources is returned.
 
   Returns:
    the gradient wrt each of the sources.

tensorflow/python/eager/polymorphic_function/atomic_function.py

@@ -55,7 +55,7 @@ class CallOptions:
   # Used by ACD to list Ops/Tensors/Callables that must be called in advance.
   control_captures: List[Any] = dataclasses.field(default_factory=list)
 
-  # Determines what kind of partitoned call is used for this function.
+  # Determines what kind of partitioned call is used for this function.
   is_stateful: bool = False
 
 

tensorflow/python/eager/polymorphic_function/compiler_ir.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""Implmentation for defining get_compiler_ir."""
+"""Implementation for defining get_compiler_ir."""
 from typing import List, Optional
 import warnings
 

tensorflow/python/eager/polymorphic_function/polymorphic_function.py

@@ -966,7 +966,7 @@ class Function(core.PolymorphicFunction, trackable.Trackable):
 
     def _check_inputs(args, kwargs):
       all_inputs = list(args) + list(kwargs.values())
-      # Emtpy input is okay.
+      # Empty input is okay.
       if not all_inputs:
         return
       if any(map(is_tensor_spec, all_inputs)) and any(
@@ -1423,7 +1423,8 @@ def function(
   thought of as compile-time constants), and builds a separate `tf.Graph` for
   each set of Python arguments that it encounters.
   For more information, see the
-  [tf.function guide](https://www.tensorflow.org/guide/function#rules_of_tracing)
+  [tf.function
+  guide](https://www.tensorflow.org/guide/function#rules_of_tracing)
 
   Executing a `PolymorphicFunction` will select and execute the appropriate
   `ConcreteFunction` based on the argument types and values.
@@ -1440,14 +1441,17 @@ def function(
   >>> isinstance(f.get_concrete_function(1).graph, tf.Graph)
   True
 
-  `ConcreteFunction`s can be executed just like `PolymorphicFunction`s, but their
-  input is resticted to the types to which they're specialized.
+  `ConcreteFunction`s can be executed just like `PolymorphicFunction`s, but
+  their
+  input is restricted to the types to which they're specialized.
 
   ## Retracing
 
-  `ConcreteFunctions` are built (traced) on the fly, as the `PolymorphicFunction` is
+  `ConcreteFunctions` are built (traced) on the fly, as the
+  `PolymorphicFunction` is
   called with new TensorFlow types or shapes, or with new Python values as
-  arguments. When `PolymorphicFunction` builds a new trace, it is said that `func`
+  arguments. When `PolymorphicFunction` builds a new trace, it is said that
+  `func`
   is retraced. Retracing is a frequent performance concern for `tf.function` as
   it can be considerably slower than executing a graph that's already been
   traced. It is ideal to minimize the amount of retracing in your code.
@@ -1473,7 +1477,8 @@ def function(
 
   ## Input signatures
 
-  For Tensor arguments, `PolymorphicFunction`creates a new `ConcreteFunction` for
+  For Tensor arguments, `PolymorphicFunction`creates a new `ConcreteFunction`
+  for
   every unique set of input shapes and datatypes. The example below creates two
   separate `ConcreteFunction`s, each specialized to a different shape:
 
@@ -1580,59 +1585,58 @@ def function(
       `func` must be a `Tensor`, and `func` cannot accept `**kwargs`.
     autograph: Whether autograph should be applied on `func` before tracing a
       graph. Data-dependent Python control flow statements require
-      `autograph=True`. For more information, see the
-      [tf.function and AutoGraph guide](
+      `autograph=True`. For more information, see the [tf.function and AutoGraph
+      guide](
       https://www.tensorflow.org/guide/function#autograph_transformations).
     jit_compile: If `True`, compiles the function using
       [XLA](https://tensorflow.org/xla). XLA performs compiler optimizations,
       such as fusion, and attempts to emit more efficient code. This may
-      drastically improve the performance. If set to `True`,
-      the whole function needs to be compilable by XLA, or an
-      `errors.InvalidArgumentError` is thrown.
-      If `None` (default), compiles the function with XLA when running on TPU
-      and goes through the regular function execution path when running on
-      other devices.
-      If `False`, executes the function without XLA compilation.  Set this value
-      to `False` when directly running a multi-device function on TPUs (e.g. two
-      TPU cores, one TPU core and its host CPU).
-      Not all functions are compilable, see a list of
-      [sharp corners](https://tensorflow.org/xla/known_issues).
-    reduce_retracing: When True, `tf.function` attempts to reduce the
-      amount of retracing, for example by using more generic shapes. This
-      can be controlled for user objects by customizing their associated
+      drastically improve the performance. If set to `True`, the whole function
+      needs to be compilable by XLA, or an `errors.InvalidArgumentError` is
+      thrown. If `None` (default), compiles the function with XLA when running
+      on TPU and goes through the regular function execution path when running
+      on other devices. If `False`, executes the function without XLA
+      compilation.  Set this value to `False` when directly running a
+      multi-device function on TPUs (e.g. two TPU cores, one TPU core and its
+      host CPU). Not all functions are compilable, see a list of [sharp
+      corners](https://tensorflow.org/xla/known_issues).
+    reduce_retracing: When True, `tf.function` attempts to reduce the amount of
+      retracing, for example by using more generic shapes. This can be
+      controlled for user objects by customizing their associated
       `tf.types.experimental.TraceType`.
     experimental_implements: If provided, contains a name of a "known" function
-      this implements. For example "mycompany.my_recurrent_cell".
-      This is stored as an attribute in inference function,
-      which can then be detected when processing serialized function.
-      See [standardizing composite ops](https://github.com/tensorflow/community/blob/master/rfcs/20190610-standardizing-composite_ops.md)  # pylint: disable=line-too-long
-      for details.  For an example of utilizing this attribute see this
+      this implements. For example "mycompany.my_recurrent_cell". This is stored
+      as an attribute in inference function, which can then be detected when
+      processing serialized function. See [standardizing composite
+      ops](https://github.com/tensorflow/community/blob/master/rfcs/20190610-standardizing-composite_ops.md)
+      # pylint: disable=line-too-long for details.  For an example of utilizing
+      this attribute see this
       [example](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/compiler/mlir/lite/transforms/prepare_composite_functions_tf.cc)
       The code above automatically detects and substitutes function that
       implements "embedded_matmul" and allows TFLite to substitute its own
-      implementations. For instance, a tensorflow user can use this
-       attribute to mark that their function also implements
-      `embedded_matmul` (perhaps more efficiently!)
-      by specifying it using this parameter:
-      `@tf.function(experimental_implements="embedded_matmul")`
-      This can either be specified as just the string name of the function or
-      a NameAttrList corresponding to a list of key-value attributes associated
-      with the function name. The name of the function will be in the 'name'
-      field of the NameAttrList. To define a formal TF op for this function
-      implements, try the experimental [composite TF](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/compiler/mlir/tfr)
+      implementations. For instance, a tensorflow user can use this attribute to
+      mark that their function also implements `embedded_matmul` (perhaps more
+      efficiently!) by specifying it using this parameter:
+      `@tf.function(experimental_implements="embedded_matmul")` This can either
+      be specified as just the string name of the function or a NameAttrList
+      corresponding to a list of key-value attributes associated with the
+      function name. The name of the function will be in the 'name' field of the
+      NameAttrList. To define a formal TF op for this function implements, try
+      the experimental [composite
+      TF](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/compiler/mlir/tfr)
       project.
     experimental_autograph_options: Optional tuple of
       `tf.autograph.experimental.Feature` values.
     experimental_attributes: Optional dictionary of attributes to include in the
       generated FunctionDefs.
-    experimental_relax_shapes: Deprecated. Use `reduce_retracing`
-      instead.
+    experimental_relax_shapes: Deprecated. Use `reduce_retracing` instead.
     experimental_compile: Deprecated alias to 'jit_compile'.
     experimental_follow_type_hints: Deprecated. Please use input_signature or
       reduce_retracing instead.
 
   Returns:
-     If `func` is not None, returns a `tf.types.experimental.PolymorphicFunction`.
+     If `func` is not None, returns a
+     `tf.types.experimental.PolymorphicFunction`.
      If `func` is None, returns a decorator that, when invoked with a single
      `func` argument, returns a `tf.types.experimental.PolymorphicFunction`.
 

tensorflow/python/eager/tape.py

@@ -48,9 +48,9 @@ def watch(tape, tensor):
 def default_get_variables(variable):
   return [variable]
 
-# Gets a list of changed variables. Can be overriden using
+# Gets a list of changed variables. Can be overridden using
 # register_variables_override. An example of overriding is for getting the
-# varibles within a distributed context.
+# variables within a distributed context.
 _variables_override = default_get_variables
 
 

tensorflow/python/ops/summary_ops_v2.py

@@ -151,7 +151,11 @@ def _legacy_contrib_should_record_summaries():
 
 def is_recording_summaries():
   """Returns non-Tensor boolean indicating if summaries are being recorded."""
-  return _summary_state.is_recording is not None and _summary_state.is_recording
+  if _summary_state.writer is None:
+    return False
+  if _summary_state.is_recording is None:
+    return False
+  return _summary_state.is_recording
 
 
 @tf_export("summary.record_if", v1=[])