def train(self) : self.optimizer = tf.keras.optimizers.Adam(beta_1 = 0.9, beta_2 = 0.98, epsilon = 1e-9) if self.use_label_smoothing : self.loss_function = tf.keras.losses.CategoricalCrossentropy(from_logits = True) else : self.loss_function = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) self.loss_metric = tf.keras.metrics.Mean(name = "train_loss") self.acc_metric = tf.keras.metrics.SparseCategoricalAccuracy(name = "train_acc") ckpt = tf.train.Checkpoint(model = self.transformer, opt = self.optimizer) if self.ckpt_path is not None : fname, self.initial_epoch = load_checkpoint(Path(self.ckpt_path).resolve(), self.ckpt_epoch) print("\nCheckpoint File : {}\n".format(fname)) ckpt.mapped = {"model" : self.transformer, "opt" : self.optimizer} ckpt.restore(fname) progbar = tf.keras.utils.Progbar(target = self.num_train) self.count = 0 for epoch in range(self.initial_epoch, self.initial_epoch + self.epochs) : K.set_value(self.optimizer.lr, self._get_lr(epoch)) progbar.update(0) self.loss_metric.reset_states() self.acc_metric.reset_states() start_time = korea_time(None) for train_src, train_tar in self.train_dataset : num_data = K.int_shape(train_src)[0] logits = self.forward(train_src, train_tar) progbar.add(num_data) end_time = korea_time(None) epoch_loss = self.loss_metric.result() epoch_acc = self.acc_metric.result() ckpt_prefix = self.ckpt_folder / "Epoch-{}_Loss-{:.5f}_Acc-{:5f}".format( epoch, epoch_loss, epoch_acc) ckpt.save(file_prefix = ckpt_prefix) print("Epoch = [{:5d}] Loss = [{:8.6f}] Acc = [{:8.6f}] LR = [{:.10f}]\n".format( epoch, epoch_loss, epoch_acc, K.get_value(self.optimizer.lr))) # model result 저장 msg = "Epoch = [{:5d}] - End Time [ {} ]\n".format(epoch, end_time.strftime("%Y/%m/%d %H:%M:%S")) msg += "Elapsed Time = {}\n".format(end_time - start_time) msg += "Learning Rate = [{:.10f}]\n".format(K.get_value(self.optimizer.lr)) msg += "Loss : [{:8.6f}] - Acc : [{:8.6f}]\n".format(epoch_loss, epoch_acc) msg += " - " * 15 + "\n\n" with self.training_result_file.open("a+", encoding = "utf-8") as fp : fp.write(msg) if self.test_result_file is not None : self.translate(epoch)
def test(self) : ckpt = tf.train.Checkpoint(model = self.transformer) fname, _ = load_checkpoint(Path(self.ckpt_path).resolve(), self.ckpt_epoch) print("\nCheckpoint File : {}\n".format(fname)) # model만 불러옴 ckpt.mapped = {"model" : self.transformer} ckpt.restore(fname).expect_partial() self.translate("Test")
def test(self): ckpt = tf.train.Checkpoint(encoder=self.encoder, decoder=self.decoder) fname, _ = load_checkpoint(self.ckpt_path, self.ckpt_epoch) print("\nCheckpoint File : {}\n".format(fname)) # model만 불러옴 ckpt.mapped = {"encoder": self.encoder, "decoder": self.decoder} ckpt.restore(fname).expect_partial() self.translate("Test")
def test(self): ckpt = tf.train.Checkpoint(generator=self.gen) fname, _ = load_checkpoint( Path(self.ckpt_path).resolve(), self.ckpt_epoch) print("\nCheckpoint File : {}\n".format(fname)) # model만 불러옴 ckpt.mapped = {"generator": self.gen} ckpt.restore(fname).expect_partial() fname = self.image_folder / "Test.png" self.plot_images(fname)
def test(self, *args, **kwargs): self.generator = self.make_generator(**kwargs) ckpt = tf.train.Checkpoint(g_model=self.generator) fname, _ = load_checkpoint(**kwargs) print("\nCheckpoint File : {}\n".format(fname)) # model만 불러옴 ckpt.mapped = {"g_model": self.generator} ckpt.restore(fname).expect_partial() _, model_images_path, _, _ = make_folders_for_model(kwargs['folder']) fname = os.path.join(model_images_path, "Test.png") self.plot_images(fname)
def train(self): self.g_opt = tf.keras.optimizers.Adam(lr=self.lr, beta_1=0.5) self.d_opt = tf.keras.optimizers.Adam(lr=self.lr, beta_1=0.5) self.g_loss_metric = tf.keras.metrics.Mean(name="g_loss") self.d_loss_metric = tf.keras.metrics.Mean(name="d_loss") ckpt = tf.train.Checkpoint(generator=self.gen, discriminator=self.disc, genenerator_optimizer=self.g_opt, discriminator_optimizer=self.d_opt) if self.ckpt_path is not None: fname, self.initial_epoch = load_checkpoint( Path(self.ckpt_path).resolve(), self.ckpt_epoch) print("\nCheckpoint File : {}\n".format(fname)) ckpt.mapped = { "generator": self.gen, "discriminator": self.disc, "generator_optimizer": self.g_opt, "discriminator_optimizer": self.d_opt } ckpt.restore(fname) self.lr = self.g_opt.get_config()["learning_rate"] progbar = tf.keras.utils.Progbar(target=self.num_train) for epoch in range(self.initial_epoch, self.initial_epoch + self.epochs): self.g_loss_metric.reset_states() self.d_loss_metric.reset_states() start_time = korea_time(None) for images in self.dataset: num_images = K.int_shape(images)[0] self.train_D(images) self.train_G(num_images) progbar.add(num_images) end_time = korea_time(None) progbar.update(0) # Progress bar 초기화 g_loss = self.g_loss_metric.result() d_loss = self.d_loss_metric.result() ckpt_prefix = self.ckpt_folder / "Epoch-{}_gLoss-{:.6f}_dLoss-{:.6f}".format( epoch, g_loss, d_loss) ckpt.save(file_prefix=ckpt_prefix) print("Epoch = [{:5d}] G_loss = [{:8.6f}] D_loss = [{:8.6f}]\n". format(epoch, g_loss, d_loss)) # model result 저장 with self.training_result_file.open("a+", encoding='utf-8') as fp: str_ = "Epoch = [{:5d}] - End Time [ {} ]\n".format( epoch, str(end_time.strftime("%Y / %m / %d %H:%M:%S"))) str_ += "Elapsed Time = {}\n".format(end_time - start_time) str_ += "Learning Rate = [{:.6f}]\n".format(self.lr) str_ += "g_loss = [{:8.6f}] d_loss = [{:8.6f}]\n".format( g_loss, d_loss) str_ += " - " * 15 + "\n\n" fp.write(str_) fname = self.image_folder / "{}.png".format(epoch) self.plot_images(fname)
def train(self, **kwargs): interval = kwargs["interval"] model_ckpt_path, model_images_path, model_logs_path, model_result_file = make_folders_for_model( kwargs['folder']) self.generator = self.make_generator() self.discriminator = self.make_discriminator() train_dataset = self.get_dataset() num_batches = ceil(self.num_train / self.batch_size) d_epoch_loss = [] d_epoch_aux_loss = [] g_epoch_loss = [] training_progbar = tf.keras.utils.Progbar(target=self.num_train) save_initial_model_info( { 'generator': self.generator, 'discriminator': self.discriminator }, model_logs_path, model_ckpt_path, **kwargs) count = 0 self.g_opt = tf.keras.optimizers.Adam(lr=self.g_lr, beta_1=0.5) self.d_opt = tf.keras.optimizers.Adam(lr=self.d_lr, beta_1=0.5) self.BC_function = tf.keras.losses.BinaryCrossentropy(from_logits=True) self.SCC_function = tf.keras.losses.SparseCategoricalCrossentropy( from_logits=True) ckpt = tf.train.Checkpoint(g_opt=self.g_opt, d_opt=self.d_opt, g_model=self.generator, d_model=self.discriminator) if kwargs["ckpt_path"] is not None: fname, self.initial_epoch = load_checkpoint(**kwargs) print("\nCheckpoint File : {}\n".format(fname)) ckpt.mapped = { "g_opt": self.g_opt, "d_opt": self.d_opt, "g_model": self.generator, "d_model": self.discriminator } ckpt.restore(fname) self.g_lr = self.g_opt.get_config()["learning_rate"] self.d_lr = self.d_opt.get_config()["learning_rate"] for epoch in range(self.initial_epoch, self.initial_epoch + 50000): count += 1 start_time = korea_time() for real_images, real_labels in train_dataset: num_images = K.int_shape(real_labels)[0] g_loss = (self.train_G(num_images)).numpy() d_BC_loss, d_SCC_loss = self.train_D(real_images, real_labels) d_BC_loss = d_BC_loss.numpy() d_SCC_loss = d_SCC_loss.numpy() d_epoch_loss.append(d_BC_loss) d_epoch_aux_loss.append(d_SCC_loss) g_epoch_loss.append(g_loss) training_progbar.add(num_images) end_time = korea_time() training_progbar.update(0) # Progress bar 초기화 d_mean_loss = np.mean(d_epoch_loss, axis=0) d_mean_aux_loss = np.mean(d_epoch_aux_loss, axis=0) g_mean_loss = np.mean(g_epoch_loss, axis=0) ckpt_prefix = os.path.join( model_ckpt_path, "Epoch-{}_G-Loss-{:.6f}_D-Loss-{:.6f}".format( epoch, g_mean_loss, d_mean_loss + d_mean_aux_loss)) ckpt.save(file_prefix=ckpt_prefix) str_ = ("Epoch = [{:5d}]\tG Loss = [{:8.6f}]\t".format( epoch, g_mean_loss) + "D Loss = [{:8.6f}]\tD AUX Loss = [{:8.6f}]\n".format( d_mean_loss, d_mean_aux_loss)) print(str_) # model result 저장 str_ = "Epoch = [{:5d}] - End Time [ {} ]\n".format( epoch, str(end_time.strftime("%Y / %m / %d %H:%M:%S"))) str_ += "Elapsed Time = {}\n".format(end_time - start_time) str_ += "G Learning Rate = [{:.6f}] - D Learning Rate = [{:.6f}]\n".format( self.g_lr, self.d_lr) str_ += "G Loss : [{:8.6f}] - D Loss : [{:8.6f}] - D AUX Loss : [{:8.6f}] - Sum : [{:8.6f}]\n".format( g_mean_loss, d_mean_loss, d_mean_aux_loss, g_mean_loss + d_mean_loss + d_mean_aux_loss) str_ += " - " * 15 + "\n\n" with open(model_result_file, "a+", encoding='utf-8') as fp: fp.write(str_) if count == interval: fname = os.path.join(model_images_path, "{}.png".format(epoch)) self.plot_images(fname) count = 0 d_epoch_loss = [] d_epoch_aux_loss = [] g_epoch_loss = []
def train(self, **kwargs): interval = kwargs["interval"] model_ckpt_path, model_images_path, model_logs_path, model_result_file = make_folders_for_model( kwargs['folder']) self.generator = self.make_generator() self.critic = self.make_critic() train_dataset = self.get_dataset() num_batches = ceil(self.num_train / self.batch_size) c_epoch_loss = [] g_epoch_loss = [] training_progbar = tf.keras.utils.Progbar(target=self.num_train) save_initial_model_info( { 'generator': self.generator, 'critic': self.critic }, model_logs_path, model_ckpt_path, **kwargs) count = 0 self.g_opt = tf.keras.optimizers.Adam(lr=self.g_lr, beta_1=0, beta_2=0.9) self.c_opt = tf.keras.optimizers.Adam(lr=self.c_lr, beta_1=0, beta_2=0.9) ckpt = tf.train.Checkpoint(g_opt=self.g_opt, c_opt=self.c_opt, g_model=self.generator, c_model=self.critic) if kwargs["ckpt_path"] is not None: fname, self.initial_epoch = load_checkpoint(**kwargs) print("\nCheckpoint File : {}\n".format(fname)) ckpt.mapped = { "g_opt": self.g_opt, "c_opt": self.c_opt, "g_model": self.generator, "c_model": self.critic } ckpt.restore(fname) self.g_lr = self.g_opt.get_config()["learning_rate"] self.c_lr = self.c_opt.get_config()["learning_rate"] for epoch in range(self.initial_epoch, self.initial_epoch + 50000): count += 1 start_time = korea_time() num_batch = 0 # 64 * 5 = 320 mult = self.n_critic * self.batch_size num_dataset = 0 # 60000 real_images_list = [] for real_images in train_dataset: # self.n_critic개 만큼의 image dataset을 불러옴 real_images_list.append(real_images) num_images = K.int_shape(real_images)[0] num_batch += num_images num_dataset += num_images if (num_batch == mult) or (num_dataset == self.num_train): critic_loss_list = [(self.train_D(real_images)).numpy() for real_images in real_images_list] g_loss = (self.train_G()).numpy() c_epoch_loss.extend(critic_loss_list) g_epoch_loss.append(g_loss) training_progbar.add(num_batch) if num_dataset == self.num_train: break num_batch = 0 real_images_list = [] end_time = korea_time() training_progbar.update(0) # Progress bar 초기화 c_mean_loss = np.mean(c_epoch_loss, axis=0) g_mean_loss = np.mean(g_epoch_loss, axis=0) ckpt_prefix = os.path.join( model_ckpt_path, "Epoch-{}_G-Loss-{:.6f}_C-Loss-{:.6f}".format( epoch, g_mean_loss, c_mean_loss)) ckpt.save(file_prefix=ckpt_prefix) print( "Epoch = [{:5d}]\tGenerator Loss = [{:8.6f}]\tCritic Loss = [{:8.6f}]\n" .format(epoch, g_mean_loss, c_mean_loss)) # model result 저장 str_ = "Epoch = [{:5d}] - End Time [ {} ]\n".format( epoch, str(end_time.strftime("%Y / %m / %d %H:%M:%S"))) str_ += "Elapsed Time = {}\n".format(end_time - start_time) str_ += "Generator Learning Rate = [{:.6f}] - Critic Learning Rate = [{:.6f}]\n".format( self.g_lr, self.c_lr) str_ += "Generator Loss : [{:8.6f}] - Critic Loss : [{:8.6f}] - Sum : [{:8.6f}]\n".format( g_mean_loss, c_mean_loss, g_mean_loss + c_mean_loss) str_ += " - " * 15 + "\n\n" with open(model_result_file, "a+", encoding='utf-8') as fp: fp.write(str_) if count == interval: fname = os.path.join(model_images_path, "{}.png".format(epoch)) self.plot_images(fname) count = 0 c_epoch_loss = [] g_epoch_loss = []