code: def main():
      data_root = os.path.abspath(
          os.path.join(os.getcwd(), "../..")
      )  # get data root path
      image_path = os.path.join(
          data_root, "data_set", "flower_data"
      )  # flower data set path
      train_dir = os.path.join(image_path, "train")
      validation_dir = os.path.join(image_path, "val")
      assert os.path.exists(train_dir), "cannot find {}".format(
          train_dir
      )
      assert os.path.exists(validation_dir), "cannot find {}".format(
          validation_dir
      )
  
      # create direction for saving weights
      if not os.path.exists("save_weights"):
          os.makedirs("save_weights")
  
      im_height = 224
      im_width = 224
      batch_size = 32
      epochs = 10
  
      # data generator with data augmentation
      train_image_generator = ImageDataGenerator(
          rescale=1.0 / 255, horizontal_flip=True
      )
      validation_image_generator = ImageDataGenerator(rescale=1.0 / 255)
  
      train_data_gen = train_image_generator.flow_from_directory(
          directory=train_dir,
          batch_size=batch_size,
          shuffle=True,
          target_size=(im_height, im_width),
          class_mode="categorical",
      )
      total_train = train_data_gen.n
  
      # get class dict
      class_indices = train_data_gen.class_indices
  
      # transform value and key of dict
      inverse_dict = dict(
          (val, key) for key, val in class_indices.items()
      )
      # write dict into json file
      json_str = json.dumps(inverse_dict, indent=4)
      with open("class_indices.json", "w") as json_file:
          json_file.write(json_str)
  
      val_data_gen = validation_image_generator.flow_from_directory(
          directory=validation_dir,
          batch_size=batch_size,
          shuffle=False,
          target_size=(im_height, im_width),
          class_mode="categorical",
      )
      total_val = val_data_gen.n
      print(
          "using {} images for training, {} images for validation.".format(
              total_train, total_val
          )
      )
  
      model = vgg("vgg16", im_height, im_width, num_classes=5)
      model.summary()
  
      # using keras high level api for training
      model.compile(
          optimizer=tf.keras.optimizers.Adam(learning_rate=0.0001),
          loss=tf.keras.losses.CategoricalCrossentropy(
              from_logits=False
          ),
          metrics=["accuracy"],
      )
  
      callbacks = [
          tf.keras.callbacks.ModelCheckpoint(
              filepath="./save_weights/myVGG.h5",
              save_best_only=True,
              save_weights_only=True,
              monitor="val_loss",
          )
      ]
  
      # tensorflow2.1 recommend to using fit
      history = model.fit(
          x=train_data_gen,
          steps_per_epoch=total_train // batch_size,
          epochs=epochs,
          validation_data=val_data_gen,
          validation_steps=total_val // batch_size,
          callbacks=callbacks,
      )
  
      # plot loss and accuracy image
      history_dict = history.history
      train_loss = history_dict["loss"]
      train_accuracy = history_dict["accuracy"]
      val_loss = history_dict["val_loss"]
      val_accuracy = history_dict["val_accuracy"]
  
      # figure 1
      plt.figure()
      plt.plot(range(epochs), train_loss, label="train_loss")
      plt.plot(range(epochs), val_loss, label="val_loss")
      plt.legend()
      plt.xlabel("epochs")
      plt.ylabel("loss")
  
      # figure 2
      plt.figure()
      plt.plot(range(epochs), train_accuracy, label="train_accuracy")
      plt.plot(range(epochs), val_accuracy, label="val_accuracy")
      plt.legend()
      plt.xlabel("epochs")
      plt.ylabel("accuracy")
      plt.show()
  
imports: from tensorflow.keras.preprocessing.image import ImageDataGenerator
  import matplotlib.pyplot
  from model import vgg
  import tensorflow
  import json
  import os
label_desc: Use image node_id 1 for calling a global function with example usage: main() without return types