code: def get_tabular_classifier_tf_v1(load_init=True, sess=None):
      """
      Standard TensorFlow classifier for unit testing.
  
      The following hyper-parameters were used to obtain the weights and biases:
  
      * learning_rate: 0.01
      * batch size: 5
      * number of epochs: 200
      * optimizer: tf.train.AdamOptimizer
  
      The model is trained of 70% of the dataset, and 30% of the training set is used as validation split.
  
      :param load_init: Load the initial weights if True.
      :type load_init: `bool`
      :param sess: Computation session.
      :type sess: `tf.Session`
      :return: The trained model for Iris dataset and the session.
      :rtype: `tuple(TensorFlowClassifier, tf.Session)`
      """
      import tensorflow as tf
  
      if tf.__version__[0] == "2":
          # pylint: disable=E0401
          import tensorflow.compat.v1 as tf
  
          tf.disable_eager_execution()
      from art.estimators.classification.tensorflow import (
          TensorFlowClassifier,
      )
  
      # Define input and output placeholders
      input_ph = tf.placeholder(tf.float32, shape=[None, 4])
      output_ph = tf.placeholder(tf.int32, shape=[None, 3])
  
      # Define the TensorFlow graph
      if load_init:
          dense1 = tf.layers.dense(
              input_ph,
              10,
              kernel_initializer=_tf_weights_loader(
                  "IRIS", "W", "DENSE1"
              ),
              bias_initializer=_tf_weights_loader(
                  "IRIS", "B", "DENSE1"
              ),
          )
          dense2 = tf.layers.dense(
              dense1,
              10,
              kernel_initializer=_tf_weights_loader(
                  "IRIS", "W", "DENSE2"
              ),
              bias_initializer=_tf_weights_loader(
                  "IRIS", "B", "DENSE2"
              ),
          )
          logits = tf.layers.dense(
              dense2,
              3,
              kernel_initializer=_tf_weights_loader(
                  "IRIS", "W", "DENSE3"
              ),
              bias_initializer=_tf_weights_loader(
                  "IRIS", "B", "DENSE3"
              ),
          )
      else:
          dense1 = tf.layers.dense(input_ph, 10)
          dense2 = tf.layers.dense(dense1, 10)
          logits = tf.layers.dense(dense2, 3)
  
      # Train operator
      loss = tf.reduce_mean(
          tf.losses.softmax_cross_entropy(
              logits=logits, onehot_labels=output_ph
          )
      )
      optimizer = tf.train.AdamOptimizer(learning_rate=0.01)
      train = optimizer.minimize(loss)
  
      # TensorFlow session and initialization
      if sess is None:
          sess = tf.Session()
      elif not isinstance(sess, tf.Session):
          raise TypeError(
              "An instance of `tf.Session` should be passed to `sess`."
          )
  
      sess.run(tf.global_variables_initializer())
  
      # Train the classifier
      tfc = TensorFlowClassifier(
          clip_values=(0, 1),
          input_ph=input_ph,
          output=logits,
          labels_ph=output_ph,
          train=train,
          loss=loss,
          learning=None,
          sess=sess,
          channels_first=True,
      )
  
      return tfc, sess
  
imports: from __future__ import absolute_import, division, print_function, unicode_literals
  import json
  import logging
  import os
  import pickle
  import time
  import unittest
  import warnings
  import sklearn
  import numpy
  from art.estimators.classification.tensorflow import TensorFlowV2Classifier
  from art.estimators.encoding.tensorflow import TensorFlowEncoder
  from art.estimators.generation.tensorflow import TensorFlowGenerator, TensorFlowV2Generator
  from art.estimators.gan.tensorflow import TensorFlowV2GAN
  from art.utils import load_dataset
label_desc: Use image node_id 27 for calling a global function with example usage: get_tabular_classifier_tf_v1(load_init, sess) and returns: tfc,  sess