code: def Unet(
      backbone_name="vgg16",
      input_shape=(None, None, 3),
      classes=1,
      activation="sigmoid",
      weights=None,
      encoder_weights="imagenet",
      encoder_freeze=False,
      encoder_features="default",
      decoder_block_type="upsampling",
      decoder_filters=(256, 128, 64, 32, 16),
      decoder_use_batchnorm=True,
      **kwargs,
  ):
      """Unet_ is a fully convolution neural network for image semantic segmentation
  
      Args:
          backbone_name: name of classification model (without last dense layers) used as feature
              extractor to build segmentation model.
          input_shape: shape of input data/image ``(H, W, C)``, in general
              case you do not need to set ``H`` and ``W`` shapes, just pass ``(None, None, C)`` to make your model be
              able to process images af any size, but ``H`` and ``W`` of input images should be divisible by factor ``32``.
          classes: a number of classes for output (output shape - ``(h, w, classes)``).
          activation: name of one of ``keras.activations`` for last model layer
              (e.g. ``sigmoid``, ``softmax``, ``linear``).
          weights: optional, path to model weights.
          encoder_weights: one of ``None`` (random initialization), ``imagenet`` (pre-training on ImageNet).
          encoder_freeze: if ``True`` set all layers of encoder (backbone model) as non-trainable.
          encoder_features: a list of layer numbers or names starting from top of the model.
              Each of these layers will be concatenated with corresponding decoder block. If ``default`` is used
              layer names are taken from ``DEFAULT_SKIP_CONNECTIONS``.
          decoder_block_type: one of blocks with following layers structure:
  
              - `upsampling`:  ``UpSampling2D`` -> ``Conv2D`` -> ``Conv2D``
              - `transpose`:   ``Transpose2D`` -> ``Conv2D``
  
          decoder_filters: list of numbers of ``Conv2D`` layer filters in decoder blocks
          decoder_use_batchnorm: if ``True``, ``BatchNormalisation`` layer between ``Conv2D`` and ``Activation`` layers
              is used.
  
      Returns:
          ``keras.models.Model``: **Unet**
  
      .. _Unet:
          https://arxiv.org/pdf/1505.04597
  
      """
  
      global backend, layers, models, keras_utils
      submodule_args = filter_keras_submodules(kwargs)
      backend, layers, models, keras_utils = get_submodules_from_kwargs(
          submodule_args
      )
  
      if decoder_block_type == "upsampling":
          decoder_block = DecoderUpsamplingX2Block
      elif decoder_block_type == "transpose":
          decoder_block = DecoderTransposeX2Block
      else:
          raise ValueError(
              'Decoder block type should be in ("upsampling", "transpose"). '
              "Got: {}".format(decoder_block_type)
          )
  
      backbone = Backbones.get_backbone(
          backbone_name,
          input_shape=input_shape,
          weights=encoder_weights,
          include_top=False,
          **kwargs,
      )
  
      if encoder_features == "default":
          encoder_features = Backbones.get_feature_layers(
              backbone_name, n=4
          )
  
      model = build_unet(
          backbone=backbone,
          decoder_block=decoder_block,
          skip_connection_layers=encoder_features,
          decoder_filters=decoder_filters,
          classes=classes,
          activation=activation,
          n_upsample_blocks=len(decoder_filters),
          use_batchnorm=decoder_use_batchnorm,
      )
  
      # lock encoder weights for fine-tuning
      if encoder_freeze:
          freeze_model(backbone, **kwargs)
  
      # loading model weights
      if weights is not None:
          model.load_weights(weights)
  
      return model
  
file_path: segmentation_models/segmentation_models/models/unet.py
imports: from keras_applications import get_submodules_from_kwargs
  from ._common_blocks import Conv2dBn
  from ._utils import freeze_model, filter_keras_submodules
  from ..backbones.backbones_factory import Backbones
label_desc: Use image node_id 6 for calling a global function with example usage: Unet(backbone_name, input_shape, classes, activation, weights, encoder_weights, encoder_freeze, encoder_features, decoder_block_type, decoder_filters, decoder_use_batchnorm) and returns: model