rec functions also hidden

Author: albertz

nn/_generate_layers.py

@@ -81,7 +81,7 @@
 }
 
 FunctionNameMap = {
-  "source": "external_data",  # but not used actually
+  "source": "external_data",  # but not used actually because blacklisted
   "norm": "normalize",
   "softmax_over_spatial": "softmax",  # generic also for normal softmax on feature
 }
@@ -236,7 +236,8 @@ def setup():
       name = camel_case_to_snake_case(name.lstrip("_"))
       if name in FunctionNameMap:
         name = FunctionNameMap[name]
-      if sig.layer_class.layer_class in LayersHidden:
+      # Also see get_module_class_name_for_layer_class for the hidden logic.
+      if sig.layer_class.layer_class in LayersHidden or sig.has_recurrent_state():
         name = "_" + name
       print("\n", file=f)
       print("# noinspection PyShadowingBuiltins,PyShadowingNames", file=f)
@@ -876,8 +877,7 @@ def get_module_class_name_for_layer_class(sig: LayerSignature) -> str:
   # LayersHidden is our explicit list.
   # When some layer is purely functional (is_functional), then we just make the function public
   # but keep the wrapped layer maker hidden.
-  # When it has recurrent state, we either have a public function in case it is functional (no params),
-  # or if not (e.g. RecLayer, TwoDLSTMLayer), we anyway better should use explicit public wrappers.
+  # When it has recurrent state, we anyway better use explicit public wrappers.
   # https://github.com/rwth-i6/returnn_common/issues/31
   if layer_class.layer_class in LayersHidden or sig.is_functional() or sig.has_recurrent_state():
     return "_" + name  # we make a public function for it, but the module is hidden

nn/_generated_layers.py

