returnn 1.20230626.20229__tar.gz → 1.20230626.24329__tar.gz

{returnn-1.20230626.20229/returnn.egg-info → returnn-1.20230626.24329}/PKG-INFO

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

returnn-1.20230626.24329/_setup_info_generated.py

@@ -0,0 +1,2 @@
+version = '1.20230626.024329'
+long_version = '1.20230626.024329+git.70a4c6c'

{returnn-1.20230626.20229 → returnn-1.20230626.24329}/returnn/frontend/_backend.py

@@ -659,7 +659,7 @@ class Backend(Generic[T]):
     @staticmethod
     def full(
         dims: Sequence[Dim],
-        fill_value: RawTensorTypes,
+        fill_value: Union[RawTensorTypes, Tensor],
         *,
         dtype: str,
         sparse_dim: Optional[Dim] = None,

{returnn-1.20230626.20229 → returnn-1.20230626.24329}/returnn/frontend/const.py

@@ -3,7 +3,7 @@ Constant / full / fill / zeros / ones, etc
 """
 
 from __future__ import annotations
-from typing import Optional, Sequence
+from typing import Optional, Union, Sequence
 import numpy
 from returnn.tensor import Tensor, Dim
 from .types import RawTensorTypes
@@ -17,7 +17,7 @@ __all__ = ["full", "fill", "constant", "zeros", "ones", "zeros_like", "ones_like
 def full(
     *,
     dims: Sequence[Dim],
-    fill_value: RawTensorTypes,
+    fill_value: Union[RawTensorTypes, Tensor],
     dtype: Optional[str] = None,
     sparse_dim: Optional[Dim] = None,
     feature_dim: Optional[Dim] = None,
@@ -42,6 +42,8 @@ def full(
             dtype = rf.get_default_float_dtype()
         elif isinstance(fill_value, bool):
             dtype = "bool"
+        elif isinstance(fill_value, Tensor):
+            dtype = fill_value.dtype
         else:
             raise ValueError(f"cannot infer dtype from {fill_value!r} or type ({type(fill_value)})")
     if isinstance(fill_value, numpy.ndarray):
@@ -49,6 +51,10 @@ def full(
             f"full/fill/constant: expect scalar fill_value, got array with shape {fill_value.shape}.\n"
             "Use rf.convert_to_tensor to convert an arbitrary array to a tensor."
         )
+    if isinstance(fill_value, Tensor):
+        assert (
+            fill_value.dims == ()
+        ), f"full/fill/constant: expect scalar fill_value, got tensor with shape {fill_value.dims}."
     return global_backend.full(dims, fill_value, dtype=dtype, sparse_dim=sparse_dim, feature_dim=feature_dim)
 
 

{returnn-1.20230626.20229 → returnn-1.20230626.24329}/returnn/frontend/run_ctx.py

@@ -8,6 +8,7 @@ or forwarding loop.
 
 from __future__ import annotations
 from typing import Optional, Union, Any, Sequence, Dict
+import logging
 from dataclasses import dataclass
 from returnn.tensor import Tensor, Dim, TensorDict
 import returnn.frontend as rf
@@ -194,8 +195,7 @@ class RunCtx:
             ), f"mark_as_output: {name!r} dims mismatch from expected output, given {dims}, expected {expected_output}"
 
         if not isinstance(tensor, Tensor):
-            assert isinstance(tensor, _backend.global_backend.RawTensorType)
-            tensor = rf.convert_to_tensor(tensor, dims=dims)
+            tensor = _output_tensor_from_raw(tensor, dims=dims, name=name)
             # In case it was not specified, just accept whatever order we got.
             dims = tensor.dims
 
@@ -386,3 +386,30 @@ def _default_dim_order(tensor: Tensor) -> Sequence[Dim]:
     elif len(rem_dims) == 1:
         dims.append(rem_dims[0])
     return dims
+
+
+def _output_tensor_from_raw(raw_tensor, *, dims: Sequence[Dim], name: str) -> Tensor:
+    assert isinstance(raw_tensor, _backend.global_backend.RawTensorType)
+    tensor = rf.convert_to_tensor(raw_tensor, dims=dims)
+    # This is called when the user passed some raw tensor directly to mark_as_output.
+    # So e.g. in case of pure PyTorch code.
+    # In this case, it is common that the user does not explicitly specify the dyn sizes of the dim tags.
+    # We accept this, but for ONNX export and maybe other cases,
+    # we automatically fill in the dyn sizes from the raw tensor.
+    # In case the dim tag has scalar size, this is non-ambiguous,
+    # however, otherwise, it is ambiguous, so we print a warning that we always use the highest dim size.
+    for axis, dim in enumerate(tensor.dims):
+        if dim.dyn_size_ext and dim.dyn_size_ext.raw_tensor is None:
+            dim_value_raw = _backend.global_backend.get_shape_tuple_raw(raw_tensor)[axis]
+            dim_value = rf.convert_to_tensor(dim_value_raw, dims=())
+            dim_value = rf.cast(dim_value, dtype=dim.dyn_size_ext.dtype)
+            if dim.dyn_size_ext.dims:
+                dyn_size = rf.full(dims=dim.dyn_size_ext.dims, fill_value=dim_value)
+                logging.warning(
+                    f"Cannot infer dynamic size for dim {dim} from output {name!r} {tensor}."
+                    f"Using {dyn_size} as fallback."
+                )
+            else:
+                dyn_size = dim_value
+            dim.dyn_size_ext.raw_tensor = dyn_size.raw_tensor
+    return tensor

{returnn-1.20230626.20229 → returnn-1.20230626.24329}/returnn/tf/frontend_layers/_backend.py

@@ -445,13 +445,15 @@ class ReturnnLayersBackend(Backend[Layer]):
     @staticmethod
     def full(
         dims: Sequence[Dim],
-        fill_value: RawTensorTypes,
+        fill_value: Union[RawTensorTypes, Tensor],
         *,
         dtype: str,
         sparse_dim: Optional[Dim] = None,
         feature_dim: Optional[Dim] = None,
     ) -> Tensor:
         """full"""
+        if isinstance(fill_value, Tensor):
+            return fill_value + rf.zeros_like(fill_value)
         kwargs = {}
         if sparse_dim:
             kwargs["sparse_dim"] = sparse_dim

{returnn-1.20230626.20229 → returnn-1.20230626.24329}/returnn/torch/frontend/_backend.py

@@ -660,7 +660,7 @@ class TorchBackend(Backend[torch.Tensor]):
     @staticmethod
     def full(
         dims: Sequence[Dim],
-        fill_value: RawTensorTypes,
+        fill_value: Union[RawTensorTypes, Tensor],
         *,
         dtype: str,
         sparse_dim: Optional[Dim] = None,
@@ -668,6 +668,8 @@ class TorchBackend(Backend[torch.Tensor]):
     ) -> Tensor:
         """full"""
         shape = [dim.get_dim_value() for dim in dims]
+        if isinstance(fill_value, Tensor):
+            fill_value = fill_value.raw_tensor
         raw_tensor = torch.full(shape, fill_value, dtype=TorchBackend.as_dtype_raw(dtype))
         return Tensor(
             "full", dims=dims, sparse_dim=sparse_dim, feature_dim=feature_dim, dtype=dtype, raw_tensor=raw_tensor

{returnn-1.20230626.20229 → returnn-1.20230626.24329/returnn.egg-info}/PKG-INFO

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

{returnn-1.20230626.20229 → returnn-1.20230626.24329}/tests/_setup_test_env.py

@@ -63,6 +63,18 @@ def setup():
     # No propagate, use stdout directly.
     log.initialize(verbosity=[5], propagate=False)
 
+    # PyTorch is optional.
+    if "RETURNN_DISABLE_TORCH" in os.environ and int(os.environ["RETURNN_DISABLE_TORCH"]) == 1:
+        pass
+    else:
+        # Import order of TF and PyTorch can have an influence...
+        # I have a case where only this order works: torch, tensorflow
+        try:
+            # noinspection PyUnresolvedReferences,PyPackageRequirements
+            import torch
+        except ImportError:
+            pass
+
     # TF is optional.
     if "RETURNN_DISABLE_TF" in os.environ and int(os.environ["RETURNN_DISABLE_TF"]) == 1:
         tf = None
@@ -168,7 +180,6 @@ def _try_hook_into_tests():
 
     # Skip this if we are not in a debugger.
     if test_program and in_debugger:  # nosetest, unittest
-
         # Ok, try to install our plugin.
         class _ReraiseExceptionTestHookPlugin:
             @staticmethod

returnn-1.20230626.20229/_setup_info_generated.py

@@ -1,2 +0,0 @@
-version = '1.20230626.020229'
-long_version = '1.20230626.020229+git.283f125'