def trainer(self): steps = 0 loss_deque = deque(maxlen=100) train_loss = [] last_epoch = 0 if self.opts.resume: last_epoch, loss = self.load_progress() for e in range(self.opts.epoch - last_epoch): '''Adaptive LR Change''' for param_group in self.RNN_optim.param_groups: param_group['lr'] = util.linear_LR(e, self.opts) print('epoch: {}, RNN_LR: {:.4}'.format(e, param_group['lr'])) if self.opts.save_progress: '''Save the progress before start adjusting the LR''' if e == self.opts.const_epoch: self.save_progress(self.opts.const_epoch, np.mean(loss_deque)) if e % self.opts.save_every == 0: self.save_progress(e, np.mean(loss_deque)) for data, labels, lengths in self.data_loader: steps += 1 data, labels, lengths = util.sort_batch(data, labels, lengths) #data = data[:lengths] #labels = labels[:lengths] self.RNN_optim.zero_grad() loss = self.RNN(data.to(device), labels.to(device), lengths.to(device)) loss.backward() self.RNN_optim.step() loss_deque.append(loss.cpu().item()) train_loss.append(np.mean(loss_deque)) if steps % self.opts.print_every == 0: print('Epoch: {}, Steps: {}, Loss: {:.4}'.format( e, steps, loss.item())) util.raw_score_plotter(train_loss) if self.opts.save_progress: '''Save the progress before start adjusting the LR''' self.save_progress(-1, np.mean(loss_deque)) util.raw_score_plotter(train_loss)
def trainer(opts, RNN, RNN_optim, criterion, loader): last_100_loss = deque(maxlen=100) last_100_g_loss = [] iter_count = 0 for epoch in range(opts.epoch): for param_group in RNN_optim.param_groups: param_group['lr'] = util.linear_LR(epoch, opts) print('Epoch: {}, D_LR: {:.4}'.format(epoch, param_group['lr'])) for image, label in loader: '''Images''' image = image.view(-1, 28, 28) image = image.to(device) label = label.to(device) '''run the data through RNN''' output = RNN(image) loss = criterion(output, label) '''take a gradient step''' RNN_optim.zero_grad() loss.backward() RNN_optim.step() # One step Descent into loss '''plot the loss''' last_100_loss.append(loss.item()) last_100_g_loss.append(np.mean(last_100_loss)) util.raw_score_plotter(last_100_g_loss) '''Train Generator''' iter_count += 1 if iter_count % opts.print_every == 0: print('Epoch: {}, Iter: {}, Loss: {:.4},'.format( epoch, iter_count, loss.item()))
def train_CycleGan(train_step, loss, reconstruction, show_every=opts.show_every, print_every=opts.print_every, batch_size=128, num_epoch=10): """ function that trains VAE. :param train_step: an op that defines what to do with the loss function (minimize or maximize) :param loss: an op that defines the loss function to be minimized :param reconstruction: an op that defines how to reconstruct a target image :param show_every: how often to show an image to gauge training progress :param print_every: how often to print loss :param batch_size: batch size of training samples :param num_epoch: how many times to iterate over the training samples :return: """ image_dir = '/home/youngwook/Downloads/edges2shoes' folder_names = get_folders(image_dir) train_folder = folder_names[2] val_folder = folder_names[1] train_data = AB_Combined_ImageLoader(train_folder, size=opts.resize, num_images=opts.num_images, randomcrop=opts.image_shape) train_loader = DataLoader(train_data, batch_size=opts.batch, shuffle=True, num_workers=12) step = 0 target_pred_list = [] input_pred_list = [] input_true_list = [] target_true_list = [] last_100_loss_dq = deque(maxlen=100) last_100_loss = [] checkpoint_dir = './model' saver = tf.train.Saver() if opts.resume: #print('Loading Saved Checkpoint') tf_util.load_session(checkpoint_dir, saver, session, model_name=opts.model_name) for epoch in range(num_epoch): # every show often, show a sample result lr = util.linear_LR(epoch, opts) for (minibatch, minbatch_y) in train_loader: # run a batch of data through the network # logits= sess.run(logits_real, feed_dict={x:minibatch}) target_pred, input_pred = session.run( [target_image_prediction, input_image_prediction], feed_dict={ input_image: minibatch, target_image: minbatch_y, adaptive_lr: lr }) input_memory.append(input_pred) target_memory.append(target_pred) target_replay_images = np.vstack(target_memory) input_replay_images = np.vstack(input_memory) #train the Generator _, G_loss_curr = session.run( [train_step[2], loss[1]], feed_dict={ input_image: minibatch, target_image: minbatch_y, input_replay: input_replay_images, target_replay: target_replay_images, input_image_pred: input_pred, target_image_pred: target_pred, adaptive_lr: lr }) #train the discriminator _, D_loss_curr = session.run( [train_step[0], loss[0][0]], feed_dict={ input_image: minibatch, input_replay: input_replay_images, adaptive_lr: lr }) _, D_loss_curr = session.run( [train_step[1], loss[0][1]], feed_dict={ target_image: minbatch_y, target_replay: target_replay_images, adaptive_lr: lr }) last_100_loss_dq.append(G_loss_curr) last_100_loss.append(np.mean(last_100_loss_dq)) step += 1 if step % show_every == 0: '''for every show_every step, show reconstructed images from the training iteration''' target_name = './img/target_pred_%s.png' % step input_name = './img/input_pred_%s.png' % step input_true_name = './img/true_input_%s.png' % step target_true_name = './img/true_target_%s.png' % step #translate the image target_pred, input_pred = session.run( [target_image_prediction, input_image_prediction], feed_dict={ input_image: minibatch, target_image: minbatch_y }) target_pred_list.append(target_name) input_pred_list.append(input_name) input_true_list.append(input_true_name) target_true_list.append(target_true_name) util.show_images(target_pred[:opts.batch], opts, target_name) util.plt.show() util.show_images(minbatch_y[:opts.batch], opts, target_true_name) util.plt.show() util.show_images(input_pred[:opts.batch], opts, input_name) util.plt.show() util.show_images(minibatch[:opts.batch], opts, input_true_name) util.plt.show() if step % print_every == 0: print('Epoch: {}, D: {:.4}'.format(epoch, G_loss_curr)) util.raw_score_plotter(last_100_loss) #save the model after every epoch if opts.save_progress: tf_util.save_session(saver, session, checkpoint_dir, epoch, model_name=opts.model_name) util.raw_score_plotter(last_100_loss) image_to_gif('', target_pred_list, duration=0.5, gifname='target_pred') image_to_gif('', input_pred_list, duration=0.5, gifname='input_pred') image_to_gif('', input_true_list, duration=0.5, gifname='input_true') image_to_gif('', target_true_list, duration=0.5, gifname='target_true')
def train(self): """ Vanilla GAN Trainer :param D: Discriminator :param G: Generator :param D_solver: Optimizer for D :param G_solver: Optimizer for G :param discriminator_loss: Loss for D :param generator_loss: Loss for G :param loader: Torch dataloader :param show_every: Show samples after every show_every iterations :param batch_size: Batch Size used for training :param noise_size: Dimension of the noise to use as input for G :param num_epochs: Number of epochs over the training dataset to use for training :return: """ last_100_loss = deque(maxlen=100) last_100_g_loss = [] iter_count = 0 last_epoch = 0 if self.opts.resume: last_epoch, loss = self.load_progress() for epoch in range(self.opts.epoch - last_epoch): '''Adaptive LR Change''' for param_group in self.D_solver.param_groups: param_group['lr'] = util.linear_LR(epoch, self.opts) print('epoch: {}, D_LR: {:.4}'.format(epoch, param_group['lr'])) if self.opts.save_progress: '''Save the progress before start adjusting the LR''' if epoch == self.opts.const_epoch: self.save_progress(self.opts.const_epoch, np.mean(last_100_loss)) for image, label in self.loader: '''Real Images''' image = image.to(device) '''one hot encode the real label''' label = label.float().to(device) '''Train Discriminator''' '''Get the logits''' real_logits_cls = self.D(image.to(device)) loss = self.opts.cls_lambda * F.binary_cross_entropy_with_logits( real_logits_cls, label, reduction='sum') / real_logits_cls.size(0) self.D_solver.zero_grad() loss.backward() self.D_solver.step() # One step Descent into loss '''Train Generator''' iter_count += 1 last_100_loss.append(loss.cpu().item()) last_100_g_loss.append(np.mean(last_100_loss)) if iter_count % self.opts.print_every == 0: print('Epoch: {}, Iter: {}, D: {:.4} '.format( epoch, iter_count, loss.item())) util.raw_score_plotter(last_100_g_loss) if self.opts.save_progress: if iter_count % self.opts.save_every == 0: self.save_progress(epoch, np.mean(last_100_loss)) if self.opts.save_progress: '''Save the progress before start adjusting the LR''' self.save_progress(-1, np.mean(last_100_loss))
def trainer(self): steps = 0 correct = 0 total = 0 loss_deque = deque(maxlen=100) train_loss = [] last_epoch = 0 if self.opts.resume: last_epoch, loss = self.load_progress() for e in range(self.opts.epoch - last_epoch): '''Adaptive LR Change''' for param_group in self.RNN_optim.param_groups: param_group['lr'] = util.linear_LR(e, self.opts) print('epoch: {}, RNN_LR: {:.4}'.format(e, param_group['lr'])) if self.opts.save_progress: '''Save the progress before start adjusting the LR''' if e == self.opts.const_epoch: self.save_progress(self.opts.const_epoch, np.mean(loss_deque)) if e % self.opts.save_every == 0: self.save_progress(e, np.mean(loss_deque)) for data, labels, lengths in self.data_loader: steps += 1 data, labels, lengths = util.sort_batch(data, labels, lengths) self.RNN_optim.zero_grad() pred = self.RNN(data, lengths) loss = self.criterion(pred, labels.to(device)) loss.backward() self.RNN_optim.step() # pick the argmax output = torch.max(pred, 1)[1] for output, label in zip(output, labels): if output.cpu().item() == label.item(): correct += 1 total += 1 loss_deque.append(loss.cpu().item()) train_loss.append(np.mean(loss_deque)) if steps % self.opts.print_every == 0: print( 'Epoch: {}, Steps: {}, Loss: {:.4}, Train Accuracy {:4}, ' .format(e, steps, loss.item(), correct / float(total))) correct = 0 total = 0 util.raw_score_plotter(train_loss) if self.opts.save_progress: '''Save the progress before start adjusting the LR''' self.save_progress(-1, np.mean(loss_deque)) util.raw_score_plotter(train_loss)