code: def get_tabular_classifier_kr(load_init=True):
      """
      Standard Keras classifier for unit testing on Iris dataset. The weights and biases are identical to the TensorFlow
      model in `get_iris_classifier_tf`.
  
      :param load_init: Load the initial weights if True.
      :type load_init: `bool`
      :return: The trained model for Iris dataset and the session.
      :rtype: `tuple(KerasClassifier, tf.Session)`
      """
      import tensorflow as tf
  
      tf_version = [int(v) for v in tf.__version__.split(".")]
      if tf_version[0] == 2 and tf_version[1] >= 3:
          is_tf23_keras24 = True
          tf.compat.v1.disable_eager_execution()
          from tensorflow import keras
          from tensorflow.keras.layers import Dense
          from tensorflow.keras.models import Sequential
      else:
          is_tf23_keras24 = False
          import keras
          from keras.models import Sequential
          from keras.layers import Dense
  
      from art.estimators.classification.keras import KerasClassifier
  
      # Create simple CNN
      model = Sequential()
  
      if load_init:
          if is_tf23_keras24:
              model.add(
                  Dense(
                      10,
                      input_shape=(4,),
                      activation="relu",
                      kernel_initializer=_tf_weights_loader(
                          "IRIS", "W", "DENSE1", 2
                      ),
                      bias_initializer=_tf_weights_loader(
                          "IRIS", "B", "DENSE1", 2
                      ),
                  )
              )
              model.add(
                  Dense(
                      10,
                      activation="relu",
                      kernel_initializer=_tf_weights_loader(
                          "IRIS", "W", "DENSE2", 2
                      ),
                      bias_initializer=_tf_weights_loader(
                          "IRIS", "B", "DENSE2", 2
                      ),
                  )
              )
              model.add(
                  Dense(
                      3,
                      activation="softmax",
                      kernel_initializer=_tf_weights_loader(
                          "IRIS", "W", "DENSE3", 2
                      ),
                      bias_initializer=_tf_weights_loader(
                          "IRIS", "B", "DENSE3", 2
                      ),
                  )
              )
          else:
              model.add(
                  Dense(
                      10,
                      input_shape=(4,),
                      activation="relu",
                      kernel_initializer=_kr_weights_loader(
                          "IRIS", "W", "DENSE1"
                      ),
                      bias_initializer=_kr_weights_loader(
                          "IRIS", "B", "DENSE1"
                      ),
                  )
              )
              model.add(
                  Dense(
                      10,
                      activation="relu",
                      kernel_initializer=_kr_weights_loader(
                          "IRIS", "W", "DENSE2"
                      ),
                      bias_initializer=_kr_weights_loader(
                          "IRIS", "B", "DENSE2"
                      ),
                  )
              )
              model.add(
                  Dense(
                      3,
                      activation="softmax",
                      kernel_initializer=_kr_weights_loader(
                          "IRIS", "W", "DENSE3"
                      ),
                      bias_initializer=_kr_weights_loader(
                          "IRIS", "B", "DENSE3"
                      ),
                  )
              )
      else:
          model.add(Dense(10, input_shape=(4,), activation="relu"))
          model.add(Dense(10, activation="relu"))
          model.add(Dense(3, activation="softmax"))
  
      model.compile(
          loss="categorical_crossentropy",
          optimizer=keras.optimizers.legacy.Adam(lr=0.001),
          metrics=["accuracy"],
      )
  
      # Get classifier
      krc = KerasClassifier(
          model,
          clip_values=(0, 1),
          use_logits=False,
          channels_first=True,
      )
  
      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 30 for calling a global function with example usage: get_tabular_classifier_kr(load_init) and returns: krc