returnn 1.20230501.131856__tar.gz → 1.20230503.142906__tar.gz

{returnn-1.20230501.131856/returnn.egg-info → returnn-1.20230503.142906}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: returnn
-Version: 1.20230501.131856
+Version: 1.20230503.142906
 Summary: The RWTH extensible training framework for universal recurrent neural networks
 Home-page: https://github.com/rwth-i6/returnn/
 Author: Albert Zeyer

returnn-1.20230503.142906/_setup_info_generated.py

@@ -0,0 +1,2 @@
+version = '1.20230503.142906'
+long_version = '1.20230503.142906+git.1c628d2'

{returnn-1.20230501.131856 → returnn-1.20230503.142906}/returnn/frontend/_backend.py

@@ -42,7 +42,15 @@ class Backend(Generic[T]):
 
     @staticmethod
     def cond(pred: Tensor, true_fn: Callable, false_fn: Callable):
-        """cond"""
+        """
+        cond: conditional execution.
+
+        Note that this does not need an implementation for eager-based frameworks
+        (:func:`executing_eagerly` returns True),
+        as the :func:`returnn.frontend.cond` function already covers that case.
+        """
+        # noinspection PyProtectedMember
+        assert not pred._raw_backend.executing_eagerly(), "should not get here"
         raise NotImplementedError
 
     @staticmethod

{returnn-1.20230501.131856 → returnn-1.20230503.142906}/returnn/frontend/const.py

@@ -10,7 +10,7 @@ from ._backend import global_backend
 import returnn.frontend as rf
 
 