@@ -1984,18 +1984,18 @@ def make_layer_dict(self,
 
 
 # noinspection PyShadowingBuiltins,PyShadowingNames
-def window(
-           source: LayerRef,
-           *,
-           state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
-           initial_state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
-           window_size: int,
-           window_left: Optional[int] = NotSpecified,
-           window_right: Optional[int] = NotSpecified,
-           axis: str = NotSpecified,
-           padding: str = NotSpecified,
-           stride: int = NotSpecified,
-           name: Optional[Union[str, NameCtx]] = None) -> Tuple[Layer, Union[LayerRef, Any]]:
+def _window(
+            source: LayerRef,
+            *,
+            state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
+            initial_state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
+            window_size: int,
+            window_left: Optional[int] = NotSpecified,
+            window_right: Optional[int] = NotSpecified,
+            axis: str = NotSpecified,
+            padding: str = NotSpecified,
+            stride: int = NotSpecified,
+            name: Optional[Union[str, NameCtx]] = None) -> Tuple[Layer, Union[LayerRef, Any]]:
   """
   Adds a window dimension.
   By default, uses the time axis and goes over it with a sliding window.
@@ -2095,15 +2095,15 @@ def make_layer_dict(self,
 
 
 # noinspection PyShadowingBuiltins,PyShadowingNames
-def cumsum(
-           source: LayerRef,
-           *,
-           state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
-           initial_state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
-           axis: str = NotSpecified,
-           additional_left_summand_per_element: Optional[Union[str, int, float]] = NotSpecified,
-           reverse: bool = NotSpecified,
-           name: Optional[Union[str, NameCtx]] = None) -> Tuple[Layer, Union[LayerRef, Any]]:
+def _cumsum(
+            source: LayerRef,
+            *,
+            state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
+            initial_state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
+            axis: str = NotSpecified,
+            additional_left_summand_per_element: Optional[Union[str, int, float]] = NotSpecified,
+            reverse: bool = NotSpecified,
+            name: Optional[Union[str, NameCtx]] = None) -> Tuple[Layer, Union[LayerRef, Any]]:
   """
   Basically wraps tf.cumsum. Also supports that in the RecLayer.
 
@@ -6455,19 +6455,19 @@ def make_layer_dict(self,
 
 
 # noinspection PyShadowingBuiltins,PyShadowingNames
-def ken_lm_state(
-                 source: LayerRef,
-                 *,
-                 state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
-                 initial_state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
-                 lm_file: Any,
-                 vocab_file: Optional[str] = NotSpecified,
-                 vocab_unknown_label: str = NotSpecified,
-                 bpe_merge_symbol: Optional[str] = NotSpecified,
-                 input_step_offset: int = NotSpecified,
-                 dense_output: bool = NotSpecified,
-                 debug: bool = NotSpecified,
-                 name: Optional[Union[str, NameCtx]] = None) -> Tuple[Layer, Union[LayerRef, Any]]:
+def _ken_lm_state(
+                  source: LayerRef,
+                  *,
+                  state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
+                  initial_state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
+                  lm_file: Any,
+                  vocab_file: Optional[str] = NotSpecified,
+                  vocab_unknown_label: str = NotSpecified,
+                  bpe_merge_symbol: Optional[str] = NotSpecified,
+                  input_step_offset: int = NotSpecified,
+                  dense_output: bool = NotSpecified,
+                  debug: bool = NotSpecified,
+                  name: Optional[Union[str, NameCtx]] = None) -> Tuple[Layer, Union[LayerRef, Any]]:
   """
   Get next word (or subword) each frame,
   accumulates string,
@@ -6565,14 +6565,14 @@ def make_layer_dict(self,
 
 
 # noinspection PyShadowingBuiltins,PyShadowingNames
-def edit_distance_table(
-                        source: LayerRef,
-                        *,
-                        state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
-                        initial_state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
-                        debug: bool = NotSpecified,
-                        blank_idx: Optional[int] = NotSpecified,
-                        name: Optional[Union[str, NameCtx]] = None) -> Tuple[Layer, Union[LayerRef, Any]]:
+def _edit_distance_table(
+                         source: LayerRef,
+                         *,
+                         state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
+                         initial_state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
+                         debug: bool = NotSpecified,
+                         blank_idx: Optional[int] = NotSpecified,
+                         name: Optional[Union[str, NameCtx]] = None) -> Tuple[Layer, Union[LayerRef, Any]]:
   """
   Given a source and a target, calculates the edit distance table between them.
   Source can be inside a recurrent loop.
@@ -6730,13 +6730,13 @@ def make_layer_dict(self,
 
 
 # noinspection PyShadowingBuiltins,PyShadowingNames
-def unmask(
-           source: LayerRef,
-           *,
-           state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
-           initial_state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
-           mask: LayerRef,
-           name: Optional[Union[str, NameCtx]] = None) -> Tuple[Layer, Union[LayerRef, Any]]:
+def _unmask(
+            source: LayerRef,
+            *,
+            state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
+            initial_state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
+            mask: LayerRef,
+            name: Optional[Union[str, NameCtx]] = None) -> Tuple[Layer, Union[LayerRef, Any]]:
   """
   This is meant to be used together with :class:`MaskedComputationLayer`,
   which operates on input [B,T,D], and given a mask, returns [B,T',D'].
@@ -7002,13 +7002,13 @@ def make_layer_dict(self,
 
 
 # noinspection PyShadowingBuiltins,PyShadowingNames
-def cum_concat(
-               source: LayerRef,
-               *,
-               state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
-               initial_state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
-               new_dim: DimensionTag,
-               name: Optional[Union[str, NameCtx]] = None) -> Tuple[Layer, Union[LayerRef, Any]]:
+def _cum_concat(
+                source: LayerRef,
+                *,
+                state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
+                initial_state: Optional[Union[LayerRef, Dict[str, LayerRef], NotSpecified]] = NotSpecified,
+                new_dim: DimensionTag,
+                name: Optional[Union[str, NameCtx]] = None) -> Tuple[Layer, Union[LayerRef, Any]]:
   """
   Concatenates all previous frames of a time-axis.
   Like :class:`CumsumLayer` uses `sum`, this layer uses `concat`.