def train(netD, netG, criterion, optimizerG, optimizerD): for epoch in range(Opt.epoch): avg_lossD = 0 avg_lossG = 0 with open(os.path.join(Opt.root, 'logs.txt', 'a')) as file: for i, (data, _) in enumerate(train_loader): # Update D network mini_batch = data.shape[0] # train with real input = Variable(data.cuda()) # image input real_label = Variable(torch.ones(mini_batch).cuda()) output = netD(input) D_real_loss = criterion(output, real_label) # train with fake noise = Variable(torch.randn(mini_batch, Opt.nz).view(-1, Opt.nz, 1, 1).cuda()) fake = netG(noise) fake_label = Variable(torch.zeros(mini_batch).cuda()) output = netD(fake.detach()) # detach to avoid training G on these labels G_real_loss = criterion(output, fake_label) D_loss = D_real_loss + G_real_loss netD.zero_grad() D_loss.backward() if Opt.which_pc == 0: avg_lossD += D_loss.item() else: avg_lossD += D_loss.data[0] optimizerD.step() # Update G network output = netD(fake) G_loss = criterion(output, real_label) if Opt.which_pc == 0: avg_lossG += G_loss.item() else: avg_lossG += G_loss.data[0] netG.zero_grad() G_loss.backward() optimizerG.step() print('Epoch [%d/%d], Step [%d/%d], D_loss: %.4f, G_loss: %.4f' % (epoch + 1, Opt.epoch, i + 1, len(train_loader), D_loss.data[0], G_loss.data[0])) avg_lossD /= i avg_lossG /= i print('epoch: ' + str(epoch) + ', G_loss: ' + str(avg_lossG) + ', D_loss: ' + str(avg_lossD)) file.write('epoch: ' + str(epoch) + ', G_loss: ' + str(avg_lossG) + ', D_loss: ' + str(avg_lossD) + '\n') # save generated images fixed_pred = netG(fixed_noise) vutils.save_image(fixed_pred.data, os.path.join(Opt.results_dir,'img'+str(epoch)+'.png'), nrow=10, scale_each=True) if epoch % 200 == 0: if Opt.save_model: torch.save(netD.state_dict(), os.path.join(Opt.checkpoint_dir, 'netD-01.pt')) torch.save(netG.state_dict(), os.path.join(Opt.checkpoint_dir, 'netG-01.pt'))
def __init__(self, args): self.args = args self.data_loader = get_data_loader(args) netG = model.netG(args) netD = model.netD(args) if args.use_cuda: netG = netG.cuda() netD = netD.cuda() self.netG = netG self.netD = netD self.optimizer_D = optim.Adam(self.netD.parameters(), lr=args.lr, betas=(args.beta1, 0.999)) self.optimizer_G = optim.Adam(self.netG.parameters(), lr=args.lr, betas=(args.beta1, 0.999)) self.criterion = nn.BCELoss() self.real_label = 1 self.fake_label = 0 fixed_noise_np = np.random.normal(0.0, 1.0, size=(args.batch_size, args.nz, 1, 1)) fixed_noise = torch.from_numpy(fixed_noise_np).type(torch.FloatTensor) if args.use_cuda: fixed_noise = fixed_noise.cuda() self.fixed_noise = Variable(fixed_noise)
def __init__(self, args): np.random.seed(args.seed) self.args = args self.logger = logger.Logger(args.output_dir) self.args.logger = self.logger current_commit_hash =\ subprocess.check_output(["git", "rev-parse", "HEAD"]).strip() self.logger.log('current git commit hash: %s' % current_commit_hash) print('load vec') source_vecs, source_dico =\ utils.load_word_vec_list(args.source_vec_file, args.source_lang) target_vecs, target_dico =\ utils.load_word_vec_list(args.target_vec_file, args.target_lang) self.src_dico = source_dico self.tgt_dico = target_dico args.src_dico = source_dico args.tgt_dico = target_dico src_embed, tgt_embed =\ utils.get_embeds_from_numpy(source_vecs, target_vecs) if args.use_cuda: self.src_embed = src_embed.cuda() self.tgt_embed = tgt_embed.cuda() else: self.src_embed = src_embed self.tgt_embed = tgt_embed print('setting models') netD = model.netD(self.args) netG = model.netG() netG.W.weight.data.copy_(torch.diag(torch.ones(300))) if args.multi_gpu: netD = nn.DataParallel(netD) netG = nn.DataParallel(netG) if args.use_cuda: netD = netD.cuda() netG = netG.cuda() self.netD = netD self.netG = netG self.optimizer_D = optim.Adam(self.netD.parameters(), lr=args.lr, betas=(args.beta1, 0.999)) self.optimizer_G = optim.Adam(self.netG.parameters(), lr=args.lr, betas=(args.beta1, 0.999)) self.criterion = nn.BCELoss() self.prefix = os.path.basename(args.output_dir) self.evaluator = Evaluator(self)
ngf = int(opt.ngf) ndf = int(opt.ndf) size = int(opt.imageSize) nc = 1 batch_size = int(opt.batchSize) def cv2_loader(filename): if (nc == 1): im = cv2.imread(filename, 0) elif (nc == 3): im = cv2.imread(filename) im = cv2.resize(im, (size, size), interpolation=cv2.INTER_AREA) im = im.reshape(size, size, nc) return im netD = netD(ngpu, nc, ndf) netD.load_state_dict(torch.load(opt.netD)) # print(netD) label = torch.FloatTensor(opt.batchSize) real_label = 1 fake_label = 0 batchSize = 1 # setup optimizer optimizerD = optim.Adam(netD.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999)) label = torch.FloatTensor(batchSize) def cv2_loader(filename):
############ train_loader = data.DataLoader(dataset=train_data, batch_size=batch_size, shuffle=True, drop_last=True, num_workers=4) generator = define_G( 4, 1, 64, 'unet_128', norm='instance', ) discriminator = netD() unet = Unet() unet.load_state_dict(torch.load("./weight/unet_pretrained.pth")) optimizer_g = torch.optim.Adam(generator.parameters(), lr=0.0002) optimizer_d = torch.optim.Adam(discriminator.parameters(), lr=0.0002) optimizer_s = torch.optim.Adam(unet.parameters(), lr=0.0002) generator.cuda() discriminator.cuda() unet.cuda() EPOCH = 100 num_iter = len(train_loader) D_LOSS = [] G_LOSS = [] # S_LOSS=[]
import torch import torch.nn as nn from torch.autograd import Variable from torchvision.utils import save_image from tqdm import tqdm import time from model import netD, netG from config import opt from Myutils import dataloader netd = netD(opt) netg = netG(opt) ds, dl = dataloader() device = torch.device('cuda:0') if opt.use_gpu else torch.device('cpu') if opt.d_save_path: netd.load_state_dict(torch.load(opt.d_save_path)) print("net_D loads weight successfully......") print('___' * 10) if opt.g_save_path: netg.load_state_dict(torch.load(opt.g_save_path)) print("net_G loads weight successfully......") print('___' * 10) netd.to(device) netg.to(device) optm_g = torch.optim.Adam(netg.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999)) optm_d = torch.optim.Adam(netd.parameters(), lr=opt.lr,
ngf = int(opt.ngf) ndf = int(opt.ndf) if opt.dataset == 'mnist': nc = 1 nb_label = 10 else: nc = 3 nb_label = 10 netG = model.netG(nz, ngf, nc) if opt.netG != '': netG.load_state_dict(torch.load(opt.netG)) print(netG) netD = model.netD(ndf, nc, nb_label) if opt.netD != '': netD.load_state_dict(torch.load(opt.netD)) print(netD) s_criterion = nn.BCELoss() c_criterion = nn.NLLLoss() input = torch.FloatTensor(opt.batchSize, 3, opt.imageSize, opt.imageSize) noise = torch.FloatTensor(opt.batchSize, nz, 1, 1) fixed_noise = torch.FloatTensor(opt.batchSize, nz, 1, 1).normal_(0, 1) s_label = torch.FloatTensor(opt.batchSize) c_label = torch.LongTensor(opt.batchSize) real_label = 1
file.write('epoch: ' + str(epoch) + ', G_loss: ' + str(avg_lossG) + ', D_loss: ' + str(avg_lossD) + '\n') # save generated images fixed_pred = netG(fixed_noise) vutils.save_image(fixed_pred.data, os.path.join(Opt.results_dir,'img'+str(epoch)+'.png'), nrow=10, scale_each=True) if epoch % 200 == 0: if Opt.save_model: torch.save(netD.state_dict(), os.path.join(Opt.checkpoint_dir, 'netD-01.pt')) torch.save(netG.state_dict(), os.path.join(Opt.checkpoint_dir, 'netG-01.pt')) if __name__ == '__main__': fixed_noise = Variable(torch.randn(100, Opt.nz).view(-1, Opt.nz, 1, 1).cuda()) netG = netG() # netG.apply(weights_init) netD = netD() # netD.apply(weights_init) netG.cuda() netD.cuda() # Loss function criterion = torch.nn.BCELoss() # Optimizers optimizerG = torch.optim.Adam(netG.parameters(), lr=Opt.lr, betas=Opt.betas) optimizerD = torch.optim.Adam(netD.parameters(), lr=Opt.lr, betas=Opt.betas) train(netD, netG, criterion, optimizerG, optimizerD)
def train(train_loader, netD, netG, criterion, optimizerG, optimizerD): for epoch in range(Opt.epochs): avg_lossD = 0 avg_lossG = 0 save_img = torch.zeros(16, 1, 128, 128) with open('logs.txt', 'a') as file: for i, sample_batched in enumerate(train_loader): image = sample_batched['image'] label = sample_batched['mask'] image = image.type(torch.FloatTensor) label = label.type(torch.FloatTensor) # Update D network mini_batch = label.shape[0] # train with real input = image * label input = Variable(input.cuda()) # image input real_label = Variable(torch.ones(mini_batch).cuda()) output = netD(input) D_real_loss = criterion(output, real_label) # train with fake fake = netG(Variable(image.cuda())) # fake = Variable((fake > 0.5).type(torch.FloatTensor).cuda()) fake_concat = fake * Variable(image.cuda()) fake_label = Variable(torch.zeros(mini_batch).cuda()) output = netD(fake_concat.detach() ) # detach to avoid training G on these labels D_fake_loss = criterion(output, fake_label) D_loss = D_real_loss + D_fake_loss netD.zero_grad() D_loss.backward() if Opt.which_pc == 0: avg_lossD += D_loss.item() else: avg_lossD += D_loss.data[0] optimizerD.step() # Update G network G_loss1 = criterion(fake, Variable(label.cuda())) output = netD(fake_concat) G_loss2 = criterion(output, real_label) G_loss = G_loss2 + G_loss1 if Opt.which_pc == 0: avg_lossG += G_loss.item() else: avg_lossG += G_loss.data[0] netG.zero_grad() G_loss.backward() optimizerG.step() print( 'Epoch [%d/%d], Step [%d/%d], D_loss: %.4f, G_loss: %.4f' % (epoch + 1, Opt.epochs, i + 1, len(train_loader), D_loss.data[0], G_loss.data[0])) # get generated images idice = intersect_index(Opt.save_img_id, sample_batched['img_id']) for j in range(len(idice)): idx = idice[j] save_img[idx[0]] = fake[idx[1]].data.cpu() avg_lossD /= i avg_lossG /= i print('epoch: ' + str(epoch + 1) + ', D_loss: ' + str(avg_lossD) + ', G_loss: ' + str(avg_lossG)) file.write('epoch: ' + str(epoch + 1) + ', D_loss: ' + str(avg_lossD) + ', G_loss: ' + str(avg_lossG) + '\n') # save generated images vutils.save_image(save_img, os.path.join(Opt.results_dir, 'img' + str(epoch) + '.png'), nrow=4, scale_each=True) if epoch % 50 == 0: if Opt.save_model: torch.save(netD.state_dict(), os.path.join(Opt.checkpoint_dir, 'netD-01.pt')) torch.save(netG.state_dict(), os.path.join(Opt.checkpoint_dir, 'netG-01.pt'))