code: def get_image_classifier_tf_v2(from_logits=False):
      """
      Standard TensorFlow v2 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
  
      :return: TensorFlowV2Classifier
      """
      # pylint: disable=E0401
      import tensorflow as tf
      from tensorflow.keras.layers import (
          Conv2D,
          Dense,
          Flatten,
          MaxPool2D,
      )
      from tensorflow.keras.models import Sequential
  
      from art.estimators.classification.tensorflow import (
          TensorFlowV2Classifier,
      )
  
      if tf.__version__[0] != "2":
          raise ImportError("This function requires TensorFlow v2.")
  
      model = Sequential()
      model.add(
          Conv2D(
              filters=1,
              kernel_size=7,
              activation="relu",
              kernel_initializer=_tf_weights_loader(
                  "MNIST", "W", "CONV2D", 2
              ),
              bias_initializer=_tf_weights_loader(
                  "MNIST", "B", "CONV2D", 2
              ),
              input_shape=(28, 28, 1),
          )
      )
      model.add(
          MaxPool2D(
              pool_size=(4, 4),
              strides=(4, 4),
              padding="valid",
              data_format=None,
          )
      )
      model.add(Flatten())
      if from_logits:
          model.add(
              Dense(
                  10,
                  activation="linear",
                  kernel_initializer=_tf_weights_loader(
                      "MNIST", "W", "DENSE", 2
                  ),
                  bias_initializer=_tf_weights_loader(
                      "MNIST", "B", "DENSE", 2
                  ),
              )
          )
      else:
          model.add(
              Dense(
                  10,
                  activation="softmax",
                  kernel_initializer=_tf_weights_loader(
                      "MNIST", "W", "DENSE", 2
                  ),
                  bias_initializer=_tf_weights_loader(
                      "MNIST", "B", "DENSE", 2
                  ),
              )
          )
  
      loss_object = tf.keras.losses.SparseCategoricalCrossentropy(
          from_logits=from_logits,
          reduction=tf.keras.losses.Reduction.SUM,
      )
  
      optimizer = tf.keras.optimizers.legacy.Adam(learning_rate=0.01)
  
      model.compile(optimizer=optimizer, loss=loss_object)
  
      # Create the classifier
      tfc = TensorFlowV2Classifier(
          model=model,
          loss_object=loss_object,
          optimizer=optimizer,
          nb_classes=10,
          input_shape=(28, 28, 1),
          clip_values=(0, 1),
      )
  
      return tfc
  
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 11 for calling a global function with example usage: get_image_classifier_tf_v2(from_logits) and returns: tfc