code: def get_image_classifier_tf_v1(
      from_logits=False, 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: 10
      number of epochs: 2
      optimizer: tf.train.AdamOptimizer
  
      :param from_logits: Flag if model should predict logits (True) or probabilities (False).
      :type from_logits: `bool`
      :param load_init: Load the initial weights if True.
      :type load_init: `bool`
      :param sess: Computation session.
      :type sess: `tf.Session`
      :return: TensorFlowClassifier, tf.Session()
      """
      # pylint: disable=E0401
      import tensorflow as tf
  
      if tf.__version__[0] == "2":
          tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR)
          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, 28, 28, 1])
      output_ph = tf.placeholder(tf.float32, shape=[None, 10])
  
      # Define the TensorFlow graph
      if load_init:
          conv = tf.layers.conv2d(
              input_ph,
              1,
              7,
              activation=tf.nn.relu,
              kernel_initializer=_tf_weights_loader(
                  "MNIST", "W", "CONV2D"
              ),
              bias_initializer=_tf_weights_loader(
                  "MNIST", "B", "CONV2D"
              ),
          )
      else:
          conv = tf.layers.conv2d(input_ph, 1, 7, activation=tf.nn.relu)
  
      conv = tf.layers.max_pooling2d(conv, 4, 4)
      flattened = tf.layers.flatten(conv)
  
      # Logits layer
      if load_init:
          logits = tf.layers.dense(
              flattened,
              10,
              kernel_initializer=_tf_weights_loader(
                  "MNIST", "W", "DENSE"
              ),
              bias_initializer=_tf_weights_loader(
                  "MNIST", "B", "DENSE"
              ),
          )
      else:
          logits = tf.layers.dense(flattened, 10)
  
      # probabilities
      probabilities = tf.keras.activations.softmax(x=logits)
  
      # Train operator
      loss = tf.reduce_mean(
          tf.losses.softmax_cross_entropy(
              logits=logits,
              onehot_labels=output_ph,
              reduction=tf.losses.Reduction.SUM,
          )
      )
      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())
  
      # Create the classifier
      if from_logits:
          tfc = TensorFlowClassifier(
              clip_values=(0, 1),
              input_ph=input_ph,
              output=logits,
              labels_ph=output_ph,
              train=train,
              loss=loss,
              learning=None,
              sess=sess,
          )
      else:
          tfc = TensorFlowClassifier(
              clip_values=(0, 1),
              input_ph=input_ph,
              output=probabilities,
              labels_ph=output_ph,
              train=train,
              loss=loss,
              learning=None,
              sess=sess,
          )
  
      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 8 for calling a global function with example usage: get_image_classifier_tf_v1(from_logits, load_init, sess) and returns: tfc,  sess