code: def classifier_model(
      bert_config,
      float_type,
      num_labels,
      max_seq_length,
      final_layer_initializer=None,
      hub_module_url=None,
  ):
      """BERT classifier model in functional API style.
  
      Construct a Keras model for predicting `num_labels` outputs from an input with
      maximum sequence length `max_seq_length`.
  
      Args:
        bert_config: BertConfig, the config defines the core BERT model.
        float_type: dtype, tf.float32 or tf.bfloat16.
        num_labels: integer, the number of classes.
        max_seq_length: integer, the maximum input sequence length.
        final_layer_initializer: Initializer for final dense layer. Defaulted
          TruncatedNormal initializer.
        hub_module_url: TF-Hub path/url to Bert module.
  
      Returns:
        Combined prediction model (words, mask, type) -> (one-hot labels)
        BERT sub-model (words, mask, type) -> (bert_outputs)
      """
      if final_layer_initializer is not None:
          initializer = final_layer_initializer
      else:
          initializer = tf.keras.initializers.TruncatedNormal(
              stddev=bert_config.initializer_range
          )
  
      if not hub_module_url:
          bert_encoder = _get_transformer_encoder(
              bert_config, max_seq_length
          )
          return (
              bert_classifier.BertClassifier(
                  bert_encoder,
                  num_classes=num_labels,
                  dropout_rate=bert_config.hidden_dropout_prob,
                  initializer=initializer,
              ),
              bert_encoder,
          )
  
      input_word_ids = tf.keras.layers.Input(
          shape=(max_seq_length,), dtype=tf.int32, name="input_word_ids"
      )
      input_mask = tf.keras.layers.Input(
          shape=(max_seq_length,), dtype=tf.int32, name="input_mask"
      )
      input_type_ids = tf.keras.layers.Input(
          shape=(max_seq_length,), dtype=tf.int32, name="input_type_ids"
      )
      bert_model = hub.KerasLayer(hub_module_url, trainable=True)
      pooled_output, _ = bert_model(
          [input_word_ids, input_mask, input_type_ids]
      )
      output = tf.keras.layers.Dropout(
          rate=bert_config.hidden_dropout_prob
      )(pooled_output)
  
      output = tf.keras.layers.Dense(
          num_labels,
          kernel_initializer=initializer,
          name="output",
          dtype=float_type,
      )(output)
      return (
          tf.keras.Model(
              inputs={
                  "input_word_ids": input_word_ids,
                  "input_mask": input_mask,
                  "input_type_ids": input_type_ids,
              },
              outputs=output,
          ),
          bert_model,
      )
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import tensorflow
  import tensorflow_hub
  from utils import tf_utils
  from utils.modeling import losses
  from utils.modeling import networks
  from utils.modeling.networks import bert_classifier
  from utils.modeling.networks import bert_pretrainer
  from utils.modeling.networks import bert_span_labeler
label_desc: Use image node_id 5 for calling a global function with example usage: classifier_model(bert_config, float_type, num_labels, max_seq_length, final_layer_initializer, hub_module_url) and returns: tf,  bert_model, bert_classifier,  bert_encoder