class_docstr: This defines a network for relating large-sized input tensors to small output tensors, ie. regressing large
  values to a prediction. An output of a single dimension can be used as value regression or multi-label
  classification prediction, an output of a single value can be used as a discriminator or critic prediction.
  
  The network is constructed as a sequence of layers, either :py:class:`monai.networks.blocks.Convolution` or
  :py:class:`monai.networks.blocks.ResidualUnit`, with a final fully-connected layer resizing the output from the
  blocks to the final size. Each block is defined with a stride value typically used to downsample the input using
  strided convolutions. In this way each block progressively condenses information from the input into a deep
  representation the final fully-connected layer relates to a final result.
  
  Args:
      in_shape: tuple of integers stating the dimension of the input tensor (minus batch dimension)
      out_shape: tuple of integers stating the dimension of the final output tensor (minus batch dimension)
      channels: tuple of integers stating the output channels of each convolutional layer
      strides: tuple of integers stating the stride (downscale factor) of each convolutional layer
      kernel_size: integer or tuple of integers stating size of convolutional kernels
      num_res_units: integer stating number of convolutions in residual units, 0 means no residual units
      act: name or type defining activation layers
      norm: name or type defining normalization layers
      dropout: optional float value in range [0, 1] stating dropout probability for layers, None for no dropout
      bias: boolean stating if convolution layers should have a bias component
  
  Examples::
  
      # infers a 2-value result (eg. a 2D cartesian coordinate) from a 64x64 image
      net = Regressor((1, 64, 64), (2,), (2, 4, 8), (2, 2, 2))
code: def _get_final_layer(self, in_shape: Sequence[int]):
      linear = nn.Linear(
          int(np.prod(in_shape)), int(np.prod(self.out_shape))
      )
      return nn.Sequential(nn.Flatten(), linear)
  
file_path: MONAI/monai/networks/nets/regressor.py
imports: from __future__ import annotations
  from collections.abc import Sequence
  import numpy
  import torch
  import torch.nn
  from monai.networks.blocks import Convolution, ResidualUnit
  from monai.networks.layers.convutils import calculate_out_shape, same_padding
  from monai.networks.layers.factories import Act, Norm
  from monai.networks.layers.simplelayers import Reshape
  from monai.utils import ensure_tuple, ensure_tuple_rep
label_desc: Use image node_id 3 for calling the Regressor obj's underlying member method code with example usage: obj._get_final_layer(in_shape) and returns: nn