code: def get_image_classifier_kr_tf(
      loss_name="categorical_crossentropy",
      loss_type="function",
      from_logits=False,
  ):
      """
      Standard Keras classifier for unit testing
  
      The weights and biases are identical to the TensorFlow model in get_classifier_tf().
  
      :param loss_name: The name of the loss function.
      :type loss_name: `str`
      :param loss_type: The type of loss function definitions: label (loss function defined by string of its name),
                        function_losses (loss function), class (loss function generator)
      :type loss_type: `str`
      :param from_logits: Flag if model should predict logits (True) or probabilities (False).
      :type from_logits: `bool`
  
  
      :return: KerasClassifier
      """
      # pylint: disable=E0401
      import tensorflow as tf
  
      if tf.__version__[0] == "2":
          tf.compat.v1.disable_eager_execution()
      from tensorflow.keras.layers import (
          Conv2D,
          Dense,
          Flatten,
          MaxPooling2D,
      )
      from tensorflow.keras.models import Sequential
  
      from art.estimators.classification.keras import KerasClassifier
  
      # Create simple CNN
      model = Sequential()
      model.add(
          Conv2D(
              1,
              kernel_size=(7, 7),
              activation="relu",
              input_shape=(28, 28, 1),
          )
      )
      model.layers[-1].set_weights(
          [
              _kr_tf_weights_loader("MNIST", "W", "CONV2D"),
              _kr_tf_weights_loader("MNIST", "B", "CONV2D"),
          ]
      )
      model.add(MaxPooling2D(pool_size=(4, 4)))
      model.add(Flatten())
  
      if from_logits:
          model.add(Dense(10, activation="linear"))
      else:
          model.add(Dense(10, activation="softmax"))
  
      model.layers[-1].set_weights(
          [
              _kr_tf_weights_loader("MNIST", "W", "DENSE"),
              _kr_tf_weights_loader("MNIST", "B", "DENSE"),
          ]
      )
  
      loss = None
  
      if loss_name == "categorical_hinge":
          if loss_type == "label":
              loss = loss_name
          elif loss_type == "function":
              loss = tf.keras.losses.categorical_hinge
          elif loss_type == "class":
              try:
                  reduction = tf.keras.losses.Reduction.NONE
              except AttributeError:
                  try:
                      reduction = tf.losses.Reduction.NONE
                  except AttributeError:
                      try:
                          reduction = (
                              tf.python.keras.utils.losses_utils.ReductionV2.NONE
                          )
                      except AttributeError:
                          raise ImportError(
                              "This combination of loss function options is not supported."
                          )
              loss = tf.keras.losses.CategoricalHinge(
                  reduction=reduction
              )
      elif loss_name == "categorical_crossentropy":
          if loss_type == "label":
              if from_logits:
                  raise AttributeError
              else:
                  loss = loss_name
          elif loss_type == "function":
              if from_logits:
  
                  def categorical_crossentropy(y_true, y_pred):
                      return tf.keras.losses.categorical_crossentropy(
                          y_true, y_pred, from_logits=True
                      )
  
                  loss = categorical_crossentropy
              else:
                  loss = tf.keras.losses.categorical_crossentropy
          elif loss_type == "class":
              try:
                  reduction = tf.keras.losses.Reduction.NONE
              except AttributeError:
                  try:
                      reduction = tf.losses.Reduction.NONE
                  except AttributeError:
                      try:
                          reduction = (
                              tf.python.keras.utils.losses_utils.ReductionV2.NONE
                          )
                      except AttributeError:
                          raise ImportError(
                              "This combination of loss function options is not supported."
                          )
              loss = tf.keras.losses.CategoricalCrossentropy(
                  from_logits=from_logits, reduction=reduction
              )
      elif loss_name == "sparse_categorical_crossentropy":
          if loss_type == "label":
              if from_logits:
                  raise AttributeError
              else:
                  loss = loss_name
          elif loss_type == "function":
              if from_logits:
  
                  def sparse_categorical_crossentropy(y_true, y_pred):
                      return tf.keras.losses.sparse_categorical_crossentropy(
                          y_true, y_pred, from_logits=True
                      )
  
                  loss = sparse_categorical_crossentropy
              else:
                  loss = tf.keras.losses.sparse_categorical_crossentropy
          elif loss_type == "class":
              try:
                  reduction = tf.keras.losses.Reduction.NONE
              except AttributeError:
                  try:
                      reduction = tf.losses.Reduction.NONE
                  except AttributeError:
                      try:
                          reduction = (
                              tf.python.keras.utils.losses_utils.ReductionV2.NONE
                          )
                      except AttributeError:
                          raise ImportError(
                              "This combination of loss function options is not supported."
                          )
              loss = tf.keras.losses.SparseCategoricalCrossentropy(
                  from_logits=from_logits, reduction=reduction
              )
      elif loss_name == "kullback_leibler_divergence":
          if loss_type == "label":
              loss = loss_name
          elif loss_type == "function":
              loss = tf.keras.losses.kullback_leibler_divergence
          elif loss_type == "class":
              try:
                  reduction = tf.keras.losses.Reduction.NONE
              except AttributeError:
                  try:
                      reduction = tf.losses.Reduction.NONE
                  except AttributeError:
                      try:
                          reduction = (
                              tf.python.keras.utils.losses_utils.ReductionV2.NONE
                          )
                      except AttributeError:
                          raise ImportError(
                              "This combination of loss function options is not supported."
                          )
              loss = tf.keras.losses.KLDivergence(reduction=reduction)
      elif loss_name == "cosine_similarity":
          if loss_type == "label":
              loss = loss_name
          elif loss_type == "function":
              loss = tf.keras.losses.cosine_similarity
          elif loss_type == "class":
              try:
                  reduction = tf.keras.losses.Reduction.NONE
              except AttributeError:
                  try:
                      reduction = tf.losses.Reduction.NONE
                  except AttributeError:
                      try:
                          reduction = (
                              tf.python.keras.utils.losses_utils.ReductionV2.NONE
                          )
                      except AttributeError:
                          raise ImportError(
                              "This combination of loss function options is not supported."
                          )
              loss = tf.keras.losses.CosineSimilarity(
                  reduction=reduction
              )
  
      else:
          raise ValueError("Loss name not recognised.")
  
      model.compile(
          loss=loss,
          optimizer=tf.keras.optimizers.legacy.Adam(lr=0.01),
          metrics=["accuracy"],
      )
  
      # Get classifier
      krc = KerasClassifier(
          model, clip_values=(0, 1), use_logits=from_logits
      )
  
      return krc
  
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 15 for calling a global function with example usage: get_image_classifier_kr_tf(loss_name, loss_type, from_logits) and returns: krc, tf, tf