code: def _tabular_model(
      name,
      train_data,
      multilabel=None,
      is_regression=False,
      metrics=None,
      hidden_layers=[1000, 500],
      hidden_dropouts=[0.0, 0.5],
      bn=False,
      verbose=1,
  ):
      """
      ```
      Build and return a classification or regression model for tabular data
  
      Args:
          name (string): currently accepts 'mlp' for multilayer perceptron
          train_data (TabularDataset): TabularDataset instance returned from one of the tabular_from_* functions
          multilabel (bool):  If True, multilabel model will be returned.
                              If false, binary/multiclass model will be returned.
                              If None, multilabel will be inferred from data.
          is_regression(bool): If True, will build a regression model, else classification model.
          metrics(list): List of metrics to use.  If None: 'accuracy' is used for binar/multiclass,
                         'binary_accuracy' is used for multilabel classification, and 'mae' is used for regressio
          hidden_layers(list): number of units in each hidden layer of NN
          hidden_dropouts(list): Dropout values after each hidden layer of NN
          bn(bool): If True, BatchNormalization will be used before each fully-connected layer in NN
          verbose (boolean): verbosity of output
      Return:
          model (Model): A Keras Model instance
      ```
      """
  
      # check arguments
      if not U.is_tabular_from_data(train_data):
          err = """
              Please pass training data in the form of data returned from a ktrain tabular_from* function.
              """
          raise Exception(err)
      if len(hidden_layers) != len(hidden_dropouts):
          raise ValueError(
              "len(hidden_layers) must equal len(hidden_dropouts)"
          )
  
      # reformat dropouts for each of construction
      output_dropout = hidden_dropouts[1]
      hidden_dropouts[1] = hidden_dropouts[0]
      hidden_dropouts[0] = 0.0
  
      # set model configuration values
      if is_regression:  # regression
          if metrics is None or metrics == ["accuracy"]:
              metrics = ["mae"]
          num_classes = 1
          multilabel = False
          loss_func = "mse"
          activation = "linear"
      else:  # classification
          # set metrics
          if multilabel and metrics is None:
              metrics = ["binary_accuracy"]
          elif metrics is None:
              metrics = ["accuracy"]
  
          # set number of classes and multilabel flag
          num_classes = U.nclasses_from_data(train_data)
  
          # determine multilabel
          if multilabel is None:
              multilabel = U.is_multilabel(train_data)
          U.vprint("Is Multi-Label? %s" % (multilabel), verbose=verbose)
  
          # set loss and activations
          loss_func = "categorical_crossentropy"
          activation = "softmax"
          if multilabel:
              loss_func = "binary_crossentropy"
              activation = "sigmoid"
  
      # construct model
  
      ilayers = []
      n_cat = len(train_data.cat_columns)
      n_cont = len(train_data.cont_columns)
      if n_cat == 0 and n_cont == 0:
          raise ValueError(
              "There are zero continuous and cateorical variables."
          )
  
      # categorical inputs and embeddings
      if n_cat > 0:
          emblayers = []
          num_uniques = [
              max(c.cat.codes.values + 1) + 1
              for n, c in train_data.df[train_data.cat_columns].items()
          ]
          for i in range(n_cat):
              inp = keras.layers.Input(shape=(1,))
              ilayers.append(inp)
              emb_size = min(50, (num_uniques[i] // 2) + 1)
              # emb_size = min(600, round(1.6 * num_uniques[i]**0.56))
              emb = keras.layers.Embedding(
                  num_uniques[i], emb_size, input_length=1
              )(inp)
              emblayers.append(emb)
          x = (
              keras.layers.concatenate(emblayers)
              if len(emblayers) > 1
              else emblayers[0]
          )
          x = keras.layers.Flatten()(x)
  
      # continuous inputs
      if n_cont > 0:
          x_cont = keras.layers.Input(shape=(n_cont,))
          ilayers.append(x_cont)
          x = (
              keras.layers.concatenate([x, x_cont])
              if n_cat > 0
              else x_cont
          )
  
      # hidden layers
      output = x
      for i, n_out in enumerate(hidden_layers):
          output = bn_drop_lin(
              output, n_out, bn=bn, p=hidden_dropouts[i], actn="relu"
          )
  
      # output layer
      output = bn_drop_lin(
          output, num_classes, bn=bn, p=output_dropout, actn=activation
      )
  
      # construct and compile model
      model = keras.Model(inputs=ilayers, outputs=output)
      model.compile(
          optimizer=U.DEFAULT_OPT, loss=loss_func, metrics=metrics
      )
      U.vprint("done.", verbose=verbose)
      return model
  
file_path: ktrain/ktrain/tabular/models.py
imports: from ..None import utils
  from ..imports import *
  from ..models import bn_drop_lin
label_desc: Use image node_id 3 for calling a global function with example usage: _tabular_model(name, train_data, multilabel, is_regression, metrics, hidden_layers, hidden_dropouts, bn, verbose) and returns: model