-__all__ = ["full", "constant", "fill", "zeros", "ones"]
+__all__ = ["full", "constant", "fill", "zeros", "ones", "zeros_like", "ones_like"]
 
 
 def full(
@@ -54,3 +54,13 @@ def ones(dims: Sequence[Dim], *, dtype: Optional[str] = None, sparse_dim: Option
     ones. float by default.
     """
     return full(dims=dims, fill_value=1, dtype=dtype or rf.get_default_float_dtype(), sparse_dim=sparse_dim)
+
+
+def zeros_like(other: Tensor) -> Tensor:
+    """zeros like other"""
+    return zeros(dims=other.dims, dtype=other.dtype, sparse_dim=other.sparse_dim)
+
+
+def ones_like(other: Tensor) -> Tensor:
+    """ones like other"""
+    return ones(dims=other.dims, dtype=other.dtype, sparse_dim=other.sparse_dim)

{returnn-1.20230501.131856 → returnn-1.20230503.142906}/returnn/frontend/parameter.py

@@ -138,7 +138,12 @@ class Parameter(Tensor[T]):
     def trainable(self, trainable: Optional[bool]):
         self._trainable = trainable
         if trainable is None:
-            trainable = not self.auxiliary
+            if self.auxiliary:
+                trainable = False
+            elif self.dtype.startswith("int"):
+                trainable = False
+            else:
+                trainable = True
         self._raw_backend.set_parameter_trainable(self, trainable)
 
     @property

{returnn-1.20230501.131856 → returnn-1.20230503.142906}/returnn/tf/layers/basic.py

@@ -309,6 +309,7 @@ class _ConcatInputLayer(LayerBase):
 class CopyLayer(_ConcatInputLayer):
     """
     This layer does nothing, it copies its input.
+    This is not even a ``tf.identity``. It refers to the same TF tensor.
     If multiple sources are provided, they are concatenated in the feature-dim.
     """
 
@@ -323,6 +324,9 @@ class CopyLayer(_ConcatInputLayer):
           We only have this here for the :class:`CopyLayer` because the :func:`get_out_data_from_opts`
           must know about it and define the right beam.
           Also see the option ``collocate_with``, which is different in that it does *not* add a dependency.
+          Note that this will not be real TF control dependencies,
+          but it simply sets the dependency on the layer.
+          If you want to have a real TF control dependency, use :class:`IdentityLayer`.
         """
         if in_dim and out_dim:
             assert in_dim == out_dim
@@ -415,6 +419,42 @@ class CopyLayer(_ConcatInputLayer):
             d["extra_deps"] = [get_layer(src_name) for src_name in extra_deps]
 
 
+class IdentityLayer(LayerBase):
+    """
+    Wraps ``tf.identity`` with potential control dependencies.
+
+    The difference to :class:`CopyLayer` is that this creates a new TF op (``tf.identity``),
+    which allows for potential control dependencies.
+    This is the whole purpose of this layer.
+    """
+
+    layer_class = "identity"
+
+    def __init__(self, sources: List[LayerBase], control_dependencies: Sequence[LayerBase], **kwargs):
+        super().__init__(sources=sources, **kwargs)
+        assert len(sources) == 1
+        self.control_dependencies = control_dependencies
+        with tf.control_dependencies([src.output.placeholder.op for src in self.control_dependencies]):
+            self.output.placeholder = tf.identity(self.sources[0].output.placeholder)
+
+    def get_dep_layers(self) -> List[LayerBase]:
+        """deps"""
+        return super().get_dep_layers() + list(self.control_dependencies)
+
+    @classmethod
+    def get_out_data_from_opts(cls, name: str, sources: List[LayerBase], **kwargs):
+        """out"""
+        assert sources
+        return sources[0].output.copy(name="%s_output" % name)
+
+    @classmethod
+    def transform_config_dict(cls, d, network, get_layer):
+        """transform"""
+        super().transform_config_dict(d, network=network, get_layer=get_layer)
+        assert isinstance(d.get("control_dependencies"), (list, tuple))
+        d["control_dependencies"] = [get_layer(src_name) for src_name in d["control_dependencies"]]
+
+
 class ConcatLayer(LayerBase):
     """
     Concatenates the inputs in specified axes.

{returnn-1.20230501.131856 → returnn-1.20230503.142906}/returnn/tf/util/basic.py

@@ -5850,11 +5850,13 @@ def same_control_flow_ctx(x):
         with tf.control_dependencies(None) as dep:  # this will reset the context
             yield dep
         return
-    # noinspection PyProtectedMember
-    graph._set_control_flow_context(ctx)
-    yield ctx
-    # noinspection PyProtectedMember
-    graph._set_control_flow_context(cur_ctx)
+    try:
+        # noinspection PyProtectedMember
+        graph._set_control_flow_context(ctx)
+        yield ctx
+    finally:
+        # noinspection PyProtectedMember
+        graph._set_control_flow_context(cur_ctx)
 
 
 def get_protobuf_fields(obj):

{returnn-1.20230501.131856 → returnn-1.20230503.142906}/returnn/torch/frontend/_backend.py

@@ -483,8 +483,12 @@ class TorchBackend(Backend[torch.Tensor]):
         :return: parameter
         """
         assert all(d.is_static() for d in tensor.dims)
-        data = torch.zeros(*(d.dimension for d in tensor.dims), dtype=TorchBackend.as_dtype_raw(tensor.dtype))
-        return torch.nn.Parameter(data)
+        data = torch.zeros([d.dimension for d in tensor.dims], dtype=TorchBackend.as_dtype_raw(tensor.dtype))
+        if tensor.dtype.startswith("int"):
+            requires_grad = False
+        else:
+            requires_grad = True
+        return torch.nn.Parameter(data, requires_grad=requires_grad)
 
     @staticmethod
     def set_parameter_initial_value(param: rf.Parameter, value: Union[None, Tensor, rf.RawTensorTypes]) -> None:
@@ -498,7 +502,8 @@ class TorchBackend(Backend[torch.Tensor]):
         assert isinstance(raw_param, torch.nn.Parameter)
         with torch.no_grad():
             if isinstance(value, Tensor):
-                raw_param.copy_(value.raw_tensor)
+                value_ = value.copy_compatible_to(param)
+                raw_param.copy_(value_.raw_tensor)
             elif isinstance(value, numpy.ndarray):
                 raw_param.copy_(torch.from_numpy(value))
             else:

{returnn-1.20230501.131856 → returnn-1.20230503.142906/returnn.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: returnn
-Version: 1.20230501.131856
+Version: 1.20230503.142906
 Summary: The RWTH extensible training framework for universal recurrent neural networks
 Home-page: https://github.com/rwth-i6/returnn/
 Author: Albert Zeyer

returnn-1.20230501.131856/_setup_info_generated.py

@@ -1,2 +0,0 @@
-version = '1.20230501.131856'
-long_version = '1.20230501.131856+git.d47969b'