def main(): for DOMAIN in domains: domain_file = DOMAINS_PATH + DOMAIN + "/" + DOMAIN_FILE problem_file_path = DOMAINS_PATH + DOMAIN + "/" + PROBLEM_DIR + "/*.pddl" problem_file_l = glob.glob(problem_file_path) problem_file_list = sorted(problem_file_l) all_states = [] for problem_file in problem_file_list: _, _, _, _, objects, _, init_state, domain_name = generate_ds( domain_file, problem_file) run_ff(domain_file, problem_file, GEN_RESULT_FILE) f = open(GEN_RESULT_FILE, "r") _plan_found = False _plan = "" step = 0 for x in f: if "found legal plan as follows" in x: _plan_found = True if not _plan_found: continue if str(step) + ":" in x: k = copy.deepcopy(x) _plan += str(step) + " : (" + k.lower().rstrip().split( ":")[-1].lstrip() + ")\n" step += 1 if "time spent" in x: break f.close() f = open(GEN_PLAN_FILE, "w") f.write(_plan) f.close() states = get_state_from_val(domain_file, problem_file, GEN_PLAN_FILE, objects, init_state) all_states.extend(states) if len(all_states) >= STORED_STATES_COUNT: break with open(RANDOM_STATE_FOLDER + "random_" + DOMAIN + ".pkl", "wb") as f: pickle.dump(all_states[0:STORED_STATES_COUNT + 1], f)
def main(): data_root = "/data/flower_photos" # get data root path if not os.path.exists("./save_weights"): os.makedirs("./save_weights") img_size = {"s": [300, 384], # train_size, val_size "m": [384, 480], "l": [384, 480]} num_model = "s" batch_size = 8 epochs = 30 num_classes = 5 freeze_layers = True initial_lr = 0.01 log_dir = "./logs/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S") train_writer = tf.summary.create_file_writer(os.path.join(log_dir, "train")) val_writer = tf.summary.create_file_writer(os.path.join(log_dir, "val")) # data generator with data augmentation train_ds, val_ds = generate_ds(data_root, train_im_height=img_size[num_model][0], train_im_width=img_size[num_model][0], val_im_height=img_size[num_model][1], val_im_width=img_size[num_model][1], batch_size=batch_size) # create model model = create_model(num_classes=num_classes) model.build((1, img_size[num_model][0], img_size[num_model][0], 3)) # 下载我提前转好的预训练权重 # 链接: https://pan.baidu.com/s/1Pr-pO5sQVySPQnBY8pQH7w 密码: f6hi # load weights pre_weights_path = './efficientnetv2-s.h5' assert os.path.exists(pre_weights_path), "cannot find {}".format(pre_weights_path) model.load_weights(pre_weights_path, by_name=True, skip_mismatch=True) # freeze bottom layers if freeze_layers: unfreeze_layers = "head" for layer in model.layers: if unfreeze_layers not in layer.name: layer.trainable = False else: print("training {}".format(layer.name)) model.summary() # custom learning rate curve def scheduler(now_epoch): end_lr_rate = 0.01 # end_lr = initial_lr * end_lr_rate rate = ((1 + math.cos(now_epoch * math.pi / epochs)) / 2) * (1 - end_lr_rate) + end_lr_rate # cosine new_lr = rate * initial_lr # writing lr into tensorboard with train_writer.as_default(): tf.summary.scalar('learning rate', data=new_lr, step=epoch) return new_lr # using keras low level api for training loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) optimizer = tf.keras.optimizers.SGD(learning_rate=initial_lr, momentum=0.9) train_loss = tf.keras.metrics.Mean(name='train_loss') train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy') val_loss = tf.keras.metrics.Mean(name='val_loss') val_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='val_accuracy') @tf.function def train_step(train_images, train_labels): with tf.GradientTape() as tape: output = model(train_images, training=True) loss = loss_object(train_labels, output) gradients = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(zip(gradients, model.trainable_variables)) train_loss(loss) train_accuracy(train_labels, output) @tf.function def val_step(val_images, val_labels): output = model(val_images, training=False) loss = loss_object(val_labels, output) val_loss(loss) val_accuracy(val_labels, output) best_val_acc = 0. for epoch in range(epochs): train_loss.reset_states() # clear history info train_accuracy.reset_states() # clear history info val_loss.reset_states() # clear history info val_accuracy.reset_states() # clear history info # train train_bar = tqdm(train_ds, file=sys.stdout) for images, labels in train_bar: train_step(images, labels) # print train process train_bar.desc = "train epoch[{}/{}] loss:{:.3f}, acc:{:.3f}".format(epoch + 1, epochs, train_loss.result(), train_accuracy.result()) # update learning rate optimizer.learning_rate = scheduler(epoch) # validate val_bar = tqdm(val_ds, file=sys.stdout) for images, labels in val_bar: val_step(images, labels) # print val process val_bar.desc = "valid epoch[{}/{}] loss:{:.3f}, acc:{:.3f}".format(epoch + 1, epochs, val_loss.result(), val_accuracy.result()) # writing training loss and acc with train_writer.as_default(): tf.summary.scalar("loss", train_loss.result(), epoch) tf.summary.scalar("accuracy", train_accuracy.result(), epoch) # writing validation loss and acc with val_writer.as_default(): tf.summary.scalar("loss", val_loss.result(), epoch) tf.summary.scalar("accuracy", val_accuracy.result(), epoch) # only save best weights if val_accuracy.result() > best_val_acc: best_val_acc = val_accuracy.result() save_name = "./save_weights/efficientnetv2.ckpt" model.save_weights(save_name, save_format="tf")
def main(): data_root = "D:/My_code/pythonProject/deep-learning-for-image-processing-master/data_set/flower_data/flower_photos" # get data root path if not os.path.exists("./save_weights"): os.makedirs("./save_weights") im_height = 224 im_width = 224 batch_size = 16 epochs = 20 num_classes = 5 # data generator with data augmentation train_ds, val_ds = generate_ds(data_root, im_height, im_width, batch_size) # create model model = mobilenet_v3_large(input_shape=(im_height, im_width, 3), num_classes=num_classes, include_top=True) # load weights pre_weights_path = './weights_mobilenet_v3_large_224_1.0_float.h5' assert os.path.exists(pre_weights_path), "cannot find {}".format( pre_weights_path) model.load_weights(pre_weights_path, by_name=True, skip_mismatch=True) # freeze layer, only training 2 last layers for layer in model.layers: if layer.name not in ["Conv_2", "Logits/Conv2d_1c_1x1"]: layer.trainable = False else: print("training: " + layer.name) model.summary() # using keras low level api for training loss_object = tf.keras.losses.SparseCategoricalCrossentropy( from_logits=False) optimizer = tf.keras.optimizers.Adam(learning_rate=0.0005) train_loss = tf.keras.metrics.Mean(name='train_loss') train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy( name='train_accuracy') val_loss = tf.keras.metrics.Mean(name='val_loss') val_accuracy = tf.keras.metrics.SparseCategoricalAccuracy( name='val_accuracy') @tf.function def train_step(train_images, train_labels): with tf.GradientTape() as tape: output = model(train_images, training=True) loss = loss_object(train_labels, output) gradients = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(zip(gradients, model.trainable_variables)) train_loss(loss) train_accuracy(train_labels, output) @tf.function def val_step(val_images, val_labels): output = model(val_images, training=False) loss = loss_object(val_labels, output) val_loss(loss) val_accuracy(val_labels, output) best_test_loss = float('inf') for epoch in range(epochs): train_loss.reset_states() # clear history info train_accuracy.reset_states() # clear history info val_loss.reset_states() # clear history info val_accuracy.reset_states() # clear history info # train train_bar = tqdm(train_ds) for images, labels in train_bar: train_step(images, labels) # print train process train_bar.desc = "train epoch[{}/{}] loss:{:.3f}, acc:{:.3f}".format( epoch + 1, epochs, train_loss.result(), train_accuracy.result()) # validate val_bar = tqdm(val_ds, colour='green') for images, labels in val_bar: val_step(images, labels) # print val process val_bar.desc = "valid epoch[{}/{}] loss:{:.3f}, acc:{:.3f}".format( epoch + 1, epochs, val_loss.result(), val_accuracy.result()) if val_loss.result() < best_test_loss: best_test_loss = val_loss.result() model.save_weights("./save_weights/resMobileNetV3.ckpt", save_format="tf")
def main(): data_root = "/data/flower_photos" # get data root path if not os.path.exists("./save_weights"): os.makedirs("./save_weights") im_height = 224 im_width = 224 batch_size = 16 epochs = 30 num_classes = 5 log_dir = "./logs/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S") train_writer = tf.summary.create_file_writer(os.path.join( log_dir, "train")) val_writer = tf.summary.create_file_writer(os.path.join(log_dir, "val")) # data generator with data augmentation train_ds, val_ds = generate_ds(data_root, im_height, im_width, batch_size) # create model model = shufflenet_v2_x1_0(input_shape=(im_height, im_width, 3), num_classes=num_classes) # load weights # x1.0权重链接: https://pan.baidu.com/s/1M2mp98Si9eT9qT436DcdOw 密码: mhts pre_weights_path = './shufflenetv2_x1_0.h5' assert os.path.exists(pre_weights_path), "cannot find {}".format( pre_weights_path) model.load_weights(pre_weights_path, by_name=True, skip_mismatch=True) model.summary() # custom learning rate curve def scheduler(now_epoch): initial_lr = 0.1 end_lr_rate = 0.1 # end_lr = initial_lr * end_lr_rate rate = ((1 + math.cos(now_epoch * math.pi / epochs)) / 2) * (1 - end_lr_rate) + end_lr_rate # cosine new_lr = rate * initial_lr # writing lr into tensorboard with train_writer.as_default(): tf.summary.scalar('learning rate', data=new_lr, step=epoch) return new_lr # using keras low level api for training loss_object = tf.keras.losses.SparseCategoricalCrossentropy( from_logits=False) optimizer = tf.keras.optimizers.SGD(learning_rate=0.1, momentum=0.9) train_loss = tf.keras.metrics.Mean(name='train_loss') train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy( name='train_accuracy') val_loss = tf.keras.metrics.Mean(name='val_loss') val_accuracy = tf.keras.metrics.SparseCategoricalAccuracy( name='val_accuracy') @tf.function def train_step(train_images, train_labels): with tf.GradientTape() as tape: output = model(train_images, training=True) loss = loss_object(train_labels, output) gradients = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(zip(gradients, model.trainable_variables)) train_loss(loss) train_accuracy(train_labels, output) @tf.function def val_step(val_images, val_labels): output = model(val_images, training=False) loss = loss_object(val_labels, output) val_loss(loss) val_accuracy(val_labels, output) best_test_loss = float('inf') for epoch in range(epochs): train_loss.reset_states() # clear history info train_accuracy.reset_states() # clear history info val_loss.reset_states() # clear history info val_accuracy.reset_states() # clear history info # train train_bar = tqdm(train_ds) for images, labels in train_bar: train_step(images, labels) # print train process train_bar.desc = "train epoch[{}/{}] loss:{:.3f}, acc:{:.3f}".format( epoch + 1, epochs, train_loss.result(), train_accuracy.result()) # update learning rate optimizer.learning_rate = scheduler(epoch) # validate val_bar = tqdm(val_ds, colour='green') for images, labels in val_bar: val_step(images, labels) # print val process val_bar.desc = "valid epoch[{}/{}] loss:{:.3f}, acc:{:.3f}".format( epoch + 1, epochs, val_loss.result(), val_accuracy.result()) # writing training loss and acc with train_writer.as_default(): tf.summary.scalar("loss", train_loss.result(), epoch) tf.summary.scalar("accuracy", train_accuracy.result(), epoch) # writing validation loss and acc with val_writer.as_default(): tf.summary.scalar("loss", val_loss.result(), epoch) tf.summary.scalar("accuracy", val_accuracy.result(), epoch) if val_loss.result() < best_test_loss: best_test_loss = val_loss.result() model.save_weights("./save_weights/shufflenetv2.ckpt", save_format="tf")
def main(): data_root = "/data/flower_photos" # get data root path if not os.path.exists("./save_weights"): os.makedirs("./save_weights") img_size = { "B0": 224, "B1": 240, "B2": 260, "B3": 300, "B4": 380, "B5": 456, "B6": 528, "B7": 600 } im_height = img_size["B0"] im_width = img_size["B0"] batch_size = 16 epochs = 30 num_classes = 5 freeze_layers = True initial_lr = 0.01 log_dir = "./logs/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S") train_writer = tf.summary.create_file_writer(os.path.join( log_dir, "train")) val_writer = tf.summary.create_file_writer(os.path.join(log_dir, "val")) # data generator with data augmentation train_ds, val_ds = generate_ds(data_root, im_height, im_width, batch_size) # create model model = EfficientNetB0(num_classes=num_classes) # load weights pre_weights_path = './efficientnetb0.h5' assert os.path.exists(pre_weights_path), "cannot find {}".format( pre_weights_path) model.load_weights(pre_weights_path, by_name=True, skip_mismatch=True) # freeze bottom layers if freeze_layers: unfreeze_layers = ["top_conv", "top_bn", "predictions"] for layer in model.layers: if layer.name not in unfreeze_layers: layer.trainable = False else: print("training {}".format(layer.name)) model.summary() # custom learning rate curve def scheduler(now_epoch): end_lr_rate = 0.01 # end_lr = initial_lr * end_lr_rate rate = ((1 + math.cos(now_epoch * math.pi / epochs)) / 2) * (1 - end_lr_rate) + end_lr_rate # cosine new_lr = rate * initial_lr # writing lr into tensorboard with train_writer.as_default(): tf.summary.scalar('learning rate', data=new_lr, step=epoch) return new_lr # using keras low level api for training loss_object = tf.keras.losses.SparseCategoricalCrossentropy( from_logits=False) optimizer = tf.keras.optimizers.SGD(learning_rate=initial_lr, momentum=0.9) train_loss = tf.keras.metrics.Mean(name='train_loss') train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy( name='train_accuracy') val_loss = tf.keras.metrics.Mean(name='val_loss') val_accuracy = tf.keras.metrics.SparseCategoricalAccuracy( name='val_accuracy') @tf.function def train_step(train_images, train_labels): with tf.GradientTape() as tape: output = model(train_images, training=True) loss = loss_object(train_labels, output) gradients = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(zip(gradients, model.trainable_variables)) train_loss(loss) train_accuracy(train_labels, output) @tf.function def val_step(val_images, val_labels): output = model(val_images, training=False) loss = loss_object(val_labels, output) val_loss(loss) val_accuracy(val_labels, output) best_val_acc = 0. for epoch in range(epochs): train_loss.reset_states() # clear history info train_accuracy.reset_states() # clear history info val_loss.reset_states() # clear history info val_accuracy.reset_states() # clear history info # train train_bar = tqdm(train_ds) for images, labels in train_bar: train_step(images, labels) # print train process train_bar.desc = "train epoch[{}/{}] loss:{:.3f}, acc:{:.3f}".format( epoch + 1, epochs, train_loss.result(), train_accuracy.result()) # update learning rate optimizer.learning_rate = scheduler(epoch) # validate val_bar = tqdm(val_ds, colour='green') for images, labels in val_bar: val_step(images, labels) # print val process val_bar.desc = "valid epoch[{}/{}] loss:{:.3f}, acc:{:.3f}".format( epoch + 1, epochs, val_loss.result(), val_accuracy.result()) # writing training loss and acc with train_writer.as_default(): tf.summary.scalar("loss", train_loss.result(), epoch) tf.summary.scalar("accuracy", train_accuracy.result(), epoch) # writing validation loss and acc with val_writer.as_default(): tf.summary.scalar("loss", val_loss.result(), epoch) tf.summary.scalar("accuracy", val_accuracy.result(), epoch) # only save best weights if val_accuracy.result() > best_val_acc: best_val_acc = val_accuracy.result() save_name = "./save_weights/efficientnet.ckpt" model.save_weights(save_name, save_format="tf")
def __init__(self, pddl_gym_env_name, pddl_domain_name, custom_fd): """ Generic agent for pddlgym environments creates the environment and parses domain files, """ self.new_problem_number = 99 self.action_mapping = {} self.pddl_gym_env_name = pddl_gym_env_name self.pddl_domain_name = pddl_domain_name self.custom_fd = custom_fd self.random_states = [] try: os.remove(self.custom_fd) except OSError as e: print(e) pass self.n = 0 self.env = gym.make(pddl_gym_env_name) self.state, dbg = self.env.reset() self.env_actions = [] self.problem_file_loaded = dbg['problem_file'] for action in list(self.env.action_space.all_ground_literals()): self.env_actions.append(action.pddl_str()[1:-1]) self.action_parameters, self.predicates, _, _, self.objects, self.types, _, _ = generate_ds( self.env.domain.domain_fname, self.env.problems[0].problem_fname)
def main(): data_root = "/data/flower_photos" # get data root path if not os.path.exists("./save_weights"): os.makedirs("./save_weights") img_size = 224 batch_size = 8 epochs = 10 num_classes = 5 freeze_layers = False initial_lr = 0.0001 weight_decay = 1e-5 log_dir = "./logs/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S") train_writer = tf.summary.create_file_writer(os.path.join( log_dir, "train")) val_writer = tf.summary.create_file_writer(os.path.join(log_dir, "val")) # data generator with data augmentation train_ds, val_ds = generate_ds(data_root, train_im_width=img_size, train_im_height=img_size, batch_size=batch_size, val_rate=0.2) # create model model = create_model(num_classes=num_classes) model.build((1, img_size, img_size, 3)) # 下载我提前转好的预训练权重 # 链接: https://pan.baidu.com/s/1cHVwia2i3wD7-0Ueh2WmrQ 密码: sq8c # load weights pre_weights_path = './swin_tiny_patch4_window7_224.h5' assert os.path.exists(pre_weights_path), "cannot find {}".format( pre_weights_path) model.load_weights(pre_weights_path, by_name=True, skip_mismatch=True) # freeze bottom layers if freeze_layers: for layer in model.layers: if "head" not in layer.name: layer.trainable = False else: print("training {}".format(layer.name)) model.summary() # using keras low level api for training loss_object = tf.keras.losses.SparseCategoricalCrossentropy( from_logits=True) optimizer = tf.keras.optimizers.Adam(learning_rate=initial_lr) train_loss = tf.keras.metrics.Mean(name='train_loss') train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy( name='train_accuracy') val_loss = tf.keras.metrics.Mean(name='val_loss') val_accuracy = tf.keras.metrics.SparseCategoricalAccuracy( name='val_accuracy') @tf.function def train_step(train_images, train_labels): with tf.GradientTape() as tape: output = model(train_images, training=True) # cross entropy loss ce_loss = loss_object(train_labels, output) # l2 loss matcher = re.compile(".*(bias|gamma|beta).*") l2loss = weight_decay * tf.add_n([ tf.nn.l2_loss(v) for v in model.trainable_variables if not matcher.match(v.name) ]) loss = ce_loss + l2loss gradients = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(zip(gradients, model.trainable_variables)) train_loss(ce_loss) train_accuracy(train_labels, output) @tf.function def val_step(val_images, val_labels): output = model(val_images, training=False) loss = loss_object(val_labels, output) val_loss(loss) val_accuracy(val_labels, output) best_val_acc = 0. for epoch in range(epochs): train_loss.reset_states() # clear history info train_accuracy.reset_states() # clear history info val_loss.reset_states() # clear history info val_accuracy.reset_states() # clear history info # train train_bar = tqdm(train_ds, file=sys.stdout) for images, labels in train_bar: train_step(images, labels) # print train process train_bar.desc = "train epoch[{}/{}] loss:{:.3f}, acc:{:.3f}".format( epoch + 1, epochs, train_loss.result(), train_accuracy.result()) # validate val_bar = tqdm(val_ds, file=sys.stdout) for images, labels in val_bar: val_step(images, labels) # print val process val_bar.desc = "valid epoch[{}/{}] loss:{:.3f}, acc:{:.3f}".format( epoch + 1, epochs, val_loss.result(), val_accuracy.result()) # writing training loss and acc with train_writer.as_default(): tf.summary.scalar("loss", train_loss.result(), epoch) tf.summary.scalar("accuracy", train_accuracy.result(), epoch) # writing validation loss and acc with val_writer.as_default(): tf.summary.scalar("loss", val_loss.result(), epoch) tf.summary.scalar("accuracy", val_accuracy.result(), epoch) # only save best weights if val_accuracy.result() > best_val_acc: best_val_acc = val_accuracy.result() save_name = "./save_weights/model.ckpt" model.save_weights(save_name, save_format="tf")
def main(): data_root = "/data/flower_photos" # get data root path if not os.path.exists("./save_weights"): os.makedirs("./save_weights") batch_size = 8 epochs = 10 num_classes = 5 freeze_layers = True initial_lr = 0.001 weight_decay = 1e-4 log_dir = "./logs/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S") train_writer = tf.summary.create_file_writer(os.path.join( log_dir, "train")) val_writer = tf.summary.create_file_writer(os.path.join(log_dir, "val")) # data generator with data augmentation train_ds, val_ds = generate_ds(data_root, batch_size=batch_size, val_rate=0.2) # create model model = create_model(num_classes=num_classes, has_logits=False) model.build((1, 224, 224, 3)) # 下载我提前转好的预训练权重 # 链接: https://pan.baidu.com/s/1ro-6bebc8zroYfupn-7jVQ 密码: s9d9 # load weights pre_weights_path = './ViT-B_16.h5' assert os.path.exists(pre_weights_path), "cannot find {}".format( pre_weights_path) model.load_weights(pre_weights_path, by_name=True, skip_mismatch=True) # freeze bottom layers if freeze_layers: for layer in model.layers: if "pre_logits" not in layer.name and "head" not in layer.name: layer.trainable = False else: print("training {}".format(layer.name)) model.summary() # custom learning rate curve def scheduler(now_epoch): end_lr_rate = 0.01 # end_lr = initial_lr * end_lr_rate rate = ((1 + math.cos(now_epoch * math.pi / epochs)) / 2) * (1 - end_lr_rate) + end_lr_rate # cosine new_lr = rate * initial_lr # writing lr into tensorboard with train_writer.as_default(): tf.summary.scalar('learning rate', data=new_lr, step=epoch) return new_lr # using keras low level api for training loss_object = tf.keras.losses.SparseCategoricalCrossentropy( from_logits=True) optimizer = tf.keras.optimizers.SGD(learning_rate=initial_lr, momentum=0.9) train_loss = tf.keras.metrics.Mean(name='train_loss') train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy( name='train_accuracy') val_loss = tf.keras.metrics.Mean(name='val_loss') val_accuracy = tf.keras.metrics.SparseCategoricalAccuracy( name='val_accuracy') @tf.function def train_step(train_images, train_labels): with tf.GradientTape() as tape: output = model(train_images, training=True) # cross entropy loss ce_loss = loss_object(train_labels, output) # l2 loss matcher = re.compile(".*(bias|gamma|beta).*") l2loss = weight_decay * tf.add_n([ tf.nn.l2_loss(v) for v in model.trainable_variables if not matcher.match(v.name) ]) loss = ce_loss + l2loss gradients = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(zip(gradients, model.trainable_variables)) train_loss(ce_loss) train_accuracy(train_labels, output) @tf.function def val_step(val_images, val_labels): output = model(val_images, training=False) loss = loss_object(val_labels, output) val_loss(loss) val_accuracy(val_labels, output) best_val_acc = 0. for epoch in range(epochs): train_loss.reset_states() # clear history info train_accuracy.reset_states() # clear history info val_loss.reset_states() # clear history info val_accuracy.reset_states() # clear history info # train train_bar = tqdm(train_ds, file=sys.stdout) for images, labels in train_bar: train_step(images, labels) # print train process train_bar.desc = "train epoch[{}/{}] loss:{:.3f}, acc:{:.3f}".format( epoch + 1, epochs, train_loss.result(), train_accuracy.result()) # update learning rate optimizer.learning_rate = scheduler(epoch) # validate val_bar = tqdm(val_ds, file=sys.stdout) for images, labels in val_bar: val_step(images, labels) # print val process val_bar.desc = "valid epoch[{}/{}] loss:{:.3f}, acc:{:.3f}".format( epoch + 1, epochs, val_loss.result(), val_accuracy.result()) # writing training loss and acc with train_writer.as_default(): tf.summary.scalar("loss", train_loss.result(), epoch) tf.summary.scalar("accuracy", train_accuracy.result(), epoch) # writing validation loss and acc with val_writer.as_default(): tf.summary.scalar("loss", val_loss.result(), epoch) tf.summary.scalar("accuracy", val_accuracy.result(), epoch) # only save best weights if val_accuracy.result() > best_val_acc: best_val_acc = val_accuracy.result() save_name = "./save_weights/model.ckpt" model.save_weights(save_name, save_format="tf")
def main(): data_root = "/home/wz/my_project/my_github/data_set/flower_data/flower_photos" # get data root path if not os.path.exists("./save_weights"): os.makedirs("./save_weights") num_classes = 5 im_height = 224 im_width = 224 batch_size = 8 epochs = 20 log_dir = "logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S") train_ds, val_ds = generate_ds(data_root, im_height, im_width, batch_size) # create base model base_model = tf.keras.applications.ResNet50(include_top=False, input_shape=(224, 224, 3), weights='imagenet') # freeze base model base_model.trainable = False base_model.summary() # create new model on top inputs = tf.keras.Input(shape=(224, 224, 3)) x = tf.keras.applications.resnet50.preprocess_input(inputs) x = base_model(x, training=False) x = tf.keras.layers.GlobalAveragePooling2D()(x) outputs = tf.keras.layers.Dense(num_classes)(x) model = tf.keras.Model(inputs, outputs) model.summary() model.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=0.001, momentum=0.9), loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=['accuracy']) def scheduler(epoch): """ 自定义学习率变化 :param epoch: 当前训练epoch :return: """ initial_lr = 0.01 end_lr = 0.001 rate = ((1 + math.cos(epoch * math.pi / epochs)) / 2) * (1 - end_lr) + end_lr # cosine new_lr = rate * initial_lr return new_lr callbacks = [tf.keras.callbacks.ModelCheckpoint(filepath='./save_weights/model_{epoch}.h5', save_best_only=True, save_weights_only=True, monitor='val_accuracy'), tf.keras.callbacks.TensorBoard(log_dir=log_dir, write_graph=True, histogram_freq=1), tf.keras.callbacks.LearningRateScheduler(schedule=scheduler)] model.fit(x=train_ds, epochs=epochs, validation_data=val_ds, callbacks=callbacks)