code: def _create_model(self):
      # Dnn part
      with tf.variable_scope("dnn"):
          # input layer
          with tf.variable_scope(
              "input_from_feature_columns",
              partitioner=self._input_layer_partitioner,
              reuse=tf.AUTO_REUSE,
          ):
              if self._adaptive_emb and not self.tf:
                  """Adaptive Embedding Feature Part 1 of 2"""
                  adaptive_mask_tensors = {}
                  for col in CATEGORICAL_COLUMNS:
                      adaptive_mask_tensors[col] = tf.ones(
                          [args.batch_size], tf.int32
                      )
                  net = tf.feature_column.input_layer(
                      features=self._feature,
                      feature_columns=self._deep_column,
                      adaptive_mask_tensors=adaptive_mask_tensors,
                  )
              else:
                  net = tf.feature_column.input_layer(
                      features=self._feature,
                      feature_columns=self._deep_column,
                  )
              self._add_layer_summary(net, "input_from_feature_columns")
  
          # hidden layers
          dnn_scope = tf.variable_scope(
              "dnn_layers",
              partitioner=self._dense_layer_partitioner,
              reuse=tf.AUTO_REUSE,
          )
          with dnn_scope.keep_weights(
              dtype=tf.float32
          ) if self.bf16 else dnn_scope:
              if self.bf16:
                  net = tf.cast(net, dtype=tf.bfloat16)
  
              net = self._dnn(
                  net, self._dnn_hidden_units, "hiddenlayer"
              )
  
              if self.bf16:
                  net = tf.cast(net, dtype=tf.float32)
  
              # dnn logits
              logits_scope = tf.variable_scope("logits")
              with logits_scope.keep_weights(
                  dtype=tf.float32
              ) if self.bf16 else logits_scope as dnn_logits_scope:
                  dnn_logits = tf.layers.dense(
                      net,
                      units=1,
                      activation=None,
                      name=dnn_logits_scope,
                  )
                  self._add_layer_summary(
                      dnn_logits, dnn_logits_scope.name
                  )
  
      # linear part
      with tf.variable_scope(
          "linear", partitioner=self._dense_layer_partitioner
      ) as scope:
          linear_logits = tf.feature_column.linear_model(
              units=1,
              features=self._feature,
              feature_columns=self._wide_column,
              sparse_combiner="sum",
              weight_collections=None,
              trainable=True,
          )
  
          self._add_layer_summary(linear_logits, scope.name)
  
      self._logits = tf.add_n([dnn_logits, linear_logits])
      self.probability = tf.math.sigmoid(self._logits)
      self.output = tf.round(self.probability)
  
imports: import time
  import argparse
  import tensorflow
  import os
  import sys
  import math
  import collections
  from tensorflow.python.client import timeline
  import json
  from tensorflow.python.ops import partitioned_variables
  import ray
  from bigdl.dllib.utils.log4Error import *
  from bigdl.orca import init_orca_context, stop_orca_context, OrcaContext
  from bigdl.orca.data.utils import process_spark_xshards
  from bigdl.orca.learn.utils import maybe_dataframe_to_xshards
  from bigdl.friesian.feature import FeatureTable
label_desc: Use image node_id 4 for calling the WDL obj's underlying member method code with example usage: obj._create_model() without return types