code: def main():
      gpus = tf.config.experimental.list_physical_devices("GPU")
      if gpus:
          try:
              for gpu in gpus:
                  tf.config.experimental.set_memory_growth(gpu, True)
          except RuntimeError as e:
              print(e)
              exit(-1)
  
      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 = 30
  
      # class dict
      data_class = [
          cla
          for cla in os.listdir(train_dir)
          if os.path.isdir(os.path.join(train_dir, cla))
      ]
      class_num = len(data_class)
      class_dict = dict(
          (value, index) for index, value in enumerate(data_class)
      )
  
      # reverse value and key of dict
      inverse_dict = dict((val, key) for key, val in class_dict.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)
  
      # load train images list
      train_image_list = glob.glob(train_dir + "/*/*.jpg")
      random.shuffle(train_image_list)
      train_num = len(train_image_list)
      assert train_num > 0, "cannot find any .jpg file in {}".format(
          train_dir
      )
      train_label_list = [
          class_dict[path.split(os.path.sep)[-2]]
          for path in train_image_list
      ]
  
      # load validation images list
      val_image_list = glob.glob(validation_dir + "/*/*.jpg")
      random.shuffle(val_image_list)
      val_num = len(val_image_list)
      assert val_num > 0, "cannot find any .jpg file in {}".format(
          validation_dir
      )
      val_label_list = [
          class_dict[path.split(os.path.sep)[-2]]
          for path in val_image_list
      ]
  
      print(
          "using {} images for training, {} images for validation.".format(
              train_num, val_num
          )
      )
  
      def process_train_img(img_path, label):
          label = tf.one_hot(label, depth=class_num)
          image = tf.io.read_file(img_path)
          image = tf.image.decode_jpeg(image)
          image = tf.image.convert_image_dtype(image, tf.float32)
          image = tf.image.resize(image, [im_height, im_width])
          image = tf.image.random_flip_left_right(image)
          # image = (image - 0.5) / 0.5
          image = (image - 0.5) * 2.0
          return image, label
  
      def process_val_img(img_path, label):
          label = tf.one_hot(label, depth=class_num)
          image = tf.io.read_file(img_path)
          image = tf.image.decode_jpeg(image)
          image = tf.image.convert_image_dtype(image, tf.float32)
          image = tf.image.resize(image, [im_height, im_width])
          # image = (image - 0.5) / 0.5
          image = (image - 0.5) * 2.0
          return image, label
  
      AUTOTUNE = tf.data.experimental.AUTOTUNE
  
      # load train dataset
      train_dataset = tf.data.Dataset.from_tensor_slices(
          (train_image_list, train_label_list)
      )
      train_dataset = (
          train_dataset.shuffle(buffer_size=train_num)
          .map(process_train_img, num_parallel_calls=AUTOTUNE)
          .repeat()
          .batch(batch_size)
          .prefetch(AUTOTUNE)
      )
  
      # load train dataset
      val_dataset = tf.data.Dataset.from_tensor_slices(
          (val_image_list, val_label_list)
      )
      val_dataset = (
          val_dataset.map(
              process_val_img,
              num_parallel_calls=tf.data.experimental.AUTOTUNE,
          )
          .repeat()
          .batch(batch_size)
      )
  
      # 实例化模型
      model = MobileNetV2(num_classes=5)
      pre_weights_path = "./pretrain_weights.ckpt"
      assert len(
          glob.glob(pre_weights_path + "*")
      ), "cannot find {}".format(pre_weights_path)
      model.load_weights(pre_weights_path)
      for layer_t in model.layers[:-1]:
          layer_t.trainable = False
  
      model.summary()
  
      # using keras low level api for training
      loss_object = tf.keras.losses.CategoricalCrossentropy(
          from_logits=True
      )
      optimizer = tf.keras.optimizers.Adam(learning_rate=0.0005)
  
      train_loss = tf.keras.metrics.Mean(name="train_loss")
      train_accuracy = tf.keras.metrics.CategoricalAccuracy(
          name="train_accuracy"
      )
  
      test_loss = tf.keras.metrics.Mean(name="test_loss")
      test_accuracy = tf.keras.metrics.CategoricalAccuracy(
          name="test_accuracy"
      )
  
      @tf.function
      def train_step(images, labels):
          with tf.GradientTape() as tape:
              output = model(images, training=True)
              loss = loss_object(labels, output)
          gradients = tape.gradient(loss, model.trainable_variables)
          optimizer.apply_gradients(
              zip(gradients, model.trainable_variables)
          )
  
          train_loss(loss)
          train_accuracy(labels, output)
  
      @tf.function
      def test_step(images, labels):
          output = model(images, training=False)
          t_loss = loss_object(labels, output)
  
          test_loss(t_loss)
          test_accuracy(labels, output)
  
      best_test_loss = float("inf")
      train_step_num = train_num // batch_size
      val_step_num = val_num // batch_size
      for epoch in range(1, epochs + 1):
          train_loss.reset_states()  # clear history info
          train_accuracy.reset_states()  # clear history info
          test_loss.reset_states()  # clear history info
          test_accuracy.reset_states()  # clear history info
  
          t1 = time.perf_counter()
          for index, (images, labels) in enumerate(train_dataset):
              train_step(images, labels)
              if index + 1 == train_step_num:
                  break
          print(time.perf_counter() - t1)
  
          for index, (images, labels) in enumerate(val_dataset):
              test_step(images, labels)
              if index + 1 == val_step_num:
                  break
  
          template = "Epoch {}, Loss: {}, Accuracy: {}, Test Loss: {}, Test Accuracy: {}"
          print(
              template.format(
                  epoch,
                  train_loss.result(),
                  train_accuracy.result() * 100,
                  test_loss.result(),
                  test_accuracy.result() * 100,
              )
          )
          if test_loss.result() < best_test_loss:
              model.save_weights(
                  "./save_weights/myMobileNet.ckpt".format(epoch),
                  save_format="tf",
              )
  
file_path: deep-learning-for-image-processing/tensorflow_classification/Test6_mobilenet/trainGPU_mobilenet_v2.py
imports: from model_v2 import MobileNetV2
  import tensorflow
  import json
  import os
  import time
  import glob
  import random
label_desc: Use image node_id 1 for calling a global function with example usage: main() and returns: image,  label, image,  label