class_docstr: The layer that splits images into square blocks of size `k x k x Ch` and
  writes the contents of these blocks to the corresponding pixels (`1 x 1 x Ch*k*k`) of the
  output images in channel-last ordering.
  
  As a result image of size `H x W x Ch` is transformed into images of size `H/k x W/k x Ch*k*k`.
  
  This operation is the inverse function of DepthToSpace.
  
  :param input_layers: The input layers to be connected. 
      The integer in each tuple specifies the number of the output.
      If not set, the first output will be used.
  :type input_layers: object, tuple(object, int) or list of them
  :param block_size: The size of the block (`k` from the formula).
  :type block_size: int, default=1
  :param name: The layer name.
  :type name: str, default=None
  
  .. rubric:: Layer inputs:
  
  Has single input, of the dimensions:
  
  - **BatchLength** * **BatchWidth** * **ListSize** is equal to the number of images
  - **Height** is the image height; should be a multiple of `block_size`
  - **Width** is the image width; should be a multiple of `block_size`
  - **Depth** is equal to `1`
  - **Channels** is the number of channels in the image format
  
  .. rubric:: Layer outputs:
  
  The layer has single output, of the dimensions:
  
  - **BatchLength** is equal to the input `BatchLength`
  - **BatchWidth** is equal to the input `BatchWidth`
  - **ListSize** is equal to the input `ListSize`
  - **Height** is equal to the input `Height / block_size`
  - **Width** is equal to the input `Width / block_size`
  - **Depth** is equal to `1`
  - **Channels** is equal to the input `Channels * block_size * block_size`
code: def __init__(self, input_layer, block_size=1, name=None):
      if type(input_layer) is PythonWrapper.SpaceToDepth:
          super().__init__(input_layer)
          return
  
      layers, outputs = check_input_layers(input_layer, 1)
  
      if block_size < 1:
          raise ValueError("`block_size` must be < 0.")
  
      internal = PythonWrapper.SpaceToDepth(
          str(name), layers[0], int(outputs[0]), block_size
      )
      super().__init__(internal)
  
file_path: neoml/NeoML/Python/neoml/Dnn/SpaceAndDepth.py
imports: import neoml.PythonWrapper
  from .Dnn import Layer
  from neoml.Utils import check_input_layers
  import neoml.Blob
label_desc: Use image node_id 1 to create a new SpaceToDepth object from inherited base classes: Layer with example: obj = SpaceToDepth(input_layer, block_size, name)